web-doc 0.9.0 → 0.10.0

package/THIRD_PARTY_NOTICES.md

@@ -49,5 +49,19 @@ The release artifact contains or depends on the following principal components.
   `packages/viewer/src/edit/pptx/`, `packages/viewer/src/edit/docx/` and
   `packages/viewer/src/edit/ai/` are web-doc's own; no GenOffice code is
   included.
+- [Adobe Glyph List and Adobe Glyph List For New Fonts](https://github.com/adobe-type-tools/agl-aglfn) — BSD-3-Clause; the glyph names and code points in `packages/viewer/src/edit/pdf/engine/glyph-names.ts` (AGLFN 1.7 and nine AGL 2.0 entries), which give an embedded CFF font a Unicode cmap. The ISOAdobe glyph names in `packages/viewer/src/edit/pdf/engine/cff.ts` are the standard strings of the CFF specification (Adobe Technical Note 5176). Their license:
+
+  > Copyright 2002-2019 Adobe (http://www.adobe.com/).
+
+  > Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+  > Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+  > Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+  > Neither the name of Adobe nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+  > THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
 - [Noto Sans](https://github.com/notofonts/noto-fonts) and [Noto Sans CJK](https://github.com/notofonts/noto-cjk) subset fonts — SIL Open Font License 1.1. The font manifest, complete OFL text, pinned source commits and SHA-256 hashes are included in `dist/fonts/`.
   No Microsoft proprietary font or copyleft runtime component is bundled. Transitive notices and license expressions are verified by `npm run licenses`.

package/dist/adapters/office.js

@@ -32,7 +32,7 @@ export class OfficeDocumentAdapter {
             : (await import("../edit/pptx/provider.js")).loadPptxEditEngine(original, context, this.#options.edit ?? {}),
         createSession: (core, access) => core.format === "docx"
             ? new DocxSession(core, access)
-            : new PptxSession(core),
+            : new PptxSession(core, access),
     };
     formats = [...MODERN_FORMATS, ...LEGACY_FORMATS];
     #options;
@@ -309,6 +309,7 @@ export class OfficeDocumentAdapter {
                 y: run.shapeY + run.inShapeY,
                 width: run.w,
                 height: run.h,
+                shapeOrigin: { x: run.shapeX, y: run.shapeY },
                 ...safeHyperlink(run.hyperlink, (ref) => handle.backend.resolveInternalTarget?.(ref, pageIndex)),
                 direction: textDirection(run.text),
             }));

package/dist/contracts.d.ts

@@ -195,6 +195,15 @@ export interface TextRun {
      * source paragraph.
      */
     readonly paragraphId?: string;
+    /**
+     * PPTX: the top-left corner of the frame of the shape the run was laid out
+     * in, in the run coordinate space (slide CSS pixels). Text a shape paints
+     * past its frame, wrapped below a short box, still names its shape.
+     */
+    readonly shapeOrigin?: {
+        readonly x: number;
+        readonly y: number;
+    };
 }
 export type HyperlinkTarget = {
     readonly kind: "external";

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

@@ -0,0 +1,28 @@
+/** What a browser font is built from. */
+export interface CffFont {
+    /** The font's PostScript name, a subset tag included. */
+    readonly name: string;
+    /** CID-keyed: glyphs are numbered, not named, and only the PDF's CMap says what they draw. */
+    readonly cid: boolean;
+    /** Glyph names by glyph id; `undefined` where the name is not one this reader knows. */
+    readonly glyphNames: readonly (string | undefined)[];
+    /** Advance widths by glyph id, in font units. */
+    readonly widths: readonly number[];
+    readonly bbox: readonly [number, number, number, number];
+    readonly unitsPerEm: number;
+}
+/**
+ * The code point a glyph name stands for: an Adobe Glyph List name, or
+ * `uniXXXX` or `uXXXX[XX]` for one code point. Ligatures of several code
+ * points, suffixed variants such as `a.sc`, and noncharacters stand for none.
+ */
+export declare function glyphUnicode(name: string | undefined): number | undefined;
+/** Reads a CFF font program, or `undefined` when it is not one this reader can use. */
+export declare function readCff(bytes: Uint8Array): CffFont | undefined;
+/**
+ * A copy of the program whose font name holds only what a browser's font
+ * sanitizer accepts in a CFF table: printable ASCII without
+ * `[](){}<>/%` or a space, each other byte becoming `_`; `undefined` past
+ * the 127 characters it accepts or for a program that is not one font.
+ */
+export declare function cffWithSafeName(bytes: Uint8Array): Uint8Array | undefined;

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

@@ -0,0 +1,416 @@
+import { GLYPH_UNICODE } from "./glyph-names.js";
+const ISO_ADOBE_NAMES = `
+.notdef space exclam quotedbl numbersign dollar percent ampersand
+quoteright parenleft parenright asterisk plus comma hyphen period slash
+zero one two three four five six seven eight nine colon semicolon less
+equal greater question at A B C D E F G H I J K L M N O P Q R S T U V W X Y
+Z bracketleft backslash bracketright asciicircum underscore quoteleft a b c
+d e f g h i j k l m n o p q r s t u v w x y z braceleft bar braceright
+asciitilde exclamdown cent sterling fraction yen florin section currency
+quotesingle quotedblleft guillemotleft guilsinglleft guilsinglright fi fl
+endash dagger daggerdbl periodcentered paragraph bullet quotesinglbase
+quotedblbase quotedblright guillemotright ellipsis perthousand questiondown
+grave acute circumflex tilde macron breve dotaccent dieresis ring cedilla
+hungarumlaut ogonek caron emdash AE ordfeminine Lslash Oslash OE
+ordmasculine ae dotlessi lslash oslash oe germandbls onesuperior logicalnot
+mu trademark Eth onehalf plusminus Thorn onequarter divide brokenbar degree
+thorn threequarters twosuperior registered minus eth multiply threesuperior
+copyright Aacute Acircumflex Adieresis Agrave Aring Atilde Ccedilla Eacute
+Ecircumflex Edieresis Egrave Iacute Icircumflex Idieresis Igrave Ntilde
+Oacute Ocircumflex Odieresis Ograve Otilde Scaron Uacute Ucircumflex
+Udieresis Ugrave Yacute Ydieresis Zcaron aacute acircumflex adieresis
+agrave aring atilde ccedilla eacute ecircumflex edieresis egrave iacute
+icircumflex idieresis igrave ntilde oacute ocircumflex odieresis ograve
+otilde scaron uacute ucircumflex udieresis ugrave yacute ydieresis zcaron
+`
+    .trim()
+    .split(/\s+/);
+/**
+ * The code point a glyph name stands for: an Adobe Glyph List name, or
+ * `uniXXXX` or `uXXXX[XX]` for one code point. Ligatures of several code
+ * points, suffixed variants such as `a.sc`, and noncharacters stand for none.
+ */
+export function glyphUnicode(name) {
+    if (!name || name === ".notdef")
+        return undefined;
+    const known = GLYPH_UNICODE.get(name);
+    if (known !== undefined)
+        return known;
+    const match = /^uni([0-9A-F]{4})$|^u([0-9A-F]{4,6})$/.exec(name);
+    const hex = match?.[1] ?? match?.[2];
+    if (!hex)
+        return undefined;
+    const code = Number.parseInt(hex, 16);
+    const surrogate = code >= 0xd800 && code <= 0xdfff;
+    const nonCharacter = (code & 0xfffe) === 0xfffe;
+    return code <= 0x10ffff && !surrogate && !nonCharacter ? code : undefined;
+}
+/** Top and Private DICT operators this reader uses; two-byte ones as 1200 + their second byte. */
+const OP = {
+    fontBBox: 5,
+    charset: 15,
+    charStrings: 17,
+    private: 18,
+    defaultWidthX: 20,
+    nominalWidthX: 21,
+    subrs: 19,
+    charstringType: 1206,
+    fontMatrix: 1207,
+    ros: 1230,
+};
+/** Standard strings come first; a string id from here on names an entry of the String INDEX. */
+const STANDARD_STRINGS = 391;
+/** Reads a CFF font program, or `undefined` when it is not one this reader can use. */
+export function readCff(bytes) {
+    try {
+        const at = (offset) => {
+            if (!Number.isInteger(offset) || offset < 0 || offset >= bytes.length)
+                throw new RangeError("Outside the font");
+            return bytes[offset];
+        };
+        const u16 = (offset) => (at(offset) << 8) | at(offset + 1);
+        if (at(0) !== 1)
+            return undefined;
+        const names = readIndex(bytes, at(2), at, u16);
+        const tops = readIndex(bytes, names.end, at, u16);
+        const strings = readIndex(bytes, tops.end, at, u16);
+        const globalSubrs = readIndex(bytes, strings.end, at, u16);
+        // A PDF embeds one font per program.
+        if (names.items.length !== 1 || tops.items.length !== 1)
+            return undefined;
+        const top = readDict(bytes, ...tops.items[0], at);
+        const charStringsAt = top.get(OP.charStrings)?.[0];
+        if (charStringsAt === undefined)
+            return undefined;
+        if ((top.get(OP.charstringType)?.[0] ?? 2) !== 2)
+            return undefined;
+        const charStrings = readIndex(bytes, charStringsAt, at, u16);
+        const glyphCount = charStrings.items.length;
+        if (glyphCount === 0)
+            return undefined;
+        const [scale = 0.001, skewX = 0, skewY = 0, scaleY = 0.001] = top.get(OP.fontMatrix) ?? [];
+        if (skewX !== 0 || skewY !== 0 || scale !== scaleY || scale <= 0)
+            return undefined;
+        const unitsPerEm = Math.round(1 / scale);
+        if (unitsPerEm < 16 || unitsPerEm > 16384)
+            return undefined;
+        const [xMin = 0, yMin = 0, xMax = 0, yMax = 0] = top.get(OP.fontBBox) ?? [];
+        const cid = top.has(OP.ros);
+        const [nameStart, nameEnd] = names.items[0];
+        // A font name is 127 characters at most.
+        const name = latin1(bytes.subarray(nameStart, Math.min(nameEnd, nameStart + 127)));
+        if (cid)
+            return {
+                name,
+                cid,
+                glyphNames: [],
+                widths: [],
+                bbox: [xMin, yMin, xMax, yMax],
+                unitsPerEm,
+            };
+        // Glyphs may share a string; each is read once.
+        const custom = new Map();
+        const stringOf = (sid) => {
+            if (sid < ISO_ADOBE_NAMES.length)
+                return ISO_ADOBE_NAMES[sid];
+            const item = strings.items[sid - STANDARD_STRINGS];
+            if (!item)
+                return undefined;
+            if (!custom.has(sid))
+                custom.set(sid, 
+                // A glyph name is 63 characters at most.
+                item[1] - item[0] <= 63 ? latin1(bytes.subarray(...item)) : undefined);
+            return custom.get(sid);
+        };
+        const glyphNames = charsetNames(top.get(OP.charset)?.[0] ?? 0, glyphCount, stringOf, at, u16);
+        const [privateSize, privateAt] = top.get(OP.private) ?? [0, 0];
+        const privateDict = privateSize
+            ? readDict(bytes, privateAt, privateAt + privateSize, at)
+            : new Map();
+        const localAt = privateDict.get(OP.subrs)?.[0];
+        const metrics = {
+            bytes,
+            defaultWidth: privateDict.get(OP.defaultWidthX)?.[0] ?? 0,
+            nominalWidth: privateDict.get(OP.nominalWidthX)?.[0] ?? 0,
+            global: globalSubrs.items,
+            local: localAt === undefined
+                ? []
+                : readIndex(bytes, privateAt + localAt, at, u16).items,
+        };
+        const widths = charStrings.items.map(([start, end]) => charstringWidth(metrics, start, end));
+        return {
+            name,
+            cid,
+            glyphNames,
+            widths,
+            bbox: [xMin, yMin, xMax, yMax],
+            unitsPerEm,
+        };
+    }
+    catch (error) {
+        if (error instanceof RangeError)
+            return undefined;
+        throw error;
+    }
+}
+/**
+ * A copy of the program whose font name holds only what a browser's font
+ * sanitizer accepts in a CFF table: printable ASCII without
+ * `[](){}<>/%` or a space, each other byte becoming `_`; `undefined` past
+ * the 127 characters it accepts or for a program that is not one font.
+ */
+export function cffWithSafeName(bytes) {
+    try {
+        const at = (offset) => {
+            if (offset < 0 || offset >= bytes.length)
+                throw new RangeError("Outside the font");
+            return bytes[offset];
+        };
+        const u16 = (offset) => (at(offset) << 8) | at(offset + 1);
+        const names = readIndex(bytes, at(2), at, u16);
+        const [start, end] = names.items[0] ?? [0, 0];
+        if (names.items.length !== 1 || end - start > 127)
+            return undefined;
+        const safe = bytes.slice();
+        for (let offset = start; offset < end; offset += 1) {
+            const byte = safe[offset];
+            // A name that starts with NUL marks a deleted font, which is allowed.
+            if (offset === start && byte === 0)
+                continue;
+            if (byte < 33 || byte > 126 || UNSAFE_NAME_BYTES.has(byte))
+                safe[offset] = 0x5f;
+        }
+        return safe;
+    }
+    catch (error) {
+        if (error instanceof RangeError)
+            return undefined;
+        throw error;
+    }
+}
+const UNSAFE_NAME_BYTES = new Set([..."[](){}<>/%"].map((character) => character.charCodeAt(0)));
+/** An INDEX: its items' byte ranges and where it ends. */
+function readIndex(bytes, start, at, u16) {
+    const count = u16(start);
+    if (count === 0)
+        return { items: [], end: start + 2 };
+    const offSize = at(start + 2);
+    if (offSize < 1 || offSize > 4)
+        throw new RangeError("Bad offset size");
+    const offset = (index) => {
+        let value = 0;
+        for (let byte = 0; byte < offSize; byte += 1)
+            value = value * 256 + at(start + 3 + index * offSize + byte);
+        return value;
+    };
+    if (offset(0) !== 1)
+        throw new RangeError("Bad INDEX");
+    // Offsets count from the byte before the data.
+    const base = start + 2 + (count + 1) * offSize;
+    const items = [];
+    for (let index = 0; index < count; index += 1) {
+        const from = base + offset(index);
+        const to = base + offset(index + 1);
+        if (to < from || to > bytes.length)
+            throw new RangeError("Bad INDEX");
+        items.push([from, to]);
+    }
+    return { items, end: base + offset(count) };
+}
+/** A DICT's operands by operator. */
+function readDict(bytes, start, end, at) {
+    if (end > bytes.length)
+        throw new RangeError("DICT past the font");
+    const entries = new Map();
+    let operands = [];
+    let offset = start;
+    while (offset < end) {
+        const byte = at(offset);
+        if (byte <= 21) {
+            const operator = byte === 12 ? 1200 + at(offset + 1) : byte;
+            offset += byte === 12 ? 2 : 1;
+            entries.set(operator, operands);
+            operands = [];
+        }
+        else if (byte === 28) {
+            operands.push(int16((at(offset + 1) << 8) | at(offset + 2)));
+            offset += 3;
+        }
+        else if (byte === 29) {
+            operands.push((at(offset + 1) << 24) |
+                (at(offset + 2) << 16) |
+                (at(offset + 3) << 8) |
+                at(offset + 4));
+            offset += 5;
+        }
+        else if (byte === 30) {
+            let text = "";
+            offset += 1;
+            for (let done = false; !done; offset += 1) {
+                const pair = at(offset);
+                for (const nibble of [pair >> 4, pair & 15]) {
+                    if (nibble === 15) {
+                        done = true;
+                        break;
+                    }
+                    text += REAL_NIBBLES[nibble] ?? "";
+                }
+            }
+            operands.push(Number.parseFloat(text));
+        }
+        else if (byte >= 32 && byte <= 246) {
+            operands.push(byte - 139);
+            offset += 1;
+        }
+        else if (byte >= 247 && byte <= 250) {
+            operands.push((byte - 247) * 256 + at(offset + 1) + 108);
+            offset += 2;
+        }
+        else if (byte >= 251 && byte <= 254) {
+            operands.push(-(byte - 251) * 256 - at(offset + 1) - 108);
+            offset += 2;
+        }
+        else
+            throw new RangeError("Bad DICT byte");
+    }
+    return entries;
+}
+const REAL_NIBBLES = [
+    "0",
+    "1",
+    "2",
+    "3",
+    "4",
+    "5",
+    "6",
+    "7",
+    "8",
+    "9",
+    ".",
+    "E",
+    "E-",
+    "",
+    "-",
+];
+/** Glyph names by glyph id from the charset at `offset`; 0 is the ISOAdobe set. */
+function charsetNames(offset, glyphCount, stringOf, at, u16) {
+    const names = [".notdef"];
+    if (offset === 0) {
+        for (let glyph = 1; glyph < glyphCount; glyph += 1)
+            names.push(stringOf(glyph));
+        return names;
+    }
+    // The predefined expert sets name small capitals and old-style figures.
+    if (offset <= 2)
+        return [...names, ...Array(glyphCount - 1)];
+    const format = at(offset);
+    let cursor = offset + 1;
+    if (format === 0) {
+        for (let glyph = 1; glyph < glyphCount; glyph += 1, cursor += 2)
+            names.push(stringOf(u16(cursor)));
+    }
+    else if (format === 1 || format === 2) {
+        while (names.length < glyphCount) {
+            const first = u16(cursor);
+            const left = format === 1 ? at(cursor + 2) : u16(cursor + 2);
+            cursor += format === 1 ? 3 : 4;
+            for (let step = 0; step <= left && names.length < glyphCount; step += 1)
+                names.push(stringOf(first + step));
+        }
+    }
+    else
+        throw new RangeError("Bad charset format");
+    return names;
+}
+/**
+ * A Type 2 charstring's advance width (Adobe TN 5177): an extra first operand
+ * before the first operator that clears the stack, plus the nominal width;
+ * the default width without one. Subroutines called on the way are followed,
+ * ten deep at most. A charstring that breaks a rule gets the default width.
+ */
+function charstringWidth(context, start, end) {
+    const { bytes, defaultWidth, nominalWidth } = context;
+    const stack = [];
+    // A width, or `undefined` to go on after a subroutine returns.
+    const walk = (from, to, depth) => {
+        let offset = from;
+        while (offset < to) {
+            const byte = bytes[offset];
+            const size = byte === 28 ? 3 : byte === 255 ? 5 : byte >= 247 && byte <= 254 ? 2 : 1;
+            if (offset + size > to)
+                return defaultWidth;
+            if (byte === 28 || byte >= 32) {
+                const next = (step) => bytes[offset + step];
+                stack.push(byte === 28
+                    ? int16((next(1) << 8) | next(2))
+                    : byte <= 246
+                        ? byte - 139
+                        : byte <= 250
+                            ? (byte - 247) * 256 + next(1) + 108
+                            : byte <= 254
+                                ? -(byte - 251) * 256 - next(1) - 108
+                                : ((next(1) << 24) |
+                                    (next(2) << 16) |
+                                    (next(3) << 8) |
+                                    next(4)) /
+                                    65536);
+                // The Type 2 stack holds 48 operands.
+                if (stack.length > 48)
+                    return defaultWidth;
+                offset += size;
+                continue;
+            }
+            offset += 1;
+            if (byte === 10 || byte === 29) {
+                const subrs = byte === 10 ? context.local : context.global;
+                const index = stack.pop();
+                const subr = index === undefined
+                    ? undefined
+                    : subrs[index + subrBias(subrs.length)];
+                if (!subr || depth >= 10)
+                    return defaultWidth;
+                const width = walk(subr[0], subr[1], depth + 1);
+                if (width !== undefined)
+                    return width;
+                continue;
+            }
+            if (byte === 11)
+                return depth > 0 ? undefined : defaultWidth;
+            const takes = STACK_CLEARING[byte];
+            if (takes === undefined)
+                return defaultWidth;
+            const count = stack.length;
+            const widthFirst = takes === "pairs"
+                ? count % 2 === 1
+                : takes === "endchar"
+                    ? count === 1 || count === 5
+                    : count > takes;
+            return widthFirst ? stack[0] + nominalWidth : defaultWidth;
+        }
+        return depth > 0 ? undefined : defaultWidth;
+    };
+    return walk(start, end, 0) ?? defaultWidth;
+}
+/** What a subroutine number is offset by, for a set of `count` subroutines. */
+function subrBias(count) {
+    return count < 1240 ? 107 : count < 33900 ? 1131 : 32768;
+}
+/** Operators that clear the stack, and the operands they take without a width. */
+const STACK_CLEARING = {
+    1: "pairs", // hstem
+    3: "pairs", // vstem
+    18: "pairs", // hstemhm
+    23: "pairs", // vstemhm
+    19: "pairs", // hintmask, after implied vstems
+    20: "pairs", // cntrmask
+    21: 2, // rmoveto
+    22: 1, // hmoveto
+    4: 1, // vmoveto
+    14: "endchar", // endchar: none, or four for an accented character
+};
+function int16(value) {
+    return value >= 0x8000 ? value - 0x10000 : value;
+}
+function latin1(bytes) {
+    return String.fromCharCode(...bytes);
+}

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

@@ -1,6 +1,6 @@
 import type { EngineBatch, EngineChange, MaterializedDocument, RestoreTarget } from "../../engine.js";
 import type { EditFindOptions, EditOperation, ElementQuery, OperationIssue, PagePoint, PageRect, TextPosition, TextRange, TextTarget } from "../../types.js";
-import type { PageLayout, PdfElement, PdfOperation, TextLayout } from "../types.js";
+import type { PageLayout, PdfElement, PdfOperation, TextFont, TextLayout } from "../types.js";
 import type { EditWorkerBitmap } from "../../../worker-protocol.js";
 import { FontLibrary } from "./fonts.js";
 import { ImageCache } from "./images.js";
@@ -78,6 +78,8 @@ export declare class PdfEditDocument {
     findText(query: string, options: EditFindOptions): TextTarget[];
     /** Lines, glyph boxes and styles of a text, text box or table element. */
     textLayout(elementId: string): TextLayout | undefined;
+    /** The browser face of the font a text or text box element is drawn in, see `TextFont`. */
+    textFont(elementId: string): TextFont | undefined;
     /** The layouts of every text element on a page, with the page's displayed size. */
     pageLayout(pageIndex: number): PageLayout | undefined;
     /** The caret position nearest to a page-space point; none on a page without text. */

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

@@ -1,8 +1,9 @@
 import { ViewerError } from "../../../errors.js";
 import { invalidOperationError, parseReference } from "../../operations.js";
 import { layoutOf, layoutsOf, positionIn, rectsOf, } from "./layout.js";
-import { markIsFresh, readMark, scanPage, } from "./elements.js";
+import { markIsFresh, OBJECT_TEXT, readMark, scanPage, } from "./elements.js";
 import { FontLibrary, TextMeasurer } from "./fonts.js";
+import { textFaceOf } from "./text-font.js";
 import { fontRequestsOf } from "./text-box.js";
 import { issueCollector, } from "./operations.js";
 import { insertTextBox } from "./text-box.js";
@@ -123,6 +124,8 @@ export class PdfEditDocument {
     #measurer;
     #pages;
     #batches = 0;
+    /** Browser faces of the document's fonts, by font program; see `textFont`. */
+    #faces = new Map();
     constructor(pdfium, original, fonts = new FontLibrary(async () => {
         throw new Error("No font source is configured");
     }), limits = defaultResourceLimits, assets = new AssetStore(), compact = compactPdf) {
@@ -402,6 +405,23 @@ export class PdfEditDocument {
             return element ? layoutOf(this.#pdfium, scan, element) : undefined;
         });
     }
+    /** The browser face of the font a text or text box element is drawn in, see `TextFont`. */
+    textFont(elementId) {
+        const location = this.#locate(elementId);
+        const element = location && this.getElement(elementId);
+        if (!element || (element.kind !== "text" && element.kind !== "textBox"))
+            return undefined;
+        const { lib } = this.#pdfium;
+        return this.#withPage(location.pageIndex, (page) => {
+            // A text box's lines share their font; its first line answers.
+            const object = location.indexes
+                .map((index) => lib.FPDFPage_GetObject(page, index))
+                .find((entry) => lib.FPDFPageObj_GetType(entry) === OBJECT_TEXT);
+            return object === undefined
+                ? undefined
+                : { elementId, ...textFaceOf(this.#pdfium, object, this.#faces) };
+        });
+    }
     /** The layouts of every text element on a page, with the page's displayed size. */
     pageLayout(pageIndex) {
         if (pageIndex < 0 || pageIndex >= this.#pages.length)

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

@@ -47,5 +47,12 @@ export declare function readMark(pdfium: Pdfium, object: number): MarkParams | u
  */
 export declare function markIsFresh(pdfium: Pdfium, page: number, textPage: number, geometry: PageGeometry, mark: MarkParams, indexes: readonly number[]): boolean;
 export declare function objectBounds(pdfium: Pdfium, object: number, geometry: PageGeometry): PageRect | undefined;
+/**
+ * How much a text object's matrix scales its glyphs: the length of its
+ * vertical axis. Producers often write `1 Tf` and carry the size in the
+ * matrix, so the point size the text shows is its font size times this; a
+ * turn or a horizontal squeeze leaves it alone.
+ */
+export declare function textScale(matrix: readonly number[] | undefined): number;
 export declare function textStyle(pdfium: Pdfium, object: number): PdfTextStyle;
 export declare function hex(rgba: readonly number[]): string;

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

@@ -232,6 +232,16 @@ const TABLE_OPERATIONS = Object.freeze([
 function textOf(pdfium, object, textPage) {
     return pdfium.readWideString((buffer, bytes) => pdfium.lib.FPDFTextObj_GetText(object, textPage, buffer, bytes));
 }
+/**
+ * How much a text object's matrix scales its glyphs: the length of its
+ * vertical axis. Producers often write `1 Tf` and carry the size in the
+ * matrix, so the point size the text shows is its font size times this; a
+ * turn or a horizontal squeeze leaves it alone.
+ */
+export function textScale(matrix) {
+    const scale = matrix ? Math.hypot(matrix[2], matrix[3]) : 1;
+    return Number.isFinite(scale) && scale > 0 ? scale : 1;
+}
 export function textStyle(pdfium, object) {
     const { lib } = pdfium;
     const font = lib.FPDFTextObj_GetFont(object);
@@ -245,9 +255,10 @@ export function textStyle(pdfium, object) {
     const flags = lib.FPDFFont_GetFlags(font);
     const weight = lib.FPDFFont_GetWeight(font);
     const size = pdfium.readNumbers(1, "float", ([pointer]) => lib.FPDFTextObj_GetFontSize(object, pointer))?.[0] ?? 0;
+    const matrix = pdfium.readNumbers(6, "float", ([pointer]) => lib.FPDFPageObj_GetMatrix(object, pointer));
     return {
         fontFamily: family,
-        fontSize: round(size),
+        fontSize: round(size * textScale(matrix)),
         bold: weight >= 600 ||
             (flags & FLAG_FORCE_BOLD) !== 0 ||
             /bold|black|heavy/i.test(baseName),

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

@@ -1,4 +1,4 @@
-import { objectBounds, OBJECT_TEXT } from "./elements.js";
+import { objectBounds, OBJECT_TEXT, textScale } from "./elements.js";
 import { firstNonWinAnsi, isStandardFamily, parseCmap, } from "./fonts.js";
 import { pageToUser } from "./geometry.js";
 import { parseColor, setText, textBoxReplaceText, textBoxSetTextStyle, textBoxTarget, } from "./text-box.js";
@@ -255,7 +255,7 @@ function splitAround(context, target, before, middle, after) {
         const old = lib.FPDFPage_GetObject(page, index);
         const oldFont = lib.FPDFTextObj_GetFont(old);
         const matrix = pdfium.readNumbers(6, "float", ([pointer]) => lib.FPDFPageObj_GetMatrix(old, pointer)) ?? [1, 0, 0, 1, 0, 0];
-        const size = pdfium.readNumbers(1, "float", ([pointer]) => lib.FPDFTextObj_GetFontSize(old, pointer))?.[0] ?? style.fontSize;
+        const size = pdfium.readNumbers(1, "float", ([pointer]) => lib.FPDFTextObj_GetFontSize(old, pointer))?.[0] ?? style.fontSize / textScale(matrix);
         const [a, b, c, d, e, f] = matrix;
         const [r, g, bl] = parseColor(style.color);
         const parts = [
@@ -349,7 +349,7 @@ function replaceWithFallback(context, target, text) {
     context.withPage(location.pageIndex, (page) => {
         const old = lib.FPDFPage_GetObject(page, index);
         const matrix = pdfium.readNumbers(6, "float", ([pointer]) => lib.FPDFPageObj_GetMatrix(old, pointer)) ?? [1, 0, 0, 1, 0, 0];
-        const size = pdfium.readNumbers(1, "float", ([pointer]) => lib.FPDFTextObj_GetFontSize(old, pointer))?.[0] ?? style.fontSize;
+        const size = pdfium.readNumbers(1, "float", ([pointer]) => lib.FPDFTextObj_GetFontSize(old, pointer))?.[0] ?? style.fontSize / textScale(matrix);
         const object = lib.FPDFPageObj_CreateTextObj(context.document, font.handle, size);
         setText(pdfium, object, text);
         const [r, g, b] = parseColor(style.color);
@@ -399,7 +399,9 @@ function resize(context, target, fontSize) {
         }
         const matrix = pdfium.readNumbers(6, "float", ([pointer]) => lib.FPDFPageObj_GetMatrix(old, pointer)) ?? [1, 0, 0, 1, 0, 0];
         const color = pdfium.readNumbers(4, "i32", ([r, g, b, a]) => lib.FPDFPageObj_GetFillColor(old, r, g, b, a)) ?? [0, 0, 0, 255];
-        const object = lib.FPDFPageObj_CreateTextObj(context.document, lib.FPDFTextObj_GetFont(old), fontSize);
+        // The size is the one the text shows: the old matrix, applied below,
+        // scales it again, so the font gets the size undone by that scale.
+        const object = lib.FPDFPageObj_CreateTextObj(context.document, lib.FPDFTextObj_GetFont(old), fontSize / textScale(matrix));
         setText(pdfium, object, text);
         lib.FPDFPageObj_SetFillColor(object, color[0], color[1], color[2], color[3]);
         const [a, b, c, d, e, f] = matrix;

package/dist/edit/pdf/engine/glyph-names.d.ts

@@ -0,0 +1,2 @@
+/** Code points by glyph name. */
+export declare const GLYPH_UNICODE: ReadonlyMap<string, number>;