@weasel-js/diagram-formats 0.0.0-stage → 1.12.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 orochi235
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,238 @@
-# Temporary Holding Version
+# @weasel-js/diagram-formats
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Turns `@weasel-js/diagram` scenes into files and files into scenes. Every
+format reads and writes one interchange document, built on the diagram
+package's `DiagramData`. One page at a time exports as an SVG document or a
+PNG image, and every page together as one PDF, each showing the page as the
+canvas draws it.
+
+Part of [weasel](https://github.com/orochi235/weasel), a domain-agnostic 2D
+scene-graph canvas kit for React. See the
+[API reference](https://orochi235.github.io/weasel/#pkg/diagram-formats).
+
+```sh
+npm install @weasel-js/diagram-formats
+```
+
+## The interchange document
+
+A `DiagramDocument` is a diagram's pages and its theme. Each page has an id,
+an optional name, a sheet size, and a `DiagramData` whose places, boxes,
+waypoints, and label points run from the page's top-left corner. Ids share one
+namespace across the document. Edges whose ends are on different pages sit in
+`crossPageEdges`, with no waypoints, since they draw as two stubs and their
+off-page tags.
+
+```ts
+import { documentFromScene, documentSpecs } from '@weasel-js/diagram-formats';
+
+const doc = documentFromScene(scene);
+const { specs, doc: values } = documentSpecs(doc, { layer: 'shapes', measure });
+// values holds `core:pages` and `diagram:theme`; replace the scene's nodes with specs.
+```
+
+`documentFromScene(scene, { theme })` puts each shape, container, pool, and
+group on the page its outermost container overlaps most, or the first page
+when it overlaps none; a scene with no pages gets one page around everything.
+It keeps the colors the scene's theme would not give: those the author set by
+hand (the trait's `ownStyle`) and any that differ from the theme, as `colors`.
+A route or a port that layout chose, and an avoiding connector's computed
+route, are read as `routed` and `routedPorts`, not as waypoints, so they stay
+layout's. `theme` is what colors are compared against when the scene names
+none.
+
+`documentSpecs(doc, { layer, theme, measure })` is the way back. Pages are
+placed with core's `layoutPages`, as `core:pages` places them. A page where a
+node has no `at`, or a pool has no box, is laid out first with `layered`,
+running the way its `direction` says, with whatever it places pinned; the
+result is kept as places and routes, a page that placed nothing is moved to sit
+40 inside its corner, and the page grows to hold it. Then one `diagramScene`
+call with no layout draws every page and the edges between them, so no layout
+runs again after an import.
+
+## Formats
+
+A `DiagramFormat` has an `id`, a `name`, its `extensions`, and `detect(text)`,
+which judges by content alone. `read(text)` returns the document and the
+warnings, one sentence each, for what the file had that a diagram cannot hold;
+`write(doc, { page })` returns the text and the warnings for what the format
+cannot carry. A format with `onePage` writes the page `page` names, else the
+first (`writtenPage`).
+
+`DIAGRAM_FORMATS` lists them. `detectFormat(text, fileName)` takes, of the
+formats whose `detect` passes, the first claiming the file's extension, else the
+first; an extension alone never picks one. `readDocument(text, fileName)` reads
+with it and rejects on a file nothing reads.
+
+| Format | Extensions | Reads | Writes |
+| --- | --- | --- | --- |
+| `DIAGRAM_JSON`, the document as JSON | `.diagram.json` | yes | the whole document |
+| `DRAW_XML`, draw-style XML | `.xml` | yes, plain or compressed | every page, uncompressed |
+| `DIAGRAM_MERMAID`, a Mermaid flowchart | `.mmd`, `.mermaid` | yes | one page |
+| `DIAGRAM_DOT`, a Graphviz DOT graph | `.dot`, `.gv` | yes | one page |
+
+Not read, by decision (2026-10-20): packaged office-suite drawing formats,
+which are zip archives of many XML parts built on master shapes a scene has no
+equivalent for; and SVG, which carries drawn paths rather than shapes and
+connectors, so a connector would arrive as a path that follows nothing.
+
+### Draw-style XML
+
+The format that keeps a chart laid out. A file is an `<mxfile>` holding a
+`<diagram name=…>` per page, each a graph model of cells; a bare
+`<mxGraphModel>` reads as one page. A cell has a `key=value;` style string and
+a geometry measured from the corner of the cell holding it. A compressed page
+is base64 of raw deflate of the URI-encoded model, so `read` answers a promise.
+The file is known by its root element, not its `.xml` extension.
+
+| Diagram | Draw-style XML |
+| --- | --- |
+| Outline | `rhombus` diamond, `ellipse`, `hexagon`, `parallelogram`, `trapezoid`; `rounded=1` with `arcSize` 50 or more is a stadium; any other shape reads as a rect, with a warning |
+| Colors and font | `fillColor` (`none` is transparent), `strokeColor`, `fontColor`, `strokeWidth`, `dashed`; `fontSize`, `fontFamily`, and bold in `fontStyle` as label rows' style |
+| Text | `value`; with `html=1`, tags stripped and `<br>` and blocks kept as line breaks. Written plain. |
+| Router | `edgeStyle=orthogonalEdgeStyle` orthogonal, `curved=1` bezier, else straight; `avoid` writes as orthogonal along its route |
+| Route | the edge geometry's points: `waypoints`, else `routed`, read back as `waypoints` |
+| Ports | `exitX`/`exitY` and `entryX`/`entryY`, read as the nearest compass port |
+| Edge label | the edge's `value`, or a label cell on it; its geometry `x` (-1 to 1) is where along, `y` how far off the line |
+| Arrowheads | `startArrow`/`endArrow` and their `Fill` |
+| Container, pool, lane | `container=1` or a `swimlane` is a container; a swimlane whose swimlanes span its body is a pool of lanes, stacked in rows with `horizontal=0` |
+| Group | a `group` cell around its members |
+| Page | one `<diagram>` each, `pageWidth` and `pageHeight` its size |
+
+Reading leaves a color the style does not name unset, so the chart's theme
+draws it. A page grows to hold what is on it, and what sits left of or above it
+moves onto it. An id an earlier page used is prefixed with its page's id.
+Layers merge into one, and edges with a loose end are left out, each with a
+warning.
+
+Writing spells out every color as the document's theme draws it, so the file
+looks the same anywhere. A node is written the size it states, which is its
+drawn size in a document read from a scene; a page with unplaced nodes is laid
+out first, as an import would. Edges between pages are left out, with a
+warning, since a page's cells cannot reach another's; so are marks, port rows,
+and outline paths, which become rects.
+
+### Mermaid and Graphviz DOT
+
+Both hold a graph's topology and text, not its places (DOT holds them when
+every node has a `pos`), so a file reads into one page whose nodes have no
+`at`, and `documentSpecs` lays it out the way the page's `direction` says.
+Both readers are hand-written and throw an error naming the line on text they
+cannot read.
+
+| Diagram | Mermaid flowchart | Graphviz DOT |
+| --- | --- | --- |
+| rect | `A[text]` | `shape=box` |
+| stadium | `A([text])`, and `A(text)` | `shape=box, style=rounded` |
+| diamond | `A{text}` | `shape=diamond` |
+| ellipse | `A((text))` | `shape=ellipse`, the default, and `circle` |
+| hexagon | `A{{text}}` | `shape=hexagon` |
+| parallelogram | `A[/text/]` | `shape=parallelogram` |
+| trapezoid | `A[/text\]` | `shape=trapezium` |
+| edge and label | `A -->\|text\| B`, `A -- text --> B` | `A -> B [label=…]` |
+| no arrowhead, dashed, thick | `---`, `-.->`, `==>` | `dir`, `arrowhead`, `style=dashed`, `penwidth` |
+| container | `subgraph` | `subgraph cluster_*` |
+| page name | front matter `title` | the graph's `label`, else its name |
+| page `direction` | `flowchart TD/LR/BT/RL` | `rankdir` |
+| colors | `classDef`, `class`, `:::`, `style`, `linkStyle` | `fillcolor` with `style=filled`, `color`, `fontcolor` |
+| ports | — | `node:compass`, `n`, `e`, `s`, and `w` only |
+
+A Mermaid shape with no outline here reads as a rect, with a warning; a
+Mermaid diagram of another kind is refused with an error naming the kind. DOT
+reads its whole grammar: `strict`, `graph` and `digraph`, attribute
+statements and their scoping, edge chains, and subgraphs as edge ends. Its
+HTML labels read as their text, and the attributes it does not read are
+listed in one warning. A cluster's container drops its `cluster_` prefix when
+that id is free.
+
+Writing, each writes the theme's colors once (Mermaid's `classDef default`,
+DOT's `node` and `edge` defaults) and each item's own where they differ. DOT
+writes every node's `pos`, `width`, and `height` when each has a place and a
+size, so a DOT file read back keeps the layout. Pools, lanes, and groups are
+written as nested clusters or subgraphs and read back as containers. Mermaid
+ids that are keywords or not plain names are renamed, keeping their text.
+Bends, connectors to other pages, drawn outlines, and ports a format lacks
+are dropped with a warning.
+
+## Exporting a page
+
+A page is a rect in world space; a `PlacedPage` from core's `placedPagesOf` is
+one. Pages sit apart in one world, and a connector between two pages draws as
+two stubs and their off-page tags, so cutting the scene to the page rect leaves
+nothing from another page.
+
+```ts
+import { placedPagesOf } from '@weasel-js/core';
+import { exportPagePng, exportPageSvg, exportPagesPdf } from '@weasel-js/diagram-formats';
+
+const pages = placedPagesOf(scene);
+const svg = await exportPageSvg(scene, pages[0], { title: 'Page 1' });
+const png = await exportPagePng(scene, pages[0], { scale: 2 });
+const { blob, skipped } = await exportPagesPdf(scene, pages, { title: 'Chart' });
+```
+
+None writes to the scene, so an export takes no undo entry. Each takes
+`background`, the color painted under the page: by default the page color of
+the scene's diagram theme (`diagram:theme`), and `null` for none.
+
+### SVG
+
+`exportPageSvg` returns the document as a string. Its `viewBox` is the page
+rect and its `width` and `height` the page's size. Only nodes whose box meets
+the page are written, in paint order, on the scene's visible layers;
+annotation layers are left out.
+
+| In the scene | In the SVG |
+| --- | --- |
+| A shape's outline (`diagram.outline`) | A path of that outline in the shape's box, with its fill and stroke; a container's divider under its header as a second path. A container's members follow inside its group. |
+| A connector, or any node that derives its path | One path along the route, with its stroke and its `marker-start` and `marker-end`. A path made of parts writes one path per part. |
+| A drawn mark | Its unit-square path stretched over its box. |
+| Rows, labels, text marks, and off-page tags | Text, laid out in the lines the canvas lays it into; a tag's background is a rect behind it. |
+| Anything else | What `@weasel-js/svg`'s `svgLeafFromKit` writes for it. |
+
+It waits for the paint kinds and font faces the document uses before
+writing it. A load that fails goes to `onWarn`, and so does anything SVG cannot
+say the way weasel draws it. `title` and `pretty` are passed on to
+`serializeSvg`.
+
+`pageSvgNodes(scene, page)` is the walk on its own: the `SvgNode`s, with no
+background, for a caller assembling its own document.
+
+### PNG
+
+`exportPagePng` draws the page with core's `renderSceneToPixels`, the renderer
+the canvas uses, so its pixels are the canvas's. The image is the page's size
+times `scale`, and the result is a `Blob` of type `image/png`. It needs WebGL2
+and `OffscreenCanvas`.
+
+Paint kinds and fonts that load on demand are waited for, but the painters are
+the caller's to register, as they are to draw the scene at all:
+
+```ts
+import { registerDiagramShape, registerMarkShape } from '@weasel-js/diagram';
+
+registerDiagramShape();
+registerMarkShape();
+```
+
+### PDF
+
+`exportPagesPdf` writes each of `pages` as a page of one PDF, in the order
+given, at 0.75 points per unit (96 units to the inch). It answers the `Blob`,
+of type `application/pdf`, and `skipped`: what the PDF could not carry, each a
+`{ kind, detail }` from `@weasel-js/pdf`. Annotation layers are left out.
+
+Shapes and strokes are written as vectors and text as selectable text in its
+embedded face, which needs the face's outlines registered from a TrueType file
+(`registerFontOutlines` in `@weasel-js/font`). A face that cannot be embedded
+is drawn as glyph outlines, so its text is not selectable; a glyph with no
+outline at all is left out and listed in `skipped`.
+
+Effects, custom shaders, and fills in a registered paint kind are drawn through
+the renderer and placed as images, so the painters are the caller's to
+register, as for the PNG, and this needs WebGL2 and `OffscreenCanvas`.
+
+## Scenes it reads
+
+Poses are read as world-space `RectPose`s, which is what a diagram scene
+holds. A scene that composes child poses into a parent's frame is not one.

package/dist/index.d.ts

@@ -0,0 +1,246 @@
+import { DiagramData, LayoutDirection, DataEdge, DiagramTheme, DiagramSpec, MeasureRowText } from '@weasel-js/diagram';
+import { Scene, SerializedDoc, RectPose } from '@weasel-js/core';
+import { SvgNode, SerializeOptions } from '@weasel-js/svg';
+import { PdfSkip } from '@weasel-js/pdf';
+
+/**
+ * The interchange document every format reads and writes: a diagram's pages,
+ * each holding a `DiagramData`, and the theme it is drawn in. Only
+ * `documentFromScene` and `documentSpecs` know scenes, so a codec is written
+ * once for a chart and for a data-backed host alike.
+ */
+
+/**
+ * One page: its sheet size, and what is on it in coordinates from the page's
+ * top-left corner. Ids share one namespace across the whole document.
+ */
+interface DocumentPage {
+    id: string;
+    name?: string;
+    width: number;
+    height: number;
+    data: DiagramData;
+    /** The way layout runs when the page is laid out on import, which it is when a node has no `at`. */
+    direction?: LayoutDirection;
+}
+/** A diagram as every format reads and writes it. */
+interface DiagramDocument {
+    pages: readonly DocumentPage[];
+    /**
+     * Edges the scene splits off-page, and edges whose ends export to different pages: their ends, ports, router,
+     * label, and colors. One the scene splits off-page carries no waypoints,
+     * since it draws as two stubs ending at off-page tags; one it keeps whole
+     * (an end in the gap between pages) keeps them, in world coordinates.
+     */
+    crossPageEdges?: readonly DataEdge[];
+    /** A shipped theme's id, or a whole theme. Unset, the host's own. */
+    theme?: string | DiagramTheme;
+}
+/** What a format read, and what it could not carry into a diagram, one sentence each. */
+interface ImportResult {
+    document: DiagramDocument;
+    warnings: readonly string[];
+}
+/** What a format wrote, and what it could not carry out of the diagram, one sentence each. */
+interface ExportResult {
+    text: string;
+    warnings: readonly string[];
+}
+/** Options for {@link DiagramFormat.write}. */
+interface WriteOptions {
+    /** The page a format with no pages writes. Default the first. */
+    page?: string;
+}
+/** A file format a diagram can be read from or written to. */
+interface DiagramFormat {
+    id: string;
+    /** What a menu calls it. */
+    name: string;
+    /** With their dots, most usual first: `['.dot', '.gv']`. */
+    extensions: readonly string[];
+    /** Whether `text` looks like this format, from its content alone. */
+    detect(text: string): boolean;
+    /** Throws on text this format cannot read. */
+    read?(text: string): ImportResult | Promise<ImportResult>;
+    write?(doc: DiagramDocument, opts?: WriteOptions): ExportResult;
+    /** Whether {@link write} writes one page rather than the whole document. */
+    onePage?: boolean;
+}
+/** The page a one-page format writes: the one `opts.page` names, else the first. `null` for a document with none. */
+declare function writtenPage(doc: DiagramDocument, opts?: WriteOptions): DocumentPage | null;
+
+/** The formats a diagram reads from and writes to, and how a file finds its format. */
+
+/** Every format this package reads or writes. */
+declare const DIAGRAM_FORMATS: readonly DiagramFormat[];
+/**
+ * The format `text` is in: among those whose content test passes, the first
+ * that claims `fileName`'s extension, else the first. `null` when none
+ * passes, whatever the extension says, since an extension such as `.xml` names
+ * many formats.
+ */
+declare function detectFormat(text: string, fileName?: string, formats?: readonly DiagramFormat[]): DiagramFormat | null;
+/** Reads `text` with the format {@link detectFormat} picks. Rejects when none reads it. */
+declare function readDocument(text: string, fileName?: string, formats?: readonly DiagramFormat[]): Promise<ImportResult>;
+
+/** The native format: a {@link DiagramDocument} written out as JSON, which carries everything the model holds. */
+
+/** A diagram document as JSON, every page in one file, recognized by its `format` field. */
+declare const DIAGRAM_JSON: DiagramFormat;
+
+/** Draw-style XML as a {@link DiagramFormat}. */
+
+/**
+ * Draw-style XML: a page per `<diagram>`, each a graph model of cells with
+ * geometry, written out or compressed. Recognized by its root element, since
+ * `.xml` names many formats.
+ */
+declare const DRAW_XML: DiagramFormat;
+
+/** Mermaid as a {@link DiagramFormat}. */
+
+/**
+ * A Mermaid flowchart, one page per file, laid out on import. Any Mermaid
+ * diagram is recognized, so reading another kind says which kind it is.
+ */
+declare const DIAGRAM_MERMAID: DiagramFormat;
+
+/** Graphviz DOT as a {@link DiagramFormat}. */
+
+/** A Graphviz DOT graph, one page per file, laid out on import unless every node has a `pos`. */
+declare const DIAGRAM_DOT: DiagramFormat;
+
+/** A diagram scene as a {@link DiagramDocument}: what every format writes from. */
+
+/** Options for {@link documentFromScene}. */
+interface DocumentFromSceneOptions {
+    /** The theme colors are read against when the scene's `diagram:theme` names none. Default the night theme. */
+    theme?: DiagramTheme;
+}
+/**
+ * Reads a diagram scene into a document: one page per page in its `core:pages`
+ * (one page around everything when it has none), each holding the shapes,
+ * connectors, containers and pools, and groups on it, in coordinates from the
+ * page's corner. A shape belongs to the page its outermost container does, and
+ * that is the one its box overlaps most, or the nearest one when it overlaps
+ * none. A connector the scene splits off-page, or whose ends export to
+ * different pages, goes in `crossPageEdges`: without waypoints when split,
+ * with them in world coordinates when not. Colors are kept
+ * where the scene's theme would not give them: the author's own, and any a
+ * theme never set.
+ */
+declare function documentFromScene<TData, TLayer extends string, TPose>(scene: Scene<TData, TLayer, TPose>, opts?: DocumentFromSceneOptions): DiagramDocument;
+
+/** A {@link DiagramDocument} as scene specs and document values: what every import draws from. */
+
+/** Options for {@link documentSpecs}. */
+interface DocumentSpecsOptions<TLayer extends string = 'main'> {
+    /** The layer every spec goes on. Default `'main'`. */
+    layer?: TLayer;
+    /** The theme to draw in. Default the one the document names, else the night theme. */
+    theme?: DiagramTheme;
+    /** Measures text. Default an estimate from character count. */
+    measure?: MeasureRowText;
+}
+/** What {@link documentSpecs} returns: the nodes, and the `core:pages` and `diagram:theme` document values. */
+interface DocumentScene<TLayer extends string = 'main'> {
+    specs: DiagramSpec<TLayer>[];
+    doc: SerializedDoc;
+}
+/**
+ * The scene a document draws as. Its pages are placed with core's
+ * `layoutPages`, as a scene's `core:pages` places them. A page whose nodes
+ * all have a place is drawn where they say; any other page is laid out first,
+ * with `layered`, its placed nodes pinned (and grows to hold the result). Then
+ * every page, moved to its place, and the edges between pages are drawn by one
+ * `diagramScene` call with no layout, so the scene holds places and routes and
+ * no layout runs again.
+ */
+declare function documentSpecs<TLayer extends string = 'main'>(document: DiagramDocument, opts?: DocumentSpecsOptions<TLayer>): DocumentScene<TLayer>;
+
+/**
+ * One page of a diagram scene as `SvgNode`s: the nodes whose box meets the
+ * page, each written the way the canvas paints it.
+ */
+
+/** A page's rect in world space. A `PlacedPage` is one. */
+interface PageRect {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+/** A diagram scene as the exports read it: world-space `RectPose`s. */
+type PageExportScene = Scene<unknown, string, RectPose>;
+/**
+ * The `SvgNode`s of everything on `page`, in paint order: every node on a
+ * visible content layer whose box meets the page, with what is under it.
+ * Diagram outlines and drawn marks go through the diagram painters, a node
+ * that derives its path (a connector) is drawn along that path, and anything
+ * else is written by `svgLeafFromKit`.
+ */
+declare function pageSvgNodes(scene: PageExportScene, page: PageRect): SvgNode[];
+
+/** Options for {@link exportPageSvg}. */
+interface ExportPageSvgOptions extends Pick<SerializeOptions, 'title' | 'onWarn' | 'pretty'> {
+    /** The color painted under the page. Default: the page color of the
+     *  scene's diagram theme (`diagram:theme`). `null` paints none. */
+    background?: string | null;
+}
+/**
+ * Write `page` of `scene` as an SVG document: its `viewBox` is the page rect,
+ * its size the page's, the page color comes first, and the scene is drawn as
+ * the canvas draws it, cut to the page's edges. What lies wholly off the page
+ * is left out.
+ *
+ * It waits for the paint kinds and faces the document needs, so its text is
+ * written in the lines the canvas lays it out into. A load that fails goes to
+ * `onWarn`, and the export goes ahead without it.
+ */
+declare function exportPageSvg(scene: PageExportScene, page: PageRect, opts?: ExportPageSvgOptions): Promise<string>;
+
+/** Options for {@link exportPagePng}. */
+interface ExportPagePngOptions {
+    /** Output pixels per world unit: 2 makes an image twice the page's size. */
+    scale: number;
+    /** The color painted under the page. Default: the page color of the
+     *  scene's diagram theme. `null` leaves it transparent. */
+    background?: string | null;
+}
+/**
+ * Draw `page` of `scene` into a PNG, `page × scale` pixels, through the
+ * renderer the canvas draws with, so it shows what the canvas shows, cut to
+ * the page's edges. Annotation layers are left out.
+ *
+ * The caller has registered whatever the scene needs painting with, as it
+ * must to draw it at all: the diagram painters (`registerDiagramShape`,
+ * `registerMarkShape`) and its fonts. Paint kinds and faces that load on
+ * demand are waited for. Needs WebGL2 and `OffscreenCanvas`.
+ */
+declare function exportPagePng(scene: PageExportScene, page: PageRect, opts: ExportPagePngOptions): Promise<Blob>;
+
+/** Options for {@link exportPagesPdf}. */
+interface ExportPagesPdfOptions {
+    /** The color painted under each page. Default: the page color of the
+     *  scene's diagram theme. `null` leaves it unpainted. */
+    background?: string | null;
+    /** The document's title. */
+    title?: string;
+}
+/**
+ * Write each of `pages` of `scene` as a page of one PDF, `page × 0.75` points
+ * in size, in the order given. Shapes and strokes are vector; text is real,
+ * selectable text in its embedded face. What a PDF cannot draw is painted
+ * through the renderer and placed as an image, and anything it could not
+ * carry at all comes back in `skipped`. Annotation layers are left out.
+ *
+ * The caller has registered what the scene needs painting with, as for
+ * `exportPagePng`, including each font's outlines. Needs WebGL2 and
+ * `OffscreenCanvas`.
+ */
+declare function exportPagesPdf(scene: PageExportScene, pages: readonly PageRect[], opts?: ExportPagesPdfOptions): Promise<{
+    blob: Blob;
+    skipped: readonly PdfSkip[];
+}>;
+
+export { DIAGRAM_DOT, DIAGRAM_FORMATS, DIAGRAM_JSON, DIAGRAM_MERMAID, DRAW_XML, type DiagramDocument, type DiagramFormat, type DocumentFromSceneOptions, type DocumentPage, type DocumentScene, type DocumentSpecsOptions, type ExportPagePngOptions, type ExportPageSvgOptions, type ExportPagesPdfOptions, type ExportResult, type ImportResult, type PageExportScene, type PageRect, type WriteOptions, detectFormat, documentFromScene, documentSpecs, exportPagePng, exportPageSvg, exportPagesPdf, pageSvgNodes, readDocument, writtenPage };