@jasy/pdf 1.0.0-alpha.1 → 1.0.0-alpha.3

package/dist/api/layout.js

@@ -1,71 +1,61 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Column = Column;
-exports.Row = Row;
-exports.Box = Box;
-exports.Padding = Padding;
-exports.Spacer = Spacer;
-exports.Expanded = Expanded;
-const container_element_1 = require("../elements/container-element");
-const row_element_1 = require("../elements/row-element");
-const rectangle_element_1 = require("../elements/rectangle-element");
-const expanded_element_1 = require("../elements/layout/expanded-element");
-const padding_element_1 = require("../elements/layout/padding-element");
-const color_1 = require("./color");
-const insets_1 = require("./insets");
-const args_1 = require("./args");
+import { ContainerElement } from "../elements/container-element.js";
+import { RowElement } from "../elements/row-element.js";
+import { RectangleElement } from "../elements/rectangle-element.js";
+import { ExpandedElement } from "../elements/layout/expanded-element.js";
+import { PaddingElement } from "../elements/layout/padding-element.js";
+import { PositionedElement } from "../elements/layout/positioned-element.js";
+import { toColor } from "./color.js";
+import { toEdges } from "./insets.js";
+import { splitArgs } from "./args.js";
 // The public default for `cross` is `start` (locked §5) - i.e. don't stretch a child unless
 // asked. The engine default is `stretch`; the factory sets the friendlier public one.
 const DEFAULT_CROSS = "start";
