web-doc 0.6.2 → 0.7.0

package/dist/edit/pdf/engine/shapes.js

@@ -0,0 +1,183 @@
+import { OBJECT_PATH } from "./elements.js";
+import { pageToUser } from "./geometry.js";
+import { parseColor, validateRect } from "./text-box.js";
+/*
+ * Vector shapes as path objects. Geometry is given in page space and turned
+ * into user space point by point, so shapes land where the host expects on
+ * rotated and cropped pages too.
+ */
+/** FPDFPath_SetDrawMode fill modes. */
+const FILL_NONE = 0;
+const FILL_ALTERNATE = 1;
+/** Bézier control-point ratio that approximates a quarter circle. */
+const KAPPA = 0.5522847498;
+/** Round joins keep rectangle corners tidy at wide strokes. */
+const LINE_JOIN_ROUND = 1;
+export const insertShape = {
+    validate(operation, context, issue) {
+        if (operation.pageIndex >= context.pageCount) {
+            issue("/pageIndex", "unknown-target", `No page ${operation.pageIndex}`);
+            return;
+        }
+        const geometry = context.geometry(operation.pageIndex);
+        if (operation.shape === "line") {
+            if (!operation.from || !operation.to) {
+                issue("", "required", "A line needs `from` and `to`");
+                return;
+            }
+            if ("fill" in operation && operation.fill !== undefined)
+                issue("/fill", "unsupported-style", "A line cannot be filled");
+            if (!operation.stroke)
+                issue("/stroke", "required", "A line needs a stroke");
+            for (const [name, point] of [
+                ["from", operation.from],
+                ["to", operation.to],
+            ])
+                validateRect({ ...point, width: 0.001, height: 0.001 }, geometry, issue, `/${name}`);
+            return;
+        }
+        if (!operation.rect) {
+            issue("/rect", "required", `A ${operation.shape} needs a rect`);
+            return;
+        }
+        validateRect(operation.rect, geometry, issue);
+        if (!operation.stroke && !operation.fill)
+            issue("", "required", "Give a stroke, a fill, or both");
+    },
+    apply(operation, context) {
+        const { lib } = context.pdfium;
+        const geometry = context.geometry(operation.pageIndex);
+        const id = context.newId(operation.pageIndex);
+        const path = operation.shape === "line"
+            ? linePath(context, geometry, operation.from, operation.to)
+            : operation.shape === "rectangle"
+                ? rectanglePath(context, geometry, operation.rect)
+                : ellipsePath(context, geometry, operation.rect);
+        applyStyle(context, path, operation.stroke, operation.shape === "line" ? undefined : operation.fill);
+        context.withPage(operation.pageIndex, (page) => {
+            lib.FPDFPage_InsertObject(page, path);
+        });
+        context.appendObjects(operation.pageIndex, [{ id, type: OBJECT_PATH }]);
+        return {
+            createdIds: [id],
+            changedPages: [operation.pageIndex],
+            warnings: [],
+        };
+    },
+};
+export const setShapeStyle = {
+    validate(operation, context, issue) {
+        const target = shapeTarget(operation.target, context, issue);
+        if (!target)
+            return;
+        const style = target.element.shapeStyle ?? {};
+        const stroke = operation.stroke === undefined ? style.stroke : operation.stroke;
+        const fill = operation.fill === undefined ? style.fill : operation.fill;
+        if (!stroke && !fill)
+            issue("", "required", "A shape keeps a stroke, a fill, or both");
+    },
+    apply(operation, context) {
+        const { lib } = context.pdfium;
+        const { location, element } = shapeTarget(operation.target, context);
+        const style = element.shapeStyle ?? {};
+        const stroke = operation.stroke === undefined ? style.stroke : operation.stroke;
+        const fill = operation.fill === undefined ? style.fill : operation.fill;
+        context.withPage(location.pageIndex, (page) => {
+            applyStyle(context, lib.FPDFPage_GetObject(page, location.indexes[0]), stroke ?? undefined, fill ?? undefined);
+        });
+        return result(location);
+    },
+};
+function shapeTarget(target, context, issue = () => { }) {
+    const location = context.locate(target);
+    const element = location && context.element(target);
+    if (!location || !element) {
+        issue("/target", "unknown-target", `No element ${target}`);
+        return undefined;
+    }
+    if (element.kind !== "shape") {
+        issue("/target", "unsupported-target", "Only shapes have a stroke and fill");
+        return undefined;
+    }
+    return { location, element };
+}
+function applyStyle(context, path, stroke, fill) {
+    const { lib } = context.pdfium;
+    if (stroke) {
+        const [r, g, b] = parseColor(stroke.color);
+        lib.FPDFPageObj_SetStrokeColor(path, r, g, b, 255);
+        lib.FPDFPageObj_SetStrokeWidth(path, stroke.width);
+    }
+    if (fill) {
+        const [r, g, b] = parseColor(fill.color);
+        lib.FPDFPageObj_SetFillColor(path, r, g, b, 255);
+    }
+    lib.FPDFPath_SetDrawMode(path, fill ? FILL_ALTERNATE : FILL_NONE, Boolean(stroke));
+}
+function linePath(context, geometry, from, to) {
+    const { lib } = context.pdfium;
+    const start = pageToUser(geometry, from.x, from.y);
+    const end = pageToUser(geometry, to.x, to.y);
+    const path = lib.FPDFPageObj_CreateNewPath(start.x, start.y);
+    lib.FPDFPath_LineTo(path, end.x, end.y);
+    return path;
+}
+function rectanglePath(context, geometry, rect) {
+    const { lib } = context.pdfium;
+    const corners = [
+        pageToUser(geometry, rect.x, rect.y),
+        pageToUser(geometry, rect.x + rect.width, rect.y),
+        pageToUser(geometry, rect.x + rect.width, rect.y + rect.height),
+        pageToUser(geometry, rect.x, rect.y + rect.height),
+    ];
+    const path = lib.FPDFPageObj_CreateNewPath(corners[0].x, corners[0].y);
+    for (const corner of corners.slice(1))
+        lib.FPDFPath_LineTo(path, corner.x, corner.y);
+    lib.FPDFPath_Close(path);
+    lib.FPDFPageObj_SetLineJoin(path, LINE_JOIN_ROUND);
+    return path;
+}
+function ellipsePath(context, geometry, rect) {
+    const { lib } = context.pdfium;
+    const cx = rect.x + rect.width / 2;
+    const cy = rect.y + rect.height / 2;
+    const rx = rect.width / 2;
+    const ry = rect.height / 2;
+    const at = (x, y) => pageToUser(geometry, x, y);
+    // Four quarter arcs, clockwise in page space from the right-most point.
+    const arcs = [
+        [
+            { x: cx + rx, y: cy + ry * KAPPA },
+            { x: cx + rx * KAPPA, y: cy + ry },
+            { x: cx, y: cy + ry },
+        ],
+        [
+            { x: cx - rx * KAPPA, y: cy + ry },
+            { x: cx - rx, y: cy + ry * KAPPA },
+            { x: cx - rx, y: cy },
+        ],
+        [
+            { x: cx - rx, y: cy - ry * KAPPA },
+            { x: cx - rx * KAPPA, y: cy - ry },
+            { x: cx, y: cy - ry },
+        ],
+        [
+            { x: cx + rx * KAPPA, y: cy - ry },
+            { x: cx + rx, y: cy - ry * KAPPA },
+            { x: cx + rx, y: cy },
+        ],
+    ];
+    const start = at(cx + rx, cy);
+    const path = lib.FPDFPageObj_CreateNewPath(start.x, start.y);
+    for (const [c1, c2, end] of arcs) {
+        const u1 = at(c1.x, c1.y);
+        const u2 = at(c2.x, c2.y);
+        const u3 = at(end.x, end.y);
+        lib.FPDFPath_BezierTo(path, u1.x, u1.y, u2.x, u2.y, u3.x, u3.y);
+    }
+    lib.FPDFPath_Close(path);
+    return path;
+}
+function result(location) {
+    return { createdIds: [], changedPages: [location.pageIndex], warnings: [] };
+}

