@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/core/errors/docx-error.js

@@ -0,0 +1,138 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+/**
+ * Base error for every library failure. Consumers switch on {@link DocxError.code}, never on message text.
+ *
+ * @private
+ */
+var DocxError = /** @class */ (function (_super) {
+    __extends(DocxError, _super);
+    function DocxError(code, message, options) {
+        var _newTarget = this.constructor;
+        var _this = _super.call(this, message) || this;
+        _this.name = _newTarget.name;
+        _this.code = code;
+        if (options !== undefined && options.cause !== undefined) {
+            _this.cause = options.cause;
+        }
+        Object.setPrototypeOf(_this, _newTarget.prototype);
+        return _this;
+    }
+    return DocxError;
+}(Error));
+export { DocxError };
+/**
+ * ZIP or OPC package problems.
+ *
+ * @private
+ */
+var PackageError = /** @class */ (function (_super) {
+    __extends(PackageError, _super);
+    function PackageError() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return PackageError;
+}(DocxError));
+export { PackageError };
+/**
+ * Well-formedness, DTD, or XML limit failures.
+ *
+ * @private
+ */
+var XmlError = /** @class */ (function (_super) {
+    __extends(XmlError, _super);
+    function XmlError() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return XmlError;
+}(DocxError));
+export { XmlError };
+/**
+ * Security-limit and untrusted-input failures.
+ *
+ * @private
+ */
+var SecurityError = /** @class */ (function (_super) {
+    __extends(SecurityError, _super);
+    function SecurityError() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return SecurityError;
+}(DocxError));
+export { SecurityError };
+/**
+ * Markup Compatibility MustUnderstand and related failures.
+ *
+ * @private
+ */
+var MarkupCompatibilityError = /** @class */ (function (_super) {
+    __extends(MarkupCompatibilityError, _super);
+    function MarkupCompatibilityError() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return MarkupCompatibilityError;
+}(DocxError));
+export { MarkupCompatibilityError };
+/**
+ * Exhaustiveness failure for a content union the compiler should have rejected.
+ *
+ * @private
+ */
+var UnsupportedContentError = /** @class */ (function (_super) {
+    __extends(UnsupportedContentError, _super);
+    function UnsupportedContentError(message, options) {
+        return _super.call(this, 'content/unsupported', message, options) || this;
+    }
+    return UnsupportedContentError;
+}(DocxError));
+export { UnsupportedContentError };
+/**
+ * Mutation of an object after it was removed from its document.
+ *
+ * @private
+ */
+var DetachedObjectError = /** @class */ (function (_super) {
+    __extends(DetachedObjectError, _super);
+    function DetachedObjectError(message, options) {
+        return _super.call(this, 'model/detached-object', message, options) || this;
+    }
+    return DetachedObjectError;
+}(DocxError));
+export { DetachedObjectError };
+/**
+ * API argument is missing or empty where a value is required.
+ *
+ * @private
+ */
+var InvalidArgumentError = /** @class */ (function (_super) {
+    __extends(InvalidArgumentError, _super);
+    function InvalidArgumentError(message, options) {
+        return _super.call(this, 'argument/invalid', message, options) || this;
+    }
+    return InvalidArgumentError;
+}(DocxError));
+export { InvalidArgumentError };
+/**
+ * Underlying filesystem or byte I/O failure wrapped for consumers.
+ *
+ * @private
+ */
+var IoError = /** @class */ (function (_super) {
+    __extends(IoError, _super);
+    function IoError(message, options) {
+        return _super.call(this, 'io/error', message, options) || this;
+    }
+    return IoError;
+}(DocxError));
+export { IoError };

