@reportwright/engine 0.11.0 → 0.12.1

package/dist/pdfstreamworker.js

@@ -0,0 +1,38 @@
+// @ts-check
+// A paint worker of a streaming PDF (pdfstream.js, opts.parallel): it lays out the windows of rows it is sent
+// (engine/paged.js jobs, with the pages already counted) and paints their pages with the same painter and names as the
+// writer, then sends back each page's compressed content stream and what it used (fonts, glyphs, opacities). Node only.
+import { render, FontStore, __streamPaint } from './index.js';
+const { createPdfStream, paintPage, paintEnv, latin1 } = __streamPaint;
+
+const proc = /** @type {any} */ (globalThis).process;
+const { parentPort, workerData } = proc.getBuiltinModule('node:worker_threads');
+const zlib = proc.getBuiltinModule('node:zlib');
+const bytes = new Map(workerData.fonts);
+const fontStore = new FontStore(async (k) => {
+  const b = bytes.get(k);
+  if (!b) throw new Error(`The font "${k}" was not sent to the paint worker`);
+  return b;
+});
+
+parentPort.on('message', async (/** @type {any} */ job) => {
+  try {
+    const t0 = Date.now();
+    const m = await render(job.def, { ...job.opts, fontStore, sources: { __rows: { rows: job.rows } }, pageWindow: job.pageWindow });
+    // a writer of its own for the names and glyphs (nothing is written): the pages' links name pages by placeholder
+    const rec = createPdfStream({ write() {} }, { fontStore });
+    const env = paintEnv(rec, fontStore, { drillBase: job.drillBase, pageRef: (i) => `@@P${i}@@` });
+    const pages = [], transfer = [];
+    for (let k = 0; k < Math.min(job.keep, m.pages.length); k++) {
+      const pg = m.pages[k];
+      const { content, annots } = paintPage(pg, pg.height ?? job.height, env);
+      const z = new Uint8Array(zlib.deflateSync(latin1(content), { level: 9 })); // as pdfpaint.js's deflate
+      transfer.push(z.buffer);
+      pages.push({ deflated: z, annots, width: pg.width, height: pg.height, firstRow: pg.firstRow, rowHead: pg.rowHead, headLevel: pg.headLevel });
+    }
+    parentPort.postMessage({ id: job.id, count: m.pages.length, nextFirst: m.pages[job.keep]?.firstRow, pages, used: rec.used(),
+      shaped: [...env.shaped].map(([k, g]) => [k, [...g]]), bookmarks: m.bookmarks, headings: m.headings, warnings: m.warnings, ms: Date.now() - t0 }, transfer);
+  } catch (e) {
+    parentPort.postMessage({ id: job.id, error: { message: String(/** @type {any} */ (e)?.message || e), status: /** @type {any} */ (e)?.status, timeout: /** @type {any} */ (e)?.timeout } });
+  }
+});

package/dist/types/packages/engine/entry.d.ts

