web-doc 0.11.0 → 0.12.1

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;
@@ -214,16 +169,30 @@ function replaceInPlace(context, target, text) {
     context.withPage(target.location.pageIndex, (page) => {
         setText(pdfium, lib.FPDFPage_GetObject(page, index), text);
     });
-    const readBack = context.withPage(target.location.pageIndex, (page) => {
+    const faithful = context.withPage(target.location.pageIndex, (page) => {
         const textPage = lib.FPDFText_LoadPage(page);
         try {
-            return pdfium.readWideString((buffer, bytes) => lib.FPDFTextObj_GetText(lib.FPDFPage_GetObject(page, index), textPage, buffer, bytes));
+            const object = lib.FPDFPage_GetObject(page, index);
+            const readBack = pdfium.readWideString((buffer, bytes) => lib.FPDFTextObj_GetText(object, textPage, buffer, bytes));
+            if (readBack === text)
+                return true;
+            // Reading-order extraction can append a generated gap before the next
+            // object. Verify the object's own characters instead, retaining every
+            // authored space: trimming would also hide a lost deliberate space.
+            let authored = "";
+            const count = lib.FPDFText_CountChars(textPage);
+            for (let at = 0; at < count; at += 1) {
+                if (lib.FPDFText_GetTextObject(textPage, at) === object &&
+                    lib.FPDFText_IsGenerated(textPage, at) === 0)
+                    authored += String.fromCodePoint(lib.FPDFText_GetUnicode(textPage, at));
+            }
+            return authored === text;
         }
         finally {
             lib.FPDFText_ClosePage(textPage);
         }
     });
-    if (readBack === text)
+    if (faithful)
         return true;
     // Put the old text back so the fallback path starts from a known state.
     context.withPage(target.location.pageIndex, (page) => {

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