@openpresentation/opf 0.15.1 → 0.17.0

package/dist/conversion-SBpTOwdg.d.ts

@@ -0,0 +1,444 @@
+import { a as DeckFormat } from './deck-report-Bx3naFlF.js';
+import { F as Finding, f as FindingSeverity } from './finding-CDQ_wH8j.js';
+import { P as Presentation } from './presentation-fb8CZmRq.js';
+import { f as ValidationReport, e as ValidationChecks, c as ValidateOptions } from './validation-types-iZbXfES6.js';
+import { b as Catalog } from './catalog-refs-C4K4y-vh.js';
+
+/** The base class: thrown for the request and the files (`invalid-option`, `input-not-found`, `input-unreadable`, `invalid-presentation`, `output-exists`, `output-not-file`, `output-unwritable`). */
+declare class OPFApiError extends Error {
+    readonly code: string;
+    readonly details: Record<string, unknown>;
+    readonly findings: Finding[];
+    constructor(message: string, code: string, extra?: {
+        details?: Record<string, unknown>;
+        findings?: Finding[];
+        cause?: unknown;
+    });
+}
+/** Thrown by the export step of `convert`: `peer-not-installed`, `peer-too-old`, `peer-load-failed`, `invalid-option`, `invalid-presentation`, `no-slides`, `all-slides-hidden`, `font-failed`, `export-failed`. */
+declare class OPFExportError extends OPFApiError {
+}
+/** Thrown by the import step of `convert` and by `open` for a PowerPoint file: `peer-not-installed`, `peer-too-old`, `peer-load-failed`, `invalid-option`, `invalid-presentation`, `import-failed`. */
+declare class OPFImportError extends OPFApiError {
+}
+/** The error as `Class`, whatever was thrown below: an error of that class is returned as it is, another API error keeps its code, details and findings. */
+declare function asApiError<T extends OPFApiError>(Class: new (message: string, code: string, extra?: {
+    details?: Record<string, unknown>;
+    findings?: Finding[];
+    cause?: unknown;
+}) => T, error: unknown, fallbackCode: string): T;
+
+declare const RENDER_PACKAGE = "@openpresentation/opf-render";
+declare const PPTX_PACKAGE = "@openpresentation/opf-pptx";
+/** Peer ranges. The CLI checks the features it calls rather than the version, so a newer release in range keeps working. */
+declare const PEER_RANGES: {
+    readonly "@openpresentation/opf-render": "^0.17.0";
+    readonly "@openpresentation/opf-pptx": "^0.17.0";
+};
+interface Diagnostic {
+    code: string;
+    path?: string;
+    message: string;
+    [detail: string]: unknown;
+}
+interface EmbeddedFace {
+    family: string;
+    weight: number;
+    italic?: boolean;
+    dataUrl: string;
+}
+/** What the renderer's deck-level functions read from `{ fonts }` (opf-render `RenderFonts`). */
+interface RenderFonts {
+    textMeasurement?: unknown;
+    embeddedFonts?: readonly EmbeddedFace[];
+    fontFiles?: readonly string[];
+    useBundledFonts?: boolean;
+    loadSystemFonts?: boolean;
+}
+interface FontRegistry {
+    scriptSelection?: {
+        detected: string[];
+        scripts: string[];
+        unavailable: string[];
+        packages?: string[];
+        notInstalled?: string[];
+        uncovered?: string[];
+    };
+}
+/** The handle `loadFonts()` of opf-render `/fonts-node` returns: pass it as `{ fonts }` to every deck-level call. */
+interface FontsHandle extends RenderFonts {
+    textMeasurement: unknown;
+    embeddedFonts: EmbeddedFace[];
+    fontFiles: string[];
+    useBundledFonts: false;
+    loadSystemFonts: false;
+    registry: FontRegistry;
+    substitutions: {
+        requestedFamily: string;
+        resolvedFamily: string;
+        compatibility: string;
+        substitute: boolean;
+    }[];
+}
+interface RenderModule {
+    renderSlideSvg(presentation: unknown, index: number, options?: Record<string, unknown>): string;
+    svgToPng(svg: string, options?: Record<string, unknown>): Promise<Uint8Array>;
+    svgToPdf(svgs: string | string[], options?: Record<string, unknown>): Promise<Uint8Array>;
+}
+interface FontsNodeModule {
+    loadFonts(options?: Record<string, unknown>): Promise<FontsHandle>;
+}
+interface PptxModule {
+    toPptx(presentation: unknown, options?: Record<string, unknown>): Promise<Uint8Array>;
+    /** Without `signals` the presentation itself; with `signals: true`, `{ presentation, signals }`. */
+    fromPptx(input: Uint8Array, options?: Record<string, unknown>): Promise<Record<string, unknown>>;
+}
+interface Peer<T> {
+    module: T;
+    version: string;
+    name: string;
+}
+/**
+ * The missing-peer error for a renderer failure that says a package it loads lazily is absent (RR-63): `converter-missing` (pdf-lib,
+ * @resvg/resvg-js, sharp) or `font-resource-unavailable` naming font packages. The renderer's message, with its install command, is kept;
+ * `details` has `package` (or `packages`), `range`, `install` and `purpose` where the renderer gave them. A converter that is installed but
+ * did not load is `peer-load-failed`. Undefined for any other error.
+ */
+declare function missingPeerFrom(error: unknown): OPFApiError | undefined;
+interface Renderer {
+    render: Peer<RenderModule>;
+    fonts: FontsNodeModule;
+}
+declare function loadRenderer(): Promise<Renderer>;
+declare function loadPptx(): Promise<Peer<PptxModule>>;
+
+/** True when any finding is at or above the level (the `--fail-on` rule). */
+declare const reaches: (findings: readonly {
+    severity: FindingSeverity;
+}[], level: FindingSeverity) => boolean;
+type Source = "render" | "pptx" | "pdf" | "fonts" | "import" | "cli";
+/** A finding of the shared format, with the library's details (font family, package, ...) alongside. */
+interface ReportFinding extends Finding {
+    [detail: string]: unknown;
+}
+declare class Reporter {
+    readonly findings: ReportFinding[];
+    private readonly seen;
+    constructor(initial?: readonly Finding[]);
+    /** Add a library diagnostic (`code`, `path`, `message` and details). Identical entries are kept once. */
+    add(source: Source, diagnostic: Diagnostic, severity?: FindingSeverity): void;
+    /** Add a finding as the library made it (the `findings` of a thrown OPFRenderError, OPFPptxError or core validation error). Identical entries are kept once. */
+    addFinding(finding: Finding): void;
+    error(source: Source, code: string, message: string, where?: string, details?: Record<string, unknown>): void;
+    get counts(): Record<FindingSeverity, number>;
+    get failed(): boolean;
+}
+/**
+ * Convert a thrown library error into the report. An error that carries `findings` (the error findings of the format check,
+ * on OPFRenderError, OPFPptxError and core's OPFValidationError) is reported as those findings; any other error becomes one
+ * diagnostic that keeps its code and the path it names.
+ */
+declare function reportThrown(reporter: Reporter, source: Source, error: unknown): void;
+declare function finishReport(base: Pick<ValidationReport, "valid" | "schemaValid" | "checks">, reporter: Reporter, failOn: FindingSeverity): {
+    ok: boolean;
+    valid: boolean;
+    schemaValid: boolean | null;
+    findings: ReportFinding[];
+    counts: Record<FindingSeverity, number>;
+    checks: ValidationChecks;
+};
+
+type ExportFormat = "svg" | "png" | "pdf" | "pptx";
+declare const EXPORT_FORMATS: readonly ExportFormat[];
+interface ExportOptions {
+    /** What to write. `svg` and `png` give one file per slide (or one zip), `pdf` and `pptx` one file. */
+    format: ExportFormat;
+    /** A prepared fonts handle (`loadFonts()` of `@openpresentation/opf-render/fonts-node`), reused across calls. Omitted: the bundled open font pack plus `fontDirs`. */
+    fonts?: FontsHandle;
+    /** Directories of `.ttf` and `.otf` files to load before the bundled pack (not recursive). Ignored when `fonts` is given. */
+    fontDirs?: readonly string[];
+    /** The catalogs the presentation's references resolve in. Omitted: core's default catalog. */
+    catalogs?: readonly Catalog[];
+    /** The slides to write, one-based: numbers or a selection such as `"1,3-5"`. Omitted: every slide that is not hidden. Not for `pptx`. */
+    slides?: readonly number[] | string;
+    /** Write hidden slides too (`svg`, `png`, `pdf`). */
+    includeHidden?: boolean;
+    /** Split overflowing slides with the same fonts before drawing, as `opf paginate` does. */
+    paginate?: boolean;
+    /** Pixel scale of `png` and of a raster `pdf` (0.1 to 8; 1 draws the 1280 x 720 reference slide at 1280 x 720 pixels). */
+    scale?: number;
+    /** `pdf`: `vector` (selectable text, the default) or `raster`. */
+    pdfMode?: "vector" | "raster";
+    /** `svg`: embed the faces the slide's text uses (`used`, the default) or none (`none`). */
+    svgFonts?: "used" | "none";
+    /** `pptx`: native charts (`native`), picture fallbacks (`fallback`) or opf-pptx's choice (`auto`). */
+    chartex?: "auto" | "native" | "fallback";
+    /** `pptx`: what the file records about where media came from. */
+    provenance?: "full" | "references-only" | "none";
+    /** `pptx`: keep images as they are (`preserve`) or convert them for older PowerPoint (`compatible`). */
+    imageFormat?: "compatible" | "preserve";
+    /** `YYYY-MM-DD`, for date fields that show today's date. Nothing reads a clock: without it such a field reports `date-needs-value`. */
+    date?: string;
+    /** The directory a presentation's relative image paths resolve against. Omitted: no local file is read (data URIs and remote references work as the engines handle them). */
+    assetDir?: string;
+    /** `svg` and `png`: one zip of the slides instead of one file per slide. */
+    zip?: boolean;
+    /** The source file name, for naming the output when the presentation has no `filename` or `name`. */
+    filename?: string;
+}
+interface ExportFile {
+    /** The file name: the presentation's `filename`, else its slugified `name`, else the source name, then `-001.png` for slide 1 and so on. */
+    name: string;
+    /** The media type. */
+    type: string;
+    bytes: Uint8Array;
+    /** `svg` and `png`: the slide number (one-based) and its id. */
+    slide?: number;
+    id?: string;
+    /** `svg` and `png`: the picture's size in pixels. */
+    width?: number;
+    height?: number;
+    /** `pdf`: the number of pages and the slide numbers they show. */
+    pages?: number;
+    slides?: number[];
+    /** `zip`: the names of the entries. */
+    entries?: string[];
+}
+interface ExportFontSummary {
+    pack: "office";
+    substitutionPolicy: "visual";
+    /** The `fontDirs` files, in load order. */
+    userFonts: string[];
+    substitutions: {
+        requested: string;
+        resolved: string;
+        compatibility: string;
+    }[];
+    scripts?: unknown;
+}
+interface ExportRun {
+    files: ExportFile[];
+    fonts?: ExportFontSummary;
+    pagination?: {
+        pages: unknown;
+    };
+    pdf?: {
+        mode: "vector" | "raster";
+    };
+    skippedHidden: number[];
+    /** Set when drawing or paginating threw: the reporter holds the error finding and `files` is empty. */
+    failure?: {
+        code: string;
+        message: string;
+    };
+}
+/** What a caller that has already done some of the work passes in, so the engine does not repeat it. */
+interface ExportContext {
+    reporter: Reporter;
+    renderer?: Renderer;
+    pptx?: Peer<PptxModule>;
+    /** Absolute font file paths already listed from `fontDirs`. */
+    userFonts?: string[];
+    /** Name options as the command line does (`--slides`, `--font-dir`, `--asset-dir`) in the messages of errors the engine throws. */
+    flags?: boolean;
+}
+/** `YYYY-MM-DD` and a real calendar date, or undefined. `label` names the option in the message (`--date` for the command, `date` for the function). */
+declare function checkDate(value: unknown, label?: string): string | undefined;
+/** A scale from 0.1 to 8, 1 when absent. */
+declare function checkScale(value: unknown, label?: string): number;
+/** The options of a call, checked against each other. Throws `invalid-option` (an OPFApiError) for a value out of range or an option that does not apply to the format. */
+declare function resolveExportOptions(options: ExportOptions): Required<Pick<ExportOptions, "format" | "svgFonts" | "scale">> & ExportOptions;
+/**
+ * Draw a presentation that has already passed the format and references check (`ctx.reporter` holds that check's findings).
+ * Diagnostics from fonts, layout, the SVG, PDF and PPTX writers are added to `ctx.reporter`. Throws an `OPFApiError` for an
+ * option, a missing or old peer, a font directory or a selection that names no slide; a failure while drawing is returned in
+ * `failure` after the reporter has the error finding.
+ */
+declare function runExport(presentation: unknown, options: ReturnType<typeof resolveExportOptions>, ctx: ExportContext): Promise<ExportRun>;
+declare const VERSIONS: (renderer: Renderer, pptx?: Peer<PptxModule>) => {
+    pptx?: {
+        package: string;
+        version: string;
+    } | undefined;
+    renderer: {
+        package: string;
+        version: string;
+    };
+};
+
+/** The check a presentation passes before it is exported or after it is imported: format and references, so a contrast warning never blocks a write. */
+declare const checkOptions: (catalogs: readonly Catalog[] | undefined) => ValidateOptions;
+interface ExportResult {
+    /** The files, in slide order: one per slide for `svg` and `png`, otherwise one. */
+    files: ExportFile[];
+    /** The findings of the format and references check (warnings and notes; errors throw) and the diagnostics of the engines: fonts, layout, SVG, PDF and PPTX, each with a `render/`, `pptx/`, `pdf/`, `fonts/` or `cli/` rule prefix. */
+    findings: Finding[];
+    /** The bundled fonts and font files used, and the substitutions made. */
+    fonts: ExportFontSummary;
+    /** Slide numbers left out because they are hidden (`svg`, `png`, `pdf` without `includeHidden` or `slides`). */
+    skippedHidden: number[];
+    /** With `paginate`: the pages the slides were split into. */
+    pagination?: {
+        pages: unknown;
+    };
+    /** `pdf`: the mode used. */
+    pdf?: {
+        mode: "vector" | "raster";
+    };
+    /** The engines that drew the files. */
+    renderer: {
+        package: string;
+        version: string;
+    };
+    pptx?: {
+        package: string;
+        version: string;
+    };
+}
+interface ImportOptions {
+    /** The catalogs the imported presentation's references resolve in. Omitted: core's default catalog. */
+    catalogs?: readonly Catalog[];
+    /** Also return the raw per-shape layout and style signals of the file (`signals`). */
+    signals?: boolean;
+}
+interface ImportResult {
+    /** The presentation. It passed the format and references check. */
+    presentation: Presentation;
+    /** What the conversion could not keep or had to change, and the findings of the check. */
+    findings: Finding[];
+    /** With `signals: true`. */
+    signals?: {
+        version?: number;
+    };
+    /** The importer that read the file. */
+    pptx: {
+        package: string;
+        version: string;
+    };
+}
+/** An export whose options are checked and whose engines and font files are loaded, before any document is read. */
+interface PreparedExport {
+    options: ReturnType<typeof resolveExportOptions>;
+    renderer: Renderer;
+    pptx?: Peer<PptxModule>;
+    userFonts: string[];
+    /** Name options as the command's flags (`--slides`, `--font-dir`, `--asset-dir`) in messages. */
+    flags: boolean;
+}
+/** Check the options, then load the engines and list the font directories, so a missing install is reported before the document is looked at. */
+declare function prepareExport(options: ExportOptions, flags?: boolean): Promise<PreparedExport>;
+/**
+ * Draw a presentation. Without `checked` it is checked first (`invalid-presentation` when it fails); with `checked`, the findings
+ * of a check already made (located in the text it was read from, or the findings of an import) start the report instead.
+ */
+declare function runPreparedExport(prepared: PreparedExport, presentation: Presentation, checked?: readonly Finding[]): Promise<ExportResult>;
+/** Read a PowerPoint file and check the presentation (`import-failed`, `invalid-presentation`). `check` is the report of that check. */
+declare function importPresentation(bytes: Uint8Array, options: ImportOptions, loaded?: Peer<PptxModule>): Promise<{
+    result: ImportResult;
+    check: ValidationReport;
+}>;
+
+/** What `convert` makes: an export format, or a deck form. */
+type ConvertFormat = ExportFormat | DeckFormat;
+/** What `convert` reads: a file path (`.pptx`, `.opf.md`, `.yaml`/`.yml`, `.json`), a deck, or the bytes of a `.pptx` file. */
+type ConvertInput = string | Presentation | Uint8Array | ArrayBuffer;
+interface ConvertOptions extends Omit<ExportOptions, "format" | "filename"> {
+    /**
+     * What to make. With an output path the path's extension names it, and `format` is needed only for a `.zip` (the slides in
+     * it: `png`, the default, or `svg`); a `format` that disagrees with the extension is refused. Without an output path it is
+     * required: `pdf`, `pptx`, `png`, `svg`, `json`, `yaml` or `markdown`.
+     */
+    format?: ConvertFormat;
+    /** One archive of the slides instead of one file per slide (`png`, `svg`). With an output path, the path must end `.zip`, and a `.zip` path implies it. */
+    zip?: boolean;
+    /** A `.pptx` input: also return the raw per-shape layout and style signals of the file (`signals` in the result). */
+    signals?: boolean;
+    /**
+     * Replace outputs that exist (the default, as `save` and `fs.writeFile` do), atomically. `false` refuses: an existing output
+     * rejects with `output-exists` before anything is written, the rule the opf commands apply without `--force`. A symlink, a
+     * directory or another non-regular file is never replaced (`output-not-file`).
+     */
+    overwrite?: boolean;
+}
+interface ConvertedFile {
+    /** The file name: the output's base name, or without an output path the deck's `filename`, else its slugified `name`, else the input file's stem, then `-001.png` for slide 1 and so on. */
+    name: string;
+    /** With an output path, the file written: the path itself, or for one file per slide the path's folder and stem plus the slide number (`slides/deck-001.png`). */
+    path?: string;
+    /** The media type. */
+    type: string;
+    bytes: Uint8Array;
+    /** `png` and `svg`: the slide number (one-based), its id and the picture's size in pixels. */
+    slide?: number;
+    id?: string;
+    width?: number;
+    height?: number;
+    /** `pdf`: the number of pages and the slide numbers they show. */
+    pages?: number;
+    slides?: number[];
+    /** `zip`: the names of the entries. */
+    entries?: string[];
+}
+interface ConvertResult {
+    /** The files, in slide order: written when an output path was given, otherwise only returned. */
+    files: ConvertedFile[];
+    /** The findings of every step: the import (`import/` rules), the format and references check, and the export engines (`render/`, `pptx/`, `pdf/`, `fonts/`, `cli/`). Errors throw instead. */
+    findings: Finding[];
+    /** With `signals: true` and a `.pptx` input. */
+    signals?: {
+        version?: number;
+    };
+}
+interface OpenOptions {
+    /** The catalogs the deck's references resolve in. Omitted: the default catalog. */
+    catalogs?: ExportOptions["catalogs"];
+}
+interface SaveOptions {
+    /** Check format and references first and refuse an invalid deck (`OPFValidationError`). Default true; `false` writes work in progress, as an editor's autosave does. */
+    validate?: boolean;
+    /** The catalogs the deck's references resolve in. Omitted: the default catalog. */
+    catalogs?: ExportOptions["catalogs"];
+    /** YAML: start with a `# yaml-language-server: $schema=...` line so editors validate the file. */
+    schemaComment?: boolean;
+}
+interface SaveResult {
+    /** The file, as it was given. */
+    path: string;
+    /** The form written, from the file name. */
+    format: DeckFormat;
+}
+/** A planned conversion: everything `convert` would write, and what `opf convert` reports about it. */
+interface ConversionPlan {
+    files: ConvertedFile[];
+    findings: Finding[];
+    /** The format and references check of the deck that was drawn or written. */
+    check: Pick<ValidationReport, "valid" | "schemaValid" | "checks">;
+    format: ConvertFormat;
+    zip: boolean;
+    input?: {
+        file: string;
+        bytes: Uint8Array;
+    };
+    exported?: ExportResult;
+    imported?: ImportResult;
+}
+/** The deck form a file name stands for (core's `deckFormatOf`: `.opf.md`, `.yaml`, `.yml`), or JSON for `.json`; undefined for any other name. A plain `.md` file is not a deck. */
+declare function deckFileFormat(file: string): DeckFormat | undefined;
+/** The export format a file name stands for (`.pdf`, `.pptx`, `.png`, `.svg`, any case), else undefined. `opf render` and `opf export` read `--out` with the same rule. */
+declare function exportFormatOf(file: string): ExportFormat | undefined;
+/** Read an input file: `input-not-found` when there is none, `input-unreadable` for any other failure. */
+declare function readInput(file: string): Promise<Uint8Array>;
+/**
+ * Plan a conversion: check the request, read the input, then import, check, export or serialize. Nothing is written. Throws
+ * `OPFApiError` for the request and the files (`invalid-option`, `input-not-found`, `input-unreadable`, and
+ * `invalid-presentation` for a deck written as a deck), `OPFImportError` for the import step and `OPFExportError` for the export
+ * step (`invalid-presentation` included). `flags` names options as the command's flags in messages.
+ */
+declare function planConversion(input: ConvertInput, output: string | undefined, options?: ConvertOptions, flags?: boolean): Promise<ConversionPlan>;
+/**
+ * Write planned files atomically (temporary sibling, then rename), creating folders. `overwrite` false refuses an existing output
+ * (`output-exists`): the opf commands pass it unless `--force`; `convert` passes its `overwrite` option, true by default.
+ */
+declare function writePlanned(files: readonly ConvertedFile[], overwrite: boolean, flags?: boolean): Promise<void>;
+
+export { runExport as $, asApiError as A, checkDate as B, type ConvertInput as C, type Diagnostic as D, type ExportFormat as E, type FontsHandle as F, checkOptions as G, checkScale as H, type ImportOptions as I, deckFileFormat as J, exportFormatOf as K, finishReport as L, importPresentation as M, loadPptx as N, type OpenOptions as O, type Peer as P, loadRenderer as Q, type Renderer as R, type SaveOptions as S, missingPeerFrom as T, planConversion as U, VERSIONS as V, prepareExport as W, reaches as X, readInput as Y, reportThrown as Z, resolveExportOptions as _, type ConvertOptions as a, runPreparedExport as a0, writePlanned as a1, type ConvertResult as b, type ConvertFormat as c, type SaveResult as d, type ConvertedFile as e, OPFApiError as f, OPFExportError as g, OPFImportError as h, type EmbeddedFace as i, Reporter as j, type PptxModule as k, type ConversionPlan as l, EXPORT_FORMATS as m, type ExportContext as n, type ExportFile as o, type ExportFontSummary as p, type ExportOptions as q, type ExportResult as r, type ExportRun as s, type ImportResult as t, PEER_RANGES as u, PPTX_PACKAGE as v, type PreparedExport as w, RENDER_PACKAGE as x, type ReportFinding as y, type Source as z };

