@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/core/opc/content-types.d.ts

@@ -0,0 +1,34 @@
+import { OpenXmlElement } from '../xml/index';
+import { ZipEntry } from '../zip/zip-entry';
+/** OPC Media Types stream ZIP item name (ECMA-376-2 §7.3.7). */
+export declare const CONTENT_TYPES_ZIP_ITEM = "[Content_Types].xml";
+/** `opc-contentTypes.xsd` targetNamespace. */
+export declare const CONTENT_TYPES_NAMESPACE = "http://schemas.openxmlformats.org/package/2006/content-types";
+/** ECMA-376-1 §11.3.10 Main Document content type. */
+export declare const MAIN_DOCUMENT_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml";
+/** ECMA-376-1 §11.2 example Default for relationship parts. */
+export declare const RELATIONSHIPS_CONTENT_TYPE = "application/vnd.openxmlformats-package.relationships+xml";
+export declare type ContentTypeRecord = {
+    readonly kind: 'default';
+    readonly extension: string;
+    readonly contentType: string;
+} | {
+    readonly kind: 'override';
+    readonly partName: string;
+    readonly contentType: string;
+} | {
+    readonly kind: 'opaque';
+    readonly xml: OpenXmlElement;
+};
+export interface ContentTypes {
+    readonly records: ReadonlyArray<ContentTypeRecord>;
+}
+export declare function parseContentTypesXml(xml: string): ContentTypes;
+export declare function readContentTypes(entries: ReadonlyArray<ZipEntry>): ContentTypes;
+/**
+ * Lookup as specified by OPC: Override by part name, else Default by extension.
+ * ECMA-376-2: order of Default/Override is not significant for lookup.
+ */
+export declare function lookupContentType(types: ContentTypes, logicalPartName: string): string | undefined;
+export declare function createTransitionalContentTypes(mainDocumentPartName?: string): ContentTypes;
+export declare function serializeContentTypes(types: ContentTypes): string;

package/src/core/opc/content-types.js

