web-doc 0.8.0 → 0.10.0

package/dist/edit/pptx/session.js

@@ -11,8 +11,11 @@ export class PptxSession {
     format = "pptx";
     #core;
     #tools;
-    constructor(core) {
+    /** The shown deck's text runs; absent in a headless session, which hits frames only. */
+    #access;
+    constructor(core, access) {
         this.#core = core;
+        this.#access = access;
     }
     get sessionId() {
         return this.#core.sessionId;
@@ -53,8 +56,31 @@ export class PptxSession {
     getElement(id, options) {
         return this.#core.getElement(id, options);
     }
-    elementsAt(pageIndex, point, options) {
-        return this.#core.elementsAt(pageIndex, point, options);
+    /**
+     * The elements under a point, top-most first: those whose frame holds it,
+     * and before them a shape whose text is painted there past its frame, as
+     * text wrapped below a short box is.
+     */
+    async elementsAt(pageIndex, point, options) {
+        const framed = (await this.#core.elementsAt(pageIndex, point, options));
+        const access = this.#access;
+        if (!access)
+            return framed;
+        const origins = (await access.getTextRuns(pageIndex, options?.signal))
+            .filter((run) => run.shapeOrigin && runHolds(run, point))
+            .map((run) => run.shapeOrigin);
+        if (origins.length === 0)
+            return framed;
+        const all = (await this.getElements({ pageIndex }, options)).items;
+        const painted = all.filter((element) => element.text !== undefined &&
+            !framed.items.some((hit) => hit.id === element.id) &&
+            origins.some((origin) => originOf(element, origin)));
+        if (painted.length === 0)
+            return framed;
+        return Object.freeze({
+            ...framed,
+            items: Object.freeze([...painted, ...framed.items]),
+        });
     }
     findText(query, options) {
         return this.#core.findText(query, options);
@@ -143,3 +169,15 @@ function pptxReads(engine) {
         throw new ViewerError("edit-unsupported", "The engine does not provide the PPTX reads", { details: { format: "pptx", reason: "no-reads" } });
     return candidate;
 }
+/** Whether a run's box holds a point. */
+function runHolds(run, point) {
+    return (point.x >= run.x &&
+        point.x <= run.x + run.width &&
+        point.y >= run.y &&
+        point.y <= run.y + run.height);
+}
+/** Whether a shape's frame starts where a run says its shape does, to half a pixel. */
+function originOf(element, origin) {
+    const frame = element.frame ?? element.bounds;
+    return (Math.abs(frame.x - origin.x) <= 0.5 && Math.abs(frame.y - origin.y) <= 0.5);
+}

package/dist/fonts/THIRD_PARTY_NOTICES.md

@@ -6,8 +6,11 @@ The WOFF2 files in this directory are modified/subset builds of Noto Sans and No
 - Noto Sans CJK sources: `notofonts/noto-cjk` commit `f8d157532fbfaeda587e826d4cd5b21a49186f7c`.
 - License: SIL Open Font License 1.1; see `OFL-1.1.txt`.
 - Modified font family used by the viewer: `Zrimo Noto`.
-- `noto-sans-latin-cyrillic.ttf` is the same Latin/Cyrillic subset saved as an
-  uncompressed TrueType file; the PDF editor embeds it into documents whose
-  text the standard fonts cannot encode.
+- `noto-sans-latin-cyrillic.ttf` is the same Latin/Cyrillic subset plus Noto
+  Sans's General Punctuation, Superscripts and Subscripts, Currency Symbols,
+  Letterlike Symbols and Number Forms (ranges in `manifest.json`; the Arrows
+  and Mathematical Operators ranges are requested too, but Noto Sans has no
+  glyphs there), saved as an uncompressed TrueType file; the PDF editor embeds it into
+  documents whose text the standard fonts cannot encode.
 
 No proprietary Microsoft font is included.

package/dist/fonts/manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "family": "Zrimo Noto",
-  "generated": "2026-07-16",
-  "tooling": "fonttools pyftsubset with all layout features, then woff2_compress; the .ttf is the Latin/Cyrillic subset saved uncompressed with fonttools for embedding into PDFs",
+  "generated": "2026-10-02",
+  "tooling": "fonttools pyftsubset with all layout features, then woff2_compress; the .ttf is the Latin/Cyrillic subset saved uncompressed with fonttools for embedding into PDFs, from hinted/ttf/NotoSans/NotoSans-Regular.ttf with U+0000,U+000D,U+0020-007E,U+00A0-024F,U+0300-036F,U+0400-052F,U+1E00-1EFF plus General Punctuation, Superscripts and Subscripts, Currency Symbols, Letterlike Symbols, Number Forms, Arrows, Mathematical Operators, U+25CC and U+FFFD (U+2000-206F,U+2070-209F,U+20A0-20CF,U+2100-214F,U+2150-218F,U+2190-21FF,U+2200-22FF,U+25CC,U+FFFD) so text typed with dashes, quotes, currency signs and the numero sign can be embedded; Noto Sans has no glyphs in the Arrows and Mathematical Operators ranges, so those two add none",
   "license": "OFL-1.1",
   "sources": {
     "noto-fonts": "https://github.com/notofonts/noto-fonts/tree/ffebf8c1ee449e544955a7e813c54f9b73848eac",
@@ -81,8 +81,8 @@
     },
     {
       "file": "noto-sans-latin-cyrillic.ttf",
-      "bytes": 218796,
-      "sha256": "6a23e5413988b4b523ceb4aa81a1de85dad21336868997f52eb6d42159345262"
+      "bytes": 260552,
+      "sha256": "94094981da300fdb704d64cb91354360d37bf69b26f8584da7d44fdc2e0bdc84"
     }
   ]
 }

package/dist/viewport.js

@@ -156,6 +156,8 @@ export class ViewerViewport {
     }
     replaceDocument(info, changedPages, revision) {
         const previous = this.#info;
+        const painted = this.#painted.get(this.#contentRevision);
+        this.#painted.clear();
         this.#info = info;
         this.#contentRevision = revision ?? this.#contentRevision + 1;
         // Only pages whose content or size changed get a new render key; the
@@ -172,9 +174,15 @@ export class ViewerViewport {
             const size = info.pageSizes?.[pageIndex];
             const before = previous?.pageSizes?.[pageIndex];
             const resized = size?.width !== before?.width || size?.height !== before?.height;
-            if (pageIndex >= from || changed.has(pageIndex) || resized)
+            if (pageIndex >= from || changed.has(pageIndex) || resized) {
                 this.#pageRevisions[pageIndex] =
                     (this.#pageRevisions[pageIndex] ?? 0) + 1;
+            }
+            else if (painted?.has(pageIndex) && this.#slots.has(pageIndex)) {
+                // A completed, retained page is still current. Carry its queued
+                // notification forward instead of losing it at the next frame.
+                this.#markPainted(pageIndex, this.#contentRevision);
+            }
         }
         // Slots stay mounted and repaint in place; the browser clamps the scroll
         // position itself once the spacer takes the new document's height.
@@ -371,6 +379,8 @@ export class ViewerViewport {
                 slot.controller?.abort();
                 slot.root.remove();
                 this.#slots.delete(pageIndex);
+                for (const pages of this.#painted.values())
+                    pages.delete(pageIndex);
             }
         for (let pageIndex = range.start; pageIndex < range.end; pageIndex += 1) {
             const slot = this.#slots.get(pageIndex) ?? this.#createSlot(pageIndex);
@@ -443,41 +453,86 @@ export class ViewerViewport {
         slot.controller = controller;
         const generation = ++slot.generation;
         const zoom = this.#host.state.zoom;
+        const devicePixelRatio = window.devicePixelRatio || 1;
+        const pageRevision = this.#pageRevisions[pageIndex] ?? 0;
         const contentRevision = this.#contentRevision;
+        // Adapters resize and paint their target asynchronously. Never give them
+        // the visible canvas: resizing clears it before the next frame is ready.
+        const canvas = document.createElement("canvas");
+        const textLayer = document.createElement("div");
+        const highlightLayer = document.createElement("div");
+        textLayer.style.cssText = slot.textLayer.style.cssText;
+        highlightLayer.style.cssText = slot.highlightLayer.style.cssText;
+        const isCurrent = () => !this.#destroyed &&
+            !controller.signal.aborted &&
+            this.#slots.get(pageIndex) === slot &&
+            slot.controller === controller &&
+            slot.generation === generation &&
+            (this.#pageRevisions[pageIndex] ?? 0) === pageRevision &&
+            this.#host.state.zoom === zoom &&
+            (window.devicePixelRatio || 1) === devicePixelRatio;
+        let rendering;
         try {
-            let renderError;
-            const rendering = this.#host
-                .renderPage(pageIndex, slot.canvas, {
+            rendering = this.#host.renderPage(pageIndex, canvas, {
                 zoom,
-                devicePixelRatio: window.devicePixelRatio || 1,
+                devicePixelRatio,
                 priority: pageIndex === this.#host.state.pageIndex ? "visible" : "adjacent",
                 signal: controller.signal,
+            });
+            const preparingText = this.#host
+                .getTextRuns(pageIndex, controller.signal)
+                .then(async (runs) => {
+                await rendering;
+                if (!isCurrent())
+                    return;
+                await this.#buildTextLayers(textLayer, highlightLayer, pageIndex, runs, zoom, controller.signal);
             })
-                .catch((error) => {
-                renderError = error;
+                .then(() => true, (error) => {
+                if (isCurrent())
+                    slot.root.dataset.renderError =
+                        error instanceof Error ? error.message : String(error);
+                // A valid raster still publishes without unavailable geometry.
+                // Never retain partial or previous text/highlight hit targets.
+                for (const layer of [textLayer, highlightLayer]) {
+                    layer.replaceChildren();
+                    resetOverlay(layer);
+                }
+                return false;
             });
-            const runs = await this.#host.getTextRuns(pageIndex, controller.signal);
-            if (controller.signal.aborted || slot.generation !== generation)
-                return;
-            await this.#buildTextLayers(slot.textLayer, slot.highlightLayer, pageIndex, runs, zoom, controller.signal);
-            if (controller.signal.aborted || slot.generation !== generation)
-                return;
-            await rendering;
-            if (renderError)
-                throw renderError;
-            if (controller.signal.aborted || slot.generation !== generation)
+            const [, textReady] = await Promise.all([rendering, preparingText]);
+            if (!isCurrent())
                 return;
-            const cssWidth = slot.canvas.width / (window.devicePixelRatio || 1);
-            const cssHeight = slot.canvas.height / (window.devicePixelRatio || 1);
+            const context = slot.canvas.getContext("2d");
+            if (!context)
+                throw new Error("Canvas 2D context is unavailable");
+            // Publish the completed raster and its matching text geometry in one
+            // synchronous commit, keeping the mounted page and layer identities.
+            slot.canvas.width = canvas.width;
+            slot.canvas.height = canvas.height;
+            context.drawImage(canvas, 0, 0);
+            replaceTextLayer(slot.textLayer, textLayer);
+            replaceTextLayer(slot.highlightLayer, highlightLayer);
+            const cssWidth = canvas.width / devicePixelRatio;
+            const cssHeight = canvas.height / devicePixelRatio;
             slot.root.style.width = `${cssWidth}px`;
             slot.root.style.height = `${cssHeight}px`;
+            if (textReady)
+                delete slot.root.dataset.renderError;
             this.#markPainted(pageIndex, contentRevision);
         }
         catch (error) {
-            if (!controller.signal.aborted) {
+            if (isCurrent()) {
                 slot.root.dataset.renderError =
                     error instanceof Error ? error.message : String(error);
             }
+            controller.abort();
+        }
+        finally {
+            // A cancelled adapter may still be writing. Release its backing store
+            // only once it has stopped, without affecting the committed page.
+            await rendering?.catch(() => undefined);
+            canvas.width = 0;
+            canvas.height = 0;
         }
     }
     async #buildTextLayers(textLayer, highlightLayer, pageIndex, runs, zoom, signal) {
@@ -817,6 +872,7 @@ export class ViewerViewport {
         });
     }
     #clearSlots() {
+        this.#painted.clear();
         for (const slot of this.#slots.values()) {
             slot.controller?.abort();
             slot.root.remove();
@@ -824,6 +880,13 @@ export class ViewerViewport {
         this.#slots.clear();
     }
 }
+function replaceTextLayer(target, source) {
+    const children = document.createDocumentFragment();
+    while (source.firstChild)
+        children.append(source.firstChild);
+    target.style.cssText = source.style.cssText;
+    target.replaceChildren(children);
+}
 function naturalPageSize(info, pageIndex) {
     const candidate = info?.pageSizes?.[pageIndex];
     return candidate &&

package/dist/worker-protocol.d.ts

@@ -2,7 +2,7 @@ import type { DocumentFormat, DocumentInfo, ResourceLimits, TextRun, ViewerError
 import type { EditableFormat } from "./edit/types.js";
 export type DocumentWorkerOperation = "init" | "open" | "get-info" | "render" | "get-text-map" | "close" | "destroy";
 /** Operations of an edit engine worker; payloads mirror the engine interface. */
-export type EditWorkerOperation = "edit-init" | "edit-open" | "edit-validate" | "edit-apply" | "edit-materialize" | "edit-restore" | "edit-put-asset" | "edit-elements" | "edit-element" | "edit-elements-at" | "edit-find-text" | "edit-text-layout" | "edit-position-at" | "edit-range-rects" | "edit-render-without" | "edit-page-layout" | "edit-pptx-slides" | "edit-pptx-layouts" | "edit-docx-revisions" | "edit-dispose";
+export type EditWorkerOperation = "edit-init" | "edit-open" | "edit-validate" | "edit-apply" | "edit-materialize" | "edit-restore" | "edit-put-asset" | "edit-elements" | "edit-element" | "edit-elements-at" | "edit-find-text" | "edit-text-layout" | "edit-text-font" | "edit-position-at" | "edit-range-rects" | "edit-render-without" | "edit-page-layout" | "edit-pptx-slides" | "edit-pptx-layouts" | "edit-docx-revisions" | "edit-dispose";
 export type WorkerOperation = DocumentWorkerOperation | EditWorkerOperation;
 export interface WorkerRequest {
     readonly kind: "request";

package/dist/workers/ooxml-edit-worker.js

@@ -3300,13 +3300,27 @@ function paragraphElement(model, record, base) {
     id: record.elementId,
     kind: "paragraph",
     text: record.text.text,
-    ...record.table ? { parentId: record.table.elementId } : {},
+    ...record.table ? { parentId: record.table.elementId, ...cellOf(record.table, record) } : {},
     textStyle: resolveTextStyle(model.styles, record.pPr, first?.rPr),
     paragraphStyle: resolveParagraphStyle(model.styles, record.pPr),
     ...record.readOnlyReason ? { readOnlyReason: record.readOnlyReason } : {},
     operations: operationsOf("paragraph", record.readOnlyReason !== void 0)
   };
 }
+var CELLS = /* @__PURE__ */ new WeakMap();
+function cellOf(table, record) {
+  let cells = CELLS.get(table);
+  if (!cells) {
+    cells = /* @__PURE__ */ new Map();
+    for (const [row, cellsOfRow] of table.rows.entries())
+      for (const [column, cell2] of cellsOfRow.entries())
+        for (const paragraph of cell2.paragraphs)
+          cells.set(paragraph, { row, column });
+    CELLS.set(table, cells);
+  }
+  const cell = cells.get(record);
+  return cell ? { cell } : {};
+}
 
 // src/edit/docx/write.ts
 var MC_NS = "http://schemas.openxmlformats.org/markup-compatibility/2006";