@syncfusion/ej2-docx 0.0.0-stage → 35.1.39

package/src/features/custom-xml/index.js

@@ -0,0 +1,661 @@
+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 { DocxError } from '../../core/errors/docx-error';
+import { parseBodyBlocks, serializeBodyBlocks } from '../document/body-blocks';
+import { FeatureInlineParagraphItem, serializeRun, TextRange, } from '../document/text-range';
+import { elementChildren, isWml, wmlAttr, wmlElement } from '../document/wml';
+import { partByName, relationshipsForPart } from '../../core/opc/package';
+import { resolveInternalTarget } from '../../core/opc/part-name';
+import { featureId, registerFeature, registerFeatureBlockHandler, registerFeatureInlineHandler, registerFeatureMultiPartHandler, } from '../../core/registry/index';
+import { detachedBodyBlockParseContext } from '../../core/registry/block-handlers';
+import { serializeFeatureInline, tryParseFeatureInline, } from '../../core/registry/inline-handlers';
+import { parseXml } from '../../core/xml/index';
+var CUSTOM_XML = featureId('custom-xml');
+var utf8Decoder = new TextDecoder('utf-8');
+/**
+ * @private
+ * Transitional custom XML datastore relationship (ECMA-376-1 §15.2.5). */
+export var CUSTOM_XML_RELATIONSHIP_TYPE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/customXml';
+/**
+ * @private
+ * Strict custom XML datastore relationship. */
+export var STRICT_CUSTOM_XML_RELATIONSHIP_TYPE = 'http://purl.oclc.org/ooxml/officeDocument/relationships/customXml';
+/**
+ * @private
+ * Transitional custom XML properties relationship (ECMA-376-1 §15.2.6). */
+export var CUSTOM_XML_PROPS_RELATIONSHIP_TYPE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/customXmlProps';
+/**
+ * @private
+ * Strict custom XML properties relationship. */
+export var STRICT_CUSTOM_XML_PROPS_RELATIONSHIP_TYPE = 'http://purl.oclc.org/ooxml/officeDocument/relationships/customXmlProps';
+/**
+ * @private
+ * Custom XML Data Storage Properties part content type. */
+export var CUSTOM_XML_PROPS_CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.customXmlProperties+xml';
+/**
+ * @private
+ * Custom XML Data Storage part content type (ECMA-376-1 §15.2.5). */
+export var CUSTOM_XML_DATA_CONTENT_TYPE = 'application/xml';
+/**
+ * @private
+ * Root namespace for custom XML properties parts. */
+export var CUSTOM_XML_PROPS_NAMESPACE = 'http://schemas.openxmlformats.org/officeDocument/2006/customXml';
+var CUSTOM_XML_RELATIONSHIP_TYPES = [
+    CUSTOM_XML_RELATIONSHIP_TYPE,
+    STRICT_CUSTOM_XML_RELATIONSHIP_TYPE,
+];
+var CUSTOM_XML_PROPS_RELATIONSHIP_TYPES = [
+    CUSTOM_XML_PROPS_RELATIONSHIP_TYPE,
+    STRICT_CUSTOM_XML_PROPS_RELATIONSHIP_TYPE,
+];
+function unqualifiedAttribute(el, localName) {
+    var __ts33_0;
+    return ((__ts33_0 = el.attributes.find(function (a) { return a.localName === localName &&
+        (a.namespaceUri === '' || a.prefix === 'w' || a.namespaceUri.includes('wordprocessingml')); })), __ts33_0 == null ? undefined : __ts33_0.value);
+}
+/**
+ * Custom XML wrapper properties read from `w:customXmlPr`.
+ * Preserve-only; not part of the supported public surface.
+ *
+ * @private
+ */
+var CustomXmlProperties = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function CustomXmlProperties(placeholder, attributes) {
+        this.placeholder = placeholder;
+        this.attributes = attributes;
+    }
+    return CustomXmlProperties;
+}());
+export { CustomXmlProperties };
+function parseCustomXmlAttribute(element) {
+    if (!isWml(element, 'attr')) {
+        return undefined;
+    }
+    var name = unqualifiedAttribute(element, 'name');
+    var val = unqualifiedAttribute(element, 'val');
+    if (name === undefined || name.length === 0 || val === undefined) {
+        return undefined;
+    }
+    var uri = unqualifiedAttribute(element, 'uri');
+    return { uri: uri, name: name, val: val };
+}
+function parseCustomXmlProperties(customXmlPr) {
+    var e_1, _a;
+    if (customXmlPr === undefined || !isWml(customXmlPr, 'customXmlPr')) {
+        return undefined;
+    }
+    var placeholder;
+    var attributes = [];
+    try {
+        for (var _b = __values(elementChildren(customXmlPr)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (isWml(child, 'placeholder')) {
+                placeholder = unqualifiedAttribute(child, 'val');
+                continue;
+            }
+            var attribute = parseCustomXmlAttribute(child);
+            if (attribute !== undefined) {
+                attributes.push(attribute);
+            }
+        }
+    }
+    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; }
+    }
+    if (placeholder === undefined && attributes.length === 0) {
+        return undefined;
+    }
+    return new CustomXmlProperties(placeholder, attributes);
+}
+var detachedRunOwner = {
+    assertAttachedItem: function () {
+        return;
+    },
+};
+function parseInlineContent(children, owner) {
+    var e_2, _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_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (children_1_1 && !children_1_1.done && (_a = children_1.return)) _a.call(children_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return inlines;
+}
+function serializeInlineContent(inlines) {
+    var e_3, _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_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (inlines_1_1 && !inlines_1_1.done && (_a = inlines_1.return)) _a.call(inlines_1);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    return out;
+}
+function releaseBlockContent(blocks) {
+    var e_4, _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 CustomXmlMarkup) {
+                block.value.releaseContent();
+            }
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (blocks_1_1 && !blocks_1_1.done && (_a = blocks_1.return)) _a.call(blocks_1);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+}
+function releaseInlineContent(inlines) {
+    var e_5, _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 CustomXmlMarkup) {
+                inline.value.releaseContent();
+            }
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (inlines_2_1 && !inlines_2_1.done && (_a = inlines_2.return)) _a.call(inlines_2);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+}
+/**
+ * Preserve-only in-body custom XML wrapper (`w:customXml`) at block or run level.
+ * Markup and children round-trip; bindings are never resolved. No schema
+ * validation, data-source mutation, or binding-editor API is provided.
+ *
+ * @private
+ */
+var CustomXmlMarkup = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function CustomXmlMarkup(elementName, uri, properties, customXmlPr, blocks, inlines, preservedXml) {
+        this.elementName = elementName;
+        this.uri = uri;
+        this.properties = properties;
+        this.customXmlPr = customXmlPr;
+        this.blocks = blocks;
+        this.inlines = inlines;
+        this.preservedXml = preservedXml;
+    }
+    Object.defineProperty(CustomXmlMarkup.prototype, "blockContent", {
+        /**
+         * @private
+       * Block-level inner content, when loaded from a body block. */
+        get: function () {
+            return this.blocks;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CustomXmlMarkup.prototype, "inlineContent", {
+        /**
+         * @private
+       * Run-level inner content, when loaded from a paragraph inline. */
+        get: function () {
+            return this.inlines;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CustomXmlMarkup.prototype, "firstParagraphText", {
+        /**
+         * @private
+       * Visible paragraph text inside a block wrapper, when present. */
+        get: function () {
+            var e_6, _a, e_7, _b;
+            if (this.blocks === undefined) {
+                return undefined;
+            }
+            try {
+                for (var _c = __values(this.blocks), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var block = _d.value;
+                    if (block.type !== 'paragraph') {
+                        continue;
+                    }
+                    try {
+                        for (var _e = __values(block.paragraph.items), _f = _e.next(); !_f.done; _f = _e.next()) {
+                            var inline = _f.value;
+                            if (inline instanceof TextRange && inline.text.length > 0) {
+                                return inline.text;
+                            }
+                        }
+                    }
+                    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+                    finally {
+                        try {
+                            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                        }
+                        finally { if (e_7) throw e_7.error; }
+                    }
+                }
+            }
+            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                }
+                finally { if (e_6) throw e_6.error; }
+            }
+            return undefined;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    CustomXmlMarkup.prototype.releaseContent = function () {
+        if (this.blocks !== undefined) {
+            releaseBlockContent(this.blocks);
+        }
+        if (this.inlines !== undefined) {
+            releaseInlineContent(this.inlines);
+        }
+    };
+    /**
+     * @private
+   * Serialize to `w:customXml` (or preserved original element). */
+    CustomXmlMarkup.prototype.toOpenXml = function () {
+        if (this.preservedXml !== undefined) {
+            return this.preservedXml;
+        }
+        var attributes = [wmlAttr('element', this.elementName)];
+        if (this.uri !== undefined && this.uri.length > 0) {
+            attributes.push(wmlAttr('uri', this.uri));
+        }
+        var children = [];
+        if (this.customXmlPr !== undefined) {
+            children.push(this.customXmlPr);
+        }
+        if (this.blocks !== undefined) {
+            children.push.apply(children, __spread(serializeBodyBlocks(this.blocks)));
+        }
+        else if (this.inlines !== undefined) {
+            children.push.apply(children, __spread(serializeInlineContent(this.inlines)));
+        }
+        return wmlElement('customXml', { attributes: attributes, children: children });
+    };
+    return CustomXmlMarkup;
+}());
+export { CustomXmlMarkup };
+function splitCustomXmlChildren(element) {
+    var e_8, _a;
+    var content = [];
+    var customXmlPr;
+    try {
+        for (var _b = __values(elementChildren(element)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (isWml(child, 'customXmlPr')) {
+                customXmlPr = child;
+            }
+            else {
+                content.push(child);
+            }
+        }
+    }
+    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_8) throw e_8.error; }
+    }
+    return { customXmlPr: customXmlPr, content: content };
+}
+function parseCustomXmlMarkup(element, mode, ctx) {
+    if (!isWml(element, 'customXml')) {
+        return undefined;
+    }
+    var elementName = unqualifiedAttribute(element, 'element');
+    if (elementName === undefined || elementName.length === 0) {
+        return new CustomXmlMarkup('', undefined, undefined, undefined, undefined, undefined, element);
+    }
+    var uri = unqualifiedAttribute(element, 'uri');
+    var _a = splitCustomXmlChildren(element), customXmlPr = _a.customXmlPr, content = _a.content;
+    var properties = parseCustomXmlProperties(customXmlPr);
+    if (mode === 'block') {
+        var blocks = parseBodyBlocks(content, ctx);
+        return new CustomXmlMarkup(elementName, uri, properties, customXmlPr, blocks, undefined, undefined);
+    }
+    var inlines = parseInlineContent(content, detachedRunOwner);
+    return new CustomXmlMarkup(elementName, uri, properties, customXmlPr, undefined, inlines, undefined);
+}
+function parseItemIdFromProps(data) {
+    var __ts33_1;
+    try {
+        var root = parseXml(utf8Decoder.decode(data));
+        if (root.localName !== 'datastoreItem') {
+            return undefined;
+        }
+        return ((__ts33_1 = root.attributes.find(function (attribute) { return attribute.localName === 'itemID' &&
+            (attribute.namespaceUri === CUSTOM_XML_PROPS_NAMESPACE ||
+                attribute.namespaceUri === '' ||
+                attribute.namespaceUri.includes('customXml')); })), __ts33_1 == null ? undefined : __ts33_1.value);
+    }
+    catch (_a) {
+        return undefined;
+    }
+}
+/**
+ * One Custom XML item part plus optional properties part.
+ * Preserve-only; not part of the supported public surface.
+ *
+ * @private
+ */
+var CustomXmlStorageItem = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function CustomXmlStorageItem(partNameValue, data, contentType, itemId, propertiesPartName, propertiesData, propertiesContentType) {
+        this.partName = partNameValue;
+        this.data = data;
+        this.contentType = contentType;
+        this.itemId = itemId;
+        this.propertiesPartName = propertiesPartName;
+        this.propertiesData = propertiesData;
+        this.propertiesContentType = propertiesContentType;
+    }
+    return CustomXmlStorageItem;
+}());
+export { CustomXmlStorageItem };
+/**
+ * Preserve-only Custom XML datastore catalog linked from the Main Document.
+ * Items round-trip as opaque bytes; no mutation or binding API is provided.
+ * Not part of the supported public surface.
+ *
+ * @private
+ */
+var CustomXmlDatastore = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function CustomXmlDatastore(storageItems) {
+        this.storageItems = storageItems;
+    }
+    Object.defineProperty(CustomXmlDatastore.prototype, "items", {
+        /**
+         * @private
+       * Loaded datastore items in relationship order. */
+        get: function () {
+            return this.storageItems;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    CustomXmlDatastore.prototype.isDirty = function () {
+        return false;
+    };
+    /**
+     * @private
+     */
+    CustomXmlDatastore.prototype.applyToPackage = function (pkg, mainPartName) {
+        void mainPartName;
+        return pkg;
+    };
+    return CustomXmlDatastore;
+}());
+export { CustomXmlDatastore };
+function isCustomXmlRelationship(type) {
+    return CUSTOM_XML_RELATIONSHIP_TYPES.indexOf(type) !== -1;
+}
+function isCustomXmlPropsRelationship(type) {
+    return CUSTOM_XML_PROPS_RELATIONSHIP_TYPES.indexOf(type) !== -1;
+}
+function loadDatastore(pkg, mainPartName) {
+    var e_9, _a, e_10, _b;
+    var items = [];
+    try {
+        for (var _c = __values(relationshipsForPart(pkg, mainPartName).items), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var rel = _d.value;
+            if (!isCustomXmlRelationship(rel.type)) {
+                continue;
+            }
+            var itemPartName = resolveInternalTarget(rel.target, mainPartName);
+            var itemPart = partByName(pkg, itemPartName);
+            if (itemPart === undefined) {
+                continue;
+            }
+            var propertiesPartName = void 0;
+            var propertiesData = void 0;
+            var propertiesContentType = void 0;
+            var itemId = void 0;
+            try {
+                for (var _e = __values(relationshipsForPart(pkg, itemPartName).items), _f = _e.next(); !_f.done; _f = _e.next()) {
+                    var propsRel = _f.value;
+                    if (!isCustomXmlPropsRelationship(propsRel.type)) {
+                        continue;
+                    }
+                    propertiesPartName = resolveInternalTarget(propsRel.target, itemPartName);
+                    var propsPart = partByName(pkg, propertiesPartName);
+                    if (propsPart === undefined) {
+                        continue;
+                    }
+                    propertiesData = propsPart.data;
+                    propertiesContentType = propsPart.contentType;
+                    itemId = parseItemIdFromProps(propsPart.data);
+                    break;
+                }
+            }
+            catch (e_10_1) { e_10 = { error: e_10_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                }
+                finally { if (e_10) throw e_10.error; }
+            }
+            items.push(new CustomXmlStorageItem(itemPartName, itemPart.data, itemPart.contentType, itemId, propertiesPartName, propertiesData, propertiesContentType));
+        }
+    }
+    catch (e_9_1) { e_9 = { error: e_9_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_9) throw e_9.error; }
+    }
+    return new CustomXmlDatastore(items);
+}
+function markupFromBlocks(blocks) {
+    var e_11, _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.type === 'feature' && block.value instanceof CustomXmlMarkup) {
+                found.push(block.value);
+            }
+        }
+    }
+    catch (e_11_1) { e_11 = { error: e_11_1 }; }
+    finally {
+        try {
+            if (blocks_2_1 && !blocks_2_1.done && (_a = blocks_2.return)) _a.call(blocks_2);
+        }
+        finally { if (e_11) throw e_11.error; }
+    }
+    return found;
+}
+function markupFromInlines(inlines) {
+    var e_12, _a;
+    var found = [];
+    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 instanceof FeatureInlineParagraphItem && inline.value instanceof CustomXmlMarkup) {
+                found.push(inline.value);
+            }
+        }
+    }
+    catch (e_12_1) { e_12 = { error: e_12_1 }; }
+    finally {
+        try {
+            if (inlines_3_1 && !inlines_3_1.done && (_a = inlines_3.return)) _a.call(inlines_3);
+        }
+        finally { if (e_12) throw e_12.error; }
+    }
+    return found;
+}
+var registered = false;
+/**
+ * @private
+ * Test hook */
+export function resetCustomXmlFeatureForTests() {
+    registered = false;
+}
+/**
+ * @private
+ * Register custom XML markup and datastore handlers. Idempotent. */
+export function registerCustomXmlFeature() {
+    if (registered) {
+        return;
+    }
+    registered = true;
+    registerFeature({ id: CUSTOM_XML });
+    registerFeatureMultiPartHandler({
+        featureId: CUSTOM_XML,
+        relationshipTypes: CUSTOM_XML_RELATIONSHIP_TYPES,
+        loadParts: function (pkg, ctx) {
+            return loadDatastore(pkg, ctx.mainPartName);
+        },
+    });
+    registerFeatureInlineHandler({
+        featureId: CUSTOM_XML,
+        wmlLocalName: 'customXml',
+        tryParse: function (element) {
+            return parseCustomXmlMarkup(element, 'inline', detachedBodyBlockParseContext());
+        },
+    });
+    registerFeatureBlockHandler({
+        featureId: CUSTOM_XML,
+        wmlLocalName: 'customXml',
+        tryParse: function (element, ctx) {
+            return parseCustomXmlMarkup(element, 'block', ctx);
+        },
+    });
+}
+/**
+ * Custom XML datastore linked from the Main Document.
+ * Returns the preserve-only catalog; not part of the supported public surface.
+ *
+ * @private
+ */
+export function customXmlDatastore(document) {
+    var part = document.featurePart(CUSTOM_XML);
+    if (part === undefined || !(part instanceof CustomXmlDatastore)) {
+        throw new DocxError('feature/not-registered', 'Custom XML datastore was not loaded; call registerCustomXmlFeature() before WordDocument.open');
+    }
+    return part;
+}
+/**
+ * Block-level custom XML wrappers in a block list, in document order.
+ *
+ * @private
+ */
+export function customXmlMarkupInBlocks(blocks) {
+    return markupFromBlocks(blocks);
+}
+/**
+ * Run-level custom XML wrappers in a paragraph, in document order.
+ *
+ * @private
+ */
+export function customXmlMarkupInParagraph(paragraph) {
+    return markupFromInlines(paragraph.items.toArray());
+}
+/**
+ * Whether inline content is modeled custom XML from this module.
+ *
+ * @private
+ */
+export function isCustomXmlMarkupInline(inline) {
+    return (inline instanceof FeatureInlineParagraphItem &&
+        inline.featureId === CUSTOM_XML &&
+        inline.value instanceof CustomXmlMarkup);
+}
+registerCustomXmlFeature();

package/src/features/document/alignment.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Semantic paragraph alignment mapped from `ST_Jc`.
+ *
+ * New writes use `start`/`center`/`end`/`justify`. Loaded `left` reads as `Start`
+ * and `both` reads as `Justify` without rewriting the stored value on a no-op save.
+ *
+ * @public
+ */
+export declare const ParagraphAlignment: {
+    Left: "start";
+    Center: "center";
+    Right: "end";
+    Justify: "justify";
+};
+/**
+ * One of the `ParagraphAlignment` tokens (`start`, `center`, `end`, `justify`).
+ *
+ * @public
+ */
+export declare type ParagraphAlignment = (typeof ParagraphAlignment)[keyof typeof ParagraphAlignment];
+/** ST_Jc `left`/`start` read as Start; `both` reads as Justify (spec). */
+export declare function alignmentFromJc(val: string): ParagraphAlignment | undefined;
+export declare function jcForNewAlignment(alignment: ParagraphAlignment): string;