package/dist/edit/pdf/engine/tables.d.ts

@@ -0,0 +1,44 @@
+import type { PagePoint } from "../../types.js";
+import type { InsertTableOperation, PdfTableStyle, SetTableCellOperation } from "../types.js";
+import { type MarkParams } from "./elements.js";
+import type { FontRequest } from "./fonts.js";
+import type { ElementLocation, Issue, OperationContext, OperationHandler, OperationResult } from "./operations.js";
+import { type DrawnTextBox } from "./text-box.js";
+export declare const MAX_ROWS = 100;
+export declare const MAX_COLUMNS = 20;
+/** A table's inputs with every default filled in; stored in its head mark. */
+export type TableSpec = {
+    readonly kind: "table";
+    readonly id: string;
+    readonly at: PagePoint;
+    readonly rows: readonly (readonly string[])[];
+    /** Absolute column widths in points. */
+    readonly columnWidths: readonly number[];
+    readonly style: {
+        readonly fontFamily: string;
+        readonly fontSize: number;
+        readonly color: string;
+        readonly borderColor: string;
+        readonly borderWidth: number;
+        readonly cellPadding: number;
+        readonly headerFill: string | null;
+    };
+};
+export declare const insertTable: OperationHandler<InsertTableOperation>;
+export declare const setTableCell: OperationHandler<SetTableCellOperation>;
+/** Lays the table out and inserts its objects, appended or at `insertAt`. */
+export declare function drawTable(context: OperationContext, pageIndex: number, spec: TableSpec, insertAt?: number): DrawnTextBox;
+/** Redraws a table from `spec` at the same place in the drawing order. */
+export declare function rebuildTable(context: OperationContext, location: ElementLocation, spec: TableSpec): DrawnTextBox;
+/** The location and stored inputs of a table, or the issue that stops the edit. */
+export declare function tableTarget(target: string, context: OperationContext, issue?: Issue): {
+    readonly location: ElementLocation;
+    readonly spec: TableSpec;
+} | undefined;
+/** The spec a mark carries when it is a table's head mark. */
+export declare function tableSpecOf(mark: MarkParams | undefined): TableSpec | undefined;
+export declare function changedTable(location: ElementLocation, drawn: DrawnTextBox): OperationResult;
+/** Every cell's text, for font coverage checks. */
+export declare function tableText(rows: readonly (readonly string[])[]): string;
+export declare function tableFontRequest(style: TableSpec["style"], text: string): FontRequest;
+export declare function resolveTableStyle(style: PdfTableStyle): TableSpec["style"];

