@reportwright/engine 0.0.0-stage → 0.12.0

package/dist/types/src/engine/units.d.ts

@@ -0,0 +1,53 @@
+/** @param {number} v @param {keyof UNITS} unit */
+export function toPt(v: number, unit: "pt" | "in" | "cm" | "mm" | "px"): number;
+/** @param {number} pt @param {keyof UNITS} unit */
+export function fromPt(pt: number, unit: "pt" | "in" | "cm" | "mm" | "px"): number;
+/**
+ * @param {{size?: string, width?: number, height?: number, orientation?: string, margins?: number[]|number}} page
+ */
+/** A size name as the engine reads it: trimmed, case-insensitive ("a4 " -> "A4"); undefined when it names no size. */
+export function normalizePageSize(size: any): string;
+export function resolvePage(page?: {}): {
+    width: number;
+    height: number;
+    margins: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    bodyWidth: number;
+    pageless: boolean;
+    minHeight: number;
+} | {
+    width: any;
+    height: any;
+    margins: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    bodyWidth: number;
+    pageless?: undefined;
+    minHeight?: undefined;
+};
+/** CSS-like box shorthand → [top, right, bottom, left] */
+export function normBox(v: any): number[];
+export namespace PAGE_SIZES {
+    let A4: number[];
+    let A5: number[];
+    let A3: number[];
+    let Letter: number[];
+    let Legal: number[];
+}
+export namespace UNITS {
+    export let pt: number;
+    let _in: number;
+    export { _in as in };
+    export let cm: number;
+    export let mm: number;
+    export let px: number;
+}
+/** A pageless report grows to fit its content, up to the largest PDF page (200 inches). */
+export const PAGELESS_MAX: 14400;

package/dist/types/src/engine/url.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The one allow-list for links the engine emits (url actions, rich text <a href>), checked on the exact
+ * string that is emitted. Browsers and PDF readers parse URLs leniently (they drop tabs and newlines before
+ * the scheme, read "\" as "/", take "https:x" and "//host" as absolute), so the rule is strict:
+ * - no character at or below U+0020, no DEL or C1 control, no backslash;
+ * - http:// or https:// with a host (double slash required), or mailto:;
+ * - a relative path that starts with one "/" (not "//").
+ * @param {unknown} v
+ * @returns {string|null} v itself when allowed, else null
+ */
+export function safeUrl(v: unknown): string | null;
+/**
+ * A drill-through's address in the ReportWright viewer: `<base>/viewer/<report>?<parameters>` (a list parameter
+ * repeats its name), checked by safeUrl; null without a base URL or a report. The HTML and PDF exports link to it.
+ * @param {string|undefined|null} base @param {{ report?: string, params?: Record<string, any> }} a @returns {string|null}
+ */
+export function drillUrl(base: string | undefined | null, a: {
+    report?: string;
+    params?: Record<string, any>;
+}): string | null;
+/** A URL as a PDF URI action may hold it: 7-bit ASCII (an international host as punycode, other characters
+ *  percent-encoded). @param {string} href @returns {string} */
+export function asciiUrl(href: string): string;

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

@@ -0,0 +1,9 @@
+/** @returns {{r:number,g:number,b:number,a:number}|null} channels 0..1 */
+export function parseColor(c: any): {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+} | null;
+/** Safe color for SVG/HTML attributes. */
+export function cssColor(c: any): string;

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

@@ -0,0 +1,44 @@
+/**
+ * CSV of the report's data: one header row and the detail rows of the main table (the one with the most detail rows),
+ * numbers without symbols or separators, dates in ISO form. Group headers, subtotals, totals and other tables are left
+ * out. layout: true gives the printed layout instead: every table with its name and every row (group lines, totals).
+ * @param {any} model @param {{ all?: boolean, layout?: boolean, locale?: string, currency?: string }} [o]
+ */
+export function exportCsv(model: any, { all, layout, locale, currency }?: {
+    all?: boolean;
+    layout?: boolean;
+    locale?: string;
+    currency?: string;
+}): string;
+/**
+ * A CSV line from a region row (one value per column, empty where no cell starts). Shared by exportCsv and the streaming
+ * writer (writeCsvStream), so both write the same bytes.
+ * @param {{ timeZone?: string|null, locale?: string, currency?: string }} o
+ */
+export function csvLine({ timeZone, locale, currency }: {
+    timeZone?: string | null;
+    locale?: string;
+    currency?: string;
+}): (ncols: any, row: any) => string;
+/** The data CSV's header line: header rows stacked into one, a cell spanning columns naming each of them ("Who Id"). */
+export function csvNames(ncols: any): {
+    /** @param {{ cells: any[] }} row */
+    add(row: {
+        cells: any[];
+    }): void;
+    line: () => string;
+};
+/**
+ * The data CSV of a streaming plan (engine/stream.js), written as its rows come: the same bytes exportCsv writes for the
+ * model of that report. put(text) may return a promise (back-pressure): it is awaited.
+ * @param {{ columns: number[], timeZone: string|null, rows: () => AsyncGenerator<any> }} plan
+ * @param {(s: string) => any} put @param {{ locale?: string, currency?: string }} [o]
+ */
+export function writeCsvStream(plan: {
+    columns: number[];
+    timeZone: string | null;
+    rows: () => AsyncGenerator<any>;
+}, put: (s: string) => any, { locale, currency }?: {
+    locale?: string;
+    currency?: string;
+}): Promise<void>;

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

@@ -0,0 +1,6 @@
+/**
+ * An export bounded by opt.timeoutMs: past it the promise rejects with status 504. The work itself is not stopped
+ * (a server render runs in a worker that the pool terminates); the caller is not left waiting.
+ * @template T @param {Promise<T>} work @param {number|undefined} ms @returns {Promise<T>}
+ */
+export function withDeadline<T>(work: Promise<T>, ms: number | undefined): Promise<T>;

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

@@ -0,0 +1,19 @@
+/** Left, right or centre, from where the lines sit in their box. */
+export function alignOf(it: any): "center" | "left" | "right" | "both";
+/**
+ * @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>, figures?: boolean }} [opt]
+ *   fontStore: text in pictures as outlines (else the reader's fallback font); fetchImage: pictures by URL;
+ *   rasterize: the PNG fallback of a picture (default: a canvas in a browser, sharp in Node); figures: false leaves them out.
+ * @returns {Promise<Uint8Array>}
+ */
+export function exportDocx(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>;
+    figures?: boolean;
+}): Promise<Uint8Array>;

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