package/dist/convert.d.ts

@@ -1,7 +1,7 @@
-import { P as PaginatedPage, d as PresentationPaginationOptions } from './pagination-wedbe7eq.js';
-import './composition-D2tghM82.js';
-import './catalog-refs-BSfGELpt.js';
-import './chart-data-BnNqgnC-.js';
+import { P as PaginatedPage, d as PresentationPaginationOptions } from './pagination-BhX4M48Y.js';
+import './composition-BbZ_9C-c.js';
+import './catalog-refs-C4K4y-vh.js';
+import './chart-data-DTxdRRT1.js';
 
 type Json = any;
 type Obj = Record<string, any>;

package/dist/convert.js

@@ -1,12 +1,12 @@
-import { paginate, OPFPaginationError } from './chunk-UBFJ2QHH.js';
-import { parseQuoteLines, parseCodeFence, splitWhen, parseListLine, levelsFromIndents, fenceCode } from './chunk-374R35TJ.js';
-import { CONTENT_KEYS, isRecord, contentKeysOf, refuse, clone, Loss, isSlideLike, assertValidOwner, report, OPFConversionError, plainOf, assertValidOutput, same, splitRuns, runsOf, lineIsPlain, linePlain, concatText, lineValue, joinLines, hasFormatting } from './chunk-VGAOJEY7.js';
-export { OPFConversionError } from './chunk-VGAOJEY7.js';
-import './chunk-QDI75P2M.js';
-import { promotedRegionKeys, isDatasetRef, inlineTableData, visitContentPayloads, chartNumber } from './chunk-O744SXXA.js';
+import { paginate, OPFPaginationError } from './chunk-O2CX5NEH.js';
+import { parseQuoteLines, parseCodeFence, splitWhen, parseListLine, levelsFromIndents, fenceCode } from './chunk-ESRYBYLY.js';
+import { CONTENT_KEYS, isRecord, contentKeysOf, refuse, clone, Loss, isSlideLike, assertValidOwner, report, OPFConversionError, plainOf, assertValidOutput, same, splitRuns, runsOf, lineIsPlain, linePlain, concatText, lineValue, joinLines, hasFormatting } from './chunk-PPROJP2E.js';
+export { OPFConversionError } from './chunk-PPROJP2E.js';
+import './chunk-NLNYNBTS.js';
+import { promotedRegionKeys, isDatasetRef, inlineTableData, visitContentPayloads, chartNumber } from './chunk-CW7GEAV3.js';
 import './chunk-TRDXRRQK.js';
 import './chunk-SPFV27O5.js';
