@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/core/opc/part-name.js

@@ -0,0 +1,205 @@
+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';
+/**
+ * ASCII case-insensitive part-name key (ECMA-376-2 §6.2.2.3).
+ */
+export function partNameKey(name) {
+    return name.toLowerCase();
+}
+function rejectUnsafeSegments(logicalName) {
+    var e_1, _a;
+    if (logicalName.includes('\0')) {
+        throw new PackageError('package/invalid-part-name', 'Part name contains a NUL');
+    }
+    if (logicalName.includes('\\')) {
+        throw new PackageError('package/invalid-part-name', "Part name contains a backslash: " + logicalName);
+    }
+    if (!logicalName.startsWith('/')) {
+        throw new PackageError('package/invalid-part-name', "OPC part names begin with '/': " + logicalName);
+    }
+    if (logicalName === '/') {
+        throw new PackageError('package/invalid-part-name', 'Part name must have at least one segment');
+    }
+    if (logicalName.endsWith('/')) {
+        throw new PackageError('package/invalid-part-name', "Part name must not end with '/': " + logicalName);
+    }
+    var segments = logicalName.slice(1).split('/');
+    try {
+        for (var segments_1 = __values(segments), segments_1_1 = segments_1.next(); !segments_1_1.done; segments_1_1 = segments_1.next()) {
+            var segment = segments_1_1.value;
+            if (segment.length === 0) {
+                throw new PackageError('package/invalid-part-name', "Part name has an empty segment: " + logicalName);
+            }
+            if (segment === '.' || segment === '..') {
+                throw new PackageError('package/invalid-part-name', "Part name contains a '.' or '..' segment: " + logicalName);
+            }
+            if (segment.endsWith('.')) {
+                throw new PackageError('package/invalid-part-name', "OPC forbids a path segment that ends with '.': " + logicalName);
+            }
+            if (/^[a-zA-Z]:/.test(segment)) {
+                throw new PackageError('package/invalid-part-name', "Part name has a drive letter: " + logicalName);
+            }
+            if (/%2f/i.test(segment) || /%5c/i.test(segment)) {
+                throw new PackageError('package/invalid-part-name', "Part name has a percent-encoded slash: " + logicalName);
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (segments_1_1 && !segments_1_1.done && (_a = segments_1.return)) _a.call(segments_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    if (!/^[\u0020-\u007e]+$/.test(logicalName)) {
+        throw new PackageError('package/invalid-part-name', "Phase 1 part names are ASCII (ECMA-376-2 \u00A77.3.3 ZIP mapping): " + logicalName);
+    }
+}
+/**
+ * Validates and brands an OPC logical part name (leading `/`).
+ * ECMA-376-2 §6.2.2.2 production `part_name = 1*( "/" isegment-nz )`.
+ */
+export function partName(value) {
+    rejectUnsafeSegments(value);
+    return value;
+}
+/** ZIP item name → logical part name (ECMA-376-2 §7.3.5). */
+export function partNameFromZipItem(zipItemName) {
+    // split/join: String.replaceAll is ES2021 and is not rewritten by target ES5.
+    var withForwardSlashes = zipItemName.split('\\').join('/');
+    return partName("/" + withForwardSlashes);
+}
+/** Logical part name → ZIP item name (no leading `/`). */
+export function zipItemFromPartName(name) {
+    return name.slice(1);
+}
+export function partNamesEquivalent(left, right) {
+    return partNameKey(left) === partNameKey(right);
+}
+/**
+ * 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 function isPartNameDerivableFrom(candidate, base) {
+    var child = partNameKey(candidate);
+    var parent = partNameKey(base);
+    return child.startsWith(parent + "/");
+}
+export function assertPartNameSetIntegrity(names) {
+    for (var i = 0; i < names.length; i += 1) {
+        var left = names[i];
+        if (left === undefined) {
+            continue;
+        }
+        for (var j = i + 1; j < names.length; j += 1) {
+            var right = names[j];
+            if (right === undefined) {
+                continue;
+            }
+            if (partNamesEquivalent(left, right)) {
+                throw new PackageError('package/duplicate-zip-entry', "Equivalent part names in one package: " + left + " and " + right + " (ECMA-376-2 \u00A76.2.2.3)");
+            }
+            if (isPartNameDerivableFrom(left, right) || isPartNameDerivableFrom(right, left)) {
+                throw new PackageError('package/invalid-part-name', "Part name " + left + " is derivable from " + right + " (ECMA-376-2 \u00A76.2.2.3)");
+            }
+        }
+    }
+}
+var RELS_SUFFIX = '.rels';
+/**
+ * Relationships parts: `/_rels/.rels` and `…/_rels/….rels` (ECMA-376-2 §6.5.2.2–§6.5.2.3).
+ */
+export function isRelationshipsPartName(name) {
+    var segments = name.split('/').filter(function (segment) { return segment.length > 0; });
+    if (segments.length < 2) {
+        return false;
+    }
+    var last = segments[segments.length - 1];
+    var secondLast = segments[segments.length - 2];
+    if (last === undefined || secondLast === undefined) {
+        return false;
+    }
+    return secondLast.toLowerCase() === '_rels' && last.toLowerCase().endsWith(RELS_SUFFIX);
+}
+export function isPackageRelationshipsPartName(name) {
+    return partNamesEquivalent(name, '/_rels/.rels');
+}
+/** Package Relationships part name (ECMA-376-2 §6.5.2.2). */
+export function packageRelationshipsPartName() {
+    return partName('/_rels/.rels');
+}
+/**
+ * Part Relationships part name from a source part (ECMA-376-2 §6.5.2.3).
+ */
+export function partRelationshipsPartName(source) {
+    var lastSlash = source.lastIndexOf('/');
+    var directory = source.slice(0, lastSlash);
+    var fileName = source.slice(lastSlash + 1);
+    var relsDirectory = directory === '' ? '/_rels' : directory + "/_rels";
+    return partName(relsDirectory + "/" + fileName + RELS_SUFFIX);
+}
+/**
+ * Inverse of {@link partRelationshipsPartName}. Package rels yield `undefined`.
+ */
+export function sourcePartNameFromRelationshipsPart(relsPart) {
+    if (!isRelationshipsPartName(relsPart)) {
+        throw new PackageError('package/invalid-part-name', "Not a Relationships part: " + relsPart);
+    }
+    if (isPackageRelationshipsPartName(relsPart)) {
+        return undefined;
+    }
+    var segments = relsPart.split('/');
+    var last = segments[segments.length - 1];
+    if (last === undefined || !last.toLowerCase().endsWith(RELS_SUFFIX)) {
+        throw new PackageError('package/invalid-part-name', "Relationships part name is malformed: " + relsPart);
+    }
+    var sourceFile = last.slice(0, last.length - RELS_SUFFIX.length);
+    var withoutRelsSegments = segments.slice(0, -2);
+    return partName(withoutRelsSegments.join('/') + "/" + sourceFile);
+}
+function directoryOfPart(source) {
+    var lastSlash = source.lastIndexOf('/');
+    if (lastSlash <= 0) {
+        return '/';
+    }
+    return source.slice(0, lastSlash) + "/";
+}
+/**
+ * Resolve an Internal relationship Target against a source part, or against the
+ * package when `source` is omitted (package Relationships).
+ */
+export function resolveInternalTarget(target, source) {
+    var trimmed = target.trim();
+    if (trimmed.length === 0) {
+        throw new PackageError('package/invalid-part-name', 'Internal relationship Target is empty');
+    }
+    if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(trimmed)) {
+        throw new PackageError('package/invalid-part-name', "Internal relationship Target is not a package-relative reference: " + target);
+    }
+    var path;
+    if (trimmed.startsWith('/')) {
+        path = trimmed;
+    }
+    else {
+        var basePath = source === undefined ? '/' : directoryOfPart(source);
+        var resolved = new URL(trimmed, "https://opc.invalid" + basePath);
+        path = resolved.pathname;
+    }
+    var decoded;
+    try {
+        decoded = decodeURIComponent(path);
+    }
+    catch (_a) {
+        throw new PackageError('package/invalid-part-name', "Internal Target is not a valid URI path: " + target);
+    }
+    return partName(decoded);
+}

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

@@ -0,0 +1,46 @@
+import { OpenXmlAttribute, OpenXmlChild, OpenXmlElement } from '../xml/index';
+/**
+ * Relationship Id (`Id` on `Relationship`, `xsd:ID` in opc-relationships.xsd).
+ */
+export declare type RelationshipId = string & {
+    readonly __brand: 'RelationshipId';
+};
+/** `opc-relationships.xsd` targetNamespace. */
+export declare const RELATIONSHIPS_NAMESPACE = "http://schemas.openxmlformats.org/package/2006/relationships";
+/**
+ * Transitional officeDocument relationship Type (ECMA-376-4 §9.2.10).
+ */
+export declare const OFFICE_DOCUMENT_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument";
+/**
+ * Strict officeDocument relationship Type (ECMA-376-1 §11.2 example).
+ * Accepted on load; never rewritten to Transitional on save.
+ */
+export declare const STRICT_OFFICE_DOCUMENT_RELATIONSHIP_TYPE = "http://purl.oclc.org/ooxml/officeDocument/relationships/officeDocument";
+export declare const TargetMode: {
+    Internal: "Internal";
+    External: "External";
+};
+export declare type TargetMode = (typeof TargetMode)[keyof typeof TargetMode];
+export interface OpcRelationship {
+    readonly id: RelationshipId;
+    readonly type: string;
+    readonly target: string;
+    readonly targetMode?: TargetMode;
+    readonly extraAttributes: ReadonlyArray<OpenXmlAttribute>;
+    readonly children: ReadonlyArray<OpenXmlChild>;
+}
+export interface Relationships {
+    readonly items: ReadonlyArray<OpcRelationship>;
+    readonly opaque: ReadonlyArray<OpenXmlElement>;
+}
+export declare function relationshipId(value: string): RelationshipId;
+export declare function allocateRelationshipId(used: ReadonlySet<string>): RelationshipId;
+export declare function isOfficeDocumentRelationshipType(type: string): boolean;
+export declare function parseRelationshipsXml(xml: string, options?: {
+    readonly relationshipCountLimit?: number;
+    readonly sourceLabel?: string;
+}): Relationships;
+export declare function serializeRelationships(rels: Relationships): string;
+export declare function findOfficeDocumentRelationship(rels: Relationships): OpcRelationship | undefined;
+export declare function emptyRelationships(): Relationships;
+export declare function relationshipsWith(items: ReadonlyArray<OpcRelationship>, opaque?: ReadonlyArray<OpenXmlElement>): Relationships;

package/src/core/opc/relationships.js

@@ -0,0 +1,212 @@
+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 __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 };
+        }
+    };
+};
+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;
+};
+import { PackageError, SecurityError } from '../errors/docx-error';
+import { DEFAULT_RESOURCE_LIMITS } from '../security/limits';
+import { parseXml, serializeXml } from '../xml/index';
+/** `opc-relationships.xsd` targetNamespace. */
+export var RELATIONSHIPS_NAMESPACE = 'http://schemas.openxmlformats.org/package/2006/relationships';
+/**
+ * Transitional officeDocument relationship Type (ECMA-376-4 §9.2.10).
+ */
+export var OFFICE_DOCUMENT_RELATIONSHIP_TYPE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument';
+/**
+ * Strict officeDocument relationship Type (ECMA-376-1 §11.2 example).
+ * Accepted on load; never rewritten to Transitional on save.
+ */
+export var STRICT_OFFICE_DOCUMENT_RELATIONSHIP_TYPE = 'http://purl.oclc.org/ooxml/officeDocument/relationships/officeDocument';
+export var TargetMode = {
+    Internal: 'Internal',
+    External: 'External',
+};
+var ID_PATTERN = /^[A-Za-z_][\w.-]*$/;
+export function relationshipId(value) {
+    if (!ID_PATTERN.test(value)) {
+        throw new PackageError('package/invalid-relationship-id', "Relationship Id is not a valid xsd:ID token: " + value);
+    }
+    return value;
+}
+export function allocateRelationshipId(used) {
+    var n = 1;
+    while (used.has("rId" + String(n))) {
+        n += 1;
+    }
+    return relationshipId("rId" + String(n));
+}
+export function isOfficeDocumentRelationshipType(type) {
+    return type === OFFICE_DOCUMENT_RELATIONSHIP_TYPE || type === STRICT_OFFICE_DOCUMENT_RELATIONSHIP_TYPE;
+}
+function childElements(el) {
+    return el.children.filter(function (c) { return c.kind === 'element'; });
+}
+function attr(el, localName) {
+    var found = el.attributes.find(function (a) { return a.localName === localName && a.namespaceUri === ''; });
+    return found == null ? undefined : found.value;
+}
+function requiredAttr(el, localName) {
+    var value = attr(el, localName);
+    if (value === undefined || value.length === 0) {
+        throw new PackageError('package/invalid-relationships', "Relationship is missing " + localName);
+    }
+    return value;
+}
+function parseTargetMode(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === TargetMode.Internal || value === TargetMode.External) {
+        return value;
+    }
+    throw new PackageError('package/invalid-relationships', "TargetMode must be Internal or External (opc-relationships.xsd ST_TargetMode), got " + value);
+}
+export function parseRelationshipsXml(xml, options) {
+    var e_1, _a;
+    var __ts33_0, __ts33_1;
+    var limit = ((__ts33_0 = options == null ? undefined : options.relationshipCountLimit), __ts33_0 != null ? __ts33_0 : DEFAULT_RESOURCE_LIMITS.relationshipCountPerPart);
+    var sourceLabel = ((__ts33_1 = options == null ? undefined : options.sourceLabel), __ts33_1 != null ? __ts33_1 : 'Relationships part');
+    var root = parseXml(xml);
+    if (root.localName !== 'Relationships' || root.namespaceUri !== RELATIONSHIPS_NAMESPACE) {
+        throw new PackageError('package/invalid-relationships', "Expected Relationships in " + RELATIONSHIPS_NAMESPACE + ", found {" + root.namespaceUri + "}" + root.localName);
+    }
+    var items = [];
+    var opaque = [];
+    var seenIds = new Set();
+    var relationshipCount = 0;
+    var _loop_1 = function (child) {
+        if (child.namespaceUri !== RELATIONSHIPS_NAMESPACE || child.localName !== 'Relationship') {
+            opaque.push(child);
+            return "continue";
+        }
+        relationshipCount += 1;
+        if (relationshipCount > limit) {
+            throw new SecurityError('security/relationship-count', "Relationship count exceeds " + String(limit) + " on " + sourceLabel);
+        }
+        var id = relationshipId(requiredAttr(child, 'Id'));
+        if (seenIds.has(id)) {
+            throw new PackageError('package/invalid-relationships', "Duplicate Relationship Id " + id + " in " + sourceLabel + " (xsd:ID uniqueness)");
+        }
+        seenIds.add(id);
+        var known = new Set(['Id', 'Type', 'Target', 'TargetMode']);
+        var extraAttributes = child.attributes.filter(function (a) { return a.namespaceUri !== '' || !known.has(a.localName); });
+        var mode = parseTargetMode(attr(child, 'TargetMode'));
+        var relationship = __assign({ id: id, type: requiredAttr(child, 'Type'), target: requiredAttr(child, 'Target'), extraAttributes: extraAttributes, children: child.children }, (mode === undefined ? {} : { targetMode: mode }));
+        items.push(relationship);
+    };
+    try {
+        for (var _b = __values(childElements(root)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            _loop_1(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 { items: items, opaque: opaque };
+}
+export function serializeRelationships(rels) {
+    var children = __spread(rels.items.map(function (item) {
+        var attributes = [
+            { namespaceUri: '', localName: 'Id', prefix: '', value: item.id },
+            { namespaceUri: '', localName: 'Type', prefix: '', value: item.type },
+            { namespaceUri: '', localName: 'Target', prefix: '', value: item.target },
+        ];
+        if (item.targetMode !== undefined) {
+            attributes.push({
+                namespaceUri: '',
+                localName: 'TargetMode',
+                prefix: '',
+                value: item.targetMode,
+            });
+        }
+        attributes.push.apply(attributes, __spread(item.extraAttributes));
+        return {
+            kind: 'element',
+            namespaceUri: RELATIONSHIPS_NAMESPACE,
+            localName: 'Relationship',
+            prefix: '',
+            attributes: attributes,
+            namespaceDeclarations: [],
+            children: item.children,
+        };
+    }), rels.opaque);
+    var root = {
+        kind: 'element',
+        namespaceUri: RELATIONSHIPS_NAMESPACE,
+        localName: 'Relationships',
+        prefix: '',
+        attributes: [],
+        namespaceDeclarations: [{ prefix: '', namespaceUri: RELATIONSHIPS_NAMESPACE }],
+        children: children,
+    };
+    return serializeXml(root);
+}
+export function findOfficeDocumentRelationship(rels) {
+    return rels.items.find(function (item) { return isOfficeDocumentRelationshipType(item.type); });
+}
+export function emptyRelationships() {
+    return { items: [], opaque: [] };
+}
+export function relationshipsWith(items, opaque) {
+    if (opaque === void 0) { opaque = []; }
+    var e_2, _a;
+    var seen = new Set();
+    try {
+        for (var items_1 = __values(items), items_1_1 = items_1.next(); !items_1_1.done; items_1_1 = items_1.next()) {
+            var item = items_1_1.value;
+            if (seen.has(item.id)) {
+                throw new PackageError('package/invalid-relationships', "Duplicate Relationship Id " + item.id);
+            }
+            seen.add(item.id);
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (items_1_1 && !items_1_1.done && (_a = items_1.return)) _a.call(items_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return { items: items, opaque: opaque };
+}

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

@@ -0,0 +1,2 @@
+export { documentBody, isWmlElement, opaqueBlocksFromBody, withOpaqueBody } from './opaque-body';
+export { OpaqueBlock } from './opaque-body';

package/src/core/preservation/index.js

@@ -0,0 +1 @@
+export { documentBody, isWmlElement, opaqueBlocksFromBody, withOpaqueBody } from './opaque-body';

package/src/core/preservation/opaque-body.d.ts

@@ -0,0 +1,16 @@
+import { OpenXmlElement } from '../xml/index';
+/**
+ * Unmodeled body child (EG_ContentBlockContent and anything else). Phase 1
+ * tables module is absent, so `w:tbl` is opaque.
+ */
+export interface OpaqueBlock {
+    readonly type: 'opaque';
+    readonly xml: OpenXmlElement;
+}
+export declare function isWmlElement(element: OpenXmlElement, localName: string): boolean;
+export declare function documentBody(root: OpenXmlElement): OpenXmlElement;
+/**
+ * Every body child element is opaque until a feature claims it (TASK-1009 for `w:p`).
+ */
+export declare function opaqueBlocksFromBody(body: OpenXmlElement): ReadonlyArray<OpaqueBlock>;
+export declare function withOpaqueBody(root: OpenXmlElement, blocks: ReadonlyArray<OpaqueBlock>): OpenXmlElement;

package/src/core/preservation/opaque-body.js

@@ -0,0 +1,69 @@
+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;
+};
+import { PackageError } from '../errors/docx-error';
+import { WML_STRICT_NAMESPACE, WML_TRANSITIONAL_NAMESPACE } from '../xml/index';
+function childElements(element) {
+    return element.children.filter(function (c) { return c.kind === 'element'; });
+}
+function isWmlNamespace(namespaceUri) {
+    return namespaceUri === WML_TRANSITIONAL_NAMESPACE || namespaceUri === WML_STRICT_NAMESPACE;
+}
+export function isWmlElement(element, localName) {
+    return isWmlNamespace(element.namespaceUri) && element.localName === localName;
+}
+export function documentBody(root) {
+    if (!isWmlElement(root, 'document')) {
+        throw new PackageError('package/invalid-document-part', "Expected w:document in " + WML_TRANSITIONAL_NAMESPACE + " or " + WML_STRICT_NAMESPACE + ", found {" + root.namespaceUri + "}" + root.localName);
+    }
+    var body = childElements(root).find(function (c) { return isWmlElement(c, 'body'); });
+    if (body === undefined) {
+        throw new PackageError('package/invalid-document-part', 'w:document is missing w:body');
+    }
+    return body;
+}
+/**
+ * Every body child element is opaque until a feature claims it (TASK-1009 for `w:p`).
+ */
+export function opaqueBlocksFromBody(body) {
+    return childElements(body).map(function (xml) { return ({ type: 'opaque', xml: xml }); });
+}
+export function withOpaqueBody(root, blocks) {
+    var body = documentBody(root);
+    var keptNonElements = body.children.filter(function (c) { return c.kind !== 'element'; });
+    var newBody = __assign({}, body, { children: __spread(blocks.map(function (b) { return b.xml; }), keptNonElements) });
+    return __assign({}, root, { children: root.children.map(function (child) {
+            if (child.kind === 'element' && isWmlElement(child, 'body')) {
+                return newBody;
+            }
+            return child;
+        }) });
+}

package/src/core/registry/block-handlers.d.ts

@@ -0,0 +1,30 @@
+import { WordDocument } from '../../features/document/document';
+import { FeatureId } from './feature-registry';
+import { FeatureBlock } from '../../features/document/feature-block';
+import { BlockContent, Paragraph } from '../../features/document/paragraph';
+import { OpenXmlElement } from '../xml/index';
+/** @public */
+export interface BodyBlockParseContext {
+    assertAttachedParagraph(target: Paragraph): void;
+    owningDocument(): WordDocument;
+}
+/**
+ * @private
+ */
+export declare function detachedBodyBlockParseContext(): BodyBlockParseContext;
+export interface FeatureBlockHandler {
+    readonly featureId: FeatureId;
+    readonly wmlLocalName: string;
+    tryParse(element: OpenXmlElement, ctx: BodyBlockParseContext): FeatureBlock | undefined;
+}
+/** Test hook */
+export declare function resetFeatureBlockHandlers(): void;
+export declare function registerFeatureBlockHandler(handler: FeatureBlockHandler): void;
+export declare function tryParseFeatureBlock(element: OpenXmlElement, ctx: BodyBlockParseContext): BlockContent | undefined;
+/** Feature body item — explicit shape (TS 3.3 does not distribute BodyItem & { type: 'feature' }). */
+export declare type FeatureBodyItem = {
+    readonly type: 'feature';
+    readonly featureId: FeatureId;
+    readonly value: FeatureBlock;
+};
+export declare function serializeFeatureBlock(block: FeatureBodyItem): OpenXmlElement;

package/src/core/registry/block-handlers.js

@@ -0,0 +1,36 @@
+import { DetachedObjectError } from '../errors/docx-error';
+/**
+ * @private
+ */
+export function detachedBodyBlockParseContext() {
+    return {
+        assertAttachedParagraph: function () {
+            return;
+        },
+        owningDocument: function () {
+            throw new DetachedObjectError('This content is not in a document');
+        },
+    };
+}
+var handlersByLocalName = new Map();
+/** Test hook */
+export function resetFeatureBlockHandlers() {
+    handlersByLocalName.clear();
+}
+export function registerFeatureBlockHandler(handler) {
+    handlersByLocalName.set(handler.wmlLocalName, handler);
+}
+export function tryParseFeatureBlock(element, ctx) {
+    var handler = handlersByLocalName.get(element.localName);
+    if (handler === undefined) {
+        return undefined;
+    }
+    var value = handler.tryParse(element, ctx);
+    if (value === undefined) {
+        return undefined;
+    }
+    return { type: 'feature', featureId: handler.featureId, value: value };
+}
+export function serializeFeatureBlock(block) {
+    return block.value.toOpenXml();
+}

package/src/core/registry/create-defaults.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Feature-owned default state attached when {@link WordDocument.create} builds a
+ * fresh, empty document (for example Word's own default `settings.xml`
+ * content, TASK-8027). Mirrors the shape of `materialize-handlers.ts`, but runs
+ * once at construction time instead of on every save, and never runs for
+ * `WordDocument.fromPackage` / `WordDocument.openSync` — a loaded package that has no
+ * state for a given feature keeps round-tripping without gaining any.
+ *
+ * @private
+ */
+import { FeatureMultiPackagePart } from '../../features/document/feature-multi-package-part';
+import { FeaturePackageLevelPart } from '../../features/document/feature-package-level-part';
+import { FeaturePackagePart } from '../../features/document/feature-package-part';
+import { FeatureId } from './feature-registry';
+/**
+ * @private
+ * Minimal document surface required to attach a create-time default part. */
+export interface FeatureCreateDefaultsTarget {
+    setFeaturePart(id: FeatureId, part: FeaturePackagePart | FeatureMultiPackagePart | FeaturePackageLevelPart): void;
+}
+/**
+ * @private
+ */
+export interface FeatureCreateDefaultHandler {
+    readonly featureId: FeatureId;
+    attachCreateDefault(document: FeatureCreateDefaultsTarget): void;
+}
+/**
+ * @private
+ * Test hook */
+export declare function resetFeatureCreateDefaultHandlers(): void;
+/**
+ * @private
+ */
+export declare function registerFeatureCreateDefaultHandler(handler: FeatureCreateDefaultHandler): void;
+/**
+ * @private
+ * Run every registered feature create-default pass, in registration order. */
+export declare function attachFeatureCreateDefaults(document: FeatureCreateDefaultsTarget): void;