@@ -48,11 +48,47 @@ export function exportDocx(model: any, options?: NonNullable<Parameters<typeof e
 export function exportPptx(model: any, options?: NonNullable<Parameters<typeof exportPptxFull>[1]> & {
     fonts?: FontStore;
 }, ...args: any[]): Promise<Uint8Array>;
+/**
+ * @typedef {RenderOptions & Omit<PdfOptions, 'fonts'> & { fonts?: FontStore, tagged?: { lang?: string, maxElements?: number },
+ *   window?: number, parallel?: number, maxRows?: number, id?: string, presorted?: boolean,
+ *   spill?: false | { dir?: string, maxMB?: number }, sorter?: (cmp: (a: any, b: any) => number) => any }} PdfStreamOptions
+ *   render()'s options and exportPdf's, plus: window (rows laid out at once, 1000), parallel (Node: worker threads
+ *   that lay out and paint pages, opt-in; the file is the same, each thread costs memory), maxRows (rows read,
+ *   5,000,000), id (the file ID). presorted: the rows come in the report's order (its sort, its groups together), so
+ *   they are not sorted, only checked as they pass (a row out of order stops the export). spill: where a sort's runs go
+ *   (Node: the system temp folder, 2 GB at most; false sorts in memory); in a browser a sort is in memory.
+ */
+/**
+ * Report definition → PDF written to a sink as it is made, for reports too large to hold as a page model: a flowing
+ * table (and its groups) is laid out a window of rows at a time and each page leaves memory once written. Other
+ * reports are rendered whole and written by exportPdf in one piece (the result says why). sink: a Node Writable
+ * (fs.createWriteStream) or anything with write(bytes) that may return a promise (back-pressure); it is not closed.
+ * @param {any} def the report definition
+ * @param {PdfStreamOptions} options
+ * @param {{ write(bytes: Uint8Array): any, once?: (ev: string, cb: () => void) => any }} sink
+ * @returns {Promise<{ streamed: boolean, pages: number, warnings: string[], why?: string }>}
+ */
+export function exportPdfStream(def: any, options: PdfStreamOptions, sink: {
+    write(bytes: Uint8Array): any;
+    once?: (ev: string, cb: () => void) => any;
+}): Promise<{
+    streamed: boolean;
+    pages: number;
+    warnings: string[];
+    why?: string;
+}>;
 export { validate } from "../../src/engine/schema/validate.js";
 export { exportHtml } from "../../src/exporters/html.js";
 export { exportCsv } from "../../src/exporters/csv.js";
 export { needsExportData } from "../../src/exporters/regions.js";
 export { pageToSvg } from "../../src/exporters/svg.js";
+export namespace __streamPaint {
+    export { createPdfStream };
+    export { paintPage };
+    export { paintEnv };
+    export { latin1 };
+}
+export { planPaged } from "../../src/engine/paged.js";
 export type PdfOptions = Omit<NonNullable<Parameters<typeof exportPdfFull>[2]>, "subset" | "pdfa"> & {
     fonts?: FontStore;
     subset?: false | NonNullable<Parameters<typeof exportPdfFull>[2]>["subset"];
@@ -61,6 +97,30 @@ export type PdfOptions = Omit<NonNullable<Parameters<typeof exportPdfFull>[2]>,
         [k: string]: unknown;
     };
 };
+/**
+ * render()'s options and exportPdf's, plus: window (rows laid out at once, 1000), parallel (Node: worker threads
+ * that lay out and paint pages, opt-in; the file is the same, each thread costs memory), maxRows (rows read,
+ * 5,000,000), id (the file ID). presorted: the rows come in the report's order (its sort, its groups together), so
+ * they are not sorted, only checked as they pass (a row out of order stops the export). spill: where a sort's runs go
+ * (Node: the system temp folder, 2 GB at most; false sorts in memory); in a browser a sort is in memory.
+ */
+export type PdfStreamOptions = RenderOptions & Omit<PdfOptions, "fonts"> & {
+    fonts?: FontStore;
+    tagged?: {
+        lang?: string;
+        maxElements?: number;
+    };
+    window?: number;
+    parallel?: number;
+    maxRows?: number;
+    id?: string;
+    presorted?: boolean;
+    spill?: false | {
+        dir?: string;
+        maxMB?: number;
+    };
+    sorter?: (cmp: (a: any, b: any) => number) => any;
+};
 export type RenderOptions = import("../../src/engine/index.js").RenderOptions;
 import { FontStore } from '../../src/engine/index.js';
 import { exportXlsx as exportXlsxFull } from '../../src/exporters/xlsx.js';
@@ -68,6 +128,10 @@ import { exportDocx as exportDocxFull } from '../../src/exporters/docx.js';
 import { exportPptx as exportPptxFull } from '../../src/exporters/pptx.js';
 import { fontFile } from '../../src/engine/text/fonts.js';
 import { createSubsetter } from '../../src/exporters/subset.js';
+import { createPdfStream } from '../../src/exporters/pdfstream.js';
+import { paintPage } from '../../src/exporters/pdfstream.js';
+import { paintEnv } from '../../src/exporters/pdfstream.js';
+import { latin1 } from '../../src/exporters/pdfpaint.js';
 import { exportPdf as exportPdfFull } from '../../src/exporters/pdf.js';
 export { fontFile, createSubsetter };
 export { render, FontStore, ITEMS, parameterOptions, resolveParameters } from "../../src/engine/index.js";

package/dist/types/src/engine/data/guard.d.ts

