web-doc 0.6.2 → 0.7.0

package/dist/edit/ooxml/names.js

@@ -0,0 +1,61 @@
+/*
+ * OPC part names (ECMA-376 Part 2 §9.1): absolute, "/"-separated, compared
+ * case-insensitively. ZIP entry names carry them without the leading slash.
+ */
+/** "/ppt/slides/slide1.xml" for a ZIP entry name or a loosely written name. */
+export function partNameOf(entryName) {
+    const name = entryName.replaceAll("\\", "/");
+    return name.startsWith("/") ? name : `/${name}`;
+}
+/** The ZIP entry name of a part: no leading slash. */
+export function entryNameOf(partName) {
+    return partNameOf(partName).slice(1);
+}
+/** The key two part names are compared by. */
+export function partKey(name) {
+    return partNameOf(name).toLowerCase();
+}
+/** Whether a ZIP entry is a directory marker rather than a part. */
+export function isDirectoryEntry(entryName) {
+    return entryName.endsWith("/");
+}
+/** "/ppt/slides/" for "/ppt/slides/slide1.xml"; "/" at the root. */
+export function folderOf(partName) {
+    const name = partNameOf(partName);
+    return name.slice(0, name.lastIndexOf("/") + 1);
+}
+/** The extension without the dot, lower-case; "" when there is none. */
+export function extensionOf(partName) {
+    const name = partNameOf(partName);
+    const slash = name.lastIndexOf("/");
+    const dot = name.lastIndexOf(".");
+    return dot > slash ? name.slice(dot + 1).toLowerCase() : "";
+}
+/** The relationships part of a part ("/" for the package): "/ppt/slides/_rels/slide1.xml.rels". */
+export function relationshipsPartOf(partName) {
+    if (partName === "/" || partName === "")
+        return "/_rels/.rels";
+    const name = partNameOf(partName);
+    const slash = name.lastIndexOf("/");
+    return `${name.slice(0, slash + 1)}_rels/${name.slice(slash + 1)}.rels`;
+}
+/**
+ * Resolves a relationship target against its source part: relative targets
+ * against the source's folder, absolute ones as they are; "." and ".."
+ * segments collapse. The result is an absolute part name.
+ */
+export function resolveTarget(sourcePart, target) {
+    const base = sourcePart === "/" || sourcePart === "" ? "/" : folderOf(sourcePart);
+    const raw = target.replaceAll("\\", "/");
+    const combined = raw.startsWith("/") ? raw : `${base}${raw}`;
+    const segments = [];
+    for (const segment of combined.split("/")) {
+        if (segment === "" || segment === ".")
+            continue;
+        if (segment === "..")
+            segments.pop();
+        else
+            segments.push(segment);
+    }
+    return `/${segments.join("/")}`;
+}

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

@@ -0,0 +1,50 @@
+import type { XmlElement, XmlPart } from "./xml.js";
+export declare const CONTENT_TYPES_NAMESPACE = "http://schemas.openxmlformats.org/package/2006/content-types";
+export declare const RELATIONSHIPS_NAMESPACE = "http://schemas.openxmlformats.org/package/2006/relationships";
+export declare const RELATIONSHIPS_CONTENT_TYPE = "application/vnd.openxmlformats-package.relationships+xml";
+export declare const IMAGE_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image";
+export interface Relationship {
+    readonly id: string;
+    readonly type: string;
+    /** As written. */
+    readonly target: string;
+    readonly targetMode: "Internal" | "External";
+    /** Absolute part name for internal targets. */
+    readonly targetPart?: string;
+    /** The element in the scanned .rels part, for patches. */
+    readonly node?: XmlElement;
+}
+export declare class RelationshipSet {
+    #private;
+    /** "/" for the package. */
+    readonly sourcePart: string;
+    /** The .rels part, when it exists. */
+    readonly partName: string | undefined;
+    readonly items: readonly Relationship[];
+    constructor(
+    /** "/" for the package. */
+    sourcePart: string, 
+    /** The .rels part, when it exists. */
+    partName: string | undefined, items: readonly Relationship[]);
+    byId(id: string): Relationship | undefined;
+    byType(type: string): readonly Relationship[];
+    /** The first free "rId<n>", counting from 1 and skipping `taken`. */
+    nextId(taken?: ReadonlySet<string>): string;
+}
+/** Reads a relationships part; `part` undefined means the source has none yet. */
+export declare function parseRelationships(sourcePart: string, partName: string | undefined, part: XmlPart | undefined): RelationshipSet;
+export interface ContentTypes {
+    /** Lower-case extension → content type. */
+    readonly defaults: ReadonlyMap<string, string>;
+    /** Part-name key → content type. */
+    readonly overrides: ReadonlyMap<string, string>;
+    typeOf(partName: string): string | undefined;
+    /** The Override element of a part, for patches. */
+    overrideNode(partName: string): XmlElement | undefined;
+    defaultNode(extension: string): XmlElement | undefined;
+}
+export declare function parseContentTypes(part: XmlPart): ContentTypes;
+/** The file extension conventionally used for a media type. */
+export declare function extensionForMime(mimeType: string): string;
+/** The relationships part a .rels file belongs to, or undefined for other parts. */
+export declare function sourceOfRelationshipsPart(partName: string): string | undefined;

