web-doc 0.6.2 → 0.7.0

package/dist/edit/docx/schemas.js

@@ -0,0 +1,192 @@
+/*
+ * JSON Schemas of the DOCX operations, shared by the worker (engine
+ * validation), the main thread (shape checks) and clients
+ * (`session.schemas`). Only keywords the in-repo validator implements may
+ * appear here. The exported set lists the operations that have an engine
+ * handler.
+ */
+const HIGHLIGHTS = [
+    "yellow",
+    "green",
+    "cyan",
+    "magenta",
+    "blue",
+    "red",
+    "darkBlue",
+    "darkCyan",
+    "darkGreen",
+    "darkMagenta",
+    "darkRed",
+    "darkYellow",
+    "darkGray",
+    "lightGray",
+    "black",
+    "white",
+];
+const definitions = {
+    target: { type: "string", minLength: 1, maxLength: 200 },
+    textPosition: {
+        type: "object",
+        required: ["elementId", "offset"],
+        additionalProperties: false,
+        properties: {
+            elementId: { $ref: "#/$defs/target" },
+            offset: { type: "integer", minimum: 0 },
+        },
+    },
+    textRange: {
+        type: "object",
+        required: ["start", "end"],
+        additionalProperties: false,
+        properties: {
+            start: { $ref: "#/$defs/textPosition" },
+            end: { $ref: "#/$defs/textPosition" },
+        },
+    },
+    text: { type: "string", maxLength: 100_000 },
+    rgb: { type: "string", pattern: "^#[0-9A-Fa-f]{6}$" },
+    themeColor: {
+        type: "object",
+        required: ["theme"],
+        additionalProperties: false,
+        properties: {
+            theme: { type: "string", minLength: 1, maxLength: 20 },
+            mods: { type: "object" },
+        },
+    },
+    color: {
+        oneOf: [
+            { $ref: "#/$defs/rgb" },
+            { $ref: "#/$defs/themeColor" },
+            { const: "auto" },
+        ],
+    },
+    textStyle: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            fontFamily: { type: "string", minLength: 1, maxLength: 100 },
+            fontSize: { type: "number", minimum: 1, maximum: 400 },
+            bold: { type: "boolean" },
+            italic: { type: "boolean" },
+            underline: { type: "boolean" },
+            color: { $ref: "#/$defs/color" },
+            highlight: { enum: [...HIGHLIGHTS, "none"] },
+        },
+    },
+    paragraphStyle: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            align: { enum: ["left", "center", "right", "justify"] },
+            spacing: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    before: { type: "number", minimum: 0, maximum: 1584 },
+                    after: { type: "number", minimum: 0, maximum: 1584 },
+                    line: { type: "number", minimum: 0.06, maximum: 132 },
+                },
+            },
+        },
+    },
+    tableRows: {
+        type: "array",
+        minItems: 1,
+        maxItems: 100,
+        items: {
+            type: "array",
+            minItems: 1,
+            maxItems: 20,
+            items: { type: "string", maxLength: 10_000 },
+        },
+    },
+    index: { type: "integer", minimum: 0, maximum: 100_000 },
+    size: {
+        type: "object",
+        required: ["width", "height"],
+        additionalProperties: false,
+        properties: {
+            width: { type: "number", exclusiveMinimum: 0, maximum: 1584 },
+            height: { type: "number", exclusiveMinimum: 0, maximum: 1584 },
+        },
+    },
+};
+function operation(name, properties, required) {
+    return {
+        type: "object",
+        required: ["op", ...required],
+        additionalProperties: false,
+        properties: { op: { const: name }, ...properties },
+        $defs: definitions,
+    };
+}
+/** `before` or `after`: the element the operation places next to. */
+const placement = {
+    before: { $ref: "#/$defs/target" },
+    after: { $ref: "#/$defs/target" },
+};
+const all = {
+    replaceText: operation("replaceText", {
+        target: { $ref: "#/$defs/target" },
+        text: { $ref: "#/$defs/text" },
+        range: { $ref: "#/$defs/textRange" },
+    }, ["target", "text"]),
+    setTextStyle: operation("setTextStyle", {
+        target: { $ref: "#/$defs/target" },
+        range: { $ref: "#/$defs/textRange" },
+        style: { $ref: "#/$defs/textStyle" },
+    }, ["target", "style"]),
+    setParagraphStyle: operation("setParagraphStyle", {
+        target: { $ref: "#/$defs/target" },
+        style: { $ref: "#/$defs/paragraphStyle" },
+    }, ["target", "style"]),
+    insertParagraph: operation("insertParagraph", {
+        ...placement,
+        text: { $ref: "#/$defs/text" },
+        style: { $ref: "#/$defs/textStyle" },
+    }, ["text"]),
+    deleteElement: operation("deleteElement", { target: { $ref: "#/$defs/target" } }, ["target"]),
+    moveElement: operation("moveElement", { target: { $ref: "#/$defs/target" }, ...placement }, ["target"]),
+    insertTable: operation("insertTable", {
+        ...placement,
+        rows: { $ref: "#/$defs/tableRows" },
+        columnWidths: {
+            type: "array",
+            minItems: 1,
+            maxItems: 20,
+            items: { type: "number", exclusiveMinimum: 0 },
+        },
+    }, ["rows"]),
+    setTableCell: operation("setTableCell", {
+        target: { $ref: "#/$defs/target" },
+        row: { $ref: "#/$defs/index" },
+        column: { $ref: "#/$defs/index" },
+        text: { $ref: "#/$defs/text" },
+    }, ["target", "row", "column", "text"]),
+    insertImage: operation("insertImage", {
+        ...placement,
+        data: { "x-binary": true, type: "string", contentEncoding: "base64" },
+        mimeType: { enum: ["image/png", "image/jpeg"] },
+        size: { $ref: "#/$defs/size" },
+    }, ["data", "mimeType", "size"]),
+};
+/** Operations with an engine handler; grows as the tasks land. */
+export const IMPLEMENTED_OPERATIONS = [
+    "replaceText",
+    "setTextStyle",
+    "setParagraphStyle",
+    "insertParagraph",
+    "deleteElement",
+    "moveElement",
+    "insertImage",
+    "insertTable",
+    "setTableCell",
+];
+export const docxOperationSchemas = Object.freeze({
+    format: "docx",
+    version: 1,
+    operations: Object.freeze(Object.fromEntries(IMPLEMENTED_OPERATIONS.map((name) => [name, all[name]]))),
+});
+/** Every schema, implemented or not, for the conformance test. */
+export const docxOperationSchemaDrafts = all;

