@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/font-table/font-table-entry.js

@@ -0,0 +1,823 @@
+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;
+};
+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 _a;
+import { parseOnOff, serializeOnOff } from '../document/on-off';
+import { elementChildren, isWml, wmlAttr, wmlElement, wValAttribute, WML, } from '../document/wml';
+import { objectValues } from '../../core/compat/object-compat';
+/**
+ * Office WordDocument relationships namespace for `r:id` on `CT_FontRel` / `CT_Rel`
+ * (Transitional `wml.xsd`).
+ */
+var OFFICE_RELATIONSHIPS_NAMESPACE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships';
+/**
+ * Font family values for `w:family/@w:val` (`ST_FontFamily`, Transitional `wml.xsd`).
+ *
+ * @private
+ */
+export var FontFamily = {
+    Decorative: 'decorative',
+    Modern: 'modern',
+    Roman: 'roman',
+    Script: 'script',
+    Swiss: 'swiss',
+    Auto: 'auto',
+};
+/**
+ * Pitch values for `w:pitch/@w:val` (`ST_Pitch`, Transitional `wml.xsd`).
+ *
+ * @private
+ */
+export var FontPitch = {
+    Fixed: 'fixed',
+    Variable: 'variable',
+    Default: 'default',
+};
+/**
+ * Embedded font face slot (`w:embedRegular` / `Bold` / `Italic` / `BoldItalic`).
+ *
+ * @private
+ */
+export var FontEmbedSlot = {
+    Regular: 'regular',
+    Bold: 'bold',
+    Italic: 'italic',
+    BoldItalic: 'boldItalic',
+};
+var FONT_FAMILY_VALUES = new Set(objectValues(FontFamily));
+var FONT_PITCH_VALUES = new Set(objectValues(FontPitch));
+var EMBED_LOCAL_BY_SLOT = (_a = {},
+    _a[FontEmbedSlot.Regular] = 'embedRegular',
+    _a[FontEmbedSlot.Bold] = 'embedBold',
+    _a[FontEmbedSlot.Italic] = 'embedItalic',
+    _a[FontEmbedSlot.BoldItalic] = 'embedBoldItalic',
+    _a);
+var EMBED_SLOT_BY_LOCAL = {
+    embedRegular: FontEmbedSlot.Regular,
+    embedBold: FontEmbedSlot.Bold,
+    embedItalic: FontEmbedSlot.Italic,
+    embedBoldItalic: FontEmbedSlot.BoldItalic,
+};
+/**
+ * One `w:font` row in `fontTable.xml` (`CT_Font`, Transitional `wml.xsd`).
+ *
+ * Models the full schema child sequence after `w:name`:
+ * `altName`, `panose1`, `charset`, `family`, `notTrueType`, `pitch`, `sig`,
+ * `embedRegular`, `embedBold`, `embedItalic`, `embedBoldItalic`, then residual
+ * unknown children.
+ *
+ * Substitution remains `w:altName` (ECMA-376-1 §17.8.3.1). Embed APIs expose
+ * relationship metadata only; they do not author or decode ODTTF binaries.
+ * `clearEmbed` drops the corresponding child element (markup only); package
+ * orphan cleanup of the target part is not performed in this MVP.
+ *
+ * @private
+ */
+var FontTableFont = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function FontTableFont(name, options, markDirty) {
+        this.nameValue = name;
+        this.alternateNameValue = options.alternateName;
+        this.panoseValue = options.panose;
+        this.charsetValue = options.charset;
+        this.familyValue = options.family;
+        this.familyRawValue = options.familyRaw;
+        this.notTrueTypeValue = options.notTrueType;
+        this.pitchValue = options.pitch;
+        this.pitchRawValue = options.pitchRaw;
+        this.signatureValue = options.signature;
+        this.embeds = options.embeds !== undefined ? options.embeds.map(cloneEmbed) : [];
+        this.residualChildren =
+            options.residualChildren !== undefined ? __spread(options.residualChildren) : [];
+        this.extraAttributes =
+            options.extraAttributes !== undefined ? __spread(options.extraAttributes) : [];
+        this.markDirty = markDirty;
+    }
+    Object.defineProperty(FontTableFont.prototype, "name", {
+        /**
+         * Primary name from `w:font/@w:name` (stored casing preserved).
+         *
+         * @public
+         */
+        get: function () {
+            return this.nameValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(FontTableFont.prototype, "alternateName", {
+        /**
+         * Alternate name list as stored on `w:altName/@w:val`, or `undefined` if absent.
+         *
+         * ECMA-376-1 §17.8.3.1: comma-delimited list; writers may set a single name or a
+         * full list string. Assign `undefined` (or empty / whitespace-only) to remove
+         * `w:altName`; the font entry is kept. Empty `w:val` is never emitted.
+         *
+         * @public
+         */
+        get: function () {
+            return this.alternateNameValue;
+        },
+        set: function (value) {
+            if (value === undefined || value.trim().length === 0) {
+                if (this.alternateNameValue === undefined) {
+                    return;
+                }
+                this.alternateNameValue = undefined;
+                this.markDirty();
+                return;
+            }
+            if (this.alternateNameValue === value) {
+                return;
+            }
+            this.alternateNameValue = value;
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(FontTableFont.prototype, "alternateNames", {
+        /**
+         * Split {@link alternateName} on commas; empty segments (adjacent commas) dropped
+         * per ECMA. Empty array when no `altName`.
+         *
+         * @public
+         */
+        get: function () {
+            var e_1, _a;
+            if (this.alternateNameValue === undefined) {
+                return [];
+            }
+            var parts = [];
+            try {
+                for (var _b = __values(this.alternateNameValue.split(',')), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var segment = _c.value;
+                    var trimmed = segment.trim();
+                    if (trimmed.length > 0) {
+                        parts.push(trimmed);
+                    }
+                }
+            }
+            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 parts;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(FontTableFont.prototype, "panose", {
+        /**
+         * PANOSE-1 classification from `w:panose1/@w:val` (`ST_Panose`), or `undefined`.
+         * Stored as the attribute string. Assign `undefined` / empty to clear.
+         *
+         * @public
+         */
+        get: function () {
+            return this.panoseValue;
+        },
+        set: function (value) {
+            var next = normalizeOptionalString(value);
+            if (this.panoseValue === next) {
+                return;
+            }
+            this.panoseValue = next;
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(FontTableFont.prototype, "charset", {
+        /**
+         * Character set from `w:charset/@w:val` (`ST_UcharHexNumber`), or `undefined`.
+         * Stored as the attribute string. Assign `undefined` / empty to clear.
+         *
+         * @public
+         */
+        get: function () {
+            return this.charsetValue;
+        },
+        set: function (value) {
+            var next = normalizeOptionalString(value);
+            if (this.charsetValue === next) {
+                return;
+            }
+            this.charsetValue = next;
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(FontTableFont.prototype, "family", {
+        /**
+         * Font family from `w:family/@w:val` (`ST_FontFamily`), or `undefined` when
+         * absent or not a known enumeration value on load.
+         *
+         * @throws RangeError when assigning a string that is not a {@link FontFamily} value.
+         *
+         * @public
+         */
+        get: function () {
+            return this.familyValue;
+        },
+        set: function (value) {
+            if (value === undefined) {
+                if (this.familyValue === undefined && this.familyRawValue === undefined) {
+                    return;
+                }
+                this.familyValue = undefined;
+                this.familyRawValue = undefined;
+                this.markDirty();
+                return;
+            }
+            assertFontFamily(value);
+            if (this.familyValue === value && this.familyRawValue === undefined) {
+                return;
+            }
+            this.familyValue = value;
+            this.familyRawValue = undefined;
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(FontTableFont.prototype, "notTrueType", {
+        /**
+         * `w:notTrueType` (`CT_OnOff`). `true` when the element is present without `val`
+         * or with a true `ST_OnOff` value; `false` when explicitly off; `undefined` when
+         * the child is absent.
+         *
+         * @public
+         */
+        get: function () {
+            return this.notTrueTypeValue;
+        },
+        set: function (value) {
+            if (this.notTrueTypeValue === value) {
+                return;
+            }
+            this.notTrueTypeValue = value;
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(FontTableFont.prototype, "pitch", {
+        /**
+         * Pitch from `w:pitch/@w:val` (`ST_Pitch`), or `undefined` when absent or not a
+         * known enumeration value on load.
+         *
+         * @throws RangeError when assigning a string that is not a {@link FontPitch} value.
+         *
+         * @public
+         */
+        get: function () {
+            return this.pitchValue;
+        },
+        set: function (value) {
+            if (value === undefined) {
+                if (this.pitchValue === undefined && this.pitchRawValue === undefined) {
+                    return;
+                }
+                this.pitchValue = undefined;
+                this.pitchRawValue = undefined;
+                this.markDirty();
+                return;
+            }
+            assertFontPitch(value);
+            if (this.pitchValue === value && this.pitchRawValue === undefined) {
+                return;
+            }
+            this.pitchValue = value;
+            this.pitchRawValue = undefined;
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(FontTableFont.prototype, "signature", {
+        /**
+         * Supported Unicode / code-page bitmasks from `w:sig` (`CT_FontSig`), or
+         * `undefined` when the child is absent or missing a required attribute.
+         *
+         * @public
+         */
+        get: function () {
+            return this.signatureValue;
+        },
+        set: function (value) {
+            if (value === undefined) {
+                if (this.signatureValue === undefined) {
+                    return;
+                }
+                this.signatureValue = undefined;
+                this.markDirty();
+                return;
+            }
+            var next = {
+                usb0: value.usb0,
+                usb1: value.usb1,
+                usb2: value.usb2,
+                usb3: value.usb3,
+                csb0: value.csb0,
+                csb1: value.csb1,
+            };
+            if (signaturesEqual(this.signatureValue, next)) {
+                return;
+            }
+            this.signatureValue = next;
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Embedded font relationship metadata for each modeled embed child present on
+     * this row, in schema slot order.
+     *
+     * @public
+     */
+    FontTableFont.prototype.embedRefs = function () {
+        return this.embeds.map(toEmbedRef);
+    };
+    /**
+     * Embed metadata for `slot`, or `undefined` when that child is absent.
+     *
+     * @public
+     */
+    FontTableFont.prototype.embedRef = function (slot) {
+        assertFontEmbedSlot(slot);
+        var found = this.embeds.find(function (entry) { return entry.slot === slot; });
+        return found === undefined ? undefined : toEmbedRef(found);
+    };
+    /**
+     * Drop the embed child for `slot` from this font row (markup only).
+     * Does not remove package parts or relationships targeted by `r:id`.
+     * No-op when the slot is already absent.
+     *
+     * @public
+     */
+    FontTableFont.prototype.clearEmbed = function (slot) {
+        assertFontEmbedSlot(slot);
+        var index = this.embeds.findIndex(function (entry) { return entry.slot === slot; });
+        if (index < 0) {
+            return;
+        }
+        this.embeds.splice(index, 1);
+        this.markDirty();
+    };
+    /**
+     * @private
+     */
+    FontTableFont.prototype.serialize = function () {
+        var e_2, _a;
+        var children = [];
+        if (this.alternateNameValue !== undefined) {
+            children.push(wmlElement('altName', {
+                attributes: [wmlAttr('val', this.alternateNameValue)],
+            }));
+        }
+        if (this.panoseValue !== undefined) {
+            children.push(wmlElement('panose1', {
+                attributes: [wmlAttr('val', this.panoseValue)],
+            }));
+        }
+        if (this.charsetValue !== undefined) {
+            children.push(wmlElement('charset', {
+                attributes: [wmlAttr('val', this.charsetValue)],
+            }));
+        }
+        var familyEmit = this.familyValue != null ? this.familyValue : this.familyRawValue;
+        if (familyEmit !== undefined) {
+            children.push(wmlElement('family', {
+                attributes: [wmlAttr('val', familyEmit)],
+            }));
+        }
+        if (this.notTrueTypeValue !== undefined) {
+            children.push(serializeOnOff('notTrueType', this.notTrueTypeValue));
+        }
+        var pitchEmit = this.pitchValue != null ? this.pitchValue : this.pitchRawValue;
+        if (pitchEmit !== undefined) {
+            children.push(wmlElement('pitch', {
+                attributes: [wmlAttr('val', pitchEmit)],
+            }));
+        }
+        if (this.signatureValue !== undefined) {
+            children.push(serializeSignature(this.signatureValue));
+        }
+        var _loop_1 = function (slot) {
+            var embed = this_1.embeds.find(function (entry) { return entry.slot === slot; });
+            if (embed !== undefined) {
+                children.push(serializeEmbed(embed));
+            }
+        };
+        var this_1 = this;
+        try {
+            for (var _b = __values([
+                FontEmbedSlot.Regular,
+                FontEmbedSlot.Bold,
+                FontEmbedSlot.Italic,
+                FontEmbedSlot.BoldItalic,
+            ]), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var slot = _c.value;
+                _loop_1(slot);
+            }
+        }
+        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; }
+        }
+        children.push.apply(children, __spread(this.residualChildren));
+        var attributes = __spread([
+            wmlAttr('name', this.nameValue)
+        ], this.extraAttributes);
+        return wmlElement('font', { attributes: attributes, children: children });
+    };
+    return FontTableFont;
+}());
+export { FontTableFont };
+function cloneEmbed(embed) {
+    return {
+        slot: embed.slot,
+        relationshipId: embed.relationshipId,
+        fontKey: embed.fontKey,
+        subsetted: embed.subsetted,
+        extraAttributes: __spread(embed.extraAttributes),
+        children: __spread(embed.children),
+        namespaceDeclarations: __spread(embed.namespaceDeclarations),
+    };
+}
+function toEmbedRef(embed) {
+    return {
+        slot: embed.slot,
+        relationshipId: embed.relationshipId,
+        fontKey: embed.fontKey,
+        subsetted: embed.subsetted,
+    };
+}
+function normalizeOptionalString(value) {
+    if (value === undefined || value.trim().length === 0) {
+        return undefined;
+    }
+    return value;
+}
+function assertFontFamily(value) {
+    if (!FONT_FAMILY_VALUES.has(value)) {
+        throw new RangeError("Invalid FontFamily value: " + value);
+    }
+}
+function assertFontPitch(value) {
+    if (!FONT_PITCH_VALUES.has(value)) {
+        throw new RangeError("Invalid FontPitch value: " + value);
+    }
+}
+function assertFontEmbedSlot(value) {
+    if (value !== FontEmbedSlot.Regular &&
+        value !== FontEmbedSlot.Bold &&
+        value !== FontEmbedSlot.Italic &&
+        value !== FontEmbedSlot.BoldItalic) {
+        throw new RangeError("Invalid FontEmbedSlot value: " + value);
+    }
+}
+function signaturesEqual(a, b) {
+    if (a === undefined) {
+        return false;
+    }
+    return (a.usb0 === b.usb0 &&
+        a.usb1 === b.usb1 &&
+        a.usb2 === b.usb2 &&
+        a.usb3 === b.usb3 &&
+        a.csb0 === b.csb0 &&
+        a.csb1 === b.csb1);
+}
+function fontNameAttribute(element) {
+    var found = element.attributes.find(function (attribute) { return attribute.localName === 'name' &&
+        (attribute.namespaceUri === WML || attribute.namespaceUri === ''); });
+    return found == null ? undefined : found.value;
+}
+function wmlNamedAttribute(element, localName) {
+    var found = element.attributes.find(function (attribute) { return attribute.localName === localName &&
+        (attribute.namespaceUri === WML || attribute.namespaceUri === ''); });
+    return found == null ? undefined : found.value;
+}
+function relationshipIdAttribute(element) {
+    var found = element.attributes.find(function (attribute) { return attribute.localName === 'id' &&
+        (attribute.namespaceUri === OFFICE_RELATIONSHIPS_NAMESPACE ||
+            attribute.prefix === 'r' ||
+            attribute.namespaceUri === ''); });
+    return found == null ? undefined : found.value;
+}
+function parseSignature(element) {
+    var usb0 = wmlNamedAttribute(element, 'usb0');
+    var usb1 = wmlNamedAttribute(element, 'usb1');
+    var usb2 = wmlNamedAttribute(element, 'usb2');
+    var usb3 = wmlNamedAttribute(element, 'usb3');
+    var csb0 = wmlNamedAttribute(element, 'csb0');
+    var csb1 = wmlNamedAttribute(element, 'csb1');
+    if (usb0 === undefined ||
+        usb1 === undefined ||
+        usb2 === undefined ||
+        usb3 === undefined ||
+        csb0 === undefined ||
+        csb1 === undefined) {
+        return undefined;
+    }
+    return { usb0: usb0, usb1: usb1, usb2: usb2, usb3: usb3, csb0: csb0, csb1: csb1 };
+}
+function serializeSignature(signature) {
+    return wmlElement('sig', {
+        attributes: [
+            wmlAttr('usb0', signature.usb0),
+            wmlAttr('usb1', signature.usb1),
+            wmlAttr('usb2', signature.usb2),
+            wmlAttr('usb3', signature.usb3),
+            wmlAttr('csb0', signature.csb0),
+            wmlAttr('csb1', signature.csb1),
+        ],
+    });
+}
+function parseSubsetted(element) {
+    var found = element.attributes.find(function (attribute) { return attribute.localName === 'subsetted' &&
+        (attribute.namespaceUri === WML || attribute.namespaceUri === ''); });
+    if (found === undefined) {
+        return undefined;
+    }
+    var normalized = found.value.trim().toLowerCase();
+    if (normalized === 'true' || normalized === '1' || normalized === 'on') {
+        return true;
+    }
+    if (normalized === 'false' || normalized === '0' || normalized === 'off') {
+        return false;
+    }
+    return undefined;
+}
+function parseEmbed(element, slot) {
+    var relationshipId = relationshipIdAttribute(element);
+    if (relationshipId === undefined || relationshipId.length === 0) {
+        return undefined;
+    }
+    var fontKeyRaw = wmlNamedAttribute(element, 'fontKey');
+    var fontKey = fontKeyRaw !== undefined && fontKeyRaw.trim().length > 0 ? fontKeyRaw : undefined;
+    var subsetted = parseSubsetted(element);
+    var extraAttributes = element.attributes.filter(function (attribute) {
+        if (attribute.localName === 'id' &&
+            (attribute.namespaceUri === OFFICE_RELATIONSHIPS_NAMESPACE ||
+                attribute.prefix === 'r' ||
+                attribute.namespaceUri === '')) {
+            return false;
+        }
+        if (attribute.localName === 'fontKey' &&
+            (attribute.namespaceUri === WML || attribute.namespaceUri === '')) {
+            return false;
+        }
+        if (attribute.localName === 'subsetted' &&
+            (attribute.namespaceUri === WML || attribute.namespaceUri === '')) {
+            return false;
+        }
+        return true;
+    });
+    return {
+        slot: slot,
+        relationshipId: relationshipId,
+        fontKey: fontKey,
+        subsetted: subsetted,
+        extraAttributes: extraAttributes,
+        children: __spread(element.children),
+        namespaceDeclarations: __spread(element.namespaceDeclarations),
+    };
+}
+function serializeEmbed(embed) {
+    var localName = EMBED_LOCAL_BY_SLOT[embed.slot];
+    var attributes = [
+        {
+            namespaceUri: OFFICE_RELATIONSHIPS_NAMESPACE,
+            localName: 'id',
+            prefix: 'r',
+            value: embed.relationshipId,
+        },
+    ];
+    if (embed.fontKey !== undefined) {
+        attributes.push(wmlAttr('fontKey', embed.fontKey));
+    }
+    if (embed.subsetted !== undefined) {
+        attributes.push(wmlAttr('subsetted', embed.subsetted ? 'true' : 'false'));
+    }
+    attributes.push.apply(attributes, __spread(embed.extraAttributes));
+    var namespaceDeclarations = embed.namespaceDeclarations.length > 0
+        ? __spread(embed.namespaceDeclarations) : [{ prefix: 'r', namespaceUri: OFFICE_RELATIONSHIPS_NAMESPACE }];
+    if (!namespaceDeclarations.some(function (declaration) { return declaration.prefix === 'r' && declaration.namespaceUri === OFFICE_RELATIONSHIPS_NAMESPACE; })) {
+        namespaceDeclarations.push({
+            prefix: 'r',
+            namespaceUri: OFFICE_RELATIONSHIPS_NAMESPACE,
+        });
+    }
+    return wmlElement(localName, {
+        attributes: attributes,
+        children: embed.children,
+        namespaceDeclarations: namespaceDeclarations,
+    });
+}
+function parseKnownChildren(element) {
+    var e_3, _a;
+    var alternateName;
+    var panose;
+    var charset;
+    var family;
+    var familyRaw;
+    var notTrueType;
+    var pitch;
+    var pitchRaw;
+    var signature;
+    var embeds = [];
+    var seenEmbedSlots = new Set();
+    var residualChildren = [];
+    try {
+        for (var _b = __values(elementChildren(element)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (isWml(child, 'altName')) {
+                if (alternateName === undefined) {
+                    var val = wValAttribute(child);
+                    if (val !== undefined && val.trim().length > 0) {
+                        alternateName = val;
+                    }
+                }
+                continue;
+            }
+            if (isWml(child, 'panose1')) {
+                if (panose === undefined) {
+                    var val = wValAttribute(child);
+                    if (val !== undefined && val.trim().length > 0) {
+                        panose = val;
+                    }
+                }
+                continue;
+            }
+            if (isWml(child, 'charset')) {
+                if (charset === undefined) {
+                    var val = wValAttribute(child);
+                    if (val !== undefined && val.trim().length > 0) {
+                        charset = val;
+                    }
+                }
+                continue;
+            }
+            if (isWml(child, 'family')) {
+                if (family === undefined && familyRaw === undefined) {
+                    var val = wValAttribute(child);
+                    if (val !== undefined && val.trim().length > 0) {
+                        if (FONT_FAMILY_VALUES.has(val)) {
+                            family = val;
+                        }
+                        else {
+                            familyRaw = val;
+                        }
+                    }
+                }
+                continue;
+            }
+            if (isWml(child, 'notTrueType')) {
+                if (notTrueType === undefined) {
+                    var parsed = parseOnOff(child);
+                    if (parsed !== undefined) {
+                        notTrueType = parsed;
+                    }
+                }
+                continue;
+            }
+            if (isWml(child, 'pitch')) {
+                if (pitch === undefined && pitchRaw === undefined) {
+                    var val = wValAttribute(child);
+                    if (val !== undefined && val.trim().length > 0) {
+                        if (FONT_PITCH_VALUES.has(val)) {
+                            pitch = val;
+                        }
+                        else {
+                            pitchRaw = val;
+                        }
+                    }
+                }
+                continue;
+            }
+            if (isWml(child, 'sig')) {
+                if (signature === undefined) {
+                    var parsed = parseSignature(child);
+                    if (parsed !== undefined) {
+                        signature = parsed;
+                    }
+                    else {
+                        residualChildren.push(child);
+                    }
+                }
+                continue;
+            }
+            var embedSlot = EMBED_SLOT_BY_LOCAL[child.localName];
+            if (embedSlot !== undefined && isWml(child, child.localName)) {
+                if (!seenEmbedSlots.has(embedSlot)) {
+                    var parsed = parseEmbed(child, embedSlot);
+                    if (parsed !== undefined) {
+                        embeds.push(parsed);
+                        seenEmbedSlots.add(embedSlot);
+                    }
+                    else {
+                        residualChildren.push(child);
+                    }
+                }
+                continue;
+            }
+            residualChildren.push(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 {
+        alternateName: alternateName,
+        panose: panose,
+        charset: charset,
+        family: family,
+        familyRaw: familyRaw,
+        notTrueType: notTrueType,
+        pitch: pitch,
+        pitchRaw: pitchRaw,
+        signature: signature,
+        embeds: embeds,
+        residualChildren: residualChildren,
+    };
+}
+/**
+ * Parse one `w:font` element into a {@link FontTableFont}, or `undefined` when
+ * `@w:name` is missing/empty.
+ *
+ * @private
+ */
+export function parseFontTableFont(element, markDirty) {
+    var name = fontNameAttribute(element);
+    if (name === undefined || name.length === 0) {
+        return undefined;
+    }
+    var parsed = parseKnownChildren(element);
+    var extraAttributes = element.attributes.filter(function (attribute) { return !(attribute.localName === 'name' &&
+        (attribute.namespaceUri === WML || attribute.namespaceUri === '')); });
+    return new FontTableFont(name, {
+        alternateName: parsed.alternateName,
+        panose: parsed.panose,
+        charset: parsed.charset,
+        family: parsed.family,
+        familyRaw: parsed.familyRaw,
+        notTrueType: parsed.notTrueType,
+        pitch: parsed.pitch,
+        pitchRaw: parsed.pitchRaw,
+        signature: parsed.signature,
+        embeds: parsed.embeds,
+        residualChildren: parsed.residualChildren,
+        extraAttributes: extraAttributes,
+    }, markDirty);
+}
+/**
+ * Create a minimal font entry (`@w:name` only).
+ *
+ * @private
+ */
+export function createFontTableFont(name, markDirty) {
+    return new FontTableFont(name, {}, markDirty);
+}