@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/content-controls/index.js

@@ -0,0 +1,2857 @@
+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 __());
+    };
+})();
+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 { registerAlwaysOnBodyFeatureBootstrap } from '../document/body-always-on';
+import { parseBodyBlocks, serializeBodyBlocks } from '../document/body-blocks';
+import { DetachedObjectError } from '../../core/errors/docx-error';
+import { WordDocument, Body } from '../document/document';
+import { Paragraph } from '../document/paragraph';
+import { projectBlockToBodyItem, registerBodyItemAdapter } from '../document/body-item-adapters';
+import { registerTypedCollectionHooks } from '../document/typed-body-collections';
+import { CharacterFormat, parseCharacterFormat, } from '../document/character-format';
+import { colorFromWire, colorToHexWire } from '../document/color';
+import { EntityType } from '../document/entity-type';
+import { localeIdFromBcp47, localeIdToBcp47 } from '../document/locale-ids';
+import { ParagraphItemCollection } from '../document/paragraph-item-collection';
+import { FeatureInlineParagraphItem, OpaqueParagraphItem, serializeRun, serializeParagraphItems, TextRange, } from '../document/text-range';
+import { elementChildren, isWml, isWmlNamespace, wmlAttr, wmlElement } from '../document/wml';
+import { featureId, registerFeature, registerFeatureBlockHandler, registerFeatureBlockParagraphWalker, registerFeatureInlineHandler, visitBlocksInDocumentOrder, } from '../../core/registry/index';
+import { detachedBodyBlockParseContext } from '../../core/registry/block-handlers';
+import { serializeFeatureInline, tryParseFeatureInline, } from '../../core/registry/inline-handlers';
+var CONTENT_CONTROLS = featureId('content-controls');
+/**
+ * @private
+ * [MS-DOCX] WordprocessingML 2010 extension namespace
+ * (`http://schemas.microsoft.com/office/word/2010/wordml`) — checkbox / `w14`.
+ */
+export var WORDML_2010_NAMESPACE = 'http://schemas.microsoft.com/office/word/2010/wordml';
+/**
+ * @private
+ * [MS-DOCX] WordprocessingML 2012 extension namespace
+ * (`http://schemas.microsoft.com/office/word/2012/wordml`) — appearance / color.
+ */
+export var WORDML_2012_NAMESPACE = 'http://schemas.microsoft.com/office/word/2012/wordml';
+var W14_PREFIX = 'w14';
+var W15_PREFIX = 'w15';
+var DEFAULT_CHECKBOX_FONT = 'Segoe UI Symbol';
+var DEFAULT_CHECKED_SYMBOL = '2612';
+var DEFAULT_UNCHECKED_SYMBOL = '2610';
+var DEFAULT_CHECKED_SYMBOL_TEXT = '\u2612';
+var DEFAULT_UNCHECKED_SYMBOL_TEXT = '\u2610';
+/**
+ * Runtime values for {@link ContentControlType}.
+ * @public
+ */
+export var ContentControlType = {
+    RichText: 'richText',
+    Text: 'plainText',
+    Picture: 'picture',
+    ComboBox: 'comboBox',
+    DropDownList: 'dropDownList',
+    Date: 'date',
+    CheckBox: 'checkbox',
+};
+/**
+ * Runtime values for {@link ContentControlAppearance}.
+ * @public
+ */
+export var ContentControlAppearance = {
+    BoundingBox: 'boundingBox',
+    Tags: 'tags',
+    Hidden: 'hidden',
+};
+/**
+ * Runtime values for {@link CalendarType}.
+ * @public
+ */
+export var CalendarType = {
+    Gregorian: 'gregorian',
+    Hijri: 'hijri',
+    Hebrew: 'hebrew',
+    Taiwan: 'taiwan',
+    Japan: 'japan',
+    Thai: 'thai',
+    Korea: 'korea',
+    Saka: 'saka',
+    GregorianArabic: 'gregorianArabic',
+    GregorianMiddleEastFrench: 'gregorianMiddleEastFrench',
+    GregorianTransliteratedEnglish: 'gregorianTransliteratedEnglish',
+    GregorianTransliteratedFrench: 'gregorianTransliteratedFrench',
+    GregorianUsLocale: 'gregorianUsLocale',
+};
+/**
+ * Runtime values for {@link ContentControlDateStorageFormat}.
+ * @public
+ */
+export var ContentControlDateStorageFormat = {
+    DateStorageDate: 'date',
+    DateStorageDateTime: 'dateTime',
+    DateStorageText: 'text',
+};
+/**
+ * Checkbox symbol (`w14:checkedState` / `w14:uncheckedState`) — mutable stable identity.
+ * @public
+ */
+var ContentControlCheckBoxState = /** @class */ (function () {
+    /** @private */
+    function ContentControlCheckBoxState(init) {
+        this.fontValue = init != null ? init.font : undefined;
+        this.valueValue = init != null ? init.value : undefined;
+        this.onChange = undefined;
+    }
+    /** @private */
+    ContentControlCheckBoxState.prototype.bind = function (onChange) {
+        this.onChange = onChange;
+    };
+    ContentControlCheckBoxState.prototype.dirty = function () {
+        if (this.onChange !== undefined) {
+            this.onChange();
+        }
+    };
+    Object.defineProperty(ContentControlCheckBoxState.prototype, "font", {
+        /** Font name for the checkbox glyph. @public */
+        get: function () {
+            return this.fontValue;
+        },
+        set: function (value) {
+            this.fontValue = value;
+            this.dirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControlCheckBoxState.prototype, "value", {
+        /** Glyph code point / short-hex value. @public */
+        get: function () {
+            return this.valueValue;
+        },
+        set: function (value) {
+            this.valueValue = value;
+            this.dirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return ContentControlCheckBoxState;
+}());
+export { ContentControlCheckBoxState };
+/**
+ * Combo-box or drop-down list entry.
+ * @public
+ */
+var ContentControlListItem = /** @class */ (function () {
+    /** @public */
+    function ContentControlListItem() {
+        this.displayTextValue = undefined;
+        this.valueValue = undefined;
+        this.onChange = undefined;
+    }
+    /** @private */
+    ContentControlListItem.prototype.bind = function (onChange) {
+        this.onChange = onChange;
+    };
+    ContentControlListItem.prototype.dirty = function () {
+        if (this.onChange !== undefined) {
+            this.onChange();
+        }
+    };
+    Object.defineProperty(ContentControlListItem.prototype, "displayText", {
+        /** Display label. @public */
+        get: function () {
+            return this.displayTextValue;
+        },
+        set: function (value) {
+            this.displayTextValue = value;
+            this.dirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControlListItem.prototype, "value", {
+        /** Stored value. @public */
+        get: function () {
+            return this.valueValue;
+        },
+        set: function (value) {
+            this.valueValue = value;
+            this.dirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return ContentControlListItem;
+}());
+export { ContentControlListItem };
+/**
+ * Mutable list of {@link ContentControlListItem} with stable identity.
+ * @public
+ */
+var ContentControlListItemCollection = /** @class */ (function () {
+    /** @private */
+    function ContentControlListItemCollection(items) {
+        this.items = items != null ? items.slice() : [];
+        this.onChange = undefined;
+    }
+    /** @private */
+    ContentControlListItemCollection.prototype.bind = function (onChange) {
+        this.onChange = onChange;
+        for (var i = 0; i < this.items.length; i++) {
+            this.items[i].bind(onChange);
+        }
+    };
+    ContentControlListItemCollection.prototype.dirty = function () {
+        if (this.onChange !== undefined) {
+            this.onChange();
+        }
+    };
+    Object.defineProperty(ContentControlListItemCollection.prototype, "count", {
+        /** Number of list items. @public */
+        get: function () {
+            return this.items.length;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /** Item at zero-based index. @public */
+    ContentControlListItemCollection.prototype.getItem = function (index) {
+        if (index < 0 || index >= this.items.length) {
+            throw new RangeError('List item index out of range');
+        }
+        return this.items[index];
+    };
+    /** Snapshot array (copy). @public */
+    ContentControlListItemCollection.prototype.toArray = function () {
+        return this.items.slice();
+    };
+    /** Add a list item. @public */
+    ContentControlListItemCollection.prototype.add = function (item) {
+        if (this.onChange !== undefined) {
+            item.bind(this.onChange);
+        }
+        this.items.push(item);
+        this.dirty();
+    };
+    /** Remove all items. @public */
+    ContentControlListItemCollection.prototype.clear = function () {
+        this.items.length = 0;
+        this.dirty();
+    };
+    /** @private */
+    ContentControlListItemCollection.prototype.asReadonly = function () {
+        return this.items;
+    };
+    return ContentControlListItemCollection;
+}());
+export { ContentControlListItemCollection };
+function locksFromWire(lock) {
+    if (lock === 'sdtLocked') {
+        return { lockContentControl: true, lockContents: false };
+    }
+    if (lock === 'contentLocked') {
+        return { lockContentControl: false, lockContents: true };
+    }
+    if (lock === 'sdtContentLocked') {
+        return { lockContentControl: true, lockContents: true };
+    }
+    return { lockContentControl: false, lockContents: false };
+}
+function locksToWire(lockContentControl, lockContents) {
+    if (lockContentControl && lockContents) {
+        return 'sdtContentLocked';
+    }
+    if (lockContentControl) {
+        return 'sdtLocked';
+    }
+    if (lockContents) {
+        return 'contentLocked';
+    }
+    return undefined;
+}
+/**
+ * Structured document tag properties (`w:sdtPr`).
+ *
+ * @public
+ */
+var ContentControlProperties = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function ContentControlProperties(init) {
+        var _this = this;
+        var src = init != null ? init : {};
+        this.tagValue = src.tag;
+        this.titleValue = src.title;
+        this.idValue = src.id;
+        var fromLock = src.lock !== undefined
+            ? locksFromWire(src.lock)
+            : {
+                lockContentControl: src.lockContentControl === true,
+                lockContents: src.lockContents === true,
+            };
+        this.lockContentControlValue = fromLock.lockContentControl;
+        this.lockContentsValue = fromLock.lockContents;
+        this.placeholderDocPartValue = src.placeholderDocPart;
+        this.dataBindingValue = src.dataBinding;
+        this.typeValue = src.type;
+        this.temporaryValue = src.temporary === true;
+        this.appearanceValue = src.appearance;
+        this.colorValue = src.color;
+        this.themeColorValue = src.themeColor;
+        this.themeTintValue = src.themeTint;
+        this.themeShadeValue = src.themeShade;
+        this.isCheckedValue = src.isChecked === true;
+        this.checkedStateValue =
+            src.checkedState != null
+                ? src.checkedState
+                : new ContentControlCheckBoxState(src.type === 'checkbox'
+                    ? { font: DEFAULT_CHECKBOX_FONT, value: DEFAULT_CHECKED_SYMBOL }
+                    : undefined);
+        this.uncheckedStateValue =
+            src.uncheckedState != null
+                ? src.uncheckedState
+                : new ContentControlCheckBoxState(src.type === 'checkbox'
+                    ? { font: DEFAULT_CHECKBOX_FONT, value: DEFAULT_UNCHECKED_SYMBOL }
+                    : undefined);
+        this.fullDateValue = src.fullDate;
+        this.dateDisplayFormatValue = src.dateDisplayFormat;
+        this.dateDisplayLocaleValue = src.dateDisplayLocale;
+        this.dateStorageFormatValue = src.dateStorageFormat;
+        this.dateCalendarTypeValue = src.dateCalendarType;
+        this.contentControlListItemsValue = new ContentControlListItemCollection(src.listItems);
+        this.lastValueValue = src.lastValue;
+        this.multilineValue = src.multiline;
+        this.residualChildrenValue = src.residualChildren != null ? src.residualChildren : [];
+        this.leftoverAttributesValue =
+            src.leftoverAttributes != null ? src.leftoverAttributes : [];
+        this.namespaceDeclarationsValue =
+            src.namespaceDeclarations != null ? src.namespaceDeclarations : [];
+        this.owner = undefined;
+        var mark = function () {
+            _this.markDirty();
+        };
+        this.checkedStateValue.bind(mark);
+        this.uncheckedStateValue.bind(mark);
+        this.contentControlListItemsValue.bind(mark);
+    }
+    /**
+     * @private
+     * Bind owning control so property sets rebuild `sdtPr` on save.
+     */
+    ContentControlProperties.prototype.bindOwner = function (owner) {
+        this.owner = owner;
+    };
+    ContentControlProperties.prototype.markDirty = function () {
+        if (this.owner !== undefined) {
+            this.owner.markSdtPrDirty();
+        }
+    };
+    /**
+     * Drop type-specific payloads that do not belong to `type`.
+     */
+    ContentControlProperties.prototype.clearPayloadsForType = function (type) {
+        if (type !== 'checkbox') {
+            this.isCheckedValue = false;
+            this.checkedStateValue.font = undefined;
+            this.checkedStateValue.value = undefined;
+            this.uncheckedStateValue.font = undefined;
+            this.uncheckedStateValue.value = undefined;
+        }
+        if (type !== 'date') {
+            this.fullDateValue = undefined;
+            this.dateDisplayFormatValue = undefined;
+            this.dateDisplayLocaleValue = undefined;
+            this.dateStorageFormatValue = undefined;
+            this.dateCalendarTypeValue = undefined;
+        }
+        if (type !== 'comboBox' && type !== 'dropDownList') {
+            this.contentControlListItemsValue.clear();
+            this.lastValueValue = undefined;
+        }
+        if (type !== 'plainText') {
+            this.multilineValue = undefined;
+        }
+    };
+    Object.defineProperty(ContentControlProperties.prototype, "tag", {
+        /**
+         * Gets or sets the programmatic tag used to identify this content control in code.
+         *
+         * If undefined, no tag is explicitly specified.
+         *
+         * @public
+         */
+        get: function () {
+            return this.tagValue;
+        },
+        set: function (value) {
+            this.tagValue = value;
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControlProperties.prototype, "title", {
+        /**
+         * Gets or sets the friendly display name shown as the content-control title in Word.
+         *
+         * If undefined, no title is explicitly specified.
+         *
+         * @public
+         */
+        get: function () {
+            return this.titleValue;
+        },
+        set: function (value) {
+            this.titleValue = value;
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControlProperties.prototype, "id", {
+        /**
+         * @private
+         * Numeric id (`w:sdtPr/w:id/@w:val`). Preserve-only identity from load or
+         * author options — not a general post-create editing knob.
+         */
+        get: function () {
+            return this.idValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControlProperties.prototype, "lockContentControl", {
+        /**
+         * Gets or sets whether the content-control definition is locked.
+         * @public
+         */
+        get: function () {
+            return this.lockContentControlValue;
+        },
+        set: function (value) {
+            this.lockContentControlValue = value === true;
+            if (this.lockContentControlValue) {
+                this.temporaryValue = false;
+            }
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControlProperties.prototype, "lockContents", {
+        /**
+         * Gets or sets whether the content inside the control is locked.
+         * @public
+         */
+        get: function () {
+            return this.lockContentsValue;
+        },
+        set: function (value) {
+            this.lockContentsValue = value === true;
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControlProperties.prototype, "lockWire", {
+        /**
+         * @private
+         * Combined ST_Lock wire value for serialize.
+         */
+        get: function () {
+            return locksToWire(this.lockContentControlValue, this.lockContentsValue);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControlProperties.prototype, "placeholderDocPart", {
+        /**
+         * @private
+         * Placeholder document-part name
+         * (`w:sdtPr/w:placeholder/w:docPart/@w:val`).
+         */
+        get: function () {
+            return this.placeholderDocPartValue;
+        },
+        set: function (value) {
+            this.placeholderDocPartValue = value;
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControlProperties.prototype, "dataBinding", {
+        /**
+         * @private
+         * Custom XML data binding metadata. Detect/preserve only — never resolved
+         * against a store or network; no public setter.
+         */
+        get: function () {
+            return this.dataBindingValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControlProperties.prototype, "type", {
+        /**
+         * Gets or sets the content-control kind.
+         * @public
+         */
+        get: function () {
+            return this.typeValue;
+        },
+        set: function (value) {
+            requireAuthorableType(value);
+            this.typeValue = value;
+            this.clearPayloadsForType(value);
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControlProperties.prototype, "isTemporary", {
+        /**
+         * Gets or sets whether the control is removed after contents are edited once (`w:temporary`).
+         * @public
+         */
+        get: function () {
+            return this.temporaryValue;
+        },
+        set: function (value) {
+            this.temporaryValue = value === true;
+            if (this.temporaryValue) {
+                this.lockContentControlValue = false;
+            }
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControlProperties.prototype, "temporary", {
+        /**
+         * @private Compatibility alias for load/serialize paths that used `temporary`.
+         */
+        get: function () {
+            return this.temporaryValue;
+        },
+        set: function (value) {
+            this.isTemporary = value === true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControlProperties.prototype, "appearance", {
+        /**
+         * Gets or sets how the control chrome is shown.
+         * @public
+         */
+        get: function () {
+            return this.appearanceValue;
+        },
+        set: function (value) {
+            this.appearanceValue = value;
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControlProperties.prototype, "color", {
+        /**
+         * Gets or sets the border/chrome color (`Color` API).
+         * @public
+         */
+        get: function () {
+            return this.colorValue;
+        },
+        set: function (value) {
+            this.colorValue = value;
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControlProperties.prototype, "themeColor", {
+        /** @private */
+        get: function () {
+            return this.themeColorValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControlProperties.prototype, "themeTint", {
+        /** @private */
+        get: function () {
+            return this.themeTintValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControlProperties.prototype, "themeShade", {
+        /** @private */
+        get: function () {
+            return this.themeShadeValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControlProperties.prototype, "isChecked", {
+        /**
+         * Gets or sets whether a checkbox control is checked.
+         * @public
+         */
+        get: function () {
+            return this.isCheckedValue;
+        },
+        set: function (value) {
+            this.isCheckedValue = value === true;
+            if (this.typeValue !== 'checkbox') {
+                this.typeValue = 'checkbox';
+                this.clearPayloadsForType('checkbox');
+                this.isCheckedValue = value === true;
+            }
+            this.markDirty();
+            if (this.owner !== undefined) {
+                this.owner.synchronizeCheckboxContent();
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControlProperties.prototype, "checkedState", {
+        /**
+         * Checked-state symbol (stable identity).
+         * @public
+         */
+        get: function () {
+            return this.checkedStateValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControlProperties.prototype, "uncheckedState", {
+        /**
+         * Unchecked-state symbol (stable identity).
+         * @public
+         */
+        get: function () {
+            return this.uncheckedStateValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControlProperties.prototype, "fullDate", {
+        /**
+         * Full date/time stored value.
+         * @public
+         */
+        get: function () {
+            return this.fullDateValue;
+        },
+        set: function (value) {
+            this.fullDateValue = value;
+            if (value !== undefined && this.typeValue !== 'date') {
+                this.typeValue = 'date';
+                this.clearPayloadsForType('date');
+                this.fullDateValue = value;
+            }
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControlProperties.prototype, "dateDisplayFormat", {
+        /**
+         * Display format pattern for the date.
+         * @public
+         */
+        get: function () {
+            return this.dateDisplayFormatValue;
+        },
+        set: function (value) {
+            this.dateDisplayFormatValue = value;
+            if (value !== undefined && this.typeValue !== 'date') {
+                this.typeValue = 'date';
+                this.clearPayloadsForType('date');
+                this.dateDisplayFormatValue = value;
+            }
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControlProperties.prototype, "dateDisplayLocale", {
+        /**
+         * Locale used for date display.
+         * @public
+         */
+        get: function () {
+            return this.dateDisplayLocaleValue;
+        },
+        set: function (value) {
+            this.dateDisplayLocaleValue = value;
+            if (value !== undefined && this.typeValue !== 'date') {
+                this.typeValue = 'date';
+                this.clearPayloadsForType('date');
+                this.dateDisplayLocaleValue = value;
+            }
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControlProperties.prototype, "dateStorageFormat", {
+        /**
+         * How mapped date data is stored.
+         * @public
+         */
+        get: function () {
+            return this.dateStorageFormatValue;
+        },
+        set: function (value) {
+            this.dateStorageFormatValue = value;
+            if (value !== undefined && this.typeValue !== 'date') {
+                this.typeValue = 'date';
+                this.clearPayloadsForType('date');
+                this.dateStorageFormatValue = value;
+            }
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControlProperties.prototype, "dateCalendarType", {
+        /**
+         * Calendar system for the date control.
+         * @public
+         */
+        get: function () {
+            return this.dateCalendarTypeValue;
+        },
+        set: function (value) {
+            this.dateCalendarTypeValue = value;
+            if (value !== undefined && this.typeValue !== 'date') {
+                this.typeValue = 'date';
+                this.clearPayloadsForType('date');
+                this.dateCalendarTypeValue = value;
+            }
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControlProperties.prototype, "contentControlListItems", {
+        /**
+         * Combo-box / drop-down list items (stable identity).
+         * @public
+         */
+        get: function () {
+            return this.contentControlListItemsValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControlProperties.prototype, "lastValue", {
+        /**
+         * Last selected list value.
+         * @public
+         */
+        get: function () {
+            return this.lastValueValue;
+        },
+        set: function (value) {
+            this.lastValueValue = value;
+            if (value !== undefined) {
+                if (this.typeValue !== 'comboBox' && this.typeValue !== 'dropDownList') {
+                    this.typeValue = 'dropDownList';
+                    this.clearPayloadsForType(this.typeValue);
+                    this.lastValueValue = value;
+                }
+            }
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControlProperties.prototype, "multiline", {
+        /**
+         * Whether a plain-text control accepts multiple lines (`w:text/@w:multiLine`).
+         * @public
+         */
+        get: function () {
+            return this.multilineValue;
+        },
+        set: function (value) {
+            this.multilineValue = value;
+            if (value !== undefined) {
+                this.typeValue = 'plainText';
+                this.clearPayloadsForType('plainText');
+                this.multilineValue = value;
+            }
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControlProperties.prototype, "residualChildren", {
+        /**
+         * @private
+         * Unmodeled `sdtPr` children (including extra kind markers). */
+        get: function () {
+            return this.residualChildrenValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControlProperties.prototype, "leftoverAttributes", {
+        /**
+         * @private
+         * Leftover attributes on `sdtPr` itself. */
+        get: function () {
+            return this.leftoverAttributesValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControlProperties.prototype, "namespaceDeclarations", {
+        /**
+         * @private
+         * Namespace declarations on `sdtPr`. */
+        get: function () {
+            return this.namespaceDeclarationsValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return ContentControlProperties;
+}());
+export { ContentControlProperties };
+// ── XML helpers ─────────────────────────────────────────────────────────────
+function isWordMl2010(el, localName) {
+    return el.namespaceUri === WORDML_2010_NAMESPACE && el.localName === localName;
+}
+function isWordMl2012(el, localName) {
+    return el.namespaceUri === WORDML_2012_NAMESPACE && el.localName === localName;
+}
+function attributeByLocalName(el, localName) {
+    var __ts33_0;
+    return ((__ts33_0 = el.attributes.find(function (a) { return a.localName === localName; })), __ts33_0 == null ? undefined : __ts33_0.value);
+}
+function wmlAttribute(el, localName) {
+    var __ts33_1;
+    return ((__ts33_1 = el.attributes.find(function (a) { return a.localName === localName &&
+        (a.namespaceUri === '' || isWmlNamespace(a.namespaceUri) || a.prefix === 'w'); })), __ts33_1 == null ? undefined : __ts33_1.value);
+}
+function wValAttribute(el) {
+    return wmlAttribute(el, 'val');
+}
+function anyValAttribute(el) {
+    return attributeByLocalName(el, 'val');
+}
+function parseStOnOff(raw) {
+    if (raw === undefined || raw.length === 0) {
+        return true;
+    }
+    var normalized = raw.trim().toLowerCase();
+    if (normalized === 'true' || normalized === '1' || normalized === 'on') {
+        return true;
+    }
+    if (normalized === 'false' || normalized === '0' || normalized === 'off') {
+        return false;
+    }
+    return undefined;
+}
+function parseDecimalId(raw) {
+    if (raw === undefined || !/^\d+$/.test(raw)) {
+        return undefined;
+    }
+    return Number.parseInt(raw, 10);
+}
+function parseLockWire(raw) {
+    if (raw === 'sdtLocked' ||
+        raw === 'contentLocked' ||
+        raw === 'unlocked' ||
+        raw === 'sdtContentLocked') {
+        return raw;
+    }
+    return undefined;
+}
+function parseAppearance(raw) {
+    if (raw === 'boundingBox' || raw === 'tags' || raw === 'hidden') {
+        return raw;
+    }
+    return undefined;
+}
+function parseDateStorageFormat(raw) {
+    if (raw === 'text' || raw === 'date' || raw === 'dateTime') {
+        return raw;
+    }
+    return undefined;
+}
+function parseCalendarType(raw) {
+    if (raw === 'gregorian' ||
+        raw === 'hijri' ||
+        raw === 'hebrew' ||
+        raw === 'taiwan' ||
+        raw === 'japan' ||
+        raw === 'thai' ||
+        raw === 'korea' ||
+        raw === 'saka' ||
+        raw === 'gregorianArabic' ||
+        raw === 'gregorianMiddleEastFrench' ||
+        raw === 'gregorianTransliteratedEnglish' ||
+        raw === 'gregorianTransliteratedFrench' ||
+        raw === 'gregorianUsLocale') {
+        return raw;
+    }
+    return undefined;
+}
+function unqualifiedAttribute(el, localName) {
+    var __ts33_2;
+    return ((__ts33_2 = el.attributes.find(function (a) { return a.localName === localName &&
+        (a.namespaceUri === '' ||
+            a.prefix === 'w' ||
+            a.namespaceUri.includes('wordprocessingml') ||
+            a.namespaceUri === WORDML_2010_NAMESPACE ||
+            a.namespaceUri === WORDML_2012_NAMESPACE); })), __ts33_2 == null ? undefined : __ts33_2.value);
+}
+function parseDataBinding(element) {
+    if (!isWml(element, 'dataBinding')) {
+        return undefined;
+    }
+    var xpath = unqualifiedAttribute(element, 'xpath');
+    var storeItemID = unqualifiedAttribute(element, 'storeItemID');
+    if (xpath === undefined || xpath.length === 0 || storeItemID === undefined || storeItemID.length === 0) {
+        return undefined;
+    }
+    var prefixMappings = unqualifiedAttribute(element, 'prefixMappings');
+    return { prefixMappings: prefixMappings, xpath: xpath, storeItemID: storeItemID };
+}
+function nsAttr(namespaceUri, prefix, localName, value) {
+    return { namespaceUri: namespaceUri, localName: localName, prefix: prefix, value: value };
+}
+function nsElement(namespaceUri, prefix, localName, options) {
+    var __ts33_3, __ts33_4, __ts33_5;
+    return {
+        kind: 'element',
+        namespaceUri: namespaceUri,
+        localName: localName,
+        prefix: prefix,
+        attributes: ((__ts33_3 = options == null ? undefined : options.attributes), __ts33_3 != null ? __ts33_3 : []),
+        namespaceDeclarations: ((__ts33_4 = options == null ? undefined : options.namespaceDeclarations), __ts33_4 != null ? __ts33_4 : []),
+        children: ((__ts33_5 = options == null ? undefined : options.children), __ts33_5 != null ? __ts33_5 : []),
+    };
+}
+function serializeOnOffWml(localName, value) {
+    if (value) {
+        return wmlElement(localName);
+    }
+    return wmlElement(localName, { attributes: [wmlAttr('val', 'false')] });
+}
+function serializeOnOffNs(namespaceUri, prefix, localName, value) {
+    if (value) {
+        return nsElement(namespaceUri, prefix, localName);
+    }
+    return nsElement(namespaceUri, prefix, localName, {
+        attributes: [nsAttr(namespaceUri, prefix, 'val', '0')],
+    });
+}
+// ── Kind local-name maps ────────────────────────────────────────────────────
+/** Authorable kinds only — public ContentControlType. */
+var WML_TYPE_LOCAL_TO_TYPE = new Map([
+    ['comboBox', 'comboBox'],
+    ['date', 'date'],
+    ['dropDownList', 'dropDownList'],
+    ['picture', 'picture'],
+    ['richText', 'richText'],
+    ['text', 'plainText'],
+]);
+var TYPE_TO_WML_LOCAL = new Map([
+    ['comboBox', 'comboBox'],
+    ['date', 'date'],
+    ['dropDownList', 'dropDownList'],
+    ['picture', 'picture'],
+    ['richText', 'richText'],
+    ['plainText', 'text'],
+    ['checkbox', 'checkbox'],
+]);
+/** Non-authorable WML kind local names preserved as residual. */
+var NON_AUTHORABLE_KIND_LOCALS = new Set([
+    'equation',
+    'docPartObj',
+    'docPartList',
+    'citation',
+    'group',
+    'bibliography',
+]);
+var AUTHORABLE_TYPES = new Set([
+    'comboBox',
+    'date',
+    'dropDownList',
+    'picture',
+    'richText',
+    'plainText',
+    'checkbox',
+]);
+function isWmlTypeLocalName(localName) {
+    return WML_TYPE_LOCAL_TO_TYPE.has(localName) || NON_AUTHORABLE_KIND_LOCALS.has(localName);
+}
+function requireAuthorableType(value) {
+    if (value === undefined) {
+        return;
+    }
+    if (!AUTHORABLE_TYPES.has(value)) {
+        throw new Error("Content control type '" + value + "' is not authorable.");
+    }
+}
+// ── Kind-specific parsers ───────────────────────────────────────────────────
+function parseListItems(kindEl) {
+    var e_1, _a;
+    var items = [];
+    try {
+        for (var _b = __values(elementChildren(kindEl)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (!isWml(child, 'listItem')) {
+                continue;
+            }
+            var item = new ContentControlListItem();
+            item.displayText = unqualifiedAttribute(child, 'displayText');
+            item.value = unqualifiedAttribute(child, 'value');
+            items.push(item);
+        }
+    }
+    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,
+        lastValue: unqualifiedAttribute(kindEl, 'lastValue'),
+    };
+}
+function parseDateFields(kindEl) {
+    var e_2, _a;
+    var dateDisplayFormat;
+    var dateDisplayLocale;
+    var dateStorageFormat;
+    var dateCalendarType;
+    try {
+        for (var _b = __values(elementChildren(kindEl)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (isWml(child, 'dateFormat')) {
+                dateDisplayFormat = wValAttribute(child);
+                continue;
+            }
+            if (isWml(child, 'lid')) {
+                var lid = wValAttribute(child);
+                if (lid !== undefined) {
+                    dateDisplayLocale = localeIdFromBcp47(lid);
+                }
+                continue;
+            }
+            if (isWml(child, 'storeMappedDataAs')) {
+                dateStorageFormat = parseDateStorageFormat(wValAttribute(child));
+                continue;
+            }
+            if (isWml(child, 'calendar')) {
+                dateCalendarType = parseCalendarType(wValAttribute(child));
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return {
+        fullDate: unqualifiedAttribute(kindEl, 'fullDate'),
+        dateDisplayFormat: dateDisplayFormat,
+        dateDisplayLocale: dateDisplayLocale,
+        dateStorageFormat: dateStorageFormat,
+        dateCalendarType: dateCalendarType,
+    };
+}
+function parseCheckboxState(el) {
+    return new ContentControlCheckBoxState({
+        font: attributeByLocalName(el, 'font'),
+        value: attributeByLocalName(el, 'val'),
+    });
+}
+function parseCheckboxFields(kindEl) {
+    var e_3, _a;
+    var isChecked = false;
+    var checkedState = new ContentControlCheckBoxState();
+    var uncheckedState = new ContentControlCheckBoxState();
+    try {
+        for (var _b = __values(elementChildren(kindEl)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (isWordMl2010(child, 'checked')) {
+                var parsed = parseStOnOff(anyValAttribute(child));
+                isChecked = parsed != null ? parsed : true;
+                continue;
+            }
+            if (isWordMl2010(child, 'checkedState')) {
+                checkedState = parseCheckboxState(child);
+                continue;
+            }
+            if (isWordMl2010(child, 'uncheckedState')) {
+                uncheckedState = parseCheckboxState(child);
+            }
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    return { isChecked: isChecked, checkedState: checkedState, uncheckedState: uncheckedState };
+}
+function parseColorFields(el) {
+    var val = attributeByLocalName(el, 'val');
+    return {
+        color: val !== undefined && val.length > 0 ? colorFromWire(val) : undefined,
+        themeColor: attributeByLocalName(el, 'themeColor'),
+        themeTint: attributeByLocalName(el, 'themeTint'),
+        themeShade: attributeByLocalName(el, 'themeShade'),
+    };
+}
+function parseContentControlProperties(sdtPr) {
+    var e_4, _a, e_5, _b;
+    if (sdtPr === undefined || !isWml(sdtPr, 'sdtPr')) {
+        return undefined;
+    }
+    var tag;
+    var title;
+    var id;
+    var lock;
+    var placeholderDocPart;
+    var dataBinding;
+    var type;
+    var temporary;
+    var appearance;
+    var color;
+    var themeColor;
+    var themeTint;
+    var themeShade;
+    var isChecked;
+    var checkedState;
+    var uncheckedState;
+    var fullDate;
+    var dateDisplayFormat;
+    var dateDisplayLocale;
+    var dateStorageFormat;
+    var dateCalendarType;
+    var listItems;
+    var lastValue;
+    var multiline;
+    var residualChildren = [];
+    var sawAlias = false;
+    var sawTag = false;
+    var sawId = false;
+    var sawLock = false;
+    var sawPlaceholder = false;
+    var sawTemporary = false;
+    var sawDataBinding = false;
+    var sawAppearance = false;
+    var sawColor = false;
+    var sawKind = false;
+    try {
+        for (var _c = __values(elementChildren(sdtPr)), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var child = _d.value;
+            if (isWml(child, 'alias') && !sawAlias) {
+                sawAlias = true;
+                title = wValAttribute(child);
+                continue;
+            }
+            if (isWml(child, 'tag') && !sawTag) {
+                sawTag = true;
+                tag = wValAttribute(child);
+                continue;
+            }
+            if (isWml(child, 'id') && !sawId) {
+                sawId = true;
+                id = parseDecimalId(wValAttribute(child));
+                continue;
+            }
+            if (isWml(child, 'lock') && !sawLock) {
+                sawLock = true;
+                lock = parseLockWire(wValAttribute(child));
+                continue;
+            }
+            if (isWml(child, 'placeholder') && !sawPlaceholder) {
+                sawPlaceholder = true;
+                try {
+                    for (var _e = __values(elementChildren(child)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                        var placeholderChild = _f.value;
+                        if (isWml(placeholderChild, 'docPart')) {
+                            placeholderDocPart = wValAttribute(placeholderChild);
+                        }
+                    }
+                }
+                catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                finally {
+                    try {
+                        if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                    }
+                    finally { if (e_5) throw e_5.error; }
+                }
+                continue;
+            }
+            if (isWml(child, 'temporary') && !sawTemporary) {
+                sawTemporary = true;
+                var parsed = parseStOnOff(wValAttribute(child));
+                temporary = parsed != null ? parsed : true;
+                continue;
+            }
+            if (isWml(child, 'dataBinding') && !sawDataBinding) {
+                sawDataBinding = true;
+                var binding = parseDataBinding(child);
+                if (binding !== undefined) {
+                    dataBinding = binding;
+                    continue;
+                }
+                residualChildren.push(child);
+                continue;
+            }
+            if (isWordMl2012(child, 'appearance') && !sawAppearance) {
+                sawAppearance = true;
+                var parsed = parseAppearance(anyValAttribute(child));
+                if (parsed !== undefined) {
+                    appearance = parsed;
+                    continue;
+                }
+                residualChildren.push(child);
+                continue;
+            }
+            if (isWordMl2012(child, 'color') && !sawColor) {
+                sawColor = true;
+                var parsed = parseColorFields(child);
+                if (parsed.color !== undefined ||
+                    parsed.themeColor !== undefined ||
+                    parsed.themeTint !== undefined ||
+                    parsed.themeShade !== undefined) {
+                    color = parsed.color;
+                    themeColor = parsed.themeColor;
+                    themeTint = parsed.themeTint;
+                    themeShade = parsed.themeShade;
+                    continue;
+                }
+                residualChildren.push(child);
+                continue;
+            }
+            if (isWordMl2010(child, 'checkbox')) {
+                if (!sawKind) {
+                    sawKind = true;
+                    type = 'checkbox';
+                    var cb = parseCheckboxFields(child);
+                    isChecked = cb.isChecked;
+                    checkedState = cb.checkedState;
+                    uncheckedState = cb.uncheckedState;
+                    continue;
+                }
+                residualChildren.push(child);
+                continue;
+            }
+            if (isWmlNamespace(child.namespaceUri) && isWmlTypeLocalName(child.localName)) {
+                if (!sawKind) {
+                    sawKind = true;
+                    if (NON_AUTHORABLE_KIND_LOCALS.has(child.localName)) {
+                        residualChildren.push(child);
+                        continue;
+                    }
+                    var mapped = WML_TYPE_LOCAL_TO_TYPE.get(child.localName);
+                    if (mapped === undefined) {
+                        residualChildren.push(child);
+                        continue;
+                    }
+                    type = mapped;
+                    if (mapped === 'plainText') {
+                        multiline = parseStOnOff(wmlAttribute(child, 'multiLine'));
+                    }
+                    else if (mapped === 'date') {
+                        var d = parseDateFields(child);
+                        fullDate = d.fullDate;
+                        dateDisplayFormat = d.dateDisplayFormat;
+                        dateDisplayLocale = d.dateDisplayLocale;
+                        dateStorageFormat = d.dateStorageFormat;
+                        dateCalendarType = d.dateCalendarType;
+                    }
+                    else if (mapped === 'comboBox' || mapped === 'dropDownList') {
+                        var list = parseListItems(child);
+                        listItems = list.items;
+                        lastValue = list.lastValue;
+                    }
+                    continue;
+                }
+                residualChildren.push(child);
+                continue;
+            }
+            residualChildren.push(child);
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    return new ContentControlProperties({
+        tag: tag,
+        title: title,
+        id: id,
+        lock: lock,
+        placeholderDocPart: placeholderDocPart,
+        dataBinding: dataBinding,
+        type: type,
+        temporary: temporary,
+        appearance: appearance,
+        color: color,
+        themeColor: themeColor,
+        themeTint: themeTint,
+        themeShade: themeShade,
+        isChecked: isChecked,
+        checkedState: checkedState,
+        uncheckedState: uncheckedState,
+        fullDate: fullDate,
+        dateDisplayFormat: dateDisplayFormat,
+        dateDisplayLocale: dateDisplayLocale,
+        dateStorageFormat: dateStorageFormat,
+        dateCalendarType: dateCalendarType,
+        listItems: listItems,
+        lastValue: lastValue,
+        multiline: multiline,
+        residualChildren: residualChildren,
+        leftoverAttributes: __spread(sdtPr.attributes),
+        namespaceDeclarations: sdtPr.namespaceDeclarations,
+    });
+}
+// ── Serialize modeled sdtPr ─────────────────────────────────────────────────
+function serializeListItem(item) {
+    var attributes = [];
+    if (item.displayText !== undefined) {
+        attributes.push(wmlAttr('displayText', item.displayText));
+    }
+    if (item.value !== undefined) {
+        attributes.push(wmlAttr('value', item.value));
+    }
+    return wmlElement('listItem', { attributes: attributes });
+}
+function serializeDateElement(properties) {
+    var children = [];
+    if (properties.dateDisplayFormat !== undefined) {
+        children.push(wmlElement('dateFormat', { attributes: [wmlAttr('val', properties.dateDisplayFormat)] }));
+    }
+    if (properties.dateDisplayLocale !== undefined) {
+        var bcp47 = localeIdToBcp47(properties.dateDisplayLocale);
+        if (bcp47 !== undefined) {
+            children.push(wmlElement('lid', { attributes: [wmlAttr('val', bcp47)] }));
+        }
+    }
+    if (properties.dateStorageFormat !== undefined) {
+        children.push(wmlElement('storeMappedDataAs', {
+            attributes: [wmlAttr('val', properties.dateStorageFormat)],
+        }));
+    }
+    if (properties.dateCalendarType !== undefined) {
+        children.push(wmlElement('calendar', { attributes: [wmlAttr('val', properties.dateCalendarType)] }));
+    }
+    var attributes = [];
+    if (properties.fullDate !== undefined) {
+        attributes.push(wmlAttr('fullDate', properties.fullDate));
+    }
+    return wmlElement('date', { attributes: attributes, children: children });
+}
+function serializeCheckboxStateElement(localName, state) {
+    var attrs = [];
+    if (state.font !== undefined) {
+        attrs.push(nsAttr(WORDML_2010_NAMESPACE, W14_PREFIX, 'font', state.font));
+    }
+    if (state.value !== undefined) {
+        attrs.push(nsAttr(WORDML_2010_NAMESPACE, W14_PREFIX, 'val', state.value));
+    }
+    return nsElement(WORDML_2010_NAMESPACE, W14_PREFIX, localName, { attributes: attrs });
+}
+function serializeCheckboxElement(properties) {
+    var children = [
+        nsElement(WORDML_2010_NAMESPACE, W14_PREFIX, 'checked', {
+            attributes: [
+                nsAttr(WORDML_2010_NAMESPACE, W14_PREFIX, 'val', properties.isChecked ? '1' : '0'),
+            ],
+        }),
+        serializeCheckboxStateElement('checkedState', properties.checkedState),
+        serializeCheckboxStateElement('uncheckedState', properties.uncheckedState),
+    ];
+    return nsElement(WORDML_2010_NAMESPACE, W14_PREFIX, 'checkbox', { children: children });
+}
+function serializeTypeElement(properties) {
+    var type = properties.type;
+    if (type === undefined) {
+        return undefined;
+    }
+    if (type === 'checkbox') {
+        return serializeCheckboxElement(properties);
+    }
+    if (type === 'date') {
+        return serializeDateElement(properties);
+    }
+    if (type === 'comboBox' || type === 'dropDownList') {
+        var localName_1 = type === 'comboBox' ? 'comboBox' : 'dropDownList';
+        var children = properties.contentControlListItems.asReadonly().map(serializeListItem);
+        var attributes = [];
+        if (properties.lastValue !== undefined) {
+            attributes.push(wmlAttr('lastValue', properties.lastValue));
+        }
+        return wmlElement(localName_1, { attributes: attributes, children: children });
+    }
+    if (type === 'plainText') {
+        var attributes = [];
+        if (properties.multiline !== undefined) {
+            attributes.push(wmlAttr('multiLine', properties.multiline ? '1' : '0'));
+        }
+        return wmlElement('text', { attributes: attributes });
+    }
+    var localName = TYPE_TO_WML_LOCAL.get(type);
+    if (localName === undefined) {
+        return undefined;
+    }
+    return wmlElement(localName);
+}
+function serializeDataBinding(binding) {
+    var attributes = [];
+    if (binding.prefixMappings !== undefined) {
+        attributes.push(wmlAttr('prefixMappings', binding.prefixMappings));
+    }
+    attributes.push(wmlAttr('xpath', binding.xpath));
+    attributes.push(wmlAttr('storeItemID', binding.storeItemID));
+    return wmlElement('dataBinding', { attributes: attributes });
+}
+function serializeAppearance(appearance) {
+    return nsElement(WORDML_2012_NAMESPACE, W15_PREFIX, 'appearance', {
+        attributes: [nsAttr(WORDML_2012_NAMESPACE, W15_PREFIX, 'val', appearance)],
+    });
+}
+function serializeColor(properties) {
+    var hex = properties.color !== undefined ? colorToHexWire(properties.color) : undefined;
+    var themeColor = properties.themeColor;
+    var themeTint = properties.themeTint;
+    var themeShade = properties.themeShade;
+    if (hex === undefined && themeColor === undefined && themeTint === undefined && themeShade === undefined) {
+        return undefined;
+    }
+    var attributes = [];
+    if (hex !== undefined) {
+        attributes.push(wmlAttr('val', hex));
+    }
+    if (themeColor !== undefined) {
+        attributes.push(nsAttr(WORDML_2012_NAMESPACE, W15_PREFIX, 'themeColor', themeColor));
+    }
+    if (themeTint !== undefined) {
+        attributes.push(nsAttr(WORDML_2012_NAMESPACE, W15_PREFIX, 'themeTint', themeTint));
+    }
+    if (themeShade !== undefined) {
+        attributes.push(nsAttr(WORDML_2012_NAMESPACE, W15_PREFIX, 'themeShade', themeShade));
+    }
+    return nsElement(WORDML_2012_NAMESPACE, W15_PREFIX, 'color', { attributes: attributes });
+}
+/**
+ * Build `w:sdtPr` from modeled properties + residual.
+ *
+ * Child order follows Transitional `CT_SdtPr` sequence for WML members, with
+ * MS `appearance`/`color` after `temporary` and the kind choice last among
+ * modeled members, then residual unknowns.
+ */
+function buildSdtPrFromProperties(properties) {
+    var e_6, _a;
+    var children = [];
+    if (properties.title !== undefined) {
+        children.push(wmlElement('alias', { attributes: [wmlAttr('val', properties.title)] }));
+    }
+    if (properties.tag !== undefined) {
+        children.push(wmlElement('tag', { attributes: [wmlAttr('val', properties.tag)] }));
+    }
+    if (properties.id !== undefined) {
+        children.push(wmlElement('id', { attributes: [wmlAttr('val', String(properties.id))] }));
+    }
+    var lockWire = properties.lockWire;
+    if (lockWire !== undefined) {
+        children.push(wmlElement('lock', { attributes: [wmlAttr('val', lockWire)] }));
+    }
+    if (properties.placeholderDocPart !== undefined) {
+        children.push(wmlElement('placeholder', {
+            children: [
+                wmlElement('docPart', {
+                    attributes: [wmlAttr('val', properties.placeholderDocPart)],
+                }),
+            ],
+        }));
+    }
+    if (properties.isTemporary) {
+        children.push(serializeOnOffWml('temporary', true));
+    }
+    if (properties.appearance !== undefined) {
+        children.push(serializeAppearance(properties.appearance));
+    }
+    var colorEl = serializeColor(properties);
+    if (colorEl !== undefined) {
+        children.push(colorEl);
+    }
+    if (properties.dataBinding !== undefined) {
+        children.push(serializeDataBinding(properties.dataBinding));
+    }
+    var kindEl = serializeTypeElement(properties);
+    if (kindEl !== undefined) {
+        children.push(kindEl);
+    }
+    try {
+        for (var _b = __values(properties.residualChildren), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var residual = _c.value;
+            children.push(residual);
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+    var namespaceDeclarations = __spread(properties.namespaceDeclarations);
+    var needW14 = properties.type === 'checkbox' ||
+        namespaceDeclarations.some(function (d) { return d.namespaceUri === WORDML_2010_NAMESPACE; });
+    var needW15 = properties.appearance !== undefined ||
+        properties.color !== undefined ||
+        properties.themeColor !== undefined ||
+        namespaceDeclarations.some(function (d) { return d.namespaceUri === WORDML_2012_NAMESPACE; });
+    if (needW14 && !namespaceDeclarations.some(function (d) { return d.namespaceUri === WORDML_2010_NAMESPACE; })) {
+        namespaceDeclarations.push({ prefix: W14_PREFIX, namespaceUri: WORDML_2010_NAMESPACE });
+    }
+    if (needW15 && !namespaceDeclarations.some(function (d) { return d.namespaceUri === WORDML_2012_NAMESPACE; })) {
+        namespaceDeclarations.push({ prefix: W15_PREFIX, namespaceUri: WORDML_2012_NAMESPACE });
+    }
+    return wmlElement('sdtPr', {
+        attributes: properties.leftoverAttributes,
+        namespaceDeclarations: namespaceDeclarations,
+        children: children,
+    });
+}
+var detachedRunOwner = {
+    assertAttachedItem: function () {
+        return;
+    },
+};
+function parseInlineContent(children, owner) {
+    var e_7, _a;
+    var inlines = [];
+    try {
+        for (var children_1 = __values(children), children_1_1 = children_1.next(); !children_1_1.done; children_1_1 = children_1.next()) {
+            var child = children_1_1.value;
+            if (child.kind !== 'element') {
+                continue;
+            }
+            var element = child;
+            if (isWml(element, 'r')) {
+                inlines.push({ type: 'textRange', run: TextRange.fromXml(element, owner) });
+                continue;
+            }
+            var feature = tryParseFeatureInline(element);
+            if (feature !== undefined) {
+                inlines.push(feature);
+                continue;
+            }
+            inlines.push({ type: 'opaque', xml: element });
+        }
+    }
+    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+    finally {
+        try {
+            if (children_1_1 && !children_1_1.done && (_a = children_1.return)) _a.call(children_1);
+        }
+        finally { if (e_7) throw e_7.error; }
+    }
+    return inlines;
+}
+function serializeInlineContent(inlines) {
+    var e_8, _a;
+    var out = [];
+    try {
+        for (var inlines_1 = __values(inlines), inlines_1_1 = inlines_1.next(); !inlines_1_1.done; inlines_1_1 = inlines_1.next()) {
+            var inline = inlines_1_1.value;
+            if (inline.type === 'textRange') {
+                out.push(serializeRun(inline.run));
+            }
+            else if (inline.type === 'feature') {
+                out.push(serializeFeatureInline(inline));
+            }
+            else {
+                out.push(inline.xml);
+            }
+        }
+    }
+    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    finally {
+        try {
+            if (inlines_1_1 && !inlines_1_1.done && (_a = inlines_1.return)) _a.call(inlines_1);
+        }
+        finally { if (e_8) throw e_8.error; }
+    }
+    return out;
+}
+function releaseBlockContent(blocks) {
+    var e_9, _a;
+    try {
+        for (var blocks_1 = __values(blocks), blocks_1_1 = blocks_1.next(); !blocks_1_1.done; blocks_1_1 = blocks_1.next()) {
+            var block = blocks_1_1.value;
+            if (block.type === 'feature' && block.value instanceof ContentControl) {
+                block.value.releaseContent();
+            }
+        }
+    }
+    catch (e_9_1) { e_9 = { error: e_9_1 }; }
+    finally {
+        try {
+            if (blocks_1_1 && !blocks_1_1.done && (_a = blocks_1.return)) _a.call(blocks_1);
+        }
+        finally { if (e_9) throw e_9.error; }
+    }
+}
+function releaseInlineContent(inlines) {
+    var e_10, _a;
+    try {
+        for (var inlines_2 = __values(inlines), inlines_2_1 = inlines_2.next(); !inlines_2_1.done; inlines_2_1 = inlines_2.next()) {
+            var inline = inlines_2_1.value;
+            if (inline.type === 'feature' && inline.value instanceof ContentControl) {
+                inline.value.releaseContent();
+            }
+        }
+    }
+    catch (e_10_1) { e_10 = { error: e_10_1 }; }
+    finally {
+        try {
+            if (inlines_2_1 && !inlines_2_1.done && (_a = inlines_2.return)) _a.call(inlines_2);
+        }
+        finally { if (e_10) throw e_10.error; }
+    }
+}
+// ── ContentControl ───────────────────────────────────────────────────
+/**
+ * Structured document tag (`w:sdt`) base — shared properties, facades, and
+ * serialize hooks for block and inline content controls.
+ *
+ * Prefer {@link BlockContentControl} / {@link InlineContentControl} for new
+ * code. This class remains the shared base and legacy facade surface.
+ *
+ * @public
+ */
+var ContentControl = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function ContentControl(properties, sdtPr, sdtEndPr, preservedXml, rebuildSdtPr) {
+        if (rebuildSdtPr === void 0) { rebuildSdtPr = false; }
+        this.propertiesValue = properties;
+        this.sdtPr = sdtPr;
+        this.sdtEndPrRaw = sdtEndPr;
+        this.preservedXml = preservedXml;
+        this.documentOwner = undefined;
+        this.rebuildSdtPr = rebuildSdtPr;
+        this.rebuildSdtEndPr = false;
+        this.breakFormatDirty = false;
+        this.breakCharacterFormatInstance = new CharacterFormat(this);
+        if (sdtEndPr !== undefined) {
+            this.hydrateBreakCharacterFormat(sdtEndPr);
+        }
+        if (this.propertiesValue !== undefined) {
+            this.propertiesValue.bindOwner(this);
+        }
+    }
+    Object.defineProperty(ContentControl.prototype, "contentControlProperties", {
+        /**
+         * Always-defined typed property bag (created on first access when missing).
+         *
+         * @public
+         */
+        get: function () {
+            return this.ensureProperties();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControl.prototype, "properties", {
+        /**
+         * Gets the typed property bag for this content control.
+         *
+         * @public
+         */
+        get: function () {
+            return this.propertiesValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControl.prototype, "breakCharacterFormat", {
+        /**
+         * Character formatting for the SDT end mark (`w:sdtEndPr/w:rPr`).
+         *
+         * @public
+         */
+        get: function () {
+            return this.breakCharacterFormatInstance;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    ContentControl.prototype.notifyCharacterFormatMutation = function () {
+        this.breakFormatDirty = true;
+        this.rebuildSdtEndPr = true;
+    };
+    ContentControl.prototype.hydrateBreakCharacterFormat = function (sdtEndPr) {
+        var e_11, _a;
+        try {
+            for (var _b = __values(elementChildren(sdtEndPr)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var child = _c.value;
+                if (isWml(child, 'rPr')) {
+                    var snap = parseCharacterFormat(child);
+                    this.breakCharacterFormatInstance.hydrate(snap);
+                    this.breakFormatDirty = false;
+                    this.rebuildSdtEndPr = false;
+                    return;
+                }
+            }
+        }
+        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_11) throw e_11.error; }
+        }
+    };
+    ContentControl.prototype.serializeSdtEndPr = function () {
+        if (this.rebuildSdtEndPr || this.breakFormatDirty) {
+            var rPrChildren = this.breakCharacterFormatInstance.buildRPrChildren();
+            if (rPrChildren.length === 0 && this.sdtEndPrRaw === undefined) {
+                return undefined;
+            }
+            return wmlElement('sdtEndPr', {
+                children: [wmlElement('rPr', { children: rPrChildren })],
+            });
+        }
+        return this.sdtEndPrRaw;
+    };
+    /**
+     * @private
+     * Prefer modeled rebuild after any user-facing property write.
+     */
+    ContentControl.prototype.markSdtPrDirty = function () {
+        this.rebuildSdtPr = true;
+    };
+    /** @private */
+    ContentControl.prototype.synchronizeCheckboxContent = function () {
+        return;
+    };
+    /**
+     * Ensure a properties bag exists so facade setters can write fields on
+     * controls that loaded without a complete `sdtPr` model.
+     */
+    ContentControl.prototype.ensureProperties = function () {
+        if (this.propertiesValue === undefined) {
+            this.propertiesValue = new ContentControlProperties({});
+            this.propertiesValue.bindOwner(this);
+        }
+        return this.propertiesValue;
+    };
+    Object.defineProperty(ContentControl.prototype, "title", {
+        /**
+         * Gets or sets the friendly display name shown as the content-control title in Word.
+         *
+         * @public
+         */
+        get: function () {
+            return this.propertiesValue == null ? undefined : this.propertiesValue.title;
+        },
+        set: function (value) {
+            this.ensureProperties().title = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControl.prototype, "tag", {
+        /**
+         * Gets or sets the programmatic tag used to identify this content control in code.
+         *
+         * @public
+         */
+        get: function () {
+            return this.propertiesValue == null ? undefined : this.propertiesValue.tag;
+        },
+        set: function (value) {
+            this.ensureProperties().tag = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControl.prototype, "lockContentControl", {
+        /**
+         * Gets or sets whether the content-control definition is locked.
+         *
+         * @public
+         */
+        get: function () {
+            return this.ensureProperties().lockContentControl;
+        },
+        set: function (value) {
+            this.ensureProperties().lockContentControl = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControl.prototype, "lockContents", {
+        /**
+         * Gets or sets whether the content inside the control is locked.
+         *
+         * @public
+         */
+        get: function () {
+            return this.ensureProperties().lockContents;
+        },
+        set: function (value) {
+            this.ensureProperties().lockContents = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControl.prototype, "placeholderText", {
+        /**
+         * Gets or sets the placeholder document-part name used when the control shows placeholder content.
+         *
+         * @public
+         */
+        get: function () {
+            return this.propertiesValue == null ? undefined : this.propertiesValue.placeholderDocPart;
+        },
+        set: function (value) {
+            this.ensureProperties().placeholderDocPart = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControl.prototype, "type", {
+        /**
+         * Gets or sets the content-control kind.
+         *
+         * @public
+         */
+        get: function () {
+            return this.propertiesValue == null ? undefined : this.propertiesValue.type;
+        },
+        set: function (value) {
+            this.ensureProperties().type = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControl.prototype, "isTemporary", {
+        /**
+         * Gets or sets whether the control is removed after its contents are edited once.
+         *
+         * @public
+         */
+        get: function () {
+            return this.ensureProperties().isTemporary;
+        },
+        set: function (value) {
+            this.ensureProperties().isTemporary = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControl.prototype, "appearance", {
+        /**
+         * Gets or sets how the control chrome is shown.
+         *
+         * @public
+         */
+        get: function () {
+            return this.propertiesValue == null ? undefined : this.propertiesValue.appearance;
+        },
+        set: function (value) {
+            this.ensureProperties().appearance = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControl.prototype, "color", {
+        /**
+         * Gets or sets the border/chrome color for the content control.
+         *
+         * @public
+         */
+        get: function () {
+            return this.propertiesValue == null ? undefined : this.propertiesValue.color;
+        },
+        set: function (value) {
+            this.ensureProperties().color = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControl.prototype, "isChecked", {
+        /**
+         * Gets or sets whether a checkbox control is checked.
+         *
+         * @public
+         */
+        get: function () {
+            return this.ensureProperties().isChecked;
+        },
+        set: function (value) {
+            this.ensureProperties().isChecked = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControl.prototype, "checkedState", {
+        /**
+         * Checked-state symbol (stable identity).
+         *
+         * @public
+         */
+        get: function () {
+            return this.ensureProperties().checkedState;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControl.prototype, "uncheckedState", {
+        /**
+         * Unchecked-state symbol (stable identity).
+         *
+         * @public
+         */
+        get: function () {
+            return this.ensureProperties().uncheckedState;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControl.prototype, "fullDate", {
+        /**
+         * Full date/time stored value.
+         *
+         * @public
+         */
+        get: function () {
+            return this.propertiesValue == null ? undefined : this.propertiesValue.fullDate;
+        },
+        set: function (value) {
+            this.ensureProperties().fullDate = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControl.prototype, "dateDisplayFormat", {
+        /**
+         * Display format pattern for the date.
+         *
+         * @public
+         */
+        get: function () {
+            return this.propertiesValue == null ? undefined : this.propertiesValue.dateDisplayFormat;
+        },
+        set: function (value) {
+            this.ensureProperties().dateDisplayFormat = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControl.prototype, "dateDisplayLocale", {
+        /**
+         * Locale used for date display.
+         *
+         * @public
+         */
+        get: function () {
+            return this.propertiesValue == null ? undefined : this.propertiesValue.dateDisplayLocale;
+        },
+        set: function (value) {
+            this.ensureProperties().dateDisplayLocale = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControl.prototype, "dateStorageFormat", {
+        /**
+         * How mapped date data is stored.
+         *
+         * @public
+         */
+        get: function () {
+            return this.propertiesValue == null ? undefined : this.propertiesValue.dateStorageFormat;
+        },
+        set: function (value) {
+            this.ensureProperties().dateStorageFormat = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControl.prototype, "dateCalendarType", {
+        /**
+         * Calendar system for the date control.
+         *
+         * @public
+         */
+        get: function () {
+            return this.propertiesValue == null ? undefined : this.propertiesValue.dateCalendarType;
+        },
+        set: function (value) {
+            this.ensureProperties().dateCalendarType = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControl.prototype, "contentControlListItems", {
+        /**
+         * Combo-box / drop-down list items (stable identity).
+         *
+         * @public
+         */
+        get: function () {
+            return this.ensureProperties().contentControlListItems;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControl.prototype, "lastValue", {
+        /**
+         * Gets or sets the last selected value for a combo-box or drop-down list control.
+         *
+         * @public
+         */
+        get: function () {
+            return this.propertiesValue == null ? undefined : this.propertiesValue.lastValue;
+        },
+        set: function (value) {
+            this.ensureProperties().lastValue = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControl.prototype, "multiline", {
+        /**
+         * Gets or sets whether a plain-text content control accepts multiple lines of text.
+         *
+         * @public
+         */
+        get: function () {
+            return this.propertiesValue == null ? undefined : this.propertiesValue.multiline;
+        },
+        set: function (value) {
+            this.ensureProperties().multiline = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControl.prototype, "blockContentControl", {
+        /**
+         * Compatibility: block children projected as BodyItem[] (block controls only).
+         *
+         * @public
+         */
+        get: function () {
+            return undefined;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ContentControl.prototype, "inlineContentControl", {
+        /**
+         * Compatibility: inline bag children (inline controls only).
+         *
+         * @public
+         */
+        get: function () {
+            return undefined;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    ContentControl.prototype.releaseContent = function () {
+        return;
+    };
+    /**
+     * @private
+     * Bind owning document so nested content can mutate.
+     */
+    ContentControl.prototype.bindDocument = function (document) {
+        this.documentOwner = document;
+    };
+    /**
+     * @private
+     */
+    ContentControl.prototype.owningDocument = function () {
+        if (this.documentOwner === undefined) {
+            throw new DetachedObjectError('This content control is not bound to a document');
+        }
+        return this.documentOwner;
+    };
+    /**
+     * @private
+     */
+    ContentControl.prototype.buildSdtShell = function (contentChildren) {
+        if (this.preservedXml !== undefined) {
+            return this.preservedXml;
+        }
+        var children = [];
+        if (this.rebuildSdtPr && this.propertiesValue !== undefined) {
+            children.push(buildSdtPrFromProperties(this.propertiesValue));
+        }
+        else if (this.sdtPr !== undefined) {
+            children.push(this.sdtPr);
+        }
+        else if (this.propertiesValue !== undefined) {
+            children.push(buildSdtPrFromProperties(this.propertiesValue));
+        }
+        var endPr = this.serializeSdtEndPr();
+        if (endPr !== undefined) {
+            children.push(endPr);
+        }
+        children.push(wmlElement('sdtContent', { children: contentChildren }));
+        return wmlElement('sdt', { children: children });
+    };
+    /**
+     * @private
+     */
+    ContentControl.prototype.toOpenXml = function () {
+        return this.buildSdtShell([]);
+    };
+    return ContentControl;
+}());
+export { ContentControl };
+/**
+ * Block-level structured document tag (`w:sdt` / `CT_SdtBlock`).
+ *
+ * Owns a nested {@link Body} whose {@link Body.items} are the live DOM for
+ * `w:sdtContent` children. Public identity is this instance (BodyItem).
+ *
+ * @public
+ */
+var BlockContentControl = /** @class */ (function (_super) {
+    __extends(BlockContentControl, _super);
+    /**
+     * @private
+     */
+    function BlockContentControl(properties, sdtPr, sdtEndPr, blocks, preservedXml, rebuildSdtPr, document) {
+        var e_12, _a;
+        if (rebuildSdtPr === void 0) { rebuildSdtPr = false; }
+        var _this = _super.call(this, properties, sdtPr, sdtEndPr, preservedXml, rebuildSdtPr) || this;
+        _this.isBlockLevel = true;
+        _this.bodyInstance = new Body(document, blocks != null ? blocks : []);
+        try {
+            // Nested body paragraphs attach via Body constructor; re-bind CC as owner for assertAttached.
+            for (var _b = __values(_this.bodyInstance.rawBlocks()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var block = _c.value;
+                if (block.type === 'paragraph') {
+                    block.paragraph.attach(_this);
+                }
+            }
+        }
+        catch (e_12_1) { e_12 = { error: e_12_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_12) throw e_12.error; }
+        }
+        return _this;
+    }
+    Object.defineProperty(BlockContentControl.prototype, "body", {
+        /**
+         * Nested body for block content-control children (`w:sdtContent`).
+         *
+         * @public
+         */
+        get: function () {
+            return this.bodyInstance;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(BlockContentControl.prototype, "blockContentControl", {
+        /**
+         * Projected public children (compat with prior APIs).
+         *
+         * @public
+         */
+        get: function () {
+            var e_13, _a;
+            var out = [];
+            try {
+                for (var _b = __values(this.bodyInstance.rawBlocks()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var block = _c.value;
+                    var item = projectBlockToBodyItem(block);
+                    if (item !== undefined) {
+                        out.push(item);
+                    }
+                }
+            }
+            catch (e_13_1) { e_13 = { error: e_13_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_13) throw e_13.error; }
+            }
+            return out;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    BlockContentControl.prototype.releaseContent = function () {
+        releaseBlockContent(this.bodyInstance.rawBlocks());
+    };
+    /**
+     * @private
+     */
+    BlockContentControl.prototype.bindDocument = function (document) {
+        var e_14, _a;
+        _super.prototype.bindDocument.call(this, document);
+        this.bodyInstance.setOwningDocument(document);
+        try {
+            for (var _b = __values(this.bodyInstance.rawBlocks()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var block = _c.value;
+                if (block.type === 'paragraph') {
+                    block.paragraph.attach(this);
+                }
+                if (block.type === 'feature' && block.value instanceof ContentControl) {
+                    block.value.bindDocument(document);
+                }
+            }
+        }
+        catch (e_14_1) { e_14 = { error: e_14_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_14) throw e_14.error; }
+        }
+    };
+    /**
+     * @private
+     */
+    BlockContentControl.prototype.assertAttachedParagraph = function (target) {
+        var e_15, _a;
+        var found = false;
+        try {
+            for (var _b = __values(this.bodyInstance.rawBlocks()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var block = _c.value;
+                if (block.type === 'paragraph' && block.paragraph === target) {
+                    found = true;
+                    break;
+                }
+            }
+        }
+        catch (e_15_1) { e_15 = { error: e_15_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_15) throw e_15.error; }
+        }
+        if (!found) {
+            throw new DetachedObjectError('Paragraph is not in this content control');
+        }
+    };
+    /**
+     * @private
+     */
+    BlockContentControl.prototype.toOpenXml = function () {
+        return this.buildSdtShell(serializeBodyBlocks(this.bodyInstance.rawBlocks()));
+    };
+    return BlockContentControl;
+}(ContentControl));
+export { BlockContentControl };
+/**
+ * Inline (run-level) structured document tag (`w:sdt` / `CT_SdtRun`).
+ *
+ * Owns a {@link ParagraphItemCollection} for `w:sdtContent` children.
+ * Projected as a public paragraph item via EntityType unwrap.
+ *
+ * @public
+ */
+var InlineContentControl = /** @class */ (function (_super) {
+    __extends(InlineContentControl, _super);
+    /**
+     * @private
+     */
+    function InlineContentControl(properties, sdtPr, sdtEndPr, initialItems, preservedXml, rebuildSdtPr) {
+        if (rebuildSdtPr === void 0) { rebuildSdtPr = false; }
+        var _this = _super.call(this, properties, sdtPr, sdtEndPr, preservedXml, rebuildSdtPr) || this;
+        /**
+         * Discriminator for paragraph-item projection (`projectPublicItem`).
+         *
+         * @public
+         */
+        _this.entityType = EntityType.InlineContentControl;
+        _this.paragraphItemsInstance = new ParagraphItemCollection(_this);
+        _this.itemOwner = undefined;
+        if (initialItems !== undefined && initialItems.length > 0) {
+            _this.paragraphItemsInstance.hydrate(initialItems);
+        }
+        return _this;
+    }
+    Object.defineProperty(InlineContentControl.prototype, "paragraphItems", {
+        /**
+         * Live paragraph items inside this inline content control.
+         *
+         * @public
+         */
+        get: function () {
+            return this.paragraphItemsInstance;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(InlineContentControl.prototype, "inlineContentControl", {
+        /**
+         * Compatibility bags for legacy tests (`{ type:'textRange', run }`).
+         *
+         * @public
+         */
+        get: function () {
+            var e_16, _a;
+            var out = [];
+            try {
+                for (var _b = __values(this.paragraphItemsInstance), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var item = _c.value;
+                    if (item instanceof TextRange) {
+                        out.push({ type: 'textRange', run: item });
+                    }
+                    else if (item instanceof FeatureInlineParagraphItem) {
+                        out.push({
+                            type: 'feature',
+                            featureId: item.featureId,
+                            value: item.value,
+                        });
+                    }
+                    else if (item instanceof OpaqueParagraphItem) {
+                        out.push({ type: 'opaque', xml: item.xml });
+                    }
+                    else if (typeof item.toOpenXml === 'function') {
+                        out.push({ type: 'opaque', xml: item.toOpenXml() });
+                    }
+                }
+            }
+            catch (e_16_1) { e_16 = { error: e_16_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_16) throw e_16.error; }
+            }
+            return out;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(InlineContentControl.prototype, "owner", {
+        /**
+         * @private
+         */
+        get: function () {
+            return this.itemOwner;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    InlineContentControl.prototype.attach = function (owner) {
+        this.itemOwner = owner;
+        this.paragraphItemsInstance.reattachAll();
+    };
+    /**
+     * @private
+     */
+    InlineContentControl.prototype.detach = function () {
+        this.paragraphItemsInstance.detachAll();
+        this.itemOwner = undefined;
+    };
+    /**
+     * @private
+     */
+    InlineContentControl.prototype.assertAttachedItem = function (target) {
+        if (!this.paragraphItemsInstance.containsIdentity(target)) {
+            throw new DetachedObjectError('Paragraph item is not in this content control');
+        }
+    };
+    /**
+     * @private
+     */
+    InlineContentControl.prototype.assertMutable = function () {
+        return;
+    };
+    /**
+     * @private
+     */
+    InlineContentControl.prototype.releaseContent = function () {
+        var e_17, _a;
+        try {
+            for (var _b = __values(this.paragraphItemsInstance), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var item = _c.value;
+                if (item instanceof InlineContentControl) {
+                    item.releaseContent();
+                }
+                else if (item instanceof FeatureInlineParagraphItem && item.value instanceof ContentControl) {
+                    item.value.releaseContent();
+                }
+            }
+        }
+        catch (e_17_1) { e_17 = { error: e_17_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_17) throw e_17.error; }
+        }
+    };
+    /** @private */
+    InlineContentControl.prototype.synchronizeCheckboxContent = function () {
+        var properties = this.properties;
+        if (properties === undefined || properties.type !== 'checkbox') {
+            return;
+        }
+        var state = properties.isChecked ? properties.checkedState : properties.uncheckedState;
+        var fallback = properties.isChecked
+            ? DEFAULT_CHECKED_SYMBOL_TEXT
+            : DEFAULT_UNCHECKED_SYMBOL_TEXT;
+        var symbol = fallback;
+        if (state.value !== undefined && /^[0-9A-Fa-f]{1,6}$/.test(state.value)) {
+            var codePoint = Number.parseInt(state.value, 16);
+            if (codePoint <= 0x10FFFF) {
+                symbol = String.fromCodePoint(codePoint);
+            }
+        }
+        var items = __spread(this.paragraphItemsInstance);
+        var first = items.length === 1 ? items[0] : undefined;
+        if (first instanceof TextRange) {
+            first.text = symbol;
+            return;
+        }
+        if (items.length !== 0) {
+            return;
+        }
+        try {
+            var run = new TextRange(this.owningDocument());
+            run.text = symbol;
+            this.paragraphItemsInstance.add(run);
+        }
+        catch (_a) {
+            // Initialize later when the detached control is bound to a document.
+        }
+    };
+    /**
+     * @private
+     */
+    InlineContentControl.prototype.bindDocument = function (document) {
+        var e_18, _a;
+        _super.prototype.bindDocument.call(this, document);
+        try {
+            for (var _b = __values(this.paragraphItemsInstance), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var item = _c.value;
+                if (item instanceof ContentControl) {
+                    item.bindDocument(document);
+                }
+                else if (item instanceof FeatureInlineParagraphItem && item.value instanceof ContentControl) {
+                    item.value.bindDocument(document);
+                }
+            }
+        }
+        catch (e_18_1) { e_18 = { error: e_18_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_18) throw e_18.error; }
+        }
+        this.synchronizeCheckboxContent();
+    };
+    /**
+     * @private
+     */
+    InlineContentControl.prototype.toOpenXml = function () {
+        return this.buildSdtShell(serializeParagraphItems(__spread(this.paragraphItemsInstance)));
+    };
+    return InlineContentControl;
+}(ContentControl));
+export { InlineContentControl };
+function bagsToParagraphItems(inlines) {
+    var e_19, _a;
+    var items = [];
+    try {
+        for (var inlines_3 = __values(inlines), inlines_3_1 = inlines_3.next(); !inlines_3_1.done; inlines_3_1 = inlines_3.next()) {
+            var inline = inlines_3_1.value;
+            if (inline.type === 'textRange') {
+                items.push(inline.run);
+                continue;
+            }
+            if (inline.type === 'feature') {
+                items.push(new FeatureInlineParagraphItem(inline.featureId, inline.value));
+                continue;
+            }
+            items.push(new OpaqueParagraphItem(inline.xml));
+        }
+    }
+    catch (e_19_1) { e_19 = { error: e_19_1 }; }
+    finally {
+        try {
+            if (inlines_3_1 && !inlines_3_1.done && (_a = inlines_3.return)) _a.call(inlines_3);
+        }
+        finally { if (e_19) throw e_19.error; }
+    }
+    return items;
+}
+function splitSdtChildren(element) {
+    var e_20, _a;
+    var sdtPr;
+    var sdtEndPr;
+    var sdtContent;
+    try {
+        for (var _b = __values(elementChildren(element)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (isWml(child, 'sdtPr')) {
+                sdtPr = child;
+            }
+            else if (isWml(child, 'sdtEndPr')) {
+                sdtEndPr = child;
+            }
+            else if (isWml(child, 'sdtContent')) {
+                sdtContent = child;
+            }
+        }
+    }
+    catch (e_20_1) { e_20 = { error: e_20_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_20) throw e_20.error; }
+    }
+    return { sdtPr: sdtPr, sdtEndPr: sdtEndPr, sdtContent: sdtContent };
+}
+function parseContentControl(element, mode, ctx) {
+    if (!isWml(element, 'sdt')) {
+        return undefined;
+    }
+    var _a = splitSdtChildren(element), sdtPr = _a.sdtPr, sdtEndPr = _a.sdtEndPr, sdtContent = _a.sdtContent;
+    var properties = parseContentControlProperties(sdtPr);
+    if (sdtContent === undefined && sdtPr === undefined && sdtEndPr === undefined) {
+        if (mode === 'block') {
+            return new BlockContentControl(undefined, undefined, undefined, [], element);
+        }
+        return new InlineContentControl(undefined, undefined, undefined, [], element);
+    }
+    if (mode === 'block') {
+        var blocks = sdtContent !== undefined ? parseBodyBlocks(sdtContent.children, ctx) : [];
+        return new BlockContentControl(properties, sdtPr, sdtEndPr, blocks, undefined);
+    }
+    var inlines = sdtContent !== undefined ? parseInlineContent(sdtContent.children, detachedRunOwner) : [];
+    return new InlineContentControl(properties, sdtPr, sdtEndPr, bagsToParagraphItems(inlines), undefined);
+}
+function contentControlsFromBlocks(blocks) {
+    var e_21, _a;
+    var found = [];
+    try {
+        for (var blocks_2 = __values(blocks), blocks_2_1 = blocks_2.next(); !blocks_2_1.done; blocks_2_1 = blocks_2.next()) {
+            var block = blocks_2_1.value;
+            if (block instanceof ContentControl) {
+                found.push(block);
+                continue;
+            }
+            if (typeof block === 'object' && block !== null && 'type' in block) {
+                var candidate = block;
+                if (candidate.type === 'feature' && candidate.value instanceof ContentControl) {
+                    found.push(candidate.value);
+                }
+            }
+        }
+    }
+    catch (e_21_1) { e_21 = { error: e_21_1 }; }
+    finally {
+        try {
+            if (blocks_2_1 && !blocks_2_1.done && (_a = blocks_2.return)) _a.call(blocks_2);
+        }
+        finally { if (e_21) throw e_21.error; }
+    }
+    return found;
+}
+function contentControlsFromInlines(inlines) {
+    var e_22, _a;
+    var found = [];
+    try {
+        for (var inlines_4 = __values(inlines), inlines_4_1 = inlines_4.next(); !inlines_4_1.done; inlines_4_1 = inlines_4.next()) {
+            var inline = inlines_4_1.value;
+            if (inline instanceof InlineContentControl) {
+                found.push(inline);
+                continue;
+            }
+            if (inline instanceof FeatureInlineParagraphItem && inline.value instanceof ContentControl) {
+                found.push(inline.value);
+            }
+        }
+    }
+    catch (e_22_1) { e_22 = { error: e_22_1 }; }
+    finally {
+        try {
+            if (inlines_4_1 && !inlines_4_1.done && (_a = inlines_4.return)) _a.call(inlines_4);
+        }
+        finally { if (e_22) throw e_22.error; }
+    }
+    return found;
+}
+// ── Authoring ───────────────────────────────────────────────────────────────
+/**
+ * Create a detached block-level content control (`w:sdt`) ready for append.
+ *
+ * @private
+ */
+export function createBlockContentControl(type) {
+    requireAuthorableType(type);
+    var properties = type !== undefined ? new ContentControlProperties({ type: type }) : undefined;
+    var sdtPr = properties !== undefined ? buildSdtPrFromProperties(properties) : undefined;
+    var paragraph = new Paragraph(undefined);
+    var sdt = new BlockContentControl(properties, sdtPr, undefined, [{ type: 'paragraph', paragraph: paragraph }], undefined, true);
+    paragraph.attach(sdt);
+    return sdt;
+}
+/**
+ * Create a detached run-level content control (`w:sdt`) ready for append.
+ *
+ * @private
+ */
+export function createInlineContentControl(type) {
+    requireAuthorableType(type);
+    var properties = type !== undefined ? new ContentControlProperties({ type: type }) : undefined;
+    var sdtPr = properties !== undefined ? buildSdtPrFromProperties(properties) : undefined;
+    return new InlineContentControl(properties, sdtPr, undefined, [], undefined, true);
+}
+Object.defineProperty(Body.prototype, 'addBlockContentControl', {
+    value: function (type) {
+        var sdt = createBlockContentControl(type);
+        this.appendRawBlock({ type: 'feature', featureId: CONTENT_CONTROLS, value: sdt });
+        sdt.bindDocument(this.owningDocument());
+        return sdt;
+    },
+    writable: true,
+    configurable: true,
+});
+Object.defineProperty(WordDocument.prototype, 'addBlockContentControl', {
+    value: function (type) {
+        var body = this.firstSectionBody();
+        return body.addBlockContentControl(type);
+    },
+    writable: true,
+    configurable: true,
+});
+Object.defineProperty(Paragraph.prototype, 'appendInlineContentControl', {
+    value: function (type) {
+        var sdt = createInlineContentControl(type);
+        this.appendFeatureInline(CONTENT_CONTROLS, sdt);
+        try {
+            sdt.bindDocument(this.owningDocument());
+        }
+        catch (_a) {
+            // Detached paragraph — bind later when the paragraph attaches.
+        }
+        return sdt;
+    },
+    writable: true,
+    configurable: true,
+});
+var registered = false;
+/**
+ * @private
+ * Test hook */
+export function resetContentControlsFeatureForTests() {
+    registered = false;
+}
+/**
+ * @private
+ * Register structured document tag handlers. Idempotent. */
+export function registerContentControlsFeature() {
+    if (registered) {
+        return;
+    }
+    registered = true;
+    registerFeature({ id: CONTENT_CONTROLS });
+    registerFeatureInlineHandler({
+        featureId: CONTENT_CONTROLS,
+        wmlLocalName: 'sdt',
+        tryParse: function (element) {
+            return parseContentControl(element, 'inline', detachedBodyBlockParseContext());
+        },
+    });
+    registerFeatureBlockHandler({
+        featureId: CONTENT_CONTROLS,
+        wmlLocalName: 'sdt',
+        tryParse: function (element, ctx) {
+            return parseContentControl(element, 'block', ctx);
+        },
+    });
+    registerFeatureBlockParagraphWalker({
+        featureId: CONTENT_CONTROLS,
+        visitParagraphs: function (block, visit) {
+            if (block instanceof BlockContentControl) {
+                visitBlocksInDocumentOrder(block.body.rawBlocks(), visit);
+            }
+        },
+    });
+    registerBodyItemAdapter({
+        project: function (block) {
+            if (block.featureId === CONTENT_CONTROLS && block.value instanceof ContentControl) {
+                return block.value;
+            }
+            return undefined;
+        },
+        toBlock: function (item) {
+            if (item instanceof ContentControl) {
+                return { type: 'feature', featureId: CONTENT_CONTROLS, value: item };
+            }
+            return undefined;
+        },
+        isInstance: function (item) {
+            return item instanceof BlockContentControl || item instanceof ContentControl;
+        },
+    });
+    registerTypedCollectionHooks({
+        isBlockContentControl: function (item) {
+            return item instanceof BlockContentControl || (item instanceof ContentControl && item.isBlockLevel === true);
+        },
+        createBlockContentControl: function () {
+            return createBlockContentControl();
+        },
+    });
+}
+/**
+ * Block-level SDTs in a block list, in document order.
+ *
+ * @private
+ */
+export function structuredDocumentTagsInBlocks(blocks) {
+    return contentControlsFromBlocks(blocks);
+}
+/**
+ * Run-level SDTs in a paragraph, in document order.
+ *
+ * @private
+ */
+export function structuredDocumentTagsInParagraph(paragraph) {
+    return contentControlsFromInlines(paragraph.items.toArray());
+}
+/**
+ * Whether inline content is a modeled SDT from this module.
+ *
+ * @private
+ */
+export function isStructuredDocumentTagInline(inline) {
+    return (inline instanceof FeatureInlineParagraphItem &&
+        inline.featureId === CONTENT_CONTROLS &&
+        inline.value instanceof ContentControl);
+}
+/**
+ * Feature id constant for the content-controls module (used by host features
+ * that embed SDT blocks, e.g. text box bodies in the drawing module).
+ *
+ * @private
+ */
+export var CONTENT_CONTROLS_FEATURE_ID = CONTENT_CONTROLS;
+/**
+ * Whether a body block is a modeled block-level SDT (`w:sdt`) from this module.
+ *
+ * Prefer with {@link elementTypeOf} when branching on body children:
+ * `elementTypeOf(item) === 'blockContentControl'` then narrow with this guard.
+ *
+ * @param block - Body child to test.
+ * @returns `true` when `block` is a modeled block {@link ContentControl}.
+ *
+ * @private
+ */
+export function isBlockContentControl(block) {
+    if (block instanceof BlockContentControl) {
+        return true;
+    }
+    if (block instanceof ContentControl && block.isBlockLevel === true) {
+        return true;
+    }
+    if (typeof block !== 'object' || block === null) {
+        return false;
+    }
+    var candidate = block;
+    return (candidate.type === 'feature' &&
+        candidate.featureId === CONTENT_CONTROLS &&
+        candidate.value instanceof ContentControl &&
+        (candidate.value instanceof BlockContentControl || candidate.value.isBlockLevel === true));
+}
+/** True when `value` is a public block ContentControl body item. */
+export function isBlockContentControlBodyItem(value) {
+    return value instanceof BlockContentControl || (value instanceof ContentControl && value.isBlockLevel === true);
+}
+registerAlwaysOnBodyFeatureBootstrap(function () {
+    registerContentControlsFeature();
+});
+registerContentControlsFeature();