@a3s-lab/office 0.28.0 → 0.30.0

package/dist/4121.js

@@ -0,0 +1,3448 @@
+import jszip from "jszip";
+import { Extension } from "@tiptap/core";
+import { isHistoryTransaction } from "@tiptap/pm/history";
+import { Plugin } from "@tiptap/pm/state";
+import { Mapping } from "@tiptap/pm/transform";
+const DOCUMENT_INTEGRITY_BOOKMARK = 1;
+const DOCUMENT_INTEGRITY_FIELD = 2;
+const DOCUMENT_INTEGRITY_IMAGE = 4;
+const DOCUMENT_INTEGRITY_NOTE = 8;
+const DOCUMENT_INTEGRITY_PARAGRAPH_IDENTITY = 16;
+const DOCUMENT_INTEGRITY_TABLE_ROW_IDENTITY = 32;
+const featureCache = new WeakMap();
+function documentHasIntegrityFeature(document, feature) {
+    return (documentIntegrityFeatures(document, true) & feature) !== 0;
+}
+function primeDocumentIntegrityFeatures(document) {
+    document.forEach(primeDocumentIntegrityNode);
+}
+function primeDocumentIntegrityNode(node) {
+    if ('documentChunk' === node.type.name) {
+        const features = nonNegativeInteger(node.attrs.integrityFeatures);
+        if (null !== features) featureCache.set(node, features);
+        if (true !== node.attrs.windowContainer) return;
+    }
+    node.forEach(primeDocumentIntegrityNode);
+}
+function documentIntegrityFeatures(node, cacheNode) {
+    if (cacheNode) {
+        const cached = featureCache.get(node);
+        if (void 0 !== cached) return cached;
+    }
+    let features = nodeIntegrityFeatures(node);
+    node.forEach((child)=>{
+        features |= documentIntegrityFeatures(child, 'documentChunk' === child.type.name);
+    });
+    if (cacheNode) featureCache.set(node, features);
+    return features;
+}
+function nodeIntegrityFeatures(node) {
+    let features = 0;
+    switch(node.type.name){
+        case 'documentBookmarkBoundary':
+            features |= DOCUMENT_INTEGRITY_BOOKMARK;
+            break;
+        case 'documentCrossReference':
+            if ('bookmark' === node.attrs.targetType) features |= DOCUMENT_INTEGRITY_BOOKMARK;
+            break;
+        case 'documentField':
+            features |= DOCUMENT_INTEGRITY_FIELD;
+            break;
+        case 'image':
+            features |= DOCUMENT_INTEGRITY_IMAGE;
+            break;
+        case 'documentNote':
+        case 'documentNoteReference':
+            features |= DOCUMENT_INTEGRITY_NOTE;
+            break;
+    }
+    if (node.isText && node.marks.some((mark)=>'link' === mark.type.name && 'string' == typeof mark.attrs.href && mark.attrs.href.startsWith('#'))) features |= DOCUMENT_INTEGRITY_BOOKMARK;
+    if (identityComponent(node.attrs.paragraphId) || identityComponent(node.attrs.textId)) features |= DOCUMENT_INTEGRITY_PARAGRAPH_IDENTITY;
+    if (identityComponent(node.attrs.rowId) || identityComponent(node.attrs.rowTextId)) features |= DOCUMENT_INTEGRITY_TABLE_ROW_IDENTITY;
+    return features;
+}
+function identityComponent(value) {
+    return 'string' == typeof value && value.trim().length > 0;
+}
+function nonNegativeInteger(value) {
+    const number = Number(value);
+    return Number.isSafeInteger(number) && number >= 0 ? number : null;
+}
+function normalizeCssColor(source) {
+    const value = source?.trim().toLowerCase();
+    if (!value) return null;
+    if ('transparent' === value) return 'transparent';
+    const shortHex = /^#([0-9a-f]{3})$/i.exec(value);
+    if (shortHex?.[1]) return `#${Array.from(shortHex[1]).map((channel)=>`${channel}${channel}`).join('')}`;
+    if (/^#[0-9a-f]{6}$/i.test(value)) return value;
+    const rgb = /^rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})(?:\s*,\s*([\d.]+))?\s*\)$/i.exec(value);
+    if (!rgb) return null;
+    const channels = rgb.slice(1, 4).map(Number);
+    if (channels.some((channel)=>channel < 0 || channel > 255)) return null;
+    if (void 0 !== rgb[4] && 0 === Number(rgb[4])) return 'transparent';
+    if (void 0 !== rgb[4] && 1 !== Number(rgb[4])) return null;
+    return `#${channels.map((channel)=>channel.toString(16).padStart(2, '0')).join('')}`;
+}
+function decodeXmlBytes(bytes, label) {
+    let encoding = 'utf-8';
+    let offset = 0;
+    if (0xef === bytes[0] && 0xbb === bytes[1] && 0xbf === bytes[2]) offset = 3;
+    else if (0xff === bytes[0] && 0xfe === bytes[1]) {
+        encoding = 'utf-16le';
+        offset = 2;
+    } else if (0xfe === bytes[0] && 0xff === bytes[1]) {
+        encoding = 'utf-16be';
+        offset = 2;
+    } else if (0x3c === bytes[0] && 0 === bytes[1] && 0x3f === bytes[2] && 0 === bytes[3]) encoding = 'utf-16le';
+    else if (0 === bytes[0] && 0x3c === bytes[1] && 0 === bytes[2] && 0x3f === bytes[3]) encoding = 'utf-16be';
+    try {
+        return new TextDecoder(encoding, {
+            fatal: true
+        }).decode(bytes.subarray(offset));
+    } catch  {
+        throw new Error(`${label} uses an invalid ${encoding} XML encoding.`);
+    }
+}
+function serializeUtf8Xml(document) {
+    const serialized = new XMLSerializer().serializeToString(document);
+    const body = serialized.replace(/^\s*<\?xml[^?]*\?>\s*/i, '');
+    return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>${body}`;
+}
+class OoxmlPackage {
+    zip;
+    textCache = new Map();
+    constructor(zip){
+        this.zip = zip;
+    }
+    static async load(buffer) {
+        return new OoxmlPackage(await jszip.loadAsync(buffer));
+    }
+    has(partPath) {
+        return Boolean(this.zip.file(partPath));
+    }
+    paths(prefix) {
+        return Object.keys(this.zip.files).filter((path)=>path.startsWith(prefix) && !this.zip.files[path]?.dir);
+    }
+    async text(partPath) {
+        const cached = this.textCache.get(partPath);
+        if (cached) return cached;
+        const entry = this.zip.file(partPath);
+        if (!entry) throw new Error(`Office package part is missing: ${partPath}`);
+        const pending = entry.async('uint8array').then((bytes)=>decodeXmlBytes(bytes, partPath));
+        this.textCache.set(partPath, pending);
+        try {
+            return await pending;
+        } catch (error) {
+            this.textCache.delete(partPath);
+            throw error;
+        }
+    }
+    async xml(partPath) {
+        return parseXml(await this.text(partPath), partPath);
+    }
+    async bytes(partPath) {
+        const entry = this.zip.file(partPath);
+        if (!entry) throw new Error(`Office package part is missing: ${partPath}`);
+        return entry.async('uint8array');
+    }
+    async relationships(sourcePart) {
+        const partPath = relationshipsPartPath(sourcePart);
+        if (!this.has(partPath)) return new Map();
+        const document = await this.xml(partPath);
+        return new Map(descendants(document, 'Relationship').map((element)=>{
+            const relationship = {
+                id: attribute(element, 'Id') ?? '',
+                target: resolvePartTarget(sourcePart, attribute(element, 'Target') ?? ''),
+                type: attribute(element, 'Type') ?? '',
+                targetMode: attribute(element, 'TargetMode') ?? void 0
+            };
+            return [
+                relationship.id,
+                relationship
+            ];
+        }));
+    }
+}
+function parseXml(source, label = 'Office XML') {
+    const document = new DOMParser().parseFromString(source, 'application/xml');
+    const error = descendants(document, 'parsererror')[0];
+    if (error) throw new Error(`${label} is not valid XML: ${error.textContent?.trim() || 'parse error'}`);
+    return document;
+}
+const xmlElementPatterns = new Map();
+function xmlContainsAnyElement(source, localNames) {
+    if (!source || !localNames.length) return false;
+    const key = localNames.join('\u0000');
+    let pattern = xmlElementPatterns.get(key);
+    if (!pattern) {
+        const alternatives = localNames.map((name)=>name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|');
+        pattern = new RegExp(`<(?:[A-Za-z_][\\w.-]*:)?(?:${alternatives})(?=[\\s/>])`);
+        xmlElementPatterns.set(key, pattern);
+    }
+    return pattern.test(source);
+}
+function attribute(element, name) {
+    const direct = element.getAttribute(name);
+    if (null !== direct) return direct;
+    const localName = name.includes(':') ? name.slice(name.indexOf(':') + 1) : name;
+    return Array.from(element.attributes).find((item)=>{
+        const itemLocalName = item.localName.includes(':') ? item.localName.slice(item.localName.indexOf(':') + 1) : item.localName;
+        return itemLocalName === localName && (!name.includes(':') || item.name === name);
+    })?.value ?? null;
+}
+function xmlNamespacePrefix(element, namespace) {
+    if (!namespace) return element.prefix;
+    if ('function' == typeof element.lookupPrefix) {
+        const prefix = element.lookupPrefix(namespace);
+        if (prefix) return prefix;
+    }
+    let current = element;
+    while(current){
+        if (current.namespaceURI === namespace && current.prefix) return current.prefix;
+        const declaration = Array.from(current.attributes).find((item)=>item.value === namespace && ('xmlns' === item.name || item.name.startsWith('xmlns:')));
+        if (declaration?.name.startsWith('xmlns:')) return declaration.name.slice(6);
+        current = current.parentElement;
+    }
+    return null;
+}
+function directChildren(parent, localName) {
+    return Array.from(parent.children).filter((element)=>!localName || element.localName === localName);
+}
+function directChild(parent, localName) {
+    return directChildren(parent, localName)[0];
+}
+function descendants(parent, localName) {
+    return Array.from(parent.querySelectorAll('*')).filter((element)=>element.localName === localName);
+}
+function firstDescendant(parent, localName) {
+    if (!parent) return;
+    return descendants(parent, localName)[0];
+}
+function childPath(parent, ...localNames) {
+    let current = parent;
+    for (const name of localNames){
+        if (!current) return;
+        current = directChild(current, name);
+    }
+    return current instanceof Element ? current : void 0;
+}
+function resolvePartTarget(sourcePart, target) {
+    if (/^[a-z][a-z0-9+.-]*:/i.test(target)) return target;
+    const segments = target.startsWith('/') ? [] : sourcePart.split('/').slice(0, -1);
+    for (const segment of target.replace(/^\/+/, '').split('/'))if (segment && '.' !== segment) if ('..' === segment) segments.pop();
+    else segments.push(segment);
+    return segments.join('/');
+}
+function contentTypeForPart(partPath) {
+    const extension = partPath.split('.').pop()?.toLowerCase();
+    const types = {
+        apng: 'image/apng',
+        bmp: 'image/bmp',
+        emf: 'image/emf',
+        gif: 'image/gif',
+        jpeg: 'image/jpeg',
+        jpg: 'image/jpeg',
+        png: 'image/png',
+        svg: 'image/svg+xml',
+        tif: 'image/tiff',
+        tiff: 'image/tiff',
+        webp: 'image/webp',
+        wmf: 'image/wmf'
+    };
+    return types[extension ?? ''] ?? 'application/octet-stream';
+}
+function bytesToDataUrl(bytes, contentType) {
+    let binary = '';
+    const chunkSize = 32768;
+    for(let offset = 0; offset < bytes.length; offset += chunkSize)binary += String.fromCharCode(...bytes.subarray(offset, offset + chunkSize));
+    return `data:${contentType};base64,${btoa(binary)}`;
+}
+function relationshipsPartPath(sourcePart) {
+    const separator = sourcePart.lastIndexOf('/');
+    const directory = separator >= 0 ? sourcePart.slice(0, separator + 1) : '';
+    const fileName = separator >= 0 ? sourcePart.slice(separator + 1) : sourcePart;
+    return `${directory}_rels/${fileName}.rels`;
+}
+const WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+class DocxThemePatchCollector {
+    patches = [];
+    nextMarker = 1;
+    usedColors;
+    constructor(sourceHtml){
+        this.usedColors = sourceColors(sourceHtml);
+    }
+    marker(kind, reference, currentColor) {
+        if (!reference || normalizeColor(currentColor) !== reference.resolved) return null;
+        let marker = '';
+        do {
+            marker = (0xf00000 + this.nextMarker).toString(16).padStart(6, '0').toUpperCase();
+            this.nextMarker += 1;
+        }while (this.usedColors.has(marker))
+        this.usedColors.add(marker);
+        this.patches.push({
+            kind,
+            marker,
+            reference
+        });
+        return marker;
+    }
+}
+function serializeDocxThemeReference(reference) {
+    return reference ? JSON.stringify(reference) : void 0;
+}
+function parseDocxThemeReference(value) {
+    if (!value) return null;
+    try {
+        const parsed = JSON.parse(value);
+        const theme = 'string' == typeof parsed.theme ? parsed.theme.trim() : '';
+        const resolved = normalizeColor('string' == typeof parsed.resolved ? parsed.resolved : null);
+        const tint = byteHex(parsed.tint);
+        const shade = byteHex(parsed.shade);
+        if (!theme || !resolved) return null;
+        return {
+            theme,
+            resolved,
+            ...tint ? {
+                tint
+            } : {},
+            ...shade ? {
+                shade
+            } : {}
+        };
+    } catch  {
+        return null;
+    }
+}
+async function patchDocxThemeReferences(buffer, patches) {
+    if (!patches.length) return buffer;
+    const archive = await jszip.loadAsync(buffer);
+    const byMarker = new Map(patches.map((patch)=>[
+            patch.marker,
+            patch
+        ]));
+    const entries = Object.values(archive.files).filter((entry)=>!entry.dir && /^word\/(?:document|header\d+|footer\d+|footnotes|endnotes|comments)\.xml$/.test(entry.name));
+    for (const entry of entries){
+        const document = parseXml(await entry.async('text'), entry.name);
+        let changed = false;
+        for (const element of Array.from(document.getElementsByTagName('*')))for (const target of themePatchTargets(element.localName)){
+            const marker = wordAttribute(element, target.directAttribute)?.toUpperCase();
+            const patch = marker ? byMarker.get(marker) : void 0;
+            if (patch && patch.kind === target.kind) {
+                setWordAttribute(document, element, target.directAttribute, patch.reference.resolved.slice(1).toUpperCase());
+                setWordAttribute(document, element, target.themeAttribute, patch.reference.theme);
+                setOptionalWordAttribute(document, element, target.tintAttribute, patch.reference.tint);
+                setOptionalWordAttribute(document, element, target.shadeAttribute, patch.reference.shade);
+                changed = true;
+            }
+        }
+        if (changed) archive.file(entry.name, new XMLSerializer().serializeToString(document));
+    }
+    return archive.generateAsync({
+        type: 'arraybuffer'
+    });
+}
+function themePatchTargets(localName) {
+    if ('color' === localName) return [
+        {
+            kind: 'color',
+            directAttribute: 'val',
+            themeAttribute: 'themeColor',
+            tintAttribute: 'themeTint',
+            shadeAttribute: 'themeShade'
+        }
+    ];
+    if ('u' === localName) return [
+        {
+            kind: 'underline',
+            directAttribute: 'color',
+            themeAttribute: 'themeColor',
+            tintAttribute: 'themeTint',
+            shadeAttribute: 'themeShade'
+        }
+    ];
+    if ('shd' === localName) return [
+        {
+            kind: 'fill',
+            directAttribute: 'fill',
+            themeAttribute: 'themeFill',
+            tintAttribute: 'themeFillTint',
+            shadeAttribute: 'themeFillShade'
+        },
+        {
+            kind: 'shadingColor',
+            directAttribute: 'color',
+            themeAttribute: 'themeColor',
+            tintAttribute: 'themeTint',
+            shadeAttribute: 'themeShade'
+        }
+    ];
+    return [
+        'top',
+        'right',
+        'bottom',
+        'left',
+        'start',
+        'end'
+    ].includes(localName) ? [
+        {
+            kind: 'border',
+            directAttribute: 'color',
+            themeAttribute: 'themeColor',
+            tintAttribute: 'themeTint',
+            shadeAttribute: 'themeShade'
+        }
+    ] : [];
+}
+function normalizeColor(value) {
+    const normalized = value?.trim().toLowerCase();
+    if (!normalized || !/^#[0-9a-f]{6}$/.test(normalized)) return null;
+    return normalized;
+}
+function sourceColors(source) {
+    const colors = new Set();
+    for (const match of source.matchAll(/#([0-9a-f]{6})\b/gi))if (match[1]) colors.add(match[1].toUpperCase());
+    for (const match of source.matchAll(/rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/gi)){
+        const channels = match.slice(1, 4).map(Number);
+        if (!channels.some((channel)=>channel < 0 || channel > 255)) colors.add(channels.map((channel)=>channel.toString(16).padStart(2, '0')).join('').toUpperCase());
+    }
+    return colors;
+}
+function byteHex(value) {
+    if ('string' != typeof value) return;
+    const normalized = value.trim().toUpperCase();
+    return /^[0-9A-F]{2}$/.test(normalized) ? normalized : void 0;
+}
+function wordAttribute(element, name) {
+    return element.getAttributeNS(WORD_NAMESPACE, name) ?? element.getAttribute(`w:${name}`);
+}
+function setWordAttribute(document, element, name, value) {
+    const prefix = xmlNamespacePrefix(document.documentElement, WORD_NAMESPACE) ?? 'w';
+    element.setAttributeNS(WORD_NAMESPACE, `${prefix}:${name}`, value);
+}
+function setOptionalWordAttribute(document, element, name, value) {
+    if (value) setWordAttribute(document, element, name, value);
+    else element.removeAttributeNS(WORD_NAMESPACE, name);
+}
+const DOCUMENT_PARAGRAPH_BORDERS_ATTRIBUTE = 'data-office-paragraph-borders';
+const DOCUMENT_PARAGRAPH_BORDER_EDGES = [
+    'top',
+    'left',
+    'bottom',
+    'right',
+    'between',
+    'bar'
+];
+const DOCUMENT_PARAGRAPH_BORDER_STYLES = [
+    'nil',
+    'none',
+    'single',
+    'thick',
+    'double',
+    'dotted',
+    'dashed',
+    'dotDash',
+    'dotDotDash',
+    'triple',
+    'thinThickSmallGap',
+    'thickThinSmallGap',
+    'thinThickThinSmallGap',
+    'thinThickMediumGap',
+    'thickThinMediumGap',
+    'thinThickThinMediumGap',
+    'thinThickLargeGap',
+    'thickThinLargeGap',
+    'thinThickThinLargeGap',
+    'wave',
+    'doubleWave',
+    'dashSmallGap',
+    'dashDotStroked',
+    'threeDEmboss',
+    'threeDEngrave',
+    'outset',
+    'inset',
+    'apples',
+    'archedScallops',
+    'babyPacifier',
+    'babyRattle',
+    'balloons3Colors',
+    'balloonsHotAir',
+    'basicBlackDashes',
+    'basicBlackDots',
+    'basicBlackSquares',
+    'basicThinLines',
+    'basicWhiteDashes',
+    'basicWhiteDots',
+    'basicWhiteSquares',
+    'basicWideInline',
+    'basicWideMidline',
+    'basicWideOutline',
+    'bats',
+    'birds',
+    'birdsFlight',
+    'cabins',
+    'cakeSlice',
+    'candyCorn',
+    'celticKnotwork',
+    'certificateBanner',
+    'chainLink',
+    'champagneBottle',
+    'checkedBarBlack',
+    'checkedBarColor',
+    'checkered',
+    'christmasTree',
+    'circlesLines',
+    'circlesRectangles',
+    'classicalWave',
+    'clocks',
+    'compass',
+    'confetti',
+    'confettiGrays',
+    'confettiOutline',
+    'confettiStreamers',
+    'confettiWhite',
+    'cornerTriangles',
+    'couponCutoutDashes',
+    'couponCutoutDots',
+    'crazyMaze',
+    'creaturesButterfly',
+    'creaturesFish',
+    'creaturesInsects',
+    'creaturesLadyBug',
+    'crossStitch',
+    'cup',
+    'decoArch',
+    'decoArchColor',
+    'decoBlocks',
+    'diamondsGray',
+    'doubleD',
+    'doubleDiamonds',
+    'earth1',
+    'earth2',
+    'eclipsingSquares1',
+    'eclipsingSquares2',
+    'eggsBlack',
+    'fans',
+    'film',
+    'firecrackers',
+    'flowersBlockPrint',
+    'flowersDaisies',
+    'flowersModern1',
+    'flowersModern2',
+    'flowersPansy',
+    'flowersRedRose',
+    'flowersRoses',
+    'flowersTeacup',
+    'flowersTiny',
+    'gems',
+    'gingerbreadMan',
+    'gradient',
+    'handmade1',
+    'handmade2',
+    'heartBalloon',
+    'heartGray',
+    'hearts',
+    'heebieJeebies',
+    'holly',
+    'houseFunky',
+    'hypnotic',
+    'iceCreamCones',
+    'lightBulb',
+    'lightning1',
+    'lightning2',
+    'mapPins',
+    'mapleLeaf',
+    'mapleMuffins',
+    'marquee',
+    'marqueeToothed',
+    'moons',
+    'mosaic',
+    'musicNotes',
+    'northwest',
+    'ovals',
+    'packages',
+    'palmsBlack',
+    'palmsColor',
+    'paperClips',
+    'papyrus',
+    'partyFavor',
+    'partyGlass',
+    'pencils',
+    'people',
+    'peopleWaving',
+    'peopleHats',
+    'poinsettias',
+    'postageStamp',
+    'pumpkin1',
+    'pushPinNote2',
+    'pushPinNote1',
+    'pyramids',
+    'pyramidsAbove',
+    'quadrants',
+    'rings',
+    'safari',
+    'sawtooth',
+    'sawtoothGray',
+    'scaredCat',
+    'seattle',
+    'shadowedSquares',
+    'sharksTeeth',
+    'shorebirdTracks',
+    'skyrocket',
+    'snowflakeFancy',
+    'snowflakes',
+    'sombrero',
+    'southwest',
+    'stars',
+    'starsTop',
+    'stars3d',
+    'starsBlack',
+    'starsShadowed',
+    'sun',
+    'swirligig',
+    'tornPaper',
+    'tornPaperBlack',
+    'trees',
+    'triangleParty',
+    'triangles',
+    'tribal1',
+    'tribal2',
+    'tribal3',
+    'tribal4',
+    'tribal5',
+    'tribal6',
+    'triangle1',
+    'triangle2',
+    'triangleCircle1',
+    'triangleCircle2',
+    'shapes1',
+    'shapes2',
+    'twistedLines1',
+    'twistedLines2',
+    'vine',
+    'waveline',
+    'weavingAngles',
+    'weavingBraid',
+    'weavingRibbon',
+    'weavingStrips',
+    'whiteFlowers',
+    'woodwork',
+    'xIllusions',
+    'zanyTriangles',
+    'zigZag',
+    'zigZagStitch'
+];
+const BORDER_STYLE_SET = new Set(DOCUMENT_PARAGRAPH_BORDER_STYLES);
+const BORDER_EDGE_SET = new Set(DOCUMENT_PARAGRAPH_BORDER_EDGES);
+const BORDER_PROPERTY_SET = new Set([
+    'style',
+    'color',
+    'size',
+    'space',
+    'shadow',
+    'frame'
+]);
+const LINE_BORDER_STYLES = new Set(DOCUMENT_PARAGRAPH_BORDER_STYLES.slice(0, 27));
+const DASHED_BORDER_STYLES = new Set([
+    'dashed',
+    'dashSmallGap',
+    'dashDotStroked',
+    'dotDash',
+    'dotDotDash'
+]);
+const DOUBLE_BORDER_STYLES = new Set([
+    'double',
+    'triple',
+    'thinThickSmallGap',
+    'thickThinSmallGap',
+    'thinThickThinSmallGap',
+    'thinThickMediumGap',
+    'thickThinMediumGap',
+    'thinThickThinMediumGap',
+    'thinThickLargeGap',
+    'thickThinLargeGap',
+    'thinThickThinLargeGap',
+    'doubleWave'
+]);
+const MAX_SERIALIZED_PARAGRAPH_BORDERS = 32768;
+const POINTS_TO_PIXELS = 96 / 72;
+function normalizeDocumentParagraphBorders(source) {
+    if (!source || 'object' != typeof source || Array.isArray(source)) return null;
+    const record = source;
+    if (Object.keys(record).some((key)=>!BORDER_EDGE_SET.has(key))) return null;
+    const borders = {};
+    for (const edge of DOCUMENT_PARAGRAPH_BORDER_EDGES){
+        if (void 0 === record[edge]) continue;
+        const border = normalizeDocumentParagraphBorder(record[edge]);
+        if (!border) return null;
+        borders[edge] = border;
+    }
+    return Object.keys(borders).length ? borders : null;
+}
+function normalizeDocumentParagraphBorder(source) {
+    if (!source || 'object' != typeof source || Array.isArray(source)) return null;
+    const record = source;
+    if (Object.keys(record).some((key)=>!BORDER_PROPERTY_SET.has(key))) return null;
+    const style = record.style;
+    if ('string' != typeof style || !BORDER_STYLE_SET.has(style)) return null;
+    const normalizedStyle = style;
+    const color = normalizeBorderColor(record.color);
+    if (void 0 !== record.color && !color) return null;
+    const size = optionalInteger(record.size);
+    if (null === size || void 0 !== size && !validBorderSize(normalizedStyle, size)) return null;
+    const space = optionalInteger(record.space);
+    if (null === space || void 0 !== space && (space < 0 || space > 31)) return null;
+    const shadow = optionalBoolean(record.shadow);
+    const frame = optionalBoolean(record.frame);
+    if (null === shadow || null === frame) return null;
+    return {
+        style: normalizedStyle,
+        ...color ? {
+            color
+        } : {},
+        ...void 0 !== size ? {
+            size
+        } : {},
+        ...void 0 !== space ? {
+            space
+        } : {},
+        ...void 0 !== shadow ? {
+            shadow
+        } : {},
+        ...void 0 !== frame ? {
+            frame
+        } : {}
+    };
+}
+function parseDocumentParagraphBorders(source) {
+    if ('string' != typeof source) return normalizeDocumentParagraphBorders(source);
+    if (!source.trim() || source.length > MAX_SERIALIZED_PARAGRAPH_BORDERS) return null;
+    try {
+        return normalizeDocumentParagraphBorders(JSON.parse(source));
+    } catch  {
+        return null;
+    }
+}
+function serializeDocumentParagraphBorders(source) {
+    const borders = normalizeDocumentParagraphBorders(source);
+    if (!borders) return;
+    return JSON.stringify(Object.fromEntries(DOCUMENT_PARAGRAPH_BORDER_EDGES.flatMap((edge)=>{
+        const border = borders[edge];
+        return border ? [
+            [
+                edge,
+                serializedBorder(border)
+            ]
+        ] : [];
+    })));
+}
+function parseDocumentParagraphBordersElement(element) {
+    const semantic = parseDocumentParagraphBorders(element.getAttribute(DOCUMENT_PARAGRAPH_BORDERS_ATTRIBUTE));
+    if (!semantic) return paragraphBordersFromCss(element);
+    const edited = {
+        ...semantic
+    };
+    for (const edge of [
+        'top',
+        'left',
+        'bottom',
+        'right'
+    ]){
+        const border = semantic[edge];
+        const css = cssBorder(element, edge);
+        if (!(!css || border && sameBorderPresentation(border, css))) {
+            if ('none' === css.style) {
+                edited[edge] = {
+                    style: 'nil'
+                };
+                continue;
+            }
+            edited[edge] = {
+                ...border ?? {
+                    style: 'single'
+                },
+                style: cssStyleToBorderStyle(css.style),
+                color: {
+                    value: css.color
+                },
+                size: cssWidthToEighthPoints(css.width)
+            };
+        }
+    }
+    return normalizeDocumentParagraphBorders(edited);
+}
+function documentParagraphBordersDomAttributes(source) {
+    const borders = normalizeDocumentParagraphBorders(source);
+    const serialized = serializeDocumentParagraphBorders(borders);
+    if (!borders || !serialized) return {};
+    const styles = [];
+    const shadows = [];
+    for (const edge of [
+        'top',
+        'left',
+        'bottom',
+        'right'
+    ]){
+        const border = borders[edge];
+        if (!border) continue;
+        const presentation = documentBorderPresentation(border);
+        styles.push(`border-${edge}: ${formatPixels(presentation.width)}px ${presentation.style} ${presentation.color}`);
+        if (border.space) styles.push(`padding-${edge}: ${formatPixels(border.space * POINTS_TO_PIXELS)}px`);
+        if (border.shadow && presentation.width > 0) shadows.push(`2px 2px 0 ${presentation.color}`);
+    }
+    const between = borders.between ? documentBorderPresentation(borders.between) : null;
+    if (between && between.width > 0) shadows.push(`inset 0 -${formatPixels(between.width)}px 0 ${between.color}`);
+    const bar = borders.bar ? documentBorderPresentation(borders.bar) : null;
+    if (bar && bar.width > 0) shadows.push(`inset ${formatPixels(bar.width)}px 0 0 ${bar.color}`);
+    if (shadows.length) styles.push(`box-shadow: ${shadows.join(', ')}`);
+    return {
+        [DOCUMENT_PARAGRAPH_BORDERS_ATTRIBUTE]: serialized,
+        ...styles.length ? {
+            style: styles.join('; ')
+        } : {}
+    };
+}
+function isDocumentParagraphArtBorderStyle(style) {
+    return !LINE_BORDER_STYLES.has(style);
+}
+function normalizeBorderColor(source) {
+    if (!source || 'object' != typeof source || Array.isArray(source)) return null;
+    const record = source;
+    if (Object.keys(record).some((key)=>'value' !== key && 'theme' !== key)) return null;
+    const theme = parseDocxThemeReference('string' == typeof record.theme ? record.theme : record.theme ? JSON.stringify(record.theme) : void 0);
+    const direct = 'auto' === record.value ? 'auto' : 'string' == typeof record.value ? normalizeCssColor(record.value) : null;
+    const resolved = direct ?? theme?.resolved ?? null;
+    if (!resolved || 'transparent' === resolved) return null;
+    if (theme && resolved !== theme.resolved && !('auto' === resolved && 'none' === theme.theme && '#000000' === theme.resolved)) return null;
+    return {
+        value: resolved,
+        ...theme ? {
+            theme
+        } : {}
+    };
+}
+function serializedBorder(border) {
+    const color = border.color ? serializedBorderColor(border.color) : void 0;
+    return {
+        style: border.style,
+        ...color ? {
+            color
+        } : {},
+        ...void 0 !== border.size ? {
+            size: border.size
+        } : {},
+        ...void 0 !== border.space ? {
+            space: border.space
+        } : {},
+        ...void 0 !== border.shadow ? {
+            shadow: border.shadow
+        } : {},
+        ...void 0 !== border.frame ? {
+            frame: border.frame
+        } : {}
+    };
+}
+function serializedBorderColor(color) {
+    const theme = serializeDocxThemeReference(color.theme ?? null);
+    return {
+        value: color.value,
+        ...theme ? {
+            theme: JSON.parse(theme)
+        } : {}
+    };
+}
+function optionalInteger(value) {
+    if (void 0 === value) return;
+    return 'number' == typeof value && Number.isSafeInteger(value) ? value : null;
+}
+function optionalBoolean(value) {
+    if (void 0 === value) return;
+    return 'boolean' == typeof value ? value : null;
+}
+function validBorderSize(style, size) {
+    if ('nil' === style || 'none' === style) return size >= 0 && size <= 96;
+    return isDocumentParagraphArtBorderStyle(style) ? size >= 1 && size <= 31 : size >= 2 && size <= 96;
+}
+function documentBorderPresentation(border) {
+    if ('nil' === border.style || 'none' === border.style || !border.size) return {
+        color: 'transparent',
+        style: 'none',
+        width: 0
+    };
+    const width = Math.min(16, isDocumentParagraphArtBorderStyle(border.style) ? border.size * POINTS_TO_PIXELS : border.size / 6);
+    return {
+        color: border.color && 'auto' !== border.color.value ? border.color.value : '#000000',
+        style: borderStyleToCssStyle(border.style),
+        width
+    };
+}
+function borderStyleToCssStyle(style) {
+    if ('nil' === style || 'none' === style) return 'none';
+    if ('dotted' === style) return 'dotted';
+    if (DASHED_BORDER_STYLES.has(style)) return 'dashed';
+    if (DOUBLE_BORDER_STYLES.has(style)) return 'double';
+    if ('inset' === style || 'threeDEngrave' === style) return 'inset';
+    if ('outset' === style || 'threeDEmboss' === style) return 'outset';
+    return 'solid';
+}
+function paragraphBordersFromCss(element) {
+    const borders = {};
+    for (const edge of [
+        'top',
+        'left',
+        'bottom',
+        'right'
+    ]){
+        const css = cssBorder(element, edge);
+        if (css && 'none' !== css.style) borders[edge] = {
+            style: cssStyleToBorderStyle(css.style),
+            color: {
+                value: css.color
+            },
+            size: cssWidthToEighthPoints(css.width)
+        };
+    }
+    return normalizeDocumentParagraphBorders(borders);
+}
+function cssBorder(element, edge) {
+    const style = element.style.getPropertyValue(`border-${edge}-style`).trim();
+    const width = Number.parseFloat(element.style.getPropertyValue(`border-${edge}-width`));
+    const color = normalizeCssColor(element.style.getPropertyValue(`border-${edge}-color`));
+    if (!style) return null;
+    if ('none' === style || 'hidden' === style) return {
+        color: '#000000',
+        style: 'none',
+        width: 0
+    };
+    return color && 'transparent' !== color && Number.isFinite(width) && width > 0 ? {
+        color,
+        style,
+        width
+    } : null;
+}
+function sameBorderPresentation(border, css) {
+    const expected = documentBorderPresentation(border);
+    if ('none' === expected.style) return 'none' === css.style && 0 === css.width;
+    return expected.color === css.color && expected.style === css.style && Math.abs(expected.width - css.width) < 0.01;
+}
+function cssStyleToBorderStyle(style) {
+    if ('double' === style) return 'double';
+    if ('dashed' === style) return 'dashed';
+    if ('dotted' === style) return 'dotted';
+    if ('inset' === style || 'groove' === style) return 'inset';
+    if ('outset' === style || 'ridge' === style) return 'outset';
+    return 'single';
+}
+function cssWidthToEighthPoints(width) {
+    return Math.max(2, Math.min(96, Math.round(6 * width)));
+}
+function formatPixels(value) {
+    return Number(value.toFixed(3)).toString();
+}
+const DOCUMENT_RUN_BORDER_ATTRIBUTE = 'data-office-run-border';
+const DOCUMENT_RUN_BORDER_STYLES = DOCUMENT_PARAGRAPH_BORDER_STYLES.slice(0, 27);
+const MAX_SERIALIZED_RUN_BORDER_BYTES = 4096;
+const work_document_run_border_POINTS_TO_PIXELS = 96 / 72;
+function normalizeDocumentRunBorder(source) {
+    const border = normalizeDocumentParagraphBorder(source);
+    return border && !isDocumentParagraphArtBorderStyle(border.style) ? border : null;
+}
+function parseDocumentRunBorder(source) {
+    if ('string' != typeof source) return normalizeDocumentRunBorder(source);
+    if (!source.trim() || source.length > MAX_SERIALIZED_RUN_BORDER_BYTES) return null;
+    try {
+        return normalizeDocumentRunBorder(JSON.parse(source));
+    } catch  {
+        return null;
+    }
+}
+function serializeDocumentRunBorder(source) {
+    const border = normalizeDocumentRunBorder(source);
+    if (!border) return;
+    const theme = serializeDocxThemeReference(border.color?.theme ?? null);
+    return JSON.stringify({
+        style: border.style,
+        ...border.color ? {
+            color: {
+                value: border.color.value,
+                ...theme ? {
+                    theme: JSON.parse(theme)
+                } : {}
+            }
+        } : {},
+        ...void 0 !== border.size ? {
+            size: border.size
+        } : {},
+        ...void 0 !== border.space ? {
+            space: border.space
+        } : {},
+        ...void 0 !== border.shadow ? {
+            shadow: border.shadow
+        } : {},
+        ...void 0 !== border.frame ? {
+            frame: border.frame
+        } : {}
+    });
+}
+function parseDocumentRunBorderElement(element) {
+    const semantic = parseDocumentRunBorder(element.getAttribute(DOCUMENT_RUN_BORDER_ATTRIBUTE));
+    return semantic ?? documentRunBorderFromCss(element);
+}
+function documentRunBorderDomAttributes(source) {
+    const border = normalizeDocumentRunBorder(source);
+    const serialized = serializeDocumentRunBorder(border);
+    if (!border || !serialized) return {};
+    const presentation = documentBorderPresentation(border);
+    const declarations = [
+        `border: ${work_document_run_border_formatPixels(presentation.width)}px ${presentation.style} ${presentation.color}`,
+        `padding: ${work_document_run_border_formatPixels((border.space ?? 0) * work_document_run_border_POINTS_TO_PIXELS)}px`,
+        'box-decoration-break: clone',
+        '-webkit-box-decoration-break: clone'
+    ];
+    if (border.shadow && presentation.width > 0) declarations.push(`box-shadow: 2px 2px 0 ${presentation.color}`);
+    return {
+        [DOCUMENT_RUN_BORDER_ATTRIBUTE]: serialized,
+        style: declarations.join('; ')
+    };
+}
+function documentRunBorderIsVisible(source) {
+    const border = normalizeDocumentRunBorder(source);
+    return Boolean(border && documentBorderPresentation(border).width > 0);
+}
+function documentRunBorderFromCss(element) {
+    const style = element.style.borderStyle.trim();
+    if (!style) return null;
+    if ('none' === style || 'hidden' === style) return {
+        style: 'none'
+    };
+    const width = Number.parseFloat(element.style.borderWidth);
+    const color = normalizeCssColor(element.style.borderColor);
+    if (!Number.isFinite(width) || width <= 0 || !color || 'transparent' === color) return null;
+    const padding = Number.parseFloat(element.style.padding);
+    return normalizeDocumentRunBorder({
+        style: cssBorderStyle(style),
+        color: {
+            value: color
+        },
+        size: Math.max(2, Math.min(96, Math.round(6 * width))),
+        ...Number.isFinite(padding) && padding >= 0 ? {
+            space: Math.max(0, Math.min(31, Math.round(padding / work_document_run_border_POINTS_TO_PIXELS)))
+        } : {}
+    });
+}
+function cssBorderStyle(style) {
+    if ('double' === style) return 'double';
+    if ('dashed' === style) return 'dashed';
+    if ('dotted' === style) return 'dotted';
+    if ('inset' === style || 'groove' === style) return 'inset';
+    if ('outset' === style || 'ridge' === style) return 'outset';
+    return 'single';
+}
+function work_document_run_border_formatPixels(value) {
+    return Number(value.toFixed(3)).toString();
+}
+const work_document_paragraph_shading_DOCUMENT_PARAGRAPH_SHADING_PATTERNS = new Set([
+    'nil',
+    'clear',
+    'solid',
+    'horzStripe',
+    'vertStripe',
+    'reverseDiagStripe',
+    'diagStripe',
+    'horzCross',
+    'diagCross',
+    'thinHorzStripe',
+    'thinVertStripe',
+    'thinReverseDiagStripe',
+    'thinDiagStripe',
+    'thinHorzCross',
+    'thinDiagCross',
+    'pct5',
+    'pct10',
+    'pct12',
+    'pct15',
+    'pct20',
+    'pct25',
+    'pct30',
+    'pct35',
+    'pct37',
+    'pct40',
+    'pct45',
+    'pct50',
+    'pct55',
+    'pct60',
+    'pct62',
+    'pct65',
+    'pct70',
+    'pct75',
+    'pct80',
+    'pct85',
+    'pct87',
+    'pct90',
+    'pct95'
+]);
+function normalizeDocumentParagraphShading(source) {
+    if (!source || 'object' != typeof source) return null;
+    const value = source;
+    const pattern = value.pattern;
+    if ('string' != typeof pattern || !work_document_paragraph_shading_DOCUMENT_PARAGRAPH_SHADING_PATTERNS.has(pattern)) return null;
+    const color = normalizeShadingColor(value.color);
+    const fill = normalizeShadingColor(value.fill);
+    if (void 0 !== value.color && !color || void 0 !== value.fill && !fill) return null;
+    return {
+        pattern: pattern,
+        ...color ? {
+            color
+        } : {},
+        ...fill ? {
+            fill
+        } : {}
+    };
+}
+function parseDocumentParagraphShading(source) {
+    if ('string' != typeof source) return normalizeDocumentParagraphShading(source);
+    if (!source.trim()) return null;
+    try {
+        return normalizeDocumentParagraphShading(JSON.parse(source));
+    } catch  {
+        return null;
+    }
+}
+function serializeDocumentParagraphShading(source) {
+    const shading = normalizeDocumentParagraphShading(source);
+    if (!shading) return;
+    return JSON.stringify({
+        pattern: shading.pattern,
+        ...shading.color ? {
+            color: serializedShadingColor(shading.color)
+        } : {},
+        ...shading.fill ? {
+            fill: serializedShadingColor(shading.fill)
+        } : {}
+    });
+}
+function parseDocumentParagraphShadingElement(element) {
+    const semantic = parseDocumentParagraphShading(element.dataset.officeParagraphShading);
+    const background = normalizeCssColor(element.style.backgroundColor);
+    if (semantic) {
+        const presentation = documentParagraphShadingPresentation(semantic);
+        const expected = normalizeCssColor(presentation.backgroundColor);
+        if (background && expected && background !== expected) {
+            if ('transparent' === background) return {
+                pattern: 'nil'
+            };
+            if (paragraphShadingBackgroundUsesForeground(semantic)) return {
+                ...semantic,
+                color: {
+                    value: background
+                }
+            };
+            return {
+                ...semantic,
+                fill: {
+                    value: background
+                }
+            };
+        }
+        return semantic;
+    }
+    return background && 'transparent' !== background ? {
+        pattern: 'clear',
+        fill: {
+            value: background
+        }
+    } : null;
+}
+function documentParagraphShadingDomAttributes(source) {
+    const shading = normalizeDocumentParagraphShading(source);
+    const serialized = serializeDocumentParagraphShading(shading);
+    if (!shading || !serialized) return {};
+    const presentation = documentParagraphShadingPresentation(shading);
+    const styles = [
+        `background-color: ${presentation.backgroundColor}`,
+        presentation.backgroundImage ? `background-image: ${presentation.backgroundImage}` : '',
+        presentation.backgroundSize ? `background-size: ${presentation.backgroundSize}` : ''
+    ].filter(Boolean);
+    return {
+        'data-office-paragraph-shading': serialized,
+        style: styles.join('; ')
+    };
+}
+function normalizeShadingColor(source) {
+    if (!source || 'object' != typeof source) return null;
+    const value = source;
+    const theme = parseDocxThemeReference('string' == typeof value.theme ? value.theme : value.theme ? JSON.stringify(value.theme) : void 0);
+    const direct = 'auto' === value.value ? 'auto' : 'string' == typeof value.value ? normalizeCssColor(value.value) : null;
+    const resolved = direct ?? theme?.resolved ?? null;
+    if (!resolved || 'transparent' === resolved) return null;
+    if (theme && resolved !== theme.resolved) return null;
+    return {
+        value: resolved,
+        ...theme ? {
+            theme
+        } : {}
+    };
+}
+function serializedShadingColor(color) {
+    const theme = serializeDocxThemeReference(color.theme ?? null);
+    return {
+        value: color.value,
+        ...theme ? {
+            theme: JSON.parse(theme)
+        } : {}
+    };
+}
+function documentParagraphShadingPresentation(shading) {
+    if ('nil' === shading.pattern) return {
+        backgroundColor: 'transparent'
+    };
+    const foreground = shadingColor(shading.color, '#000000');
+    const background = shadingColor(shading.fill, 'transparent');
+    if ('clear' === shading.pattern) return {
+        backgroundColor: background
+    };
+    if ('solid' === shading.pattern) return {
+        backgroundColor: foreground
+    };
+    const percentage = shadingPercentage(shading.pattern);
+    if (null !== percentage) {
+        const inverted = percentage > 50;
+        const dotColor = inverted ? background : foreground;
+        const baseColor = inverted ? foreground : background;
+        const density = Math.min(50, inverted ? 100 - percentage : percentage);
+        const spacing = Math.max(2, Math.round(9 - density / 7));
+        return {
+            backgroundColor: baseColor,
+            backgroundImage: `radial-gradient(circle, ${dotColor} 0 1px, transparent 1.2px)`,
+            backgroundSize: `${spacing}px ${spacing}px`
+        };
+    }
+    const thin = shading.pattern.startsWith('thin');
+    const width = thin ? 1 : 2;
+    const period = thin ? 7 : 6;
+    const stripe = (angle)=>`repeating-linear-gradient(${angle}deg, ${foreground} 0 ${width}px, transparent ${width}px ${period}px)`;
+    const angles = shadingPatternAngles(shading.pattern);
+    return {
+        backgroundColor: background,
+        backgroundImage: angles.map(stripe).join(', ')
+    };
+}
+function shadingColor(color, fallback) {
+    return color && 'auto' !== color.value ? color.value : fallback;
+}
+function shadingPercentage(pattern) {
+    const match = /^pct(\d+)$/.exec(pattern);
+    return match?.[1] ? Number(match[1]) : null;
+}
+function paragraphShadingBackgroundUsesForeground(shading) {
+    if ('solid' === shading.pattern) return true;
+    const percentage = shadingPercentage(shading.pattern);
+    return null !== percentage && percentage > 50;
+}
+function shadingPatternAngles(pattern) {
+    if (pattern.includes('HorzCross')) return [
+        0,
+        90
+    ];
+    if (pattern.includes('DiagCross')) return [
+        45,
+        -45
+    ];
+    if (pattern.includes('VertStripe')) return [
+        90
+    ];
+    if (pattern.includes('ReverseDiagStripe')) return [
+        -45
+    ];
+    if (pattern.includes('DiagStripe')) return [
+        45
+    ];
+    return [
+        0
+    ];
+}
+const DOCUMENT_HIGHLIGHT_ATTRIBUTE = 'data-office-highlight';
+const DOCUMENT_HIGHLIGHT_VALUES = new Set([
+    'black',
+    'blue',
+    'cyan',
+    'darkBlue',
+    'darkCyan',
+    'darkGray',
+    'darkGreen',
+    'darkMagenta',
+    'darkRed',
+    'darkYellow',
+    'green',
+    'lightGray',
+    'magenta',
+    'none',
+    'red',
+    'white',
+    'yellow'
+]);
+const HIGHLIGHT_COLORS = {
+    black: '#000000',
+    blue: '#0000ff',
+    cyan: '#00ffff',
+    darkBlue: '#000080',
+    darkCyan: '#008080',
+    darkGray: '#808080',
+    darkGreen: '#008000',
+    darkMagenta: '#800080',
+    darkRed: '#800000',
+    darkYellow: '#808000',
+    green: '#00ff00',
+    lightGray: '#c0c0c0',
+    magenta: '#ff00ff',
+    none: 'transparent',
+    red: '#ff0000',
+    white: '#ffffff',
+    yellow: '#ffff00'
+};
+function normalizeDocumentHighlight(source) {
+    return 'string' == typeof source && DOCUMENT_HIGHLIGHT_VALUES.has(source) ? source : null;
+}
+function documentHighlightFromDocxValue(source) {
+    if ('string' != typeof source) return null;
+    const normalized = source.trim().toLowerCase();
+    for (const value of DOCUMENT_HIGHLIGHT_VALUES)if (value.toLowerCase() === normalized) return value;
+    return null;
+}
+function documentHighlightCssColor(source) {
+    const value = normalizeDocumentHighlight(source);
+    return value ? HIGHLIGHT_COLORS[value] : null;
+}
+function documentHighlightForCssColor(source) {
+    const color = normalizeCssColor('string' == typeof source ? source : null);
+    if (!color) return null;
+    for (const [value, candidate] of Object.entries(HIGHLIGHT_COLORS))if (candidate === color) return value;
+    return null;
+}
+function documentHighlightFromElement(element) {
+    return normalizeDocumentHighlight(element.getAttribute(DOCUMENT_HIGHLIGHT_ATTRIBUTE)) ?? documentHighlightForCssColor(element.style.backgroundColor);
+}
+function documentHighlightDomAttributes(source) {
+    const value = normalizeDocumentHighlight(source);
+    const color = documentHighlightCssColor(value);
+    return value && color ? {
+        [DOCUMENT_HIGHLIGHT_ATTRIBUTE]: value,
+        style: `background-color: ${color}`
+    } : {};
+}
+const DOCUMENT_RUN_SHADING_ATTRIBUTE = 'data-office-run-shading';
+const MAX_SERIALIZED_RUN_SHADING_BYTES = 4096;
+const RUN_SHADING_KEYS = new Set([
+    'pattern',
+    'color',
+    'fill'
+]);
+const RUN_SHADING_COLOR_KEYS = new Set([
+    'value',
+    'theme'
+]);
+const THEME_REFERENCE_KEYS = new Set([
+    'theme',
+    'resolved',
+    'tint',
+    'shade'
+]);
+function normalizeDocumentRunShading(source) {
+    if (!isRecordWithKeys(source, RUN_SHADING_KEYS)) return null;
+    for (const name of [
+        'color',
+        'fill'
+    ]){
+        const color = source[name];
+        if (void 0 !== color) {
+            if (!isRecordWithKeys(color, RUN_SHADING_COLOR_KEYS)) return null;
+            if (void 0 !== color.theme && !isRecordWithKeys(color.theme, THEME_REFERENCE_KEYS)) return null;
+        }
+    }
+    return normalizeDocumentParagraphShading(source);
+}
+function parseDocumentRunShading(source) {
+    if ('string' != typeof source) return normalizeDocumentRunShading(source);
+    if (!source.trim() || source.length > MAX_SERIALIZED_RUN_SHADING_BYTES) return null;
+    try {
+        return normalizeDocumentRunShading(JSON.parse(source));
+    } catch  {
+        return null;
+    }
+}
+function serializeDocumentRunShading(source) {
+    const shading = normalizeDocumentRunShading(source);
+    const serialized = shading ? serializeDocumentParagraphShading(shading) : void 0;
+    return serialized && serialized.length <= MAX_SERIALIZED_RUN_SHADING_BYTES ? serialized : void 0;
+}
+function parseDocumentRunShadingElement(element) {
+    const semantic = parseDocumentRunShading(element.getAttribute(DOCUMENT_RUN_SHADING_ATTRIBUTE));
+    if (!semantic) return null;
+    if (element.hasAttribute(DOCUMENT_HIGHLIGHT_ATTRIBUTE)) return semantic;
+    const background = normalizeCssColor(element.style.backgroundColor);
+    const expected = normalizeCssColor(documentParagraphShadingPresentation(semantic).backgroundColor);
+    if (!background || !expected || background === expected) return semantic;
+    if ('transparent' === background) return {
+        pattern: 'nil'
+    };
+    return paragraphShadingBackgroundUsesForeground(semantic) ? {
+        ...semantic,
+        color: {
+            value: background
+        }
+    } : {
+        ...semantic,
+        fill: {
+            value: background
+        }
+    };
+}
+function documentRunShadingDomAttributes(source) {
+    const shading = normalizeDocumentRunShading(source);
+    const serialized = serializeDocumentRunShading(shading);
+    if (!shading || !serialized) return {};
+    const paragraphAttributes = documentParagraphShadingDomAttributes(shading);
+    const style = [
+        paragraphAttributes.style,
+        'box-decoration-break: clone',
+        '-webkit-box-decoration-break: clone'
+    ].filter(Boolean).join('; ');
+    return {
+        [DOCUMENT_RUN_SHADING_ATTRIBUTE]: serialized,
+        style
+    };
+}
+function isRecordWithKeys(source, allowed) {
+    return 'object' == typeof source && null !== source && !Array.isArray(source) && Object.keys(source).every((key)=>allowed.has(key));
+}
+const DOCUMENT_SCRIPT_FONTS_ATTRIBUTE = "data-office-script-fonts";
+const DOCUMENT_SCRIPT_FONT_SLOT_ATTRIBUTE = "data-office-script-font-slot";
+const MAX_FONT_NAME_LENGTH = 127;
+const MAX_SERIALIZED_SCRIPT_FONTS_LENGTH = 4096;
+const SCRIPT_FONT_KEYS = new Set([
+    'ascii',
+    'highAnsi',
+    'eastAsia',
+    'complexScript',
+    'hint'
+]);
+const SCRIPT_FONT_FACE_KEYS = new Set([
+    'name',
+    'theme',
+    'resolved'
+]);
+const SCRIPT_FONT_HINTS = new Set([
+    'default',
+    'eastAsia',
+    'cs'
+]);
+const THEME_FONTS = new Set([
+    'majorEastAsia',
+    'majorBidi',
+    'majorAscii',
+    'majorHAnsi',
+    'minorEastAsia',
+    'minorBidi',
+    'minorAscii',
+    'minorHAnsi'
+]);
+const SLOT_FALLBACK_ORDER = {
+    ascii: [
+        'ascii',
+        'highAnsi',
+        'eastAsia',
+        'complexScript'
+    ],
+    highAnsi: [
+        'highAnsi',
+        'ascii',
+        'eastAsia',
+        'complexScript'
+    ],
+    eastAsia: [
+        'eastAsia',
+        'highAnsi',
+        'ascii',
+        'complexScript'
+    ],
+    complexScript: [
+        'complexScript',
+        'highAnsi',
+        'ascii',
+        'eastAsia'
+    ]
+};
+const NEUTRAL_SCRIPT_CHARACTER = /^[\p{Cc}\p{Cf}\p{M}\p{N}\p{P}\p{S}\p{Z}]$/u;
+function normalizeDocumentScriptFonts(source) {
+    if (!work_document_script_fonts_isRecordWithKeys(source, SCRIPT_FONT_KEYS)) return null;
+    const normalized = {};
+    for (const slot of scriptFontSlots){
+        if (void 0 === source[slot]) continue;
+        const face = normalizeDocumentScriptFontFace(source[slot]);
+        if (!face) return null;
+        normalized[slot] = face;
+    }
+    if (void 0 !== source.hint) {
+        const hint = normalizeDocumentScriptFontHint(source.hint);
+        if (!hint) return null;
+        normalized.hint = hint;
+    }
+    return Object.keys(normalized).length ? normalized : null;
+}
+function serializeDocumentScriptFonts(source) {
+    const fonts = normalizeDocumentScriptFonts(source);
+    return fonts ? JSON.stringify(fonts) : null;
+}
+function parseDocumentScriptFonts(source) {
+    if (!source || source.length > MAX_SERIALIZED_SCRIPT_FONTS_LENGTH) return null;
+    try {
+        return normalizeDocumentScriptFonts(JSON.parse(source));
+    } catch  {
+        return null;
+    }
+}
+function documentScriptFontsFromElement(element) {
+    return parseDocumentScriptFonts(element.getAttribute(DOCUMENT_SCRIPT_FONTS_ATTRIBUTE));
+}
+function documentScriptFontSlotFromElement(element) {
+    return normalizeDocumentScriptFontSlot(element.getAttribute(DOCUMENT_SCRIPT_FONT_SLOT_ATTRIBUTE));
+}
+function documentScriptFontsDomAttributes(source, slot) {
+    const fonts = normalizeDocumentScriptFonts(source);
+    const normalizedSlot = normalizeDocumentScriptFontSlot(slot);
+    if (!fonts) return {};
+    const serialized = serializeDocumentScriptFonts(fonts);
+    if (!serialized) return {};
+    const family = documentScriptFontFamily(fonts, normalizedSlot ?? documentScriptFontSlotFromHint(fonts.hint));
+    return {
+        [DOCUMENT_SCRIPT_FONTS_ATTRIBUTE]: serialized,
+        ...normalizedSlot ? {
+            [DOCUMENT_SCRIPT_FONT_SLOT_ATTRIBUTE]: normalizedSlot
+        } : {},
+        ...family ? {
+            style: `font-family: ${family}`
+        } : {}
+    };
+}
+function documentScriptFontFamily(source, slot) {
+    const fonts = normalizeDocumentScriptFonts(source);
+    if (!fonts) return;
+    const families = [];
+    const seen = new Set();
+    for (const candidate of documentScriptFontFallbackSlots(slot)){
+        const family = documentScriptFontFaceFamily(fonts[candidate]);
+        const key = family?.toLocaleLowerCase();
+        if (!(!family || !key || seen.has(key))) {
+            seen.add(key);
+            families.push(cssFontFamily(family));
+        }
+    }
+    return families.length ? families.join(', ') : void 0;
+}
+function documentScriptFontFallbackSlots(slot) {
+    return SLOT_FALLBACK_ORDER[slot];
+}
+function documentScriptFontFamilyForRendering(source, slot, currentFontFamily) {
+    const projected = documentScriptFontFamily(source, slot);
+    const safeCurrent = safeCssFontFamilyList(currentFontFamily);
+    if (!safeCurrent || !projected) return projected;
+    const currentPrimary = documentFontNameFromCssFamily(safeCurrent);
+    const projectedPrimary = documentFontNameFromCssFamily(projected);
+    return currentPrimary && projectedPrimary && currentPrimary.toLocaleLowerCase() === projectedPrimary.toLocaleLowerCase() ? safeCurrent : projected;
+}
+function documentScriptFontDirectFamily(source, slot) {
+    const fonts = normalizeDocumentScriptFonts(source);
+    return fonts ? documentScriptFontFaceFamily(fonts[slot]) ?? null : null;
+}
+function documentScriptFontsForAllText(fontFamily) {
+    const name = documentFontNameFromCssFamily(fontFamily);
+    if (!name) return null;
+    const face = {
+        name,
+        resolved: name
+    };
+    return {
+        ascii: face,
+        highAnsi: face,
+        eastAsia: face,
+        complexScript: face,
+        hint: 'default'
+    };
+}
+function patchDocumentScriptFonts(source, patch, fallbackFontFamily) {
+    const current = normalizeDocumentScriptFonts(source) ?? documentScriptFontsForAllText(fallbackFontFamily) ?? {};
+    const next = {
+        ...current
+    };
+    if (void 0 !== patch.latin) {
+        const face = directFontFace(patch.latin);
+        if (face) {
+            next.ascii = face;
+            next.highAnsi = face;
+        } else {
+            delete next.ascii;
+            delete next.highAnsi;
+        }
+    }
+    if (void 0 !== patch.eastAsia) {
+        const face = directFontFace(patch.eastAsia);
+        if (face) next.eastAsia = face;
+        else delete next.eastAsia;
+    }
+    if (void 0 !== patch.complexScript) {
+        const face = directFontFace(patch.complexScript);
+        if (face) next.complexScript = face;
+        else delete next.complexScript;
+    }
+    return normalizeDocumentScriptFonts(next);
+}
+function documentScriptFontSegments(text, hint = 'default', forceComplexScript = false) {
+    if (!text) return [];
+    if (forceComplexScript) return [
+        {
+            from: 0,
+            to: text.length,
+            slot: 'complexScript'
+        }
+    ];
+    const characters = [];
+    let offset = 0;
+    for (const character of text){
+        const from = offset;
+        offset += character.length;
+        characters.push({
+            from,
+            to: offset,
+            slot: strongDocumentScriptFontSlot(character)
+        });
+    }
+    const fallback = documentScriptFontSlotFromHint(hint);
+    let previous = null;
+    for(let index = 0; index < characters.length; index += 1){
+        const entry = characters[index];
+        if (!entry) continue;
+        if (entry.slot) {
+            previous = entry.slot;
+            continue;
+        }
+        let next = previous;
+        if (!next) for(let cursor = index + 1; cursor < characters.length; cursor += 1){
+            const candidate = characters[cursor]?.slot;
+            if (candidate) {
+                next = candidate;
+                break;
+            }
+        }
+        entry.slot = next ?? fallback;
+    }
+    const segments = [];
+    for (const entry of characters){
+        const slot = entry.slot ?? fallback;
+        const prior = segments[segments.length - 1];
+        if (prior?.slot === slot && prior.to === entry.from) prior.to = entry.to;
+        else segments.push({
+            from: entry.from,
+            to: entry.to,
+            slot
+        });
+    }
+    return segments;
+}
+function normalizeDocumentScriptFontSlot(value) {
+    return scriptFontSlots.includes(value) ? value : null;
+}
+function normalizeDocumentScriptFontHint(value) {
+    return SCRIPT_FONT_HINTS.has(value) ? value : null;
+}
+function normalizeDocumentThemeFont(value) {
+    return THEME_FONTS.has(value) ? value : null;
+}
+function documentScriptFontSlotFromHint(hint) {
+    if ('eastAsia' === hint) return 'eastAsia';
+    if ('cs' === hint) return 'complexScript';
+    return 'ascii';
+}
+function documentFontNameFromCssFamily(value) {
+    if ('string' != typeof value) return null;
+    const source = value.trim();
+    if (!source) return null;
+    let family = '';
+    const quote = source[0];
+    if ('"' === quote || "'" === quote) {
+        let closed = false;
+        for(let index = 1; index < source.length; index += 1){
+            const character = source[index];
+            if (character === quote) {
+                closed = true;
+                break;
+            }
+            if ('\\' !== character) {
+                family += character;
+                continue;
+            }
+            const decoded = decodeCssEscape(source, index + 1);
+            if (!decoded) return null;
+            family += decoded.value;
+            index = decoded.end - 1;
+        }
+        if (!closed) return null;
+    } else family = source.split(',')[0] ?? '';
+    return normalizeDocumentFontName(family);
+}
+function cssDocumentFontFamily(value) {
+    const family = normalizeDocumentFontName(value);
+    return family ? cssFontFamily(family) : null;
+}
+function normalizeDocumentFontName(value) {
+    if ('string' != typeof value) return null;
+    const normalized = value.trim();
+    return normalized && normalized.length <= MAX_FONT_NAME_LENGTH && !/[\p{Cc}\p{Cs}]/u.test(normalized) ? normalized : null;
+}
+const scriptFontSlots = [
+    'ascii',
+    'highAnsi',
+    'eastAsia',
+    'complexScript'
+];
+function normalizeDocumentScriptFontFace(source) {
+    if (!work_document_script_fonts_isRecordWithKeys(source, SCRIPT_FONT_FACE_KEYS)) return null;
+    const name = void 0 === source.name ? void 0 : normalizeDocumentFontName(source.name);
+    const resolved = void 0 === source.resolved ? void 0 : normalizeDocumentFontName(source.resolved);
+    const theme = void 0 === source.theme ? void 0 : normalizeDocumentThemeFont(source.theme);
+    if (void 0 !== source.name && !name || void 0 !== source.resolved && !resolved || null === theme || !name && !theme && !resolved) return null;
+    return {
+        ...name ? {
+            name
+        } : {},
+        ...theme ? {
+            theme
+        } : {},
+        ...resolved ? {
+            resolved
+        } : {}
+    };
+}
+function directFontFace(value) {
+    if (null === value) return null;
+    const name = documentFontNameFromCssFamily(value) ?? normalizeDocumentFontName(value);
+    return name ? {
+        name,
+        resolved: name
+    } : null;
+}
+function documentScriptFontFaceFamily(face) {
+    return face?.resolved ?? face?.name;
+}
+function strongDocumentScriptFontSlot(character) {
+    if (NEUTRAL_SCRIPT_CHARACTER.test(character)) return null;
+    const codePoint = character.codePointAt(0);
+    if (void 0 === codePoint) return null;
+    if (isComplexScriptCodePoint(codePoint)) return 'complexScript';
+    if (isEastAsianCodePoint(codePoint)) return 'eastAsia';
+    return codePoint <= 0x7f ? 'ascii' : 'highAnsi';
+}
+function isComplexScriptCodePoint(codePoint) {
+    return codePoint >= 0x0590 && codePoint <= 0x08ff || codePoint >= 0x0900 && codePoint <= 0x109f || codePoint >= 0x1780 && codePoint <= 0x18af || codePoint >= 0x1900 && codePoint <= 0x1cff || codePoint >= 0xa800 && codePoint <= 0xa8ff || codePoint >= 0xa980 && codePoint <= 0xa9df || codePoint >= 0xaa00 && codePoint <= 0xaa7f || codePoint >= 0xabc0 && codePoint <= 0xabff || codePoint >= 0xfb1d && codePoint <= 0xfdff || codePoint >= 0xfe70 && codePoint <= 0xfeff || codePoint >= 0x10a00 && codePoint <= 0x10fff || codePoint >= 0x11000 && codePoint <= 0x11fff || codePoint >= 0x1e900 && codePoint <= 0x1edff || codePoint >= 0x1ee00 && codePoint <= 0x1eeff;
+}
+function isEastAsianCodePoint(codePoint) {
+    return codePoint >= 0x1100 && codePoint <= 0x11ff || codePoint >= 0x2e80 && codePoint <= 0xa4cf || codePoint >= 0xac00 && codePoint <= 0xd7af || codePoint >= 0xf900 && codePoint <= 0xfaff || codePoint >= 0xfe10 && codePoint <= 0xfe6f || codePoint >= 0xff00 && codePoint <= 0xffef || codePoint >= 0x20000 && codePoint <= 0x323af;
+}
+function cssFontFamily(value) {
+    return /^(?:-?[\p{L}_])[\p{L}\p{N}_-]*$/u.test(value) ? value : `"${Array.from(value, cssStringCharacter).join('')}"`;
+}
+function cssStringCharacter(character) {
+    return /[\\":;{}<>]/u.test(character) ? `\\${character.codePointAt(0)?.toString(16)} ` : character;
+}
+function safeCssFontFamilyList(value) {
+    if ('string' != typeof value) return null;
+    const source = value.trim();
+    if (!source || source.length > 1024 || /[;{}]/u.test(source)) return null;
+    const tokens = [];
+    let start = 0;
+    let quote = '';
+    for(let index = 0; index < source.length; index += 1){
+        const character = source[index] ?? '';
+        if (quote) {
+            if ('\\' === character) {
+                index += 1;
+                if (index >= source.length) return null;
+            } else if (character === quote) quote = '';
+            continue;
+        }
+        if ('"' === character || "'" === character) {
+            quote = character;
+            continue;
+        }
+        if (',' === character) {
+            tokens.push(source.slice(start, index).trim());
+            start = index + 1;
+        }
+    }
+    if (quote) return null;
+    tokens.push(source.slice(start).trim());
+    return tokens.length && tokens.every(validCssFontFamilyToken) ? source : null;
+}
+function validCssFontFamilyToken(value) {
+    if (!value) return false;
+    if (value.startsWith('"')) return /^"(?:[^"\\\r\n\f]|\\(?:[\da-f]{1,6}\s?|[^\r\n\f]))*"$/iu.test(value) && null !== documentFontNameFromCssFamily(value);
+    if (value.startsWith("'")) return /^'(?:[^'\\\r\n\f]|\\(?:[\da-f]{1,6}\s?|[^\r\n\f]))*'$/iu.test(value) && null !== documentFontNameFromCssFamily(value);
+    return /[\p{L}_]/u.test(value) && /^[\p{L}_-][\p{L}\p{N}_ -]*$/u.test(value) && !/^(?:inherit|initial|revert(?:-layer)?|unset)$/iu.test(value);
+}
+function decodeCssEscape(source, start) {
+    if (start >= source.length) return null;
+    const hexadecimal = /^[\da-f]{1,6}/i.exec(source.slice(start))?.[0];
+    if (hexadecimal) {
+        const codePoint = Number.parseInt(hexadecimal, 16);
+        if (0 === codePoint || codePoint > 0x10ffff || codePoint >= 0xd800 && codePoint <= 0xdfff) return null;
+        let end = start + hexadecimal.length;
+        if (/\s/u.test(source[end] ?? '')) end += 1;
+        return {
+            value: String.fromCodePoint(codePoint),
+            end
+        };
+    }
+    const value = source[start];
+    return !value || /[\r\n\f]/u.test(value) ? null : {
+        value,
+        end: start + 1
+    };
+}
+function work_document_script_fonts_isRecordWithKeys(value, allowed) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value) && Object.keys(value).every((key)=>allowed.has(key));
+}
+const DOCUMENT_PROOFING_LANGUAGES_ATTRIBUTE = 'data-office-proofing-languages';
+const DOCUMENT_NO_PROOF_ATTRIBUTE = 'data-office-no-proof';
+const PROOFING_LANGUAGE_KEYS = new Set([
+    'latin',
+    'eastAsia',
+    'bidi'
+]);
+const PROOFING_LANGUAGE_ORDER = [
+    'latin',
+    'eastAsia',
+    'bidi'
+];
+const MAX_LANGUAGE_TAG_LENGTH = 85;
+const MAX_SERIALIZED_PROOFING_LANGUAGES_BYTES = 384;
+function normalizeDocumentLanguageTag(source) {
+    if ('string' != typeof source) return null;
+    if (!source || source !== source.trim() || source.length > MAX_LANGUAGE_TAG_LENGTH || /[\p{Cc}\p{Cs}]/u.test(source)) return null;
+    return /^(?:x-none|[a-z0-9]{1,8}(?:-[a-z0-9]{1,8})*)$/iu.test(source) ? source : null;
+}
+function normalizeDocumentProofingLanguages(source) {
+    if (!isRecord(source)) return null;
+    const keys = Object.keys(source);
+    if (!keys.length || keys.some((key)=>!PROOFING_LANGUAGE_KEYS.has(key))) return null;
+    const normalized = {};
+    for (const key of PROOFING_LANGUAGE_ORDER){
+        if (void 0 === source[key]) continue;
+        const language = normalizeDocumentLanguageTag(source[key]);
+        if (!language) return null;
+        normalized[key] = language;
+    }
+    return Object.keys(normalized).length ? normalized : null;
+}
+function serializeDocumentProofingLanguages(source) {
+    const normalized = normalizeDocumentProofingLanguages(source);
+    if (!normalized) return;
+    const serialized = JSON.stringify(normalized);
+    return serialized.length <= MAX_SERIALIZED_PROOFING_LANGUAGES_BYTES ? serialized : void 0;
+}
+function parseDocumentProofingLanguages(source) {
+    if ('string' != typeof source) return normalizeDocumentProofingLanguages(source);
+    if (!source || source.length > MAX_SERIALIZED_PROOFING_LANGUAGES_BYTES) return null;
+    try {
+        const normalized = normalizeDocumentProofingLanguages(JSON.parse(source));
+        return normalized && JSON.stringify(normalized) === source ? normalized : null;
+    } catch  {
+        return null;
+    }
+}
+function normalizeDocumentNoProof(source) {
+    if (true === source || 'true' === source || '1' === source) return true;
+    if (false === source || 'false' === source || '0' === source) return false;
+    return null;
+}
+function documentProofingLanguagesFromElement(element) {
+    return parseDocumentProofingLanguages(element.getAttribute(DOCUMENT_PROOFING_LANGUAGES_ATTRIBUTE));
+}
+function documentNoProofFromElement(element) {
+    return normalizeDocumentNoProof(element.getAttribute(DOCUMENT_NO_PROOF_ATTRIBUTE));
+}
+function documentProofingLanguageForScript(source, slot) {
+    const languages = normalizeDocumentProofingLanguages(source);
+    if (!languages) return;
+    if ('eastAsia' === slot) return languages.eastAsia ?? languages.latin;
+    if ('complexScript' === slot) return languages.bidi ?? languages.latin;
+    return languages.latin ?? languages.eastAsia ?? languages.bidi;
+}
+function documentProofingDomAttributes(languagesSource, noProofSource, slot) {
+    const languages = normalizeDocumentProofingLanguages(languagesSource);
+    const serialized = serializeDocumentProofingLanguages(languages);
+    const noProof = normalizeDocumentNoProof(noProofSource);
+    const language = documentProofingLanguageForScript(languages, slot);
+    return {
+        ...serialized ? {
+            [DOCUMENT_PROOFING_LANGUAGES_ATTRIBUTE]: serialized
+        } : {},
+        ...null === noProof ? {} : {
+            [DOCUMENT_NO_PROOF_ATTRIBUTE]: String(noProof)
+        },
+        ...slot ? {
+            [DOCUMENT_SCRIPT_FONT_SLOT_ATTRIBUTE]: slot
+        } : {},
+        ...language && 'x-none' !== language ? {
+            lang: language
+        } : {},
+        ...true === noProof ? {
+            spellcheck: 'false'
+        } : {}
+    };
+}
+function patchDocumentProofingLanguages(source, patch) {
+    const current = normalizeDocumentProofingLanguages(source) ?? {};
+    const next = {
+        ...current
+    };
+    for (const slot of PROOFING_LANGUAGE_ORDER){
+        const value = patch[slot];
+        if (void 0 === value) continue;
+        if (null === value) {
+            delete next[slot];
+            continue;
+        }
+        const language = normalizeDocumentLanguageTag(value);
+        if (!language) return null;
+        next[slot] = language;
+    }
+    return Object.keys(next).length ? next : null;
+}
+function isRecord(source) {
+    return 'object' == typeof source && null !== source && !Array.isArray(source);
+}
+const DOCUMENT_PARAGRAPH_ID_ATTRIBUTE = 'data-office-paragraph-id';
+const DOCUMENT_PARAGRAPH_TEXT_ID_ATTRIBUTE = 'data-office-paragraph-text-id';
+const PARAGRAPH_ID_PATTERN = /^[0-9A-F]{8}$/;
+const MAX_PARAGRAPH_ID = 0x7fffffff;
+let fallbackIdentitySequence = 0;
+const DocumentParagraphIdentity = Extension.create({
+    name: 'documentParagraphIdentity',
+    addOptions () {
+        return {
+            rotateTextId: ()=>true,
+            types: [
+                'paragraph',
+                'heading',
+                'documentCaption'
+            ]
+        };
+    },
+    addGlobalAttributes () {
+        return [
+            {
+                types: this.options.types,
+                attributes: {
+                    paragraphId: {
+                        default: null,
+                        parseHTML: (element)=>normalizeDocumentParagraphId(element.getAttribute(DOCUMENT_PARAGRAPH_ID_ATTRIBUTE)),
+                        renderHTML: (attributes)=>{
+                            const value = normalizeDocumentParagraphId(attributes.paragraphId);
+                            return value ? {
+                                [DOCUMENT_PARAGRAPH_ID_ATTRIBUTE]: value
+                            } : {};
+                        }
+                    },
+                    textId: {
+                        default: null,
+                        parseHTML: (element)=>normalizeDocumentParagraphId(element.getAttribute(DOCUMENT_PARAGRAPH_TEXT_ID_ATTRIBUTE)),
+                        renderHTML: (attributes)=>{
+                            const value = normalizeDocumentParagraphId(attributes.textId);
+                            return value ? {
+                                [DOCUMENT_PARAGRAPH_TEXT_ID_ATTRIBUTE]: value
+                            } : {};
+                        }
+                    }
+                }
+            }
+        ];
+    },
+    addProseMirrorPlugins () {
+        return [
+            createDocumentParagraphIdentityPlugin(this.options.types, this.options.rotateTextId)
+        ];
+    }
+});
+function normalizeDocumentParagraphId(value) {
+    if ('string' != typeof value) return null;
+    const normalized = value.trim().toUpperCase();
+    if (!PARAGRAPH_ID_PATTERN.test(normalized)) return null;
+    const number = Number.parseInt(normalized, 16);
+    return number > 0 && number <= MAX_PARAGRAPH_ID ? normalized : null;
+}
+function createDocumentParagraphIdentityRegistry() {
+    return {
+        paragraphIds: new Set()
+    };
+}
+function normalizeDocumentParagraphIdentity(source) {
+    const paragraphId = normalizeDocumentParagraphId(source.paragraphId);
+    const textId = normalizeDocumentParagraphId(source.textId);
+    return paragraphId && textId ? {
+        paragraphId,
+        textId
+    } : null;
+}
+function documentParagraphIdentityFromElement(element) {
+    return normalizeDocumentParagraphIdentity({
+        paragraphId: element.getAttribute(DOCUMENT_PARAGRAPH_ID_ATTRIBUTE),
+        textId: element.getAttribute(DOCUMENT_PARAGRAPH_TEXT_ID_ATTRIBUTE)
+    });
+}
+function applyDocumentParagraphIdentityToElement(element, source) {
+    const identity = normalizeDocumentParagraphIdentity(source);
+    if (!identity) {
+        element.removeAttribute(DOCUMENT_PARAGRAPH_ID_ATTRIBUTE);
+        element.removeAttribute(DOCUMENT_PARAGRAPH_TEXT_ID_ATTRIBUTE);
+        return null;
+    }
+    element.setAttribute(DOCUMENT_PARAGRAPH_ID_ATTRIBUTE, identity.paragraphId);
+    element.setAttribute(DOCUMENT_PARAGRAPH_TEXT_ID_ATTRIBUTE, identity.textId);
+    return identity;
+}
+function createDocumentParagraphIdentityPlugin(types, rotateTextId) {
+    const trackedTypes = new Set(types);
+    return new Plugin({
+        view (view) {
+            const transaction = normalizeDocumentParagraphIdentities(view.state, trackedTypes, rotateTextId);
+            if (transaction) {
+                transaction.setMeta('addToHistory', false);
+                view.dispatch(transaction);
+            }
+            return {};
+        },
+        appendTransaction (transactions, oldState, newState) {
+            if (!transactions.some((transaction)=>transaction.docChanged)) return null;
+            return normalizeDocumentParagraphIdentities(newState, trackedTypes, rotateTextId, oldState, transactions);
+        }
+    });
+}
+function normalizeDocumentParagraphIdentities(state, trackedTypes, rotateTextId, oldState, transactions = []) {
+    if (!documentHasIntegrityFeature(state.doc, 16)) return null;
+    const paragraphs = documentParagraphs(state.doc, trackedTypes);
+    if (!paragraphs.length) return null;
+    const retainedPositions = oldState ? retainedDocumentParagraphPositions(oldState, state, transactions, trackedTypes) : new Set();
+    const editedPositions = oldState && rotateTextId() && !transactions.some(isHistoryTransaction) ? editedDocumentParagraphPositions(oldState, state, transactions, trackedTypes) : new Set();
+    const ordered = [
+        ...paragraphs.filter((item)=>retainedPositions.has(item.position)),
+        ...paragraphs.filter((item)=>!retainedPositions.has(item.position))
+    ];
+    const registry = createDocumentParagraphIdentityRegistry();
+    const updates = new Map();
+    for (const paragraph of ordered){
+        const current = paragraphIdentitySourceFromNode(paragraph.node);
+        const source = editedPositions.has(paragraph.position) ? {
+            ...current,
+            textId: nextDocumentParagraphTextId(current.textId)
+        } : current;
+        const identity = uniqueDocumentParagraphIdentity(source, registry);
+        if (!sameDocumentParagraphIdentity(current, identity)) updates.set(paragraph.position, identity);
+    }
+    if (!updates.size) return null;
+    const transaction = state.tr;
+    for (const paragraph of paragraphs){
+        const identity = updates.get(paragraph.position);
+        if (identity) transaction.setNodeMarkup(paragraph.position, void 0, {
+            ...paragraph.node.attrs,
+            ...identity
+        });
+    }
+    if (!transaction.docChanged) return null;
+    transaction.setMeta('addToHistory', false);
+    return transaction;
+}
+function hasDocumentParagraphIdentityComponent(node) {
+    return Boolean(normalizeDocumentParagraphId(node.attrs.paragraphId) || normalizeDocumentParagraphId(node.attrs.textId));
+}
+function retainedDocumentParagraphPositions(oldState, newState, transactions, trackedTypes) {
+    const mapping = transactionMapping(transactions);
+    const retained = new Set();
+    for (const previous of documentParagraphs(oldState.doc, trackedTypes)){
+        const paragraphId = normalizeDocumentParagraphId(previous.node.attrs.paragraphId);
+        if (!paragraphId) continue;
+        const mapped = mapping.mapResult(previous.position, 1);
+        const current = newState.doc.nodeAt(mapped.pos);
+        if (current && trackedTypes.has(current.type.name) && normalizeDocumentParagraphId(current.attrs.paragraphId) === paragraphId) retained.add(mapped.pos);
+    }
+    return retained;
+}
+function editedDocumentParagraphPositions(oldState, newState, transactions, trackedTypes) {
+    const mapping = transactionMapping(transactions);
+    const previousParagraphs = documentParagraphs(oldState.doc, trackedTypes);
+    const currentParagraphs = documentParagraphs(newState.doc, trackedTypes);
+    const previousById = paragraphsById(previousParagraphs);
+    const currentById = paragraphsById(currentParagraphs);
+    const edited = new Set();
+    for (const previous of previousParagraphs){
+        const identity = normalizeDocumentParagraphIdentity(paragraphIdentitySourceFromNode(previous.node));
+        if (!identity) continue;
+        const mapped = mapping.mapResult(previous.position, 1);
+        const current = newState.doc.nodeAt(mapped.pos);
+        if (current && trackedTypes.has(current.type.name) && normalizeDocumentParagraphId(current.attrs.paragraphId) === identity.paragraphId) {
+            if (paragraphTextChanged(previous.node, current, identity.textId)) edited.add(mapped.pos);
+            continue;
+        }
+        const previousMatches = previousById.get(identity.paragraphId) ?? [];
+        const currentMatches = currentById.get(identity.paragraphId) ?? [];
+        if (1 === previousMatches.length && 1 === currentMatches.length && paragraphTextChanged(previous.node, currentMatches[0].node, identity.textId)) edited.add(currentMatches[0].position);
+    }
+    return edited;
+}
+function paragraphTextChanged(previous, current, previousTextId) {
+    return previous.textContent !== current.textContent && normalizeDocumentParagraphId(current.attrs.textId) === previousTextId;
+}
+function paragraphsById(paragraphs) {
+    const result = new Map();
+    for (const paragraph of paragraphs){
+        const id = normalizeDocumentParagraphId(paragraph.node.attrs.paragraphId);
+        if (!id) continue;
+        const matches = result.get(id) ?? [];
+        matches.push(paragraph);
+        result.set(id, matches);
+    }
+    return result;
+}
+function documentParagraphs(document, trackedTypes) {
+    const paragraphs = [];
+    document.descendants((node, position)=>{
+        if (trackedTypes.has(node.type.name) && hasDocumentParagraphIdentityComponent(node)) paragraphs.push({
+            node,
+            position
+        });
+    });
+    return paragraphs;
+}
+function paragraphIdentitySourceFromNode(node) {
+    return {
+        paragraphId: node.attrs.paragraphId,
+        textId: node.attrs.textId
+    };
+}
+function uniqueDocumentParagraphIdentity(source, registry) {
+    const preferred = normalizeDocumentParagraphIdentity(source);
+    if (preferred && !registry.paragraphIds.has(preferred.paragraphId)) {
+        registry.paragraphIds.add(preferred.paragraphId);
+        return preferred;
+    }
+    for(let attempt = 0; attempt < 8; attempt += 1){
+        const identity = createDocumentParagraphIdentity();
+        if (!registry.paragraphIds.has(identity.paragraphId)) {
+            registry.paragraphIds.add(identity.paragraphId);
+            return identity;
+        }
+    }
+    return sequentialDocumentParagraphIdentity(registry);
+}
+function createDocumentParagraphIdentity() {
+    return {
+        paragraphId: randomDocumentParagraphId(),
+        textId: randomDocumentParagraphId()
+    };
+}
+function sequentialDocumentParagraphIdentity(registry) {
+    for(let value = 1; value <= MAX_PARAGRAPH_ID; value += 1){
+        const paragraphId = formatDocumentParagraphId(value);
+        if (!registry.paragraphIds.has(paragraphId)) {
+            registry.paragraphIds.add(paragraphId);
+            return {
+                paragraphId,
+                textId: randomDocumentParagraphId()
+            };
+        }
+    }
+    throw new Error('No unique Word paragraph identity is available.');
+}
+function nextDocumentParagraphTextId(value) {
+    const current = normalizeDocumentParagraphId(value);
+    if (!current) return randomDocumentParagraphId();
+    const number = Number.parseInt(current, 16);
+    return formatDocumentParagraphId(number >= MAX_PARAGRAPH_ID ? 1 : number + 1);
+}
+function randomDocumentParagraphId() {
+    let value = 0;
+    const cryptoApi = globalThis.crypto;
+    if ('function' == typeof cryptoApi?.getRandomValues) {
+        const values = new Uint32Array(1);
+        cryptoApi.getRandomValues(values);
+        value = values[0] ?? 0;
+    } else if ('function' == typeof cryptoApi?.randomUUID) value = Number.parseInt(cryptoApi.randomUUID().replaceAll('-', '').slice(0, 8), 16);
+    if (!value) {
+        fallbackIdentitySequence += 1;
+        value = stableIdentityHash(`${Date.now()}:${Math.random()}:${fallbackIdentitySequence}`);
+    }
+    return formatDocumentParagraphId(value || fallbackIdentitySequence || 1);
+}
+function stableIdentityHash(value) {
+    let hash = 0x811c9dc5;
+    for(let index = 0; index < value.length; index += 1){
+        hash ^= value.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return hash >>> 0 || 1;
+}
+function formatDocumentParagraphId(value) {
+    return (value >>> 0 & MAX_PARAGRAPH_ID || 1).toString(16).toUpperCase().padStart(8, '0');
+}
+function sameDocumentParagraphIdentity(source, identity) {
+    return normalizeDocumentParagraphId(source.paragraphId) === identity.paragraphId && normalizeDocumentParagraphId(source.textId) === identity.textId;
+}
+function transactionMapping(transactions) {
+    const mapping = new Mapping();
+    for (const transaction of transactions)mapping.appendMapping(transaction.mapping);
+    return mapping;
+}
+function collectWorkDocumentOutline(document) {
+    const items = [];
+    const hierarchy = [];
+    document.descendants((node, position)=>{
+        const level = workDocumentOutlineLevel(node);
+        if (null === level) return;
+        while((hierarchy.at(-1)?.level ?? 0) >= level)hierarchy.pop();
+        const parent = hierarchy.at(-1);
+        const from = position + 1;
+        const paragraphId = normalizeDocumentParagraphId(node.attrs.paragraphId);
+        const item = {
+            id: paragraphId ? `heading-${paragraphId.toLowerCase()}` : `heading-${position}`,
+            text: normalizedDocumentHeadingText(node.textContent),
+            level,
+            depth: hierarchy.length,
+            from,
+            to: from + node.content.size,
+            ...parent ? {
+                parentId: parent.id
+            } : {}
+        };
+        items.push(item);
+        hierarchy.push(item);
+    });
+    return items.map((item, index)=>({
+            ...item,
+            hasChildren: (items[index + 1]?.depth ?? -1) > item.depth
+        }));
+}
+function workDocumentOutlineLevel(node) {
+    if ('heading' === node.type.name) return documentHeadingLevel(node.attrs.level);
+    if ('paragraph' !== node.type.name) return null;
+    const value = node.attrs.outlineLevel;
+    if (null == value || '' === value) return null;
+    const outlineLevel = Number(value);
+    return Number.isInteger(outlineLevel) && outlineLevel >= 0 && outlineLevel <= 8 ? outlineLevel + 1 : null;
+}
+function currentWorkDocumentOutlineItem(items, position) {
+    let current = null;
+    for (const item of items){
+        if (item.from > position) break;
+        current = item;
+    }
+    return current;
+}
+function visibleWorkDocumentOutlineItems(items, collapsedIds, rawQuery) {
+    const query = normalizedDocumentOutlineQuery(rawQuery);
+    if (query) return items.filter((item)=>normalizedDocumentOutlineQuery(item.text).includes(query));
+    const visible = [];
+    let hiddenBelowDepth = null;
+    for (const item of items){
+        if (null !== hiddenBelowDepth && item.depth <= hiddenBelowDepth) hiddenBelowDepth = null;
+        if (null === hiddenBelowDepth) {
+            visible.push(item);
+            if (item.hasChildren && collapsedIds.has(item.id)) hiddenBelowDepth = item.depth;
+        }
+    }
+    return visible;
+}
+function documentHeadingLevel(value) {
+    return 'number' == typeof value && Number.isInteger(value) && value >= 1 && value <= 6 ? value : 1;
+}
+function normalizedDocumentHeadingText(value) {
+    return value.replace(/\s+/g, ' ').trim() || '未命名标题';
+}
+function normalizedDocumentOutlineQuery(value) {
+    return value.normalize('NFKC').trim().toLocaleLowerCase();
+}
+const DEFAULT_DOCUMENT_TABLE_OF_CONTENTS_OPTIONS = {
+    minLevel: 1,
+    maxLevel: 3,
+    hyperlinks: true,
+    showPageNumbers: true,
+    rightAlignPageNumbers: true,
+    leader: 'dot'
+};
+const MAX_DOCUMENT_TABLE_OF_CONTENTS_ENTRIES = 512;
+const TABLE_OF_CONTENTS_SELECTOR = '[data-document-table-of-contents]';
+const MAX_TABLE_OF_CONTENTS_TITLE_LENGTH = 512;
+const TABLE_OF_CONTENTS_ID_PATTERN = /^[a-z0-9][a-z0-9._:-]{0,127}$/i;
+const TABLE_OF_CONTENTS_TARGET_PATTERN = /^heading-[a-z0-9._:-]{1,128}$/i;
+function normalizeDocumentTableOfContentsOptions(source) {
+    const minLevel = boundedLevel(source?.minLevel, 1);
+    const maxLevel = Math.max(minLevel, boundedLevel(source?.maxLevel, Math.max(3, minLevel)));
+    const showPageNumbers = source?.showPageNumbers !== false;
+    return {
+        minLevel,
+        maxLevel,
+        hyperlinks: source?.hyperlinks !== false,
+        showPageNumbers,
+        rightAlignPageNumbers: showPageNumbers && source?.rightAlignPageNumbers !== false,
+        leader: tableOfContentsLeader(source?.leader) ?? 'dot'
+    };
+}
+function buildDocumentTableOfContentsEntries(document, options, buildOptions = {}) {
+    const normalized = normalizeDocumentTableOfContentsOptions(options);
+    const outline = collectWorkDocumentOutline(document).filter((item)=>item.text.length > 0 && item.level >= normalized.minLevel && item.level <= normalized.maxLevel);
+    const entries = outline.slice(0, MAX_DOCUMENT_TABLE_OF_CONTENTS_ENTRIES).map((item)=>tableOfContentsEntryFromOutline(document, item, buildOptions.resolveContext));
+    return {
+        entries,
+        truncated: outline.length > MAX_DOCUMENT_TABLE_OF_CONTENTS_ENTRIES
+    };
+}
+function documentTableOfContentsHtml(source) {
+    const value = normalizeDocumentTableOfContentsValue(source);
+    const options = value.options;
+    const rows = value.entries.length ? value.entries.map((entry)=>tableOfContentsEntryHtml(entry, options)) : [
+        '<li class="work-document-table-of-contents-empty">没有符合级别范围的标题</li>'
+    ];
+    const status = value.truncated ? `仅显示前 ${MAX_DOCUMENT_TABLE_OF_CONTENTS_ENTRIES} 项` : `${value.entries.length} 项`;
+    return [
+        `<div data-document-table-of-contents="true" data-toc-id="${escapeHtmlAttribute(value.id)}" data-toc-min-level="${options.minLevel}" data-toc-max-level="${options.maxLevel}" data-toc-hyperlinks="${String(options.hyperlinks)}" data-toc-show-page-numbers="${String(options.showPageNumbers)}" data-toc-right-align-page-numbers="${String(options.rightAlignPageNumbers)}" data-toc-leader="${options.leader}" data-toc-entries="${escapeHtmlAttribute(JSON.stringify(value.entries))}" data-toc-truncated="${String(value.truncated)}" class="work-document-table-of-contents" contenteditable="false" aria-label="目录">`,
+        '<div class="work-document-table-of-contents-header"><strong>目录</strong>',
+        `<span>${status}</span></div>`,
+        '<ol class="work-document-table-of-contents-list">',
+        ...rows,
+        '</ol></div>'
+    ].join('');
+}
+function normalizeDocumentTableOfContentsHtml(source) {
+    const document = new DOMParser().parseFromString(source, 'text/html');
+    const usedIds = new Set();
+    for (const [index, element] of Array.from(document.body.querySelectorAll(TABLE_OF_CONTENTS_SELECTOR)).entries()){
+        const value = documentTableOfContentsValueFromElement(element, index + 1);
+        value.id = uniqueTableOfContentsId(value.id, index + 1, usedIds);
+        const replacement = document.createRange().createContextualFragment(documentTableOfContentsHtml(value));
+        element.replaceWith(replacement);
+    }
+    return document.body.innerHTML;
+}
+function documentTableOfContentsValueFromElement(element, index = 1) {
+    const entries = parseTableOfContentsEntries(element.dataset.tocEntries);
+    return normalizeDocumentTableOfContentsValue({
+        id: validTableOfContentsId(element.dataset.tocId) ?? `toc-${index}`,
+        options: {
+            minLevel: Number(element.dataset.tocMinLevel),
+            maxLevel: Number(element.dataset.tocMaxLevel),
+            hyperlinks: 'false' !== element.dataset.tocHyperlinks,
+            showPageNumbers: 'false' !== element.dataset.tocShowPageNumbers,
+            rightAlignPageNumbers: 'false' !== element.dataset.tocRightAlignPageNumbers,
+            leader: tableOfContentsLeader(element.dataset.tocLeader) ?? 'dot'
+        },
+        entries,
+        truncated: 'true' === element.dataset.tocTruncated
+    });
+}
+function parseDocumentTableOfContentsInstruction(instruction) {
+    const command = /^\s*TOC\b/i.exec(instruction);
+    if (!command) return {
+        supported: false,
+        reason: 'not-table-of-contents'
+    };
+    const source = instruction.slice(command[0].length);
+    const switches = new Map();
+    const matcher = /\\([a-z])(?:\s+("([^"]*)"|([^\\\s]+)))?/gi;
+    let cursor = 0;
+    for(let match = matcher.exec(source); match; match = matcher.exec(source)){
+        if (source.slice(cursor, match.index).trim()) return {
+            supported: false,
+            reason: 'invalid-instruction'
+        };
+        const name = match[1]?.toLowerCase() ?? '';
+        if (!name || switches.has(name)) return {
+            supported: false,
+            reason: 'invalid-instruction'
+        };
+        switches.set(name, match[3] ?? match[4] ?? null);
+        cursor = matcher.lastIndex;
+    }
+    if (source.slice(cursor).trim()) return {
+        supported: false,
+        reason: 'invalid-instruction'
+    };
+    for (const name of switches.keys())if (![
+        'o',
+        'h',
+        'z',
+        'u',
+        'n',
+        'p'
+    ].includes(name)) return {
+        supported: false,
+        reason: 'unsupported-switch'
+    };
+    const range = switches.has('o') ? parseTableOfContentsRange(switches.get('o')) : {
+        minLevel: 1,
+        maxLevel: 3
+    };
+    if (!range) return {
+        supported: false,
+        reason: 'invalid-level-range'
+    };
+    const pageRange = switches.has('n') ? parseOptionalTableOfContentsRange(switches.get('n')) : null;
+    if (switches.has('n') && void 0 === pageRange) return {
+        supported: false,
+        reason: 'invalid-level-range'
+    };
+    if (pageRange && (pageRange.minLevel !== range.minLevel || pageRange.maxLevel !== range.maxLevel)) return {
+        supported: false,
+        reason: 'unsupported-page-range'
+    };
+    const separator = switches.get('p');
+    if (switches.has('p') && (null == separator || separator.trim())) return {
+        supported: false,
+        reason: 'unsupported-separator'
+    };
+    const showPageNumbers = !switches.has('n');
+    const rightAlignPageNumbers = showPageNumbers && !switches.has('p');
+    return {
+        supported: true,
+        options: {
+            ...range,
+            hyperlinks: switches.has('h'),
+            showPageNumbers,
+            rightAlignPageNumbers,
+            leader: rightAlignPageNumbers ? 'dot' : 'none'
+        }
+    };
+}
+function tableOfContentsLeader(value) {
+    return 'dot' === value || 'dash' === value || 'underline' === value || 'none' === value ? value : null;
+}
+function normalizeDocumentTableOfContentsValue(source) {
+    return {
+        id: validTableOfContentsId(source.id) ?? 'document-table-of-contents',
+        options: normalizeDocumentTableOfContentsOptions(source.options),
+        entries: normalizeTableOfContentsEntries(source.entries),
+        truncated: Boolean(source.truncated)
+    };
+}
+function tableOfContentsEntryFromOutline(document, item, resolveContext) {
+    return {
+        targetId: item.id,
+        title: item.text.slice(0, MAX_TABLE_OF_CONTENTS_TITLE_LENGTH),
+        level: item.level,
+        pageNumber: positiveInteger(resolveContext?.(item.from)?.pageNumber) ?? fallbackDocumentPageNumber(document, item.from)
+    };
+}
+function fallbackDocumentPageNumber(document, position) {
+    let pageNumber = 1;
+    document.descendants((node, offset)=>{
+        if (offset >= position) return false;
+        if ('pageBreak' === node.type.name) pageNumber += 1;
+        return true;
+    });
+    return pageNumber;
+}
+function tableOfContentsEntryHtml(entry, options) {
+    const title = escapeHtml(entry.title);
+    const targetId = escapeHtmlAttribute(entry.targetId);
+    const label = options.hyperlinks ? `<a href="#${targetId}" data-toc-target="${targetId}" tabindex="-1">${title}</a>` : `<span>${title}</span>`;
+    const page = options.showPageNumbers ? `<span class="work-document-table-of-contents-page">${entry.pageNumber}</span>` : '';
+    return `<li data-toc-target="${targetId}" data-toc-level="${entry.level}" style="--work-toc-level:${entry.level}">${label}<i aria-hidden="true"></i>${page}</li>`;
+}
+function parseTableOfContentsEntries(source) {
+    if (!source) return [];
+    try {
+        const parsed = JSON.parse(source);
+        return Array.isArray(parsed) ? normalizeTableOfContentsEntries(parsed) : [];
+    } catch  {
+        return [];
+    }
+}
+function normalizeTableOfContentsEntries(source) {
+    const entries = [];
+    for (const value of source.slice(0, MAX_DOCUMENT_TABLE_OF_CONTENTS_ENTRIES)){
+        if (!value || 'object' != typeof value) continue;
+        const candidate = value;
+        const targetId = 'string' == typeof candidate.targetId ? candidate.targetId.trim() : '';
+        const title = 'string' == typeof candidate.title ? candidate.title.replace(/\s+/g, ' ').trim() : '';
+        const level = boundedLevel(candidate.level, 0);
+        const pageNumber = positiveInteger(candidate.pageNumber);
+        if (TABLE_OF_CONTENTS_TARGET_PATTERN.test(targetId) && title && level && pageNumber) entries.push({
+            targetId,
+            title: title.slice(0, MAX_TABLE_OF_CONTENTS_TITLE_LENGTH),
+            level,
+            pageNumber
+        });
+    }
+    return entries;
+}
+function parseTableOfContentsRange(value) {
+    if (null == value) return null;
+    const match = /^([1-9])-([1-9])$/.exec(value.trim());
+    if (!match) return null;
+    const minLevel = Number(match[1]);
+    const maxLevel = Number(match[2]);
+    return minLevel <= maxLevel ? {
+        minLevel,
+        maxLevel
+    } : null;
+}
+function parseOptionalTableOfContentsRange(value) {
+    if (null === value) return null;
+    return parseTableOfContentsRange(value) ?? void 0;
+}
+function boundedLevel(value, fallback) {
+    const number = Number(value);
+    return Number.isInteger(number) && number >= 1 && number <= 9 ? number : fallback;
+}
+function positiveInteger(value) {
+    const number = Number(value);
+    return Number.isSafeInteger(number) && number > 0 ? Math.min(999999, number) : null;
+}
+function validTableOfContentsId(value) {
+    return 'string' == typeof value && TABLE_OF_CONTENTS_ID_PATTERN.test(value) ? value : null;
+}
+function uniqueTableOfContentsId(source, index, usedIds) {
+    if (!usedIds.has(source)) {
+        usedIds.add(source);
+        return source;
+    }
+    let suffix = index;
+    while(usedIds.has(`document-table-of-contents-${suffix}`))suffix += 1;
+    const id = `document-table-of-contents-${suffix}`;
+    usedIds.add(id);
+    return id;
+}
+function escapeHtml(value) {
+    return value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+}
+function escapeHtmlAttribute(value) {
+    return escapeHtml(value).replaceAll('"', '&quot;').replaceAll("'", '&#39;');
+}
+const WORK_TEMPLATES = [
+    {
+        id: 'blank-document',
+        kind: 'document',
+        name: '空白文字',
+        description: '从一张干净的 A4 页面开始',
+        accent: '#2f6fed'
+    },
+    {
+        id: 'project-brief',
+        kind: 'document',
+        name: '项目方案',
+        description: '目标、范围、里程碑与风险',
+        accent: '#536de2'
+    },
+    {
+        id: 'table-of-contents',
+        kind: 'document',
+        name: '可更新目录',
+        description: '标题级别、超链接、页码、前导符与原生 DOCX 往返',
+        accent: '#315f9f'
+    },
+    {
+        id: 'text-effects',
+        kind: 'document',
+        name: '文字效果',
+        description: '空心、阴影、阳文与阴文',
+        accent: '#6b5bd2'
+    },
+    {
+        id: 'run-borders',
+        kind: 'document',
+        name: '字符边框',
+        description: '原生线型、颜色、宽度、间距与阴影',
+        accent: '#4472c4'
+    },
+    {
+        id: 'run-shading',
+        kind: 'document',
+        name: '字符底纹',
+        description: '原生图案、前景色、背景色与显式重置',
+        accent: '#70ad47'
+    },
+    {
+        id: 'proofing-languages',
+        kind: 'document',
+        name: '校对语言',
+        description: '拉丁、东亚、双向文字与校对排除',
+        accent: '#2f6fed'
+    },
+    {
+        id: 'blank-markdown',
+        kind: 'markdown',
+        name: '空白 Markdown',
+        description: '用轻量标记编写结构化内容',
+        accent: '#586574'
+    },
+    {
+        id: 'blank-spreadsheet',
+        kind: 'spreadsheet',
+        name: '空白表格',
+        description: '公式、表格、筛选与多工作表',
+        accent: '#16a36a'
+    },
+    {
+        id: 'quarterly-plan',
+        kind: 'spreadsheet',
+        name: '季度计划',
+        description: '目标进度与预算跟踪',
+        accent: '#168f72'
+    },
+    {
+        id: 'data-validation',
+        kind: 'spreadsheet',
+        name: '数据验证',
+        description: '下拉列表、输入提示与错误警告',
+        accent: '#13795b'
+    },
+    {
+        id: 'blank-presentation',
+        kind: 'presentation',
+        name: '空白演示',
+        description: '16:9 宽屏演示文稿',
+        accent: '#e16b3d'
+    },
+    {
+        id: 'strategy-deck',
+        kind: 'presentation',
+        name: '策略汇报',
+        description: '结论先行的三页汇报',
+        accent: '#c85637'
+    }
+];
+function createWorkArtifact(templateId) {
+    const template = WORK_TEMPLATES.find((item)=>item.id === templateId) ?? WORK_TEMPLATES[0];
+    const now = Date.now();
+    return {
+        id: createWorkId('artifact'),
+        kind: template.kind,
+        title: initialTitle(template.id, template.kind),
+        favorite: false,
+        createdAt: now,
+        updatedAt: now,
+        lastOpenedAt: now,
+        revision: 1,
+        content: contentForTemplate(template.id)
+    };
+}
+function createWorkId(prefix) {
+    const random = "u" > typeof crypto && 'function' == typeof crypto.randomUUID ? crypto.randomUUID() : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+    return `${prefix}-${random}`;
+}
+function initialTitle(templateId, kind) {
+    const titles = {
+        'project-brief': '新项目方案',
+        'table-of-contents': '可更新目录示例',
+        'text-effects': '文字效果示例',
+        'run-borders': '字符边框示例',
+        'run-shading': '字符底纹示例',
+        'proofing-languages': '校对语言示例',
+        'quarterly-plan': '季度执行计划',
+        'data-validation': '数据验证示例',
+        'strategy-deck': '业务策略汇报'
+    };
+    if (titles[templateId]) return titles[templateId];
+    if ('document' === kind) return '无标题文字';
+    if ('markdown' === kind) return '无标题 Markdown';
+    if ('spreadsheet' === kind) return '无标题表格';
+    return '无标题演示';
+}
+function contentForTemplate(templateId) {
+    if ('project-brief' === templateId) return {
+        type: 'document',
+        pageSize: 'a4',
+        html: "<h1>新项目方案</h1><p><strong>负责人：</strong>项目团队　　<strong>更新日期：</strong>今天</p><blockquote><p>用一句话说明这项工作的目标，以及完成后会带来什么变化。</p></blockquote><h2>背景与目标</h2><p>描述当前情况、核心问题和可衡量的成功标准。</p><h2>工作范围</h2><ul><li><p>需要完成的关键交付物</p></li><li><p>明确不在本期范围内的事项</p></li></ul><h2>里程碑</h2><ol><li><p>方案确认</p></li><li><p>执行与评审</p></li><li><p>交付与复盘</p></li></ol><h2>风险与决策</h2><p>记录尚未解决的问题、依赖和决策负责人。</p>"
+    };
+    if ('table-of-contents' === templateId) return {
+        type: 'document',
+        pageSize: 'a4',
+        html: [
+            documentTableOfContentsHtml({
+                id: 'playground-table-of-contents',
+                options: {
+                    minLevel: 1,
+                    maxLevel: 3,
+                    hyperlinks: true,
+                    showPageNumbers: true,
+                    rightAlignPageNumbers: true,
+                    leader: 'dot'
+                },
+                entries: [
+                    {
+                        targetId: 'heading-00001001',
+                        title: '项目概述',
+                        level: 1,
+                        pageNumber: 1
+                    },
+                    {
+                        targetId: 'heading-00001002',
+                        title: '目标与范围',
+                        level: 2,
+                        pageNumber: 1
+                    },
+                    {
+                        targetId: 'heading-00001003',
+                        title: '实施计划',
+                        level: 1,
+                        pageNumber: 2
+                    }
+                ]
+            }),
+            '<h1 data-office-paragraph-id="00001001" data-office-paragraph-text-id="00002001">项目概述</h1>',
+            '<p>目录是一个可选择、不可直接改写的结构化块。请从“引用”选项卡自定义或更新它。</p>',
+            '<h2 data-office-paragraph-id="00001002" data-office-paragraph-text-id="00002002">目标与范围</h2>',
+            '<p>修改标题文字后，使用“更新目录”同步标题与当前分页页码。</p>',
+            '<hr class="work-page-break" data-page-break="true">',
+            '<h1 data-office-paragraph-id="00001003" data-office-paragraph-text-id="00002003">实施计划</h1>',
+            '<p>导出 DOCX 后仍保留原生 TOC 域、缓存目录项、超链接和前导符。</p>'
+        ].join('')
+    };
+    if ('text-effects' === templateId) return {
+        type: 'document',
+        pageSize: 'a4',
+        html: '<h1>原生文字效果</h1><p>选择下面任一示例并打开字体高级设置，可以组合空心与阴影，或在互斥的阳文和阴文之间切换。</p><h2>可组合效果</h2><p><span data-office-legacy-text-outline="true" data-office-legacy-text-shadow="true">空心 + 阴影</span></p><p><span data-office-legacy-text-outline="true">空心</span></p><p><span data-office-legacy-text-shadow="true">阴影</span></p><h2>互斥效果</h2><p><span data-office-legacy-text-emboss="true">阳文</span></p><p><span data-office-legacy-text-imprint="true">阴文</span></p>'
+    };
+    if ('run-borders' === templateId) return {
+        type: 'document',
+        pageSize: 'a4',
+        html: [
+            '<h1>原生字符边框</h1>',
+            '<p>选择任一示例，可从开始选项卡直接开关边框，或在字体高级设置中编辑完整的原生线型、颜色、宽度、文字间距、阴影和框架属性。</p>',
+            '<h2>常用线型</h2>',
+            `<p>${runBorderTemplateSpan({
+                style: 'single',
+                color: {
+                    value: '#4472c4'
+                },
+                size: 4,
+                space: 1
+            }, '单实线字符边框')}</p>`,
+            `<p>${runBorderTemplateSpan({
+                style: 'double',
+                color: {
+                    value: '#c00000'
+                },
+                size: 8,
+                space: 2
+            }, '双线字符边框')}</p>`,
+            `<p>${runBorderTemplateSpan({
+                style: 'wave',
+                color: {
+                    value: '#7030a0'
+                },
+                size: 8,
+                space: 2
+            }, '波浪字符边框')}</p>`,
+            '<h2>高级属性</h2>',
+            `<p>${runBorderTemplateSpan({
+                style: 'thinThickMediumGap',
+                color: {
+                    value: '#0070c0'
+                },
+                size: 16,
+                space: 3,
+                shadow: true,
+                frame: true
+            }, '阴影与框架字符边框')}</p>`
+        ].join('')
+    };
+    if ('run-shading' === templateId) return {
+        type: 'document',
+        pageSize: 'a4',
+        html: [
+            '<h1>原生字符底纹</h1>',
+            '<p>选择任一示例并打开字体高级设置，可以编辑完整的原生图案、前景色、背景色，或写入显式无底纹重置。</p>',
+            '<h2>基本填充</h2>',
+            `<p>${runShadingTemplateSpan({
+                pattern: 'clear',
+                fill: {
+                    value: '#fff2cc'
+                }
+            }, '清除图案使用背景色')}</p>`,
+            `<p>${runShadingTemplateSpan({
+                pattern: 'solid',
+                color: {
+                    value: '#4472c4'
+                }
+            }, '实心图案使用前景色')}</p>`,
+            '<h2>图案与密度</h2>',
+            `<p>${runShadingTemplateSpan({
+                pattern: 'diagCross',
+                color: {
+                    value: '#c00000'
+                },
+                fill: {
+                    value: '#fce4d6'
+                }
+            }, '对角交叉字符底纹')}</p>`,
+            `<p>${runShadingTemplateSpan({
+                pattern: 'pct25',
+                color: {
+                    value: '#4472c4'
+                },
+                fill: {
+                    value: '#ddebf7'
+                }
+            }, '25% 字符底纹')}</p>`,
+            `<p>${runShadingTemplateSpan({
+                pattern: 'thinHorzStripe',
+                color: {
+                    value: '#70ad47'
+                },
+                fill: {
+                    value: '#e2f0d9'
+                }
+            }, '细水平条纹字符底纹')}</p>`
+        ].join('')
+    };
+    if ('proofing-languages' === templateId) {
+        const languages = {
+            latin: 'en-US',
+            eastAsia: 'zh-CN',
+            bidi: 'ar-SA'
+        };
+        return {
+            type: 'document',
+            pageSize: 'a4',
+            html: [
+                '<h1>原生校对语言</h1>',
+                '<p>在“审阅”选项卡中打开“设置校对语言”，可以独立编辑拉丁、东亚和双向文字语言，并决定文字是否参与拼写与语法检查。</p>',
+                '<h2>按文字系统设置</h2>',
+                `<p>${proofingLanguageTemplateSpan(languages, false, 'ascii', 'English proofing language')}</p>`,
+                `<p>${proofingLanguageTemplateSpan(languages, false, 'eastAsia', '简体中文校对语言')}</p>`,
+                `<p dir="rtl">${proofingLanguageTemplateSpan(languages, false, 'complexScript', 'لغة التدقيق العربية')}</p>`,
+                '<h2>校对行为</h2>',
+                `<p>${proofingLanguageTemplateSpan({
+                    latin: 'en-GB'
+                }, false, 'ascii', 'This text participates in proofing.')}</p>`,
+                `<p>${proofingLanguageTemplateSpan({
+                    latin: 'x-none'
+                }, true, 'ascii', 'A3S-API-v2: this product identifier is excluded from proofing.')}</p>`
+            ].join('')
+        };
+    }
+    if ('quarterly-plan' === templateId) return {
+        type: 'spreadsheet',
+        sheets: quarterlyPlanSheets()
+    };
+    if ('data-validation' === templateId) return {
+        type: 'spreadsheet',
+        sheets: dataValidationTemplateSheets()
+    };
+    if ('strategy-deck' === templateId) return strategyPresentation();
+    if ('blank-spreadsheet' === templateId) return {
+        type: 'spreadsheet',
+        sheets: [
+            blankSheet()
+        ]
+    };
+    if ('blank-markdown' === templateId) return {
+        type: 'markdown',
+        markdown: ''
+    };
+    if ('blank-presentation' === templateId) return {
+        type: 'presentation',
+        slides: [
+            blankSlide()
+        ]
+    };
+    return {
+        type: 'document',
+        pageSize: 'a4',
+        html: '<p></p>'
+    };
+}
+function runBorderTemplateSpan(border, text) {
+    const attributes = documentRunBorderDomAttributes(border);
+    return `<span ${DOCUMENT_RUN_BORDER_ATTRIBUTE}='${attributes[DOCUMENT_RUN_BORDER_ATTRIBUTE]}' style="${attributes.style}">${text}</span>`;
+}
+function runShadingTemplateSpan(shading, text) {
+    const attributes = documentRunShadingDomAttributes(shading);
+    return `<span ${DOCUMENT_RUN_SHADING_ATTRIBUTE}='${attributes[DOCUMENT_RUN_SHADING_ATTRIBUTE]}' style="${attributes.style}">${text}</span>`;
+}
+function proofingLanguageTemplateSpan(languages, noProof, slot, text) {
+    const attributes = documentProofingDomAttributes(languages, noProof, slot);
+    return `<span ${Object.entries(attributes).map(([name, value])=>`${name}='${value}'`).join(' ')}>${text}</span>`;
+}
+function blankSheet() {
+    return {
+        id: createWorkId('sheet'),
+        name: '工作表1',
+        status: 1,
+        order: 0,
+        row: 60,
+        column: 26,
+        data: emptyMatrix(60, 26)
+    };
+}
+function quarterlyPlanSheets() {
+    const data = emptyMatrix(40, 12);
+    data[0][0] = styledCell('季度执行计划', {
+        bl: 1,
+        fs: 16,
+        fc: '#ffffff',
+        bg: '#168f72'
+    });
+    data[2][0] = headerCell('目标');
+    data[2][1] = headerCell('负责人');
+    data[2][2] = headerCell('一月');
+    data[2][3] = headerCell('二月');
+    data[2][4] = headerCell('三月');
+    data[2][5] = headerCell('完成率');
+    data[2][6] = headerCell('状态');
+    const rows = [
+        [
+            '客户洞察报告',
+            '林岚',
+            1,
+            1,
+            0,
+            '=SUM(C4:E4)/3',
+            '进行中'
+        ],
+        [
+            '新版发布',
+            '周启',
+            0.8,
+            0.6,
+            0,
+            '=AVERAGE(C5:E5)',
+            '有风险'
+        ],
+        [
+            '渠道增长',
+            '陈一',
+            1,
+            0.9,
+            0.7,
+            '=AVERAGE(C6:E6)',
+            '正常'
+        ],
+        [
+            '团队能力建设',
+            '项目组',
+            1,
+            1,
+            1,
+            '=AVERAGE(C7:E7)',
+            '已完成'
+        ]
+    ];
+    rows.forEach((row, rowIndex)=>{
+        row.forEach((value, columnIndex)=>{
+            data[rowIndex + 3][columnIndex] = styledCell(value, {
+                bg: rowIndex % 2 ? '#f7faf9' : '#ffffff',
+                ...columnIndex >= 2 && columnIndex <= 5 ? {
+                    ct: {
+                        fa: '0%',
+                        t: 'n'
+                    },
+                    ...'number' == typeof value ? {
+                        m: `${Math.round(100 * value)}%`
+                    } : {}
+                } : {}
+            });
+        });
+    });
+    return [
+        {
+            id: createWorkId('sheet'),
+            name: '执行看板',
+            status: 1,
+            order: 0,
+            row: 40,
+            column: 12,
+            data,
+            config: {
+                columnlen: {
+                    0: 180,
+                    1: 96,
+                    2: 76,
+                    3: 76,
+                    4: 76,
+                    5: 96,
+                    6: 96
+                },
+                rowlen: {
+                    0: 34,
+                    2: 28
+                },
+                merge: {
+                    '0_0': {
+                        r: 0,
+                        c: 0,
+                        rs: 1,
+                        cs: 7
+                    }
+                }
+            }
+        }
+    ];
+}
+function dataValidationTemplateSheets() {
+    const inputs = emptyMatrix(24, 8);
+    [
+        'Task',
+        'State',
+        'Due date',
+        'Priority',
+        'Owner'
+    ].forEach((value, column)=>{
+        inputs[0][column] = headerCell(value);
+    });
+    const rows = [
+        [
+            'Confirm requirements',
+            'Ready',
+            '2026-09-05',
+            2,
+            'Avery'
+        ],
+        [
+            'Review integration',
+            'In review',
+            '2026-09-12',
+            3,
+            'Morgan'
+        ],
+        [
+            'Resolve blockers',
+            'Blocked',
+            '2026-09-18',
+            5,
+            'Riley'
+        ],
+        [
+            'Publish preview',
+            'Ready',
+            '2026-09-24',
+            1,
+            'Jordan'
+        ],
+        [
+            'Ship release',
+            'In review',
+            '2026-09-30',
+            4,
+            'Taylor'
+        ]
+    ];
+    rows.forEach((row, rowIndex)=>{
+        row.forEach((value, columnIndex)=>{
+            inputs[rowIndex + 1][columnIndex] = styledCell(value, {
+                bg: rowIndex % 2 ? '#f4faf7' : '#ffffff'
+            });
+        });
+    });
+    return [
+        {
+            id: createWorkId('sheet'),
+            name: 'Inputs',
+            status: 1,
+            order: 0,
+            row: 24,
+            column: 8,
+            data: inputs,
+            dataValidationRanges: [
+                {
+                    ranges: [
+                        {
+                            row: [
+                                1,
+                                5
+                            ],
+                            column: [
+                                1,
+                                1
+                            ]
+                        }
+                    ],
+                    item: dataValidationTemplateItem({
+                        type: 'dropdown',
+                        rangeTxt: 'B2:B6',
+                        value1: "'Lists'!A1:A3",
+                        allowBlank: false,
+                        showDropdownArrow: true,
+                        errorStyle: 'stop',
+                        errorTitle: 'Invalid state',
+                        errorMessage: 'Choose a state from the list.',
+                        hintShow: true,
+                        hintTitle: 'Workflow state',
+                        hintValue: 'Choose Ready, Blocked, or In review.'
+                    })
+                },
+                {
+                    ranges: [
+                        {
+                            row: [
+                                1,
+                                5
+                            ],
+                            column: [
+                                2,
+                                2
+                            ]
+                        }
+                    ],
+                    item: dataValidationTemplateItem({
+                        type: 'date',
+                        type2: 'between',
+                        rangeTxt: 'C2:C6',
+                        value1: '2026-01-01',
+                        value2: '2026-12-31',
+                        errorStyle: 'information',
+                        errorTitle: 'Date outside 2026',
+                        errorMessage: 'Enter a date in calendar year 2026.',
+                        hintShow: true,
+                        hintTitle: 'Due date',
+                        hintValue: 'Use a date between 2026-01-01 and 2026-12-31.'
+                    })
+                },
+                {
+                    ranges: [
+                        {
+                            row: [
+                                1,
+                                5
+                            ],
+                            column: [
+                                3,
+                                3
+                            ]
+                        }
+                    ],
+                    item: dataValidationTemplateItem({
+                        type: 'number_integer',
+                        type2: 'between',
+                        rangeTxt: 'D2:D6',
+                        value1: '1',
+                        value2: '5',
+                        allowBlank: false,
+                        errorStyle: 'warning',
+                        errorTitle: 'Priority outside range',
+                        errorMessage: 'Enter a whole number from 1 through 5.',
+                        hintShow: true,
+                        hintTitle: 'Priority',
+                        hintValue: '1 is highest priority; 5 is lowest.'
+                    })
+                }
+            ],
+            luckysheet_select_save: [
+                {
+                    row: [
+                        1,
+                        5
+                    ],
+                    column: [
+                        1,
+                        1
+                    ],
+                    row_focus: 1,
+                    column_focus: 1
+                }
+            ],
+            config: {
+                columnlen: {
+                    0: 190,
+                    1: 110,
+                    2: 118,
+                    3: 84,
+                    4: 104
+                },
+                rowlen: {
+                    0: 30
+                }
+            }
+        },
+        {
+            id: createWorkId('sheet'),
+            name: 'Lists',
+            status: 0,
+            order: 1,
+            row: 12,
+            column: 3,
+            data: [
+                [
+                    styledCell('Ready')
+                ],
+                [
+                    styledCell('Blocked')
+                ],
+                [
+                    styledCell('In review')
+                ]
+            ],
+            config: {
+                columnlen: {
+                    0: 120
+                }
+            }
+        }
+    ];
+}
+function dataValidationTemplateItem(overrides) {
+    return {
+        type: 'dropdown',
+        type2: '',
+        rangeTxt: '',
+        value1: '',
+        value2: '',
+        validity: '',
+        remote: false,
+        allowBlank: true,
+        showDropdownArrow: true,
+        prohibitInput: true,
+        errorStyle: 'stop',
+        errorTitle: '',
+        errorMessage: '',
+        hintShow: false,
+        hintTitle: '',
+        hintValue: '',
+        checked: false,
+        ...overrides
+    };
+}
+function emptyMatrix(rows, columns) {
+    return Array.from({
+        length: rows
+    }, ()=>Array(columns).fill(null));
+}
+function styledCell(value, style = {}) {
+    const formula = 'string' == typeof value && value.startsWith('=') ? value : void 0;
+    return {
+        v: formula ? void 0 : value,
+        m: formula ? '' : String(value),
+        f: formula,
+        ...style
+    };
+}
+function headerCell(value) {
+    return styledCell(value, {
+        bl: 1,
+        fc: '#215446',
+        bg: '#dff3ec',
+        ht: 0,
+        vt: 0
+    });
+}
+function blankSlide() {
+    return {
+        id: createWorkId('slide'),
+        name: '标题幻灯片',
+        background: '#ffffff',
+        elements: [
+            {
+                id: createWorkId('element'),
+                type: 'text',
+                x: 12,
+                y: 25,
+                width: 76,
+                height: 18,
+                text: '',
+                fontSize: 34,
+                color: '#172033',
+                fill: 'transparent',
+                bold: true,
+                align: 'center',
+                placeholder: {
+                    key: 'title',
+                    type: 'title',
+                    prompt: '单击添加标题'
+                }
+            },
+            {
+                id: createWorkId('element'),
+                type: 'text',
+                x: 18,
+                y: 49,
+                width: 64,
+                height: 10,
+                text: '',
+                fontSize: 17,
+                color: '#727b8f',
+                fill: 'transparent',
+                bold: false,
+                align: 'center',
+                placeholder: {
+                    key: 'subtitle',
+                    type: 'subtitle',
+                    prompt: '添加副标题'
+                }
+            }
+        ]
+    };
+}
+function strategyPresentation() {
+    const slides = [
+        {
+            id: createWorkId('slide'),
+            name: '封面',
+            background: '#16213d',
+            elements: [
+                {
+                    id: createWorkId('element'),
+                    type: 'shape',
+                    x: 8,
+                    y: 12,
+                    width: 9,
+                    height: 3,
+                    text: '',
+                    fontSize: 12,
+                    color: '#ffffff',
+                    fill: '#ffb15a',
+                    bold: false,
+                    align: 'left',
+                    radius: 2
+                },
+                {
+                    id: createWorkId('element'),
+                    type: 'text',
+                    x: 8,
+                    y: 30,
+                    width: 72,
+                    height: 24,
+                    text: '业务策略汇报',
+                    fontSize: 38,
+                    color: '#ffffff',
+                    fill: 'transparent',
+                    bold: true,
+                    align: 'left'
+                },
+                {
+                    id: createWorkId('element'),
+                    type: 'text',
+                    x: 8,
+                    y: 58,
+                    width: 62,
+                    height: 10,
+                    text: '把最重要的结论放在标题中',
+                    fontSize: 17,
+                    color: '#b8c4df',
+                    fill: 'transparent',
+                    bold: false,
+                    align: 'left'
+                }
+            ]
+        },
+        {
+            id: createWorkId('slide'),
+            name: '核心判断',
+            background: '#f7f4ee',
+            elements: [
+                {
+                    id: createWorkId('element'),
+                    type: 'text',
+                    x: 8,
+                    y: 10,
+                    width: 84,
+                    height: 11,
+                    text: '01　核心判断',
+                    fontSize: 15,
+                    color: '#b44e34',
+                    fill: 'transparent',
+                    bold: true,
+                    align: 'left'
+                },
+                {
+                    id: createWorkId('element'),
+                    type: 'text',
+                    x: 8,
+                    y: 27,
+                    width: 76,
+                    height: 22,
+                    text: '用一句可以独立成立的话，说明我们看到了什么。',
+                    fontSize: 31,
+                    color: '#20273a',
+                    fill: 'transparent',
+                    bold: true,
+                    align: 'left'
+                },
+                {
+                    id: createWorkId('element'),
+                    type: 'shape',
+                    x: 8,
+                    y: 60,
+                    width: 84,
+                    height: 22,
+                    text: '关键证据或数据',
+                    fontSize: 18,
+                    color: '#ffffff',
+                    fill: '#b44e34',
+                    bold: true,
+                    align: 'center',
+                    radius: 3
+                }
+            ]
+        },
+        {
+            id: createWorkId('slide'),
+            name: '下一步',
+            background: '#ffffff',
+            elements: [
+                {
+                    id: createWorkId('element'),
+                    type: 'text',
+                    x: 8,
+                    y: 10,
+                    width: 84,
+                    height: 12,
+                    text: '02　下一步',
+                    fontSize: 15,
+                    color: '#b44e34',
+                    fill: 'transparent',
+                    bold: true,
+                    align: 'left'
+                },
+                {
+                    id: createWorkId('element'),
+                    type: 'text',
+                    x: 8,
+                    y: 28,
+                    width: 84,
+                    height: 46,
+                    text: '1　确认优先级\n2　指定负责人\n3　设定可验证的里程碑',
+                    fontSize: 26,
+                    color: '#20273a',
+                    fill: '#f3f0ea',
+                    bold: false,
+                    align: 'left',
+                    radius: 3
+                }
+            ]
+        }
+    ];
+    return {
+        type: 'presentation',
+        slides
+    };
+}
+const OFFICE_KERNEL_SPREADSHEET_MAX_ROWS = 1048576;
+const spreadsheetErrors = new Set([
+    '#BLOCKED!',
+    '#BUSY!',
+    '#CALC!',
+    '#CONNECT!',
+    '#DIV/0!',
+    '#FIELD!',
+    '#GETTING_DATA',
+    '#N/A',
+    '#NAME?',
+    '#NULL!',
+    '#NUM!',
+    '#PYTHON!',
+    '#REF!',
+    '#SPILL!',
+    '#UNKNOWN!',
+    '#VALUE!'
+]);
+new TextEncoder();
+function isOfficeKernelSpreadsheetError(value) {
+    return 'string' == typeof value && spreadsheetErrors.has(value);
+}
+export { DEFAULT_DOCUMENT_TABLE_OF_CONTENTS_OPTIONS, DOCUMENT_HIGHLIGHT_ATTRIBUTE, DOCUMENT_NO_PROOF_ATTRIBUTE, DOCUMENT_PARAGRAPH_BORDERS_ATTRIBUTE, DOCUMENT_PARAGRAPH_BORDER_EDGES, DOCUMENT_PARAGRAPH_BORDER_STYLES, DOCUMENT_PARAGRAPH_ID_ATTRIBUTE, DOCUMENT_PARAGRAPH_TEXT_ID_ATTRIBUTE, DOCUMENT_PROOFING_LANGUAGES_ATTRIBUTE, DOCUMENT_RUN_BORDER_ATTRIBUTE, DOCUMENT_RUN_BORDER_STYLES, DOCUMENT_RUN_SHADING_ATTRIBUTE, DOCUMENT_SCRIPT_FONTS_ATTRIBUTE, DOCUMENT_SCRIPT_FONT_SLOT_ATTRIBUTE, DocumentParagraphIdentity, DocxThemePatchCollector, OFFICE_KERNEL_SPREADSHEET_MAX_ROWS, OoxmlPackage, WORK_TEMPLATES as officeTemplates, applyDocumentParagraphIdentityToElement, attribute, buildDocumentTableOfContentsEntries, bytesToDataUrl, childPath, collectWorkDocumentOutline, contentTypeForPart, createDocumentParagraphIdentity, createDocumentParagraphIdentityRegistry, createWorkArtifact as createArtifact, createWorkId as createOfficeId, cssDocumentFontFamily, currentWorkDocumentOutlineItem, decodeXmlBytes, descendants, directChild, directChildren, documentBorderPresentation, documentFontNameFromCssFamily, documentHasIntegrityFeature, documentHighlightCssColor, documentHighlightDomAttributes, documentHighlightForCssColor, documentHighlightFromDocxValue, documentHighlightFromElement, documentNoProofFromElement, documentParagraphBordersDomAttributes, documentParagraphIdentityFromElement, documentParagraphShadingDomAttributes, documentProofingDomAttributes, documentProofingLanguagesFromElement, documentRunBorderDomAttributes, documentRunBorderIsVisible, documentRunShadingDomAttributes, documentScriptFontDirectFamily, documentScriptFontFallbackSlots, documentScriptFontFamily, documentScriptFontFamilyForRendering, documentScriptFontSegments, documentScriptFontSlotFromElement, documentScriptFontSlotFromHint, documentScriptFontsDomAttributes, documentScriptFontsForAllText, documentScriptFontsFromElement, documentTableOfContentsHtml, documentTableOfContentsValueFromElement, firstDescendant, isDocumentParagraphArtBorderStyle, isOfficeKernelSpreadsheetError, normalizeCssColor, normalizeDocumentFontName, normalizeDocumentHighlight, normalizeDocumentLanguageTag, normalizeDocumentNoProof, normalizeDocumentParagraphBorder, normalizeDocumentParagraphBorders, normalizeDocumentParagraphId, normalizeDocumentParagraphIdentity, normalizeDocumentProofingLanguages, normalizeDocumentRunBorder, normalizeDocumentRunShading, normalizeDocumentScriptFontHint, normalizeDocumentScriptFontSlot, normalizeDocumentScriptFonts, normalizeDocumentTableOfContentsHtml, normalizeDocumentTableOfContentsOptions, normalizeDocumentTableOfContentsValue, normalizeDocumentThemeFont, parseDocumentParagraphBorders, parseDocumentParagraphBordersElement, parseDocumentParagraphShading, parseDocumentParagraphShadingElement, parseDocumentProofingLanguages, parseDocumentRunBorder, parseDocumentRunBorderElement, parseDocumentRunShading, parseDocumentRunShadingElement, parseDocumentScriptFonts, parseDocumentTableOfContentsInstruction, parseDocxThemeReference, parseXml, patchDocumentProofingLanguages, patchDocumentScriptFonts, patchDocxThemeReferences, primeDocumentIntegrityFeatures, resolvePartTarget, serializeDocumentParagraphBorders, serializeDocumentParagraphShading, serializeDocumentProofingLanguages, serializeDocumentRunBorder, serializeDocumentRunShading, serializeDocumentScriptFonts, serializeDocxThemeReference, serializeUtf8Xml, uniqueDocumentParagraphIdentity, visibleWorkDocumentOutlineItems, workDocumentOutlineLevel, work_document_paragraph_shading_DOCUMENT_PARAGRAPH_SHADING_PATTERNS, xmlContainsAnyElement, xmlNamespacePrefix };