package/src/core/errors/error-codes.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Stable machine-readable error identifiers (`area/reason`).
+ *
+ * Consumers switch on {@link DocxError.code}; this union is public API (R7.2).
+ *
+ * @private
+ */
+export declare type DocxErrorCode = 'content/invalid-baseline-alignment' | 'content/invalid-shading-pattern' | 'content/invalid-text-direction' | 'content/invalid-bookmark' | 'content/invalid-editable-range' | 'content/invalid-break' | 'content/invalid-chart' | 'content/invalid-field' | 'content/invalid-header-footer-reference' | 'content/invalid-image' | 'content/invalid-image-caption-format' | 'content/invalid-image-caption-name' | 'content/invalid-image-caption-position' | 'content/invalid-ink' | 'content/invalid-ole-object' | 'content/invalid-shape' | 'content/invalid-num-id' | 'content/invalid-list-level' | 'content/invalid-style-id' | 'content/no-preceding-list' | 'content/not-in-list' | 'content/unresolved-numbering-style' | 'content/unknown-bookmark' | 'content/unknown-editable-range' | 'content/unknown-comment' | 'content/unknown-image' | 'content/unknown-ink-part' | 'content/unknown-note' | 'content/unsupported' | 'feature/invalid-id' | 'feature/not-registered' | 'argument/invalid' | 'io/error' | 'model/detached-object' | 'package/duplicate-zip-entry' | 'package/encrypted' | 'package/invalid-content-types' | 'package/invalid-document-part' | 'package/invalid-part-name' | 'package/invalid-relationships' | 'package/invalid-relationship-id' | 'package/invalid-zip' | 'package/missing-part' | 'security/entry-count' | 'security/limit-exceeded' | 'security/part-size' | 'security/relationship-count' | 'security/total-uncompressed' | 'security/zip-bomb' | 'styles/circular-based-on' | 'styles/circular-link' | 'styles/duplicate-style' | 'styles/invalid-based-on' | 'styles/invalid-link' | 'styles/invalid-type-for-target' | 'styles/undefined-style' | 'xml/dtd-forbidden' | 'xml/malformed' | 'xml/markup-compatibility';

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

@@ -0,0 +1,10 @@
+/**
+ * Typed errors thrown by the core library.
+ *
+ * @packageDocumentation
+ */
+/**
+ * @private
+ */
+export { DetachedObjectError, DocxError, InvalidArgumentError, IoError, MarkupCompatibilityError, PackageError, SecurityError, UnsupportedContentError, XmlError, } from './docx-error';
+export { DocxErrorCode } from './error-codes';

package/src/core/errors/index.js

@@ -0,0 +1,9 @@
+/**
+ * Typed errors thrown by the core library.
+ *
+ * @packageDocumentation
+ */
+/**
+ * @private
+ */
+export { DetachedObjectError, DocxError, InvalidArgumentError, IoError, MarkupCompatibilityError, PackageError, SecurityError, UnsupportedContentError, XmlError, } from './docx-error';

package/src/core/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Core package infrastructure: errors, registry, OPC, XML, zip,
+ * Markup Compatibility, and preservation.
+ *
+ */
+export * from './errors/index';
+export * from './registry/index';
+export * from './opc/index';
+export * from './xml/index';
+export * from './zip/index';
+export * from './mc/index';
+export * from './preservation/index';

package/src/core/index.js

@@ -0,0 +1,12 @@
+/**
+ * Core package infrastructure: errors, registry, OPC, XML, zip,
+ * Markup Compatibility, and preservation.
+ *
+ */
+export * from './errors/index';
+export * from './registry/index';
+export * from './opc/index';
+export * from './xml/index';
+export * from './zip/index';
+export * from './mc/index';
+export * from './preservation/index';

package/src/core/mc/alternate-content.d.ts

@@ -0,0 +1,7 @@
+import { OpenXmlElement } from '../xml/index';
+export declare function isMarkupCompatibilityElement(element: OpenXmlElement, localName: string): boolean;
+export declare function isAlternateContent(element: OpenXmlElement): boolean;
+/**
+ * Structural checks from ECMA-376-3 §7.5–§7.7 without flattening the tree.
+ */
+export declare function assertAlternateContentShape(element: OpenXmlElement): void;

package/src/core/mc/alternate-content.js