package/dist/edit/ooxml/opc.js

@@ -0,0 +1,150 @@
+import { extensionOf, partKey, partNameOf, resolveTarget } from "./names.js";
+/*
+ * The Open Packaging Conventions parts the layer understands as models:
+ * [Content_Types].xml (Default by extension, Override by part name) and
+ * relationship parts (ordered, with ids, types and resolved targets). Both
+ * are read from scanned parts and written back as patches by transactions,
+ * so untouched entries keep their bytes.
+ */
+export const CONTENT_TYPES_NAMESPACE = "http://schemas.openxmlformats.org/package/2006/content-types";
+export const RELATIONSHIPS_NAMESPACE = "http://schemas.openxmlformats.org/package/2006/relationships";
+export const RELATIONSHIPS_CONTENT_TYPE = "application/vnd.openxmlformats-package.relationships+xml";
+export const IMAGE_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image";
+export class RelationshipSet {
+    sourcePart;
+    partName;
+    items;
+    #byId = new Map();
+    #byType = new Map();
+    constructor(
+    /** "/" for the package. */
+    sourcePart, 
+    /** The .rels part, when it exists. */
+    partName, items) {
+        this.sourcePart = sourcePart;
+        this.partName = partName;
+        this.items = items;
+        for (const item of items) {
+            this.#byId.set(item.id, item);
+            const list = this.#byType.get(item.type);
+            if (list)
+                list.push(item);
+            else
+                this.#byType.set(item.type, [item]);
+        }
+    }
+    byId(id) {
+        return this.#byId.get(id);
+    }
+    byType(type) {
+        return this.#byType.get(type) ?? [];
+    }
+    /** The first free "rId<n>", counting from 1 and skipping `taken`. */
+    nextId(taken = new Set()) {
+        for (let n = 1;; n += 1) {
+            const id = `rId${n}`;
+            if (!this.#byId.has(id) && !taken.has(id))
+                return id;
+        }
+    }
+}
+/** Reads a relationships part; `part` undefined means the source has none yet. */
+export function parseRelationships(sourcePart, partName, part) {
+    if (!part)
+        return new RelationshipSet(sourcePart, partName, []);
+    const items = [];
+    for (const node of part.root.children) {
+        if (node.local !== "Relationship")
+            continue;
+        const id = part.attribute(node, "Id");
+        const type = part.attribute(node, "Type");
+        const target = part.attribute(node, "Target");
+        if (id === undefined || type === undefined || target === undefined)
+            continue;
+        const external = part.attribute(node, "TargetMode") === "External";
+        items.push({
+            id,
+            type,
+            target,
+            targetMode: external ? "External" : "Internal",
+            ...(external ? {} : { targetPart: resolveTarget(sourcePart, target) }),
+            node,
+        });
+    }
+    return new RelationshipSet(sourcePart, partName, items);
+}
+export function parseContentTypes(part) {
+    const defaults = new Map();
+    const overrides = new Map();
+    const defaultNodes = new Map();
+    const overrideNodes = new Map();
+    for (const node of part.root.children) {
+        const contentType = part.attribute(node, "ContentType");
+        if (contentType === undefined)
+            continue;
+        if (node.local === "Default") {
+            const extension = part.attribute(node, "Extension")?.toLowerCase();
+            if (extension === undefined)
+                continue;
+            defaults.set(extension, contentType);
+            defaultNodes.set(extension, node);
+        }
+        else if (node.local === "Override") {
+            const name = part.attribute(node, "PartName");
+            if (name === undefined)
+                continue;
+            overrides.set(partKey(name), contentType);
+            overrideNodes.set(partKey(name), node);
+        }
+    }
+    return {
+        defaults,
+        overrides,
+        typeOf(partName) {
+            return (overrides.get(partKey(partName)) ?? defaults.get(extensionOf(partName)));
+        },
+        overrideNode(partName) {
+            return overrideNodes.get(partKey(partName));
+        },
+        defaultNode(extension) {
+            return defaultNodes.get(extension.toLowerCase());
+        },
+    };
+}
+/** The file extension conventionally used for a media type. */
+export function extensionForMime(mimeType) {
+    switch (mimeType.toLowerCase()) {
+        case "image/png":
+            return "png";
+        case "image/jpeg":
+        case "image/jpg":
+            return "jpeg";
+        case "image/gif":
+            return "gif";
+        case "image/bmp":
+            return "bmp";
+        case "image/tiff":
+            return "tiff";
+        case "image/svg+xml":
+            return "svg";
+        case "image/x-emf":
+        case "image/emf":
+            return "emf";
+        case "image/x-wmf":
+        case "image/wmf":
+            return "wmf";
+        default:
+            return "bin";
+    }
+}
+/** The relationships part a .rels file belongs to, or undefined for other parts. */
+export function sourceOfRelationshipsPart(partName) {
+    const name = partNameOf(partName);
+    const match = /^(.*\/)_rels\/([^/]*)\.rels$/.exec(name);
+    if (!match)
+        return undefined;
+    const [, folder, base] = match;
+    if (folder === "/" && base === "")
+        return "/";
+    return `${folder}${base}`;
+}

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

@@ -0,0 +1,82 @@
+import type { ResourceLimits } from "../../contracts.js";
+import { type XmlPart } from "./xml.js";
+import { type ContentTypes, type RelationshipSet } from "./opc.js";
+import { PackageTransaction } from "./transaction.js";
+import { type ZipArchive, type ZipEntry } from "./zip.js";
+export interface SaveOptions {
+    /** How changed and new entries are written; default "store". */
+    readonly compression?: "store" | "deflate";
+}
+/** The overlay at a point in time; opaque to callers, O(1) to take and restore. */
+export interface PackageSnapshot {
+    readonly revision: number;
+}
+export interface OpenOptions {
+    readonly limits: ResourceLimits;
+    readonly signal?: AbortSignal;
+}
+export declare const CONTENT_TYPES_PART = "/[Content_Types].xml";
+export declare class OoxmlPackage {
+    #private;
+    /** The original bytes, never mutated. */
+    readonly original: Uint8Array;
+    /** Absolute part names in archive order; directory markers are left out. */
+    readonly partNames: readonly string[];
+    private constructor();
+    /** Parses the central directory; parts are inflated on first use. */
+    static open(bytes: Uint8Array, options: OpenOptions): Promise<OoxmlPackage>;
+    /** The archive behind the package, for the writer. */
+    get archive(): ZipArchive;
+    get limits(): ResourceLimits;
+    /** Whether a part exists in the current state, overlay included. */
+    has(name: string): boolean;
+    /** Part names in the current state: archive order, then additions. */
+    get currentPartNames(): readonly string[];
+    /** Names of the parts that differ from the original: changed, added and removed. */
+    get changedParts(): readonly string[];
+    get revision(): number;
+    /** From [Content_Types].xml: an Override, else the Default for the extension. */
+    contentTypeOf(name: string): Promise<string | undefined>;
+    /** The content-type model of the current state. */
+    contentTypes(): Promise<ContentTypes>;
+    /** The relationships of a part, or of the package for "/". */
+    relationships(name: string, signal?: AbortSignal): Promise<RelationshipSet>;
+    /** Resolves a relationship target against its source part to an absolute name. */
+    resolve(sourcePart: string, target: string): string;
+    transaction(): PackageTransaction;
+    /** The ZIP entry behind a part. */
+    entry(name: string): ZipEntry | undefined;
+    /** The current bytes of a part: the overlay's when changed, else the original's. */
+    part(name: string, signal?: AbortSignal): Promise<Uint8Array>;
+    /**
+     * A part decoded and scanned, cached until the part changes. A part that
+     * is not UTF-8 is `unsupported-part`; one that does not parse is
+     * `malformed-xml`.
+     */
+    xml(name: string, signal?: AbortSignal): Promise<XmlPart>;
+    /** The original bytes of a part, inflated once and cached; ignores the overlay. */
+    originalPart(name: string, signal?: AbortSignal): Promise<Uint8Array>;
+    /**
+     * Replaces the overlay with one that has `changes` applied: replaced parts
+     * (existing names) and added parts (new names) in `set`, and `remove`.
+     * Used by transactions; the previous overlay stays reachable through its
+     * snapshot.
+     */
+    applyOverlay(changes: {
+        readonly set: ReadonlyMap<string, Uint8Array>;
+        readonly remove: ReadonlySet<string>;
+    }): PackageSnapshot;
+    /** The overlay as it is now, by reference; restore it later in O(1). */
+    snapshot(): PackageSnapshot;
+    /**
+     * Swaps the overlay back. Parts scanned after the snapshot describe a
+     * state that is gone (and a later commit could reach the same revision
+     * number with other content), so the scan cache is dropped. Other
+     * snapshots stay: a caller may restore a later one again.
+     */
+    restore(snapshot: PackageSnapshot): void;
+    /** Forgets a snapshot that will not be restored, so its overlay can be collected. */
+    release(snapshot: PackageSnapshot): void;
+    /** The package bytes: the original (copied) when nothing changed. */
+    save(options?: SaveOptions, signal?: AbortSignal): Promise<Uint8Array>;
+}

package/dist/edit/ooxml/package.js

@@ -0,0 +1,233 @@
+import { ViewerError } from "../../errors.js";
+import { isDirectoryEntry, partKey, partNameOf } from "./names.js";
+import { writeZip } from "./writer.js";
+import { decodePart, scanXml } from "./xml.js";
+import { parseContentTypes, parseRelationships, } from "./opc.js";
+import { PackageTransaction } from "./transaction.js";
+import { relationshipsPartOf, resolveTarget } from "./names.js";
+import { inflateEntry, parseZip, } from "./zip.js";
+export const CONTENT_TYPES_PART = "/[Content_Types].xml";
+export class OoxmlPackage {
+    /** The original bytes, never mutated. */
+    original;
+    /** Absolute part names in archive order; directory markers are left out. */
+    partNames;
+    #archive;
+    #limits;
+    #entries = new Map();
+    #parts = new Map();
+    #overlay = {
+        revision: 0,
+        changed: new Map(),
+        added: new Map(),
+        removed: new Set(),
+    };
+    #snapshots = new Map();
+    /** Scanned parts by key, valid for the overlay revision they were scanned at. */
+    #xml = new Map();
+    constructor(archive, limits) {
+        this.original = archive.bytes;
+        this.#archive = archive;
+        this.#limits = limits;
+        const names = [];
+        for (const entry of archive.entries) {
+            if (isDirectoryEntry(entry.name))
+                continue;
+            const name = partNameOf(entry.name);
+            const key = partKey(name);
+            if (this.#entries.has(key))
+                throw new ViewerError("invalid-file", `Duplicate package part ${name}`);
+            this.#entries.set(key, entry);
+            names.push(name);
+        }
+        this.partNames = Object.freeze(names);
+        if (!this.has(CONTENT_TYPES_PART))
+            throw new ViewerError("invalid-file", "The package has no [Content_Types].xml");
+    }
+    /** Parses the central directory; parts are inflated on first use. */
+    static async open(bytes, options) {
+        if (options.signal?.aborted)
+            throw new ViewerError("aborted", "Opening the package was aborted");
+        return new OoxmlPackage(parseZip(bytes, options.limits), options.limits);
+    }
+    /** The archive behind the package, for the writer. */
+    get archive() {
+        return this.#archive;
+    }
+    get limits() {
+        return this.#limits;
+    }
+    /** Whether a part exists in the current state, overlay included. */
+    has(name) {
+        const key = partKey(name);
+        if (this.#overlay.removed.has(key))
+            return false;
+        return this.#entries.has(key) || this.#overlay.added.has(key);
+    }
+    /** Part names in the current state: archive order, then additions. */
+    get currentPartNames() {
+        const names = this.partNames.filter((name) => this.has(name));
+        for (const [, change] of this.#overlay.added)
+            names.push(change.name);
+        return names;
+    }
+    /** Names of the parts that differ from the original: changed, added and removed. */
+    get changedParts() {
+        return [
+            ...[...this.#overlay.changed.values()].map((change) => change.name),
+            ...[...this.#overlay.added.values()].map((change) => change.name),
+            ...[...this.#overlay.removed]
+                .map((key) => this.#entries.get(key)?.name ?? key)
+                .map(partNameOf),
+        ];
+    }
+    get revision() {
+        return this.#overlay.revision;
+    }
+    /** From [Content_Types].xml: an Override, else the Default for the extension. */
+    async contentTypeOf(name) {
+        return (await this.contentTypes()).typeOf(name);
+    }
+    /** The content-type model of the current state. */
+    async contentTypes() {
+        return parseContentTypes(await this.xml(CONTENT_TYPES_PART));
+    }
+    /** The relationships of a part, or of the package for "/". */
+    async relationships(name, signal) {
+        const source = name === "/" || name === "" ? "/" : partNameOf(name);
+        const relsName = relationshipsPartOf(source);
+        if (!this.has(relsName))
+            return parseRelationships(source, undefined, undefined);
+        return parseRelationships(source, relsName, await this.xml(relsName, signal));
+    }
+    /** Resolves a relationship target against its source part to an absolute name. */
+    resolve(sourcePart, target) {
+        return resolveTarget(sourcePart, target);
+    }
+    transaction() {
+        return new PackageTransaction(this);
+    }
+    /** The ZIP entry behind a part. */
+    entry(name) {
+        return this.#entries.get(partKey(name));
+    }
+    /** The current bytes of a part: the overlay's when changed, else the original's. */
+    part(name, signal) {
+        const key = partKey(name);
+        if (this.#overlay.removed.has(key))
+            return Promise.reject(this.#missing(name));
+        const change = this.#overlay.changed.get(key) ?? this.#overlay.added.get(key);
+        if (change)
+            return Promise.resolve(change.bytes.slice());
+        return this.originalPart(name, signal);
+    }
+    /**
+     * A part decoded and scanned, cached until the part changes. A part that
+     * is not UTF-8 is `unsupported-part`; one that does not parse is
+     * `malformed-xml`.
+     */
+    xml(name, signal) {
+        const key = partKey(name);
+        const revision = this.#overlay.revision;
+        const cached = this.#xml.get(key);
+        if (cached)
+            return cached.then((part) => part.revision === revision
+                ? part
+                : this.#rescan(name, key, revision, signal));
+        return this.#rescan(name, key, revision, signal);
+    }
+    #rescan(name, key, revision, signal) {
+        const pending = this.part(name, signal).then((bytes) => {
+            const partName = partNameOf(name);
+            const { text } = decodePart(partName, bytes);
+            return scanXml(partName, text, revision);
+        });
+        this.#xml.set(key, pending);
+        pending.catch(() => this.#xml.delete(key));
+        return pending;
+    }
+    /** The original bytes of a part, inflated once and cached; ignores the overlay. */
+    originalPart(name, signal) {
+        const key = partKey(name);
+        const entry = this.#entries.get(key);
+        if (!entry)
+            return Promise.reject(this.#missing(name));
+        let pending = this.#parts.get(key);
+        if (!pending) {
+            pending = inflateEntry(this.#archive, entry, this.#limits, signal);
+            this.#parts.set(key, pending);
+            pending.catch(() => this.#parts.delete(key));
+        }
+        return pending.then((bytes) => bytes.slice());
+    }
+    /**
+     * Replaces the overlay with one that has `changes` applied: replaced parts
+     * (existing names) and added parts (new names) in `set`, and `remove`.
+     * Used by transactions; the previous overlay stays reachable through its
+     * snapshot.
+     */
+    applyOverlay(changes) {
+        const changed = new Map(this.#overlay.changed);
+        const added = new Map(this.#overlay.added);
+        const removed = new Set(this.#overlay.removed);
+        for (const name of changes.remove) {
+            const key = partKey(name);
+            changed.delete(key);
+            added.delete(key);
+            if (this.#entries.has(key))
+                removed.add(key);
+        }
+        for (const [name, bytes] of changes.set) {
+            const key = partKey(name);
+            removed.delete(key);
+            const change = { name: partNameOf(name), bytes: bytes.slice() };
+            if (this.#entries.has(key))
+                changed.set(key, change);
+            else
+                added.set(key, change);
+        }
+        const revision = this.#overlay.revision + 1;
+        this.#overlay = Object.freeze({ revision, changed, added, removed });
+        return { revision };
+    }
+    /** The overlay as it is now, by reference; restore it later in O(1). */
+    snapshot() {
+        this.#snapshots.set(this.#overlay.revision, this.#overlay);
+        return { revision: this.#overlay.revision };
+    }
+    /**
+     * Swaps the overlay back. Parts scanned after the snapshot describe a
+     * state that is gone (and a later commit could reach the same revision
+     * number with other content), so the scan cache is dropped. Other
+     * snapshots stay: a caller may restore a later one again.
+     */
+    restore(snapshot) {
+        const overlay = this.#snapshots.get(snapshot.revision);
+        if (!overlay)
+            throw new ViewerError("lifecycle-error", "Unknown package snapshot", {
+                details: { revision: snapshot.revision },
+            });
+        this.#overlay = overlay;
+        this.#xml.clear();
+    }
+    /** Forgets a snapshot that will not be restored, so its overlay can be collected. */
+    release(snapshot) {
+        if (this.#overlay.revision !== snapshot.revision)
+            this.#snapshots.delete(snapshot.revision);
+    }
+    /** The package bytes: the original (copied) when nothing changed. */
+    async save(options = {}, signal) {
+        const { changed, added, removed } = this.#overlay;
+        if (changed.size === 0 && added.size === 0 && removed.size === 0)
+            return this.original.slice();
+        return writeZip(this.#archive, this.#overlay, {
+            ...(options.compression ? { compression: options.compression } : {}),
+            ...(signal ? { signal } : {}),
+        });
+    }
+    #missing(name) {
+        return new ViewerError("invalid-file", `No part ${partNameOf(name)}`, {
+            details: { part: partNameOf(name) },
+        });
+    }
+}

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

@@ -0,0 +1,51 @@
+import { escapeAttribute, escapeText, type XmlElement, type XmlPart } from "./xml.js";
+export type PatchExpectation = {
+    readonly kind: "element";
+}
+/** The element starting at `at` (in the unpatched text) has this content afterwards. */
+ | {
+    readonly kind: "content";
+    readonly at: number;
+} | {
+    readonly kind: "attribute";
+    readonly at: number;
+    readonly name: string;
+    readonly value: string | undefined;
+} | {
+    readonly kind: "removed";
+    /** Where the parent starts, how many element children it has without the element, and the element's own text. */
+    readonly parentAt: number;
+    readonly count: number;
+    readonly xml: string;
+} | {
+    readonly kind: "none";
+};
+export interface XmlPatch {
+    /** Half-open range in the part's text; patches of one part must not overlap. */
+    readonly start: number;
+    readonly end: number;
+    readonly text: string;
+    readonly expect: PatchExpectation;
+}
+export declare const patches: {
+    /** Replaces the content between the tags; a self-closing element is opened. */
+    replaceContent(part: XmlPart, node: XmlElement, xml: string): XmlPatch;
+    /** Replaces the whole element with one element. */
+    replaceElement(part: XmlPart, node: XmlElement, xml: string): XmlPatch;
+    /** Removes the element and nothing around it. */
+    removeElement(part: XmlPart, node: XmlElement): XmlPatch;
+    insertBefore(part: XmlPart, node: XmlElement, xml: string): XmlPatch;
+    insertAfter(part: XmlPart, node: XmlElement, xml: string): XmlPatch;
+    /** Appends one element at the end of the content; a self-closing element is opened. */
+    appendChild(part: XmlPart, node: XmlElement, xml: string): XmlPatch;
+    setAttribute(part: XmlPart, node: XmlElement, name: string, value: string): XmlPatch;
+    removeAttribute(part: XmlPart, node: XmlElement, name: string): XmlPatch;
+    text: typeof escapeText;
+    attr: typeof escapeAttribute;
+};
+/**
+ * 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 declare function applyPatches(part: XmlPart, items: readonly XmlPatch[], revision: number): XmlPart;