@cj-tech-master/excelts 9.5.4 → 9.5.5

package/dist/browser/modules/pdf/word-bridge.d.ts

@@ -1,9 +1,27 @@
 /**
  * Word-to-PDF Bridge
  *
- * Converts a Word document (DocxDocument) to PDF.
- * Like excel-bridge.ts, this is the ONLY file in the PDF module that imports
- * from @word.
+ * Converts a Word document (`DocxDocument`) to PDF.
+ *
+ * The bridge is a thin translation layer:
+ *
+ *   DocxDocument
+ *      │
+ *      │  layoutDocumentFull()  ← @word/layout
+ *      ▼
+ *   LayoutDocument (positioned PageContent variants)
+ *      │
+ *      │  renderLayoutDocumentToPdf()  ← ./render-layout-to-pdf
+ *      ▼
+ *   PdfDocumentBuilder → bytes
+ *
+ * Every flow decision (line wrapping, page breaks, table sizing,
+ * float positioning) lives in `@word/layout`. This file only handles
+ * option mapping, optional chart-renderer auto-detection, and the
+ * final `builder.build()` serialization.
+ *
+ * Like `excel-bridge.ts`, this is the ONLY file in the PDF module that
+ * imports from `@word`.
  *
  * @example
  * ```typescript
@@ -13,11 +31,9 @@
  * const doc = await readDocx(docxBytes);
  * const pdfBytes = await docxToPdf(doc);
  * ```
- *
- * Note: This is a simple flow-based renderer. For high-fidelity output,
- * consider using Microsoft Word or LibreOffice.
  */
-import type { DocxDocument } from "../word/types.js";
+import type { Chart, DocxDocument } from "../word/types.js";
+import type { PdfPageBuilder } from "./builder/document-builder.js";
 /** Options for DOCX → PDF conversion. */
 export interface DocxToPdfOptions {
     /** Page width in points (default: from document sectPr or 612 US Letter). */
@@ -32,16 +48,68 @@ export interface DocxToPdfOptions {
     readonly marginLeft?: number;
     /** Right margin in points (default: from sectPr or 72). */
     readonly marginRight?: number;
-    /** Default font family (default: "Times-Roman"). */
+    /** Default font family (default: "Helvetica"). */
     readonly defaultFont?: string;
     /** Default font size in points (default: 11). */
     readonly defaultFontSize?: number;
+    /**
+     * Header margin from top edge in points (default: 36).
+     *
+     * @deprecated Currently has no effect on the layout-driven render
+     * path: header paragraphs are rendered into the page's `marginTop`
+     * strip starting at y=0 without an additional offset. Influence
+     * header placement by widening `marginTop` instead.
+     */
+    readonly headerMargin?: number;
+    /**
+     * Footer margin from bottom edge in points (default: 36).
+     *
+     * @deprecated See {@link DocxToPdfOptions.headerMargin}. Footer
+     * paragraphs are rendered starting at `pageHeight - marginBottom`.
+     */
+    readonly footerMargin?: number;
+    /**
+     * Optional high-quality chart renderer callback.
+     *
+     * When provided, Word charts are rendered using the injected renderer
+     * instead of the built-in simplified renderer. This allows consumers
+     * to plug in the Excel chart renderer for publication-quality output:
+     *
+     * ```typescript
+     * import { installChartSupport } from "excelts/chart";
+     * import { createWordChartPdfRenderer } from "excelts/pdf";
+     * installChartSupport();
+     * const pdfBytes = await docxToPdf(doc, {
+     *   chartRenderer: createWordChartPdfRenderer()
+     * });
+     * ```
+     *
+     * The callback receives the original Word `Chart` definition (taken
+     * from the source `ChartContent`), a `PdfPageBuilder`, and the
+     * destination rectangle in PDF coordinates. The implementation
+     * should draw the chart into the rectangle.
+     *
+     * Return `false` to decline a chart (the translator then falls back
+     * to its built-in placeholder rendering: an outlined rectangle with
+     * the chart title centred). Return `void` or `true` to indicate the
+     * chart was handled.
+     *
+     * Note: `chartEx` charts never reach this callback because there is
+     * no `Chart` instance to pass; they always render through the
+     * translator's built-in path.
+     */
+    readonly chartRenderer?: (chart: Chart, page: PdfPageBuilder, rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }) => boolean | void;
 }
 /**
- * Convert a DocxDocument to PDF bytes.
+ * Convert a `DocxDocument` to PDF bytes.
  *
- * @param doc - The DOCX document model (from readDocx or DocumentBuilder.build()).
- * @param options - PDF rendering options.
- * @returns Promise of PDF bytes.
+ * @param doc - The DOCX document model (from `readDocx` or `Document.build()`).
+ * @param options - Page geometry, fonts, optional chart renderer, …
+ * @returns PDF bytes ready to write to disk or stream over HTTP.
  */
 export declare function docxToPdf(doc: DocxDocument, options?: DocxToPdfOptions): Promise<Uint8Array>;

