web-doc 0.11.0 → 0.12.0

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

@@ -1,4 +1,5 @@
 import type { EditWorkerFont } from "../../../worker-protocol.js";
+import type { Issue } from "./operations.js";
 import type { Pdfium } from "./pdfium.js";
 export declare const FALLBACK_FAMILY = "Noto Sans";
 export declare function isStandardFamily(family: string): boolean;
@@ -76,3 +77,16 @@ export declare class TextMeasurer {
         descent: number;
     };
 }
+/** True only when the original native font is known to encode every character. */
+export declare function fontCanDraw(pdfium: Pdfium, font: number, text: string): boolean;
+/**
+ * Whether one text object can be rewritten in its own font: what
+ * `fontCanDraw` proves, extended to bare CFF subsets, whose glyph names say
+ * what they draw, and narrowed to characters the PDF gives an advance, since
+ * a subset's widths list only the codes it used. Paragraph reflow keeps to
+ * `fontCanDraw`, which also decides which rows join a paragraph.
+ */
+export declare function fontCanRewrite(pdfium: Pdfium, font: number, text: string): boolean;
+export declare function fontBytes(pdfium: Pdfium, font: number): Uint8Array | undefined;
+/** Right-to-left scripts need shaping the MVP does not do. */
+export declare function validateScript(text: string, issue: Issue): boolean;

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

@@ -1,3 +1,4 @@
+import { glyphUnicode, readCff } from "./cff.js";
 /*
  * Fonts for text web-doc writes into a PDF: the standard 14 fonts for
  * WinAnsi text, host-registered TrueType fonts, and a bundled Noto Sans
@@ -467,3 +468,116 @@ export class TextMeasurer {
         }
     }
 }
+/** True only when the original native font is known to encode every character. */
+export function fontCanDraw(pdfium, font, text) {
+    const { lib } = pdfium;
+    if (!lib.FPDFFont_GetIsEmbedded(font)) {
+        const base = pdfium.readUtf8String((buffer, bytes) => lib.FPDFFont_GetBaseFontName(font, buffer, bytes));
+        return (isStandardFamily(base.split(/[-,]/)[0] ?? "") &&
+            firstNonWinAnsi(text) === undefined);
+    }
+    const coverage = fontCoverage(pdfium, font);
+    if (!coverage)
+        return false;
+    return [...text].every((character) => {
+        const code = character.codePointAt(0);
+        // A space needs an encoding even though a valid space has no outline.
+        // Imported subsets can omit its cmap entry and use positioned word gaps.
+        if (code === 0x20)
+            return (coverage.glyph(code) ?? 0) !== 0;
+        return code === 0x0a || coverage.drawable(code);
+    });
+}
+/**
+ * Whether one text object can be rewritten in its own font: what
+ * `fontCanDraw` proves, extended to bare CFF subsets, whose glyph names say
+ * what they draw, and narrowed to characters the PDF gives an advance, since
+ * a subset's widths list only the codes it used. Paragraph reflow keeps to
+ * `fontCanDraw`, which also decides which rows join a paragraph.
+ */
+export function fontCanRewrite(pdfium, font, text) {
+    const characters = [...text].filter((character) => character !== "\n");
+    if (!characters.every((character) => advance(pdfium, font, character.codePointAt(0)) > 0))
+        return false;
+    if (fontCanDraw(pdfium, font, text))
+        return true;
+    if (!pdfium.lib.FPDFFont_GetIsEmbedded(font))
+        return false;
+    const data = fontBytes(pdfium, font);
+    const coverage = data && cffCoverage(data);
+    if (!coverage)
+        return false;
+    // A space needs a glyph of its own, as in `fontCanDraw`.
+    return characters.every((character) => coverage.has(character.codePointAt(0)));
+}
+/** The PDF's width for a character, per 1000 units of size; 0 for one it gives none or PDFium cannot ask about. */
+function advance(pdfium, font, code) {
+    // PDFium takes one UTF-16 code unit.
+    if (code > 0xffff)
+        return 0;
+    return (pdfium.readNumbers(1, "float", ([width]) => pdfium.lib.FPDFFont_GetGlyphWidth(font, code, 1000, width))?.[0] ?? 0);
+}
+/**
+ * A bare CFF program's glyphs by the code points their names stand for, as a
+ * simple font draws them: its encoding names the glyph. A CID-keyed program
+ * names none, and only its PDF CMap would say what its glyphs draw.
+ */
+function cffCoverage(data) {
+    const cff = readCff(data);
+    if (!cff || cff.cid)
+        return undefined;
+    const glyphs = new Map();
+    cff.glyphNames.forEach((name, glyph) => {
+        const code = glyphUnicode(name);
+        if (glyph !== 0 && code !== undefined && !glyphs.has(code))
+            glyphs.set(code, glyph);
+    });
+    return {
+        has: (code) => glyphs.has(code),
+        glyph: (code) => glyphs.get(code),
+        drawable: (code) => glyphs.has(code),
+    };
+}
+function fontCoverage(pdfium, font) {
+    const data = fontBytes(pdfium, font);
+    if (!data)
+        return undefined;
+    const tag = String.fromCharCode(...data.slice(0, 4));
+    const truetype = (data[0] === 0 && data[1] === 1 && data[2] === 0 && data[3] === 0) ||
+        tag === "true";
+    return truetype ? parseCmap(data) : undefined;
+}
+export function fontBytes(pdfium, font) {
+    const { lib } = pdfium;
+    const size = pdfium.readNumbers(1, "i32", ([out]) => lib.FPDFFont_GetFontData(font, 0, 0, out))?.[0];
+    if (!size)
+        return undefined;
+    const buffer = pdfium.malloc(size);
+    try {
+        const out = pdfium.malloc(4);
+        try {
+            if (!lib.FPDFFont_GetFontData(font, buffer, size, out))
+                return undefined;
+        }
+        finally {
+            pdfium.free(out);
+        }
+        return pdfium.readBytes(buffer, size);
+    }
+    finally {
+        pdfium.free(buffer);
+    }
+}
+/** Right-to-left scripts need shaping the MVP does not do. */
+export function validateScript(text, issue) {
+    for (const character of text) {
+        const code = character.codePointAt(0);
+        if ((code >= 0x0590 && code <= 0x08ff) ||
+            (code >= 0xfb1d && code <= 0xfdff) ||
+            (code >= 0xfe70 && code <= 0xfeff)) {
+            issue("/text", "unsupported-script", `Right-to-left text such as "${character}" cannot be edited yet`);
+            return false;
+        }
+    }
+    return true;
+}

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