@@ -0,0 +1,39 @@
+/**
+ * Algorithm 2.B: the hash of a password, a salt and (for the owner) the U string.
+ * @param {Uint8Array} pw @param {Uint8Array} salt @param {Uint8Array} udata
+ */
+export function hash2B(pw: Uint8Array, salt: Uint8Array, udata: Uint8Array): Promise<Uint8Array<ArrayBuffer>>;
+/** A password as the handler wants it: NFKC (SASLprep's main step), UTF-8, at most 127 bytes. */
+export function passwordBytes(pw: any, which: any): Uint8Array<ArrayBuffer>;
+/** /P: reserved bits 7, 8 and 13–32 set, 1–2 clear; each permission allowed unless set to false. */
+export function permissionsValue(perms?: {}): number;
+/**
+ * Encrypt a pdf-lib document in place.
+ * @param {import('pdf-lib').PDFDocument} doc
+ * @param {{ userPassword?: string, ownerPassword?: string, permissions?: Record<string, boolean> }} opt
+ */
+export function encryptPdf(doc: import("pdf-lib").PDFDocument, opt: {
+    userPassword?: string;
+    ownerPassword?: string;
+    permissions?: Record<string, boolean>;
+}): Promise<void>;
+/**
+ * The `pdf` option of an API request or the CLI → encryptPdf options, or undefined for no password.
+ * Checks the shape (400 on anything else); the passwords themselves are checked in passwordBytes.
+ * @param {any} pdf { userPassword?, ownerPassword?, permissions?: { print?: boolean, … } }
+ */
+export function pdfEncryptOptions(pdf: any): {
+    userPassword: any;
+    ownerPassword: any;
+    permissions: any;
+};
+export namespace PERMISSION_BITS {
+    let print: number;
+    let modify: number;
+    let copy: number;
+    let annotate: number;
+    let fillForms: number;
+    let accessibility: number;
+    let assemble: number;
+    let printHighQuality: number;
+}

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

