web-doc 0.6.2 → 0.8.0

package/dist/edit/engine.d.ts

@@ -0,0 +1,128 @@
+import type { DocumentFormat, RegisteredFont, ResourceLimits, TextRun, ViewerWarning } from "../contracts.js";
+import type { EditSession } from "./sessions.js";
+import type { ChangeMode, 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> {
+    /** The host's limits, for reads a typed session builds over the core. */
+    readonly limits: ResourceLimits;
+    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[];
+}
+/** How a batch is written; travels with the batch to the engine and into the history, so a replay writes it the same way. */
+export interface BatchMode {
+    /** Default `direct`; `tracked` writes revisions where the format has them. */
+    readonly changeMode?: ChangeMode;
+    /** The author of tracked changes. */
+    readonly author?: string;
+    /** ISO 8601, the date of tracked changes. */
+    readonly timestamp?: string;
+}
+/** A batch with the identity the core assigned to the state after it. */
+export interface EngineBatch extends BatchMode {
+    /** 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, mode?: BatchMode): 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,77 @@
+import type { BatchMode, EngineBatch } from "./engine.js";
+import type { EditOperation } from "./types.js";
+export interface HistoryEntry extends BatchMode {
+    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;
+    /**
+     * A restore to a named checkpoint: the content after this entry is the
+     * checkpoint's, so a replay starts from its retained bytes or from the
+     * original plus `batches`, never from the entries before.
+     */
+    readonly base?: HistoryBase;
+}
+/** Where a restore entry's content comes from. */
+export interface HistoryBase {
+    /** The checkpoint's state id; its bytes may be retained under it. */
+    readonly stateId: number;
+    /** The batches that build the checkpoint's state from the original. */
+    readonly batches: readonly EngineBatch[];
+}
+/**
+ * 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[];
+    /** Every entry still in the history: folded ones, then the undoable ones and the redo tail. */
+    get allEntries(): readonly HistoryEntry[];
+    /** 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;
+    /**
+     * Appends an entry with a fresh state id, or with `stateId` when the entry
+     * reproduces a known state (a restore to a checkpoint): the same id means
+     * the same content, so `dirty` stays exact.
+     */
+    push(entry: Omit<HistoryEntry, "stateId">, stateId?: number): HistoryEntry;
+    undo(): void;
+    redo(): void;
+    clear(): void;
+}
+/** The engine batch an entry replays as: its operations and how they were written. */
+export declare function batchOf(entry: HistoryEntry): EngineBatch;
+/** The write mode fields of a batch or an entry, only those set. */
+export declare function modeOf(mode: BatchMode): BatchMode;

package/dist/edit/history.js

@@ -0,0 +1,123 @@
+/**
+ * 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.allEntries.map((entry) => entry.stateId);
+    }
+    /** Every entry still in the history: folded ones, then the undoable ones and the redo tail. */
+    get allEntries() {
+        return [...this.#folded, ...this.#entries];
+    }
+    /** 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(batchOf);
+    }
+    /** 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;
+    }
+    /**
+     * Appends an entry with a fresh state id, or with `stateId` when the entry
+     * reproduces a known state (a restore to a checkpoint): the same id means
+     * the same content, so `dirty` stays exact.
+     */
+    push(entry, stateId) {
+        const stored = Object.freeze({
+            ...entry,
+            stateId: 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;
+    }
+}
+/** The engine batch an entry replays as: its operations and how they were written. */
+export function batchOf(entry) {
+    return {
+        stateId: entry.stateId,
+        operations: entry.operations,
+        ...modeOf(entry),
+    };
+}
+/** The write mode fields of a batch or an entry, only those set. */
+export function modeOf(mode) {
+    return {
+        ...(mode.changeMode === undefined ? {} : { changeMode: mode.changeMode }),
+        ...(mode.author === undefined ? {} : { author: mode.author }),
+        ...(mode.timestamp === undefined ? {} : { timestamp: mode.timestamp }),
+    };
+}

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;

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}`;
+}