@openpresentation/opf 0.15.1 → 0.17.0

package/dist/markdown.d.ts

@@ -1,9 +1,9 @@
-import { a as Catalog } from './catalog-refs-BSfGELpt.js';
-import { P as Presentation } from './presentation-CDKQVkyI.js';
-import { a as Finding, b as FindingLocation, F as FindingReport } from './finding-CT_f_vbD.js';
-import { V as ValidateOptions } from './validation-types-BOcY9GTs.js';
-import './composition-D2tghM82.js';
-import './chart-data-BnNqgnC-.js';
+import { b as Catalog } from './catalog-refs-C4K4y-vh.js';
+import { P as Presentation } from './presentation-fb8CZmRq.js';
+import { F as Finding, d as FindingLocation } from './finding-CDQ_wH8j.js';
+import { c as ValidateOptions, f as ValidationReport } from './validation-types-iZbXfES6.js';
+import './composition-BbZ_9C-c.js';
+import './chart-data-DTxdRRT1.js';
 import './json-BFSdESOE.js';
 
 interface EmbeddedPart {
@@ -45,7 +45,7 @@ interface FromMarkdownOptions extends ParseOptions {
     /** Catalogs the host registered, for the references check of `validate: true` (the default). Nothing is fetched. */
     catalogs?: readonly Catalog[];
 }
-interface FromMarkdownResult {
+interface FromMarkdownResult extends ValidationReport {
     /** The converted deck. Always an object; when `valid` is false it is a best effort that does not validate. */
     presentation: Presentation;
     /** True when there are no errors (Markdown syntax errors and OPF validation errors both count). */
@@ -54,7 +54,6 @@ interface FromMarkdownResult {
     findings: (Finding & {
         location: FindingLocation;
     })[];
-    counts: FindingReport["counts"];
 }
 /** Convert Markdown in the OPF dialect to an OPF document. Never throws for malformed content; read `valid` and `findings`. */
 declare function fromMarkdown(markdown: string, options?: FromMarkdownOptions): FromMarkdownResult;

package/dist/markdown.js

@@ -1,9 +1,9 @@
-export { fromMarkdown, toMarkdown } from './chunk-3JG4YXWF.js';
-export { OPFMarkdownError } from './chunk-3RKB4RDJ.js';
-import './chunk-374R35TJ.js';
-import './chunk-VGAOJEY7.js';
-import './chunk-QDI75P2M.js';
-import './chunk-O744SXXA.js';
+export { fromMarkdown, toMarkdown } from './chunk-BIC3SWPK.js';
+export { OPFMarkdownError } from './chunk-IS5H5JKH.js';
+import './chunk-ESRYBYLY.js';
+import './chunk-PPROJP2E.js';
+import './chunk-NLNYNBTS.js';
+import './chunk-CW7GEAV3.js';
 import './chunk-TRDXRRQK.js';
 import './chunk-SPFV27O5.js';
-import './chunk-2CJPC4HI.js';
+import './chunk-RA64UQKI.js';

package/dist/node-engine.d.ts

@@ -0,0 +1,94 @@
+export { b as DeckReport, c as DeckReportOptions, r as readDeckReport } from './deck-report-Bx3naFlF.js';
+import { F as FontsHandle, i as EmbeddedFace, R as Renderer, j as Reporter, P as Peer, k as PptxModule } from './conversion-SBpTOwdg.js';
+export { l as ConversionPlan, D as Diagnostic, m as EXPORT_FORMATS, n as ExportContext, o as ExportFile, p as ExportFontSummary, E as ExportFormat, q as ExportOptions, r as ExportResult, s as ExportRun, I as ImportOptions, t as ImportResult, f as OPFApiError, g as OPFExportError, h as OPFImportError, u as PEER_RANGES, v as PPTX_PACKAGE, w as PreparedExport, x as RENDER_PACKAGE, y as ReportFinding, z as Source, V as VERSIONS, A as asApiError, B as checkDate, G as checkOptions, H as checkScale, J as deckFileFormat, K as exportFormatOf, L as finishReport, M as importPresentation, N as loadPptx, Q as loadRenderer, T as missingPeerFrom, 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-SBpTOwdg.js';
+import './catalog-refs-C4K4y-vh.js';
+import './presentation-fb8CZmRq.js';
+import './validation-types-iZbXfES6.js';
+import './composition-BbZ_9C-c.js';
+import './chart-data-DTxdRRT1.js';
+import './finding-CDQ_wH8j.js';
+import './json-BFSdESOE.js';
+
+/** `1,3-5`, `2-` (to the end) and `-3` (from the start), one-based, in ascending order without repeats. */
+declare function parseSlideSelection(spec: string, total: number, label?: string): number[];
+/** `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 --font-dir 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 --font-dir 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. Marking every face `embed: "used"` makes the renderer embed a face only when the slide's
+ * text names its family, so a slide in one family ships kilobytes of font rather than the whole pack.
+ */
+declare function embeddedFor(handle: FontsHandle, mode: "used" | "none"): (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;
+
+export { FontsHandle, type ImportRun, Peer, type PlannedFile, PptxModule, Renderer, Reporter, checkDestinations, createZip, deckStem, embeddedFor, leaseSharedFonts, listFontDirectories, parseSlideSelection, pointerOf, prepareFonts, runImport, stemOf, writeFiles };

package/dist/node-engine.js

@@ -0,0 +1,21 @@
+export { EXPORT_FORMATS, OPFApiError, OPFExportError, OPFImportError, PEER_RANGES, PPTX_PACKAGE, RENDER_PACKAGE, Reporter, VERSIONS, asApiError, checkDate, checkDestinations, checkOptions, checkScale, createZip, deckFileFormat, deckStem, embeddedFor, exportFormatOf, finishReport, importPresentation, leaseSharedFonts, listFontDirectories, loadPptx, loadRenderer, missingPeerFrom, parseSlideSelection, planConversion, pointerOf, prepareExport, prepareFonts, reaches, readInput, reportThrown, resolveExportOptions, runExport, runImport, runPreparedExport, stemOf, writeFiles, writePlanned } from './chunk-IPW5BS3X.js';
+import './chunk-WWYWFVOI.js';
+import './chunk-HXHOZ7AH.js';
+import './chunk-O263APNI.js';
+import './chunk-WCG3THTD.js';
+export { readDeckReport } from './chunk-N4EVOFEA.js';
+import './chunk-BIC3SWPK.js';
+import './chunk-TCD2FB2K.js';
+import './chunk-IS5H5JKH.js';
+import './chunk-M4UR3NPN.js';
+import './chunk-O3CVNJTL.js';
+import './chunk-YT7FMQER.js';
+import './chunk-O2CX5NEH.js';
+import './chunk-ESRYBYLY.js';
+import './chunk-PPROJP2E.js';
+import './chunk-NLNYNBTS.js';
+import './chunk-CW7GEAV3.js';
+import './chunk-TRDXRRQK.js';
+import './chunk-SPFV27O5.js';
+import './chunk-RA64UQKI.js';
+import './chunk-WXSPETQ6.js';

package/dist/node.d.ts

@@ -0,0 +1,60 @@
+export { SchemaEntry, SchemaName, audience, chartType, colorScheme, fontScheme, language, layout, narrative, presentation, purpose, schemaEntries, schemaNames, schemas, socialPlatform, theme, tone } from './schemas.js';
+export { DEFAULT_CHART_PALETTE, DEFAULT_VALIDATION_THRESHOLDS, OPFValidationError, assertValid, assertValidCatalogRecord, findValidationRule, validate, validateCatalogRecord, validationRules } from './validator.js';
+export { B as BuiltinVariableInfo, C as Contract, D as DEFAULT_VARIABLE_DATE_FORMAT, O as OPFVariableError, R as ResolveVariablesOptions, a as ResolveVariablesResult, V as VARIABLE_KINDS, b as ValidateFonts, c as ValidateOptions, d as ValidationCategory, e as ValidationChecks, f as ValidationReport, g as ValidationRuleCost, h as ValidationRuleInfo, i as ValidationThresholds, j as VariableDeclaration, k as VariableDiagnostic, l as VariableDiagnosticCode, m as VariableDiagnosticSeverity, n as VariableInfo, o as VariableKind, p as VariableUse, q as VariableUseForm, r as VariableValues, s as coerceVariableValue, t as formatVariableNumber, u as hasContentVariables, v as isTemplate, w as listBuiltinVariables, x as listVariables, y as resolveVariables, z as validationCategories, A as variableDeclarations } from './validation-types-iZbXfES6.js';
+export { CatalogPatchOperation, CatalogRecordChange, CatalogRef, CatalogUpdate, CopiedRecordRename, CopySlidesResult, DatasetFact, EmbedResult, EmbeddedRecord, HeaderFooterFact, MoveToCustomErrorCode, MoveToCustomPatchOperation, MoveToCustomResult, MovedRecord, OPFMoveToCustomError, PresentationStats, ReferenceFact, ResolvedDesignRecords, SLIDE_SCOPED_BUILTINS, SlideScopedBuiltin, SlideSizeFact, SlideStats, StatsOptions, StatsSlideRef, TableFact, copySlides, embed, moveToCustom, resolveDesignRecords, resolveFontScheme, resolveSlideVariables, sameRecord, stats, updateFromCatalog } from './index.js';
+export { SpecFileEntry, SpecFileKind, SpecFilePath, specFileEntries, specFileKinds, specFilePaths } from './spec-files.js';
+import { P as Presentation } from './presentation-fb8CZmRq.js';
+export { Audience, ChartType, ColorScheme, FontScheme, Language, Layout, Narrative, Purpose, SocialPlatform, Theme, Tone } from './types.js';
+export { C as CATALOG_GROUP_PATTERN, a as CATALOG_REFERENCE_PATTERN, b as Catalog, c as CatalogKind, d as CatalogOptions, e as CatalogRecordMap, f as CatalogRecords, g as CatalogReferenceSite, O as OPFCatalogsOptionError, h as OPFUnresolvedReferenceError, R as RecordProvenance, i as ResolvedReference, U as UnresolvedReferenceDiagnostic, j as catalogGroupSource, k as catalogKinds, l as catalogRecords, m as catalogReferenceSites, p as parseReference, r as resolveReference, u as unresolvedReference } from './catalog-refs-C4K4y-vh.js';
+export { F as Finding, a as FindingCategory, b as FindingFix, c as FindingFocus, d as FindingLocation, e as FindingReport, f as FindingSeverity, g as FindingSuggestion, J as JsonPatchOperation, V as ValidationIssue } from './finding-CDQ_wH8j.js';
+export { C as CHART_TYPES, a as ComposeSlideOptions, E as ENGINE_DEFAULT_CHART_TYPES, b as ENGINE_DEFAULT_COLOR_SCHEME, c as ENGINE_DEFAULT_FONT_SCHEME, d as ENGINE_DEFAULT_THEME, F as FontFamilies, e as Fonts, L as LANGUAGES, f as LanguageFamilyName, g as LanguageVocabulary, h as LayoutDiagnostic, M as MeasureTextWidth, S as SOCIAL_PLATFORMS, i as SocialPlatformVocabulary, T as TextMeasurement, j as TextStyle, n as normalizeLanguageFamily } from './composition-BbZ_9C-c.js';
+export { C as CatalogDisplayKind, a as CatalogRecordKind, c as catalogDisplayKinds, b as catalogSchemaNames } from './catalog-schemas-g7RFQBdc.js';
+export { O as OPFPaginationError, P as PaginatedPage, a as PaginationMapping, b as PaginationOptions, c as PaginationResult, d as PresentationPaginationOptions, e as PresentationPaginationResult, S as SlideContext, f as SlideContextDiagnostic, g as SlideContextOptions, p as paginate, h as paginateSlide, r as resolveSlideContext } from './pagination-BhX4M48Y.js';
+export { ApplyPatchOptions, OPFPatchError, OPFPatchValidationError, PatchResult, applyPatch } from './patch.js';
+export { DiffOptions, MergeConflict, MergeOptions, MergeResult, PresentationDiff, diff, merge } from './diff.js';
+export { FormatOptions, OPFFormatError, format } from './format.js';
+export { FromMarkdownOptions, FromMarkdownResult, OPFMarkdownError, ToMarkdownOptions, ToMarkdownResult, fromMarkdown, toMarkdown } from './markdown.js';
+export { StringifyOptions, parse, stringify } from './deck.js';
+export { DataCell, DataImportOptions, ImportDataOptions, ImportedChart, ImportedChartData, ImportedChartType, ImportedTable, OPFDataImportError, TabularData, importData, parseTabularData } from './data.js';
+export { C as ChartComboSeries, a as ChartMapping, b as ChartNumberFix, c as ChartNumberFixOperation, d as ChartNumberFixOptions, D as DataCellValue, e as DataColumn, f as DataDiagnostic, g as DataDiagnosticCode, h as DataResolveOptions, i as DataSourceRef, j as DataStyledCell, k as DataTableCell, l as DataTableHeader, m as DataTableValue, n as DataTextRun, o as Dataset, p as DatasetRef, R as ResolvedChartData, q as ResolvedTableData, r as chartNumber, s as datasetDiagnostics, t as formatDataNumber, u as fromExcelNumberFormat, v as inlineChartData, w as inlineDatasets, x as inlineTableData, y as isDatasetRef, z as isXYChartType, A as numberFormatError, B as resolveChartData, E as resolveTableData, F as suggestChartNumberFix, G as tableCellDisplayValue, H as toExcelNumberFormat, I as unusedDatasets } from './chart-data-DTxdRRT1.js';
+export { FONT_POLICY, FontAvailability, FontAvailabilityCode, FontAvailabilityDiagnostic, FontLicenseClass, FontPolicyDecision, FontPolicyEntry, FontPolicyTable, FontReplacement, FontReplacementCompatibility, FontReplacementMeasurement, applyFontPolicyDecisions, fontAvailabilityDiagnostics, fontPolicyFor } from './font-policy.js';
+import { C as ConvertInput, a as ConvertOptions, b as ConvertResult, c as ConvertFormat, O as OpenOptions, S as SaveOptions, d as SaveResult } from './conversion-SBpTOwdg.js';
+export { e as ConvertedFile, E as ExportFormat, F as FontsHandle, f as OPFApiError, g as OPFExportError, h as OPFImportError } from './conversion-SBpTOwdg.js';
+export { defaultCatalog } from './catalog.js';
+export { D as DECK_FORMATS, a as DeckFormat, P as ParseOptions, d as deckFormatOf } from './deck-report-Bx3naFlF.js';
+import './json-BFSdESOE.js';
+
+/**
+ * Convert a file, a deck or the bytes of a `.pptx` file. With an `output` path the format comes from its extension and the
+ * files are written: `.pdf`, `.pptx`, `.png` and `.svg` are exported (one PNG or SVG per slide, `slides/deck.png` giving
+ * `slides/deck-001.png`, ...; one selected slide is written to `output` itself), `.zip` is one archive of the slides (`format`
+ * `png`, the default, or `svg`), and `.opf.md`, `.yaml`/`.yml` or `.json` writes the deck in that form. Without an output path,
+ * pass `{ format }`: nothing is written and the files come back with their names and bytes.
+ *
+ * A `.pptx` input is imported first. Local images resolve next to the input file unless `assetDir` says otherwise; URLs are
+ * never fetched. Everything is produced before anything is written, and each file is written atomically, replacing an existing
+ * output (`overwrite: false` refuses one with `output-exists`, as the commands do without `--force`). Throws `OPFApiError` for the request and the files (`invalid-option`, `input-not-found`,
+ * `input-unreadable`, `invalid-presentation`, `output-exists`, `output-not-file`, `output-unwritable`), `OPFImportError` for the
+ * import step and `OPFExportError` for the export step (`peer-not-installed`, `peer-too-old`, `peer-load-failed`,
+ * `invalid-presentation`, `no-slides`, `all-slides-hidden`, `export-failed`, `import-failed`).
+ */
+declare function convert(input: ConvertInput, output: string, options?: ConvertOptions): Promise<ConvertResult>;
+declare function convert(input: ConvertInput, options: ConvertOptions & {
+    format: ConvertFormat;
+}): Promise<ConvertResult>;
+/**
+ * Open a deck: a `.opf.md`, `.yaml`/`.yml` or `.json` file (the form named by the extension), or a PowerPoint file (a `.pptx`
+ * path or its bytes), imported. Returns the presentation. A deck file that fails the format and references check throws
+ * `OPFValidationError` (its findings located by line and column in the file); a PowerPoint file that cannot be imported throws
+ * `OPFImportError`; a missing file throws `OPFApiError` `input-not-found`. Warnings are not returned: `validate` reports them,
+ * and `convert("deck.pptx", "deck.opf.yaml")` returns what an import could not keep.
+ */
+declare function open(input: string | Uint8Array | ArrayBuffer, options?: OpenOptions): Promise<Presentation>;
+/**
+ * Save a deck in the form its file name names (`.opf.md`, `.yaml`/`.yml` or `.json`), atomically, creating folders, replacing
+ * the file. It is checked for format and references first and an invalid deck is refused with `OPFValidationError`;
+ * `validate: false` writes work in progress, as an editor's autosave does. Returns `{ path, format }`.
+ */
+declare function save(deck: Presentation, path: string, options?: SaveOptions): Promise<SaveResult>;
+
+export { ConvertFormat, ConvertInput, ConvertOptions, ConvertResult, OpenOptions, Presentation, SaveOptions, SaveResult, convert, open, save };

package/dist/node.js

@@ -0,0 +1,54 @@
+import { convertFiles, OPFApiError, openDeck, saveDeck, asApiError } from './chunk-IPW5BS3X.js';
+export { OPFApiError, OPFExportError, OPFImportError } from './chunk-IPW5BS3X.js';
+export { OPFMoveToCustomError, copySlides, embed, moveToCustom, sameRecord, stats, updateFromCatalog } from './chunk-WWYWFVOI.js';
+export { specFileEntries, specFileKinds, specFilePaths } from './chunk-HXHOZ7AH.js';
+export { OPFDataImportError, importData, parseTabularData } from './chunk-O263APNI.js';
+export { defaultCatalog } from './chunk-WCG3THTD.js';
+export { DECK_FORMATS, deckFormatOf, parse, stringify } from './chunk-N4EVOFEA.js';
+export { fromMarkdown, toMarkdown } from './chunk-BIC3SWPK.js';
+import './chunk-TCD2FB2K.js';
+export { OPFMarkdownError } from './chunk-IS5H5JKH.js';
+export { diff, merge } from './chunk-M4UR3NPN.js';
+export { OPFPatchError, OPFPatchValidationError, applyPatch } from './chunk-O3CVNJTL.js';
+export { OPFFormatError, format } from './chunk-YT7FMQER.js';
+export { OPFPaginationError, paginate, paginateSlide } from './chunk-O2CX5NEH.js';
+import './chunk-ESRYBYLY.js';
+import './chunk-PPROJP2E.js';
+import { OPFValidationError } from './chunk-NLNYNBTS.js';
+export { DEFAULT_CHART_PALETTE, DEFAULT_VALIDATION_THRESHOLDS, OPFValidationError, assertValid, assertValidCatalogRecord, findValidationRule, resolveSlideContext, validate, validateCatalogRecord, validationCategories, validationRules } from './chunk-NLNYNBTS.js';
+export { CHART_TYPES, DEFAULT_VARIABLE_DATE_FORMAT, ENGINE_DEFAULT_CHART_TYPES, ENGINE_DEFAULT_COLOR_SCHEME, ENGINE_DEFAULT_FONT_SCHEME, ENGINE_DEFAULT_THEME, LANGUAGES, OPFVariableError, SLIDE_SCOPED_BUILTINS, SOCIAL_PLATFORMS, VARIABLE_KINDS, chartNumber, coerceVariableValue, datasetDiagnostics, formatDataNumber, formatVariableNumber, fromExcelNumberFormat, hasContentVariables, inlineChartData, inlineDatasets, inlineTableData, isDatasetRef, isTemplate, isXYChartType, listBuiltinVariables, listVariables, normalizeLanguageFamily, numberFormatError, resolveChartData, resolveDesignRecords, resolveFontScheme, resolveSlideVariables, resolveTableData, resolveVariables, suggestChartNumberFix, tableCellDisplayValue, toExcelNumberFormat, unusedDatasets, variableDeclarations } from './chunk-CW7GEAV3.js';
+export { catalogDisplayKinds, catalogSchemaNames } from './chunk-TRDXRRQK.js';
+export { CATALOG_GROUP_PATTERN, CATALOG_REFERENCE_PATTERN, OPFCatalogsOptionError, OPFUnresolvedReferenceError, catalogGroupSource, catalogKinds, catalogRecords, catalogReferenceSites, parseReference, resolveReference, unresolvedReference } from './chunk-SPFV27O5.js';
+export { audience, chartType, colorScheme, fontScheme, language, layout, narrative, presentation, purpose, schemaEntries, schemaNames, schemas, socialPlatform, theme, tone } from './chunk-RA64UQKI.js';
+export { FONT_POLICY, applyFontPolicyDecisions, fontAvailabilityDiagnostics, fontPolicyFor } from './chunk-WXSPETQ6.js';
+
+// src/node.ts
+var rethrow = (error, fallback) => {
+  if (error instanceof OPFValidationError) throw error;
+  throw asApiError(OPFApiError, error, fallback);
+};
+async function convert(input, output, options = {}) {
+  try {
+    if (output !== null && typeof output === "object") return await convertFiles(input, void 0, output);
+    if (typeof output !== "string") throw new OPFApiError("convert takes an output file path, or options with a format.", "invalid-option");
+    return await convertFiles(input, output, options);
+  } catch (error) {
+    return rethrow(error, "convert-failed");
+  }
+}
+async function open(input, options = {}) {
+  try {
+    return await openDeck(input, options);
+  } catch (error) {
+    return rethrow(error, "input-unreadable");
+  }
+}
+async function save(deck, path, options = {}) {
+  try {
+    return await saveDeck(deck, path, options);
+  } catch (error) {
+    return rethrow(error, "output-unwritable");
+  }
+}
+
+export { convert, open, save };

package/dist/{pagination-wedbe7eq.d.ts → pagination-BhX4M48Y.d.ts}

@@ -1,5 +1,5 @@
-import { C as ComposeSlideOptions, F as Fonts, L as LayoutDiagnostic } from './composition-D2tghM82.js';
-import { U as UnresolvedReferenceDiagnostic, R as RecordProvenance, b as CatalogOptions } from './catalog-refs-BSfGELpt.js';
+import { a as ComposeSlideOptions, e as Fonts, h as LayoutDiagnostic } from './composition-BbZ_9C-c.js';
+import { U as UnresolvedReferenceDiagnostic, R as RecordProvenance, d as CatalogOptions, b as Catalog } from './catalog-refs-C4K4y-vh.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,13 @@ 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`.
+     * 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 +56,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. */

package/dist/pagination.d.ts

@@ -1,4 +1,4 @@
-import './composition-D2tghM82.js';
-import './catalog-refs-BSfGELpt.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-wedbe7eq.js';
-import './chart-data-BnNqgnC-.js';
+import './composition-BbZ_9C-c.js';
+import './catalog-refs-C4K4y-vh.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-BhX4M48Y.js';
+import './chart-data-DTxdRRT1.js';

package/dist/pagination.js

@@ -1,6 +1,6 @@
-export { OPFPaginationError, paginate, paginateSlide } from './chunk-UBFJ2QHH.js';
-import './chunk-QDI75P2M.js';
-import './chunk-O744SXXA.js';
+export { OPFPaginationError, paginate, paginateSlide } from './chunk-O2CX5NEH.js';
+import './chunk-NLNYNBTS.js';
+import './chunk-CW7GEAV3.js';
 import './chunk-TRDXRRQK.js';
 import './chunk-SPFV27O5.js';
-import './chunk-2CJPC4HI.js';
+import './chunk-RA64UQKI.js';

package/dist/patch.d.ts

@@ -1,4 +1,4 @@
-import { F as FindingReport, a as Finding, J as JsonPatchOperation } from './finding-CT_f_vbD.js';
+import { e as FindingReport, F as Finding, J as JsonPatchOperation } from './finding-CDQ_wH8j.js';
 
 type JsonPointer = string;
 type PatchErrorCode = "invalid-patch" | "invalid-patch-operation" | "unsupported-patch-operation" | "invalid-json-pointer" | "patch-path-missing" | "patch-parent-missing" | "invalid-array-index" | "patch-test-failed" | "patch-invalid-move" | "patch-root-remove" | "patch-invalid-document";

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-5FTUIDUH.js';
-import './chunk-QDI75P2M.js';
-import './chunk-O744SXXA.js';
+export { OPFPatchError, OPFPatchValidationError, applyPatch, applyPatchWithInverse, escapePointerToken, formatPointer, getAtPointer, hasPointer, invertPatch, jsonEqual, normalizePatch, parsePointer, pointerFromPath, readPointer, splitPointer, unescapePointerToken } from './chunk-O3CVNJTL.js';
+import './chunk-NLNYNBTS.js';
+import './chunk-CW7GEAV3.js';
 import './chunk-TRDXRRQK.js';
 import './chunk-SPFV27O5.js';
-import './chunk-2CJPC4HI.js';
+import './chunk-RA64UQKI.js';