@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/ole-object/typed-dom.js

@@ -0,0 +1,595 @@
+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;
+};
+/**
+ * OLE object typed DOM (TASK-8053): enums, wire-form model, and attribute /
+ * child patch codec over the stored `w:object` element.
+ *
+ * One semantic model over two schema-backed wire encodings:
+ * - **office** — `o:OLEObject` child (transitional `vml-officeDrawing.xsd`
+ *   `CT_OLEObject`, ECMA-376-4 §19.2.2.20); what Word writes today.
+ * - **wml** — `w:objectEmbed` / `w:objectLink` children (transitional
+ *   `wml.xsd` `CT_ObjectEmbed` line 1198 / `CT_ObjectLink` line 1211;
+ *   ECMA-376-1 §17.3.3.20/§17.3.3.21).
+ *
+ * Non-negotiable (`.agent/policies/security.md`): this DOM never executes,
+ * activates, or fetches anything. Payload bytes are not surfaced here
+ * (TASK-8054 owns that decision under human GO Q1).
+ *
+ * @packageDocumentation
+ */
+import { pointToTwips, twipsToPoint } from '../document/length';
+import { objectValues } from '../../core/compat/object-compat';
+import { DocxError } from '../../core/errors/index';
+/**
+ * Office namespace for VML Office Drawing / `o:OLEObject`.
+ *
+ * Source: transitional `vml-officeDrawing.xsd` `targetNamespace`
+ * (`urn:schemas-microsoft-com:office:office`).
+ */
+export var OFFICE_OLE_NAMESPACE = 'urn:schemas-microsoft-com:office:office';
+/** WordprocessingML transitional namespace (local constant to avoid cycles). */
+var WML_NS = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+/**
+ * Kind of OLE object connection (`o:OLEObject/@Type`, `ST_OLEType`:
+ * `Embed` | `Link`; the WML-native form encodes the same choice as
+ * `w:objectEmbed` vs `w:objectLink` element selection).
+ *
+ * @private
+ */
+export var OleLinkType = {
+    /** Embedded storage part (`word/embeddings/*.bin`). */
+    Embed: 'embed',
+    /** External link target (stored, never fetched). */
+    Link: 'link',
+};
+/**
+ * Visual representation of the object (`o:OLEObject/@DrawAspect`,
+ * `ST_OLEDrawAspect`: `Content` | `Icon`; WML-native `drawAspect` uses the
+ * lowercase tokens `content` | `icon` — both decode to this enum).
+ *
+ * @private
+ */
+export var OleDrawAspect = {
+    /** Render the object's current content. */
+    Content: 'content',
+    /** Render a placeholder icon. */
+    Icon: 'icon',
+};
+/**
+ * Link refresh mode (`o:OLEObject/@UpdateMode`, `ST_OLEUpdateMode`:
+ * `Always` | `OnCall`; WML-native `updateMode`: `always` | `onCall`).
+ * Meaningful for linked objects only.
+ *
+ * @private
+ */
+export var OleUpdateMode = {
+    /** Update automatically. */
+    Always: 'always',
+    /** Update on caller request. */
+    OnCall: 'onCall',
+};
+/** Wire-form discriminant for the office (`o:OLEObject`) encoding. */
+var OFFICE_OLE_ELEMENT = 'OLEObject';
+/** Wire-form discriminants for the WML-native encodings. */
+var WML_EMBED_ELEMENT = 'objectEmbed';
+var WML_LINK_ELEMENT = 'objectLink';
+/** `ST_OLEType` tokens (office form, capitalized). */
+var OLE_TYPE_TOKENS = { Embed: 'Embed', Link: 'Link' };
+/** `ST_OLEDrawAspect` tokens (office form, capitalized). */
+var OLE_ASPECT_TOKENS = { Content: 'Content', Icon: 'Icon' };
+/** `ST_OLEUpdateMode` tokens (office form, capitalized). */
+var OLE_UPDATE_TOKENS = { Always: 'Always', OnCall: 'OnCall' };
+/** WML-native lowercase tokens (`ST_ObjectDrawAspect` / `ST_ObjectUpdateMode`). */
+var WML_ASPECT_TOKENS = { Content: 'content', Icon: 'icon' };
+var WML_UPDATE_TOKENS = { Always: 'always', OnCall: 'onCall' };
+/** Element child of an {@link OpenXmlElement}. */
+function elementChildren(el) {
+    return el.children.filter(function (c) { return c.kind === 'element'; });
+}
+/** Attribute value by namespace + local name. */
+function attributeValue(el, namespaceUri, localName) {
+    var __ts33_0;
+    return ((__ts33_0 = el.attributes.find(function (a) { return a.namespaceUri === namespaceUri && a.localName === localName; })), __ts33_0 == null ? undefined : __ts33_0.value);
+}
+/**
+ * Resolve the OLE child of a `w:object` element and its wire form.
+ * Returns `undefined` when no recognized OLE child exists (the element
+ * stays opaque per the TASK-8022 rule).
+ *
+ * @private
+ */
+export function resolveOleChild(element) {
+    var e_1, _a;
+    try {
+        for (var _b = __values(elementChildren(element)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (child.namespaceUri === OFFICE_OLE_NAMESPACE &&
+                child.localName === OFFICE_OLE_ELEMENT) {
+                return { oleElement: child, wireForm: 'office' };
+            }
+            if (child.namespaceUri === WML_NS &&
+                (child.localName === WML_EMBED_ELEMENT || child.localName === WML_LINK_ELEMENT)) {
+                return { oleElement: child, wireForm: 'wml' };
+            }
+        }
+    }
+    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;
+}
+/** Initial DOM state parsed at load (no mutation). */
+export function parseOleObjectDomState(element, oleElement, wireForm) {
+    return { element: element, oleElement: oleElement, wireForm: wireForm };
+}
+// ---------------------------------------------------------------------------
+// Read codec (office + wml forms)
+// ---------------------------------------------------------------------------
+/** Read `@Type` / element choice as a typed link kind. */
+export function readLinkType(state) {
+    if (state.wireForm === 'wml') {
+        return state.oleElement.localName === WML_LINK_ELEMENT ? OleLinkType.Link : OleLinkType.Embed;
+    }
+    var type = attributeValue(state.oleElement, '', 'Type');
+    if (type === OLE_TYPE_TOKENS.Link) {
+        return OleLinkType.Link;
+    }
+    if (type === OLE_TYPE_TOKENS.Embed) {
+        return OleLinkType.Embed;
+    }
+    return undefined; // unknown/malformed stays residual
+}
+/** Read `@ProgID` (office) / `@progId` (wml). */
+export function readProgId(state) {
+    return state.wireForm === 'wml'
+        ? attributeValue(state.oleElement, '', 'progId')
+        : attributeValue(state.oleElement, '', 'ProgID');
+}
+/** Read `@ShapeID` (office) / `@shapeId` (wml). */
+export function readShapeId(state) {
+    return state.wireForm === 'wml'
+        ? attributeValue(state.oleElement, '', 'shapeId')
+        : attributeValue(state.oleElement, '', 'ShapeID');
+}
+/** Read `@DrawAspect` / `@drawAspect` in either casing. */
+export function readDrawAspect(state) {
+    if (state.wireForm === 'wml') {
+        var v_1 = attributeValue(state.oleElement, '', 'drawAspect');
+        if (v_1 === WML_ASPECT_TOKENS.Content) {
+            return OleDrawAspect.Content;
+        }
+        if (v_1 === WML_ASPECT_TOKENS.Icon) {
+            return OleDrawAspect.Icon;
+        }
+        return undefined;
+    }
+    var v = attributeValue(state.oleElement, '', 'DrawAspect');
+    if (v === OLE_ASPECT_TOKENS.Content) {
+        return OleDrawAspect.Content;
+    }
+    if (v === OLE_ASPECT_TOKENS.Icon) {
+        return OleDrawAspect.Icon;
+    }
+    return undefined;
+}
+/**
+ * Read `@ObjectID` (office form only; no WML-native counterpart — Office
+ * regenerates it per save and does not support it on linked objects,
+ * [MS-OI29500] §2.1.1834).
+ */
+export function readObjectId(state) {
+    return state.wireForm === 'wml'
+        ? undefined
+        : attributeValue(state.oleElement, '', 'ObjectID');
+}
+/** Read `@UpdateMode` (office) / required `@updateMode` (wml link). */
+export function readUpdateMode(state) {
+    if (state.wireForm === 'wml') {
+        if (state.oleElement.localName !== WML_LINK_ELEMENT) {
+            return undefined;
+        }
+        var v_2 = attributeValue(state.oleElement, '', 'updateMode');
+        if (v_2 === WML_UPDATE_TOKENS.Always) {
+            return OleUpdateMode.Always;
+        }
+        if (v_2 === WML_UPDATE_TOKENS.OnCall) {
+            return OleUpdateMode.OnCall;
+        }
+        return undefined;
+    }
+    var v = attributeValue(state.oleElement, '', 'UpdateMode');
+    if (v === OLE_UPDATE_TOKENS.Always) {
+        return OleUpdateMode.Always;
+    }
+    if (v === OLE_UPDATE_TOKENS.OnCall) {
+        return OleUpdateMode.OnCall;
+    }
+    return undefined;
+}
+/** `ST_TrueFalseBlank` parse: t/true/on → true; f/false/off/0 → false. */
+function parseTrueFalseBlank(value) {
+    var normalized = value.trim().toLowerCase();
+    if (normalized === 't' || normalized === 'true' || normalized === 'on') {
+        return true;
+    }
+    if (normalized === 'f' || normalized === 'false' || normalized === 'off' || normalized === '0') {
+        return false;
+    }
+    return undefined;
+}
+/** True when the attribute value is the explicit-false `ST_TrueFalseBlank` form. */
+function isExplicitFalse(value) {
+    var normalized = value.trim().toLowerCase();
+    return (normalized === 'f' || normalized === 'false' || normalized === 'off' || normalized === '0');
+}
+/**
+ * Read `o:LockedField` child (office) / `@lockedField` (wml link).
+ * Returns `undefined` when absent or unparseable (residual).
+ */
+export function readLockedField(state) {
+    if (state.wireForm === 'wml') {
+        if (state.oleElement.localName !== WML_LINK_ELEMENT) {
+            return undefined;
+        }
+        var v = attributeValue(state.oleElement, '', 'lockedField');
+        return v === undefined ? undefined : parseTrueFalseBlank(v);
+    }
+    var child = elementChildren(state.oleElement).find(function (c) { return c.namespaceUri === OFFICE_OLE_NAMESPACE && c.localName === 'LockedField'; });
+    if (child === undefined) {
+        return undefined;
+    }
+    var text = child.children.find(function (c) { return c.kind === 'text'; });
+    if (text === undefined) {
+        // `<o:LockedField/>` — blank parses as true per ST_TrueFalseBlank.
+        return true;
+    }
+    return parseTrueFalseBlank(text.value);
+}
+/** Read `o:LinkType` child (office form only; `ST_OLELinkType` is a string). */
+export function readLinkTypeDescription(state) {
+    if (state.wireForm !== 'office') {
+        return undefined;
+    }
+    var child = elementChildren(state.oleElement).find(function (c) { return c.namespaceUri === OFFICE_OLE_NAMESPACE && c.localName === 'LinkType'; });
+    var text = (child == null ? undefined : child.children).find(function (c) { return c.kind === 'text'; });
+    return text == null ? undefined : text.value;
+}
+/** Read `o:FieldCodes` child (office) / `@fieldCodes` (wml). */
+export function readFieldCodes(state) {
+    if (state.wireForm === 'wml') {
+        return attributeValue(state.oleElement, '', 'fieldCodes');
+    }
+    var child = elementChildren(state.oleElement).find(function (c) { return c.namespaceUri === OFFICE_OLE_NAMESPACE && c.localName === 'FieldCodes'; });
+    var text = (child == null ? undefined : child.children).find(function (c) { return c.kind === 'text'; });
+    return text == null ? undefined : text.value;
+}
+/**
+ * Parse an `ST_TwipsMeasure` value (`N` twips or `Npt` points) into points.
+ * Wire conversion happens only at this boundary.
+ */
+function parseTwipsMeasureAsPoints(value) {
+    var trimmed = value.trim();
+    if (trimmed.endsWith('pt')) {
+        var pts = Number(trimmed.slice(0, -2));
+        return Number.isFinite(pts) ? pts : undefined;
+    }
+    var twips = Number(trimmed);
+    return Number.isFinite(twips) ? twipsToPoint(twips) : undefined;
+}
+/**
+ * Read `w:object/@dxaOrig` as points (accepts WML-qualified and unqualified
+ * spellings — the schema declares it unqualified; Word writes `w:`-prefixed
+ * in practice).
+ */
+export function readOriginalWidth(state) {
+    var __ts33_1;
+    var v = ((__ts33_1 = attributeValue(state.element, WML_NS, 'dxaOrig')), __ts33_1 != null ? __ts33_1 : attributeValue(state.element, '', 'dxaOrig'));
+    return v === undefined ? undefined : parseTwipsMeasureAsPoints(v);
+}
+/** Read `w:object/@dyaOrig` as points (qualified/unqualified tolerant). */
+export function readOriginalHeight(state) {
+    var __ts33_2;
+    var v = ((__ts33_2 = attributeValue(state.element, WML_NS, 'dyaOrig')), __ts33_2 != null ? __ts33_2 : attributeValue(state.element, '', 'dyaOrig'));
+    return v === undefined ? undefined : parseTwipsMeasureAsPoints(v);
+}
+// ---------------------------------------------------------------------------
+// Write codec (patch-in-place)
+// ---------------------------------------------------------------------------
+/**
+ * Replace or remove one attribute on a cloned element, **preserving the
+ * original attribute position and prefix** (patch-in-place rule: attribute
+ * order is part of byte-stability). New attributes append at the end with
+ * the given prefix.
+ */
+function withAttribute(el, namespaceUri, localName, value, prefix) {
+    var index = el.attributes.findIndex(function (a) { return a.namespaceUri === namespaceUri && a.localName === localName; });
+    if (value === undefined) {
+        if (index < 0) {
+            return el; // nothing to remove
+        }
+        return __assign({}, el, { attributes: el.attributes.filter(function (_, i) { return i !== index; }) });
+    }
+    // Preserve the existing prefix on replacement (e.g. w:dxaOrig stays
+    // w:-prefixed even when the caller passes ''); use the given prefix only
+    // for newly created attributes.
+    var existing = el.attributes[index];
+    var effectivePrefix = existing !== undefined ? existing.prefix : prefix;
+    var next = {
+        namespaceUri: namespaceUri,
+        localName: localName,
+        prefix: effectivePrefix,
+        value: value,
+    };
+    if (index >= 0) {
+        return __assign({}, el, { attributes: el.attributes.map(function (a, i) { return (i === index ? next : a); }) });
+    }
+    return __assign({}, el, { attributes: __spread(el.attributes, [next]) });
+}
+/**
+ * Replace the element's children, preserving every non-modeled child.
+ * The replacer receives the current element children and returns the next
+ * list (filter/append/remove).
+ */
+function withChildren(el, replace) {
+    var next = replace(elementChildren(el));
+    // Keep text children (none modeled in CT_OLEObject today) before the
+    // element children, matching load order where both exist.
+    var textChildren = el.children.filter(function (c) { return c.kind === 'text'; });
+    return __assign({}, el, { children: __spread(textChildren, next) });
+}
+/** Shallow structural clone of the whole subtree (attributes preserved). */
+function cloneElement(el) {
+    return {
+        kind: 'element',
+        namespaceUri: el.namespaceUri,
+        localName: el.localName,
+        prefix: el.prefix,
+        attributes: el.attributes.map(function (a) { return (__assign({}, a)); }),
+        namespaceDeclarations: el.namespaceDeclarations.map(function (n) { return (__assign({}, n)); }),
+        children: el.children.map(function (c) { return c.kind === 'element'
+            ? cloneElement(c)
+            : { kind: 'text', value: c.value }; }),
+    };
+}
+/** Error for value validation failures (mapped to `content/invalid-ole-object` by callers). */
+function invalidEnum(name, value, allowed) {
+    throw new DocxError('content/invalid-ole-object', "Invalid OleObject " + name + " \"" + String(value) + "\"; expected one of: " + allowed.join(', '));
+}
+/**
+ * Runtime enum guard for values crossing the JS boundary (the type system
+ * narrows these to the union, but a JS caller can pass an arbitrary string).
+ * `never` via exhaustive check with the as-const member sets.
+ */
+function assertEnumMember(name, value, members, tokens) {
+    var __ts33_3;
+    if (members.indexOf(value) === -1) {
+        invalidEnum(name, value, tokens);
+    }
+    return ((__ts33_3 = tokens[members.indexOf(value)]), __ts33_3 != null ? __ts33_3 : value);
+}
+/** Office + WML member lists, parallel to their token lists. */
+var ASPECT_MEMBERS = [OleDrawAspect.Content, OleDrawAspect.Icon];
+var UPDATE_MEMBERS = [OleUpdateMode.Always, OleUpdateMode.OnCall];
+/** Validate + convert a draw-aspect input for the active wire form. */
+function drawAspectToken(state, value) {
+    if (state.wireForm === 'wml') {
+        return assertEnumMember('drawAspect', value, ASPECT_MEMBERS, objectValues(WML_ASPECT_TOKENS));
+    }
+    return assertEnumMember('DrawAspect', value, ASPECT_MEMBERS, objectValues(OLE_ASPECT_TOKENS));
+}
+/** Validate + convert an update-mode input for the active wire form. */
+function updateModeToken(state, value) {
+    if (state.wireForm === 'wml') {
+        return assertEnumMember('updateMode', value, UPDATE_MEMBERS, objectValues(WML_UPDATE_TOKENS));
+    }
+    return assertEnumMember('UpdateMode', value, UPDATE_MEMBERS, objectValues(OLE_UPDATE_TOKENS));
+}
+/**
+ * Format points as an `ST_TwipsMeasure` integral-twips attribute string.
+ * Conversion to wire units happens only at this boundary.
+ */
+function formatPointsAsTwipsMeasure(points) {
+    var twips = pointToTwips(points);
+    if (twips <= 0 || !Number.isFinite(twips)) {
+        throw new DocxError('content/invalid-ole-object', 'OleObject original size must be a positive point value');
+    }
+    return String(twips);
+}
+/**
+ * Patch the DOM state with the given mutations and return the next state
+ * (new element + oleElement references; previous tree untouched).
+ *
+ * @private
+ */
+export function applyOleDomMutations(state, mutations) {
+    var element = cloneElement(state.element);
+    var resolved = resolveOleChild(element);
+    if (resolved === undefined) {
+        // Defensive: callers only construct state with a resolved child.
+        throw new DocxError('content/invalid-ole-object', 'OLE object element lost its OLE child');
+    }
+    var oleElement = resolved.oleElement;
+    var nextElement = element;
+    var office = state.wireForm === 'office';
+    // All modeled attributes on o:OLEObject and w:object* WML children are
+    // schema-unqualified (no namespace, no prefix): `ProgID`, `DrawAspect`,
+    // `progId`, `dxaOrig`, … — serialize as bare localNames.
+    var attrNs = '';
+    var attrPrefix = '';
+    // -- w:object original-size attributes ---------------------------------
+    // Word writes these WML-qualified (`w:dxaOrig`); producers that emit them
+    // unqualified also parse (namespace ''). Create uses the 'w' prefix;
+    // replacement preserves whatever prefix the source carried.
+    if ('originalWidth' in mutations) {
+        nextElement = withAttribute(nextElement, WML_NS, 'dxaOrig', mutations.originalWidth === undefined
+            ? undefined
+            : formatPointsAsTwipsMeasure(mutations.originalWidth), 'w');
+    }
+    if ('originalHeight' in mutations) {
+        nextElement = withAttribute(nextElement, WML_NS, 'dyaOrig', mutations.originalHeight === undefined
+            ? undefined
+            : formatPointsAsTwipsMeasure(mutations.originalHeight), 'w');
+    }
+    // -- o:OLEObject / w:object* attributes --------------------------------
+    // Note: the WML form encodes Embed/Link in the element choice
+    // (w:objectEmbed vs w:objectLink); converting between element names is a
+    // form conversion and is out of scope (wireForm is fixed at load), so a
+    // `type` mutation only applies on the office form. Clearing `@Type` is
+    // allowed there (embed is the schema default when absent).
+    if ('type' in mutations && office) {
+        var value = mutations.type;
+        if (value === undefined) {
+            oleElement = withAttribute(oleElement, attrNs, 'Type', undefined, attrPrefix);
+        }
+        else if (value === OleLinkType.Link) {
+            oleElement = withAttribute(oleElement, attrNs, 'Type', OLE_TYPE_TOKENS.Link, attrPrefix);
+        }
+        else {
+            oleElement = withAttribute(oleElement, attrNs, 'Type', OLE_TYPE_TOKENS.Embed, attrPrefix);
+        }
+    }
+    if ('progId' in mutations) {
+        oleElement = withAttribute(oleElement, attrNs, office ? 'ProgID' : 'progId', mutations.progId, attrPrefix);
+    }
+    if ('shapeId' in mutations) {
+        oleElement = withAttribute(oleElement, attrNs, office ? 'ShapeID' : 'shapeId', mutations.shapeId, attrPrefix);
+    }
+    if ('drawAspect' in mutations) {
+        var value = mutations.drawAspect;
+        oleElement = withAttribute(oleElement, attrNs, office ? 'DrawAspect' : 'drawAspect', value === undefined ? undefined : drawAspectToken(state, value), attrPrefix);
+    }
+    if ('objectId' in mutations && office) {
+        oleElement = withAttribute(oleElement, attrNs, 'ObjectID', mutations.objectId, attrPrefix);
+    }
+    if ('updateMode' in mutations) {
+        var value = mutations.updateMode;
+        if (office || state.oleElement.localName === WML_LINK_ELEMENT) {
+            oleElement = withAttribute(oleElement, attrNs, office ? 'UpdateMode' : 'updateMode', value === undefined ? undefined : updateModeToken(state, value), attrPrefix);
+        }
+    }
+    // -- office-form children (LinkType / LockedField / FieldCodes) --------
+    if (office) {
+        oleElement = withChildren(oleElement, function (children) {
+            var next = children;
+            if ('linkTypeDescription' in mutations) {
+                next = setOfficeChild(next, 'LinkType', mutations.linkTypeDescription);
+            }
+            if ('lockedField' in mutations) {
+                next = setOfficeChild(next, 'LockedField', mutations.lockedField === undefined
+                    ? undefined
+                    : mutations.lockedField
+                        ? 't'
+                        : 'f');
+            }
+            if ('fieldCodes' in mutations) {
+                next = setOfficeChild(next, 'FieldCodes', mutations.fieldCodes);
+            }
+            return next;
+        });
+    }
+    else if ('lockedField' in mutations || 'fieldCodes' in mutations) {
+        // WML link form carries lockedField/fieldCodes as attributes.
+        if ('lockedField' in mutations) {
+            var value = mutations.lockedField;
+            oleElement = withAttribute(oleElement, attrNs, 'lockedField', value === undefined ? undefined : value ? 'true' : 'false', attrPrefix);
+        }
+        if ('fieldCodes' in mutations) {
+            oleElement = withAttribute(oleElement, attrNs, 'fieldCodes', mutations.fieldCodes, attrPrefix);
+        }
+    }
+    // Splice the patched oleElement back into the element's children.
+    nextElement = __assign({}, nextElement, { children: nextElement.children.map(function (c) { return c.kind === 'element' && c === resolved.oleElement ? oleElement : c; }) });
+    return { element: nextElement, oleElement: oleElement, wireForm: state.wireForm };
+}
+/**
+ * Set or remove one office-form child (`o:LinkType`, `o:LockedField`,
+ * `o:FieldCodes`) preserving relative order; the child is appended at the
+ * end when newly created (CT_OLEObject child sequence is
+ * LinkType → LockedField → FieldCodes; setters that create children
+ * out of order would violate the sequence, so callers set values in an
+ * order-independent way here by always keeping the three slots sorted).
+ */
+function setOfficeChild(children, localName, value) {
+    var filtered = children.filter(function (c) { return !(c.namespaceUri === OFFICE_OLE_NAMESPACE && c.localName === localName); });
+    if (value === undefined) {
+        return filtered;
+    }
+    var created = {
+        kind: 'element',
+        namespaceUri: OFFICE_OLE_NAMESPACE,
+        localName: localName,
+        prefix: 'o',
+        attributes: [],
+        namespaceDeclarations: [],
+        children: [{ kind: 'text', value: value }],
+    };
+    // Re-sort the three modeled slots into schema order relative to each other.
+    var order = ['LinkType', 'LockedField', 'FieldCodes'];
+    var slot = order.indexOf(localName);
+    var insertAt = filtered.findIndex(function (c) {
+        if (c.namespaceUri !== OFFICE_OLE_NAMESPACE) {
+            return false;
+        }
+        var other = order.indexOf(c.localName);
+        return other >= 0 && other > slot;
+    });
+    if (insertAt < 0) {
+        return __spread(filtered, [created]);
+    }
+    return __spread(filtered.slice(0, insertAt), [created], filtered.slice(insertAt));
+}
+/** Exported for the class: attribute lookup helper (namespace-qualified). */
+export function oleAttributeValue(el, namespaceUri, localName) {
+    return attributeValue(el, namespaceUri, localName);
+}
+/** Exported for the class: element children helper. */
+export function oleElementChildren(el) {
+    return elementChildren(el);
+}
+/** Exported for the class: explicit-false detection for LockedField. */
+export function oleIsExplicitFalse(value) {
+    return isExplicitFalse(value);
+}