@docx4j/core-ts 0.1.0

package/dist/opc/FlatOpcPartStore.mjs

@@ -0,0 +1,151 @@
+import { marshalNode } from '@docx4j/generated-objects-ts';
+import { ContentTypeManager } from './ContentTypeManager.mjs';
+import { ContentTypes, isXmlContentType } from './ContentTypes.mjs';
+import { CONTENT_TYPES_NAME } from './PartName.mjs';
+import { InvalidFormatException } from './exceptions.mjs';
+import { parseXml, serializeXml, childElements, encodeText, decodeXmlText, stripXmlDeclaration, base64Decode, base64Encode, XML_DECLARATION } from '../xml/dom.mjs';
+export const PKG_NS = 'http://schemas.microsoft.com/office/2006/xmlPackage';
+/**
+ * A flat OPC package (`pkg:package`, what Office JS `getOoxml()` returns) as a container
+ * (docx4j org.docx4j.openpackaging.io3.stores.FlatOpcPartStore is not a class there, but the
+ * same job is done by `FlatOpcXmlImporter`). The content types are carried per part, so
+ * `[Content_Types].xml` is synthesised. XML parts are serialised back to bytes on `load`; the
+ * document loaded from them is therefore not byte-identical to what Office would have zipped.
+ */
+export class FlatOpcPartStore {
+    /** From the `pkg:package` string. */
+    constructor(source) {
+        this.parts = new Map();
+        this.order = [];
+        this.cache = new Map();
+        if (typeof source === 'string')
+            this.readString(source);
+        else
+            this.readPackageElement(source);
+        this.order.unshift(CONTENT_TYPES_NAME);
+    }
+    readString(text) {
+        var _a;
+        const doc = parseXml(text);
+        const root = doc.documentElement;
+        if (root.namespaceURI !== PKG_NS || root.localName !== 'package') {
+            throw new InvalidFormatException(`Not a flat OPC package: root is ${root.nodeName}`);
+        }
+        for (const part of childElements(root)) {
+            if (part.namespaceURI !== PKG_NS || part.localName !== 'part')
+                continue;
+            const name = part.getAttributeNS(PKG_NS, 'name') || part.getAttribute('pkg:name');
+            const contentType = part.getAttributeNS(PKG_NS, 'contentType') || part.getAttribute('pkg:contentType');
+            if (!name || !contentType)
+                throw new InvalidFormatException('pkg:part without pkg:name or pkg:contentType');
+            const entry = { name: name.replace(/^\//, ''), contentType };
+            for (const child of childElements(part)) {
+                if (child.namespaceURI !== PKG_NS)
+                    continue;
+                if (child.localName === 'xmlData')
+                    entry.xml = childElements(child)[0];
+                else if (child.localName === 'binaryData')
+                    entry.binary = (_a = child.textContent) !== null && _a !== void 0 ? _a : '';
+            }
+            this.add(entry);
+        }
+    }
+    readPackageElement(pkg) {
+        var _a, _b, _c, _d;
+        for (const part of (_a = pkg.value.part) !== null && _a !== void 0 ? _a : []) {
+            const name = ((_b = part.name) !== null && _b !== void 0 ? _b : '').replace(/^\//, '');
+            const contentType = (_c = part.contentType) !== null && _c !== void 0 ? _c : '';
+            const entry = { name, contentType };
+            const any = (_d = part.xmlData) === null || _d === void 0 ? void 0 : _d.any;
+            if (any !== undefined && any !== null)
+                entry.xml = any;
+            if (part.binaryData !== undefined && part.binaryData !== null)
+                entry.binary = String(part.binaryData);
+            this.add(entry);
+        }
+    }
+    add(entry) {
+        this.parts.set(entry.name, entry);
+        this.order.push(entry.name);
+    }
+    /** The content type of a part as carried by the flat package. */
+    contentTypeOf(partName) {
+        var _a;
+        return (_a = this.parts.get(partName)) === null || _a === void 0 ? void 0 : _a.contentType;
+    }
+    partNames() {
+        return this.order;
+    }
+    has(partName) {
+        return partName === CONTENT_TYPES_NAME || this.parts.has(partName);
+    }
+    async load(partName) {
+        var _a;
+        if (partName === CONTENT_TYPES_NAME)
+            return ((_a = this.contentTypesXml) !== null && _a !== void 0 ? _a : (this.contentTypesXml = encodeText(this.buildContentTypes().toXml())));
+        const cached = this.cache.get(partName);
+        if (cached)
+            return cached;
+        const part = this.parts.get(partName);
+        if (!part)
+            throw new Error(`No part ${partName} in flat OPC package`);
+        let bytes;
+        if (part.binary !== undefined) {
+            bytes = base64Decode(part.binary);
+        }
+        else if (part.xml !== undefined) {
+            const el = isNode(part.xml) ? part.xml : await marshalNode(part.xml);
+            bytes = encodeText(XML_DECLARATION + serializeXml(el));
+        }
+        else {
+            bytes = new Uint8Array(0);
+        }
+        this.cache.set(partName, bytes);
+        return bytes;
+    }
+    buildContentTypes() {
+        const ctm = ContentTypeManager.createDefault();
+        for (const part of this.parts.values()) {
+            if (part.contentType === ContentTypes.RELATIONSHIPS_PART)
+                continue;
+            ctm.addContentType('/' + part.name, part.contentType);
+        }
+        return ctm;
+    }
+}
+function isNode(value) {
+    return typeof value === 'object' && value !== null && typeof value.nodeType === 'number';
+}
+/**
+ * Produces the `pkg:package` string for Office JS `insertOoxml()`. XML parts are embedded as
+ * XML (their declaration removed), everything else as base64 with the padding Word writes.
+ */
+export class FlatOpcPartSink {
+    constructor(options) {
+        this.parts = [];
+        this.progId = options === null || options === void 0 ? void 0 : options.progId;
+    }
+    put(partName, bytes, options) {
+        var _a;
+        const name = partName.startsWith('/') ? partName : '/' + partName;
+        if (name === '/' + CONTENT_TYPES_NAME)
+            return; // content types travel on each part
+        const contentType = (_a = options === null || options === void 0 ? void 0 : options.contentType) !== null && _a !== void 0 ? _a : (name.endsWith('.rels') ? ContentTypes.RELATIONSHIPS_PART : ContentTypes.OCTET_STREAM);
+        const xml = isXmlContentType(contentType) || name.endsWith('.xml') || name.endsWith('.rels');
+        if (xml) {
+            const text = stripXmlDeclaration(decodeXmlText(bytes));
+            this.parts.push(`<pkg:part pkg:name="${escapeAttr(name)}" pkg:contentType="${escapeAttr(contentType)}"><pkg:xmlData>${text}</pkg:xmlData></pkg:part>`);
+        }
+        else {
+            const b64 = base64Encode(bytes).replace(/.{76}/g, '$&\r\n');
+            this.parts.push(`<pkg:part pkg:name="${escapeAttr(name)}" pkg:contentType="${escapeAttr(contentType)}" pkg:compression="store"><pkg:binaryData>${b64}</pkg:binaryData></pkg:part>`);
+        }
+    }
+    async finish() {
+        const pi = this.progId ? `<?mso-application progid="${escapeAttr(this.progId)}"?>` : '';
+        return `<?xml version="1.0" standalone="yes"?>${pi}<pkg:package xmlns:pkg="${PKG_NS}">${this.parts.join('')}</pkg:package>`;
+    }
+}
+function escapeAttr(s) {
+    return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/"/g, '&quot;');
+}

package/dist/opc/Load.d.mts

@@ -0,0 +1,18 @@
+import type { PartStore } from './PartStore.mjs';
+import { type DomPreprocessor } from '../parts/XmlPart.mjs';
+import { PartRegistry } from '../parts/PartRegistry.mjs';
+import type { OpcPackage } from '../packages/OpcPackage.mjs';
+export interface LoadOptions {
+    /** Part classes by content type; defaults to docx4j's table. */
+    registry?: PartRegistry;
+    /** Resolve `mc:AlternateContent` before unmarshalling (default true, as docx4j and Word). */
+    mcePreprocess?: boolean;
+    /** Runs over every XML part's DOM before it is unmarshalled; set by the package from `mcePreprocess`. */
+    preprocessor?: DomPreprocessor;
+}
+/**
+ * Loads a package from a container (docx4j io3.Load3): content types, then the package
+ * relationships, then every part reachable through relationships, recursively. Parts are not
+ * unmarshalled. `createPackage` picks the package class from the main part's content type.
+ */
+export declare function loadPackage<P extends OpcPackage>(store: PartStore, createPackage: (mainPartContentType: string | undefined) => P, options?: LoadOptions): Promise<P>;

package/dist/opc/Load.mjs

@@ -0,0 +1,123 @@
+import { PartName, CONTENT_TYPES_NAME } from './PartName.mjs';
+import { ContentTypeManager } from './ContentTypeManager.mjs';
+import { Docx4JException, InvalidFormatException } from './exceptions.mjs';
+import { Namespaces } from '../parts/Namespaces.mjs';
+import { RelationshipsPart, isExternal } from '../parts/RelationshipsPart.mjs';
+import { XmlPart } from '../parts/XmlPart.mjs';
+import { CustomXmlDataStoragePart } from '../parts/DefaultXmlPart.mjs';
+import { CustomXmlDataStoragePropertiesPart, DS_NS } from '../parts/customXml/index.mjs';
+import { defaultPartRegistry } from '../parts/PartRegistry.mjs';
+import { decodeXmlText, parseXml } from '../xml/dom.mjs';
+/** Relationship types whose target is the main part (docx4j PackageRelsUtil.getNameOfMainPart). */
+const MAIN_PART_RELATIONSHIPS = [
+    Namespaces.DOCUMENT,
+    'http://schemas.microsoft.com/office/2006/relationships/graphicFrameDoc',
+    Namespaces.DRAWINGML_DIAGRAM_LAYOUT,
+    Namespaces.DOCUMENT_STRICT,
+];
+/**
+ * Loads a package from a container (docx4j io3.Load3): content types, then the package
+ * relationships, then every part reachable through relationships, recursively. Parts are not
+ * unmarshalled. `createPackage` picks the package class from the main part's content type.
+ */
+export async function loadPackage(store, createPackage, options = {}) {
+    var _a;
+    const registry = (_a = options.registry) !== null && _a !== void 0 ? _a : defaultPartRegistry;
+    if (!store.has(CONTENT_TYPES_NAME))
+        throw new InvalidFormatException(`${CONTENT_TYPES_NAME} is missing from this package`);
+    const ctm = ContentTypeManager.parse(decodeXmlText(await store.load(CONTENT_TYPES_NAME)));
+    const packageRels = RelationshipsPart.createPackageRels();
+    if (!store.has('_rels/.rels'))
+        throw new InvalidFormatException('_rels/.rels appears to be missing from this package');
+    packageRels.setBytes(await store.load('_rels/.rels'));
+    await packageRels.getContents();
+    const mainRel = packageRels.list.find((r) => MAIN_PART_RELATIONSHIPS.includes(r.type));
+    if (!mainRel)
+        throw new InvalidFormatException('No relationship of type officeDocument');
+    const mainPartName = PartName.resolve(PartName.ROOT, mainRel.target);
+    const pkg = createPackage(ctm.getContentType(mainPartName));
+    pkg.contentTypeManager = ctm;
+    pkg.sourcePartStore = store;
+    pkg.relationshipsPart = packageRels;
+    packageRels.sourceP = pkg;
+    packageRels.package = pkg;
+    const loader = new Loader(pkg, store, registry, options.preprocessor);
+    await loader.addPartsFromRelationships(pkg, packageRels);
+    await loader.registerCustomXmlDataStorageParts();
+    return pkg;
+}
+class Loader {
+    constructor(pkg, store, registry, preprocessor) {
+        this.pkg = pkg;
+        this.store = store;
+        this.registry = registry;
+        this.preprocessor = preprocessor;
+        this.handled = new Set();
+    }
+    async addPartsFromRelationships(source, rp) {
+        for (const r of rp.list) {
+            try {
+                await this.getPart(source, rp, r);
+            }
+            catch (e) {
+                if (e instanceof Docx4JException)
+                    throw e;
+                throw new Docx4JException(`Failed to add parts from relationships of ${rp.partName}`, { cause: e });
+            }
+        }
+    }
+    async getPart(source, rp, r) {
+        if (r.type === Namespaces.HYPERLINK || isExternal(r))
+            return;
+        const partName = rp.resolveTarget(r);
+        const existing = this.handled.has(partName.key) ? this.pkg.getPart(partName) : undefined;
+        if (existing) {
+            // A part can be the target of several relationships (a header used by two sections, an image twice).
+            source.setPartShortcut(existing, r.type);
+            existing.sourceRelationships.push(r);
+            return;
+        }
+        const part = this.createPart(partName, r, rp);
+        source.setPartShortcut(part, r.type);
+        if (part.relationshipType === '')
+            part.relationshipType = r.type;
+        if (part instanceof XmlPart && this.preprocessor)
+            part.preprocessor = this.preprocessor;
+        rp.loadPart(part, r);
+        this.handled.add(partName.key);
+        const relsName = PartName.relsFor(partName).storeName;
+        if (this.store.has(relsName)) {
+            const rrp = new RelationshipsPart(part);
+            rrp.setBytes(await this.store.load(relsName));
+            await rrp.getContents();
+            part.relationshipsPart = rrp;
+            await this.addPartsFromRelationships(part, rrp);
+        }
+    }
+    createPart(partName, r, rp) {
+        const storeName = partName.storeName;
+        if (!this.store.has(storeName) && !this.store.has(decodeURIComponent(storeName))) {
+            throw new Docx4JException(`For source ${rp.sourceName}, cannot find part ${partName} from rel ${r.id}=${r.target}`);
+        }
+        return this.registry.createPart(partName, this.pkg.contentTypeManager.getContentType(partName), r);
+    }
+    /** Indexes custom XML parts by the itemID of their properties part (docx4j Load.registerCustomXmlDataStorageParts). */
+    async registerCustomXmlDataStorageParts() {
+        var _a, _b;
+        for (const part of this.pkg.parts) {
+            if (!(part instanceof CustomXmlDataStoragePart))
+                continue;
+            const rel = (_a = part.relationshipsPart) === null || _a === void 0 ? void 0 : _a.getRelationshipByType(Namespaces.CUSTOM_XML_DATA_STORAGE_PROPERTIES);
+            const props = rel ? (_b = part.relationshipsPart) === null || _b === void 0 ? void 0 : _b.getPart(rel) : undefined;
+            if (!(props instanceof CustomXmlDataStoragePropertiesPart))
+                continue;
+            // Read the itemID from the DOM rather than unmarshalling, so the properties part stays untouched.
+            const doc = parseXml(decodeXmlText(await props.getBytes()));
+            const itemId = doc.documentElement.getAttributeNS(DS_NS, 'itemID') || doc.documentElement.getAttribute('ds:itemID');
+            if (!itemId)
+                continue;
+            part.itemId = itemId.toLowerCase();
+            this.pkg.customXmlDataStorageParts.set(part.itemId, part);
+        }
+    }
+}

package/dist/opc/PartName.d.mts

@@ -0,0 +1,46 @@
+/**
+ * An OPC part name (docx4j org.docx4j.openpackaging.parts.PartName): a leading '/', no trailing
+ * '/', no empty segments, no segment ending in '.', percent-encoding allowed. Equality is
+ * case-insensitive, as Word writes mixed case (`[Content_Types].xml`, `_rels/.rels`).
+ */
+export declare class PartName {
+    /** The name as given, e.g. '/word/document.xml'. */
+    readonly name: string;
+    /** Lower-cased name, the key for maps. */
+    readonly key: string;
+    private constructor();
+    /** The package root, the source of the package relationships. Not a valid part name otherwise. */
+    static readonly ROOT: PartName;
+    /** Validates and wraps a part name; a leading '/' is added when missing. */
+    static of(name: string | PartName): PartName;
+    /** 'xml' for '/word/document.xml'; '' when there is no dot. */
+    get extension(): string;
+    /** '/word' for '/word/document.xml'; '/' for '/[Content_Types].xml'. */
+    get directory(): string;
+    /** 'document.xml' for '/word/document.xml'. */
+    get fileName(): string;
+    /** The name as stored in a container: without the leading '/'. */
+    get storeName(): string;
+    /** True for '/_rels/.rels' and '/word/_rels/document.xml.rels'. */
+    get isRelationshipsPart(): boolean;
+    equals(other: PartName | string | undefined): boolean;
+    toString(): string;
+    /** The relationships part name for a part: '/word/_rels/document.xml.rels'; for the root, '/_rels/.rels'. */
+    static relsFor(source: PartName | string): PartName;
+    /** The inverse of relsFor: '/word/document.xml' for '/word/_rels/document.xml.rels'; ROOT for '/_rels/.rels'. */
+    static sourceOfRels(rels: PartName | string): PartName;
+    /**
+     * Resolves a relationship target against its source part (docx4j URIHelper.resolvePartUri):
+     * relative to the source's directory, '.' and '..' collapsed; a target with a leading '/' is
+     * absolute. The source may be the package root.
+     */
+    static resolve(source: PartName | string, target: string): PartName;
+    /**
+     * The relationship target for a part from a source part (docx4j URIHelper.relativizeURI): from
+     * '/word/document.xml' to '/word/media/image1.png' is 'media/image1.png'; from the root it is
+     * the name without the leading '/'.
+     */
+    static relativize(source: PartName | string, target: PartName | string): string;
+}
+/** The container name of the content types stream; not a part, never in `parts`. */
+export declare const CONTENT_TYPES_NAME = "[Content_Types].xml";

package/dist/opc/PartName.mjs

@@ -0,0 +1,132 @@
+import { InvalidFormatException } from './exceptions.mjs';
+/**
+ * An OPC part name (docx4j org.docx4j.openpackaging.parts.PartName): a leading '/', no trailing
+ * '/', no empty segments, no segment ending in '.', percent-encoding allowed. Equality is
+ * case-insensitive, as Word writes mixed case (`[Content_Types].xml`, `_rels/.rels`).
+ */
+export class PartName {
+    constructor(name) {
+        this.name = name;
+        this.key = name.toLowerCase();
+    }
+    /** Validates and wraps a part name; a leading '/' is added when missing. */
+    static of(name) {
+        if (name instanceof PartName)
+            return name;
+        if (typeof name !== 'string' || name.length === 0)
+            throw new InvalidFormatException('A part name shall not be empty [M1.1]');
+        const full = name.startsWith('/') ? name : '/' + name;
+        if (full === '/')
+            throw new InvalidFormatException('A part name shall not be empty [M1.1]');
+        if (full.endsWith('/'))
+            throw new InvalidFormatException(`A part name shall not have a forward slash as the last character [M1.5]: ${full}`);
+        if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(name))
+            throw new InvalidFormatException(`Absolute URI forbidden: ${name}`);
+        for (const seg of full.substring(1).split('/')) {
+            if (seg.length === 0)
+                throw new InvalidFormatException(`A part name shall not have empty segments [M1.3]: ${full}`);
+            if (seg.endsWith('.'))
+                throw new InvalidFormatException(`A segment shall not end with a dot ('.') character [M1.9]: ${full}`);
+            if (/^\.+$/.test(seg))
+                throw new InvalidFormatException(`A segment shall include at least one non-dot character [M1.10]: ${full}`);
+            if (/[\\#?\s]/.test(seg))
+                throw new InvalidFormatException(`A segment shall not hold any characters other than pchar characters [M1.6]: ${full}`);
+            if (/%(?![0-9A-Fa-f]{2})/.test(seg))
+                throw new InvalidFormatException(`The segment ${seg} contains an invalid encoded character`);
+            if (/%2[fF]|%5[cC]/.test(seg))
+                throw new InvalidFormatException(`A segment shall not contain a percent-encoded forward or backward slash [M1.7]: ${full}`);
+        }
+        return new PartName(full);
+    }
+    /** 'xml' for '/word/document.xml'; '' when there is no dot. */
+    get extension() {
+        const last = this.name.substring(this.name.lastIndexOf('/') + 1);
+        const i = last.lastIndexOf('.');
+        return i > -1 ? last.substring(i + 1) : '';
+    }
+    /** '/word' for '/word/document.xml'; '/' for '/[Content_Types].xml'. */
+    get directory() {
+        const i = this.name.lastIndexOf('/');
+        return i === 0 ? '/' : this.name.substring(0, i);
+    }
+    /** 'document.xml' for '/word/document.xml'. */
+    get fileName() {
+        return this.name.substring(this.name.lastIndexOf('/') + 1);
+    }
+    /** The name as stored in a container: without the leading '/'. */
+    get storeName() {
+        return this.name.substring(1);
+    }
+    /** True for '/_rels/.rels' and '/word/_rels/document.xml.rels'. */
+    get isRelationshipsPart() {
+        return /\/_rels\/[^/]*\.rels$/.test(this.key);
+    }
+    equals(other) {
+        if (other === undefined)
+            return false;
+        return this.key === (typeof other === 'string' ? other.toLowerCase() : other.key);
+    }
+    toString() {
+        return this.name;
+    }
+    /** The relationships part name for a part: '/word/_rels/document.xml.rels'; for the root, '/_rels/.rels'. */
+    static relsFor(source) {
+        const s = typeof source === 'string' ? source : source.name;
+        if (s === '/')
+            return PACKAGE_RELS;
+        const pos = s.lastIndexOf('/');
+        return new PartName(s.substring(0, pos) + '/_rels' + s.substring(pos) + '.rels');
+    }
+    /** The inverse of relsFor: '/word/document.xml' for '/word/_rels/document.xml.rels'; ROOT for '/_rels/.rels'. */
+    static sourceOfRels(rels) {
+        const s = typeof rels === 'string' ? rels : rels.name;
+        const m = /^(.*)\/_rels\/([^/]*)\.rels$/.exec(s);
+        if (!m)
+            throw new InvalidFormatException(`Not a relationships part name: ${s}`);
+        if (m[1] === '' && m[2] === '')
+            return PartName.ROOT;
+        return new PartName(`${m[1]}/${m[2]}`);
+    }
+    /**
+     * Resolves a relationship target against its source part (docx4j URIHelper.resolvePartUri):
+     * relative to the source's directory, '.' and '..' collapsed; a target with a leading '/' is
+     * absolute. The source may be the package root.
+     */
+    static resolve(source, target) {
+        const s = typeof source === 'string' ? source : source.name;
+        const base = s === '/' ? '/' : s.substring(0, s.lastIndexOf('/') + 1);
+        const path = target.startsWith('/') ? target : base + target;
+        const out = [];
+        for (const seg of path.split('/')) {
+            if (seg === '' || seg === '.')
+                continue;
+            if (seg === '..')
+                out.pop();
+            else
+                out.push(seg);
+        }
+        return PartName.of('/' + out.join('/'));
+    }
+    /**
+     * The relationship target for a part from a source part (docx4j URIHelper.relativizeURI): from
+     * '/word/document.xml' to '/word/media/image1.png' is 'media/image1.png'; from the root it is
+     * the name without the leading '/'.
+     */
+    static relativize(source, target) {
+        const s = typeof source === 'string' ? source : source.name;
+        const t = typeof target === 'string' ? target : target.name;
+        if (s === '/')
+            return t.substring(1);
+        const from = s.substring(1, s.lastIndexOf('/') + 1).split('/').filter((x) => x !== '');
+        const to = t.substring(1).split('/');
+        let i = 0;
+        while (i < from.length && i < to.length - 1 && from[i] === to[i])
+            i++;
+        return '../'.repeat(from.length - i) + to.slice(i).join('/');
+    }
+}
+/** The package root, the source of the package relationships. Not a valid part name otherwise. */
+PartName.ROOT = new PartName('/');
+const PACKAGE_RELS = PartName.of('/_rels/.rels');
+/** The container name of the content types stream; not a part, never in `parts`. */
+export const CONTENT_TYPES_NAME = '[Content_Types].xml';

package/dist/opc/PartStore.d.mts

@@ -0,0 +1,45 @@
+/**
+ * Where a package's bytes come from (docx4j io3.stores.PartStore, the load half). Names are as
+ * stored, without the leading '/' (`word/document.xml`, `[Content_Types].xml`, `_rels/.rels`).
+ */
+export interface PartStore {
+    /** Names in container order. */
+    partNames(): Iterable<string>;
+    has(partName: string): boolean;
+    /** Raw bytes of a part. Implementations may inflate lazily on first access. */
+    load(partName: string): Promise<Uint8Array>;
+    /** Size if known without loading, else undefined. */
+    size?(partName: string): number | undefined;
+}
+export interface PutOptions {
+    /** Deflate in a zip (default true); ignored by containers that do not compress. */
+    compress?: boolean;
+    /** The part's content type, needed by containers that carry it per part (flat OPC). */
+    contentType?: string;
+}
+/** Where a package's bytes go (docx4j PartStore, the save half). `R` is what `finish` produces. */
+export interface PartSink<R = unknown> {
+    put(partName: string, bytes: Uint8Array, options?: PutOptions): void;
+    /** Completes the container. */
+    finish(): Promise<R>;
+}
+/** An in-memory container: new packages, tests, and the result of `MemoryPartSink`. */
+export declare class MemoryPartStore implements PartStore, PartSink<MemoryPartStore> {
+    private readonly parts;
+    /** Content types as put, for stores filled through the sink side. */
+    readonly contentTypes: Map<string, string>;
+    constructor(entries?: Iterable<[string, Uint8Array]>);
+    partNames(): Iterable<string>;
+    has(partName: string): boolean;
+    load(partName: string): Promise<Uint8Array>;
+    size(partName: string): number | undefined;
+    put(partName: string, bytes: Uint8Array, options?: PutOptions): void;
+    delete(partName: string): boolean;
+    finish(): Promise<MemoryPartStore>;
+}
+/** A sink that collects into a fresh `MemoryPartStore`. */
+export declare class MemoryPartSink implements PartSink<MemoryPartStore> {
+    readonly store: MemoryPartStore;
+    put(partName: string, bytes: Uint8Array, options?: PutOptions): void;
+    finish(): Promise<MemoryPartStore>;
+}

package/dist/opc/PartStore.mjs

@@ -0,0 +1,54 @@
+/** An in-memory container: new packages, tests, and the result of `MemoryPartSink`. */
+export class MemoryPartStore {
+    constructor(entries) {
+        this.parts = new Map();
+        /** Content types as put, for stores filled through the sink side. */
+        this.contentTypes = new Map();
+        if (entries)
+            for (const [name, bytes] of entries)
+                this.parts.set(normalize(name), bytes);
+    }
+    partNames() {
+        return this.parts.keys();
+    }
+    has(partName) {
+        return this.parts.has(normalize(partName));
+    }
+    async load(partName) {
+        const bytes = this.parts.get(normalize(partName));
+        if (bytes === undefined)
+            throw new Error(`No part ${partName}`);
+        return bytes;
+    }
+    size(partName) {
+        var _a;
+        return (_a = this.parts.get(normalize(partName))) === null || _a === void 0 ? void 0 : _a.length;
+    }
+    put(partName, bytes, options) {
+        const name = normalize(partName);
+        this.parts.set(name, bytes);
+        if ((options === null || options === void 0 ? void 0 : options.contentType) !== undefined)
+            this.contentTypes.set(name, options.contentType);
+    }
+    delete(partName) {
+        return this.parts.delete(normalize(partName));
+    }
+    async finish() {
+        return this;
+    }
+}
+/** A sink that collects into a fresh `MemoryPartStore`. */
+export class MemoryPartSink {
+    constructor() {
+        this.store = new MemoryPartStore();
+    }
+    put(partName, bytes, options) {
+        this.store.put(partName, bytes, options);
+    }
+    async finish() {
+        return this.store;
+    }
+}
+function normalize(name) {
+    return name.startsWith('/') ? name.substring(1) : name;
+}

package/dist/opc/Save.d.mts

@@ -0,0 +1,9 @@
+import type { PartSink } from './PartStore.mjs';
+import type { OpcPackage } from '../packages/OpcPackage.mjs';
+/**
+ * Writes a package to a sink (docx4j io3.Save): `[Content_Types].xml` first, then the package
+ * relationships, then every part reachable through relationships, each once. Relationship parts
+ * and unmarshalled XML parts are marshalled; every other part's bytes come from its source
+ * container unchanged.
+ */
+export declare function savePackage<R>(pkg: OpcPackage, sink: PartSink<R>): Promise<R>;

package/dist/opc/Save.mjs

@@ -0,0 +1,52 @@
+import { CONTENT_TYPES_NAME } from './PartName.mjs';
+import { ContentTypes } from './ContentTypes.mjs';
+import { Docx4JException } from './exceptions.mjs';
+import { Namespaces } from '../parts/Namespaces.mjs';
+import { isExternal } from '../parts/RelationshipsPart.mjs';
+import { encodeText } from '../xml/dom.mjs';
+/**
+ * Writes a package to a sink (docx4j io3.Save): `[Content_Types].xml` first, then the package
+ * relationships, then every part reachable through relationships, each once. Relationship parts
+ * and unmarshalled XML parts are marshalled; every other part's bytes come from its source
+ * container unchanged.
+ */
+export async function savePackage(pkg, sink) {
+    const saver = new Saver(pkg, sink);
+    sink.put(CONTENT_TYPES_NAME, encodeText(pkg.contentTypeManager.toXml()), { contentType: ContentTypes.CONTENT_TYPES_PART });
+    await saver.saveRels(pkg.relationshipsPart);
+    return sink.finish();
+}
+class Saver {
+    constructor(pkg, sink) {
+        this.pkg = pkg;
+        this.sink = sink;
+        this.handled = new Set();
+    }
+    async saveRels(rp) {
+        this.sink.put(rp.partName.storeName, await rp.getBytes(), { contentType: ContentTypes.RELATIONSHIPS_PART });
+        for (const r of rp.list) {
+            if (r.type === Namespaces.HYPERLINK || isExternal(r))
+                continue;
+            const part = this.pkg.getPart(rp.resolveTarget(r));
+            if (!part)
+                throw new Docx4JException(`Part ${rp.resolveTarget(r)} (target of ${r.id} in ${rp.partName}) not found`);
+            await this.savePart(part);
+        }
+    }
+    async savePart(part) {
+        if (this.handled.has(part.partName.key))
+            return;
+        this.handled.add(part.partName.key);
+        let bytes;
+        try {
+            bytes = await part.getBytes();
+        }
+        catch (e) {
+            throw new Docx4JException(`Problem saving part ${part.partName}`, { cause: e });
+        }
+        this.sink.put(part.partName.storeName, bytes, { compress: part.compress, contentType: part.contentType });
+        const rrp = part.relationshipsPart;
+        if (rrp && rrp.size > 0)
+            await this.saveRels(rrp);
+    }
+}