package/dist/edit/pdf/engine/tables.js

@@ -0,0 +1,315 @@
+import { MARK_NAME, MARK_PARAM, OBJECT_PATH, OBJECT_TEXT, } from "./elements.js";
+import { displayedSize, pageToUser } from "./geometry.js";
+import { layoutText } from "./text-layout.js";
+import { parseColor, placeUpright, removeObjects, setText, validateRect, } from "./text-box.js";
+/*
+ * Tables are parametric like text boxes: the grid is one stroked path, an
+ * optional header fill one more, and every cell line a text object. The
+ * inputs live in the `WebDoc` mark of the path objects; the text objects
+ * carry only the table's id, so a large table does not repeat its contents.
+ */
+export const MAX_ROWS = 100;
+export const MAX_COLUMNS = 20;
+/** FPDFPath_SetDrawMode fill modes. */
+const FILL_NONE = 0;
+const FILL_ALTERNATE = 1;
+const LINE_HEIGHT = 1.2;
+export const insertTable = {
+    validate(operation, context, issue) {
+        if (operation.pageIndex >= context.pageCount) {
+            issue("/pageIndex", "unknown-target", `No page ${operation.pageIndex}`);
+            return;
+        }
+        if (!validateRows(operation.rows, issue))
+            return;
+        const columns = operation.rows[0].length;
+        if (operation.columnWidths !== undefined &&
+            operation.columnWidths.length !== columns) {
+            issue("/columnWidths", "range", `Give one width per column; the table has ${columns}`);
+            return;
+        }
+        const style = resolveTableStyle(operation.style ?? {});
+        const widths = resolveColumns(operation.width, columns, operation.columnWidths);
+        validateRect({
+            x: operation.at.x,
+            y: operation.at.y,
+            width: operation.width,
+            height: 0.001,
+        }, context.geometry(operation.pageIndex), issue, "/at");
+        if (Math.min(...widths) - 2 * style.cellPadding < 1)
+            issue("/width", "range", "Every column must be wider than twice the cell padding");
+        validateTableFont(style, tableText(operation.rows), context, issue, "/rows");
+    },
+    apply(operation, context) {
+        const id = context.newId(operation.pageIndex);
+        const columns = operation.rows[0].length;
+        const spec = {
+            kind: "table",
+            id,
+            at: operation.at,
+            rows: operation.rows,
+            columnWidths: resolveColumns(operation.width, columns, operation.columnWidths),
+            style: resolveTableStyle(operation.style ?? {}),
+        };
+        const drawn = drawTable(context, operation.pageIndex, spec);
+        return {
+            createdIds: [id],
+            changedPages: [operation.pageIndex],
+            warnings: tableWarnings(drawn, id),
+        };
+    },
+};
+export const setTableCell = {
+    validate(operation, context, issue) {
+        const target = tableTarget(operation.target, context, issue);
+        if (!target)
+            return;
+        const { spec } = target;
+        if (operation.row >= spec.rows.length) {
+            issue("/row", "range", `The table has ${spec.rows.length} rows`);
+            return;
+        }
+        const columns = spec.rows[0].length;
+        if (operation.column >= columns) {
+            issue("/column", "range", `The table has ${columns} columns`);
+            return;
+        }
+        validateTableFont(spec.style, operation.text, context, issue, "/text");
+    },
+    apply(operation, context) {
+        const { location, spec } = tableTarget(operation.target, context);
+        const rows = spec.rows.map((row, rowIndex) => rowIndex === operation.row
+            ? row.map((cell, columnIndex) => columnIndex === operation.column ? operation.text : cell)
+            : row);
+        return changedTable(location, rebuildTable(context, location, { ...spec, rows }));
+    },
+};
+/** Lays the table out and inserts its objects, appended or at `insertAt`. */
+export function drawTable(context, pageIndex, spec, insertAt) {
+    const { pdfium, measurer } = context;
+    const { lib } = pdfium;
+    const { style } = spec;
+    const font = context.fonts.resolve(pdfium, context.document, tableFontRequest(style, tableText(spec.rows)));
+    const { ascent } = measurer.metrics(font.handle, style.fontSize);
+    const layout = layoutTable(spec, ascent, (text) => measurer.advance(font.handle, style.fontSize, text));
+    const geometry = context.geometry(pageIndex);
+    const overflow = spec.at.y + layout.height > displayedSize(geometry).height + 0.001;
+    const head = JSON.stringify(spec);
+    const memberMark = { kind: "table", id: spec.id };
+    const member = JSON.stringify(memberMark);
+    const at = (x, y) => pageToUser(geometry, x, y);
+    const width = spec.columnWidths.reduce((total, w) => total + w, 0);
+    const right = spec.at.x + width;
+    const bottom = spec.at.y + layout.height;
+    const [textR, textG, textB] = parseColor(style.color);
+    context.withPage(pageIndex, (page) => {
+        const records = [];
+        let index = insertAt ?? -1;
+        const place = (object, type, mark, params) => {
+            const handle = lib.FPDFPageObj_AddMark(object, MARK_NAME);
+            lib.FPDFPageObjMark_SetStringParam(context.document, object, handle, MARK_PARAM, params);
+            if (insertAt === undefined)
+                lib.FPDFPage_InsertObject(page, object);
+            else
+                lib.FPDFPage_InsertObjectAtIndex(page, object, index++);
+            records.push({ id: spec.id, type, mark });
+        };
+        if (style.headerFill) {
+            const headerBottom = spec.at.y + layout.rows[0].height;
+            const corners = [
+                at(spec.at.x, spec.at.y),
+                at(right, spec.at.y),
+                at(right, headerBottom),
+                at(spec.at.x, headerBottom),
+            ];
+            const fill = lib.FPDFPageObj_CreateNewPath(corners[0].x, corners[0].y);
+            for (const corner of corners.slice(1))
+                lib.FPDFPath_LineTo(fill, corner.x, corner.y);
+            lib.FPDFPath_Close(fill);
+            const [r, g, b] = parseColor(style.headerFill);
+            lib.FPDFPageObj_SetFillColor(fill, r, g, b, 255);
+            lib.FPDFPath_SetDrawMode(fill, FILL_ALTERNATE, false);
+            place(fill, OBJECT_PATH, spec, head);
+        }
+        // One path for the whole grid: the frame, then the inner lines.
+        const frame = [
+            at(spec.at.x, spec.at.y),
+            at(right, spec.at.y),
+            at(right, bottom),
+            at(spec.at.x, bottom),
+        ];
+        const grid = lib.FPDFPageObj_CreateNewPath(frame[0].x, frame[0].y);
+        for (const corner of frame.slice(1))
+            lib.FPDFPath_LineTo(grid, corner.x, corner.y);
+        lib.FPDFPath_Close(grid);
+        for (const column of layout.columns.slice(1)) {
+            const top = at(column.x, spec.at.y);
+            const end = at(column.x, bottom);
+            lib.FPDFPath_MoveTo(grid, top.x, top.y);
+            lib.FPDFPath_LineTo(grid, end.x, end.y);
+        }
+        for (const row of layout.rows.slice(1)) {
+            const start = at(spec.at.x, row.y);
+            const end = at(right, row.y);
+            lib.FPDFPath_MoveTo(grid, start.x, start.y);
+            lib.FPDFPath_LineTo(grid, end.x, end.y);
+        }
+        const [r, g, b] = parseColor(style.borderColor);
+        lib.FPDFPageObj_SetStrokeColor(grid, r, g, b, 255);
+        lib.FPDFPageObj_SetStrokeWidth(grid, style.borderWidth);
+        lib.FPDFPath_SetDrawMode(grid, FILL_NONE, true);
+        place(grid, OBJECT_PATH, spec, head);
+        layout.rows.forEach((row) => {
+            row.cells.forEach((lines, columnIndex) => {
+                const column = layout.columns[columnIndex];
+                for (const line of lines) {
+                    if (!line.text)
+                        continue;
+                    const object = lib.FPDFPageObj_CreateTextObj(context.document, font.handle, style.fontSize);
+                    setText(pdfium, object, line.text);
+                    lib.FPDFPageObj_SetFillColor(object, textR, textG, textB, 255);
+                    placeUpright(pdfium, object, geometry, column.x + style.cellPadding + line.x, row.y + style.cellPadding + line.baseline);
+                    place(object, OBJECT_TEXT, memberMark, member);
+                }
+            });
+        });
+        if (insertAt === undefined)
+            context.appendObjects(pageIndex, records);
+        else
+            context.spliceObjects(pageIndex, insertAt, 0, records);
+    });
+    return {
+        overflow,
+        ...(font.substitution ? { substitution: font.substitution } : {}),
+    };
+}
+/** Redraws a table from `spec` at the same place in the drawing order. */
+export function rebuildTable(context, location, spec) {
+    const first = removeObjects(context, location);
+    return drawTable(context, location.pageIndex, spec, first);
+}
+/** The location and stored inputs of a table, or the issue that stops the edit. */
+export function tableTarget(target, context, issue = () => { }) {
+    const location = context.locate(target);
+    if (!location) {
+        issue("/target", "unknown-target", `No element ${target}`);
+        return undefined;
+    }
+    const spec = tableSpecOf(location.record.mark);
+    if (!spec) {
+        issue("/target", "unsupported-target", "Only tables created by web-doc have cells");
+        return undefined;
+    }
+    return { location, spec };
+}
+/** The spec a mark carries when it is a table's head mark. */
+export function tableSpecOf(mark) {
+    return mark?.kind === "table" && Array.isArray(mark.rows)
+        ? mark
+        : undefined;
+}
+export function changedTable(location, drawn) {
+    return {
+        createdIds: [],
+        changedPages: [location.pageIndex],
+        warnings: tableWarnings(drawn, location.record.id),
+    };
+}
+/** Every cell's text, for font coverage checks. */
+export function tableText(rows) {
+    return rows.flat().join("\n");
+}
+export function tableFontRequest(style, text) {
+    return { family: style.fontFamily, bold: false, italic: false, text };
+}
+export function resolveTableStyle(style) {
+    return {
+        fontFamily: style.fontFamily ?? "Helvetica",
+        fontSize: style.fontSize ?? 10,
+        color: style.color ?? "#000000",
+        borderColor: style.borderColor ?? "#000000",
+        borderWidth: style.borderWidth ?? 0.75,
+        cellPadding: style.cellPadding ?? 4,
+        headerFill: style.headerFill ?? null,
+    };
+}
+/** Column edges and row heights: each row is as tall as its tallest cell. */
+function layoutTable(spec, ascent, advance) {
+    const { cellPadding, fontSize } = spec.style;
+    const columns = [];
+    let x = spec.at.x;
+    for (const width of spec.columnWidths) {
+        columns.push({ x, width });
+        x += width;
+    }
+    const rows = [];
+    let y = spec.at.y;
+    for (const cells of spec.rows) {
+        const layouts = cells.map((text, columnIndex) => layoutText({
+            text,
+            width: columns[columnIndex].width - 2 * cellPadding,
+            height: Number.POSITIVE_INFINITY,
+            fontSize,
+            lineHeight: LINE_HEIGHT,
+            align: "left",
+            ascent,
+            advance,
+        }));
+        const height = Math.max(...layouts.map((layout) => layout.height)) + 2 * cellPadding;
+        rows.push({ y, height, cells: layouts.map((layout) => layout.lines) });
+        y += height;
+    }
+    return { columns, rows, height: y - spec.at.y };
+}
+/** Column widths in points from optional relative weights. */
+function resolveColumns(width, columns, weights) {
+    const relative = weights ?? Array.from({ length: columns }, () => 1);
+    const total = relative.reduce((sum, weight) => sum + weight, 0);
+    return relative.map((weight) => (weight / total) * width);
+}
+function validateRows(rows, issue) {
+    if (rows.length === 0 || rows.length > MAX_ROWS) {
+        issue("/rows", "range", `A table has 1 to ${MAX_ROWS} rows`);
+        return false;
+    }
+    const columns = rows[0].length;
+    if (columns === 0 || columns > MAX_COLUMNS) {
+        issue("/rows/0", "range", `A table has 1 to ${MAX_COLUMNS} columns`);
+        return false;
+    }
+    let ok = true;
+    rows.forEach((row, index) => {
+        if (row.length !== columns) {
+            issue(`/rows/${index}`, "range", `Row ${index} has ${row.length} cells; the first row has ${columns}`);
+            ok = false;
+        }
+    });
+    return ok;
+}
+function validateTableFont(style, text, context, issue, textPath) {
+    const problem = context.fonts.problem(tableFontRequest(style, text));
+    if (problem)
+        issue(problem.path === "/text" ? textPath : problem.path, problem.code, problem.message);
+}
+function tableWarnings(drawn, elementId) {
+    return [
+        ...(drawn.overflow
+            ? [
+                {
+                    code: "fidelity-degraded",
+                    message: "The table runs past the bottom of the page",
+                    details: { elementId },
+                },
+            ]
+            : []),
+        ...(drawn.substitution
+            ? [
+                {
+                    code: "font-substitution",
+                    message: drawn.substitution,
+                    details: { elementId },
+                },
+            ]
+            : []),
+    ];
+}