package/dist/browser/modules/pdf/word-bridge.js

@@ -1,9 +1,27 @@
 /**
  * Word-to-PDF Bridge
  *
- * Converts a Word document (DocxDocument) to PDF.
- * Like excel-bridge.ts, this is the ONLY file in the PDF module that imports
- * from @word.
+ * Converts a Word document (`DocxDocument`) to PDF.
+ *
+ * The bridge is a thin translation layer:
+ *
+ *   DocxDocument
+ *      │
+ *      │  layoutDocumentFull()  ← @word/layout
+ *      ▼
+ *   LayoutDocument (positioned PageContent variants)
+ *      │
+ *      │  renderLayoutDocumentToPdf()  ← ./render-layout-to-pdf
+ *      ▼
+ *   PdfDocumentBuilder → bytes
+ *
+ * Every flow decision (line wrapping, page breaks, table sizing,
+ * float positioning) lives in `@word/layout`. This file only handles
+ * option mapping, optional chart-renderer auto-detection, and the
+ * final `builder.build()` serialization.
+ *
+ * Like `excel-bridge.ts`, this is the ONLY file in the PDF module that
+ * imports from `@word`.
  *
  * @example
  * ```typescript
@@ -13,292 +31,122 @@
  * const doc = await readDocx(docxBytes);
  * const pdfBytes = await docxToPdf(doc);
  * ```
- *
- * Note: This is a simple flow-based renderer. For high-fidelity output,
- * consider using Microsoft Word or LibreOffice.
  */