@@ -0,0 +1,112 @@
+/**
+ * The figures of a page, in page order: { tag, items, at, box } (at: index of the first item). A figure's items are
+ * consecutive in the page. One tag id marks one figure, also in a model that went through JSON (a tag copy per item).
+ * @param {any[]} items page items
+ */
+export function figures(items: any[]): any[];
+/** Bounding box of page items (links and bookmarks left out), or null. @param {any[]} items */
+export function boxOf(items: any[]): {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+};
+/**
+ * A conservative bounding box of SVG path data: every end and control point, and an arc's end ± its radii.
+ * @param {string} d
+ */
+export function pathBox(d: string): {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+};
+/**
+ * Text as glyph outlines (SVG path data), where the engine placed it. Plain lines advance by the glyphs' own widths
+ * (as the engine measured them); shaped runs place each glyph by ID.
+ * @param {any} it a text item  @param {(key: string) => any} fontOf fontkit font or null
+ * @returns {string|null} null when a font is missing
+ */
+export function textOutline(it: any, fontOf: (key: string) => any): string | null;
+/**
+ * The SVG of a figure: its items in their own box, text as outlines when the fonts are there.
+ * @param {{ items: any[], box: { x: number, y: number, w: number, h: number } }} fig
+ * @param {{ get: (key: string) => any } | null} [fontStore]
+ */
+export function figureSvg(fig: {
+    items: any[];
+    box: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+}, fontStore?: {
+    get: (key: string) => any;
+} | null): string;
+/**
+ * PNG bytes of an SVG, `scale` pixels per point: opt.rasterize when given (the caller's own), else a canvas in a
+ * browser, else sharp in Node (Next.js installs it). Null when none of them is there.
+ * @param {string} svg @param {number} w @param {number} h (points)
+ * @param {{ rasterize?: (svg: string, w: number, h: number, scale: number) => Promise<Uint8Array|null>, scale?: number }} [opt]
+ * @returns {Promise<Uint8Array|null>}
+ */
+export function rasterize(svg: string, w: number, h: number, opt?: {
+    rasterize?: (svg: string, w: number, h: number, scale: number) => Promise<Uint8Array | null>;
+    scale?: number;
+}): Promise<Uint8Array | null>;
+/**
+ * A figure as picture parts: { png?, svg?, jpeg?, w, h, x, y } (where and how big it is drawn, in points). A figure that is one picture (an image item, maybe in a box)
+ * keeps the picture's own bytes; anything else is drawn as SVG and rasterised.
+ * @param {any} fig @param {{ fontStore?: any, fetchImage?: (src: string) => Promise<Uint8Array|null>, rasterize?: any }} opt
+ */
+export function figurePicture(fig: any, opt?: {
+    fontStore?: any;
+    fetchImage?: (src: string) => Promise<Uint8Array | null>;
+    rasterize?: any;
+}): Promise<{
+    [x: string]: any;
+    w: any;
+    h: any;
+    x: any;
+    y: any;
+    svg?: undefined;
+    png?: undefined;
+} | {
+    svg: string;
+    png: Uint8Array<ArrayBufferLike>;
+    w: any;
+    h: any;
+    x: any;
+    y: any;
+}>;
+/** base64 of bytes (Node or browser). @param {Uint8Array} u8 */
+export function b64(u8: Uint8Array): string;
+/**
+ * The box a text item was painted in (paintBox: background rect, the text, its decoration lines, then the border
+ * lines or one rounded border rect), read back from the items around it: { fill, radius, sides: { top, right, bottom, left } }.
+ * @param {any[]} items @param {number} i the text item's index
+ */
+export function boxDecor(items: any[], i: number): {
+    fill: string;
+    radius: number;
+    sides: Record<string, any>;
+};
+/**
+ * The in-cell visuals of the tables on a page (sparklines, data bars, icons that a table cell draws; the engine does
+ * not tag those): shapes inside a table's rows that are not a cell's background. Each becomes a picture in its cell.
+ * Found by position: a visual in a row with no text cell at all is not found (it stays out).
+ * @param {any[]} items @param {Set<number>} used indexes already taken (marked here too)
+ * @param {Map<string, { cells: any[] }>} tables table key → its cell text items (with cell tags and clips)
+ * @returns {Map<string, Map<string, { items: any[], box: any }>>} table key → `${row}|${col}` → the visual
+ */
+export function cellVisuals(items: any[], used: Set<number>, tables: Map<string, {
+    cells: any[];
+}>): Map<string, Map<string, {
+    items: any[];
+    box: any;
+}>>;
+/** Item kinds that are pictures in Word and PowerPoint (a heading tag alone is not). */
+export const FIGURE_KINDS: Set<string>;
+export function hexOrNull(c: any): string;
+export function altOf(tag: any): any;

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

