web-doc 0.6.2 → 0.7.0

package/dist/edit/docx/write.js

@@ -0,0 +1,352 @@
+import { patches } from "../ooxml/patch.js";
+import { escapeText } from "../ooxml/xml.js";
+import { W14_NS, W_NS } from "./ids.js";
+import { isThemeColorName } from "./style.js";
+import { LINE_BREAK, PAGE_BREAK, TAB } from "./text.js";
+/*
+ * Writing WordprocessingML: runs re-serialized from text and their
+ * properties, run and paragraph properties changed in schema order with
+ * every other child kept as its bytes, paragraph start tags carrying their
+ * `w14:paraId`, and the namespace declarations that attribute needs.
+ */
+const MC_NS = "http://schemas.openxmlformats.org/markup-compatibility/2006";
+/** Children of `w:rPr` in schema order (CT_RPr). */
+const RPR_ORDER = [
+    "rStyle",
+    "rFonts",
+    "b",
+    "bCs",
+    "i",
+    "iCs",
+    "caps",
+    "smallCaps",
+    "strike",
+    "dstrike",
+    "outline",
+    "shadow",
+    "emboss",
+    "imprint",
+    "noProof",
+    "snapToGrid",
+    "vanish",
+    "webHidden",
+    "color",
+    "spacing",
+    "w",
+    "kern",
+    "position",
+    "sz",
+    "szCs",
+    "highlight",
+    "u",
+    "effect",
+    "bdr",
+    "shd",
+    "fitText",
+    "vertAlign",
+    "rtl",
+    "cs",
+    "em",
+    "lang",
+    "eastAsianLayout",
+    "specVanish",
+    "oMath",
+    "rPrChange",
+];
+/** Children of `w:pPr` in schema order (CT_PPr). */
+const PPR_ORDER = [
+    "pStyle",
+    "keepNext",
+    "keepLines",
+    "pageBreakBefore",
+    "framePr",
+    "widowControl",
+    "numPr",
+    "suppressLineNumbers",
+    "pBdr",
+    "shd",
+    "tabs",
+    "suppressAutoHyphens",
+    "kinsoku",
+    "wordWrap",
+    "overflowPunct",
+    "topLinePunct",
+    "autoSpaceDE",
+    "autoSpaceDN",
+    "bidi",
+    "adjustRightInd",
+    "snapToGrid",
+    "spacing",
+    "ind",
+    "contextualSpacing",
+    "mirrorIndents",
+    "suppressOverlap",
+    "jc",
+    "textDirection",
+    "textAlignment",
+    "textboxTightWrap",
+    "outlineLvl",
+    "divId",
+    "cnfStyle",
+    "rPr",
+    "sectPr",
+    "pPrChange",
+];
+const FORBIDDEN = /[\u0000-\u0008\u000e-\u001f￾￿]/;
+const LONE_SURROGATE = /[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/;
+/** Why a text cannot be written, or undefined when it can. */
+export function textProblem(text) {
+    if (FORBIDDEN.test(text))
+        return "control characters XML cannot carry";
+    if (LONE_SURROGATE.test(text))
+        return "a lone surrogate";
+    return undefined;
+}
+/** Why a value cannot be written as an attribute: text problems plus the breaks text may hold. */
+export function attributeProblem(value) {
+    if (/[\u000b\u000c]/.test(value))
+        return "line or page breaks an attribute cannot carry";
+    return textProblem(value);
+}
+export function colorProblem(color) {
+    if (typeof color === "string")
+        return color === "auto" || /^#[0-9A-Fa-f]{6}$/.test(color)
+            ? undefined
+            : "not #RRGGBB or auto";
+    if (!color || typeof color !== "object")
+        return "not a colour";
+    const { theme } = color;
+    return typeof theme === "string" && isThemeColorName(theme)
+        ? undefined
+        : "not a theme colour name";
+}
+/** Text as the engine stores it: Windows and classic Mac line ends become "\n". */
+export function normalizeText(text) {
+    return text.replaceAll("\r\n", "\n").replaceAll("\r", "\n");
+}
+export function sliceOf(part, node) {
+    return node ? part.text.slice(node.start, node.end) : "";
+}
+export function escapeAttributeValue(value) {
+    return value
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("\t", "&#9;")
+        .replaceAll("\n", "&#10;")
+        .replaceAll("\r", "&#13;");
+}
+/** The content elements of a run for `text`: `w:t`, `w:tab`, `w:br`. */
+export function runContentXml(text) {
+    let out = "";
+    let pending = "";
+    const flush = () => {
+        if (pending.length === 0)
+            return;
+        const preserve = /^\s|\s$/.test(pending) ? ' xml:space="preserve"' : "";
+        out += `<w:t${preserve}>${escapeText(pending)}</w:t>`;
+        pending = "";
+    };
+    for (const char of text) {
+        if (char === TAB) {
+            flush();
+            out += "<w:tab/>";
+        }
+        else if (char === LINE_BREAK) {
+            flush();
+            out += "<w:br/>";
+        }
+        else if (char === PAGE_BREAK) {
+            flush();
+            out += '<w:br w:type="page"/>';
+        }
+        else
+            pending += char;
+    }
+    flush();
+    return out;
+}
+/** A run with `rPr` bytes (or "") and the given content; nothing for empty content. */
+export function runXml(rPr, content) {
+    return content.length === 0 ? "" : `<w:r>${rPr}${content}</w:r>`;
+}
+/**
+ * Properties with changes merged in schema order: every child of `source`
+ * keeps its bytes unless `set` names its local name, in which case the
+ * replacement (or nothing, for `null`) takes its place; new children go
+ * where the schema puts them. Returns "" for no properties at all.
+ */
+export function mergedProperties(part, source, tag, order, set) {
+    const children = source
+        ? source.children.map((child) => ({
+            local: child.local,
+            xml: sliceOf(part, child),
+        }))
+        : [];
+    for (const [local, xml] of set) {
+        const index = children.findIndex((child) => child.local === local);
+        for (let at = children.length - 1; at >= 0; at -= 1)
+            if (children[at].local === local)
+                children.splice(at, 1);
+        if (xml === null)
+            continue;
+        let at = index;
+        if (at < 0) {
+            // Before the first child the schema places later; a child the
+            // schema list does not name (an extension) counts as later too.
+            const rank = order.indexOf(local);
+            at = children.findIndex((child) => {
+                const other = order.indexOf(child.local);
+                return other < 0 || other > rank;
+            });
+            if (at < 0)
+                at = children.length;
+        }
+        children.splice(at, 0, { local, xml });
+    }
+    const attributes = source
+        ? source.attributes.map((a) => ` ${a.name}="${a.rawValue}"`).join("")
+        : "";
+    const content = children.map((child) => child.xml).join("");
+    if (!content)
+        return source ? `<${tag}${attributes}/>` : "";
+    return `<${tag}${attributes}>${content}</${tag}>`;
+}
+function toggleXml(local, on) {
+    return on ? `<w:${local}/>` : `<w:${local} w:val="0"/>`;
+}
+/** `w:rPr` bytes with a text style change applied. */
+export function changedRunProperties(part, rPr, change, styles) {
+    const set = new Map();
+    if (change.bold !== undefined) {
+        set.set("b", toggleXml("b", change.bold));
+        set.set("bCs", toggleXml("bCs", change.bold));
+    }
+    if (change.italic !== undefined) {
+        set.set("i", toggleXml("i", change.italic));
+        set.set("iCs", toggleXml("iCs", change.italic));
+    }
+    if (change.underline !== undefined)
+        set.set("u", `<w:u w:val="${change.underline ? "single" : "none"}"/>`);
+    if (change.fontSize !== undefined) {
+        const half = String(Math.round(change.fontSize * 2));
+        set.set("sz", `<w:sz w:val="${half}"/>`);
+        set.set("szCs", `<w:szCs w:val="${half}"/>`);
+    }
+    if (change.color !== undefined)
+        set.set("color", colorXml(change.color, styles));
+    if (change.highlight !== undefined)
+        set.set("highlight", change.highlight === "none"
+            ? null
+            : `<w:highlight w:val="${change.highlight}"/>`);
+    if (change.fontFamily !== undefined)
+        set.set("rFonts", fontsXml(part, rPr, change.fontFamily));
+    return mergedProperties(part, rPr, "w:rPr", RPR_ORDER, set);
+}
+/** `w:color` for a colour: RGB, automatic, or a theme name with the theme's value. */
+export function colorXml(color, styles) {
+    if (typeof color === "string") {
+        if (color === "auto")
+            return '<w:color w:val="auto"/>';
+        return `<w:color w:val="${color.slice(1).toUpperCase()}"/>`;
+    }
+    const value = styles.themeColor(color.theme) ?? "auto";
+    return `<w:color w:val="${value}" w:themeColor="${escapeAttributeValue(color.theme)}"/>`;
+}
+/** `w:rFonts` with the ASCII and high-ANSI faces set and their theme overrides dropped. */
+function fontsXml(part, rPr, family) {
+    const existing = rPr?.children.find((child) => child.local === "rFonts" && child.namespace === W_NS);
+    const kept = (existing?.attributes ?? []).filter((attribute) => !["w:ascii", "w:hAnsi", "w:asciiTheme", "w:hAnsiTheme"].includes(attribute.name));
+    const face = escapeAttributeValue(family);
+    const rest = kept.map((a) => ` ${a.name}="${a.rawValue}"`).join("");
+    return `<w:rFonts w:ascii="${face}" w:hAnsi="${face}"${rest}/>`;
+}
+/** `w:pPr` bytes with alignment and spacing changed, other children kept. */
+export function changedParagraphProperties(part, pPr, change) {
+    const set = new Map();
+    if (change.align !== undefined)
+        set.set("jc", `<w:jc w:val="${alignValue(change.align)}"/>`);
+    if (change.spacing !== undefined) {
+        const existing = pPr?.children.find((child) => child.local === "spacing" && child.namespace === W_NS);
+        const attributes = new Map();
+        for (const attribute of existing?.attributes ?? [])
+            attributes.set(attribute.name, attribute.rawValue);
+        // Word prefers the line-based and automatic forms over w:before and
+        // w:after, so a set value drops them.
+        if (change.spacing.before !== undefined) {
+            attributes.set("w:before", String(Math.round(change.spacing.before * 20)));
+            attributes.delete("w:beforeLines");
+            attributes.delete("w:beforeAutospacing");
+        }
+        if (change.spacing.after !== undefined) {
+            attributes.set("w:after", String(Math.round(change.spacing.after * 20)));
+            attributes.delete("w:afterLines");
+            attributes.delete("w:afterAutospacing");
+        }
+        if (change.spacing.line !== undefined) {
+            attributes.set("w:line", String(Math.round(change.spacing.line * 240)));
+            attributes.set("w:lineRule", "auto");
+        }
+        set.set("spacing", `<w:spacing${[...attributes].map(([name, raw]) => ` ${name}="${raw}"`).join("")}/>`);
+    }
+    return mergedProperties(part, pPr, "w:pPr", PPR_ORDER, set);
+}
+export function alignValue(align) {
+    switch (align) {
+        case "center":
+            return "center";
+        case "right":
+            return "right";
+        case "justify":
+            return "both";
+        default:
+            return "left";
+    }
+}
+/** `w:pPr` bytes with the paragraph mark's `w:rPr` changed (created when absent). */
+export function paragraphMarkProperties(part, pPr, change, styles) {
+    const rPr = pPr?.children.find((child) => child.local === "rPr" && child.namespace === W_NS);
+    const changed = changedRunProperties(part, rPr, change, styles);
+    return mergedProperties(part, pPr, "w:pPr", PPR_ORDER, new Map([["rPr", changed || null]]));
+}
+/** `w:pPr` bytes without the section properties, for a paragraph copied next to one that ends a section. */
+export function paragraphPropertiesWithoutSection(part, pPr) {
+    if (!pPr)
+        return "";
+    return mergedProperties(part, pPr, "w:pPr", PPR_ORDER, new Map([["sectPr", null]]));
+}
+/**
+ * The start tag of a `w:p` with its id written: the paragraph's own
+ * attributes, `w14:paraId` and `w14:textId` replaced.
+ */
+export function paragraphStartTag(source, id) {
+    const kept = (source?.attributes ?? []).filter((attribute) => attribute.name !== "w14:paraId" && attribute.name !== "w14:textId");
+    const rest = kept.map((a) => ` ${a.name}="${a.rawValue}"`).join("");
+    return `<w:p${rest} w14:paraId="${id}">`;
+}
+/** A whole paragraph from its start tag, property bytes and content. */
+export function paragraphXml(source, id, pPr, content) {
+    return `${paragraphStartTag(source, id)}${pPr}${content}</w:p>`;
+}
+/**
+ * Patches that declare the `w14` namespace on the document root and list
+ * it as ignorable, when the root does not yet; nothing when it does.
+ */
+export function namespacePatches(part) {
+    const root = part.root;
+    const items = [];
+    const has = (name) => root.attributes.find((attribute) => attribute.name === name)?.value;
+    if (has("xmlns:w14") === undefined)
+        items.push(patches.setAttribute(part, root, "xmlns:w14", W14_NS));
+    if (has("xmlns:mc") === undefined)
+        items.push(patches.setAttribute(part, root, "xmlns:mc", MC_NS));
+    const ignorable = has("mc:Ignorable");
+    const listed = ignorable ? ignorable.split(/\s+/).filter(Boolean) : [];
+    if (!listed.includes("w14"))
+        items.push(patches.setAttribute(part, root, "mc:Ignorable", [...listed, "w14"].join(" ")));
+    return items;
+}
+/** Whether the paragraph already carries a `w14:paraId`. */
+export function isAuthored(part, paragraph) {
+    return part.attribute(paragraph, "w14:paraId") !== undefined;
+}

package/dist/edit/engine.d.ts

@@ -0,0 +1,117 @@
+import type { DocumentFormat, RegisteredFont, ResourceLimits, TextRun, ViewerWarning } from "../contracts.js";
+import type { EditSession } from "./sessions.js";
+import type { EditableFormat, EditElement, EditFindOptions, EditOperation, EditSessionBase, ElementQuery, OperationIssue, OperationSchemaSet, PagePoint, ReadItem, ReadOptions, ReadResult, TextTarget } from "./types.js";
+export interface EditEngineContext {
+    readonly format: EditableFormat;
+    readonly fileName?: string;
+    readonly limits: ResourceLimits;
+    readonly assetBaseUrl?: URL;
+    /** Fonts the host registered with the client, for text the engine writes. */
+    readonly fonts?: readonly RegisteredFont[];
+    readonly signal: AbortSignal;
+}
+/**
+ * The format-independent session a provider wraps into its typed session.
+ * The read hooks let a typed session add engine reads that queue behind
+ * earlier calls and carry the same envelope as the core's own reads.
+ */
+export interface EditSessionCore extends EditSessionBase<EditOperation, EditElement> {
+    readItem<T>(options: ReadOptions | undefined, task: (engine: EditEngine, signal: AbortSignal) => Promise<T | undefined>): Promise<ReadItem<T>>;
+    readItems<T>(options: ReadOptions | undefined, task: (engine: EditEngine, signal: AbortSignal) => Promise<readonly T[]>): Promise<ReadResult<T>>;
+}
+/**
+ * What the viewer lends a typed session beyond the core: the text runs of
+ * the shown document, for formats whose engine never lays out (DOCX joins
+ * its elements with the renderer's runs on the main thread).
+ */
+export interface EditSessionAccess {
+    /** Text runs of a page of the shown document; computed on demand and cached by the viewer. */
+    getTextRuns(pageIndex: number, signal?: AbortSignal): Promise<readonly TextRun[]>;
+    /** Pages whose text runs are already known, in no particular order. */
+    cachedPages(): readonly number[];
+}
+/** Advertised by a `DocumentAdapter` that can edit some of its formats. */
+export interface EditEngineProvider {
+    /** Document formats the provider edits; variants map to a session format (pptm → pptx). */
+    readonly formats: readonly DocumentFormat[];
+    load(original: Uint8Array, context: EditEngineContext): Promise<EditEngine>;
+    /** Adds the format's typed methods on top of the core session. */
+    createSession(core: EditSessionCore, access: EditSessionAccess): EditSession;
+}
+/** Bytes of a state, with what the engine could not guarantee about them. */
+export interface MaterializedDocument {
+    readonly bytes: Uint8Array;
+    /** For example `privacy-not-guaranteed` when a PDF full save could not be compacted. */
+    readonly warnings: readonly ViewerWarning[];
+}
+/** A batch with the identity the core assigned to the state after it. */
+export interface EngineBatch {
+    /** Unique within the session and never reused; engines derive created ids from it. */
+    readonly stateId: number;
+    readonly operations: readonly EditOperation[];
+}
+/** Format-specific save fields, as the session's `save()` received them without the signal. */
+export type MaterializeOptions = Readonly<Record<string, unknown>>;
+/** What `restore` rebuilds: a base document (a checkpoint, else the original) plus batches. */
+export interface RestoreTarget {
+    readonly base?: Uint8Array;
+    readonly batches: readonly EngineBatch[];
+}
+export interface EngineChange {
+    readonly createdIds: readonly string[];
+    /** Ids that no longer exist after the batch, including every element of a deleted page. */
+    readonly removedIds: readonly string[];
+    /** Old id → new id, when the format had to rename an element. */
+    readonly remappedIds?: Readonly<Record<string, string>>;
+    /** A superset of the pages whose content changed. */
+    readonly changedPages: readonly number[];
+    /**
+     * Flow formats: the `paragraphId` of the text runs where the document
+     * reflows; the host turns it into every page from that paragraph's first
+     * page to the end, and `changedPages` is ignored.
+     */
+    readonly reflowFrom?: string;
+    /** Optional: the core takes the count from the renderer and only cross-checks this. */
+    readonly pageCount?: number;
+    readonly warnings: readonly ViewerWarning[];
+}
+/**
+ * A mutable working copy of one document. The core serializes every call, so
+ * an engine never sees two calls at once.
+ */
+export interface EditEngine {
+    readonly schemas: OperationSchemaSet;
+    /** Validates against the current state; an empty result means the batch can be applied. */
+    validate(operations: readonly EditOperation[], signal: AbortSignal): Promise<readonly OperationIssue[]>;
+    /**
+     * Applies an already validated batch to the working copy. Same-batch
+     * references (`"$<n>"` targets) are resolved here; one that resolves to an
+     * element the operation cannot act on rejects with `invalid-operation`.
+     */
+    apply(batch: EngineBatch, signal: AbortSignal): Promise<EngineChange>;
+    /**
+     * Bytes of the current state; the original bytes when nothing changed.
+     * `show` asks for what the viewer reopens, `save` for what the host keeps;
+     * formats read their own fields from `options` (the PDF save mode).
+     */
+    materialize(purpose: "show" | "save", options: MaterializeOptions, signal: AbortSignal): Promise<Uint8Array>;
+    /**
+     * `materialize` with what the bytes do not guarantee; an engine without it
+     * is taken to guarantee everything.
+     */
+    materializeDocument?(purpose: "show" | "save", options: MaterializeOptions, signal: AbortSignal): Promise<MaterializedDocument>;
+    /**
+     * Rebuilds a state: the base document (a checkpoint, else the original)
+     * with the batches applied in order. Used by undo, redo, reset, dry runs
+     * and recovery.
+     */
+    restore(target: RestoreTarget, signal: AbortSignal): Promise<void>;
+    /** Keeps asset bytes for the session; operations refer to them by id. */
+    putAsset(id: string, data: Uint8Array, signal: AbortSignal): Promise<void>;
+    getElements(query: ElementQuery, signal: AbortSignal): Promise<readonly EditElement[]>;
+    /** Direct lookup; without it the core scans `getElements`. */
+    getElement?(id: string, signal: AbortSignal): Promise<EditElement | undefined>;
+    elementsAt(pageIndex: number, point: PagePoint, signal: AbortSignal): Promise<readonly EditElement[]>;
+    findText(query: string, options: EditFindOptions, signal: AbortSignal): Promise<readonly TextTarget[]>;
+    dispose(): Promise<void>;
+}

package/dist/edit/engine.js

@@ -0,0 +1 @@
+export {};

package/dist/edit/history.d.ts

@@ -0,0 +1,53 @@
+import type { EngineBatch } from "./engine.js";
+import type { EditOperation } from "./types.js";
+export interface HistoryEntry {
+    readonly operations: readonly EditOperation[];
+    readonly label?: string;
+    /** Ids the batch created; an undo removes them again. */
+    readonly createdIds: readonly string[];
+    /** Ids the batch removed; a redo removes them again. */
+    readonly removedIds: readonly string[];
+    /** Page indexes the batch changed, in the document after it. */
+    readonly changedPages: readonly number[];
+    /** Flow formats: the paragraph the document reflows from, for undo and redo. */
+    readonly reflowFrom?: string;
+    readonly pageCountBefore: number;
+    readonly pageCountAfter: number;
+    /** Identifies the content after this batch; equal ids mean equal content. */
+    readonly stateId: number;
+}
+/**
+ * Linear undo history over an immutable original. Entries beyond the limit are
+ * folded into the starting point: they stay applied but can no longer be
+ * undone. Every reachable content state has a numeric id, so "unchanged since
+ * the last save" is an id comparison.
+ */
+export declare class EditHistory {
+    #private;
+    constructor(limit: number, originalPageCount: number);
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    get isPristine(): boolean;
+    /** The id the next pushed entry will get; engines derive created ids from it. */
+    get nextStateId(): number;
+    /** Content id of the current state; 0 is the original document. */
+    get stateId(): number;
+    get pageCount(): number;
+    /** State ids of every entry still in the history, folded and redo tail included. */
+    get stateIds(): readonly number[];
+    /** The entry `undo()` would revert, if any. */
+    get undoEntry(): HistoryEntry | undefined;
+    /** The entry `redo()` would re-apply, if any. */
+    get redoEntry(): HistoryEntry | undefined;
+    /** Batches applied to the original in the current state. */
+    applied(): readonly EngineBatch[];
+    /** Batches applied to the original when `position` undoable entries are applied. */
+    batchesAt(position: number): readonly EngineBatch[];
+    /** Entries applied when `position` undoable entries are applied, folded ones first. */
+    entriesAt(position: number): readonly HistoryEntry[];
+    get position(): number;
+    push(entry: Omit<HistoryEntry, "stateId">): HistoryEntry;
+    undo(): void;
+    redo(): void;
+    clear(): void;
+}

package/dist/edit/history.js

@@ -0,0 +1,101 @@
+/**
+ * Linear undo history over an immutable original. Entries beyond the limit are
+ * folded into the starting point: they stay applied but can no longer be
+ * undone. Every reachable content state has a numeric id, so "unchanged since
+ * the last save" is an id comparison.
+ */
+export class EditHistory {
+    #limit;
+    #originalPageCount;
+    /** Folded batches, always applied before the undoable entries. */
+    #folded = [];
+    #entries = [];
+    #position = 0;
+    #nextStateId = 1;
+    constructor(limit, originalPageCount) {
+        this.#limit = limit;
+        this.#originalPageCount = originalPageCount;
+    }
+    get canUndo() {
+        return this.#position > 0;
+    }
+    get canRedo() {
+        return this.#position < this.#entries.length;
+    }
+    get isPristine() {
+        return this.#folded.length === 0 && this.#entries.length === 0;
+    }
+    /** The id the next pushed entry will get; engines derive created ids from it. */
+    get nextStateId() {
+        return this.#nextStateId;
+    }
+    /** Content id of the current state; 0 is the original document. */
+    get stateId() {
+        return this.#position > 0
+            ? this.#entries[this.#position - 1].stateId
+            : (this.#folded.at(-1)?.stateId ?? 0);
+    }
+    get pageCount() {
+        return this.#position > 0
+            ? this.#entries[this.#position - 1].pageCountAfter
+            : (this.#folded.at(-1)?.pageCountAfter ?? this.#originalPageCount);
+    }
+    /** State ids of every entry still in the history, folded and redo tail included. */
+    get stateIds() {
+        return [...this.#folded, ...this.#entries].map((entry) => entry.stateId);
+    }
+    /** The entry `undo()` would revert, if any. */
+    get undoEntry() {
+        return this.#position > 0 ? this.#entries[this.#position - 1] : undefined;
+    }
+    /** The entry `redo()` would re-apply, if any. */
+    get redoEntry() {
+        return this.#entries[this.#position];
+    }
+    /** Batches applied to the original in the current state. */
+    applied() {
+        return this.batchesAt(this.#position);
+    }
+    /** Batches applied to the original when `position` undoable entries are applied. */
+    batchesAt(position) {
+        return this.entriesAt(position).map((entry) => ({
+            stateId: entry.stateId,
+            operations: entry.operations,
+        }));
+    }
+    /** Entries applied when `position` undoable entries are applied, folded ones first. */
+    entriesAt(position) {
+        return [...this.#folded, ...this.#entries.slice(0, position)];
+    }
+    get position() {
+        return this.#position;
+    }
+    push(entry) {
+        const stored = Object.freeze({
+            ...entry,
+            stateId: this.#nextStateId++,
+        });
+        // A new change after an undo drops the redo tail.
+        this.#entries.length = this.#position;
+        this.#entries.push(stored);
+        this.#position = this.#entries.length;
+        while (this.#entries.length > this.#limit) {
+            this.#folded.push(this.#entries.shift());
+            this.#position -= 1;
+        }
+        return stored;
+    }
+    undo() {
+        if (this.canUndo)
+            this.#position -= 1;
+    }
+    redo() {
+        if (this.canRedo)
+            this.#position += 1;
+    }
+    clear() {
+        this.#folded = [];
+        this.#entries = [];
+        this.#position = 0;
+    }
+}

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

@@ -0,0 +1,20 @@
+/** "/ppt/slides/slide1.xml" for a ZIP entry name or a loosely written name. */
+export declare function partNameOf(entryName: string): string;
+/** The ZIP entry name of a part: no leading slash. */
+export declare function entryNameOf(partName: string): string;
+/** The key two part names are compared by. */
+export declare function partKey(name: string): string;
+/** Whether a ZIP entry is a directory marker rather than a part. */
+export declare function isDirectoryEntry(entryName: string): boolean;
+/** "/ppt/slides/" for "/ppt/slides/slide1.xml"; "/" at the root. */
+export declare function folderOf(partName: string): string;
+/** The extension without the dot, lower-case; "" when there is none. */
+export declare function extensionOf(partName: string): string;
+/** The relationships part of a part ("/" for the package): "/ppt/slides/_rels/slide1.xml.rels". */
+export declare function relationshipsPartOf(partName: string): string;
+/**
+ * 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 declare function resolveTarget(sourcePart: string, target: string): string;