@@ -16,11 +16,14 @@ export function redirectRequest(from: URL, to: URL, req: any, status: number): a
 /**
  * The guarded default fetch (see the top of this file). In Node every hop goes through nodeRequest (address pinned);
  * in a browser through `base` with redirects by hand (literal addresses checked; a browser has no DNS to ask).
- * @param {{ allowHosts?: string[] }} opt @param {typeof fetch} base
+ * @param {{ allowHosts?: string[], viaBase?: boolean }} opt viaBase: every hop through `base`, in Node too (the browser
+ *   viewer's fetch, which its tests run in Node)
+ * @param {typeof fetch} base
  * @returns {typeof fetch}
  */
 export function guardedFetch(opt: {
     allowHosts?: string[];
+    viaBase?: boolean;
 }, base: typeof fetch): typeof fetch;
 /**
  * Any fetch with the engine's time limit and byte cap.

package/dist/types/src/engine/data/stream.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The keys a JSONPath walks to reach the rows, when the splitter can follow it: $, $.a.b, $['a b'], with a [*] at the
+ * end at most. Null for any other path (indexes, spreads in the middle): read the whole body instead.
+ * @param {string} [path] @returns {string[]|null}
+ */
+export function splitPath(path?: string): string[] | null;
+/**
+ * The rows of a JSON body at a path, in batches, without holding the body: the bytes are scanned for the array the
+ * path names, and its elements are parsed (JSON.parse, a batch at a time) as they complete. A body whose shape the path
+ * does not meet that way (an object where the rows should be, a path with indexes) is read whole and taken through
+ * jsonPathRows, exactly as a whole-body read would: maxWholeBytes caps that case. Every cap counts the text actually read
+ * (characters), not a declared length: the body before the rows (maxWholeBytes), one row (maxElementBytes, so one huge
+ * string or a row that never ends cannot grow without bound) and the nesting (maxDepth).
+ * @param {any} body @param {string|undefined} path
+ * @param {{ maxElementBytes?: number, maxWholeBytes?: number, maxDepth?: number, batch?: number }} [o]
+ * @returns {AsyncGenerator<any[]>}
+ */
+export function jsonRows(body: any, path: string | undefined, { maxElementBytes, maxWholeBytes, maxDepth, batch }?: {
+    maxElementBytes?: number;
+    maxWholeBytes?: number;
+    maxDepth?: number;
+    batch?: number;
+}): AsyncGenerator<any[]>;
+/**
+ * CSV records as they arrive: the same reading as parseCsv (a quote opens a quoted field only at the start of a field;
+ * inside, a doubled quote is a quote and separators and line breaks are data; text after the closing quote is kept;
+ * \n, \r\n and \r end a record), across chunk boundaries.
+ * @param {any} body @param {{ sep: string, quote: string, maxFieldBytes?: number }} o @returns {AsyncGenerator<string[][]>}
+ */
+export function csvRecords(body: any, { sep, quote, maxFieldBytes }: {
+    sep: string;
+    quote: string;
+    maxFieldBytes?: number;
+}, batch?: number): AsyncGenerator<string[][]>;
+/**
+ * CSV rows as objects, as parseCsv gives them (startRow, the header row's names, blank lines dropped), in batches.
+ * headerRow: false needs every row's width first: not read this way (null).
+ * @param {any} body @param {{ separator?: string, quote?: string, headerRow?: boolean, startRow?: number }} src
+ * @param {(v: any, d: string, what: string) => string} csvChar @param {number} [maxFieldBytes]
+ */
+export function csvRows(body: any, src: {
+    separator?: string;
+    quote?: string;
+    headerRow?: boolean;
+    startRow?: number;
+}, csvChar: (v: any, d: string, what: string) => string, maxFieldBytes?: number): AsyncGenerator<{
+    [k: string]: string;
+}[], void, unknown>;

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

@@ -71,7 +71,7 @@ export class ReportError extends Error {
 }
 export const BAND_ITEMS: 250000;
 /** The start of the warning for CJK text without the optional CJK fonts (the viewer opens its warnings for it). */
-export const NO_CJK_FONTS: "Text in Japanese/Chinese/Korean needs the optional CJK fonts: npm run fonts:cjk";
+export const NO_CJK_FONTS: "Text in Japanese/Chinese/Korean needs the optional CJK fonts: npm i @reportwright/fonts-cjk, then npx reportwright-fonts-cjk (npm); in the app, npm run fonts:cjk";
 /**
  * Options for render(). All optional.
  */
