@reportwright/engine 0.0.0-stage → 0.12.0

package/dist/types/src/exporters/pdfstream.d.ts

@@ -0,0 +1,198 @@
+/**
+ * @typedef {{ write(u8: Uint8Array): any, once?: (ev: string, cb: () => void) => any }} Sink
+ *   write may return a promise (awaited: back-pressure), or false with a 'drain' event to wait for (a Node Writable).
+ * @typedef {{ title: string, page: number, top?: number, level?: number }} OutlineEntry
+ *   page: 1-based; top: the destination's y in PDF space (from the bottom), else the page fits the window.
+ */
+/**
+ * @param {Sink} sink
+ * @param {{ fontStore: import('../engine/text/fonts.js').FontStore, fonts?: string[],
+ *   subset?: (font: Uint8Array, codePoints: Iterable<number>, opt?: { glyphs?: Iterable<number> }) => Promise<Uint8Array>,
+ *   id?: string }} opt
+ *   fonts: font keys to name now (F1, F2… in this order); any other font is named on first use.
+ *   subset: subset.js's subsetter; without it fonts embed in full. id: the file ID (32 hex digits), else random.
+ */
+export function createPdfStream(sink: Sink, opt: {
+    fontStore: import("../engine/text/fonts.js").FontStore;
+    fonts?: string[];
+    subset?: (font: Uint8Array, codePoints: Iterable<number>, opt?: {
+        glyphs?: Iterable<number>;
+    }) => Promise<Uint8Array>;
+    id?: string;
+}): {
+    /** @param {string} key @returns {string} the font's resource name (F1…) */
+    fontName: (key: string) => string;
+    /**
+     * The text's glyphs, one per character (as the engine measured it: no layout features), as hex for <…> Tj, with
+     * the glyphs recorded for the subset, W and ToUnicode.
+     * @param {string} key @param {string} text
+     */
+    encode(key: string, text: string): string;
+    /**
+     * The same glyphs as a literal string's body, two bytes each, escaped (as pdf.js draws plain text): ( … ) Tj.
+     * @param {string} key @param {string} text
+     */
+    literal(key: string, text: string): string;
+    /**
+     * Shaped glyphs drawn by ID (conjuncts, joined forms): [glyph ID, the text it stands for ('' for none)].
+     * @param {string} key @param {Iterable<[number, string]>} glyphs
+     */
+    addGlyphs(key: string, glyphs: Iterable<[number, string]>): void;
+    /**
+     * A name in the shared Resources dictionary for a value (an indirect ref "12 0 R" or an inline dictionary).
+     * @param {'ExtGState'|'XObject'|'Pattern'|'Shading'|'ColorSpace'} kind @param {string} value
+     */
+    resource(kind: "ExtGState" | "XObject" | "Pattern" | "Shading" | "ColorSpace", value: string, name?: any): string;
+    /**
+     * The ExtGState name for fill and stroke opacity, named by its values (the same name in every writer: pages
+     * painted elsewhere, parallel.js, use it too). @param {number} ca @param {number} CA
+     */
+    gs: (ca: number, CA: number) => string;
+    /** What this writer's pages used, for another writer to take over (pages painted elsewhere). */
+    used: () => {
+        fonts: (string | number[] | [number, string][])[][];
+        gs: string[];
+    };
+    /** Take over what pages painted elsewhere used (used() of their writer). @param {any} u */
+    take(u: any): void;
+    /**
+     * Write an object now (an image: its dictionary and its stream, already filtered). @returns {Promise<number>} its number
+     * @param {string} dict @param {Uint8Array} [stream]
+     */
+    object(dict: string, stream?: Uint8Array): Promise<number>;
+    /** An object number to write later (objectAt). */
+    reserve: () => number;
+    /** Write a reserved object. @param {number} n @param {string} dict @param {Uint8Array} [stream] */
+    objectAt: (n: number, dict: string, stream?: Uint8Array) => Promise<void>;
+    /**
+     * Write a reserved object whose text may be long (an array of every row's element): head, the parts as they come,
+     * tail; written out in place, never held whole. @param {number} n @param {string} head @param {Iterable<string>} parts @param {string} tail
+     */
+    bigObject(n: number, head: string, parts: Iterable<string>, tail: string): Promise<void>;
+    /** The object number of page i (0-based), written or not: links and outline entries may point ahead. @param {number} i */
+    pageRef(i: number): number;
+    /**
+     * The total page count, drawn at the end: a Form XObject whose origin is the text's baseline at the box's left;
+     * draw it with `q 1 0 0 1 x y cm /<name> Do Q`. align: within width.
+     * @param {{ font: string, size: number, width: number, align?: 'left'|'center'|'right', color?: string }} o
+     */
+    totalPages(o: {
+        font: string;
+        size: number;
+        width: number;
+        align?: "left" | "center" | "right";
+        color?: string;
+    }): string;
+    /**
+     * Write a page: its content stream (deflated) and its dictionary, now. Nothing of it stays but two offsets.
+     * @param {{ width: number, height: number, content?: string | Uint8Array, deflated?: Uint8Array, annots?: (string | { ref: number, dict: string })[], extra?: string }} p
+     *   deflated: the content stream already compressed (zlib), as pages painted elsewhere come.
+     *   content: the page's operators (a string holds bytes 0–255, as pdf.js's Content makes). annots: annotation
+     *   dictionaries (with a reserved number: { ref, dict }). extra: more entries for the page dictionary (/StructParents 3).
+     */
+    addPage(p: {
+        width: number;
+        height: number;
+        content?: string | Uint8Array;
+        deflated?: Uint8Array;
+        annots?: (string | {
+            ref: number;
+            dict: string;
+        })[];
+        extra?: string;
+    }): Promise<void>;
+    /**
+     * The end of the file: totals, fonts, resources, page tree, outline, catalog, Info, xref, trailer.
+     * @param {{ outline?: OutlineEntry[], info?: { title?: string, author?: string, subject?: string, creationDate?: Date }, catalog?: string }} [o]
+     *   catalog: more entries for the catalog (the structure tree, metadata, output intents).
+     * @returns {Promise<{ pages: number, bytes: number }>}
+     */
+    finish(o?: {
+        outline?: OutlineEntry[];
+        info?: {
+            title?: string;
+            author?: string;
+            subject?: string;
+            creationDate?: Date;
+        };
+        catalog?: string;
+    }): Promise<{
+        pages: number;
+        bytes: number;
+    }>;
+};
+/**
+ * A report to PDF bytes written to sink as its pages are laid out (planPaged: a flowing table, one window of rows at a
+ * time), else rendered whole and exported by exportPdf, the same file it always was, written to sink in one piece.
+ * opts: render()'s options and exportPdf's (fontStore, subset, title, author, creationDate, drillBase…). Tagged,
+ * PDF/A, encrypted and signed files take the whole-model path.
+ * @param {any} def @param {any} opts @param {Sink} sink
+ * @returns {Promise<{ streamed: boolean, pages: number, warnings: string[], why?: string }>}
+ */
+export function exportPdfStream(def: any, opts: any, sink: Sink): Promise<{
+    streamed: boolean;
+    pages: number;
+    warnings: string[];
+    why?: string;
+}>;
+/**
+ * The pages of a paged plan (planPaged) as a PDF written to sink, page by page.
+ * @param {any} plan @param {any} opts fontStore, subset, title, author, creationDate, drillBase @param {Sink} sink
+ * @returns {Promise<{ pages: number, warnings: string[] }>}
+ */
+export function writePagedPdf(plan: any, opts: any, sink: Sink): Promise<{
+    pages: number;
+    warnings: string[];
+}>;
+/**
+ * A page of the model as its content stream's operators and its link annotations, drawn with the shared painter
+ * (pdfpaint.js) as exportPdf draws it. env (paintEnv): the writer's names and glyph records, the page refs links jump
+ * to, the tagger when tagged. Pages painted in parallel (parallel.js) use a writer of their own and the same names.
+ * @param {any} pg @param {number} H @param {any} env
+ * @returns {{ content: string, annots: any[] }}
+ */
+export function paintPage(pg: any, H: number, env: any): {
+    content: string;
+    annots: any[];
+};
+/**
+ * What paintPage draws with: a writer's resource names and glyph records (w), the fonts, shaped glyphs' texts.
+ * @param {any} w @param {any} fontStore @param {{ drillBase?: string, pageRef?: (i: number) => any, tags?: any }} [o]
+ */
+export function paintEnv(w: any, fontStore: any, o?: {
+    drillBase?: string;
+    pageRef?: (i: number) => any;
+    tags?: any;
+}): {
+    shared: {
+        font: (f: any) => any;
+        gs: (ca: any, CA: any) => any;
+        image: () => never;
+    };
+    pf: (key: string) => any;
+    font: (key: string) => any;
+    shaped: Map<string, Map<number, string>>;
+    shapedOf: (key: string) => Map<number, string>;
+    vmetrics: (key: string) => any;
+    literal: (key: string, text: string) => any;
+    pageRef: (i: number) => any;
+    reserve: () => any;
+    drillBase: string;
+    tags: any;
+};
+/**
+ * write may return a promise (awaited: back-pressure), or false with a 'drain' event to wait for (a Node Writable).
+ */
+export type Sink = {
+    write(u8: Uint8Array): any;
+    once?: (ev: string, cb: () => void) => any;
+};
+/**
+ * page: 1-based; top: the destination's y in PDF space (from the bottom), else the page fits the window.
+ */
+export type OutlineEntry = {
+    title: string;
+    page: number;
+    top?: number;
+    level?: number;
+};