@@ -0,0 +1,24 @@
+/**
+ * One self-contained HTML file: every page as inline SVG, fonts embedded as
+ * base64 (subset when a subsetter is given). URLs open, bookmark jumps and TOC entries scroll to their target, and
+ * drill-through opens the ReportWright viewer at drillBase (without one it is shown disabled).
+ * Unless static, a file whose report has tables also gets a Tables view (htmldata.js): the tables as HTML, re-sorted on
+ * their interactive-sort columns, groups opened and closed, rows filtered, by one inline script the file's CSP allows.
+ * @param {any} model
+ * @param {import('../engine/text/fonts.js').FontStore} fontStore
+ * @param {{ title?: string, drillBase?: string, subset?: (font: Uint8Array, cps: Iterable<number>, o?: { layout?: boolean }) => Promise<Uint8Array>,
+ *   static?: boolean, locale?: string, currency?: string, lang?: string, strings?: Partial<typeof DATA_STRINGS> }} [opt]
+ */
+export function exportHtml(model: any, fontStore: import("../engine/text/fonts.js").FontStore, opt?: {
+    title?: string;
+    drillBase?: string;
+    subset?: (font: Uint8Array, cps: Iterable<number>, o?: {
+        layout?: boolean;
+    }) => Promise<Uint8Array>;
+    static?: boolean;
+    locale?: string;
+    currency?: string;
+    lang?: string;
+    strings?: Partial<typeof DATA_STRINGS>;
+}): any;
+import { DATA_STRINGS } from './htmldata.js';

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

@@ -0,0 +1,32 @@
+/**
+ * The tables of a model as the view's data, or null (no tables, or too many rows).
+ * Each row: { k: kind, l: level, c: [[col, text, key, span]] } (key: a number, or text in lower case, for sorting).
+ * sort: the columns the report sorts on click (its interactive-sort header cells, matched by position).
+ * @param {any} model @param {{ locale?: string, currency?: string }} [o]
+ */
+export function tablesData(model: any, o?: {
+    locale?: string;
+    currency?: string;
+}): {
+    name: string;
+    cols: any;
+    sort: any[];
+    rows: any;
+}[];
+/** sha256 of a text, base64 (a CSP hash). */
+export function cspHash(text: any): Promise<string>;
+/** Most rows a file carries for the Tables view (beyond it, the file stays pages only). */
+export const MAX_DATA_ROWS: 20000;
+export namespace DATA_STRINGS {
+    let pages: string;
+    let tables: string;
+    let all: string;
+    let filter: string;
+    let toggle: string;
+    let sortAsc: string;
+    let sortDesc: string;
+}
+/** The script of the Tables view (a constant: its hash goes in the file's CSP). @type {string} */
+export const DATA_SCRIPT: string;
+/** CSS of the bar and the Tables view. @type {string} */
+export const DATA_CSS: string;

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

@@ -0,0 +1,45 @@
+/**
+ * Page model → PDF bytes. Draws exactly the lines the engine made.
+ * @param {any} model  render() output
+ * @param {import('../engine/text/fonts.js').FontStore} fontStore
+ * @param {{ title?: string, author?: string, fetchImage?: (src: string) => Promise<Uint8Array|null>,
+ *   subset?: (font: Uint8Array, codePoints: Iterable<number>) => Promise<Uint8Array>,
+ *   pdfa?: { icc?: Uint8Array }, prepare?: (doc: PDFDocument) => any, save?: object,
+ *   encrypt?: { userPassword?: string, ownerPassword?: string, permissions?: Partial<Record<keyof typeof import('./encrypt.js').PERMISSION_BITS, boolean>> },
+ *   tagged?: { lang?: string }, drillBase?: string, onWarning?: (message: string) => void, timeoutMs?: number,
+ *   creationDate?: Date }} [opt]
+ *   subset: a HarfBuzz subsetter (see subset.js). Without it, fonts embed in full.
+ *   pdfa: make a PDF/A-2b file (needs an sRGB ICC profile). prepare: last change before saving
+ *   (the server adds a signature placeholder there). save: extra pdf-lib save options.
+ *   encrypt: { userPassword, ownerPassword, permissions } — AES-256 (see encrypt.js); not with pdfa or prepare.
+ *   tagged: an accessible PDF (PDF/UA-1, see pdfua.js): structure tree, marked content, artifacts, language, title
+ *   shown; with pdfa it is PDF/A-2a. Off, the file is exactly what it was.
+ *   drillBase: the ReportWright server whose viewer a drill-through opens (a URI link); without it a drill-through
+ *   is not a link. onWarning: what was left out (a damaged image). timeoutMs: the export's time limit (504).
+ *   creationDate: the file's dates (UTC); else SOURCE_DATE_EPOCH when set; with either, the same report exports to the
+ *   same bytes (encryption keeps its random key, so it does not).
+ */
+export function exportPdf(model: any, fontStore: import("../engine/text/fonts.js").FontStore, opt?: {
+    title?: string;
+    author?: string;
+    fetchImage?: (src: string) => Promise<Uint8Array | null>;
+    subset?: (font: Uint8Array, codePoints: Iterable<number>) => Promise<Uint8Array>;
+    pdfa?: {
+        icc?: Uint8Array;
+    };
+    prepare?: (doc: PDFDocument) => any;
+    save?: object;
+    encrypt?: {
+        userPassword?: string;
+        ownerPassword?: string;
+        permissions?: Partial<Record<keyof typeof import("./encrypt.js").PERMISSION_BITS, boolean>>;
+    };
+    tagged?: {
+        lang?: string;
+    };
+    drillBase?: string;
+    onWarning?: (message: string) => void;
+    timeoutMs?: number;
+    creationDate?: Date;
+}): any;
+import { PDFDocument } from 'pdf-lib';

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