@@ -216,6 +216,21 @@ export type RenderOptions = {
      * internal: the images drawn so far, shared with subreports
      */
     imageBudget?: any;
+    /**
+     * internal (paged.js): these pages are a window of a longer report: numbered from offset + 1 of total ('…' when not known
+     * yet); final: the window holds the report's last page; first: the report's first row; rowOffset: the rows before this
+     * window; cont: per group level, the group the window's first row continues (its first row), or null
+     */
+    pageWindow?: {
+        offset: number;
+        total?: number | null;
+        final: boolean;
+        first?: any;
+        rowOffset?: number;
+        cont?: ({
+            first: any;
+        } | null)[];
+    };
 };
 import { FontStore } from './text/fonts.js';
 import { TextMeasurer } from './text/measure.js';

package/dist/types/src/engine/items/chart-kit.d.ts

@@ -10,6 +10,12 @@ export function niceScale(min: any, max: any, ticks?: number): {
     hi: number;
     step: number;
 };
+/** A nice scale whose step is the span over the ticks: niceScale rounds the span first, which can add a whole step. */
+export function niceScaleSpan(min: any, max: any, ticks?: number): {
+    lo: number;
+    hi: number;
+    step: number;
+};
 /** Ticks from lo to hi by step, rounded so 0.1 + 0.2 reads 0.3. At most 200 (a bad min/max cannot loop for ever). */
 export function linearTicks(lo: any, hi: any, step: any): any[];
 /** Powers of ten covering [min, max] (both > 0); at least two. */

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

@@ -0,0 +1,19 @@
+/**
+ * @param {any} def0 @param {any} opts render() options, and maxRows/sorter/sqlRows as planStream takes them;
+ *   window: rows per window (tests)
+ * @returns {Promise<{ why: string } | { why?: undefined, pages: () => AsyncGenerator<any>, info: { width: number, height: number, bookmarks: any[], headings: any[], warnings: string[], pages: number } }>}
+ */
+export function planPaged(def0: any, opts?: any): Promise<{
+    why: string;
+} | {
+    why?: undefined;
+    pages: () => AsyncGenerator<any>;
+    info: {
+        width: number;
+        height: number;
+        bookmarks: any[];
+        headings: any[];
+        warnings: string[];
+        pages: number;
+    };
+}>;

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

@@ -0,0 +1,56 @@
+/**
+ * An in-memory sorter (the browser, the CLI): the server passes one that spills runs to disk (exporters/spill.js; exportPdfStream's default in Node).
+ * @param {(a: any, b: any) => number} cmp
+ */
+export function memorySorter(cmp: (a: any, b: any) => number): {
+    push(r: any): void;
+    drain(): AsyncGenerator<any, void, unknown>;
+    close(): Promise<void>;
+};
+/**
+ * @param {any} def0 the report definition
+ * @param {{ format: 'csv'|'xlsx', parameters?: object, timeZone?: string, now?: Date, state?: any, loadReport?: (id: string) => Promise<any>,
+ *   reportId?: string, fetch?: typeof fetch, baseUrl?: string, sql?: (src: any, p: any) => Promise<object[]>,
+ *   sqlRows?: (src: any, p: any) => AsyncIterable<object[]>, sources?: Record<string, any>, sorter?: (cmp: (a: any, b: any) => number) => any, presorted?: boolean,
+ *   deadline?: number, timeoutMs?: number, maxRows?: number, maxJsonRowBytes?: number, maxJsonWholeBytes?: number }} opts
+ * @returns {Promise<{ why: string } | { why?: undefined, name: string, columns: number[], title: string, timeZone: string|null, locale: string|null, currency: string|null, warnings: string[], rows: () => AsyncGenerator<any>, records: () => AsyncGenerator<any>, grouped: () => AsyncGenerator<any>, fieldList: () => Promise<any[]>, stats: { rows: number } }>}
+ */
+export function planStream(def0: any, opts: {
+    format: "csv" | "xlsx";
+    parameters?: object;
+    timeZone?: string;
+    now?: Date;
+    state?: any;
+    loadReport?: (id: string) => Promise<any>;
+    reportId?: string;
+    fetch?: typeof fetch;
+    baseUrl?: string;
+    sql?: (src: any, p: any) => Promise<object[]>;
+    sqlRows?: (src: any, p: any) => AsyncIterable<object[]>;
+    sources?: Record<string, any>;
+    sorter?: (cmp: (a: any, b: any) => number) => any;
+    presorted?: boolean;
+    deadline?: number;
+    timeoutMs?: number;
+    maxRows?: number;
+    maxJsonRowBytes?: number;
+    maxJsonWholeBytes?: number;
+}): Promise<{
+    why: string;
+} | {
+    why?: undefined;
+    name: string;
+    columns: number[];
+    title: string;
+    timeZone: string | null;
+    locale: string | null;
+    currency: string | null;
+    warnings: string[];
+    rows: () => AsyncGenerator<any>;
+    records: () => AsyncGenerator<any>;
+    grouped: () => AsyncGenerator<any>;
+    fieldList: () => Promise<any[]>;
+    stats: {
+        rows: number;
+    };
+}>;

