web-doc 0.10.0 → 0.12.0

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

@@ -1,6 +1,6 @@
 import { validateSchema } from "../../schema.js";
-import { tableMarkSchema, tableMemberMarkSchema, textBoxMarkSchema, } from "../schemas.js";
-import { round, roundRect, unionRects, userRectToPage, } from "./geometry.js";
+import { tableMarkSchema, tableMemberMarkSchema, textBoxMarkSchema, paragraphMarkSchema, } from "../schemas.js";
+import { pageToUser, round, roundRect, unionRects, userRectToPage, } from "./geometry.js";
 /** FPDFPageObj_GetType values. */
 export const OBJECT_TEXT = 1;
 export const OBJECT_PATH = 2;
@@ -11,6 +11,20 @@ export const MARK_PARAM = "webdoc";
 /** Font descriptor flag bits (PDF 32000-1 table 123). */
 const FLAG_ITALIC = 1 << 6;
 const FLAG_FORCE_BOLD = 1 << 18;
+export function paragraphSpecOf(mark) {
+    return validateSchema(mark, paragraphMarkSchema, 0).length === 0
+        ? mark
+        : undefined;
+}
+/** Paragraph marks store the upright frame; the page may subsequently rotate. */
+export function paragraphBounds(spec, geometry) {
+    if (geometry.rotation === 0)
+        return spec.rect;
+    const upright = { ...geometry, rotation: 0 };
+    const top = pageToUser(upright, spec.rect.x, spec.rect.y);
+    const bottom = pageToUser(upright, spec.rect.x + spec.rect.width, spec.rect.y + spec.rect.height);
+    return roundRect(userRectToPage(geometry, top.x, bottom.y, bottom.x, top.y));
+}
 /**
  * Reads the objects of a loaded page in drawing order and turns them into
  * elements: plain objects become one element each, objects tagged with the
@@ -46,7 +60,7 @@ export function scanPage(pdfium, page, textPage, pageIndex, geometry, records) {
             const members = groups.get(element.id);
             const record = members && records.find((entry) => entry.id === element.id);
             return members && record?.mark
-                ? compositeElement(record.mark, members, pageIndex)
+                ? compositeElement(record.mark, members, pageIndex, geometry)
                 : element;
         }),
         byObject,
@@ -77,6 +91,8 @@ function isValidMark(params) {
     switch (params.kind) {
         case "textBox":
             return validateSchema(params, textBoxMarkSchema, 0).length === 0;
+        case "paragraph":
+            return validateSchema(params, paragraphMarkSchema, 0).length === 0;
         case "table":
             return (validateSchema(params, tableMarkSchema, 0).length === 0 ||
                 validateSchema(params, tableMemberMarkSchema, 0).length === 0);
@@ -104,11 +120,58 @@ export function markIsFresh(pdfium, page, textPage, geometry, mark, indexes) {
         .map((object) => textOf(pdfium, object, textPage))
         .join(" "));
     const tolerance = 2;
-    if (mark.kind === "textBox") {
+    if (mark.kind === "paragraph") {
+        const spec = paragraphSpecOf(mark);
+        if (!spec ||
+            objects.some((object) => {
+                if (lib.FPDFPageObj_GetType(object) !== OBJECT_TEXT) {
+                    if (spec.text.trim().length !== 0 ||
+                        lib.FPDFPageObj_GetType(object) !== OBJECT_PATH)
+                        return true;
+                    const mode = pdfium.readNumbers(2, "i32", ([fill, stroke]) => lib.FPDFPath_GetDrawMode(object, fill, stroke));
+                    const color = pdfium.readNumbers(4, "i32", ([r, g, b, a]) => lib.FPDFPageObj_GetFillColor(object, r, g, b, a));
+                    return mode?.[0] !== 1 || mode[1] !== 0 || color?.[3] !== 0;
+                }
+                const current = textStyle(pdfium, object);
+                return (current.fontSize !== round(spec.style.fontSize) ||
+                    current.color !== spec.style.color ||
+                    current.bold !== spec.style.bold ||
+                    current.italic !== spec.style.italic);
+            }))
+            return false;
+        const frame = paragraphBounds(spec, geometry);
+        if (union.y + union.height > frame.y + frame.height + tolerance)
+            return false;
+        const nativeLines = objects
+            .filter((object) => lib.FPDFPageObj_GetType(object) === OBJECT_TEXT)
+            .map((object) => textOf(pdfium, object, textPage).trimEnd());
+        if (nativeLines.length !== spec.lines.length ||
+            nativeLines.some((line, index) => line !== spec.lines[index]))
+            return false;
+        // Native wrapping may split at whitespace or inside a long word, but it
+        // cannot invent, reorder or omit any non-whitespace logical character.
+        let cursor = 0;
+        for (const line of nativeLines) {
+            while (!spec.text.startsWith(line, cursor) &&
+                cursor < spec.text.length &&
+                /\s/u.test(spec.text[cursor]))
+                cursor += 1;
+            if (!spec.text.startsWith(line, cursor))
+                return false;
+            cursor += line.length;
+        }
+        if (spec.text.slice(cursor).trim())
+            return false;
+        if (geometry.rotation !== 0)
+            return (union.x >= frame.x - tolerance &&
+                union.y >= frame.y - tolerance &&
+                union.x + union.width <= frame.x + frame.width + tolerance);
+    }
+    if (mark.kind === "textBox" || mark.kind === "paragraph") {
         const rect = mark.rect;
         const text = mark.text;
         const style = mark.style;
-        return (drawn === normalizeText(text) &&
+        return ((mark.kind === "paragraph" || drawn === normalizeText(text)) &&
             union.x >= rect.x - tolerance &&
             union.x + union.width <= rect.x + rect.width + tolerance &&
             // The first line's ink starts inside the box's first line band; the
@@ -169,7 +232,7 @@ function plainElement(pdfium, object, textPage, record, pageIndex, geometry) {
             return { ...base, kind: "other", operations: TRANSFORM_OPERATIONS };
     }
 }
-function compositeElement(mark, members, pageIndex) {
+function compositeElement(mark, members, pageIndex, geometry) {
     const bounds = roundRect(unionRects(members.map((member) => member.bounds)));
     const text = members
         .filter((member) => member.kind === "text" && member.text)
@@ -198,6 +261,25 @@ function compositeElement(mark, members, pageIndex) {
             operations: TABLE_OPERATIONS,
         };
     }
+    const paragraph = paragraphSpecOf(mark);
+    if (paragraph)
+        return {
+            id: mark.id,
+            kind: "paragraph",
+            pageIndex,
+            bounds: paragraphBounds(paragraph, geometry),
+            text: paragraph.text,
+            textStyle: paragraph.style,
+            ...(geometry.rotation ? { rotation: geometry.rotation * 90 } : {}),
+            operations: geometry.rotation
+                ? ["deleteElement"]
+                : [
+                    "replaceText",
+                    "replaceParagraphText",
+                    "setTextStyle",
+                    "deleteElement",
+                ],
+        };
     const style = members.find((member) => member.textStyle)?.textStyle;
     return {
         id: mark.id,

package/dist/edit/pdf/engine/existing-text.js

@@ -1,5 +1,6 @@
+import { paragraphSetTextStyle, replaceParagraphText, } from "./paragraph-edit.js";
 import { objectBounds, OBJECT_TEXT, textScale } from "./elements.js";
-import { firstNonWinAnsi, isStandardFamily, parseCmap, } from "./fonts.js";
+import { fontCanRewrite, validateScript } from "./fonts.js";
 import { pageToUser } from "./geometry.js";
 import { parseColor, setText, textBoxReplaceText, textBoxSetTextStyle, textBoxTarget, } from "./text-box.js";
 /*
@@ -10,6 +11,8 @@ import { parseColor, setText, textBoxReplaceText, textBoxSetTextStyle, textBoxTa
  */
 export const replaceText = {
     validate(operation, context, issue) {
+        if (context.paragraph(operation.target)?.paragraph.id === operation.target)
+            return replaceParagraphText.validate({ ...operation, op: "replaceParagraphText" }, context, issue);
         const box = textBoxTarget(operation.target, context);
         if (box) {
             const spliced = splice(box.spec.text, operation, issue);
@@ -42,6 +45,8 @@ export const replaceText = {
             issue(problem.path, problem.code, problem.message);
     },
     apply(operation, context) {
+        if (context.paragraph(operation.target)?.paragraph.id === operation.target)
+            return replaceParagraphText.apply({ ...operation, op: "replaceParagraphText" }, context);
         const box = textBoxTarget(operation.target, context);
         if (box)
             return textBoxReplaceText.apply(wholeTextOperation(operation, splice(box.spec.text, operation)), context);
@@ -95,6 +100,8 @@ function spanOf(operation, previous) {
 }
 export const setTextStyle = {
     validate(operation, context, issue) {
+        if (context.paragraph(operation.target)?.paragraph.id === operation.target)
+            return paragraphSetTextStyle.validate(operation, context, issue);
         if (textBoxTarget(operation.target, context))
             return textBoxSetTextStyle.validate(operation, context, issue);
         if (!textTarget(operation.target, context, issue))
@@ -110,6 +117,8 @@ export const setTextStyle = {
                 issue(`/style/${field}`, "unsupported-style", `Only color and fontSize can change on existing text; ${field} cannot`);
     },
     apply(operation, context) {
+        if (context.paragraph(operation.target)?.paragraph.id === operation.target)
+            return paragraphSetTextStyle.apply(operation, context);
         if (textBoxTarget(operation.target, context))
             return textBoxSetTextStyle.apply(operation, context);
         const target = textTarget(operation.target, context);
@@ -139,72 +148,18 @@ function textTarget(target, context, issue = () => { }) {
     }
     return { location, element };
 }
-/** Right-to-left scripts need shaping the MVP does not do. */
-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;
-}
 /**
  * Whether the object's own font can draw `text`: a standard font for WinAnsi
- * text, or an embedded TrueType program whose cmap covers every character
- * (which also answers for subsets, since their cmaps hold only what they
- * kept).
+ * text, or an embedded TrueType or bare CFF program with a glyph for every
+ * character (which also answers for subsets, since they hold only what they
+ * kept), each with a width in the PDF.
  */
 function canKeepFont(context, target, text) {
-    const { pdfium } = context;
-    const { lib } = pdfium;
-    return context.withPage(target.location.pageIndex, (page) => {
-        const object = lib.FPDFPage_GetObject(page, target.location.indexes[0]);
-        const font = lib.FPDFTextObj_GetFont(object);
-        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;
-        for (const character of text) {
-            const code = character.codePointAt(0);
-            if (code !== 0x0a && code !== 0x20 && !coverage.drawable(code))
-                return false;
-        }
-        return true;
+    return context.readPage(target.location.pageIndex, (page) => {
+        const object = context.pdfium.lib.FPDFPage_GetObject(page, target.location.indexes[0]);
+        return fontCanRewrite(context.pdfium, context.pdfium.lib.FPDFTextObj_GetFont(object), text);
     });
 }
-function fontCoverage(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);
-        }
-        const data = pdfium.readBytes(buffer, size);
-        const tag = String.fromCharCode(data[0], data[1], data[2], data[3]);
-        const truetype = (data[0] === 0 && data[1] === 1 && data[2] === 0 && data[3] === 0) ||
-            tag === "true";
-        return truetype ? parseCmap(data) : undefined;
-    }
-    finally {
-        pdfium.free(buffer);
-    }
-}
 /** Sets the text and confirms PDFium reads it back; false means it must be replaced. */
 function replaceInPlace(context, target, text) {
     const { pdfium } = context;

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>;