@@ -0,0 +1,42 @@
+/**
+ * @param {import('pdf-lib').PDFDocument} doc  call after all pages, fields and annotations are added
+ * @param {{ icc?: Uint8Array, title?: string, author?: string, created?: Date, conformance?: 'A'|'B', ua?: boolean, id?: string }} opt
+ *   id: the file identifier as hex (derived from the content for a fixed date), else random
+ *   icc: an RGB ICC profile (the sRGB one in public/icc). conformance A (PDF/A-2a) for a tagged file; ua: it is PDF/UA-1 too.
+ */
+export function makePdfA(doc: import("pdf-lib").PDFDocument, { icc, title, author, created, conformance, ua, id }?: {
+    icc?: Uint8Array;
+    title?: string;
+    author?: string;
+    created?: Date;
+    conformance?: "A" | "B";
+    ua?: boolean;
+    id?: string;
+}): void;
+/**
+ * The Info dictionary's CreationDate and ModDate for an instant, in UTC (D:…+00'00'): the same instant gives the
+ * same bytes in any time zone. pdf-lib's own setters write the local offset.
+ * @param {import('pdf-lib').PDFDocument} doc
+ * @param {Date} when
+ */
+export function setInfoDates(doc: import("pdf-lib").PDFDocument, when: Date): void;
+/**
+ * The XMP metadata packet: title, author, dates, and the PDF/A and PDF/UA identifiers when asked.
+ * @param {{ title: string, author?: string, stamp: string, pdfa?: string|null, ua?: boolean }} o
+ */
+export function xmpPacket({ title, author, stamp, pdfa, ua }: {
+    title: string;
+    author?: string;
+    stamp: string;
+    pdfa?: string | null;
+    ua?: boolean;
+}): string;
+/**
+ * PDF/UA-1 without PDF/A: XMP metadata with the title and the PDF/UA identifier (the Info dictionary says the same).
+ * @param {import('pdf-lib').PDFDocument} doc
+ */
+export function setUaMetadata(doc: import("pdf-lib").PDFDocument, { title, author, created }?: {
+    title?: string;
+    author?: any;
+    created?: Date;
+}): void;

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