-function Column(a, b) {
-    var _a;
-    const { opts, children } = (0, args_1.splitArgs)(a, b);
-    return new container_element_1.ContainerElement({
+export function Column(a, b) {
+    const { opts, children } = splitArgs(a, b);
+    return new ContainerElement({
         x: 0,
         y: 0,
         children,
         gap: opts.gap,
         main: opts.justify, // undefined → engine default `start` (matches §5)
-        cross: (_a = opts.align) !== null && _a !== void 0 ? _a : DEFAULT_CROSS,
+        cross: opts.align ?? DEFAULT_CROSS,
     });
 }
-function Row(a, b) {
-    var _a;
-    const { opts, children } = (0, args_1.splitArgs)(a, b);
-    return new row_element_1.RowElement({
+export function Row(a, b) {
+    const { opts, children } = splitArgs(a, b);
+    return new RowElement({
         children,
         gap: opts.gap,
         main: opts.justify,
-        cross: (_a = opts.align) !== null && _a !== void 0 ? _a : DEFAULT_CROSS,
+        cross: opts.align ?? DEFAULT_CROSS,
     });
 }
-function Box(a, b) {
-    var _a;
-    const { opts, children } = (0, args_1.splitArgs)(a, b);
+export function Box(a, b) {
+    const { opts, children } = splitArgs(a, b);
     const content = opts.padding !== undefined && children.length > 0
         ? [
-            new padding_element_1.PaddingElement({
-                margin: (0, insets_1.toEdges)(opts.padding),
+            new PaddingElement({
+                margin: toEdges(opts.padding),
                 child: children.length === 1 ? children[0] : Column(children),
             }),
         ]
         : children;
     // A side is set if it (or the uniform `border`) is given. If ANY differs from a plain
-    // uniform border, we hand the engine per-side colours (which draws individual lines).
+    // uniform border, we hand the engine per-side colors (which draws individual lines).
     const sideKeys = [opts.borderTop, opts.borderRight, opts.borderBottom, opts.borderLeft];
     const hasPerSide = sideKeys.some((s) => s !== undefined);
     const side = (s) => {
-        const c = s !== null && s !== void 0 ? s : opts.border;
-        return c !== undefined ? (0, color_1.toColor)(c) : undefined;
+        const c = s ?? opts.border;
+        return c !== undefined ? toColor(c) : undefined;
     };
     const hasBorder = opts.border !== undefined || opts.borderWidth !== undefined || hasPerSide;
-    return new rectangle_element_1.RectangleElement({
+    return new RectangleElement({
         x: 0,
         y: 0,
         children: content,
-        color: opts.border !== undefined ? (0, color_1.toColor)(opts.border) : undefined,
-        backgroundColor: opts.bg !== undefined ? (0, color_1.toColor)(opts.bg) : undefined,
-        borderWidth: hasBorder ? ((_a = opts.borderWidth) !== null && _a !== void 0 ? _a : 1) : 0,
+        color: opts.border !== undefined ? toColor(opts.border) : undefined,
+        backgroundColor: opts.bg !== undefined ? toColor(opts.bg) : undefined,
+        borderWidth: hasBorder ? (opts.borderWidth ?? 1) : 0,
         width: opts.width,
         height: opts.height,
         radius: opts.radius,
@@ -77,23 +67,34 @@ function Box(a, b) {
                 left: side(opts.borderLeft),
             }
             : undefined,
+        relative: opts.relative,
+        overflow: opts.overflow,
     });
 }
 /** Insets a single child by `padding` (a number / `{x,y}` / `{top,…}` / 4-tuple). */
-function Padding(padding, child) {
-    return new padding_element_1.PaddingElement({ margin: (0, insets_1.toEdges)(padding), child });
+export function Padding(padding, child) {
+    return new PaddingElement({ margin: toEdges(padding), child });
+}
+/**
+ * Places a child OUT OF FLOW, relative to the nearest enclosing `relative` Box. Two ways, pick per
+ * axis: pin to EDGES - `Positioned({ top, left, right, bottom }, child)`, where a negative value
+ * pokes into / out of the corner (a badge, a tab, a ribbon) and pinning both sides stretches; or
+ * ANCHOR + nudge - `Positioned({ h: "center", v: "end", x: -10, y: -8 }, child)`, i.e. centered /
+ * end-aligned with a pixel offset. An edge wins over an anchor on the same axis.
+ */
+export function Positioned(opts, child) {
+    return new PositionedElement({ child, ...opts });
 }
 /**
  * A flexible empty gap that pushes its siblings apart - `Row([a, Spacer(), b])` sends `a`
  * and `b` to the edges. `flex` weights it against other flex children (default 1).
  */
-function Spacer(flex = 1) {
-    return new expanded_element_1.ExpandedElement({ flex, child: Column([]) });
+export function Spacer(flex = 1) {
+    return new ExpandedElement({ flex, child: Column([]) });
 }
-function Expanded(a, b) {
-    var _a;
+export function Expanded(a, b) {
     const isOptsForm = b !== undefined;
     const opts = (isOptsForm ? a : {});
     const child = (isOptsForm ? b : a);
-    return new expanded_element_1.ExpandedElement({ flex: (_a = opts.flex) !== null && _a !== void 0 ? _a : 1, child });
+    return new ExpandedElement({ flex: opts.flex ?? 1, child });
 }

package/dist/api/structure.d.ts

@@ -1,11 +1,22 @@
-import { PDFDocumentElement } from "../elements/pdf-document-element";
-import { PageElement } from "../elements/page-element";
-import { PDFElement } from "../elements/pdf-element";
-import { PageSize } from "../constants/page-sizes";
-import { StackOptions } from "./layout";
-import { Insets } from "./insets";
-/** A page size: a `PageSize` enum, or a friendly name like `"A4"` / `"letter"` (any case). */
-export type PageSizeInput = PageSize | string;
+import { PDFDocumentElement } from "../elements/pdf-document-element.js";
+import { PageElement } from "../elements/page-element.js";
+import { PDFElement } from "../elements/pdf-element.js";
+import { DefaultTextStyleElement } from "../elements/layout/default-text-style-element.js";
+import type { OverflowPolicy } from "../layout/fragmentation.js";
+import { PageSize } from "../constants/page-sizes.js";
+import { StackOptions } from "./layout.js";
+import { Insets } from "./insets.js";
+import { TextDefaults } from "./text.js";
+/** A custom page size. Use the `mm()` helper for millimetres, or pass points directly. */
+export interface CustomSize {
+    width: number;
+    height: number;
+    unit?: "pt" | "mm";
+}
+/** Millimetres → a custom page size, e.g. a 50×65 mm label: `Page({ size: mm(50, 65) }, …)`. */
+export declare function mm(width: number, height: number): CustomSize;
+/** A page size: a named `PageSize`/string (`"A4"`, `"letter"`, any case), or a `CustomSize`. */
+export type PageSizeInput = PageSize | string | CustomSize;
 export interface PageOptions extends StackOptions {
     /** Page size (default A4). */
     size?: PageSizeInput;
@@ -24,17 +35,50 @@ export interface PageOptions extends StackOptions {
  */
 export declare function Page(children: PDFElement[]): PageElement;
 export declare function Page(opts: PageOptions, children: PDFElement[]): PageElement;
-export interface DocumentOptions {
+/** Document options: PDF metadata plus the inheritable text defaults (font, size, color, lineHeight,
+ *  align, bold/italic) every `Text` inherits unless it sets its own - Flutter's `DefaultTextStyle`. */
+export interface DocumentOptions extends TextDefaults {
     /** PDF metadata. */
     meta?: {
         title?: string;
         author?: string;
     };
 }
+/** A single font file for `addFont`: a `.ttf` path (read on Node) or its raw bytes (e.g. a browser
+ *  upload). */
+export type FontFileSource = string | Uint8Array;
+/** A styled font family for `addFont`: one file per style, only `normal` required. `Text({ bold,
+ *  italic })` then picks the right face, falling back to `normal`. */
+export interface FontFamilyInput {
+    normal: FontFileSource;
+    bold?: FontFileSource;
+    italic?: FontFileSource;
+    boldItalic?: FontFileSource;
+}
+/** What `addFont` accepts: one file (path or bytes), or a styled family. */
+export type FontSource = FontFileSource | FontFamilyInput;
+/** The object the `Document(...)` factory returns: the element tree plus a managed font registry. */
+export interface JasyDocument extends PDFDocumentElement {
+    /** Register a font under `name`, then use it via `Text({ font: name })`. The source is a `.ttf`
+     *  path (read now, on Node), raw bytes, or a styled family. Re-adding a name overwrites it.
+     *  A registered font that no `Text` actually uses is dropped at render and costs nothing. */
+    addFont(name: string, source: FontSource): this;
+    /** The names of the registered fonts. */
+    getFonts(): string[];
+    /** Whether a font is registered under `name`. */
+    hasFont(name: string): boolean;
+}
 /** The document root. `Document(pages)` or `Document(opts, pages)`. */
-export declare function Document(pages: PageElement[]): PDFDocumentElement;
-export declare function Document(opts: DocumentOptions, pages: PageElement[]): PDFDocumentElement;
-export type FontBytes = Buffer | Uint8Array;
+export declare function Document(pages: PageElement[]): JasyDocument;
+export declare function Document(opts: DocumentOptions, pages: PageElement[]): JasyDocument;
+/**
+ * Sets default text properties (font/size/color/lineHeight/align/weight) for a whole subtree -
+ * Flutter's `DefaultTextStyle`, the per-section counterpart to the `Document` defaults. Children
+ * inherit them unless they set their own, and they layer onto whatever is inherited from above.
+ * `DefaultTextStyle(opts, children)`.
+ */
+export declare function DefaultTextStyle(opts: TextDefaults, children: PDFElement[]): DefaultTextStyleElement;
+export type FontBytes = Uint8Array;
 /** A font family: one `.ttf` per style. Only `normal` is required; `bold`/`italic`/`boldItalic`
  *  are picked up automatically by `Text({ bold, italic })`, falling back to `normal` if absent. */
 export interface FontFamily {
@@ -73,8 +117,11 @@ export interface RenderOptions {
     standardFonts?: boolean;
     /** FlateDecode-compress the streams (default true). Set false for a greppable, uncompressed PDF. */
     compress?: boolean;
+    /** What to do when content is taller than a page and cannot break: `"error"` throws (default),
+     *  `"warn"` logs and clips, `"ignore"` clips silently. It is always clipped either way. */
+    onOverflow?: OverflowPolicy;
 }
 /** Renders a `Document(...)` tree to the raw PDF string. */
 export declare function renderPdf(doc: PDFDocumentElement, options?: RenderOptions): Promise<string>;
 /** Renders a `Document(...)` tree to PDF bytes (e.g. for a download / save dialog). */
-export declare function renderToBytes(doc: PDFDocumentElement, options?: RenderOptions): Promise<Uint8Array>;
+export declare function renderToBytes(doc: PDFDocumentElement, options?: RenderOptions): Promise<Uint8Array<ArrayBuffer>>;

package/dist/api/structure.js

@@ -1,125 +1,169 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Page = Page;
-exports.Document = Document;
-exports.renderPdf = renderPdf;
-exports.renderToBytes = renderToBytes;
-const pdf_document_element_1 = require("../elements/pdf-document-element");
-const page_element_1 = require("../elements/page-element");
-const page_sizes_1 = require("../constants/page-sizes");
-const pdf_config_1 = require("../renderer/pdf-config");
-const pdf_document_class_1 = require("../renderer/pdf-document-class");
-const pdf_object_manager_1 = require("../utils/pdf-object-manager");
-const utf8_to_windows1252_encoder_1 = require("../utils/utf8-to-windows1252-encoder");
-const layout_1 = require("./layout");
-const insets_1 = require("./insets");
-const PAGE_SIZE_VALUES = new Set(Object.values(page_sizes_1.PageSize));
+import { readFileBytes } from "../platform/node-fs.js";
+import { PDFDocumentElement } from "../elements/pdf-document-element.js";
+import { PageElement } from "../elements/page-element.js";
+import { DefaultTextStyleElement } from "../elements/layout/default-text-style-element.js";
+import { PageSize } from "../constants/page-sizes.js";
+import { Orientation } from "../renderer/pdf-config.js";
+import { PDFDocument } from "../renderer/pdf-document-class.js";
+import { FontStyle } from "../utils/pdf-object-manager.js";
+import { getArrayBuffer } from "../utils/utf8-to-windows1252-encoder.js";
+import { Column } from "./layout.js";
+import { toEdges } from "./insets.js";
+import { toTextStyleOverride } from "./text.js";
+const MM_TO_PT = 72 / 25.4; // 1 mm in PDF points
+/** Millimetres → a custom page size, e.g. a 50×65 mm label: `Page({ size: mm(50, 65) }, …)`. */
+export function mm(width, height) {
+    return { width, height, unit: "mm" };
+}
+const PAGE_SIZE_VALUES = new Set(Object.values(PageSize));
 function toPageSize(input) {
     const v = String(input).toLowerCase();
     if (!PAGE_SIZE_VALUES.has(v))
         throw new Error(`Unknown page size: "${input}"`);
     return v;
 }
+/** Resolve `size` into config fields: a named `pageSize`, or an explicit [width, height] in points. */
+function resolveSize(input) {
+    if (input !== undefined && typeof input === "object") {
+        const f = input.unit === "mm" ? MM_TO_PT : 1;
+        return { pageSize: PageSize.A4, customSize: [input.width * f, input.height * f] };
+    }
+    return { pageSize: input !== undefined ? toPageSize(input) : PageSize.A4 };
+}
 /** Default page margin (all sides, points) when a `Page` doesn't set one. */
 const DEFAULT_MARGIN = 56;
-function Page(a, b) {
-    var _a;
+export function Page(a, b) {
     const isOpts = !Array.isArray(a);
     const opts = (isOpts ? a : {});
-    const children = (isOpts ? (b !== null && b !== void 0 ? b : []) : a);
-    const [top, right, bottom, left] = (0, insets_1.toEdges)((_a = opts.margin) !== null && _a !== void 0 ? _a : DEFAULT_MARGIN);
+    const children = (isOpts ? (b ?? []) : a);
+    const [top, right, bottom, left] = toEdges(opts.margin ?? DEFAULT_MARGIN);
     const config = {
-        pageSize: opts.size !== undefined ? toPageSize(opts.size) : page_sizes_1.PageSize.A4,
-        orientation: opts.orientation === "landscape" ? pdf_config_1.Orientation.landscape : pdf_config_1.Orientation.portrait,
+        ...resolveSize(opts.size),
+        orientation: opts.orientation === "landscape" ? Orientation.landscape : Orientation.portrait,
         margin: { top, right, bottom, left },
     };
-    return new page_element_1.PageElement({
+    return new PageElement({
         config,
         header: opts.header,
         footer: opts.footer,
-        children: [(0, layout_1.Column)({ gap: opts.gap, justify: opts.justify, align: opts.align }, children)],
+        children: [Column({ gap: opts.gap, justify: opts.justify, align: opts.align }, children)],
     });
 }
 // Document metadata is a document-render concern, not part of the element tree, so it is
 // kept beside the returned element and picked up by `renderPdf`.
 const docMeta = new WeakMap();
-function Document(a, b) {
+// Fonts registered via doc.addFont(...), kept beside the element (like meta) and registered on the
+// object manager at render time. Path sources are read to bytes in addFont, so the map holds bytes.
+const docFonts = new WeakMap();
+/** Reads any path sources to bytes, leaving bytes / families as-is. */
+function resolveFontSource(source) {
+    const read = (s) => (typeof s === "string" ? readFileBytes(s) : s);
+    if (typeof source === "string" || source instanceof Uint8Array) {
+        return read(source);
+    }
+    const family = { normal: read(source.normal) };
+    if (source.bold)
+        family.bold = read(source.bold);
+    if (source.italic)
+        family.italic = read(source.italic);
+    if (source.boldItalic)
+        family.boldItalic = read(source.boldItalic);
+    return family;
+}
+export function Document(a, b) {
     const isOpts = !Array.isArray(a);
     const opts = (isOpts ? a : {});
-    const pages = (isOpts ? (b !== null && b !== void 0 ? b : []) : a);
-    const doc = new pdf_document_element_1.PDFDocumentElement({ children: pages });
+    const pages = (isOpts ? (b ?? []) : a);
+    const doc = new PDFDocumentElement({
+        children: pages,
+        defaultTextStyle: toTextStyleOverride(opts),
+    });
     if (opts.meta)
         docMeta.set(doc, opts.meta);
+    // Managed font registry: addFont registers, getFonts/hasFont query, render reads it (below).
+    const registry = new Map();
+    docFonts.set(doc, registry);
+    doc.addFont = (name, source) => {
+        registry.set(name, resolveFontSource(source));
+        return doc;
+    };
+    doc.getFonts = () => [...registry.keys()];
+    doc.hasFont = (name) => registry.has(name);
     return doc;
 }
+/**
+ * Sets default text properties (font/size/color/lineHeight/align/weight) for a whole subtree -
+ * Flutter's `DefaultTextStyle`, the per-section counterpart to the `Document` defaults. Children
+ * inherit them unless they set their own, and they layer onto whatever is inherited from above.
+ * `DefaultTextStyle(opts, children)`.
+ */
+export function DefaultTextStyle(opts, children) {
+    return new DefaultTextStyleElement({ style: toTextStyleOverride(opts), child: Column(children) });
+}
 function isFontBytes(v) {
-    return Buffer.isBuffer(v) || v instanceof Uint8Array;
+    return v instanceof Uint8Array;
 }
 /** Renders a `Document(...)` tree to the raw PDF string. */
-function renderPdf(doc, options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        const meta = docMeta.get(doc);
-        const config = Object.assign(Object.assign({}, (meta ? { metaData: { title: meta.title, author: meta.author, keywords: [] } } : {})), ((options === null || options === void 0 ? void 0 : options.standardFonts) === false ? { registerStandardFonts: false } : {}));
-        const fonts = (_a = options === null || options === void 0 ? void 0 : options.fonts) !== null && _a !== void 0 ? _a : {};
-        const attachments = (_b = options === null || options === void 0 ? void 0 : options.attachments) !== null && _b !== void 0 ? _b : [];
-        // A throwaway PDFDocument whose build() yields this tree, reusing the engine's standard
-        // font registration + config handling (the constructor does both). Custom fonts are
-        // registered here, before layout/render, so both the metrics and the backend see them.
-        const Anon = class extends pdf_document_class_1.PDFDocument {
-            constructor() {
-                super(config);
-                const om = this.objectManager;
-                om.setCompress((options === null || options === void 0 ? void 0 : options.compress) !== false); // FlateDecode streams by default
-                for (const [name, value] of Object.entries(fonts)) {
-                    if (isFontBytes(value)) {
-                        om.registerCustomFont(name, Buffer.from(value));
-                    }
-                    else {
-                        om.registerCustomFont(name, Buffer.from(value.normal), pdf_object_manager_1.FontStyle.Normal);
-                        if (value.bold)
-                            om.registerCustomFont(name, Buffer.from(value.bold), pdf_object_manager_1.FontStyle.Bold);
-                        if (value.italic)
-                            om.registerCustomFont(name, Buffer.from(value.italic), pdf_object_manager_1.FontStyle.Italic);
-                        if (value.boldItalic)
-                            om.registerCustomFont(name, Buffer.from(value.boldItalic), pdf_object_manager_1.FontStyle.BoldItalic);
-                    }
+export async function renderPdf(doc, options) {
+    const meta = docMeta.get(doc);
+    const config = {
+        ...(meta ? { metaData: { title: meta.title, author: meta.author, keywords: [] } } : {}),
+        ...(options?.standardFonts === false ? { registerStandardFonts: false } : {}),
+    };
+    // Fonts registered via doc.addFont(...) plus any passed in options (options win on a name clash).
+    const registered = docFonts.get(doc);
+    const fonts = {
+        ...Object.fromEntries(registered ?? []),
+        ...options?.fonts,
+    };
+    const attachments = options?.attachments ?? [];
+    // A throwaway PDFDocument whose build() yields this tree, reusing the engine's standard
+    // font registration + config handling (the constructor does both). Custom fonts are
+    // registered here, before layout/render, so both the metrics and the backend see them.
+    const Anon = class extends PDFDocument {
+        constructor() {
+            super(config);
+            const om = this.objectManager;
+            om.setCompress(options?.compress !== false); // FlateDecode streams by default
+            om.setOverflowPolicy(options?.onOverflow ?? "error");
+            for (const [name, value] of Object.entries(fonts)) {
+                if (isFontBytes(value)) {
+                    om.registerCustomFont(name, value);
                 }
-                for (const a of attachments) {
-                    om.attachFile(a.name, Buffer.from(a.data), {
-                        relationship: a.relationship,
-                        mimeType: a.mimeType,
-                        description: a.description,
-                    });
+                else {
+                    om.registerCustomFont(name, value.normal, FontStyle.Normal);
+                    if (value.bold)
+                        om.registerCustomFont(name, value.bold, FontStyle.Bold);
+                    if (value.italic)
+                        om.registerCustomFont(name, value.italic, FontStyle.Italic);
+                    if (value.boldItalic)
+                        om.registerCustomFont(name, value.boldItalic, FontStyle.BoldItalic);
                 }
-                if (options === null || options === void 0 ? void 0 : options.xmp)
-                    om.setXmpMetadata(options.xmp);
-                if (options === null || options === void 0 ? void 0 : options.outputIntent)
-                    om.setOutputIntent(Buffer.from(options.outputIntent));
-                if (options === null || options === void 0 ? void 0 : options.pdfVersion)
-                    om.setPdfVersion(options.pdfVersion);
-                if (options === null || options === void 0 ? void 0 : options.documentId)
-                    om.enableDocumentId();
             }
-            build() {
-                return doc;
+            for (const a of attachments) {
+                om.attachFile(a.name, a.data, {
+                    relationship: a.relationship,
+                    mimeType: a.mimeType,
+                    description: a.description,
+                });
             }
-        };
-        return Anon.render();
-    });
+            if (options?.xmp)
+                om.setXmpMetadata(options.xmp);
+            if (options?.outputIntent)
+                om.setOutputIntent(options.outputIntent);
+            if (options?.pdfVersion)
+                om.setPdfVersion(options.pdfVersion);
+            if (options?.documentId)
+                om.enableDocumentId();
+        }
+        build() {
+            return doc;
+        }
+    };
+    return Anon.render();
 }
 /** Renders a `Document(...)` tree to PDF bytes (e.g. for a download / save dialog). */
-function renderToBytes(doc, options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return new Uint8Array((0, utf8_to_windows1252_encoder_1.getArrayBuffer)(yield renderPdf(doc, options)));
-    });
+export async function renderToBytes(doc, options) {
+    // Plain ArrayBuffer-backed, so the bytes drop straight into a Blob/Response (BlobPart needs <ArrayBuffer>).
+    return new Uint8Array(getArrayBuffer(await renderPdf(doc, options)));
 }

package/dist/api/table.d.ts

@@ -1,6 +1,6 @@
-import { PDFElement } from "../elements/pdf-element";
-import { Insets } from "./insets";
-import { ColorInput } from "./color";
+import { PDFElement } from "../elements/pdf-element.js";
+import { Insets } from "./insets.js";
+import { ColorInput } from "./color.js";
 /**
  * A column width: a `number` of points (fixed), an `"Nfr"` fraction (splits the leftover
  * width), or `"auto"` (as wide as the widest cell in that column - measured at layout time).
@@ -21,11 +21,11 @@ export interface TableOptions {
     colGap?: number;
     /** Padding inside every cell (default none). */
     cellPadding?: Insets;
-    /** Grid line colour around every cell. Draws the complete grid once - don't add your own
+    /** Grid line color around every cell. Draws the complete grid once - don't add your own
      *  frame Box, or the outer edges double up. */
     cellBorder?: ColorInput;
     /** A single thin horizontal rule under the header row and along the foot of the table (e.g. a
-     *  light-grey separator). Independent of `cellBorder`, which draws the full grid. */
+     *  light-gray separator). Independent of `cellBorder`, which draws the full grid. */
     rule?: ColorInput;
 }
 /**

package/dist/api/table.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Table = Table;
-const box_constraints_1 = require("../layout/box-constraints");
-const repeating_header_element_1 = require("../elements/layout/repeating-header-element");
-const deferred_element_1 = require("../elements/layout/deferred-element");
-const layout_1 = require("./layout");
-const text_1 = require("./text");
+import { BoxConstraints } from "../layout/box-constraints.js";
+import { RepeatingHeaderElement } from "../elements/layout/repeating-header-element.js";
+import { DeferredElement } from "../elements/layout/deferred-element.js";
+import { Column, Row, Box, Expanded, Padding } from "./layout.js";
+import { Text } from "./text.js";
 function asElement(c) {
-    return typeof c === "string" ? (0, text_1.Text)(c) : c;
+    return typeof c === "string" ? Text(c) : c;
 }
 /** `"2fr"` → 2, `"fr"` → 1; not a fraction → null. */
 function fractionOf(col) {
@@ -18,8 +15,8 @@ function fractionOf(col) {
 }
 /** The cell's unbounded (max-content) width - what an `"auto"` column sizes to. */
 function naturalWidth(cell, cellPadding, ctx) {
-    const el = cellPadding !== undefined ? (0, layout_1.Padding)(cellPadding, asElement(cell)) : asElement(cell);
-    return el.calculateLayout(box_constraints_1.BoxConstraints.loose(Infinity, Infinity), { x: 0, y: 0 }, ctx).width;
+    const el = cellPadding !== undefined ? Padding(cellPadding, asElement(cell)) : asElement(cell);
+    return el.calculateLayout(BoxConstraints.loose(Infinity, Infinity), { x: 0, y: 0 }, ctx).width;
 }
 /** Replaces every `"auto"` column with the widest cell width measured down that column. */
 function resolveAutoColumns(opts, rows, ctx) {
@@ -40,37 +37,44 @@ function resolveAutoColumns(opts, rows, ctx) {
 }
 /** Builds the table tree for already-resolved column widths (no `"auto"`). */
 function composeTable(opts, rows, columns) {
-    var _a, _b, _c, _d;
     const { cellPadding } = opts;
-    const colGap = (_b = (_a = opts.colGap) !== null && _a !== void 0 ? _a : opts.gap) !== null && _b !== void 0 ? _b : 0;
-    const rowGap = (_d = (_c = opts.rowGap) !== null && _c !== void 0 ? _c : opts.gap) !== null && _d !== void 0 ? _d : 0;
+    const colGap = opts.colGap ?? opts.gap ?? 0;
+    const rowGap = opts.rowGap ?? opts.gap ?? 0;
     const cb = opts.cellBorder;
     const rule = opts.rule;
     // The complete grid, once: every cell bottom+right, first row also top, first col also left.
     const borderFor = (firstRow, firstCol) => cb === undefined
         ? {}
-        : Object.assign(Object.assign({ borderBottom: cb, borderRight: cb }, (firstRow ? { borderTop: cb } : {})), (firstCol ? { borderLeft: cb } : {}));
+        : {
+            borderBottom: cb,
+            borderRight: cb,
+            ...(firstRow ? { borderTop: cb } : {}),
+            ...(firstCol ? { borderLeft: cb } : {}),
+        };
     // `ruled` rows get just a bottom line (the header underline / the table foot), without the full grid.
     const wrap = (cell, col, firstRow, firstCol, ruled) => {
-        const inner = cellPadding !== undefined ? (0, layout_1.Padding)(cellPadding, asElement(cell)) : asElement(cell);
+        const inner = cellPadding !== undefined ? Padding(cellPadding, asElement(cell)) : asElement(cell);
         // The border lives on the wrapper, which stretches to the row height (crisp lines).
-        const border = Object.assign(Object.assign({}, borderFor(firstRow, firstCol)), (ruled && rule !== undefined ? { borderBottom: rule } : {}));
+        const border = {
+            ...borderFor(firstRow, firstCol),
+            ...(ruled && rule !== undefined ? { borderBottom: rule } : {}),
+        };
         const boxed = cb !== undefined || (ruled && rule !== undefined);
         if (typeof col === "number")
-            return (0, layout_1.Box)(Object.assign({ width: col }, border), [inner]);
+            return Box({ width: col, ...border }, [inner]);
         const fr = fractionOf(col);
         if (fr !== null)
-            return (0, layout_1.Expanded)({ flex: fr }, boxed ? (0, layout_1.Box)(Object.assign({}, border), [inner]) : inner);
+            return Expanded({ flex: fr }, boxed ? Box({ ...border }, [inner]) : inner);
         throw new Error(`Unsupported column width "${col}" - use a number of points or "<n>fr"`);
     };
     // align:stretch → equal-height cells, so a wrapping cell keeps the row's bottom rule straight.
-    const buildRow = (cells, firstRow, ruled = false) => (0, layout_1.Row)({ gap: colGap, align: "stretch" }, cells.map((cell, i) => { var _a; return wrap(cell, (_a = columns[i]) !== null && _a !== void 0 ? _a : "1fr", firstRow, i === 0, ruled); }));
+    const buildRow = (cells, firstRow, ruled = false) => Row({ gap: colGap, align: "stretch" }, cells.map((cell, i) => wrap(cell, columns[i] ?? "1fr", firstRow, i === 0, ruled)));
     // The first row (which gets the top border) is the header if present, else body row 0.
     // `rule` underlines the header and the last body row (the table foot).
     const last = rows.length - 1;
-    const body = (0, layout_1.Column)({ gap: rowGap }, rows.map((cells, idx) => buildRow(cells, !opts.header && idx === 0, rule !== undefined && idx === last)));
+    const body = Column({ gap: rowGap }, rows.map((cells, idx) => buildRow(cells, !opts.header && idx === 0, rule !== undefined && idx === last)));
     return opts.header
-        ? new repeating_header_element_1.RepeatingHeaderElement(buildRow(opts.header, true, rule !== undefined), body, rowGap)
+        ? new RepeatingHeaderElement(buildRow(opts.header, true, rule !== undefined), body, rowGap)
         : body;
 }
 /**
@@ -79,9 +83,9 @@ function composeTable(opts, rows, columns) {
  * paginates at row boundaries for free (a row that doesn't fit moves whole). `"auto"`
  * columns are resolved at layout time (a `DeferredElement`), once metrics are available.
  */
-function Table(opts, rows) {
+export function Table(opts, rows) {
     if (opts.columns.some((c) => c === "auto")) {
-        return new deferred_element_1.DeferredElement((ctx) => composeTable(opts, rows, resolveAutoColumns(opts, rows, ctx)));
+        return new DeferredElement((ctx) => composeTable(opts, rows, resolveAutoColumns(opts, rows, ctx)));
     }
     return composeTable(opts, rows, opts.columns);
 }