package/dist/types/src/engine/text/measure.d.ts

@@ -19,6 +19,8 @@ export function saBreaks(text: string, segmenter?: Intl.Segmenter | null): Set<n
  * @param {any[]} items @param {TextMeasurer} m
  */
 export function finishText(items: any[], m: TextMeasurer): void;
+/** Unicode format characters (Cf): bidi marks and embeddings, joiners, soft hyphen. They have no shape of their own. */
+export const FORMAT_CHAR: RegExp;
 /**
  * @typedef {{ font: string, x: number, w: number, text: string, rtl?: boolean, shaped?: boolean, glyphs: number[] }} Run
  *   One font, one direction. x and w in points from the start of the line; glyphs: [id, x, y, cluster] per glyph

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

@@ -1,9 +1,12 @@
+/** The string cut into pieces of at most about max chars, each ending at a '>' (a tag boundary), so their join is s. */
+export function slices(s: any, max: any): any[];
 /** 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]
+ *   rasterize?: (svg: string, w: number, h: number, scale: number) => Promise<Uint8Array|null>, figures?: boolean, xmlChunk?: number }} [opt]
+ *   xmlChunk: the document XML is written to the zip in pieces of about this many chars (default 4M; tests lower it)
  *   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>}
@@ -16,4 +19,5 @@ export function exportDocx(model: any, opt?: {
     fetchImage?: (src: string) => Promise<Uint8Array | null>;
     rasterize?: (svg: string, w: number, h: number, scale: number) => Promise<Uint8Array | null>;
     figures?: boolean;
+    xmlChunk?: number;
 }): Promise<Uint8Array>;

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

@@ -4,12 +4,15 @@
  * 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.
+ * exportHtml(model, { fonts, ...options }). The 0.7 form exportHtml(model, fontStore, options) still works (deprecated).
  * @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]
+ * @param {{ fonts?: import('../engine/text/fonts.js').FontStore, fontStore?: import('../engine/text/fonts.js').FontStore, 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>, timeoutMs?: number } | import('../engine/text/fonts.js').FontStore} [options]
+ * @param {any} [legacyOpt] the options of the 0.7 form
  */
-export function exportHtml(model: any, fontStore: import("../engine/text/fonts.js").FontStore, opt?: {
+export function exportHtml(model: any, options?: {
+    fonts?: import("../engine/text/fonts.js").FontStore;
+    fontStore?: import("../engine/text/fonts.js").FontStore;
     title?: string;
     drillBase?: string;
     subset?: (font: Uint8Array, cps: Iterable<number>, o?: {
@@ -20,5 +23,6 @@ export function exportHtml(model: any, fontStore: import("../engine/text/fonts.j
     currency?: string;
     lang?: string;
     strings?: Partial<typeof DATA_STRINGS>;
-}): any;
+    timeoutMs?: number;
+} | import("../engine/text/fonts.js").FontStore, legacyOpt?: any): Promise<string>;
 import { DATA_STRINGS } from './htmldata.js';

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

@@ -20,6 +20,17 @@ export function makePdfA(doc: import("pdf-lib").PDFDocument, { icc, title, autho
  * @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

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

@@ -0,0 +1,99 @@
+export function drawRun(c: any, run: any, x: any, y: any, size: any, pf: any, color: any, spans: any, texts: any): 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;
+    /** tagged, lines wait all the same and are drawn as one artifact (the streamed PDF's painter sets it) */
+    artLines: 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;