-import './chunk-2CJPC4HI.js';
+import './chunk-RA64UQKI.js';
 
 // src/convert/tables.ts
 function cellOf(raw) {

package/dist/data.d.ts

@@ -1,10 +1,27 @@
-export { C as ChartMapping, a as ChartNumberFix, b as ChartNumberFixOperation, c as ChartNumberFixOptions, D as DataCellValue, d as DataColumn, e as DataDiagnostic, f as DataDiagnosticCode, g as DataResolveOptions, h as DataSourceRef, i as DataStyledCell, j as DataTableCell, k as DataTableHeader, l as DataTableValue, m as DataTextRun, n as Dataset, o as DatasetRef, R as ResolvedChartData, p as ResolvedTableData, q as chartNumber, r as datasetDiagnostics, s as formatDataNumber, t as fromExcelNumberFormat, u as inlineChartData, v as inlineDatasets, w as inlineTableData, x as isDatasetRef, y as isXYChartType, z as numberFormatError, A as resolveChartData, B as resolveTableData, E as suggestChartNumberFix, F as tableCellDisplayValue, G as toExcelNumberFormat, H as unusedDatasets } from './chart-data-BnNqgnC-.js';
+import { C as Chart } from './presentation-fb8CZmRq.js';
+export { 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';
 
 type DataCell = string | number | boolean | null;
 interface TabularData {
     columns: string[];
     rows: DataCell[][];
 }
+/** Chart import rejects empty columns and rows before returning a schema-compatible payload. */
+interface ImportedChartData extends TabularData {
+    columns: [string, ...string[]];
+    rows: [DataCell[], ...DataCell[][]];
+}
+/** A `chart.type` value (OPF 0.15: an engine vocabulary, `CHART_TYPES`). */
+type ImportedChartType = Chart['type'];
+interface ImportedTable {
+    table: TabularData;
+}
+interface ImportedChart {
+    chart: {
+        type: ImportedChartType;
+        data: ImportedChartData;
+    };
+}
 interface DataImportOptions {
     format?: 'csv' | 'tsv' | 'json';
     delimiter?: string;
@@ -13,7 +30,8 @@ interface DataImportOptions {
 }
 interface ImportDataOptions extends DataImportOptions {
     as: 'table' | 'chart';
-    chartType?: string;
+    /** Default `column`. Values outside `CHART_TYPES` make an invalid chart; the CLI checks `--chart-type` first. */
+    chartType?: ImportedChartType;
     category?: string;
     series?: string[];
 }
@@ -21,13 +39,12 @@ declare class OPFDataImportError extends Error {
     constructor(message: string);
 }
 declare function parseTabularData(input: unknown, options?: DataImportOptions): TabularData;
-declare function importData(input: unknown, options: ImportDataOptions): {
-    table: TabularData;
-} | {
-    chart: {
-        type: string;
-        data: TabularData;
-    };
-};
+declare function importData(input: unknown, options: ImportDataOptions & {
+    as: 'table';
+}): ImportedTable;
+declare function importData(input: unknown, options: ImportDataOptions & {
+    as: 'chart';
+}): ImportedChart;
+declare function importData(input: unknown, options: ImportDataOptions): ImportedTable | ImportedChart;
 
-export { type DataCell, type DataImportOptions, type ImportDataOptions, OPFDataImportError, type TabularData, importData, parseTabularData };
+export { type DataCell, type DataImportOptions, type ImportDataOptions, type ImportedChart, type ImportedChartData, type ImportedChartType, type ImportedTable, OPFDataImportError, type TabularData, importData, parseTabularData };

package/dist/data.js

@@ -1,3 +1,3 @@
-export { OPFDataImportError, importData, parseTabularData } from './chunk-U4J75TRG.js';
-export { chartNumber, datasetDiagnostics, formatDataNumber, fromExcelNumberFormat, inlineChartData, inlineDatasets, inlineTableData, isDatasetRef, isXYChartType, numberFormatError, resolveChartData, resolveTableData, suggestChartNumberFix, tableCellDisplayValue, toExcelNumberFormat, unusedDatasets } from './chunk-O744SXXA.js';
+export { OPFDataImportError, importData, parseTabularData } from './chunk-O263APNI.js';
+export { chartNumber, datasetDiagnostics, formatDataNumber, fromExcelNumberFormat, inlineChartData, inlineDatasets, inlineTableData, isDatasetRef, isXYChartType, numberFormatError, resolveChartData, resolveTableData, suggestChartNumberFix, tableCellDisplayValue, toExcelNumberFormat, unusedDatasets } from './chunk-CW7GEAV3.js';
 import './chunk-SPFV27O5.js';

package/dist/deck-report-Bx3naFlF.d.ts

@@ -0,0 +1,40 @@
+import { b as Catalog } from './catalog-refs-C4K4y-vh.js';
+import { P as Presentation } from './presentation-fb8CZmRq.js';
+import { f as ValidationReport, c as ValidateOptions } from './validation-types-iZbXfES6.js';
+
+/** The serializations of a deck: `json` (canonical), `yaml` (`.opf.yaml`) and `markdown` (`.opf.md`). */
+type DeckFormat = "json" | "yaml" | "markdown";
+/** Every deck format, in the order JSON, YAML, Markdown. */
+declare const DECK_FORMATS: readonly DeckFormat[];
+/**
+ * The format a file name stands for: `.opf.md` is Markdown, `.yaml` and `.yml` are YAML (any case), every other name is JSON.
+ * A plain `.md` file is not a deck: it is Markdown that `fromMarkdown` converts when asked, so it is never detected.
+ */
+declare function deckFormatOf(filename: string | undefined): DeckFormat;
+/** Where a deck's text comes from: its format, or the file name that names it, and the catalogs its references resolve in. */
+interface ParseOptions {
+    /** The format of the text. Wins over `filename`. */
+    format?: DeckFormat;
+    /** The file name, for the format only: `.opf.md` is Markdown, `.yaml` and `.yml` are YAML, anything else is JSON. The content is never sniffed. */
+    filename?: string;
+    /** Catalogs the host registered, for the references check. Nothing is fetched. */
+    catalogs?: readonly Catalog[];
+}
+/** The options of `readDeckReport`: `parse`'s, plus the check to run. */
+interface DeckReportOptions extends ParseOptions {
+    /** `true` (the default) checks `format` and `references`; options pick other rules; `false` reports only syntax errors. */
+    validate?: boolean | ValidateOptions;
+}
+/** A deck read from text with the report of its check, whatever the format. */
+interface DeckReport extends ValidationReport {
+    /** The deck; a best effort (an empty object after a syntax error) when `valid` is false. */
+    presentation: Presentation;
+    format: DeckFormat;
+}
+/**
+ * The reader behind `parse` that never throws for content: the deck and the `validate` report of it, every finding
+ * located in the text. Not exported from the package entries; `@openpresentation/opf/node` and `parse` use it.
+ */
+declare function readDeckReport(text: string, options?: DeckReportOptions, caller?: string): DeckReport;
+
+export { DECK_FORMATS as D, type ParseOptions as P, type DeckFormat as a, type DeckReport as b, type DeckReportOptions as c, deckFormatOf as d, readDeckReport as r };

package/dist/deck.d.ts

@@ -0,0 +1,47 @@
+import { a as DeckFormat, P as ParseOptions } from './deck-report-Bx3naFlF.js';
+export { D as DECK_FORMATS, d as deckFormatOf } from './deck-report-Bx3naFlF.js';
+import { P as Presentation } from './presentation-fb8CZmRq.js';
+import './catalog-refs-C4K4y-vh.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';
+
+/**
+ * One entry point to read and write a deck in any of its three serializations (RR-60): JSON, the canonical and interchange
+ * form, and the two authoring forms of the same data, YAML (`.opf.yaml`, RR-56) and Markdown (`.opf.md`, RR-30). `parse`
+ * turns text into a deck (a deck that fails the format and references check throws, with every finding located in the text
+ * that was read); `stringify` turns a deck into text.
+ *
+ * The format comes from the `format` option, else from the file name, and never from the content: a string that starts with
+ * `{` is JSON only because JSON is the default. No renderer, fonts, DOM, network or model calls, and no Node APIs, so it runs in
+ * a browser. The same input always gives the same output.
+ */
+
+/**
+ * Read a deck from JSON, YAML or Markdown text and return it. The format comes from `format`, else from `filename`, never from the
+ * content. The deck is checked for format and references (in `catalogs`); a syntax, schema or reference error throws
+ * `OPFValidationError`, whose `report.findings` carry `location` (the UTF-16 offset and length, and the one-based line and column
+ * of the text that caused them; a JSON syntax error is `opf/json-syntax`, a YAML one `yaml/<rule>`, a Markdown one
+ * `markdown/<rule>`). Warnings do not throw: `validate` reports them. Throws a `TypeError` for text that is not a string, a
+ * format that is none of the three, or a bad option.
+ */
+declare function parse(text: string, options?: ParseOptions): Presentation;
+interface StringifyOptions {
+    /** The format to write. Wins over `filename`. */
+    format?: DeckFormat;
+    /** The file name the text is for, for the format only (see `parse`). */
+    filename?: string;
+    /** YAML: start with `# yaml-language-server: $schema=...` so editors validate and complete the file. */
+    schemaComment?: boolean;
+}
+/**
+ * Write a deck as text: JSON as two-space JSON with a final newline, YAML in canonical form (`toYaml`) and Markdown in canonical
+ * form (`toMarkdown`, with anything the dialect has no syntax for embedded in `opf-slide` and `opf-block` fences so nothing is
+ * lost). `parse` reads each result back to the same deck. YAML and Markdown throw `OPFYamlError` or `OPFMarkdownError`
+ * (`invalid-document`) for a document that is not valid OPF; JSON writes whatever it is given.
+ */
+declare function stringify(presentation: unknown, options?: StringifyOptions): string;
+
+export { DeckFormat, ParseOptions, type StringifyOptions, parse, stringify };

package/dist/deck.js

@@ -0,0 +1,12 @@
+export { DECK_FORMATS, deckFormatOf, parse, stringify } from './chunk-N4EVOFEA.js';
+import './chunk-BIC3SWPK.js';
+import './chunk-TCD2FB2K.js';
+import './chunk-IS5H5JKH.js';
+import './chunk-YT7FMQER.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';

package/dist/diff.d.ts

@@ -1,4 +1,4 @@
-import { J as JsonPatchOperation } from './finding-CT_f_vbD.js';
+import { J as JsonPatchOperation } from './finding-CDQ_wH8j.js';
 
 type MatchedBy = "id" | "equal" | "similar" | "position";
 interface MatchPair {