package/dist/edit/docx/session.d.ts

@@ -0,0 +1,37 @@
+import type { EditSessionAccess, EditSessionCore } from "../engine.js";
+import type { ApplyOptions, AssetOptions, EditFindOptions, EditOperation, EditReceipt, EditState, ElementQuery, HistoryOptions, OperationSchemaSet, PagePoint, PageRect, ReadItem, ReadOptions, ReadResult, SavedDocument, TextTarget } from "../types.js";
+import type { DocxDeleteElementOperation, DocxEditSession, DocxElement, DocxFields, DocxInsertImageOperation, DocxInsertParagraphOperation, DocxInsertTableOperation, DocxMoveElementOperation, DocxOperation, DocxReplaceTextOperation, DocxSaveOptions, DocxSetParagraphStyleOperation, DocxSetTableCellOperation, DocxSetTextStyleOperation } from "./types.js";
+/** Per paragraph id (eight hex digits), the union of its runs per page. */
+type Placement = ReadonlyMap<string, ReadonlyMap<number, PageRect>>;
+export declare class DocxSession implements DocxEditSession {
+    #private;
+    readonly format: "docx";
+    constructor(core: EditSessionCore, access: EditSessionAccess);
+    get sessionId(): string;
+    get state(): EditState;
+    get schemas(): OperationSchemaSet;
+    apply(operations: readonly DocxOperation[], options?: ApplyOptions): Promise<EditReceipt>;
+    applyJson(operations: readonly EditOperation[], options?: ApplyOptions): Promise<EditReceipt>;
+    undo(options?: HistoryOptions): Promise<EditReceipt>;
+    redo(options?: HistoryOptions): Promise<EditReceipt>;
+    reset(options?: HistoryOptions): Promise<EditReceipt>;
+    save(options?: DocxSaveOptions): Promise<SavedDocument>;
+    markSaved(stateToken: string): void;
+    addAsset(data: Uint8Array, options?: AssetOptions): Promise<string>;
+    getElements(query?: ElementQuery, options?: ReadOptions): Promise<ReadResult<DocxElement>>;
+    getElement(id: string, options?: ReadOptions): Promise<ReadItem<DocxElement>>;
+    elementsAt(pageIndex: number, point: PagePoint, options?: ReadOptions): Promise<ReadResult<DocxElement>>;
+    findText(query: string, options?: EditFindOptions): Promise<ReadResult<TextTarget>>;
+    replaceText(fields: DocxFields<DocxReplaceTextOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    setTextStyle(fields: DocxFields<DocxSetTextStyleOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    setParagraphStyle(fields: DocxFields<DocxSetParagraphStyleOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    insertParagraph(fields: DocxFields<DocxInsertParagraphOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    deleteElement(fields: DocxFields<DocxDeleteElementOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    moveElement(fields: DocxFields<DocxMoveElementOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    insertTable(fields: DocxFields<DocxInsertTableOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    setTableCell(fields: DocxFields<DocxSetTableCellOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    insertImage(fields: DocxFields<DocxInsertImageOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+}
+/** Joins the engine's elements with the runs' placement. */
+export declare function placeElements(elements: readonly DocxElement[], placement: Placement): DocxElement[];
+export {};

package/dist/edit/docx/session.js

@@ -0,0 +1,426 @@
+export class DocxSession {
+    format = "docx";
+    #core;
+    #access;
+    constructor(core, access) {
+        this.#core = core;
+        this.#access = access;
+    }
+    get sessionId() {
+        return this.#core.sessionId;
+    }
+    get state() {
+        return this.#core.state;
+    }
+    get schemas() {
+        return this.#core.schemas;
+    }
+    apply(operations, options) {
+        return this.#core.apply(operations, options);
+    }
+    applyJson(operations, options) {
+        return this.#core.applyJson(operations, options);
+    }
+    undo(options) {
+        return this.#core.undo(options);
+    }
+    redo(options) {
+        return this.#core.redo(options);
+    }
+    reset(options) {
+        return this.#core.reset(options);
+    }
+    save(options) {
+        return this.#core.save(options);
+    }
+    markSaved(stateToken) {
+        this.#core.markSaved(stateToken);
+    }
+    addAsset(data, options) {
+        return this.#core.addAsset(data, options);
+    }
+    getElements(query = {}, options) {
+        return this.#core.readItems(options, async (engine, signal) => {
+            const elements = (await engine.getElements({}, signal));
+            const pages = query.pageIndex === undefined
+                ? this.#access.cachedPages()
+                : [query.pageIndex];
+            const placement = await this.#placement(pages, signal);
+            return placeElements(elements, placement).filter((element) => matchesQuery(element, query));
+        });
+    }
+    getElement(id, options) {
+        return this.#core.readItem(options, async (engine, signal) => {
+            // A table is placed through its cell paragraphs, so every element is
+            // read and the one asked for picked out of the joined list.
+            const elements = (await engine.getElements({}, signal));
+            if (!elements.some((element) => element.id === id))
+                return undefined;
+            const placement = await this.#placement(this.#access.cachedPages(), signal);
+            return placeElements(elements, placement).find((element) => element.id === id);
+        });
+    }
+    elementsAt(pageIndex, point, options) {
+        return this.#core.readItems(options, async (engine, signal) => {
+            const runs = await this.#access.getTextRuns(pageIndex, signal);
+            const hit = new Set();
+            for (const run of runs)
+                if (run.paragraphId && rectContains(runRect(run), point))
+                    hit.add(`p:${run.paragraphId}`);
+            if (hit.size === 0)
+                return [];
+            const elements = (await engine.getElements({}, signal));
+            const placed = placeElements(elements, await this.#placement([pageIndex], signal));
+            const paragraphs = placed.filter((element) => hit.has(element.id));
+            const tables = new Set(paragraphs
+                .map((element) => element.parentId)
+                .filter((id) => id !== undefined));
+            return [
+                ...paragraphs,
+                ...placed.filter((element) => tables.has(element.id)),
+            ];
+        });
+    }
+    async findText(query, options = {}) {
+        // A page range bounds the matches by where they are placed, which
+        // only the geometry knows: the engine then searches without a limit
+        // and the limit applies to the matches on those pages.
+        const { pageRange } = options;
+        const engineOptions = { ...options };
+        if (pageRange)
+            delete engineOptions.maxResults;
+        const found = await this.#core.findText(query, engineOptions);
+        const placed = await this.#placeTargets(found.items, options);
+        const items = pageRange
+            ? placed
+                .filter((target) => target.pageIndex >= pageRange[0] &&
+                target.pageIndex <= pageRange[1])
+                .slice(0, options.maxResults ?? placed.length)
+            : placed;
+        return Object.freeze({ ...found, items });
+    }
+    replaceText(fields, options) {
+        return this.apply([{ op: "replaceText", ...fields }], options);
+    }
+    setTextStyle(fields, options) {
+        return this.apply([{ op: "setTextStyle", ...fields }], options);
+    }
+    setParagraphStyle(fields, options) {
+        return this.apply([{ op: "setParagraphStyle", ...fields }], options);
+    }
+    insertParagraph(fields, options) {
+        return this.apply([{ op: "insertParagraph", ...fields }], options);
+    }
+    deleteElement(fields, options) {
+        return this.apply([{ op: "deleteElement", ...fields }], options);
+    }
+    moveElement(fields, options) {
+        return this.apply([{ op: "moveElement", ...fields }], options);
+    }
+    insertTable(fields, options) {
+        return this.apply([{ op: "insertTable", ...fields }], options);
+    }
+    setTableCell(fields, options) {
+        return this.apply([{ op: "setTableCell", ...fields }], options);
+    }
+    insertImage(fields, options) {
+        return this.apply([{ op: "insertImage", ...fields }], options);
+    }
+    /** The union of every paragraph's runs on the given pages. */
+    async #placement(pages, signal) {
+        const placement = new Map();
+        for (const pageIndex of [...new Set(pages)].sort((a, b) => a - b)) {
+            const runs = await this.#access.getTextRuns(pageIndex, signal);
+            for (const run of runs) {
+                if (!run.paragraphId)
+                    continue;
+                let pages = placement.get(run.paragraphId);
+                if (!pages) {
+                    pages = new Map();
+                    placement.set(run.paragraphId, pages);
+                }
+                const current = pages.get(pageIndex);
+                pages.set(pageIndex, current ? union(current, runRect(run)) : runRect(run));
+            }
+        }
+        return placement;
+    }
+    /**
+     * Rectangles and pages for text matches: the runs of the match's
+     * paragraph on the page that holds it, cut to the matched characters
+     * when the run text can be aligned with the paragraph text, else the
+     * paragraph's runs on its first page. Pages are read from the viewer's
+     * cache first, then from the requested range, then in order.
+     */
+    async #placeTargets(targets, options) {
+        if (targets.length === 0)
+            return targets;
+        const signal = options.signal;
+        const runsByPage = new Map();
+        const load = async (pageIndex) => {
+            let runs = runsByPage.get(pageIndex);
+            if (!runs) {
+                runs = await this.#access.getTextRuns(pageIndex, signal);
+                runsByPage.set(pageIndex, runs);
+            }
+            return runs;
+        };
+        const pageCount = this.#core.state.pageCount;
+        const cached = this.#access.cachedPages();
+        const scan = options.pageRange
+            ? range(options.pageRange[0], options.pageRange[1], pageCount)
+            : range(0, pageCount - 1, pageCount);
+        /** Pages that hold runs of a paragraph, found so far. */
+        const pagesOf = new Map();
+        const holds = async (pageIndex, paragraphId) => (await load(pageIndex)).some((run) => run.paragraphId === paragraphId);
+        // A paragraph's pages are contiguous: the first page found to hold
+        // it, among the cached pages and then the scanned ones, is grown
+        // in both directions until a page without it.
+        const locate = async (paragraphId) => {
+            const known = pagesOf.get(paragraphId);
+            if (known)
+                return known;
+            let seed;
+            for (const pageIndex of [...cached, ...scan]) {
+                if (await holds(pageIndex, paragraphId)) {
+                    seed = pageIndex;
+                    break;
+                }
+            }
+            const pages = [];
+            if (seed !== undefined) {
+                pages.push(seed);
+                for (let pageIndex = seed - 1; pageIndex >= 0 && (await holds(pageIndex, paragraphId)); pageIndex -= 1)
+                    pages.unshift(pageIndex);
+                for (let pageIndex = seed + 1; pageIndex < pageCount && (await holds(pageIndex, paragraphId)); pageIndex += 1)
+                    pages.push(pageIndex);
+            }
+            pagesOf.set(paragraphId, pages);
+            return pages;
+        };
+        const fold = (value) => options.caseSensitive ? value : value.toLocaleLowerCase();
+        const occurrences = new Map();
+        const out = [];
+        for (const target of targets) {
+            const elementId = target.elementIds[0];
+            const paragraphId = elementId?.startsWith("p:")
+                ? elementId.slice(2)
+                : undefined;
+            const pages = paragraphId ? await locate(paragraphId) : [];
+            if (!paragraphId || pages.length === 0) {
+                out.push(target);
+                continue;
+            }
+            const runs = [];
+            for (const pageIndex of pages)
+                for (const run of await load(pageIndex))
+                    if (run.paragraphId === paragraphId)
+                        runs.push({ run, pageIndex });
+            const key = `${paragraphId}\u0000${fold(target.text)}`;
+            const occurrence = occurrences.get(key) ?? 0;
+            occurrences.set(key, occurrence + 1);
+            const rects = matchRects(runs, fold(target.text), occurrence, fold);
+            const placed = rects.length > 0
+                ? rects
+                : runs
+                    .filter((entry) => entry.pageIndex === pages[0])
+                    .map((entry) => ({
+                    pageIndex: entry.pageIndex,
+                    rect: runRect(entry.run),
+                }));
+            out.push({
+                ...target,
+                pageIndex: placed[0]?.pageIndex ?? target.pageIndex,
+                rects: placed.map((entry) => entry.rect),
+            });
+        }
+        return out;
+    }
+}
+function range(first, last, pageCount) {
+    const out = [];
+    for (let index = Math.max(0, first); index <= Math.min(last, pageCount - 1); index += 1)
+        out.push(index);
+    return out;
+}
+/** The `occurrence`-th match of `needle` in the runs' text, cut to run boxes. */
+function matchRects(runs, needle, occurrence, fold) {
+    if (needle.length === 0)
+        return [];
+    const text = fold(runs.map((entry) => entry.run.text).join(""));
+    let at = -1;
+    for (let found = 0; found <= occurrence; found += 1) {
+        at = text.indexOf(needle, at + 1);
+        if (at < 0)
+            return [];
+    }
+    const end = at + needle.length;
+    const out = [];
+    let offset = 0;
+    for (const { run, pageIndex } of runs) {
+        const runStart = offset;
+        const runEnd = offset + run.text.length;
+        offset = runEnd;
+        if (runEnd <= at || runStart >= end || run.text.length === 0)
+            continue;
+        const from = Math.max(at, runStart) - runStart;
+        const to = Math.min(end, runEnd) - runStart;
+        const box = runRect(run);
+        const scale = box.width / run.text.length;
+        out.push({
+            pageIndex,
+            rect: {
+                x: box.x + from * scale,
+                y: box.y,
+                width: (to - from) * scale,
+                height: box.height,
+            },
+        });
+    }
+    return out;
+}
+function runRect(run) {
+    return { x: run.x, y: run.y, width: run.width, height: run.height };
+}
+function union(a, b) {
+    const x = Math.min(a.x, b.x);
+    const y = Math.min(a.y, b.y);
+    return {
+        x,
+        y,
+        width: Math.max(a.x + a.width, b.x + b.width) - x,
+        height: Math.max(a.y + a.height, b.y + b.height) - y,
+    };
+}
+function rectContains(rect, point) {
+    return (point.x >= rect.x &&
+        point.x <= rect.x + rect.width &&
+        point.y >= rect.y &&
+        point.y <= rect.y + rect.height);
+}
+function rectsIntersect(a, b) {
+    return (a.x < b.x + b.width &&
+        b.x < a.x + a.width &&
+        a.y < b.y + b.height &&
+        b.y < a.y + a.height);
+}
+function fragmentsOf(pages) {
+    if (!pages)
+        return [];
+    return [...pages.entries()]
+        .sort((a, b) => a[0] - b[0])
+        .map(([pageIndex, bounds]) => ({ pageIndex, bounds }));
+}
+function withFragments(element, fragments) {
+    const first = fragments[0];
+    return {
+        ...element,
+        pageIndex: first ? first.pageIndex : -1,
+        bounds: first ? first.bounds : { x: 0, y: 0, width: 0, height: 0 },
+        fragments,
+    };
+}
+/** Characters a paragraph may hold without the renderer drawing a text run for it. */
+const INVISIBLE = /^[\ufffc\s]*$/;
+/**
+ * A paragraph that draws no run (empty, or holding only pictures) is
+ * placed by estimate right after the placed paragraph before it in the
+ * same body or cell, else right before the one after it: a picture
+ * paragraph takes its largest picture's extent, an empty one a line of
+ * its neighbour's height. Nothing is estimated for a paragraph with text,
+ * whose runs simply lie on a page not read yet.
+ */
+function estimateRunless(elements, placed) {
+    const paragraphs = elements.filter((element) => element.kind === "paragraph");
+    const sizeOf = (paragraph) => {
+        const pictures = elements.filter((candidate) => candidate.kind === "image" &&
+            candidate.parentId === paragraph.id &&
+            candidate.imageSize);
+        if (pictures.length === 0)
+            return undefined;
+        return {
+            width: Math.max(...pictures.map((picture) => picture.imageSize.width)),
+            height: Math.max(...pictures.map((picture) => picture.imageSize.height)),
+        };
+    };
+    for (const [index, paragraph] of paragraphs.entries()) {
+        const current = placed.get(paragraph.id);
+        if (current.pageIndex >= 0 || !INVISIBLE.test(paragraph.text ?? ""))
+            continue;
+        const sibling = (step) => {
+            for (let at = index + step; at >= 0 && at < paragraphs.length; at += step) {
+                const other = paragraphs[at];
+                if (other.parentId !== paragraph.parentId)
+                    continue;
+                const fragments = placed.get(other.id)?.fragments ?? [];
+                const fragment = step < 0 ? fragments.at(-1) : fragments[0];
+                if (fragment)
+                    return fragment;
+                if (!INVISIBLE.test(other.text ?? ""))
+                    return undefined;
+            }
+            return undefined;
+        };
+        const before = sibling(-1);
+        const after = before ? undefined : sibling(1);
+        const anchor = before ?? after;
+        if (!anchor)
+            continue;
+        const size = sizeOf(paragraph) ?? {
+            width: anchor.bounds.width,
+            height: anchor.bounds.height,
+        };
+        const bounds = before
+            ? {
+                x: before.bounds.x,
+                y: before.bounds.y + before.bounds.height,
+                ...size,
+            }
+            : {
+                x: after.bounds.x,
+                y: Math.max(0, after.bounds.y - size.height),
+                ...size,
+            };
+        placed.set(paragraph.id, withFragments(paragraph, [{ pageIndex: anchor.pageIndex, bounds }]));
+    }
+}
+/** Joins the engine's elements with the runs' placement. */
+export function placeElements(elements, placement) {
+    const placed = new Map();
+    // Paragraphs first; tables and inline objects derive from them.
+    for (const element of elements)
+        if (element.kind === "paragraph")
+            placed.set(element.id, withFragments(element, fragmentsOf(placement.get(element.id.slice(2)))));
+    estimateRunless(elements, placed);
+    for (const element of elements) {
+        if (element.kind === "table") {
+            const pages = new Map();
+            for (const candidate of elements) {
+                if (candidate.kind !== "paragraph" || candidate.parentId !== element.id)
+                    continue;
+                for (const fragment of placed.get(candidate.id)?.fragments ?? []) {
+                    const current = pages.get(fragment.pageIndex);
+                    pages.set(fragment.pageIndex, current ? union(current, fragment.bounds) : fragment.bounds);
+                }
+            }
+            placed.set(element.id, withFragments(element, fragmentsOf(pages)));
+        }
+        else if (element.kind !== "paragraph") {
+            const parent = element.parentId
+                ? placed.get(element.parentId)
+                : undefined;
+            placed.set(element.id, withFragments(element, parent?.fragments ?? []));
+        }
+    }
+    return elements.map((element) => placed.get(element.id) ?? element);
+}
+function matchesQuery(element, query) {
+    if (query.kinds && !query.kinds.includes(element.kind))
+        return false;
+    if (query.pageIndex === undefined)
+        return true;
+    const fragment = element.fragments?.find((candidate) => candidate.pageIndex === query.pageIndex);
+    if (!fragment)
+        return false;
+    return !query.intersects || rectsIntersect(fragment.bounds, query.intersects);
+}

package/dist/edit/docx/structure-ops.d.ts

@@ -0,0 +1,6 @@
+import type { DocxOperationHandler } from "./operations.js";
+import type { DocxDeleteElementOperation, DocxInsertImageOperation, DocxInsertParagraphOperation, DocxMoveElementOperation } from "./types.js";
+export declare const insertParagraphHandler: DocxOperationHandler<DocxInsertParagraphOperation>;
+export declare const deleteElementHandler: DocxOperationHandler<DocxDeleteElementOperation>;
+export declare const moveElementHandler: DocxOperationHandler<DocxMoveElementOperation>;
+export declare const insertImageHandler: DocxOperationHandler<DocxInsertImageOperation>;