web-doc 0.6.2 → 0.7.0

package/dist/edit/ooxml/patch.js

@@ -0,0 +1,250 @@
+import { ViewerError } from "../../errors.js";
+import { escapeAttribute, escapeText, scanXml, } from "./xml.js";
+export const patches = {
+    /** Replaces the content between the tags; a self-closing element is opened. */
+    replaceContent(part, node, xml) {
+        if (node.selfClosing)
+            return {
+                start: node.end - 2,
+                end: node.end,
+                text: `>${xml}</${node.name}>`,
+                expect: { kind: "content", at: node.start },
+            };
+        return {
+            start: node.contentStart,
+            end: node.contentEnd,
+            text: xml,
+            expect: { kind: "content", at: node.start },
+        };
+    },
+    /** Replaces the whole element with one element. */
+    replaceElement(part, node, xml) {
+        return {
+            start: node.start,
+            end: node.end,
+            text: xml,
+            expect: { kind: "element" },
+        };
+    },
+    /** Removes the element and nothing around it. */
+    removeElement(part, node) {
+        if (!node.parent)
+            throw new ViewerError("invalid-patch", `Part ${part.name}: the root element cannot be removed`, { details: { part: part.name } });
+        return {
+            start: node.start,
+            end: node.end,
+            text: "",
+            expect: {
+                kind: "removed",
+                parentAt: node.parent.start,
+                count: node.parent.children.length - 1,
+                xml: part.text.slice(node.start, node.end),
+            },
+        };
+    },
+    insertBefore(part, node, xml) {
+        return {
+            start: node.start,
+            end: node.start,
+            text: xml,
+            expect: { kind: "element" },
+        };
+    },
+    insertAfter(part, node, xml) {
+        return {
+            start: node.end,
+            end: node.end,
+            text: xml,
+            expect: { kind: "element" },
+        };
+    },
+    /** Appends one element at the end of the content; a self-closing element is opened. */
+    appendChild(part, node, xml) {
+        if (node.selfClosing)
+            return {
+                start: node.end - 2,
+                end: node.end,
+                text: `>${xml}</${node.name}>`,
+                expect: { kind: "content", at: node.start },
+            };
+        return {
+            start: node.contentEnd,
+            end: node.contentEnd,
+            text: xml,
+            expect: { kind: "element" },
+        };
+    },
+    setAttribute(part, node, name, value) {
+        const existing = node.attributes.find((attribute) => attribute.name === name);
+        const expect = {
+            kind: "attribute",
+            at: node.start,
+            name,
+            value,
+        };
+        if (existing)
+            return {
+                start: existing.start,
+                end: existing.end,
+                text: `${name}=${escapeAttribute(value)}`,
+                expect,
+            };
+        const at = startTagClose(part, node);
+        return {
+            start: at,
+            end: at,
+            text: ` ${name}=${escapeAttribute(value)}`,
+            expect,
+        };
+    },
+    removeAttribute(part, node, name) {
+        const existing = node.attributes.find((attribute) => attribute.name === name);
+        const expect = {
+            kind: "attribute",
+            at: node.start,
+            name,
+            value: undefined,
+        };
+        if (!existing)
+            return { start: node.start, end: node.start, text: "", expect };
+        // Take the whitespace before the attribute with it.
+        let start = existing.start;
+        while (start > node.start && /\s/.test(part.text[start - 1]))
+            start -= 1;
+        return { start, end: existing.end, text: "", expect };
+    },
+    text: escapeText,
+    attr: escapeAttribute,
+};
+/** Where the start tag's ">" or "/>" begins. */
+function startTagClose(part, node) {
+    if (node.selfClosing)
+        return node.end - 2;
+    const last = node.attributes.at(-1);
+    const from = last ? last.end : node.start + 1 + node.name.length;
+    const close = part.text.indexOf(">", from);
+    if (close < 0 || close >= node.contentStart)
+        throw new ViewerError("internal", `Start tag of ${node.name} has no close`);
+    return close;
+}
+/**
+ * Applies the patches to the part's text, re-scans it and checks every
+ * expectation; returns the new part scanned at `revision`. Throws
+ * `invalid-patch` and leaves nothing behind when anything is wrong.
+ */
+export function applyPatches(part, items, revision) {
+    const sorted = [...items].sort((a, b) => a.start - b.start || a.end - b.end);
+    let cursor = 0;
+    for (const patch of sorted) {
+        if (!Number.isInteger(patch.start) ||
+            !Number.isInteger(patch.end) ||
+            patch.start < 0 ||
+            patch.end < patch.start ||
+            patch.end > part.text.length)
+            throw invalid(part, patch, "the range is outside the part");
+        if (patch.start < cursor)
+            throw invalid(part, patch, "the ranges overlap");
+        cursor = patch.end;
+    }
+    // Build the new text from the front, remembering where each patch lands.
+    let out = "";
+    let from = 0;
+    const landed = [];
+    for (const patch of sorted) {
+        out += part.text.slice(from, patch.start);
+        landed.push(out.length);
+        out += patch.text;
+        from = patch.end;
+    }
+    out += part.text.slice(from);
+    let rescanned;
+    try {
+        rescanned = scanXml(part.name, out, revision);
+    }
+    catch (error) {
+        throw new ViewerError("invalid-patch", `Part ${part.name}: the patched part is not well-formed`, {
+            cause: error,
+            details: {
+                part: part.name,
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+    }
+    const byStart = new Map();
+    const stack = [rescanned.root];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        byStart.set(node.start, node);
+        for (const child of node.children)
+            stack.push(child);
+    }
+    /** Where an unpatched offset lands: shifted by every patch that ends at or before it. */
+    const mapped = (offset) => {
+        let delta = 0;
+        for (const patch of sorted) {
+            if (patch.end > offset)
+                break;
+            delta += patch.text.length - (patch.end - patch.start);
+        }
+        return offset + delta;
+    };
+    sorted.forEach((patch, index) => {
+        const at = landed[index];
+        const { expect } = patch;
+        switch (expect.kind) {
+            case "element": {
+                const node = byStart.get(at);
+                if (!node || node.end !== at + patch.text.length)
+                    throw invalid(part, patch, "the fragment does not read back as one element", rescanned.text.slice(at, at + patch.text.length));
+                break;
+            }
+            case "content": {
+                const node = byStart.get(mapped(expect.at));
+                if (!node)
+                    throw invalid(part, patch, "the patched element is gone");
+                const content = rescanned.text.slice(node.contentStart, node.contentEnd);
+                const wanted = node.selfClosing
+                    ? ""
+                    : patch.text.startsWith(">") && patch.text.endsWith(`</${node.name}>`)
+                        ? patch.text.slice(1, -(node.name.length + 3))
+                        : patch.text;
+                if (content !== wanted)
+                    throw invalid(part, patch, "the content does not read back", content);
+                break;
+            }
+            case "attribute": {
+                const node = byStart.get(mapped(expect.at));
+                if (!node)
+                    throw invalid(part, patch, "the patched element is gone");
+                const read = rescanned.attribute(node, expect.name);
+                if (read !== expect.value)
+                    throw invalid(part, patch, `attribute ${expect.name} reads back differently`, read);
+                break;
+            }
+            case "removed": {
+                const parent = byStart.get(mapped(expect.parentAt));
+                if (!parent)
+                    throw invalid(part, patch, "the removed element's parent is gone");
+                // Another patch may have put a sibling in the same place; then the
+                // removed element's own text must at least be gone from there.
+                if (parent.children.length !== expect.count &&
+                    rescanned.text.startsWith(expect.xml, at))
+                    throw invalid(part, patch, "the element is still there", String(parent.children.length));
+                break;
+            }
+            case "none":
+                break;
+        }
+    });
+    return rescanned;
+}
+function invalid(part, patch, reason, read) {
+    return new ViewerError("invalid-patch", `Part ${part.name}: ${reason}`, {
+        details: {
+            part: part.name,
+            range: [patch.start, patch.end],
+            reason,
+            ...(read === undefined ? {} : { read: read.slice(0, 200) }),
+        },
+    });
+}

package/dist/edit/ooxml/transaction.d.ts

@@ -0,0 +1,39 @@
+import type { ViewerWarning } from "../../contracts.js";
+import { CONTENT_TYPES_NAMESPACE } from "./opc.js";
+import type { OoxmlPackage } from "./package.js";
+import { type XmlPatch } from "./patch.js";
+import { type XmlPart } from "./xml.js";
+export interface CommittedChange {
+    readonly changedParts: readonly string[];
+    readonly addedParts: readonly string[];
+    readonly removedParts: readonly string[];
+    /** One per relationship whose internal target no longer exists. */
+    readonly warnings: readonly ViewerWarning[];
+}
+export declare class PackageTransaction {
+    #private;
+    constructor(pkg: OoxmlPackage);
+    /** Patches of one scanned part; the scan must be of the current revision. */
+    patch(part: XmlPart, items: readonly XmlPatch[]): void;
+    /** Adds or replaces a part; `contentType` registers it unless a Default covers the extension. */
+    setPart(name: string, bytes: Uint8Array, contentType?: string): void;
+    removePart(name: string): void;
+    /** Allocates the next free rId of the source's .rels part, pending adds included. */
+    addRelationship(sourcePart: string, type: string, target: string, mode?: "Internal" | "External"): Promise<string>;
+    removeRelationship(sourcePart: string, id: string): void;
+    /**
+     * Stores media once per distinct content under `folder`, registers the
+     * extension's content type when missing, and relates it to `sourcePart`.
+     */
+    addMedia(sourcePart: string, folder: string, bytes: Uint8Array, mimeType: string, relationshipType?: string): Promise<{
+        readonly part: string;
+        readonly rId: string;
+    }>;
+    /** A part name that does not exist yet, in the package or in this transaction. */
+    uniquePartName(prefix: string, extension: string): string;
+    /** Applies everything or nothing; returns what changed. */
+    commit(signal?: AbortSignal): Promise<CommittedChange>;
+}
+/** "../media/image1.png" for a target seen from a source part. */
+export declare function relativeTarget(sourcePart: string, targetPart: string): string;
+export { CONTENT_TYPES_NAMESPACE };

package/dist/edit/ooxml/transaction.js

@@ -0,0 +1,316 @@
+import { ViewerError } from "../../errors.js";
+import { extensionOf, partKey, partNameOf, relationshipsPartOf, } from "./names.js";
+import { CONTENT_TYPES_NAMESPACE, extensionForMime, IMAGE_RELATIONSHIP_TYPE, parseContentTypes, parseRelationships, RELATIONSHIPS_NAMESPACE, sourceOfRelationshipsPart, } from "./opc.js";
+import { applyPatches, patches } from "./patch.js";
+import { encodePart, escapeAttribute, scanXml } from "./xml.js";
+const CONTENT_TYPES = "/[Content_Types].xml";
+const XML_HEADER = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n';
+export class PackageTransaction {
+    #pkg;
+    #revision;
+    #patches = new Map();
+    #set = new Map();
+    #removed = new Set();
+    #relationshipAdds = new Map();
+    #relationshipRemoves = new Map();
+    #relationshipSets = new Map();
+    #mediaByHash = new Map();
+    #committed = false;
+    constructor(pkg) {
+        this.#pkg = pkg;
+        this.#revision = pkg.revision;
+    }
+    /** Patches of one scanned part; the scan must be of the current revision. */
+    patch(part, items) {
+        this.#open();
+        if (part.revision !== this.#revision)
+            throw new ViewerError("invalid-patch", `Part ${part.name} was scanned at another revision`, {
+                details: {
+                    part: part.name,
+                    scannedAt: part.revision,
+                    current: this.#revision,
+                },
+            });
+        const key = partKey(part.name);
+        if (this.#set.has(key) || this.#removed.has(key))
+            throw new ViewerError("invalid-patch", `Part ${part.name} is replaced or removed in this transaction`, {
+                details: { part: part.name },
+            });
+        const existing = this.#patches.get(key);
+        if (existing)
+            existing.items.push(...items);
+        else
+            this.#patches.set(key, { part, items: [...items] });
+    }
+    /** Adds or replaces a part; `contentType` registers it unless a Default covers the extension. */
+    setPart(name, bytes, contentType) {
+        this.#open();
+        const partName = partNameOf(name);
+        const key = partKey(partName);
+        if (this.#patches.has(key))
+            throw new ViewerError("invalid-patch", `Part ${partName} is patched in this transaction`, {
+                details: { part: partName },
+            });
+        this.#removed.delete(key);
+        this.#set.set(key, {
+            name: partName,
+            bytes: bytes.slice(),
+            ...(contentType ? { contentType } : {}),
+        });
+    }
+    removePart(name) {
+        this.#open();
+        const key = partKey(name);
+        this.#patches.delete(key);
+        this.#set.delete(key);
+        this.#removed.add(key);
+    }
+    /** Allocates the next free rId of the source's .rels part, pending adds included. */
+    async addRelationship(sourcePart, type, target, mode = "Internal") {
+        this.#open();
+        const source = sourcePart === "/" ? "/" : partNameOf(sourcePart);
+        const set = await this.#relationships(source);
+        const pending = this.#relationshipAdds.get(source) ?? [];
+        const taken = new Set(pending.map((add) => add.id));
+        const id = set.nextId(taken);
+        pending.push({ id, type, target, mode });
+        this.#relationshipAdds.set(source, pending);
+        return id;
+    }
+    removeRelationship(sourcePart, id) {
+        this.#open();
+        const source = sourcePart === "/" ? "/" : partNameOf(sourcePart);
+        const pending = this.#relationshipAdds.get(source);
+        if (pending) {
+            const index = pending.findIndex((add) => add.id === id);
+            if (index >= 0) {
+                pending.splice(index, 1);
+                return;
+            }
+        }
+        const removes = this.#relationshipRemoves.get(source) ?? new Set();
+        removes.add(id);
+        this.#relationshipRemoves.set(source, removes);
+    }
+    /**
+     * Stores media once per distinct content under `folder`, registers the
+     * extension's content type when missing, and relates it to `sourcePart`.
+     */
+    async addMedia(sourcePart, folder, bytes, mimeType, relationshipType = IMAGE_RELATIONSHIP_TYPE) {
+        this.#open();
+        const extension = extensionForMime(mimeType);
+        const hash = `${folder}|${extension}|${await sha256(bytes)}`;
+        let part = this.#mediaByHash.get(hash);
+        if (!part) {
+            part = this.uniquePartName(`${partNameOf(folder).replace(/\/?$/, "/")}image`, `.${extension}`);
+            this.#mediaByHash.set(hash, part);
+            const types = await this.#contentTypes();
+            const needsDefault = !types.defaults.has(extension) &&
+                ![...this.#set.values()].some((entry) => entry.contentType && extensionOf(entry.name) === extension);
+            this.setPart(part, bytes, needsDefault ? mimeType : undefined);
+        }
+        const source = sourcePart === "/" ? "/" : partNameOf(sourcePart);
+        const rId = await this.addRelationship(source, relationshipType, relativeTarget(source, part));
+        return { part, rId };
+    }
+    /** A part name that does not exist yet, in the package or in this transaction. */
+    uniquePartName(prefix, extension) {
+        const base = partNameOf(prefix);
+        for (let n = 1;; n += 1) {
+            const candidate = `${base}${n}${extension}`;
+            const key = partKey(candidate);
+            if (this.#removed.has(key))
+                return candidate;
+            if (!this.#pkg.has(candidate) && !this.#set.has(key))
+                return candidate;
+        }
+    }
+    /** Applies everything or nothing; returns what changed. */
+    async commit(signal) {
+        this.#open();
+        if (signal?.aborted)
+            throw new ViewerError("aborted", "The transaction was aborted");
+        if (this.#pkg.revision !== this.#revision)
+            throw new ViewerError("edit-conflict", "The package changed since the transaction started", {
+                details: { expected: this.#revision, actual: this.#pkg.revision },
+            });
+        const set = new Map();
+        const remove = new Set();
+        const next = this.#revision + 1;
+        // 1. Patched parts, verified by re-scan.
+        for (const { part, items } of this.#patches.values()) {
+            const patched = applyPatches(part, items, next);
+            set.set(part.name, encodePart(patched.text));
+        }
+        // 2. Replaced and added parts; XML parts must scan.
+        for (const entry of this.#set.values()) {
+            if (/\.(xml|rels)$/i.test(entry.name)) {
+                const text = new TextDecoder("utf-8", { fatal: true }).decode(entry.bytes);
+                scanXml(entry.name, text, next);
+            }
+            set.set(entry.name, entry.bytes);
+        }
+        // 3. Removed parts take their own .rels part along.
+        for (const key of this.#removed) {
+            const name = this.#pkg.currentPartNames.find((candidate) => partKey(candidate) === key) ?? key;
+            if (!this.#pkg.has(name))
+                continue;
+            remove.add(name);
+            const rels = relationshipsPartOf(name);
+            if (this.#pkg.has(rels))
+                remove.add(rels);
+        }
+        // 4. Relationship parts, as patches or new parts.
+        const relationshipSources = new Set([
+            ...this.#relationshipAdds.keys(),
+            ...this.#relationshipRemoves.keys(),
+        ]);
+        for (const source of relationshipSources) {
+            const adds = this.#relationshipAdds.get(source) ?? [];
+            const removes = this.#relationshipRemoves.get(source) ?? new Set();
+            if (adds.length === 0 && removes.size === 0)
+                continue;
+            const relsName = relationshipsPartOf(source);
+            const existing = await this.#relationships(source);
+            const fragments = adds.map((add) => `<Relationship Id=${escapeAttribute(add.id)} Type=${escapeAttribute(add.type)} Target=${escapeAttribute(add.target)}${add.mode === "External" ? ' TargetMode="External"' : ""}/>`);
+            if (existing.partName &&
+                this.#pkg.has(existing.partName) &&
+                !remove.has(existing.partName)) {
+                const part = await this.#pkg.xml(existing.partName, signal);
+                const items = [];
+                for (const id of removes) {
+                    const node = existing.byId(id)?.node;
+                    if (!node)
+                        throw new ViewerError("invalid-patch", `No relationship ${id} in ${existing.partName}`, {
+                            details: { part: existing.partName, id },
+                        });
+                    items.push(patches.removeElement(part, node));
+                }
+                // One patch per element: each must read back as one element.
+                for (const fragment of fragments)
+                    items.push(patches.appendChild(part, part.root, fragment));
+                const patched = applyPatches(part, items, next);
+                set.set(existing.partName, encodePart(patched.text));
+            }
+            else {
+                if (removes.size > 0)
+                    throw new ViewerError("invalid-patch", `No relationships part for ${source}`, { details: { part: relsName } });
+                set.set(relsName, encodePart(`${XML_HEADER}<Relationships xmlns="${RELATIONSHIPS_NAMESPACE}">${fragments.join("")}</Relationships>`));
+            }
+        }
+        // 5. Content types: Overrides for new parts with a type, Defaults for media, removals.
+        const types = await this.#contentTypes();
+        const typesPart = await this.#pkg.xml(CONTENT_TYPES, signal);
+        const typeItems = [];
+        const additions = [];
+        const seenDefaults = new Set();
+        for (const entry of this.#set.values()) {
+            if (!entry.contentType)
+                continue;
+            const extension = extensionOf(entry.name);
+            const isMedia = !/\.(xml|rels)$/i.test(entry.name) && extension !== "";
+            if (isMedia &&
+                !types.defaults.has(extension) &&
+                !seenDefaults.has(extension)) {
+                seenDefaults.add(extension);
+                additions.push(`<Default Extension=${escapeAttribute(extension)} ContentType=${escapeAttribute(entry.contentType)}/>`);
+            }
+            else if (!isMedia &&
+                types.defaults.get(extension) !== entry.contentType) {
+                const node = types.overrideNode(entry.name);
+                if (node)
+                    typeItems.push(patches.setAttribute(typesPart, node, "ContentType", entry.contentType));
+                else
+                    additions.push(`<Override PartName=${escapeAttribute(entry.name)} ContentType=${escapeAttribute(entry.contentType)}/>`);
+            }
+        }
+        for (const name of remove) {
+            const node = types.overrideNode(name);
+            if (node)
+                typeItems.push(patches.removeElement(typesPart, node));
+        }
+        for (const addition of additions)
+            typeItems.push(patches.appendChild(typesPart, typesPart.root, addition));
+        if (typeItems.length > 0) {
+            const patched = applyPatches(typesPart, typeItems, next);
+            set.set(CONTENT_TYPES, encodePart(patched.text));
+        }
+        // 6. Dangling relationship targets after the removals, as warnings.
+        const warnings = [];
+        if (remove.size > 0) {
+            const removedKeys = new Set([...remove].map(partKey));
+            for (const name of this.#pkg.currentPartNames) {
+                const source = sourceOfRelationshipsPart(name);
+                if (source === undefined || remove.has(name))
+                    continue;
+                const relsPart = set.has(name)
+                    ? scanXml(name, new TextDecoder().decode(set.get(name)), next)
+                    : await this.#pkg.xml(name, signal);
+                const rels = parseRelationships(source, name, relsPart);
+                for (const item of rels.items)
+                    if (item.targetPart && removedKeys.has(partKey(item.targetPart)))
+                        warnings.push({
+                            code: "fidelity-degraded",
+                            message: `Relationship ${item.id} of ${source} points at the removed part ${item.targetPart}`,
+                            details: {
+                                source,
+                                id: item.id,
+                                target: item.targetPart,
+                                reason: "dangling-relationship",
+                            },
+                        });
+            }
+        }
+        if (signal?.aborted)
+            throw new ViewerError("aborted", "The transaction was aborted");
+        const added = [...set.keys()].filter((name) => !this.#pkg.has(name));
+        const changed = [...set.keys()].filter((name) => this.#pkg.has(name));
+        this.#pkg.applyOverlay({ set, remove });
+        this.#committed = true;
+        return {
+            changedParts: changed,
+            addedParts: added,
+            removedParts: [...remove],
+            warnings,
+        };
+    }
+    #open() {
+        if (this.#committed)
+            throw new ViewerError("lifecycle-error", "The transaction was already committed");
+    }
+    #relationships(source) {
+        let pending = this.#relationshipSets.get(source);
+        if (!pending) {
+            pending = (async () => {
+                const relsName = relationshipsPartOf(source);
+                if (!this.#pkg.has(relsName) || this.#removed.has(partKey(relsName)))
+                    return parseRelationships(source, undefined, undefined);
+                return parseRelationships(source, relsName, await this.#pkg.xml(relsName));
+            })();
+            this.#relationshipSets.set(source, pending);
+        }
+        return pending;
+    }
+    async #contentTypes() {
+        return parseContentTypes(await this.#pkg.xml(CONTENT_TYPES));
+    }
+}
+/** "../media/image1.png" for a target seen from a source part. */
+export function relativeTarget(sourcePart, targetPart) {
+    if (sourcePart === "/")
+        return partNameOf(targetPart).slice(1);
+    const from = partNameOf(sourcePart).split("/").slice(1, -1);
+    const to = partNameOf(targetPart).split("/").slice(1);
+    let common = 0;
+    while (common < from.length &&
+        common < to.length - 1 &&
+        from[common].toLowerCase() === to[common].toLowerCase())
+        common += 1;
+    const up = from.length - common;
+    return [...Array.from({ length: up }, () => ".."), ...to.slice(common)].join("/");
+}
+async function sha256(bytes) {
+    const digest = await crypto.subtle.digest("SHA-256", bytes.slice());
+    return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+export { CONTENT_TYPES_NAMESPACE };

package/dist/edit/ooxml/worker.d.ts

@@ -0,0 +1,8 @@
+import type { WorkerLike } from "../../worker-client.js";
+import type { EditEngineContext } from "../engine.js";
+export interface OoxmlEditProviderOptions {
+    readonly workerUrl?: string | URL;
+    /** Test hook: supplies the worker instead of the packaged script. */
+    readonly createWorker?: () => WorkerLike;
+}
+export declare function createOoxmlEditWorker(options: OoxmlEditProviderOptions, context: EditEngineContext): WorkerLike;

package/dist/edit/ooxml/worker.js

@@ -0,0 +1,12 @@
+import { ViewerError } from "../../errors.js";
+import { packageRelativeUrl, resolveAssetUrl } from "../worker-engine.js";
+export function createOoxmlEditWorker(options, context) {
+    if (options.createWorker)
+        return options.createWorker();
+    if (typeof Worker === "undefined")
+        throw new ViewerError("edit-unsupported", `${context.format.toUpperCase()} editing requires a browser module Worker`, { details: { format: context.format, reason: "no-worker" } });
+    const url = resolveAssetUrl(options.workerUrl, context.assetBaseUrl, context.assetBaseUrl
+        ? new URL("workers/ooxml-edit-worker.js", context.assetBaseUrl)
+        : packageRelativeUrl("../../../workers/ooxml-edit-worker.js", import.meta.url));
+    return new Worker(url, { type: "module", name: "web-doc-ooxml-edit" });
+}

package/dist/edit/ooxml/writer.d.ts

@@ -0,0 +1,21 @@
+import { type ZipArchive } from "./zip.js";
+export interface PartChange {
+    /** Absolute part name. */
+    readonly name: string;
+    readonly bytes: Uint8Array;
+}
+export interface WriteOverlay {
+    /** Replaced parts by absolute name. */
+    readonly changed: ReadonlyMap<string, PartChange>;
+    /** New parts by absolute name, in insertion order. */
+    readonly added: ReadonlyMap<string, PartChange>;
+    /** Removed parts by absolute name. */
+    readonly removed: ReadonlySet<string>;
+}
+export interface WriteOptions {
+    /** How changed and new entries are written; stored keeps output identical across engines. */
+    readonly compression?: "store" | "deflate";
+    readonly signal?: AbortSignal;
+}
+/** The package bytes for the archive with the overlay applied. */
+export declare function writeZip(archive: ZipArchive, overlay: WriteOverlay, options?: WriteOptions): Promise<Uint8Array>;