@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

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

@@ -0,0 +1,190 @@
+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 { allocateRelationshipId, relationshipsWith, TargetMode } from '../opc/relationships';
+import { partByName, withAddedPart, withContentTypeOverride, withPackageRelationships, withReplacedPart } from '../opc/package';
+import { partNameKey, resolveInternalTarget } from '../opc/part-name';
+var handlers = [];
+/** Test hook */
+export function resetFeaturePackagePartHandlers() {
+    handlers.length = 0;
+}
+export function registerFeaturePackagePartHandler(handler) {
+    handlers.push(handler);
+}
+export function listFeaturePackagePartHandlers() {
+    return handlers;
+}
+export function loadFeaturePackageParts(pkg, limits) {
+    var e_1, _a;
+    var out = new Map();
+    var ctx = { limits: limits };
+    try {
+        for (var handlers_1 = __values(handlers), handlers_1_1 = handlers_1.next(); !handlers_1_1.done; handlers_1_1 = handlers_1.next()) {
+            var handler = handlers_1_1.value;
+            out.set(handler.featureId, handler.loadParts(pkg, ctx));
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (handlers_1_1 && !handlers_1_1.done && (_a = handlers_1.return)) _a.call(handlers_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return out;
+}
+function mergeRelationships(existing, add) {
+    var e_2, _a;
+    if (add.length === 0) {
+        return existing;
+    }
+    var used = new Set(existing.items.map(function (item) { return item.id; }));
+    var next = __spread(existing.items);
+    var _loop_1 = function (rel) {
+        if (next.some(function (item) { return item.type === rel.type && item.target === rel.target; })) {
+            return "continue";
+        }
+        var id = rel.id;
+        while (used.has(id)) {
+            id = allocateRelationshipId(used);
+        }
+        used.add(id);
+        next.push(__assign({}, rel, { id: id }));
+    };
+    try {
+        for (var add_1 = __values(add), add_1_1 = add_1.next(); !add_1_1.done; add_1_1 = add_1.next()) {
+            var rel = add_1_1.value;
+            _loop_1(rel);
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (add_1_1 && !add_1_1.done && (_a = add_1.return)) _a.call(add_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return relationshipsWith(next, existing.opaque);
+}
+export function applyFeaturePackageParts(pkg, featureParts) {
+    var e_3, _a;
+    var next = pkg;
+    try {
+        for (var handlers_2 = __values(handlers), handlers_2_1 = handlers_2.next(); !handlers_2_1.done; handlers_2_1 = handlers_2.next()) {
+            var handler = handlers_2_1.value;
+            var state = featureParts.get(handler.featureId);
+            if (state === undefined || !state.isDirty()) {
+                continue;
+            }
+            next = state.applyToPackage(next);
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (handlers_2_1 && !handlers_2_1.done && (_a = handlers_2.return)) _a.call(handlers_2);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    return next;
+}
+/** @public Helpers for feature modules implementing {@link FeaturePackageLevelPart}. */
+export function findPackageRelatedPart(pkg, relationshipType) {
+    var e_4, _a;
+    try {
+        for (var _b = __values(pkg.packageRelationships.items), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var rel = _c.value;
+            if (rel.type !== relationshipType || rel.targetMode === TargetMode.External) {
+                continue;
+            }
+            var target = resolveInternalTarget(rel.target);
+            var part = partByName(pkg, target);
+            if (part === undefined) {
+                continue;
+            }
+            return { relationship: rel, part: part };
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    return undefined;
+}
+export function replaceOrAddPackageLevelPart(pkg, partNameValue, contentType, data, relationship) {
+    var next = pkg;
+    var existing = partByName(next, partNameValue);
+    if (existing === undefined) {
+        next = withAddedPart(next, { name: partNameValue, contentType: contentType, data: data });
+        next = withContentTypeOverride(next, partNameValue, contentType);
+        if (relationship !== undefined) {
+            next = withPackageRelationships(next, mergeRelationships(next.packageRelationships, [relationship]));
+        }
+        return next;
+    }
+    next = withReplacedPart(next, partNameValue, data);
+    return next;
+}
+export function usedPackagePartNameKeys(pkg) {
+    var e_5, _a;
+    var used = new Set();
+    try {
+        for (var _b = __values(pkg.parts), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var part = _c.value;
+            used.add(partNameKey(part.name));
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    return used;
+}
+export function usedPackageRelationshipIds(pkg) {
+    return new Set(pkg.packageRelationships.items.map(function (item) { return item.id; }));
+}

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

@@ -0,0 +1,24 @@
+import { FeaturePackagePart } from '../../features/document/feature-package-part';
+import { OpcPackage, PackagePart } from '../opc/package';
+import { PartName } from '../opc/part-name';
+import { ResourceLimitOverrides } from '../security/limits';
+import { FeatureId } from './feature-registry';
+/** @public */
+export interface FeaturePartLoadContext {
+    readonly mainPartName: PartName;
+    readonly limits?: ResourceLimitOverrides | undefined;
+}
+export interface FeaturePartHandler {
+    readonly featureId: FeatureId;
+    readonly relationshipTypes: ReadonlyArray<string>;
+    readonly defaultRelativeTarget: string;
+    readonly partName: PartName;
+    readonly contentType: string;
+    loadPart(part: PackagePart | undefined, ctx: FeaturePartLoadContext): FeaturePackagePart;
+}
+/** Test hook */
+export declare function resetFeaturePartHandlers(): void;
+export declare function registerFeaturePartHandler(handler: FeaturePartHandler): void;
+export declare function listFeaturePartHandlers(): ReadonlyArray<FeaturePartHandler>;
+export declare function loadFeatureParts(pkg: OpcPackage, mainPartName: PartName, limits?: ResourceLimitOverrides): Map<FeatureId, FeaturePackagePart>;
+export declare function applyFeatureParts(pkg: OpcPackage, mainPartName: PartName, featureParts: ReadonlyMap<FeatureId, FeaturePackagePart>): OpcPackage;

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

@@ -0,0 +1,172 @@
+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 { allocateRelationshipId, relationshipsWith, TargetMode } from '../opc/relationships';
+import { partByName, relationshipsForPart, withAddedPart, withContentTypeOverride, withPartRelationships, withReplacedPart } from '../opc/package';
+import { resolveInternalTarget } from '../opc/part-name';
+var handlers = [];
+/** Test hook */
+export function resetFeaturePartHandlers() {
+    handlers.length = 0;
+}
+export function registerFeaturePartHandler(handler) {
+    handlers.push(handler);
+}
+export function listFeaturePartHandlers() {
+    return handlers;
+}
+function findRelatedPart(pkg, source, relationshipTypes) {
+    var e_1, _a;
+    var rels = relationshipsForPart(pkg, source);
+    try {
+        for (var _b = __values(rels.items), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var rel = _c.value;
+            if (relationshipTypes.indexOf(rel.type) === -1 || rel.targetMode === TargetMode.External) {
+                continue;
+            }
+            var target = resolveInternalTarget(rel.target, source);
+            return partByName(pkg, target);
+        }
+    }
+    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 undefined;
+}
+export function loadFeatureParts(pkg, mainPartName, limits) {
+    var e_2, _a;
+    var out = new Map();
+    var ctx = { mainPartName: mainPartName, limits: limits };
+    try {
+        for (var handlers_1 = __values(handlers), handlers_1_1 = handlers_1.next(); !handlers_1_1.done; handlers_1_1 = handlers_1.next()) {
+            var handler = handlers_1_1.value;
+            var part = findRelatedPart(pkg, mainPartName, handler.relationshipTypes);
+            out.set(handler.featureId, handler.loadPart(part, ctx));
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (handlers_1_1 && !handlers_1_1.done && (_a = handlers_1.return)) _a.call(handlers_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return out;
+}
+function mergeRelationships(existing, add) {
+    var e_3, _a;
+    if (add.length === 0) {
+        return existing;
+    }
+    var used = new Set(existing.items.map(function (item) { return item.id; }));
+    var next = __spread(existing.items);
+    var _loop_1 = function (rel) {
+        if (next.some(function (item) { return item.type === rel.type && item.target === rel.target; })) {
+            return "continue";
+        }
+        var id = rel.id;
+        while (used.has(id)) {
+            id = allocateRelationshipId(used);
+        }
+        used.add(id);
+        next.push(__assign({}, rel, { id: id }));
+    };
+    try {
+        for (var add_1 = __values(add), add_1_1 = add_1.next(); !add_1_1.done; add_1_1 = add_1.next()) {
+            var rel = add_1_1.value;
+            _loop_1(rel);
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (add_1_1 && !add_1_1.done && (_a = add_1.return)) _a.call(add_1);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    return relationshipsWith(next, existing.opaque);
+}
+export function applyFeatureParts(pkg, mainPartName, featureParts) {
+    var e_4, _a;
+    var next = pkg;
+    try {
+        for (var handlers_2 = __values(handlers), handlers_2_1 = handlers_2.next(); !handlers_2_1.done; handlers_2_1 = handlers_2.next()) {
+            var handler = handlers_2_1.value;
+            var state = featureParts.get(handler.featureId);
+            if (state === undefined || !state.isDirty()) {
+                continue;
+            }
+            var data = state.serialize();
+            var existing = partByName(next, handler.partName);
+            if (existing === undefined) {
+                next = withAddedPart(next, {
+                    name: handler.partName,
+                    contentType: handler.contentType,
+                    data: data,
+                });
+                next = withContentTypeOverride(next, handler.partName, handler.contentType);
+                var rel = {
+                    id: allocateRelationshipId(new Set(__spread(next.packageRelationships.items.map(function (item) { return item.id; }), relationshipsForPart(next, mainPartName).items.map(function (item) { return item.id; })))),
+                    type: handler.relationshipTypes[0] != null ? handler.relationshipTypes[0] : '',
+                    target: handler.defaultRelativeTarget,
+                    extraAttributes: [],
+                    children: [],
+                };
+                var merged = mergeRelationships(relationshipsForPart(next, mainPartName), [rel]);
+                next = withPartRelationships(next, mainPartName, merged);
+                continue;
+            }
+            next = withReplacedPart(next, handler.partName, data);
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (handlers_2_1 && !handlers_2_1.done && (_a = handlers_2.return)) _a.call(handlers_2);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    return next;
+}

package/src/core/registry/run-leaf-handlers.d.ts

@@ -0,0 +1,26 @@
+import { FeatureRunLeaf } from '../../features/document/feature-run-leaf';
+import { OpenXmlElement } from '../xml/index';
+import { FeatureId } from './feature-registry';
+export declare type FeatureRunLeafContent = {
+    readonly type: 'feature';
+    readonly featureId: FeatureId;
+    readonly value: FeatureRunLeaf;
+};
+export interface FeatureRunLeafHandler {
+    readonly featureId: FeatureId;
+    readonly wmlLocalName: string;
+    /**
+     * Element namespace. When omitted, WordprocessingML transitional **or** strict
+     * namespaces match (same as {@link isWml}). When set, the URI must match
+     * exactly (for non-WML roots such as `mc:AlternateContent`).
+     */
+    readonly namespaceUri?: string;
+    tryParse(element: OpenXmlElement): FeatureRunLeaf | undefined;
+}
+/** Test hook */
+export declare function resetFeatureRunLeafHandlers(): void;
+export declare function registerFeatureRunLeafHandler(handler: FeatureRunLeafHandler, options?: {
+    readonly prepend?: boolean;
+}): void;
+export declare function tryParseFeatureRunLeaf(element: OpenXmlElement): FeatureRunLeafContent | undefined;
+export declare function serializeFeatureRunLeaf(leaf: FeatureRunLeafContent): OpenXmlElement;

package/src/core/registry/run-leaf-handlers.js

@@ -0,0 +1,72 @@
+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 { isWml, isWmlNamespace } from '../../features/document/wml';
+var handlersByLocalName = new Map();
+function elementMatchesHandler(element, handler) {
+    if (element.localName !== handler.wmlLocalName) {
+        return false;
+    }
+    if (handler.namespaceUri === undefined) {
+        return isWml(element, handler.wmlLocalName);
+    }
+    // Explicit non-default namespace (e.g. Markup Compatibility).
+    if (isWmlNamespace(handler.namespaceUri)) {
+        return isWmlNamespace(element.namespaceUri) && element.localName === handler.wmlLocalName;
+    }
+    return element.namespaceUri === handler.namespaceUri;
+}
+/** Test hook */
+export function resetFeatureRunLeafHandlers() {
+    handlersByLocalName.clear();
+}
+export function registerFeatureRunLeafHandler(handler, options) {
+    var existing = handlersByLocalName.get(handler.wmlLocalName);
+    if (existing === undefined) {
+        handlersByLocalName.set(handler.wmlLocalName, [handler]);
+        return;
+    }
+    // Charts (and similar owners) prepend so residual drawing can still claim later.
+    if ((options == null ? undefined : options.prepend) === true) {
+        existing.unshift(handler);
+        return;
+    }
+    existing.push(handler);
+}
+export function tryParseFeatureRunLeaf(element) {
+    var e_1, _a;
+    var handlers = handlersByLocalName.get(element.localName);
+    if (handlers === undefined) {
+        return undefined;
+    }
+    try {
+        for (var handlers_1 = __values(handlers), handlers_1_1 = handlers_1.next(); !handlers_1_1.done; handlers_1_1 = handlers_1.next()) {
+            var handler = handlers_1_1.value;
+            if (!elementMatchesHandler(element, handler)) {
+                continue;
+            }
+            var value = handler.tryParse(element);
+            if (value !== undefined) {
+                return { type: 'feature', featureId: handler.featureId, value: value };
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (handlers_1_1 && !handlers_1_1.done && (_a = handlers_1.return)) _a.call(handlers_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return undefined;
+}
+export function serializeFeatureRunLeaf(leaf) {
+    return leaf.value.toOpenXml();
+}

package/src/core/security/limits.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Default resource limits for untrusted packages and XML.
+ * Values are from `.agent/policies/security.md`.
+ */
+/**
+ * ZIP and XML resource limits applied on load.
+ *
+ * Required on the public surface under `stripInternal` because
+ * {@link DEFAULT_RESOURCE_LIMITS} and {@link ResourceLimitOverrides} reference
+ * this type.
+ *
+ * @private
+ */
+export interface ResourceLimits {
+    /** Total uncompressed bytes across ZIP entries. Default 512 MiB. */
+    readonly totalUncompressedSize: number;
+    /** Max inflate ratio per entry. Default 200. */
+    readonly compressionRatio: number;
+    /** Max ZIP entries. Default 10_000. */
+    readonly entryCount: number;
+    /** Max uncompressed size of one part. Default 128 MiB. */
+    readonly singlePartUncompressedSize: number;
+    /** Max XML element nesting. Default 256. */
+    readonly xmlNestingDepth: number;
+    /** Max attributes per element. Default 4096. */
+    readonly xmlAttributeCount: number;
+    /** Max `w:t` / text node length. Default 32 MiB. */
+    readonly textNodeLength: number;
+    /** Max relationships in one relationships part. Default 10_000. */
+    readonly relationshipCountPerPart: number;
+}
+/** @public */
+export declare const DEFAULT_RESOURCE_LIMITS: ResourceLimits;
+/**
+ * Partial override of {@link ResourceLimits}. Unspecified fields keep the defaults.
+ *
+ * @public
+ */
+export declare type ResourceLimitOverrides = Partial<ResourceLimits>;
+export declare function resolveResourceLimits(overrides?: ResourceLimitOverrides): ResourceLimits;

package/src/core/security/limits.js

@@ -0,0 +1,26 @@
+/** @public */
+export var DEFAULT_RESOURCE_LIMITS = {
+    totalUncompressedSize: 512 * 1024 * 1024,
+    compressionRatio: 200,
+    entryCount: 10000,
+    singlePartUncompressedSize: 128 * 1024 * 1024,
+    xmlNestingDepth: 256,
+    xmlAttributeCount: 4096,
+    textNodeLength: 32 * 1024 * 1024,
+    relationshipCountPerPart: 10000,
+};
+export function resolveResourceLimits(overrides) {
+    if (overrides === undefined) {
+        return DEFAULT_RESOURCE_LIMITS;
+    }
+    return {
+        totalUncompressedSize: overrides.totalUncompressedSize != null ? overrides.totalUncompressedSize : DEFAULT_RESOURCE_LIMITS.totalUncompressedSize,
+        compressionRatio: overrides.compressionRatio != null ? overrides.compressionRatio : DEFAULT_RESOURCE_LIMITS.compressionRatio,
+        entryCount: overrides.entryCount != null ? overrides.entryCount : DEFAULT_RESOURCE_LIMITS.entryCount,
+        singlePartUncompressedSize: overrides.singlePartUncompressedSize != null ? overrides.singlePartUncompressedSize : DEFAULT_RESOURCE_LIMITS.singlePartUncompressedSize,
+        xmlNestingDepth: overrides.xmlNestingDepth != null ? overrides.xmlNestingDepth : DEFAULT_RESOURCE_LIMITS.xmlNestingDepth,
+        xmlAttributeCount: overrides.xmlAttributeCount != null ? overrides.xmlAttributeCount : DEFAULT_RESOURCE_LIMITS.xmlAttributeCount,
+        textNodeLength: overrides.textNodeLength != null ? overrides.textNodeLength : DEFAULT_RESOURCE_LIMITS.textNodeLength,
+        relationshipCountPerPart: overrides.relationshipCountPerPart != null ? overrides.relationshipCountPerPart : DEFAULT_RESOURCE_LIMITS.relationshipCountPerPart,
+    };
+}

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

@@ -0,0 +1,7 @@
+export { decodeXmlBytes, parseXml } from './parse';
+export { serializeXml } from './serialize';
+export { XML_NAMESPACE, XMLNS_NAMESPACE, WML_TRANSITIONAL_NAMESPACE, WML_STRICT_NAMESPACE, } from './model';
+/**
+ * @private
+ */
+export { OpenXmlAttribute, OpenXmlChild, OpenXmlElement, OpenXmlText, NamespaceDeclaration, } from './model';

package/src/core/xml/index.js

@@ -0,0 +1,3 @@
+export { decodeXmlBytes, parseXml } from './parse';
+export { serializeXml } from './serialize';
+export { XML_NAMESPACE, XMLNS_NAMESPACE, WML_TRANSITIONAL_NAMESPACE, WML_STRICT_NAMESPACE, } from './model';

package/src/core/xml/model.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Attribute on an {@link OpenXmlElement}. Advanced hatch; unstable.
+ *
+ * @private
+ */
+export interface OpenXmlAttribute {
+    readonly namespaceUri: string;
+    readonly localName: string;
+    readonly prefix: string;
+    readonly value: string;
+}
+/**
+ * `xmlns` declaration on an {@link OpenXmlElement}. Advanced hatch; unstable.
+ *
+ * @private
+ */
+export interface NamespaceDeclaration {
+    readonly prefix: string;
+    readonly namespaceUri: string;
+}
+/**
+ * Child of an {@link OpenXmlElement}. Advanced hatch; unstable.
+ *
+ * @private
+ */
+export declare type OpenXmlChild = OpenXmlElement | OpenXmlText;
+/**
+ * Text node in the XML tree. Advanced hatch; unstable.
+ *
+ * @private
+ */
+export interface OpenXmlText {
+    readonly kind: 'text';
+    readonly value: string;
+}
+/**
+ * Element in the preserved XML tree. Advanced hatch; unstable.
+ *
+ * @private
+ */
+export interface OpenXmlElement {
+    readonly kind: 'element';
+    readonly namespaceUri: string;
+    readonly localName: string;
+    readonly prefix: string;
+    readonly attributes: ReadonlyArray<OpenXmlAttribute>;
+    readonly namespaceDeclarations: ReadonlyArray<NamespaceDeclaration>;
+    readonly children: ReadonlyArray<OpenXmlChild>;
+}
+/**
+ * @private
+ */
+export declare const XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace";
+/**
+ * @private
+ */
+export declare const XMLNS_NAMESPACE = "http://www.w3.org/2000/xmlns/";
+/**
+ * @private
+ */
+export declare const WML_TRANSITIONAL_NAMESPACE = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+/**
+* @private
+* Strict ISO/IEC 29500 WordprocessingML namespace (ECMA-376-1).
+*/
+export declare const WML_STRICT_NAMESPACE = "http://purl.oclc.org/ooxml/wordprocessingml/main";

package/src/core/xml/model.js

@@ -0,0 +1,17 @@
+/**
+ * @private
+ */
+export var XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+/**
+ * @private
+ */
+export var XMLNS_NAMESPACE = 'http://www.w3.org/2000/xmlns/';
+/**
+ * @private
+ */
+export var WML_TRANSITIONAL_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+/**
+* @private
+* Strict ISO/IEC 29500 WordprocessingML namespace (ECMA-376-1).
+*/
+export var WML_STRICT_NAMESPACE = 'http://purl.oclc.org/ooxml/wordprocessingml/main';

package/src/core/xml/parse.d.ts

@@ -0,0 +1,12 @@
+import { ResourceLimitOverrides } from '../security/limits';
+import { OpenXmlElement } from './model';
+/**
+ * Decode OPC/XML part bytes. Supports UTF-8 and UTF-16 (BOM).
+ * Word sometimes writes parts such as `numbering.xml` as UTF-16LE.
+ */
+export declare function decodeXmlBytes(data: Uint8Array): string;
+/**
+ * Parse XML into a preservation DOM. Namespace URI + local name identify elements;
+ * prefixes are stored only for stable serialization. DTD/ENTITY constructs fail closed.
+ */
+export declare function parseXml(xml: string, limitOverrides?: ResourceLimitOverrides): OpenXmlElement;