package/dist/types/src/exporters/pdfstreamtags.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The structure tree of a streamed, tagged PDF (PDF/UA-1, and PDF/A-2a with it): pdfua.js's tree for the shapes that
+ * stream (engine/paged.js), written as the pages are. Document > P / H1–H6 (text boxes), Table > TR > TH/TD (the table's
+ * header rows TH with Scope Column the first time, an artifact where they repeat; empty cells as empty TD; spans as
+ * ColSpan), Link > OBJR inside the element whose text it covers; page header and footer, borders and boxes artifacts.
+ * Each page's rows (TR, TD), its parent-tree array and its links' elements are written when the page ends; what stays
+ * is one number per row (the Table's kids) and two per page and link (the parent tree), written at the end.
+ */
+/**
+ * @param {any} w the PDF writer (pdfstream.js createPdfStream)
+ */
+export function createStreamTagger(w: any): {
+    /** a new page (window: the paged window it came from; row ids are its own) @param {number} window */
+    page(window: number): void;
+    /**
+     * The marked content that opens item it: a structure element's MCID, or an artifact; null for a link.
+     * @param {any} it
+     */
+    open(it: any): string;
+    /**
+     * A link annotation of the page: its Link element (in the element of the text it covers, else the Document).
+     * @returns {number} the annotation's StructParent
+     * @param {any} it @param {number} annot the annotation's object number
+     */
+    link(it: any, annot: number): number;
+    /**
+     * The page is drawn: its elements and parent-tree array are written. @returns {Promise<string>} the page's entries
+     * @param {number} pageRef
+     */
+    end(pageRef: number): Promise<string>;
+    /**
+     * The tree's top: Table, Document, the parent tree, the root. @returns {Promise<string>} the catalog's entries
+     * @param {{ lang?: string }} o
+     */
+    finish({ lang }?: {
+        lang?: string;
+    }): Promise<string>;
+};

package/dist/types/src/exporters/pdfua.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @param {any} model
+ * @param {import('pdf-lib').PDFDocument} doc
+ */
+export function createTagger(model: any, doc: import("pdf-lib").PDFDocument): {
+    /**
+     * Marked content around item ii of page pi: the operator that opens it, or null (nothing is drawn for it).
+     * @returns {string|null}
+     */
+    open(pi: any, ii: any, it: any): string | null;
+    /** A link annotation of item ii (or a field's widget): its structure element; returns its StructParent key. */
+    annot(pi: any, ii: any, ref: any, kind: any): void;
+    finish({ lang, title }?: {
+        lang?: string;
+        title?: string;
+    }): void;
+};

package/dist/types/src/exporters/png.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Why a PNG cannot be embedded, or null when it can.
+ * @param {Uint8Array} b @returns {string|null}
+ */
+export function pngProblem(b: Uint8Array): string | null;
+export namespace PNG_LIMITS {
+    let pixels: number;
+    let rawBytes: number;
+    let chunks: number;
+}

package/dist/types/src/exporters/pptx.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @param {any} model render() output
+ * @param {{ title?: string, author?: string, lang?: string, fontStore?: any, fetchImage?: (src: string) => Promise<Uint8Array|null>,
+ *   rasterize?: (svg: string, w: number, h: number, scale: number) => Promise<Uint8Array|null> }} [opt]
+ * @returns {Promise<Uint8Array>}
+ */
+export function exportPptx(model: any, opt?: {
+    title?: string;
+    author?: string;
+    lang?: string;
+    fontStore?: any;
+    fetchImage?: (src: string) => Promise<Uint8Array | null>;
+    rasterize?: (svg: string, w: number, h: number, scale: number) => Promise<Uint8Array | null>;
+}): Promise<Uint8Array>;

package/dist/types/src/exporters/regions.d.ts

@@ -0,0 +1,30 @@
+/**
+ * A page model rendered without exportData (the default: a view, a plain PDF) has no table data and no cell tags:
+ * the exports that rebuild tables refuse it rather than write a file without its tables.
+ */
+export function needsTableData(model: any, what: any): void;
+/** Merge table regions that share a name (a table repeated inside a list). */
+export function mergedRegions(model: any): any[];
+/**
+ * The visual lines of a text item, as strings. A justified line is one run per word on the same
+ * baseline; this joins them back (in x order) so text exports and search see whole lines.
+ * @param {{ lines: { x: number, y: number, text: string }[] }} it
+ * @returns {string[]}
+ */
+export function visualLines(it: {
+    lines: {
+        x: number;
+        y: number;
+        text: string;
+    }[];
+}): string[];
+/**
+ * The visual lines of a page's text items, as strings. Rich text draws one text item per styled
+ * fragment (`rich: {id, l}`); the fragments of one box on one line (superscripts included) are joined in x order with
+ * nothing between them (they keep their own spaces). Other items give their visualLines().
+ * @param {any[]} items page-model items (anything that is not text is skipped)
+ * @returns {string[]}
+ */
+export function textRows(items: any[]): string[];
+export function needsExportData(fmt: any, o?: {}): boolean;
+export function isJustified(it: any): boolean;

package/dist/types/src/exporters/subset.d.ts

@@ -0,0 +1,5 @@
+/** @param {() => Promise<ArrayBuffer|Uint8Array>} loadWasm */
+export function createSubsetter(loadWasm: () => Promise<ArrayBuffer | Uint8Array>): (font: Uint8Array, codePoints: Iterable<number>, opt?: {
+    glyphs?: Iterable<number>;
+    layout?: boolean;
+}) => Promise<Uint8Array>;

package/dist/types/src/exporters/svg.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The address a browser may load an image from, by the policy of the data fetches: a data:image URI or this server's
+ * own path as it is; an absolute http(s) URL only through this server's data proxy (/api/data/proxy: PW_PROXY_ALLOW
+ * hosts, never a private address); anything else (another scheme, //host) not at all. So a stored report cannot make
+ * its viewers' browsers call hosts of its choosing. @param {any} src @param {string} [proxyBase] the server's origin,
+ * for a file opened elsewhere (the HTML export)
+ */
+export function imageHref(src: any, proxyBase?: string): string;
+/**
+ * box: draw only this part of the page (viewBox), as Word and PowerPoint figures do. outline: text as glyph outlines,
+ * from fontkit fonts (figures.js), for readers without the report's fonts.
+ * @param {{ background?: boolean, animate?: boolean, box?: { x: number, y: number, w: number, h: number }, outline?: ((key: string) => any) | null }} [opt]
+ */
+export function pageToSvg(page: any, w: any, h: any, { background, animate, box, outline, proxyBase }?: {
+    background?: boolean;
+    animate?: boolean;
+    box?: any;
+    outline?: any;
+    proxyBase?: string;
+}): string;
+export function linkTitle(a: any): any;
+/** @font-face rules for report fonts served from /fonts (uploaded ones from /fonts/custom). */
+export function fontFaceCss(keys: any, base?: string): any;
+/** Every font key a page model draws with (text items, their runs, form fields). */
+export function fontKeysOf(model: any): any[];
+export function fontFamilyCss(key: any): string;

package/dist/types/src/exporters/svgimage.d.ts

@@ -0,0 +1,33 @@
+/** A transform list, split on ")" and "(": linear, no backtracking. @param {string} s @returns {M} */
+export function parseTransform(s: string): M;
+/**
+ * Shapes of an SVG in its own user space (the root viewBox applied), with their paint resolved.
+ * @param {string} text
+ * @returns {{ w: number, h: number, shapes: { d: string, m: M, fill: any, stroke: any, sw: number, fo: number, so: number }[] } | null}
+ */
+export function parseSvg(text: string): {
+    w: number;
+    h: number;
+    shapes: {
+        d: string;
+        m: M;
+        fill: any;
+        stroke: any;
+        sw: number;
+        fo: number;
+        so: number;
+    }[];
+} | null;
+/**
+ * Draw a parsed SVG into the box (PDF coordinates: x, y of the bottom-left corner), scaled by sx, sy.
+ * @param {any} page pdf-lib PDFPage
+ * @param {NonNullable<ReturnType<typeof parseSvg>>} svg
+ * @param {{ x: number, y: number, sx: number, sy: number }} at
+ */
+export function drawSvg(page: any, svg: NonNullable<ReturnType<typeof parseSvg>>, at: {
+    x: number;
+    y: number;
+    sx: number;
+    sy: number;
+}): void;
+export type M = [number, number, number, number, number, number];

package/dist/types/src/exporters/xlsx.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Report format → Excel number format. value: the cell's value, so a date gets a date format (N6: "d" is a date,
+ * not two decimals) and an en-IN number its own lakh grouping (N22: Excel's conditions cannot cover negatives).
+ * @param {string|null|undefined} fmt @param {string} [currencySymbol] @param {string} [locale] @param {any} [value]
+ */
+export function excelFormat(fmt: string | null | undefined, currencySymbol?: string, locale?: string, value?: any): any;
+/** The currency symbol for a code in the report locale ("INR" → ₹), else the code. */
+export function currencySymbol(iso: any, locale: any): any;
+/** A column's values over the rows a total covers, kept as they pass: what subtotalFn needs, in O(1) memory. */
+export function colStats(): {
+    vals: number;
+    nums: number;
+    sum: number;
+    min: number;
+    max: number;
+    first: any;
+    differ: boolean;
+    /** @param {any} v a region cell's value */
+    add(v: any): void;
+};
+/**
+ * The SUBTOTAL function a total's shown value is, over its column's values (colStats), or null: 9 the sum, 2/3 the
+ * count (COUNTA when there is text), 1 the average, 5 the minimum, 4 the maximum, each within the format's precision.
+ * @param {{ value: any, format?: string }} c @param {ReturnType<typeof colStats>} st
+ */
+export function subtotalFn(c: {
+    value: any;
+    format?: string;
+}, st: ReturnType<typeof colStats>): 1 | 2 | 3 | 4 | 5 | 9;
+/** Excel's sheet names, unique in a workbook: no \\ / ? * [ ] :, no control characters, not starting or ending with ', at
+*  most 31 characters (28 here, room for a " 2"). suffix: kept whole (a split sheet's " (2)"). */
+export function sheetNamer(): (n: any, suffix?: string) => string;
+/** A region cell → an Excel cell: its value (dates as the report's wall clock), number format, bold and header fill. */
+export function xlsxCell({ sym, locale, tz }: {
+    sym: any;
+    locale: any;
+    tz: any;
+}): (c: any, header: boolean) => any;
+/**
+ * Excel workbook in "data mode": one sheet per table, typed cells, number formats,
+ * bold header and group rows, and outline levels for grouped detail rows. Group and table totals that are a sum,
+ * count, average, minimum or maximum of their column are live SUBTOTAL formulas (formulas: false keeps values).
+ * Charts are native Excel charts; pictures go on a sheet of their own (PNG; needs a rasteriser, see figures.js).
+ * Written by xlsxwriter.js (no ExcelJS).
+ * @param {any} model  render() output
+ * @param {{ currency?: string, title?: string, formulas?: boolean, pictures?: boolean, charts?: boolean, fontStore?: any, fonts?: any,
+ *   fetchImage?: (src: string) => Promise<Uint8Array|null>, rasterize?: any, timeZone?: string }} [opt]
+ * @returns {Promise<Uint8Array>}
+ */
+export function exportXlsx(model: any, opt?: {
+    currency?: string;
+    title?: string;
+    formulas?: boolean;
+    pictures?: boolean;
+    charts?: boolean;
+    fontStore?: any;
+    fonts?: any;
+    fetchImage?: (src: string) => Promise<Uint8Array | null>;
+    rasterize?: any;
+    timeZone?: string;
+}, legacy?: any): Promise<Uint8Array>;

package/dist/types/src/exporters/xlsxchart.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The cells a chart's data takes on its sheet, from row 1: a header row, then one row per category (or point).
+ * @param {any} spec items[0].xchart (engine/items/chart.js nativeSpec)
+ * @returns {any[][]}
+ */
+export function chartTable(spec: any): any[][];
+/**
+ * The chart part (xl/charts/chartN.xml) for a spec whose data starts at A1 of `sheet`.
+ * @param {any} spec @param {string} sheet
+ */
+export function chartXml(spec: any, sheet: string): string;
+/**
+ * Add the charts to a workbook ExcelJS wrote. Each chart: { sheet (its sheet's name), spec, at: { col, row } } with
+ * its data at A1 of that sheet; the sheets have no drawing of their own.
+ * @param {Uint8Array} bytes @param {{ sheet: string, spec: any, at: { col: number, row: number } }[]} charts
+ * @returns {Uint8Array}
+ */
+export function addCharts(bytes: Uint8Array, charts: {
+    sheet: string;
+    spec: any;
+    at: {
+        col: number;
+        row: number;
+    };
+}[]): Uint8Array;
+export function esc(s: any): string;

package/dist/types/src/exporters/xlsxwriter.d.ts

@@ -0,0 +1,83 @@
+/** A worksheet's XML up to and including <sheetData> (what must be known before the rows: widths, frozen rows, outline). */
+export function sheetHead({ widths, frozenRows, outlineLevelRow }: {
+    widths: any;
+    frozenRows: any;
+    outlineLevelRow: any;
+}): string;
+/** The rest of a worksheet after its rows: merges (they come after <sheetData>, so they can be gathered while rows stream). */
+export function sheetTail(merges: any, drawing?: boolean): string;
+export function colName(c: any): string;
+/**
+ * @typedef {{ numFmt?: string|null, bold?: boolean, fill?: boolean }} CellStyle
+ * @typedef {{ v?: any, f?: string, style?: CellStyle }} Cell
+ */
+export class Sheet {
+    /** @param {Book} book @param {string} name */
+    constructor(book: Book, name: string);
+    book: Book;
+    name: string;
+    /** @type {string[]} */ xml: string[];
+    /** @type {number[]} */ widths: number[];
+    /** @type {string[]} */ merges: string[];
+    /** @type {{ bytes: Uint8Array, ext: string, col: number, row: number, w: number, h: number }[]} */ images: {
+        bytes: Uint8Array;
+        ext: string;
+        col: number;
+        row: number;
+        w: number;
+        h: number;
+    }[];
+    rowCount: number;
+    frozenRows: number;
+    outlineLevelRow: number;
+    /**
+     * Add a row (1-based number returned). cells: one per column (null = empty).
+     * @param {(Cell|null)[]} cells @param {{ outlineLevel?: number }} [opt]
+     */
+    addRow(cells: (Cell | null)[], opt?: {
+        outlineLevel?: number;
+    }): number;
+    /** Merge (1-based, inclusive). */
+    merge(r1: any, c1: any, r2: any, c2: any): void;
+    /** A picture with its top-left at (col, row), 0-based, w × h pixels. */
+    addImage(bytes: any, ext: any, col: any, row: any, w: any, h: any): void;
+    /** @param {number} i */
+    toXml(i: number): string;
+}
+export class Book {
+    constructor({ title, creator }?: {
+        title?: string;
+        creator?: string;
+    });
+    title: string;
+    creator: string;
+    fullCalcOnLoad: boolean;
+    /** @type {Sheet[]} */ sheets: Sheet[];
+    /** @type {Map<string, number>} */ styles: Map<string, number>;
+    /** @type {Map<string, number>} */ numFmts: Map<string, number>;
+    /** @param {string} name */
+    addSheet(name: string): Sheet;
+    /** cellXfs index for a style */
+    style(st: CellStyle | undefined): number;
+    /** One <c> element. @param {string} ref @param {Cell} c */
+    cell(ref: string, c: Cell): string;
+    stylesXml(): string;
+    /** The .xlsx bytes. */
+    write(): Uint8Array<ArrayBuffer>;
+    /**
+     * The workbook's own parts, written after the sheets (their names, the styles they used): styles, workbook,
+     * relationships, properties and content types. over: [part, content type] of the sheets and drawings.
+     * @param {[string, string][]} over @returns {[string, string][]}
+     */
+    bookParts(over: [string, string][]): [string, string][];
+}
+export type CellStyle = {
+    numFmt?: string | null;
+    bold?: boolean;
+    fill?: boolean;
+};
+export type Cell = {
+    v?: any;
+    f?: string;
+    style?: CellStyle;
+};

package/dist/types/src/importers/xml.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Parse an XML document into its root element.
+ * @param {string} src
+ * @param {Partial<typeof XML_LIMITS>} [limits]
+ * @returns {XmlElement}
+ */
+export function parseXml(src: string, limits?: Partial<typeof XML_LIMITS>): XmlElement;
+/**
+ * A small XML reader for untrusted files (SSRS .rdl). Pure JavaScript, no DOM, so it runs anywhere.
+ *
+ * Safe by construction:
+ *   - no DTDs: <!DOCTYPE and <!ENTITY are refused, so there is no entity expansion (XXE, billion laughs);
+ *     only the five XML entities and character references are read;
+ *   - caps on size, nesting depth, element count and attributes per element;
+ *   - linear time: it scans with indexOf and character tests, no regular expression runs over the input.
+ *
+ * Elements come back as { name, ns, attrs, children, text }: name is the local name (prefix removed),
+ * ns the namespace URI, text the element's own character data (CDATA included).
+ */
+export class XmlError extends Error {
+}
+export namespace XML_LIMITS {
+    let maxChars: number;
+    let maxDepth: number;
+    let maxElements: number;
+    let maxAttributes: number;
+}
+export type XmlElement = {
+    name: string;
+    ns: string;
+    attrs: Record<string, string>;
+    children: XmlElement[];
+    text: string;
+};