@@ -0,0 +1,162 @@
+var __values = (this && this.__values) || function (o) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+    if (m) return m.call(o);
+    return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+};
+import { PackageError } from '../errors/docx-error';
+import { parseXml, serializeXml } from '../xml/index';
+/** OPC Media Types stream ZIP item name (ECMA-376-2 §7.3.7). */
+export var CONTENT_TYPES_ZIP_ITEM = '[Content_Types].xml';
+/** `opc-contentTypes.xsd` targetNamespace. */
+export var CONTENT_TYPES_NAMESPACE = 'http://schemas.openxmlformats.org/package/2006/content-types';
+/** ECMA-376-1 §11.3.10 Main Document content type. */
+export var MAIN_DOCUMENT_CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml';
+/** ECMA-376-1 §11.2 example Default for relationship parts. */
+export var RELATIONSHIPS_CONTENT_TYPE = 'application/vnd.openxmlformats-package.relationships+xml';
+function isTypesElement(el) {
+    return el.localName === 'Types' && el.namespaceUri === CONTENT_TYPES_NAMESPACE;
+}
+function childElements(el) {
+    return el.children.filter(function (c) { return c.kind === 'element'; });
+}
+function requiredAttr(el, localName, what) {
+    var attr = el.attributes.find(function (a) { return a.localName === localName && a.namespaceUri === ''; });
+    if (attr === undefined || attr.value.length === 0) {
+        throw new PackageError('package/invalid-content-types', what + " is missing " + localName);
+    }
+    return attr.value;
+}
+export function parseContentTypesXml(xml) {
+    var e_1, _a;
+    var root = parseXml(xml);
+    if (!isTypesElement(root)) {
+        throw new PackageError('package/invalid-content-types', "Expected Types in " + CONTENT_TYPES_NAMESPACE + ", found {" + root.namespaceUri + "}" + root.localName);
+    }
+    var records = [];
+    try {
+        for (var _b = __values(childElements(root)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (child.namespaceUri !== CONTENT_TYPES_NAMESPACE) {
+                records.push({ kind: 'opaque', xml: child });
+                continue;
+            }
+            if (child.localName === 'Default') {
+                records.push({
+                    kind: 'default',
+                    extension: requiredAttr(child, 'Extension', 'Default'),
+                    contentType: requiredAttr(child, 'ContentType', 'Default'),
+                });
+                continue;
+            }
+            if (child.localName === 'Override') {
+                records.push({
+                    kind: 'override',
+                    partName: requiredAttr(child, 'PartName', 'Override'),
+                    contentType: requiredAttr(child, 'ContentType', 'Override'),
+                });
+                continue;
+            }
+            records.push({ kind: 'opaque', xml: child });
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return { records: records };
+}
+export function readContentTypes(entries) {
+    var item = entries.find(function (e) { return e.name === CONTENT_TYPES_ZIP_ITEM; });
+    if (item === undefined) {
+        throw new PackageError('package/missing-part', "ZIP item " + CONTENT_TYPES_ZIP_ITEM + " is required (ECMA-376-2 \u00A77.3.7)");
+    }
+    return parseContentTypesXml(new TextDecoder('utf-8').decode(item.data));
+}
+/**
+ * Lookup as specified by OPC: Override by part name, else Default by extension.
+ * ECMA-376-2: order of Default/Override is not significant for lookup.
+ */
+export function lookupContentType(types, logicalPartName) {
+    var override = types.records.find(function (r) { return r.kind === 'override' && r.partName === logicalPartName; });
+    // Classic guards: TS 3.3 does not narrow after `(x == null ? undefined : x.kind) === …`.
+    if (override !== undefined && override.kind === 'override') {
+        return override.contentType;
+    }
+    var slash = logicalPartName.lastIndexOf('/');
+    var fileName = slash === -1 ? logicalPartName : logicalPartName.slice(slash + 1);
+    var dot = fileName.lastIndexOf('.');
+    if (dot <= 0 || dot === fileName.length - 1) {
+        return undefined;
+    }
+    var extension = fileName.slice(dot + 1);
+    var def = types.records.find(function (r) { return r.kind === 'default' && r.extension.toLowerCase() === extension.toLowerCase(); });
+    if (def !== undefined && def.kind === 'default') {
+        return def.contentType;
+    }
+    return undefined;
+}
+export function createTransitionalContentTypes(mainDocumentPartName) {
+    if (mainDocumentPartName === void 0) { mainDocumentPartName = '/word/document.xml'; }
+    return {
+        records: [
+            { kind: 'default', extension: 'rels', contentType: RELATIONSHIPS_CONTENT_TYPE },
+            { kind: 'default', extension: 'xml', contentType: 'application/xml' },
+            {
+                kind: 'override',
+                partName: mainDocumentPartName,
+                contentType: MAIN_DOCUMENT_CONTENT_TYPE,
+            },
+        ],
+    };
+}
+export function serializeContentTypes(types) {
+    var children = types.records.map(function (record) {
+        if (record.kind === 'opaque') {
+            return record.xml;
+        }
+        if (record.kind === 'default') {
+            return {
+                kind: 'element',
+                namespaceUri: CONTENT_TYPES_NAMESPACE,
+                localName: 'Default',
+                prefix: '',
+                attributes: [
+                    { namespaceUri: '', localName: 'Extension', prefix: '', value: record.extension },
+                    { namespaceUri: '', localName: 'ContentType', prefix: '', value: record.contentType },
+                ],
+                namespaceDeclarations: [],
+                children: [],
+            };
+        }
+        return {
+            kind: 'element',
+            namespaceUri: CONTENT_TYPES_NAMESPACE,
+            localName: 'Override',
+            prefix: '',
+            attributes: [
+                { namespaceUri: '', localName: 'PartName', prefix: '', value: record.partName },
+                { namespaceUri: '', localName: 'ContentType', prefix: '', value: record.contentType },
+            ],
+            namespaceDeclarations: [],
+            children: [],
+        };
+    });
+    var root = {
+        kind: 'element',
+        namespaceUri: CONTENT_TYPES_NAMESPACE,
+        localName: 'Types',
+        prefix: '',
+        attributes: [],
+        namespaceDeclarations: [{ prefix: '', namespaceUri: CONTENT_TYPES_NAMESPACE }],
+        children: children,
+    };
+    return serializeXml(root);
+}

package/src/core/opc/index.d.ts

@@ -0,0 +1,8 @@
+export { CONTENT_TYPES_NAMESPACE, CONTENT_TYPES_ZIP_ITEM, MAIN_DOCUMENT_CONTENT_TYPE, RELATIONSHIPS_CONTENT_TYPE, createTransitionalContentTypes, lookupContentType, parseContentTypesXml, readContentTypes, serializeContentTypes, } from './content-types';
+export { ContentTypeRecord, ContentTypes } from './content-types';
+export { assertPartNameSetIntegrity, isPackageRelationshipsPartName, isPartNameDerivableFrom, isRelationshipsPartName, packageRelationshipsPartName, partName, partNameFromZipItem, partNameKey, partNamesEquivalent, partRelationshipsPartName, resolveInternalTarget, sourcePartNameFromRelationshipsPart, zipItemFromPartName, } from './part-name';
+export { PartName } from './part-name';
+export { OFFICE_DOCUMENT_RELATIONSHIP_TYPE, RELATIONSHIPS_NAMESPACE, STRICT_OFFICE_DOCUMENT_RELATIONSHIP_TYPE, TargetMode, allocateRelationshipId, emptyRelationships, findOfficeDocumentRelationship, isOfficeDocumentRelationshipType, parseRelationshipsXml, relationshipId, relationshipsWith, serializeRelationships, } from './relationships';
+export { OpcRelationship, RelationshipId, Relationships } from './relationships';
+export { createTransitionalWordPackage, getExternalRelationshipTargets, loadOpcPackage, officeDocumentPartName, partByName, relationshipsForPart, saveOpcPackage, transitionalDocumentStubXml, withReplacedPart, withAddedPart, withContentTypeOverride, withPartRelationships, withPackageRelationships, } from './package';
+export { OpcPackage, PackagePart, PartRelationshipSet } from './package';

package/src/core/opc/index.js

@@ -0,0 +1,4 @@
+export { CONTENT_TYPES_NAMESPACE, CONTENT_TYPES_ZIP_ITEM, MAIN_DOCUMENT_CONTENT_TYPE, RELATIONSHIPS_CONTENT_TYPE, createTransitionalContentTypes, lookupContentType, parseContentTypesXml, readContentTypes, serializeContentTypes, } from './content-types';
+export { assertPartNameSetIntegrity, isPackageRelationshipsPartName, isPartNameDerivableFrom, isRelationshipsPartName, packageRelationshipsPartName, partName, partNameFromZipItem, partNameKey, partNamesEquivalent, partRelationshipsPartName, resolveInternalTarget, sourcePartNameFromRelationshipsPart, zipItemFromPartName, } from './part-name';
+export { OFFICE_DOCUMENT_RELATIONSHIP_TYPE, RELATIONSHIPS_NAMESPACE, STRICT_OFFICE_DOCUMENT_RELATIONSHIP_TYPE, TargetMode, allocateRelationshipId, emptyRelationships, findOfficeDocumentRelationship, isOfficeDocumentRelationshipType, parseRelationshipsXml, relationshipId, relationshipsWith, serializeRelationships, } from './relationships';
+export { createTransitionalWordPackage, getExternalRelationshipTargets, loadOpcPackage, officeDocumentPartName, partByName, relationshipsForPart, saveOpcPackage, transitionalDocumentStubXml, withReplacedPart, withAddedPart, withContentTypeOverride, withPartRelationships, withPackageRelationships, } from './package';

package/src/core/opc/package.d.ts

@@ -0,0 +1,49 @@
+import { ResourceLimitOverrides } from '../security/limits';
+import { ContentTypes } from './content-types';
+import { PartName } from './part-name';
+import { OpcRelationship, Relationships } from './relationships';
+export interface PackagePart {
+    readonly name: PartName;
+    readonly contentType: string;
+    readonly data: Uint8Array;
+}
+export interface PartRelationshipSet {
+    readonly source: PartName;
+    readonly relationships: Relationships;
+}
+/**
+ * In-memory OPC package (ZIP + content types + relationships + part payloads).
+ * Not the public WordDocument API (TASK-1010).
+ */
+export interface OpcPackage {
+    readonly contentTypes: ContentTypes;
+    readonly packageRelationships: Relationships;
+    readonly parts: ReadonlyArray<PackagePart>;
+    readonly partRelationships: ReadonlyArray<PartRelationshipSet>;
+}
+/**
+ * Stub Transitional main document payload. Not a WML parser (TASK-1005 out of scope).
+ */
+export declare function transitionalDocumentStubXml(): string;
+export declare function createTransitionalWordPackage(options?: {
+    readonly documentXml?: Uint8Array;
+    readonly extraParts?: ReadonlyArray<PackagePart>;
+    readonly extraPackageRelationships?: ReadonlyArray<OpcRelationship>;
+}): OpcPackage;
+export declare function officeDocumentPartName(pkg: OpcPackage): PartName;
+export declare function loadOpcPackage(bytes: Uint8Array, limits?: ResourceLimitOverrides): OpcPackage;
+/**
+ * External TargetMode values are stored only. This module never calls fetch or
+ * opens a network/filesystem URI (`.agent/policies/security.md`).
+ */
+export declare function getExternalRelationshipTargets(pkg: OpcPackage): ReadonlyArray<string>;
+export declare function saveOpcPackage(pkg: OpcPackage): Uint8Array;
+export declare function partByName(pkg: OpcPackage, name: PartName): PackagePart | undefined;
+export declare function relationshipsForPart(pkg: OpcPackage, source: PartName): Relationships;
+/** Replace one part's payload, keeping content type and other parts. */
+export declare function withReplacedPart(pkg: OpcPackage, name: PartName, data: Uint8Array): OpcPackage;
+/** Append a part if absent; replace payload if the name already exists. */
+export declare function withAddedPart(pkg: OpcPackage, part: PackagePart): OpcPackage;
+export declare function withContentTypeOverride(pkg: OpcPackage, logicalPartName: PartName, contentType: string): OpcPackage;
+export declare function withPartRelationships(pkg: OpcPackage, source: PartName, relationships: Relationships): OpcPackage;
+export declare function withPackageRelationships(pkg: OpcPackage, relationships: Relationships): OpcPackage;

package/src/core/opc/package.js

@@ -0,0 +1,324 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+var __values = (this && this.__values) || function (o) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+    if (m) return m.call(o);
+    return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+};
+import { PackageError } from '../errors/docx-error';
+import { resolveResourceLimits } from '../security/limits';
+import { WML_TRANSITIONAL_NAMESPACE } from '../xml/index';
+import { readZip } from '../zip/read';
+import { writeZip } from '../zip/write';
+import { CONTENT_TYPES_ZIP_ITEM, createTransitionalContentTypes, lookupContentType, MAIN_DOCUMENT_CONTENT_TYPE, readContentTypes, serializeContentTypes } from './content-types';
+import { assertPartNameSetIntegrity, isPackageRelationshipsPartName, isRelationshipsPartName, packageRelationshipsPartName, partName, partNameFromZipItem, partNameKey, partRelationshipsPartName, resolveInternalTarget, sourcePartNameFromRelationshipsPart, zipItemFromPartName } from './part-name';
+import { emptyRelationships, findOfficeDocumentRelationship, OFFICE_DOCUMENT_RELATIONSHIP_TYPE, parseRelationshipsXml, relationshipId, relationshipsWith, serializeRelationships, TargetMode } from './relationships';
+var utf8 = new TextEncoder();
+var utf8Decoder = new TextDecoder('utf-8');
+function bytesOf(xml) {
+    return utf8.encode(xml);
+}
+function decodeXml(data) {
+    return utf8Decoder.decode(data);
+}
+function findPart(parts, name) {
+    var key = partNameKey(name);
+    return parts.find(function (part) { return partNameKey(part.name) === key; });
+}
+function findPartRels(sets, source) {
+    var __ts33_0;
+    var key = partNameKey(source);
+    return ((__ts33_0 = sets.find(function (set) { return partNameKey(set.source) === key; })), __ts33_0 == null ? undefined : __ts33_0.relationships);
+}
+/**
+ * Stub Transitional main document payload. Not a WML parser (TASK-1005 out of scope).
+ */
+export function transitionalDocumentStubXml() {
+    return ("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>" +
+        ("<w:document xmlns:w=\"" + WML_TRANSITIONAL_NAMESPACE + "\"><w:body/></w:document>"));
+}
+export function createTransitionalWordPackage(options) {
+    var __ts33_1, __ts33_2, __ts33_3;
+    var main = partName('/word/document.xml');
+    var documentXml = ((__ts33_1 = options == null ? undefined : options.documentXml), __ts33_1 != null ? __ts33_1 : bytesOf(transitionalDocumentStubXml()));
+    var officeRel = {
+        id: relationshipId('rId1'),
+        type: OFFICE_DOCUMENT_RELATIONSHIP_TYPE,
+        target: 'word/document.xml',
+        extraAttributes: [],
+        children: [],
+    };
+    var extra = ((__ts33_2 = options == null ? undefined : options.extraPackageRelationships), __ts33_2 != null ? __ts33_2 : []);
+    var packageRelationships = relationshipsWith(__spread([officeRel], extra));
+    var extraParts = ((__ts33_3 = options == null ? undefined : options.extraParts), __ts33_3 != null ? __ts33_3 : []);
+    var parts = __spread([
+        { name: main, contentType: MAIN_DOCUMENT_CONTENT_TYPE, data: documentXml }
+    ], extraParts);
+    assertPartNameSetIntegrity(parts.map(function (p) { return p.name; }));
+    return {
+        contentTypes: createTransitionalContentTypes(main),
+        packageRelationships: packageRelationships,
+        parts: parts,
+        partRelationships: [],
+    };
+}
+export function officeDocumentPartName(pkg) {
+    var rel = findOfficeDocumentRelationship(pkg.packageRelationships);
+    if (rel === undefined) {
+        throw new PackageError('package/missing-part', 'Package Relationships part has no officeDocument relationship (ECMA-376-1 §11.2)');
+    }
+    if (rel.targetMode === TargetMode.External) {
+        throw new PackageError('package/missing-part', 'officeDocument relationship must not use TargetMode External');
+    }
+    return resolveInternalTarget(rel.target);
+}
+function parseRelsEntry(data, sourceLabel, relationshipCountLimit) {
+    return parseRelationshipsXml(decodeXml(data), { sourceLabel: sourceLabel, relationshipCountLimit: relationshipCountLimit });
+}
+export function loadOpcPackage(bytes, limits) {
+    var e_1, _a;
+    var __ts33_4;
+    var resolved = resolveResourceLimits(limits);
+    var entries = readZip(bytes, limits);
+    var contentTypes = readContentTypes(entries);
+    var parts = [];
+    var packageRelationships;
+    var partRelationships = [];
+    try {
+        for (var entries_1 = __values(entries), entries_1_1 = entries_1.next(); !entries_1_1.done; entries_1_1 = entries_1.next()) {
+            var entry = entries_1_1.value;
+            if (entry.name === CONTENT_TYPES_ZIP_ITEM) {
+                continue;
+            }
+            // ZIP directory markers (name ends with '/') are not OPC parts
+            // (ECMA-376-2 §6.2.2.2 part_name has no trailing slash; ECMA-376-1:
+            // ZIP items that do not conform to OPC part naming are not parts).
+            if (entry.name.endsWith('/')) {
+                continue;
+            }
+            var logical = partNameFromZipItem(entry.name);
+            if (isRelationshipsPartName(logical)) {
+                var rels = parseRelsEntry(entry.data, entry.name, resolved.relationshipCountPerPart);
+                if (isPackageRelationshipsPartName(logical)) {
+                    packageRelationships = rels;
+                }
+                else {
+                    var source = sourcePartNameFromRelationshipsPart(logical);
+                    if (source === undefined) {
+                        throw new PackageError('package/invalid-relationships', "Could not invert Relationships part " + logical);
+                    }
+                    partRelationships.push({ source: source, relationships: rels });
+                }
+                continue;
+            }
+            var contentType = ((__ts33_4 = lookupContentType(contentTypes, logical)), __ts33_4 != null ? __ts33_4 : 'application/octet-stream');
+            parts.push({ name: logical, contentType: contentType, data: entry.data });
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (entries_1_1 && !entries_1_1.done && (_a = entries_1.return)) _a.call(entries_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    if (packageRelationships === undefined) {
+        throw new PackageError('package/missing-part', "Missing package Relationships part " + zipItemFromPartName(packageRelationshipsPartName()));
+    }
+    assertPartNameSetIntegrity(parts.map(function (p) { return p.name; }));
+    var pkg = {
+        contentTypes: contentTypes,
+        packageRelationships: packageRelationships,
+        parts: parts,
+        partRelationships: partRelationships,
+    };
+    var mainName = officeDocumentPartName(pkg);
+    if (findPart(parts, mainName) === undefined) {
+        throw new PackageError('package/missing-part', "officeDocument target part " + mainName + " is not in the package");
+    }
+    return pkg;
+}
+/**
+ * External TargetMode values are stored only. This module never calls fetch or
+ * opens a network/filesystem URI (`.agent/policies/security.md`).
+ */
+export function getExternalRelationshipTargets(pkg) {
+    var e_2, _a;
+    var targets = [];
+    var collect = function (rels) {
+        var e_3, _a;
+        try {
+            for (var _b = __values(rels.items), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var item = _c.value;
+                if (item.targetMode === TargetMode.External) {
+                    targets.push(item.target);
+                }
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+    };
+    collect(pkg.packageRelationships);
+    try {
+        for (var _b = __values(pkg.partRelationships), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var set = _c.value;
+            collect(set.relationships);
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return targets;
+}
+export function saveOpcPackage(pkg) {
+    var e_4, _a, e_5, _b;
+    officeDocumentPartName(pkg);
+    var entries = [
+        { name: CONTENT_TYPES_ZIP_ITEM, data: bytesOf(serializeContentTypes(pkg.contentTypes)) },
+        {
+            name: zipItemFromPartName(packageRelationshipsPartName()),
+            data: bytesOf(serializeRelationships(pkg.packageRelationships)),
+        },
+    ];
+    var seenZip = new Set(entries.map(function (e) { return e.name.toLowerCase(); }));
+    var push = function (name, data) {
+        var key = name.toLowerCase();
+        if (seenZip.has(key)) {
+            throw new PackageError('package/duplicate-zip-entry', "Duplicate ZIP item on save: " + name);
+        }
+        seenZip.add(key);
+        entries.push({ name: name, data: data });
+    };
+    try {
+        for (var _c = __values(pkg.parts), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var part = _d.value;
+            push(zipItemFromPartName(part.name), part.data);
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    try {
+        for (var _e = __values(pkg.partRelationships), _f = _e.next(); !_f.done; _f = _e.next()) {
+            var set = _f.value;
+            if (set.relationships.items.length === 0 && set.relationships.opaque.length === 0) {
+                continue;
+            }
+            push(zipItemFromPartName(partRelationshipsPartName(set.source)), bytesOf(serializeRelationships(set.relationships)));
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    return writeZip(entries);
+}
+export function partByName(pkg, name) {
+    return findPart(pkg.parts, name);
+}
+export function relationshipsForPart(pkg, source) {
+    var __ts33_5;
+    return ((__ts33_5 = findPartRels(pkg.partRelationships, source)), __ts33_5 != null ? __ts33_5 : emptyRelationships());
+}
+/** Replace one part's payload, keeping content type and other parts. */
+export function withReplacedPart(pkg, name, data) {
+    var key = partNameKey(name);
+    var index = pkg.parts.findIndex(function (part) { return partNameKey(part.name) === key; });
+    if (index < 0) {
+        throw new PackageError('package/invalid-part-name', "Part not in package: " + name);
+    }
+    var parts = pkg.parts.map(function (part, i) { return i === index ? { name: part.name, contentType: part.contentType, data: data } : part; });
+    return __assign({}, pkg, { parts: parts });
+}
+function upsertPartRelationships(sets, source, relationships) {
+    var key = partNameKey(source);
+    var index = sets.findIndex(function (set) { return partNameKey(set.source) === key; });
+    if (index < 0) {
+        return __spread(sets, [{ source: source, relationships: relationships }]);
+    }
+    var next = __spread(sets);
+    next[index] = { source: source, relationships: relationships };
+    return next;
+}
+function upsertContentTypeOverride(types, logicalPartName, contentType) {
+    var records = types.records.map(function (record) {
+        if (record.kind === 'override' && record.partName === logicalPartName) {
+            return { kind: 'override', partName: logicalPartName, contentType: contentType };
+        }
+        return record;
+    });
+    if (!records.some(function (record) { return record.kind === 'override' && record.partName === logicalPartName; })) {
+        records.push({ kind: 'override', partName: logicalPartName, contentType: contentType });
+    }
+    return { records: records };
+}
+/** Append a part if absent; replace payload if the name already exists. */
+export function withAddedPart(pkg, part) {
+    var key = partNameKey(part.name);
+    var index = pkg.parts.findIndex(function (existing) { return partNameKey(existing.name) === key; });
+    if (index >= 0) {
+        var parts_1 = pkg.parts.map(function (existing, i) { return (i === index ? part : existing); });
+        return __assign({}, pkg, { parts: parts_1 });
+    }
+    var parts = __spread(pkg.parts, [part]);
+    return __assign({}, pkg, { parts: parts });
+}
+export function withContentTypeOverride(pkg, logicalPartName, contentType) {
+    return __assign({}, pkg, { contentTypes: upsertContentTypeOverride(pkg.contentTypes, logicalPartName, contentType) });
+}
+export function withPartRelationships(pkg, source, relationships) {
+    return __assign({}, pkg, { partRelationships: upsertPartRelationships(pkg.partRelationships, source, relationships) });
+}
+export function withPackageRelationships(pkg, relationships) {
+    return __assign({}, pkg, { packageRelationships: relationships });
+}

package/src/core/opc/part-name.d.ts

@@ -0,0 +1,47 @@
+/**
+ * OPC part name. Branded so it is not interchangeable with a ZIP item name or a
+ * relationship Target string (`.agent/policies/typescript.md`).
+ */
+export declare type PartName = string & {
+    readonly __brand: 'PartName';
+};
+/**
+ * ASCII case-insensitive part-name key (ECMA-376-2 §6.2.2.3).
+ */
+export declare function partNameKey(name: string): string;
+/**
+ * Validates and brands an OPC logical part name (leading `/`).
+ * ECMA-376-2 §6.2.2.2 production `part_name = 1*( "/" isegment-nz )`.
+ */
+export declare function partName(value: string): PartName;
+/** ZIP item name → logical part name (ECMA-376-2 §7.3.5). */
+export declare function partNameFromZipItem(zipItemName: string): PartName;
+/** Logical part name → ZIP item name (no leading `/`). */
+export declare function zipItemFromPartName(name: PartName): string;
+export declare function partNamesEquivalent(left: string, right: string): boolean;
+/**
+ * True when `candidate` is derivable from `base` (ECMA-376-2 §6.2.2.3):
+ * concatenating `base`, `/`, and some string S yields an equivalent name.
+ */
+export declare function isPartNameDerivableFrom(candidate: string, base: string): boolean;
+export declare function assertPartNameSetIntegrity(names: ReadonlyArray<PartName>): void;
+/**
+ * Relationships parts: `/_rels/.rels` and `…/_rels/….rels` (ECMA-376-2 §6.5.2.2–§6.5.2.3).
+ */
+export declare function isRelationshipsPartName(name: PartName): boolean;
+export declare function isPackageRelationshipsPartName(name: PartName): boolean;
+/** Package Relationships part name (ECMA-376-2 §6.5.2.2). */
+export declare function packageRelationshipsPartName(): PartName;
+/**
+ * Part Relationships part name from a source part (ECMA-376-2 §6.5.2.3).
+ */
+export declare function partRelationshipsPartName(source: PartName): PartName;
+/**
+ * Inverse of {@link partRelationshipsPartName}. Package rels yield `undefined`.
+ */
+export declare function sourcePartNameFromRelationshipsPart(relsPart: PartName): PartName | undefined;
+/**
+ * Resolve an Internal relationship Target against a source part, or against the
+ * package when `source` is omitted (package Relationships).
+ */
+export declare function resolveInternalTarget(target: string, source?: PartName): PartName;