@@ -0,0 +1,107 @@
+/**
+ * Draw one run of shaped glyphs by ID, where the engine placed them: a TJ array whose numbers move each
+ * glyph from where the font's own advance (the W array) leaves it to the shaper's position; marks that sit
+ * higher or lower use the text rise. /ActualText gives copy and search the characters: for a left-to-right
+ * run the whole run in reading order; a right-to-left run (drawn in visual order, which readers reorder
+ * themselves) reads through ToUnicode, glyph by glyph, and only a cluster ToUnicode cannot spell gets a span
+ * (`spans`, from glyphText); glyphs that stand for nothing (`texts`: '') go last. A span per joined letter, and
+ * the dots of joined letters drawn among the letters, made pdftotext split words ("الج ميل", "الت قن ية").
+ * @param {Content} c @param {Set<number>} [spans] @param {Map<number, string>} [texts]
+ */
+export function drawRun(c: Content, run: any, x: any, y: any, size: any, pf: any, color: any, spans?: Set<number>, texts?: Map<number, string>): void;
+/**
+ * The text each shaped glyph stands for, for the font's ToUnicode map: the character whose own (character-map)
+ * glyph it is; the characters of its cluster that have no glyph of their own there (a conjunct, a joined
+ * Arabic form, a reph) go to ONE glyph, the first that is not a mark, and the cluster's other glyphs (dots,
+ * marks) stand for nothing, so a reader gets each character once. A glyph keeps its first text: a
+ * right-to-left cluster that would read differently with the texts already set goes into `spans` (drawRun
+ * gives it /ActualText). Left-to-right runs always get one span for the whole run.
+ * @param {any} run @param {any} font fontkit font @param {Map<number, string>} out
+ * @param {WeakMap<any, Set<number>>} [spans]
+ */
+export function glyphText(run: any, font: any, out: Map<number, string>, spans?: WeakMap<any, Set<number>>): void;
+/**
+ * Text inside its clip box needs no clip: the lines' advances within it across, the font's ascent and descent
+ * within it down. A cell's text almost always fits, and a clip per cell is most of a table page's operators.
+ */
+export function insideClip(it: any, m: any): any;
+/** one byte per char: the content stream holds the glyph bytes of literal strings as chars 0–255 */
+export function latin1(s: any): any;
+/**
+ * zlib (Flate) compression: Node's zlib on its thread pool (pages compress in parallel, off the main thread), else
+ * the platform's CompressionStream (browsers; in Node it is the same zlib behind web streams, slower), else fflate.
+ */
+export function deflate(bytes: any): Promise<any>;
+export function col(c: any): any;
+export namespace BLACK {
+    let color: import("pdf-lib").RGB;
+    let opacity: number;
+    let rgb: string;
+}
+export function n2(v: any): number;
+export function n3(v: any): number;
+export function n4(v: any): number;
+export function hex4(id: any): any;
+export const KAPPA: number;
+export function cleanText(t: any): any;
+/**
+ * A page's operators as text. The graphics state is tracked, so a colour, line width, dash, opacity or font
+ * that is already set is not set again; q/Q save and restore it as the PDF does.
+ */
+export class Content {
+    constructor(shared: any);
+    shared: any;
+    _s: string;
+    bt: boolean;
+    tx: number;
+    ty: number;
+    st: {
+        fill: string;
+        stroke: string;
+        lw: number;
+        dash: string;
+        ca: number;
+        CA: number;
+        font: string;
+        size: number;
+    };
+    /** @type {any[]} */ saved: any[];
+    /** straight lines waiting to be drawn after the text around them: { key, stroke, w, dash, segs: [x1, y1, x2, y2][] } */
+    lines: any;
+    tagged: boolean;
+    set s(v: string);
+    /**
+     * The operators so far. Any other drawing reads or appends to it, so the lines waiting are drawn first: the text
+     * of a table's cells stays in one text object (relative moves, which compress to little) instead of one per cell.
+     */
+    get s(): string;
+    /**
+     * A straight line. Untagged, it waits until something other than text is drawn (table borders between cell
+     * texts); collinear segments that touch, in the same stroke, become one (a row's border is one line).
+     * ponytail: lines move after the text drawn just after them; both are thin and do not cover each other.
+     */
+    line(stroke: any, w: any, dash: any, x1: any, y1: any, x2: any, y2: any): void;
+    flushLines(): void;
+    q(): void;
+    Q(): void;
+    /**
+     * A line of plain text at (x, y). Lines follow one another in one text object, each placed relative to the
+     * last (in whole hundredths, so nothing drifts): most of a table page is these.
+     * @param {string} str the glyphs, as a literal string's escaped body (array: a TJ array's body)
+     */
+    text(pf: any, size: any, color: any, x: any, y: any, str: string, array?: boolean): void;
+    /** end the open text object, if any: anything but text needs that (and draws the lines waiting) */
+    et(): void;
+    lineWidth(w: any): void;
+    setLineWidth(w: any): void;
+    /** the graphics state that sets these opacities, or undefined when they are set already */
+    gsFor(ca: any, CA: any): any;
+    alpha(ca: any, CA: any): void;
+    setAlpha(ca: any, CA: any): void;
+    /** set up to fill with fill and/or stroke with stroke (width w, dash); the lines waiting are drawn first */
+    paint(fill: any, stroke: any, w?: number, dash?: any): void;
+    setPaint(fill: any, stroke: any, w?: number, dash?: any): void;
+    font(pf: any, size: any): void;
+    setFont(pf: any, size: any): void;
+}
+export const NODE_ZLIB: any;