package/dist/edit/pdf/engine/text-box.d.ts

@@ -0,0 +1,71 @@
+import type { EditOperation, PageRect } from "../../types.js";
+import type { InsertTextBoxOperation, PdfElement, PdfTextAlign, PdfTextBoxStyle, ReplaceTextOperation, SetTextStyleOperation } from "../types.js";
+import { type MarkParams } from "./elements.js";
+import type { FontRequest } from "./fonts.js";
+import { type PageGeometry } from "./geometry.js";
+import type { ElementLocation, Issue, OperationContext, OperationHandler, OperationResult } from "./operations.js";
+import type { Pdfium } from "./pdfium.js";
+/** A text box's inputs with every default filled in; stored in its mark. */
+export type TextBoxSpec = {
+    readonly kind: "textBox";
+    readonly id: string;
+    readonly rect: PageRect;
+    readonly text: string;
+    readonly style: {
+        readonly fontFamily: string;
+        readonly fontSize: number;
+        readonly bold: boolean;
+        readonly italic: boolean;
+        readonly color: string;
+        readonly align: PdfTextAlign;
+        readonly lineHeight: number;
+    };
+};
+export declare const insertTextBox: OperationHandler<InsertTextBoxOperation>;
+/** `replaceText` for a text box: a rebuild from its inputs with new text. */
+export declare const textBoxReplaceText: OperationHandler<ReplaceTextOperation>;
+/** `setTextStyle` for a text box: a rebuild with the merged style. */
+export declare const textBoxSetTextStyle: OperationHandler<SetTextStyleOperation>;
+export interface DrawnTextBox {
+    readonly overflow: boolean;
+    /** Set when the text was drawn with another font than asked for. */
+    readonly substitution?: string;
+}
+/**
+ * Lays the box out and inserts one text object per line, appended to the
+ * page or at `insertAt` in drawing order.
+ */
+export declare function drawTextBox(context: OperationContext, pageIndex: number, spec: TextBoxSpec, insertAt?: number): DrawnTextBox;
+/**
+ * Replaces a text box's objects with ones drawn from `spec`, at the same
+ * place in the drawing order so nothing else changes its stacking.
+ */
+export declare function rebuildTextBox(context: OperationContext, location: ElementLocation, spec: TextBoxSpec): DrawnTextBox;
+/** Removes an element's objects from the page; returns where they started. */
+export declare function removeObjects(context: OperationContext, location: ElementLocation): number;
+/** The location and stored inputs of a text box, or the issue that stops the edit. */
+export declare function textBoxTarget(target: string, context: OperationContext, issue?: Issue): {
+    readonly location: ElementLocation;
+    readonly spec: TextBoxSpec;
+} | undefined;
+export declare function changed(location: ElementLocation, drawn: DrawnTextBox): OperationResult;
+/**
+ * The fonts a batch will need: what each operation draws, read from the
+ * operation itself, from the text box it rebuilds, or from the text object
+ * it may have to replace.
+ */
+export declare function fontRequestsOf(operations: readonly EditOperation[], markOf: (id: string) => MarkParams | undefined, elementOf: (id: string) => PdfElement | undefined): {
+    readonly family: string;
+    readonly text: string;
+}[];
+export declare function fontRequest(style: TextBoxSpec["style"], text: string): FontRequest;
+export declare function validateFont(request: FontRequest, context: OperationContext, issue: Issue): void;
+/**
+ * Positions an object so it reads upright on the displayed page: the object's
+ * origin goes to the page-space point and it turns against the page's /Rotate.
+ */
+export declare function placeUpright(pdfium: Pdfium, object: number, geometry: PageGeometry, pageX: number, pageY: number): void;
+export declare function setText(pdfium: Pdfium, object: number, text: string): void;
+export declare function parseColor(color: string): [number, number, number];
+export declare function resolveStyle(style: PdfTextBoxStyle): TextBoxSpec["style"];
+export declare function validateRect(rect: PageRect, geometry: PageGeometry, issue: Issue, path?: string): void;