@@ -0,0 +1,67 @@
+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 { MarkupCompatibilityError } from '../errors/docx-error';
+import { MARKUP_COMPATIBILITY_NAMESPACE } from './namespaces';
+export function isMarkupCompatibilityElement(element, localName) {
+    return element.namespaceUri === MARKUP_COMPATIBILITY_NAMESPACE && element.localName === localName;
+}
+export function isAlternateContent(element) {
+    return isMarkupCompatibilityElement(element, 'AlternateContent');
+}
+function childElements(element) {
+    return element.children.filter(function (c) { return c.kind === 'element'; });
+}
+/**
+ * Structural checks from ECMA-376-3 §7.5–§7.7 without flattening the tree.
+ */
+export function assertAlternateContentShape(element) {
+    var e_1, _a;
+    if (!isAlternateContent(element)) {
+        return;
+    }
+    var mcChildren = childElements(element).filter(function (c) { return c.namespaceUri === MARKUP_COMPATIBILITY_NAMESPACE; });
+    var seenFallback = false;
+    var choiceCount = 0;
+    try {
+        for (var mcChildren_1 = __values(mcChildren), mcChildren_1_1 = mcChildren_1.next(); !mcChildren_1_1.done; mcChildren_1_1 = mcChildren_1.next()) {
+            var child = mcChildren_1_1.value;
+            if (child.localName === 'Choice') {
+                if (seenFallback) {
+                    throw new MarkupCompatibilityError('xml/markup-compatibility', 'Choice must not follow Fallback (ECMA-376-3 §7.5)');
+                }
+                var requires = child.attributes.find(function (a) { return a.localName === 'Requires' && a.namespaceUri === ''; });
+                if (requires === undefined || requires.value.trim().length === 0) {
+                    throw new MarkupCompatibilityError('xml/markup-compatibility', 'Choice Requires is required and must list one or more prefixes (ECMA-376-3 §7.6)');
+                }
+                choiceCount += 1;
+                continue;
+            }
+            if (child.localName === 'Fallback') {
+                if (seenFallback) {
+                    throw new MarkupCompatibilityError('xml/markup-compatibility', 'AlternateContent may have at most one Fallback (ECMA-376-3 §7.5)');
+                }
+                seenFallback = true;
+                continue;
+            }
+            throw new MarkupCompatibilityError('xml/markup-compatibility', "Unexpected Markup Compatibility child " + child.localName + " of AlternateContent (ECMA-376-3 \u00A77.5)");
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (mcChildren_1_1 && !mcChildren_1_1.done && (_a = mcChildren_1.return)) _a.call(mcChildren_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    if (choiceCount < 1) {
+        throw new MarkupCompatibilityError('xml/markup-compatibility', 'AlternateContent shall contain one or more Choice children (ECMA-376-3 §7.5)');
+    }
+}

package/src/core/mc/attributes.d.ts

@@ -0,0 +1,24 @@
+import { OpenXmlElement } from '../xml/index';
+export interface BoundPrefix {
+    readonly prefix: string;
+    readonly namespaceUri: string;
+}
+export interface ProcessContentToken {
+    readonly prefix: string;
+    readonly localNameOrStar: string;
+    readonly namespaceUri: string;
+}
+export interface MarkupCompatibilityAttributes {
+    readonly ignorable: ReadonlyArray<BoundPrefix>;
+    readonly mustUnderstand: ReadonlyArray<BoundPrefix>;
+    readonly processContent: ReadonlyArray<ProcessContentToken>;
+    readonly preserveElements: ReadonlyArray<BoundPrefix>;
+    readonly preserveAttributes: ReadonlyArray<BoundPrefix>;
+}
+/**
+ * Read MC attributes on one element. Prefixes are resolved with the in-scope map
+ * (ECMA-376-3 §7.2–§7.4). PreserveElements/PreserveAttributes are treated as
+ * prefix lists when present; they are not defined in the local Part 3 5th-edition
+ * text (see TASK-1007 notes).
+ */
+export declare function readMarkupCompatibilityAttributes(element: OpenXmlElement, scope: ReadonlyMap<string, string>): MarkupCompatibilityAttributes;

package/src/core/mc/attributes.js

@@ -0,0 +1,82 @@
+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 { MarkupCompatibilityError } from '../errors/docx-error';
+import { MARKUP_COMPATIBILITY_NAMESPACE } from './namespaces';
+function mcAttr(element, localName) {
+    return element.attributes.find(function (a) { return a.localName === localName && a.namespaceUri === MARKUP_COMPATIBILITY_NAMESPACE; });
+}
+function splitTokens(value) {
+    return value.trim().length === 0 ? [] : value.trim().split(/\s+/);
+}
+function bindPrefix(prefix, scope, what) {
+    var namespaceUri = scope.get(prefix);
+    if (namespaceUri === undefined) {
+        throw new MarkupCompatibilityError('xml/markup-compatibility', what + " prefix \"" + prefix + "\" is not bound to an in-scope namespace (ECMA-376-3 \u00A77.2)");
+    }
+    if (namespaceUri === MARKUP_COMPATIBILITY_NAMESPACE) {
+        throw new MarkupCompatibilityError('xml/markup-compatibility', what + " prefix \"" + prefix + "\" is bound to the Markup Compatibility namespace");
+    }
+    return { prefix: prefix, namespaceUri: namespaceUri };
+}
+function bindPrefixList(value, scope, what) {
+    if (value === undefined) {
+        return [];
+    }
+    return splitTokens(value).map(function (prefix) { return bindPrefix(prefix, scope, what); });
+}
+function parseProcessContent(value, scope) {
+    var e_1, _a;
+    if (value === undefined) {
+        return [];
+    }
+    var tokens = [];
+    try {
+        for (var _b = __values(splitTokens(value)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var token = _c.value;
+            var colon = token.indexOf(':');
+            if (colon <= 0 || colon === token.length - 1) {
+                throw new MarkupCompatibilityError('xml/markup-compatibility', "ProcessContent token must be prefix:local or prefix:* (ECMA-376-3 \u00A77.3), got \"" + token + "\"");
+            }
+            var prefix = token.slice(0, colon);
+            var localNameOrStar = token.slice(colon + 1);
+            var bound = bindPrefix(prefix, scope, 'ProcessContent');
+            tokens.push({
+                prefix: prefix,
+                localNameOrStar: localNameOrStar,
+                namespaceUri: bound.namespaceUri,
+            });
+        }
+    }
+    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 tokens;
+}
+/**
+ * Read MC attributes on one element. Prefixes are resolved with the in-scope map
+ * (ECMA-376-3 §7.2–§7.4). PreserveElements/PreserveAttributes are treated as
+ * prefix lists when present; they are not defined in the local Part 3 5th-edition
+ * text (see TASK-1007 notes).
+ */
+export function readMarkupCompatibilityAttributes(element, scope) {
+    var __ts33_0, __ts33_1, __ts33_2, __ts33_3, __ts33_4;
+    return {
+        ignorable: bindPrefixList(((__ts33_0 = mcAttr(element, 'Ignorable')), __ts33_0 == null ? undefined : __ts33_0.value), scope, 'Ignorable'),
+        mustUnderstand: bindPrefixList(((__ts33_1 = mcAttr(element, 'MustUnderstand')), __ts33_1 == null ? undefined : __ts33_1.value), scope, 'MustUnderstand'),
+        processContent: parseProcessContent(((__ts33_2 = mcAttr(element, 'ProcessContent')), __ts33_2 == null ? undefined : __ts33_2.value), scope),
+        preserveElements: bindPrefixList(((__ts33_3 = mcAttr(element, 'PreserveElements')), __ts33_3 == null ? undefined : __ts33_3.value), scope, 'PreserveElements'),
+        preserveAttributes: bindPrefixList(((__ts33_4 = mcAttr(element, 'PreserveAttributes')), __ts33_4 == null ? undefined : __ts33_4.value), scope, 'PreserveAttributes'),
+    };
+}

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

@@ -0,0 +1,7 @@
+export { MARKUP_COMPATIBILITY_NAMESPACE } from './namespaces';
+export { inScopeNamespaces } from './scope';
+export { readMarkupCompatibilityAttributes } from './attributes';
+export { BoundPrefix, MarkupCompatibilityAttributes, ProcessContentToken, } from './attributes';
+export { assertAlternateContentShape, isAlternateContent, isMarkupCompatibilityElement, } from './alternate-content';
+export { inspectMarkupCompatibility, MarkupConformance } from './inspect';
+export { InspectMarkupCompatibilityOptions } from './inspect';

package/src/core/mc/index.js

@@ -0,0 +1,5 @@
+export { MARKUP_COMPATIBILITY_NAMESPACE } from './namespaces';
+export { inScopeNamespaces } from './scope';
+export { readMarkupCompatibilityAttributes } from './attributes';
+export { assertAlternateContentShape, isAlternateContent, isMarkupCompatibilityElement, } from './alternate-content';
+export { inspectMarkupCompatibility, MarkupConformance } from './inspect';

package/src/core/mc/inspect.d.ts

@@ -0,0 +1,16 @@
+import { OpenXmlElement } from '../xml/index';
+export declare const MarkupConformance: {
+    Lax: "lax";
+    Strict: "strict";
+};
+export declare type MarkupConformance = (typeof MarkupConformance)[keyof typeof MarkupConformance];
+export interface InspectMarkupCompatibilityOptions {
+    readonly conformance?: MarkupConformance;
+    readonly understoodNamespaces?: ReadonlySet<string>;
+}
+/**
+ * Walk a preservation DOM: resolve MC prefixes, keep AlternateContent intact,
+ * and optionally fail MustUnderstand in strict mode. Never deletes Ignorable
+ * markup. Depth of MC elements is already counted by the XML parser.
+ */
+export declare function inspectMarkupCompatibility(root: OpenXmlElement, options?: InspectMarkupCompatibilityOptions): void;

package/src/core/mc/inspect.js

@@ -0,0 +1,148 @@
+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 { MarkupCompatibilityError } from '../errors/docx-error';
+import { readMarkupCompatibilityAttributes } from './attributes';
+import { assertAlternateContentShape } from './alternate-content';
+import { MARKUP_COMPATIBILITY_NAMESPACE } from './namespaces';
+import { inScopeNamespaces } from './scope';
+function bindRequires(choice, scope) {
+    var e_1, _a;
+    var requires = choice.attributes.find(function (a) { return a.localName === 'Requires' && a.namespaceUri === ''; });
+    if (requires === undefined) {
+        return;
+    }
+    var tokens = requires.value.trim().length === 0 ? [] : requires.value.trim().split(/\s+/);
+    try {
+        for (var tokens_1 = __values(tokens), tokens_1_1 = tokens_1.next(); !tokens_1_1.done; tokens_1_1 = tokens_1.next()) {
+            var prefix = tokens_1_1.value;
+            var namespaceUri = scope.get(prefix);
+            if (namespaceUri === undefined) {
+                throw new MarkupCompatibilityError('xml/markup-compatibility', "Choice Requires prefix \"" + prefix + "\" is not bound (ECMA-376-3 \u00A77.6)");
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (tokens_1_1 && !tokens_1_1.done && (_a = tokens_1.return)) _a.call(tokens_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+}
+export var MarkupConformance = {
+    Lax: 'lax',
+    Strict: 'strict',
+};
+function childElements(element) {
+    return element.children.filter(function (c) { return c.kind === 'element'; });
+}
+function walk(element, ancestors, ignorableUris, options) {
+    var e_2, _a, e_3, _b, e_4, _c, e_5, _d;
+    var chain = __spread(ancestors, [element]);
+    var scope = inScopeNamespaces(chain);
+    var mc = readMarkupCompatibilityAttributes(element, scope);
+    try {
+        for (var _e = __values(mc.ignorable), _f = _e.next(); !_f.done; _f = _e.next()) {
+            var item = _f.value;
+            ignorableUris.add(item.namespaceUri);
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    try {
+        for (var _g = __values(mc.processContent), _h = _g.next(); !_h.done; _h = _g.next()) {
+            var token = _h.value;
+            if (!ignorableUris.has(token.namespaceUri)) {
+                throw new MarkupCompatibilityError('xml/markup-compatibility', "ProcessContent namespace " + token.namespaceUri + " is not declared Ignorable (ECMA-376-3 \u00A77.3)");
+            }
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    if (options.conformance === MarkupConformance.Strict) {
+        try {
+            for (var _j = __values(mc.mustUnderstand), _k = _j.next(); !_k.done; _k = _j.next()) {
+                var item = _k.value;
+                if (!options.understoodNamespaces.has(item.namespaceUri)) {
+                    throw new MarkupCompatibilityError('xml/markup-compatibility', "MustUnderstand namespace is not understood: " + item.namespaceUri + " (ECMA-376-3 \u00A77.4)");
+                }
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+    }
+    assertAlternateContentShape(element);
+    if (element.namespaceUri === MARKUP_COMPATIBILITY_NAMESPACE && element.localName === 'Choice') {
+        bindRequires(element, scope);
+    }
+    try {
+        for (var _l = __values(childElements(element)), _m = _l.next(); !_m.done; _m = _l.next()) {
+            var child = _m.value;
+            walk(child, chain, ignorableUris, options);
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (_m && !_m.done && (_d = _l.return)) _d.call(_l);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+}
+/**
+ * Walk a preservation DOM: resolve MC prefixes, keep AlternateContent intact,
+ * and optionally fail MustUnderstand in strict mode. Never deletes Ignorable
+ * markup. Depth of MC elements is already counted by the XML parser.
+ */
+export function inspectMarkupCompatibility(root, options) {
+    var __ts33_0, __ts33_1;
+    var understood = new Set(((__ts33_0 = options == null ? undefined : options.understoodNamespaces), __ts33_0 != null ? __ts33_0 : []));
+    understood.add(MARKUP_COMPATIBILITY_NAMESPACE);
+    walk(root, [], new Set(), {
+        conformance: ((__ts33_1 = options == null ? undefined : options.conformance), __ts33_1 != null ? __ts33_1 : MarkupConformance.Lax),
+        understoodNamespaces: understood,
+    });
+}

package/src/core/mc/namespaces.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Markup Compatibility namespace (ECMA-376-3 examples in §7).
+ */
+export declare const MARKUP_COMPATIBILITY_NAMESPACE = "http://schemas.openxmlformats.org/markup-compatibility/2006";

package/src/core/mc/namespaces.js

@@ -0,0 +1,4 @@
+/**
+ * Markup Compatibility namespace (ECMA-376-3 examples in §7).
+ */
+export var MARKUP_COMPATIBILITY_NAMESPACE = 'http://schemas.openxmlformats.org/markup-compatibility/2006';

package/src/core/mc/scope.d.ts

@@ -0,0 +1,6 @@
+import { OpenXmlElement } from '../xml/index';
+/**
+ * In-scope prefix → namespace URI, including the default namespace as `""`.
+ * Built-in `xml` / `xmlns` prefixes are always present.
+ */
+export declare function inScopeNamespaces(chain: ReadonlyArray<OpenXmlElement>): ReadonlyMap<string, string>;

package/src/core/mc/scope.js

@@ -0,0 +1,47 @@
+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 { XML_NAMESPACE, XMLNS_NAMESPACE } from '../xml/model';
+/**
+ * In-scope prefix → namespace URI, including the default namespace as `""`.
+ * Built-in `xml` / `xmlns` prefixes are always present.
+ */
+export function inScopeNamespaces(chain) {
+    var e_1, _a, e_2, _b;
+    var map = new Map();
+    map.set('xml', XML_NAMESPACE);
+    map.set('xmlns', XMLNS_NAMESPACE);
+    try {
+        for (var chain_1 = __values(chain), chain_1_1 = chain_1.next(); !chain_1_1.done; chain_1_1 = chain_1.next()) {
+            var element = chain_1_1.value;
+            try {
+                for (var _c = __values(element.namespaceDeclarations), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var decl = _d.value;
+                    map.set(decl.prefix, decl.namespaceUri);
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (chain_1_1 && !chain_1_1.done && (_a = chain_1.return)) _a.call(chain_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return map;
+}