-import { PdfDocumentBuilder } from "./builder/document-builder.js";
+import { layoutDocumentFull } from "../word/layout/layout-full.js";
+import { renderLayoutDocumentToPdf } from "./render-layout-to-pdf.js";
 /**
- * Convert a DocxDocument to PDF bytes.
+ * Convert a `DocxDocument` to PDF bytes.
  *
- * @param doc - The DOCX document model (from readDocx or DocumentBuilder.build()).
- * @param options - PDF rendering options.
- * @returns Promise of PDF bytes.
+ * @param doc - The DOCX document model (from `readDocx` or `Document.build()`).
+ * @param options - Page geometry, fonts, optional chart renderer, …
+ * @returns PDF bytes ready to write to disk or stream over HTTP.
  */
 export async function docxToPdf(doc, options) {
-    const opts = {
-        pageWidth: options?.pageWidth ?? 612,
-        pageHeight: options?.pageHeight ?? 792,
-        marginTop: options?.marginTop ?? 72,
-        marginBottom: options?.marginBottom ?? 72,
-        marginLeft: options?.marginLeft ?? 72,
-        marginRight: options?.marginRight ?? 72,
-        defaultFont: options?.defaultFont ?? "Times-Roman",
-        defaultFontSize: options?.defaultFontSize ?? 11
-    };
-    // Use section properties if available
-    const sectProps = doc.sectionProperties;
-    if (sectProps?.pageSize && !options?.pageWidth) {
-        opts.pageWidth = twipsToPt(sectProps.pageSize.width);
-        opts.pageHeight = twipsToPt(sectProps.pageSize.height);
-        if (sectProps.pageSize.orientation === "landscape") {
-            [opts.pageWidth, opts.pageHeight] = [opts.pageHeight, opts.pageWidth];
-        }
-    }
-    if (sectProps?.margins && !options?.marginTop) {
-        opts.marginTop = twipsToPt(sectProps.margins.top);
-        opts.marginBottom = twipsToPt(sectProps.margins.bottom);
-        opts.marginLeft = twipsToPt(sectProps.margins.left);
-        opts.marginRight = twipsToPt(sectProps.margins.right);
-    }
-    const builder = new PdfDocumentBuilder();
-    if (doc.coreProperties?.title || doc.coreProperties?.creator) {
-        builder.setMetadata({
-            title: doc.coreProperties?.title,
-            author: doc.coreProperties?.creator,
-            subject: doc.coreProperties?.subject
-        });
-    }
-    const state = {
-        builder,
-        opts,
-        doc,
-        rIdToImage: buildImageMap(doc),
-        currentPage: null,
-        cursorY: 0,
-        currentPageIndex: 0
-    };
-    newPage(state);
-    for (const item of doc.body) {
-        renderBodyContent(state, item);
-    }
-    return builder.build();
-}
-function newPage(state) {
-    state.currentPage = state.builder.addPage({
-        width: state.opts.pageWidth,
-        height: state.opts.pageHeight
-    });
-    state.cursorY = state.opts.pageHeight - state.opts.marginTop;
-    state.currentPageIndex++;
-}
-function ensureSpace(state, needed) {
-    if (state.cursorY - needed < state.opts.marginBottom) {
-        newPage(state);
-    }
-}
-function renderBodyContent(state, item) {
-    if (!("type" in item)) {
-        return;
-    }
-    switch (item.type) {
-        case "paragraph":
-            renderParagraphPdf(state, item);
-            break;
-        case "table":
-            renderTablePdf(state, item);
-            break;
-        case "math":
-            renderTextAtCursor(state, "[equation]", { italic: true });
-            break;
-        case "chart":
-            renderTextAtCursor(state, `[${item.chart.type} chart]`, { italic: true });
-            break;
-        default:
-            break;
-    }
-}
-function renderParagraphPdf(state, para) {
-    const props = para.properties;
-    const spacing = props?.spacing;
-    if (spacing?.before) {
-        state.cursorY -= twipsToPt(spacing.before);
-    }
-    const text = collectText(para);
-    if (!text.trim()) {
-        state.cursorY -= state.opts.defaultFontSize * 1.2;
-        return;
-    }
-    // Determine font size and weight based on style
-    let fontSize = state.opts.defaultFontSize;
-    let bold = false;
-    const styleId = props?.style?.toLowerCase() ?? "";
-    if (styleId === "heading1" || styleId === "title") {
-        fontSize = 24;
-        bold = true;
-    }
-    else if (styleId === "heading2") {
-        fontSize = 18;
-        bold = true;
-    }
-    else if (styleId === "heading3") {
-        fontSize = 14;
-        bold = true;
-    }
-    else if (styleId === "heading4") {
-        fontSize = 12;
-        bold = true;
-    }
-    let leftIndent = 0;
-    if (props?.indent?.left !== undefined) {
-        leftIndent = twipsToPt(props.indent.left);
-    }
-    const x = state.opts.marginLeft + leftIndent;
-    const availableWidth = state.opts.pageWidth - state.opts.marginLeft - state.opts.marginRight - leftIndent;
-    const lineHeight = fontSize * 1.2;
-    const estimatedLines = Math.max(1, Math.ceil((text.length * fontSize * 0.5) / availableWidth));
-    ensureSpace(state, estimatedLines * lineHeight);
-    // Simple approach: render entire paragraph as one text block
-    state.currentPage.drawText(text, {
-        x,
-        y: state.cursorY - fontSize,
-        fontSize,
-        bold,
-        maxWidth: availableWidth,
-        lineHeight: 1.2
-    });
-    state.cursorY -= estimatedLines * lineHeight;
-    if (spacing?.after) {
-        state.cursorY -= twipsToPt(spacing.after);
-    }
-    else {
-        state.cursorY -= 6;
-    }
-}
-function collectText(para) {
-    let text = "";
-    for (const child of para.children) {
-        const run = childToRun(child);
-        if (run) {
-            text += runToText(run);
-        }
-    }
-    return text;
-}
-function childToRun(child) {
-    if ("content" in child && !("type" in child)) {
-        return child;
-    }
-    if ("type" in child) {
-        const typed = child;
-        if (typed.type === "hyperlink" && typed.children) {
-            for (const c of typed.children) {
-                if ("content" in c && !("type" in c)) {
-                    return c;
-                }
+    // 1. Resolve effective page geometry. Section properties win unless the
+    //    caller explicitly overrode an axis. Margins are independent: the
+    //    section's margins are applied unless the caller overrode them.
+    const layoutOptions = mapToLayoutOptions(doc, options);
+    // 2. Auto-detect chart support: if no explicit chartRenderer is
+    //    provided, try to import the high-quality Excel-based renderer.
+    let chartRendererForChart = options?.chartRenderer;
+    if (!chartRendererForChart) {
+        try {
+            const mod = await import("./excel-bridge.js");
+            if (typeof mod.createWordChartPdfRenderer === "function") {
+                chartRendererForChart = mod.createWordChartPdfRenderer();
             }
         }
-        else if (typed.type === "insertedRun" ||
-            typed.type === "deletedRun" ||
-            typed.type === "movedFromRun" ||
-            typed.type === "movedToRun") {
-            return typed.run;
+        catch {
+            // Chart support not available — placeholder rendering takes over.
         }
     }
-    return undefined;
-}
-function runToText(run) {
-    let text = "";
-    for (const c of run.content) {
-        switch (c.type) {
-            case "text":
-                text += c.text;
-                break;
-            case "tab":
-                text += "\t";
-                break;
-            case "break":
-            case "carriageReturn":
-                text += "\n";
-                break;
-            case "noBreakHyphen":
-                text += "\u2011";
-                break;
-            case "symbol":
-                try {
-                    text += String.fromCodePoint(parseInt(c.char, 16));
-                }
-                catch {
-                    // Invalid symbol code - skip
+    // 3. Run the layout engine. Everything from line wrapping to page
+    //    breaks happens here; word-bridge no longer carries any of that.
+    const layout = layoutDocumentFull(doc, layoutOptions);
+    // 4. Build a render-options object for the PDF translator. The
+    //    chartRenderer adaptation: layout produces `LayoutChart` (which
+    //    contains the original `ChartContent` in `source`); the public
+    //    chartRenderer API takes the inner `Chart` model. We unwrap so
+    //    existing callers keep working unchanged.
+    const renderOptions = {
+        title: doc.coreProperties?.title,
+        author: doc.coreProperties?.creator,
+        subject: doc.coreProperties?.subject,
+        defaultFont: options?.defaultFont ?? "Helvetica",
+        defaultFontSize: options?.defaultFontSize ?? 11,
+        chartRenderer: chartRendererForChart
+            ? (layoutChart, page, rect) => {
+                const src = layoutChart.source;
+                if (src && src.type === "chart") {
+                    // Forward the user's return value so a renderer that knows
+                    // how to draw classic charts but declines a particular
+                    // family (e.g. unsupported axis combination) gets the
+                    // translator's placeholder fallback.
+                    return chartRendererForChart(src.chart, page, rect);
                 }
-                break;
-            case "field":
-                if (c.cachedValue) {
-                    text += c.cachedValue;
-                }
-                break;
-        }
-    }
-    return text;
-}
-function renderTablePdf(state, table) {
-    const pageWidth = state.opts.pageWidth - state.opts.marginLeft - state.opts.marginRight;
-    const numCols = Math.max(...table.rows.map(r => r.cells.length));
-    const defaultColWidth = pageWidth / numCols;
-    const rowHeight = 20;
-    for (const row of table.rows) {
-        ensureSpace(state, rowHeight);
-        let x = state.opts.marginLeft;
-        const rowTop = state.cursorY;
-        const rowBottom = state.cursorY - rowHeight;
-        for (const cell of row.cells) {
-            const span = cell.properties?.gridSpan ?? 1;
-            const cellWidth = defaultColWidth * span;
-            state.currentPage.drawRect({
-                x,
-                y: rowBottom,
-                width: cellWidth,
-                height: rowHeight,
-                stroke: { r: 0, g: 0, b: 0 },
-                lineWidth: 0.5
-            });
-            const cellText = getCellText(cell);
-            if (cellText) {
-                state.currentPage.drawText(cellText, {
-                    x: x + 4,
-                    y: rowTop - 14,
-                    fontSize: 10,
-                    maxWidth: cellWidth - 8
-                });
+                // ChartEx (or absent source) cannot be passed to the user's
+                // `Chart`-typed callback. Decline so the translator's
+                // placeholder runs instead of leaving a blank slot.
+                return false;
             }
-            x += cellWidth;
-        }
-        state.cursorY = rowBottom;
-    }
-    state.cursorY -= 6;
+            : undefined
+    };
+    const builder = renderLayoutDocumentToPdf(layout, renderOptions);
+    return builder.build();
 }
-function getCellText(cell) {
-    let text = "";
-    for (const item of cell.content) {
-        if ("type" in item && item.type === "paragraph") {
-            text += collectText(item) + " ";
+// =============================================================================
+// Internal: option mapping
+// =============================================================================
+/**
+ * Resolve the effective page geometry from `DocxToPdfOptions`. Caller-
+ * supplied overrides win; otherwise the document's section properties
+ * provide the value (with `pageSize.orientation === "landscape"`
+ * triggering the conventional width/height swap when sectPr supplies
+ * portrait-oriented numbers); otherwise the layout engine's defaults
+ * (US Letter, 1-inch margins) take over.
+ *
+ * `headerMargin` / `footerMargin` are accepted for API compatibility
+ * with the previous flow renderer but currently have no effect on the
+ * layout-driven path: the layout engine does not yet position header /
+ * footer paragraphs against custom inset values, and forwarding the
+ * field would silently mislead callers. Pre-existing documents that
+ * rely on those parameters still get the section's `headerMargin` /
+ * `footerMargin` from sectionProperties when they exist.
+ */
+function mapToLayoutOptions(doc, options) {
+    const sectProps = doc.sectionProperties;
+    // Section page size, applying the orientation swap so a landscape
+    // sectPr written with portrait numerics still ends up wide.
+    let sectionPageWidthPt;
+    let sectionPageHeightPt;
+    if (sectProps?.pageSize) {
+        sectionPageWidthPt = twipsToPt(sectProps.pageSize.width);
+        sectionPageHeightPt = twipsToPt(sectProps.pageSize.height);
+        if (sectProps.pageSize.orientation === "landscape") {
+            [sectionPageWidthPt, sectionPageHeightPt] = [sectionPageHeightPt, sectionPageWidthPt];
         }
     }
-    return text.trim();
+    const sectionMarginTopPt = sectProps?.margins?.top != null ? twipsToPt(sectProps.margins.top) : undefined;
+    const sectionMarginBottomPt = sectProps?.margins?.bottom != null ? twipsToPt(sectProps.margins.bottom) : undefined;
+    const sectionMarginLeftPt = sectProps?.margins?.left != null ? twipsToPt(sectProps.margins.left) : undefined;
+    const sectionMarginRightPt = sectProps?.margins?.right != null ? twipsToPt(sectProps.margins.right) : undefined;
+    const pageGeometry = {
+        pageWidth: options?.pageWidth ?? sectionPageWidthPt,
+        pageHeight: options?.pageHeight ?? sectionPageHeightPt,
+        marginTop: options?.marginTop ?? sectionMarginTopPt,
+        marginBottom: options?.marginBottom ?? sectionMarginBottomPt,
+        marginLeft: options?.marginLeft ?? sectionMarginLeftPt,
+        marginRight: options?.marginRight ?? sectionMarginRightPt
+    };
+    const layoutOpts = {};
+    // Only attach pageGeometry when at least one axis is actually
+    // overridden; otherwise the layout engine should apply its
+    // section-property fallbacks unchanged.
+    if (Object.values(pageGeometry).some(v => v !== undefined)) {
+        layoutOpts.pageGeometry = pageGeometry;
+    }
+    return layoutOpts;
 }
 function twipsToPt(twips) {
     return twips / 20;
 }
-function renderTextAtCursor(state, text, opts) {
-    const fontSize = opts?.fontSize ?? state.opts.defaultFontSize;
-    ensureSpace(state, fontSize * 1.2);
-    state.currentPage.drawText(text, {
-        x: state.opts.marginLeft,
-        y: state.cursorY - fontSize,
-        fontSize,
-        bold: opts?.bold,
-        italic: opts?.italic
-    });
-    state.cursorY -= fontSize * 1.2;
-}
-function buildImageMap(doc) {
-    const map = new Map();
-    if (doc.images) {
-        for (const img of doc.images) {
-            if (img.rId) {
-                map.set(img.rId, img);
-            }
-        }
-    }
-    return map;
-}

package/dist/browser/modules/stream/index.base.d.ts

@@ -14,4 +14,6 @@ export { StreamStateError, StreamTypeError, UnsupportedStreamTypeError } from ".
 export { isReadableStream, isWritableStream, isAsyncIterable, isTransformStream } from "./internal/type-guards.js";
 export { onceEvent } from "./internal/event-utils.js";
 export { eventedReadableToAsyncIterableNoDestroy, type EventedReadableLike } from "./internal/evented-readable-to-async-iterable.js";
+export { SinkAdapter } from "./internal/sink-adapter.js";
+export type { AnySink, NodeWritableLike, DuckSinkLike } from "./internal/sink-adapter.js";
 export type { EventEmitterLike } from "./types.js";

package/dist/browser/modules/stream/index.base.js

@@ -9,7 +9,8 @@ export { isDestroyed, isErrored, getDefaultHighWaterMark, setDefaultHighWaterMar
 export { ChunkedBuilder, TransactionalChunkedBuilder } from "./chunked-builder.js";
 export { collect, text, json, bytes, fromString, fromJSON, fromBytes, transform, filter, isReadableStreamLike, readableStreamToAsyncIterable } from "./utils.browser.js";
 export { StreamStateError, StreamTypeError, UnsupportedStreamTypeError } from "./errors.js";
-// Internal utilities exposed for cross-module use (e.g. archive)
+// Internal utilities exposed for cross-module use (e.g. archive, word/excel writers)
 export { isReadableStream, isWritableStream, isAsyncIterable, isTransformStream } from "./internal/type-guards.js";
 export { onceEvent } from "./internal/event-utils.js";
 export { eventedReadableToAsyncIterableNoDestroy } from "./internal/evented-readable-to-async-iterable.js";
+export { SinkAdapter } from "./internal/sink-adapter.js";

package/dist/browser/modules/stream/internal/sink-adapter.d.ts

@@ -0,0 +1,65 @@
+/**
+ * SinkAdapter — unified writable-sink view.
+ *
+ * Producers (zip writers, docx streamers, etc.) generate `Uint8Array`
+ * chunks and want to push them through a user-supplied destination
+ * without caring whether that destination is a Web `WritableStream`,
+ * a Node `Writable`, or some duck-typed object.
+ *
+ * `SinkAdapter` collapses all three into one promise-based API:
+ *   - `write(chunk)` resolves once the chunk has been accepted by the
+ *     sink (after awaiting `drain` for Node-style sinks under
+ *     backpressure, or `writer.ready` for Web streams).
+ *   - `end()` finalises the sink and resolves on close.
+ *   - The first sink error is captured and re-thrown from the next
+ *     `write` / `end` so callers can't lose it.
+ *
+ * Producers are expected to either:
+ *   - drive `await sink.write(chunk)` directly (preferred — gives
+ *     true end-to-end backpressure), or
+ *   - chain writes onto a single shared promise so a synchronous
+ *     emit callback can still feed the adapter without blocking.
+ */
+import type { EventEmitterLike } from "../types.js";
+/**
+ * Loose Node `Writable`-like contract. Matches `stream.Writable` but only
+ * the subset SinkAdapter touches; intentionally avoids depending on
+ * `node:stream` so the adapter compiles in browsers.
+ */
+export interface NodeWritableLike extends EventEmitterLike {
+    write(chunk: Uint8Array, cb?: (err?: Error | null) => void): boolean;
+    end(cb?: () => void): unknown;
+    destroyed?: boolean;
+}
+/**
+ * Object that implements just enough of a writable to be useful: a
+ * `write` returning sync bool / Promise, plus `end`. Used as a fallback
+ * for legacy producers that don't fit either Node or Web streams.
+ */
+export interface DuckSinkLike extends EventEmitterLike {
+    write(chunk: Uint8Array): boolean | Promise<boolean>;
+    end(): unknown;
+}
+/** Anything SinkAdapter knows how to drive. */
+export type AnySink = WritableStream<Uint8Array> | NodeWritableLike | DuckSinkLike;
+/** Unified sink view with awaited write + error capture. */
+export declare class SinkAdapter {
+    private readonly _kind;
+    private readonly _webWriter?;
+    private readonly _nodeSink?;
+    private readonly _duckSink?;
+    private _error;
+    private _ended;
+    constructor(sink: AnySink);
+    /**
+     * The first error reported by the sink (or `null`). Producers that
+     * cannot await `write()` (synchronous emit callbacks) should poll
+     * this between operations.
+     */
+    get error(): Error | null;
+    write(chunk: Uint8Array): Promise<void>;
+    end(): Promise<void>;
+    private _captureError;
+    private _throwIfErrored;
+    private _attachErrorListener;
+}