@@ -84,6 +84,8 @@ export function createPdfEditHandler(host) {
             }
             case "edit-text-layout":
                 return engine().textLayout(payload.id);
+            case "edit-text-paragraph":
+                return engine().textParagraph(payload.id);
             case "edit-position-at": {
                 const { pageIndex, point } = payload;
                 return engine().positionAt(pageIndex, point);

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

@@ -2,7 +2,7 @@ import { textStyle } from "./elements.js";
 import { pageToUser, rectContains, round, roundRect, unionRects, userRectToPage, userToPage, } from "./geometry.js";
 /** How far a point may be from a glyph for `FPDFText_GetCharIndexAtPos`. */
 const HIT_TOLERANCE = 2;
-const TEXT_KINDS = new Set(["text", "textBox", "table"]);
+const TEXT_KINDS = new Set(["text", "textBox", "table", "paragraph"]);
 /** The layout of one element, or `undefined` when it draws no text. */
 export function layoutOf(pdfium, scan, element) {
     if (!TEXT_KINDS.has(element.kind))

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

@@ -1,12 +1,13 @@
 import type { ResourceLimits, ViewerWarning } from "../../../contracts.js";
 import type { AssetSource } from "../../assets.js";
 import type { ImageCache } from "./images.js";
-import type { OperationIssue } from "../../types.js";
+import type { OperationIssue, TextAnchorMigration } from "../../types.js";
 import type { PdfElement, PdfOperation } from "../types.js";
 import type { PageGeometry } from "./geometry.js";
 import type { ObjectRecord } from "./elements.js";
 import type { Pdfium } from "./pdfium.js";
 import type { FontLibrary, TextMeasurer } from "./fonts.js";
+import type { ParagraphTarget } from "./paragraph.js";
 /** What an operation sees of the document while validating or applying. */
 export interface OperationContext {
     readonly pdfium: Pdfium;
@@ -24,12 +25,16 @@ export interface OperationContext {
     newId(pageIndex: number, suffix?: string): string;
     /** Loads a page for writing; its content is regenerated afterwards. */
     withPage<T>(pageIndex: number, use: (page: number) => T): T;
+    /** Reads native resources without regenerating the content stream. */
+    readPage<T>(pageIndex: number, use: (page: number) => T): T;
     /** Records objects appended to a page by this operation. */
     appendObjects(pageIndex: number, records: readonly ObjectRecord[]): void;
     /** Where an element's objects sit: their page and their indexes in drawing order. */
     locate(id: string): ElementLocation | undefined;
     /** The element as a query would return it. */
     element(id: string): PdfElement | undefined;
+    paragraph(id: string): ParagraphTarget | undefined;
+    pageElements(pageIndex: number): readonly PdfElement[];
     /** Ids of every element on a page, for what a page deletion removes. */
     pageElementIds(pageIndex: number): readonly string[];
     /** Displayed size of a page in points. */
@@ -56,6 +61,7 @@ export interface OperationResult {
     readonly createdIds: readonly string[];
     /** Ids the operation made disappear. */
     readonly removedIds?: readonly string[];
+    readonly textAnchorMigrations?: readonly Omit<TextAnchorMigration, "operationIndex">[];
     readonly changedPages: readonly number[];
     readonly warnings: readonly ViewerWarning[];
 }

package/dist/edit/pdf/engine/paragraph-edit.d.ts

@@ -0,0 +1,4 @@
+import type { ReplaceParagraphTextOperation, SetTextStyleOperation } from "../types.js";
+import type { OperationHandler } from "./operations.js";
+export declare const replaceParagraphText: OperationHandler<ReplaceParagraphTextOperation>;
+export declare const paragraphSetTextStyle: OperationHandler<SetTextStyleOperation>;

package/dist/edit/pdf/engine/paragraph-edit.js

@@ -0,0 +1,331 @@
+import { ViewerError } from "../../../errors.js";
+import { MARK_NAME, MARK_PARAM, OBJECT_PATH, OBJECT_TEXT } from "./elements.js";
+import { fontCanDraw, isStandardFamily, validateScript } from "./fonts.js";
+import { pageToUser, round } from "./geometry.js";
+import { layoutText } from "./text-layout.js";
+import { parseColor, placeUpright, setText } from "./text-box.js";
+import { intersects, } from "./paragraph.js";
+export const replaceParagraphText = {
+    validate(operation, context, issue) {
+        const target = targetOf(operation.target, context, issue);
+        if (!target)
+            return;
+        const text = replacement(operation, target.spec.text, issue);
+        if (text === undefined || !validateScript(text, issue))
+            return;
+        if (text.length > 20000) {
+            issue("/text", "max-length", "The complete paragraph cannot exceed 20000 characters");
+            return;
+        }
+        prepare(context, target, { ...target.spec, text }, issue);
+    },
+    apply(operation, context) {
+        const target = requireTarget(operation.target, context);
+        const text = replacement(operation, target.spec.text);
+        if (text === undefined)
+            throw new ViewerError("invalid-operation", "Invalid paragraph range");
+        return rebuild(context, target, { ...target.spec, text });
+    },
+};
+export const paragraphSetTextStyle = {
+    validate(operation, context, issue) {
+        const target = targetOf(operation.target, context, issue);
+        if (!target)
+            return;
+        for (const field of [
+            "fontFamily",
+            "bold",
+            "italic",
+            "align",
+            "lineHeight",
+        ])
+            if (operation.style[field] !== undefined)
+                issue(`/style/${field}`, "unsupported-style", `Only color and fontSize can change on imported paragraphs; ${field} cannot`);
+        const spec = styled(target.spec, operation);
+        if (spec.style.fontSize !== target.spec.style.fontSize)
+            prepare(context, target, spec, issue);
+    },
+    apply(operation, context) {
+        const target = requireTarget(operation.target, context);
+        const spec = styled(target.spec, operation);
+        if (spec.style.fontSize === target.spec.style.fontSize)
+            return colorInPlace(context, target, spec);
+        return rebuild(context, target, spec);
+    },
+};
+/** Color never rewrites glyphs or changes an imported font resource. */
+function colorInPlace(context, target, spec) {
+    const { pdfium } = context;
+    const { lib } = pdfium;
+    const color = parseColor(spec.style.color);
+    const persisted = target.paragraph.memberIds.includes(spec.id);
+    context.withPage(target.paragraph.pageIndex, (page) => {
+        for (const index of target.indexes) {
+            const object = lib.FPDFPage_GetObject(page, index);
+            if (lib.FPDFPageObj_GetType(object) === OBJECT_TEXT)
+                lib.FPDFPageObj_SetFillColor(object, ...color, 255);
+            if (!persisted)
+                continue;
+            for (let at = 0; at < lib.FPDFPageObj_CountMarks(object); at += 1) {
+                const mark = lib.FPDFPageObj_GetMark(object, at);
+                const name = pdfium.readWideStringOut((buffer, bytes, out) => lib.FPDFPageObjMark_GetName(mark, buffer, bytes, out));
+                if (name === MARK_NAME)
+                    lib.FPDFPageObjMark_SetStringParam(context.document, object, mark, MARK_PARAM, JSON.stringify(spec));
+            }
+            context.spliceObjects(target.paragraph.pageIndex, index, 1, [
+                { id: spec.id, type: lib.FPDFPageObj_GetType(object), mark: spec },
+            ]);
+        }
+    });
+    return {
+        createdIds: [],
+        changedPages: [target.paragraph.pageIndex],
+        warnings: [],
+    };
+}
+function styled(spec, operation) {
+    return {
+        ...spec,
+        style: {
+            ...spec.style,
+            ...(operation.style.fontSize === undefined
+                ? {}
+                : { fontSize: round(operation.style.fontSize) }),
+            ...(operation.style.color === undefined
+                ? {}
+                : { color: operation.style.color }),
+        },
+    };
+}
+function targetOf(id, context, issue) {
+    const target = context.paragraph(id);
+    if (!target || target.paragraph.id !== id) {
+        issue("/target", "unsupported-target", "The target must be a resolved native paragraph id");
+        return undefined;
+    }
+    return target;
+}
+function requireTarget(id, context) {
+    const target = targetOf(id, context, () => { });
+    if (!target)
+        throw new ViewerError("invalid-operation", "The paragraph no longer exists");
+    return target;
+}
+function replacement(operation, previous, issue = () => { }) {
+    const range = operation.range;
+    if (!range)
+        return operation.text;
+    const valid = [range.start, range.end].every((position) => position.elementId === operation.target &&
+        Number.isInteger(position.offset) &&
+        position.offset >= 0 &&
+        position.offset <= previous.length);
+    if (!valid || range.start.offset > range.end.offset) {
+        issue("/range", "invalid-range", "The range must lie inside the paragraph's logical text");
+        return undefined;
+    }
+    return (previous.slice(0, range.start.offset) +
+        operation.text +
+        previous.slice(range.end.offset));
+}
+function fontFor(context, target, spec, page) {
+    const { lib } = context.pdfium;
+    const original = target.indexes
+        .map((index) => lib.FPDFPage_GetObject(page, index))
+        .find((object) => lib.FPDFPageObj_GetType(object) === OBJECT_TEXT);
+    const native = original === undefined ? undefined : lib.FPDFTextObj_GetFont(original);
+    if (native !== undefined && fontCanDraw(context.pdfium, native, spec.text))
+        return {
+            handle: native,
+            family: spec.style.fontFamily,
+            substituted: false,
+        };
+    const family = isStandardFamily(spec.style.fontFamily) ||
+        context.fonts.hasFamily(spec.style.fontFamily)
+        ? spec.style.fontFamily
+        : "Helvetica";
+    const request = {
+        family,
+        bold: spec.style.bold,
+        italic: spec.style.italic,
+        text: spec.text,
+    };
+    const problem = context.fonts.problem(request);
+    if (problem)
+        return { problem };
+    const font = context.fonts.resolve(context.pdfium, context.document, request);
+    return {
+        handle: font.handle,
+        family: font.family,
+        substituted: original !== undefined || !isStandardFamily(spec.style.fontFamily),
+        ...(font.substitution ? { substitution: font.substitution } : {}),
+    };
+}
+/** Validate the actual final baseline/descent, not line-count × leading. */
+function prepare(context, target, spec, issue) {
+    return context.readPage(target.paragraph.pageIndex, (page) => {
+        const font = fontFor(context, target, spec, page);
+        if ("problem" in font) {
+            issue(font.problem.path, font.problem.code, font.problem.message);
+            return undefined;
+        }
+        const metrics = context.measurer.metrics(font.handle, spec.style.fontSize);
+        const layout = layoutText({
+            text: spec.text,
+            width: spec.rect.width,
+            height: Number.POSITIVE_INFINITY,
+            fontSize: spec.style.fontSize,
+            lineHeight: spec.style.lineHeight,
+            align: "left",
+            ascent: spec.baselineOffset * spec.style.fontSize,
+            advance: (text) => context.measurer.advance(font.handle, spec.style.fontSize, text),
+        });
+        const last = layout.lines.at(-1);
+        const height = spec.text.trim() && last
+            ? last.baseline + metrics.descent
+            : spec.rect.height;
+        const rect = { ...spec.rect, height: Math.max(height, 0.001) };
+        const size = context.pageSize(target.paragraph.pageIndex);
+        const members = new Set(target.paragraph.memberIds);
+        const collision = context
+            .pageElements(target.paragraph.pageIndex)
+            .some((element) => {
+            if (members.has(element.id) || !intersects(rect, element.bounds))
+                return false;
+            // An already-present background stays in its own drawing position.
+            const old = target.spec.rect;
+            const b = element.bounds;
+            const location = context.locate(element.id);
+            const behind = location &&
+                location.indexes.every((index) => index < target.indexes[0]);
+            return !(element.text === undefined &&
+                behind &&
+                b.x <= old.x &&
+                b.y <= old.y &&
+                b.x + b.width >= rect.x + rect.width &&
+                b.y + b.height >= rect.y + rect.height);
+        });
+        if (collision ||
+            rect.x < 0 ||
+            rect.y < 0 ||
+            rect.x + rect.width > size.width + 0.01 ||
+            rect.y + rect.height > size.height + 0.01) {
+            issue("/text", "paragraph-overflow", "The paragraph would overlap neighboring content or leave the page");
+            return undefined;
+        }
+        const warnings = font.substituted
+            ? [
+                {
+                    code: "font-substitution",
+                    message: "substitution" in font && font.substitution
+                        ? font.substitution
+                        : `${spec.style.fontFamily} cannot draw the new paragraph; ${font.family} is used`,
+                    details: { elementId: spec.id },
+                },
+            ]
+            : [];
+        return {
+            spec: {
+                ...spec,
+                rect,
+                lines: layout.lines.map((line) => line.text).filter(Boolean),
+                style: {
+                    ...spec.style,
+                    fontFamily: font.substituted ? font.family : spec.style.fontFamily,
+                },
+            },
+            layout,
+            warnings,
+        };
+    });
+}
+function rebuild(context, target, spec) {
+    const issues = [];
+    const prepared = prepare(context, target, spec, (path, code, message) => issues.push({ path, code, message }));
+    if (!prepared)
+        throw new ViewerError("invalid-operation", "The paragraph cannot be changed", { details: { issues } });
+    const { pdfium } = context;
+    const { lib } = pdfium;
+    const pageIndex = target.paragraph.pageIndex;
+    const geometry = context.geometry(pageIndex);
+    const first = target.indexes[0];
+    context.withPage(pageIndex, (page) => {
+        const font = fontFor(context, target, spec, page);
+        if ("problem" in font)
+            throw new ViewerError("invalid-operation", font.problem.message);
+        const objects = [];
+        const [r, g, b] = parseColor(spec.style.color);
+        // Construct before removing borrowed font owners. Empty drafts use a
+        // non-painting native path, so no placeholder character leaks into text.
+        if (!spec.text.trim()) {
+            const rect = prepared.spec.rect;
+            const origin = pageToUser(geometry, rect.x, rect.y + rect.height);
+            const object = lib.FPDFPageObj_CreateNewRect(origin.x, origin.y, rect.width, rect.height);
+            // PDFium discards a path ending in `n` when reopening. A zero-alpha
+            // fill preserves the native marked object without painting any pixels.
+            lib.FPDFPageObj_SetFillColor(object, 0, 0, 0, 0);
+            lib.FPDFPath_SetDrawMode(object, 1, false);
+            objects.push({ object, type: OBJECT_PATH });
+        }
+        else
+            for (const line of prepared.layout.lines) {
+                if (!line.text)
+                    continue;
+                const object = lib.FPDFPageObj_CreateTextObj(context.document, font.handle, spec.style.fontSize);
+                if (!object) {
+                    for (const made of objects)
+                        lib.FPDFPageObj_Destroy(made.object);
+                    throw new ViewerError("edit-failed", "PDFium could not create paragraph text");
+                }
+                setText(pdfium, object, line.text);
+                lib.FPDFPageObj_SetFillColor(object, r, g, b, 255);
+                placeUpright(pdfium, object, geometry, spec.rect.x + line.x, spec.rect.y + line.baseline);
+                objects.push({ object, type: OBJECT_TEXT });
+            }
+        const params = JSON.stringify(prepared.spec);
+        for (const { object } of objects) {
+            const mark = lib.FPDFPageObj_AddMark(object, MARK_NAME);
+            lib.FPDFPageObjMark_SetStringParam(context.document, object, mark, MARK_PARAM, params);
+        }
+        for (const index of [...target.indexes].reverse()) {
+            const object = lib.FPDFPage_GetObject(page, index);
+            lib.FPDFPage_RemoveObject(page, object);
+            lib.FPDFPageObj_Destroy(object);
+            context.spliceObjects(pageIndex, index, 1, []);
+        }
+        objects.forEach(({ object }, at) => lib.FPDFPage_InsertObjectAtIndex(page, object, first + at));
+        const textPage = lib.FPDFText_LoadPage(page);
+        try {
+            const drawn = objects
+                .filter(({ type }) => type === OBJECT_TEXT)
+                .map(({ object }) => pdfium
+                .readWideString((buffer, bytes) => lib.FPDFTextObj_GetText(object, textPage, buffer, bytes))
+                .trimEnd());
+            if (drawn.length !== prepared.spec.lines.length ||
+                drawn.some((line, index) => line !== prepared.spec.lines[index]))
+                throw new ViewerError("edit-failed", "The native font could not encode the paragraph faithfully");
+        }
+        finally {
+            lib.FPDFText_ClosePage(textPage);
+        }
+        context.spliceObjects(pageIndex, first, 0, objects.map(({ type }) => ({ id: spec.id, type, mark: prepared.spec })));
+    });
+    const promoted = !target.paragraph.memberIds.includes(spec.id);
+    // The logical paragraph already existed before promotion. Reporting it as
+    // newly created would incorrectly destroy its ranges when Undo restores rows.
+    return {
+        createdIds: [],
+        removedIds: promoted ? target.paragraph.memberIds : [],
+        ...(promoted
+            ? {
+                textAnchorMigrations: target.paragraph.members.map((member) => ({
+                    sourceElementId: member.elementId,
+                    targetElementId: spec.id,
+                    sourceLength: member.end - member.start,
+                    targetOffset: member.start,
+                })),
+            }
+            : {}),
+        changedPages: [pageIndex],
+        warnings: prepared.warnings,
+    };
+}

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

@@ -0,0 +1,31 @@
+import type { PageRect } from "../../types.js";
+import type { PdfElement, PdfTextParagraph } from "../types.js";
+import { type MarkParams, type ObjectRecord } from "./elements.js";
+import { type PageGeometry } from "./geometry.js";
+import { type TextMeasurer } from "./fonts.js";
+import type { Pdfium } from "./pdfium.js";
+/** Persisted inputs, validated at the PDF marked-content boundary. */
+export interface ParagraphSpec extends MarkParams {
+    readonly kind: "paragraph";
+    readonly rect: PageRect;
+    readonly text: string;
+    /** Actual native line strings, retained to detect edits made by another tool. */
+    readonly lines: readonly string[];
+    readonly style: PdfTextParagraph["textStyle"];
+    /** First baseline relative to rect.y, in multiples of the current style font size. */
+    readonly baselineOffset: number;
+}
+export interface ParagraphTarget {
+    readonly paragraph: PdfTextParagraph;
+    readonly spec: ParagraphSpec;
+    /** Native drawing-order indexes, not logical reading order. */
+    readonly indexes: readonly number[];
+}
+export declare function paragraphElement(paragraph: PdfTextParagraph): PdfElement;
+/**
+ * Conservative import recognition. Only whole, equally styled native lines
+ * with uniform upright matrices and regular left-aligned leading participate.
+ * Content-stream order is deliberately irrelevant to reading order.
+ */
+export declare function discoverParagraphs(pdfium: Pdfium, page: number, pageIndex: number, geometry: PageGeometry, records: readonly ObjectRecord[], elements: readonly PdfElement[], textPage: number, measurer: TextMeasurer): ReadonlyMap<string, ParagraphTarget>;
+export declare function intersects(a: PageRect, b: PageRect): boolean;