@a3s-lab/office 0.29.0 → 0.30.0

package/dist/4121.js

@@ -1,4 +1,73 @@
 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;
@@ -971,6 +1040,1489 @@ function cssBorderStyle(style) {
 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',
@@ -986,6 +2538,13 @@ const WORK_TEMPLATES = [
         description: '目标、范围、里程碑与风险',
         accent: '#536de2'
     },
+    {
+        id: 'table-of-contents',
+        kind: 'document',
+        name: '可更新目录',
+        description: '标题级别、超链接、页码、前导符与原生 DOCX 往返',
+        accent: '#315f9f'
+    },
     {
         id: 'text-effects',
         kind: 'document',
@@ -1000,6 +2559,20 @@ const WORK_TEMPLATES = [
         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',
@@ -1021,6 +2594,13 @@ const WORK_TEMPLATES = [
         description: '目标进度与预算跟踪',
         accent: '#168f72'
     },
+    {
+        id: 'data-validation',
+        kind: 'spreadsheet',
+        name: '数据验证',
+        description: '下拉列表、输入提示与错误警告',
+        accent: '#13795b'
+    },
     {
         id: 'blank-presentation',
         kind: 'presentation',
@@ -1058,9 +2638,13 @@ function createWorkId(prefix) {
 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];
@@ -1075,6 +2659,50 @@ function contentForTemplate(templateId) {
         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',
@@ -1124,10 +2752,89 @@ function contentForTemplate(templateId) {
             }, '阴影与框架字符边框')}</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',
@@ -1155,6 +2862,14 @@ 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'),
@@ -1270,6 +2985,229 @@ function quarterlyPlanSheets() {
         }
     ];
 }
+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
@@ -1507,4 +3445,4 @@ new TextEncoder();
 function isOfficeKernelSpreadsheetError(value) {
     return 'string' == typeof value && spreadsheetErrors.has(value);
 }
-export { DOCUMENT_PARAGRAPH_BORDERS_ATTRIBUTE, DOCUMENT_PARAGRAPH_BORDER_EDGES, DOCUMENT_PARAGRAPH_BORDER_STYLES, DOCUMENT_RUN_BORDER_ATTRIBUTE, DOCUMENT_RUN_BORDER_STYLES, DocxThemePatchCollector, OFFICE_KERNEL_SPREADSHEET_MAX_ROWS, OoxmlPackage, WORK_TEMPLATES as officeTemplates, attribute, bytesToDataUrl, childPath, contentTypeForPart, createWorkArtifact as createArtifact, createWorkId as createOfficeId, decodeXmlBytes, descendants, directChild, directChildren, documentBorderPresentation, documentParagraphBordersDomAttributes, documentRunBorderDomAttributes, documentRunBorderIsVisible, firstDescendant, isDocumentParagraphArtBorderStyle, isOfficeKernelSpreadsheetError, normalizeCssColor, normalizeDocumentParagraphBorder, normalizeDocumentParagraphBorders, normalizeDocumentRunBorder, parseDocumentParagraphBorders, parseDocumentParagraphBordersElement, parseDocumentRunBorder, parseDocumentRunBorderElement, parseDocxThemeReference, parseXml, patchDocxThemeReferences, resolvePartTarget, serializeDocumentParagraphBorders, serializeDocumentRunBorder, serializeDocxThemeReference, serializeUtf8Xml, xmlContainsAnyElement, xmlNamespacePrefix };
+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 };