@a3s-lab/office 0.2.2 → 0.4.0

package/dist/0~5861.js

@@ -1,596 +0,0 @@
-import { Extension } from "@tiptap/core";
-import font_family from "@tiptap/extension-text-style/font-family";
-import { TextStyle } from "@tiptap/extension-text-style";
-const DOCUMENT_INDENT_STEP_PX = 24;
-const MAX_DOCUMENT_INDENT_LEVEL = 8;
-const MAX_DOCUMENT_INDENT_PX = DOCUMENT_INDENT_STEP_PX * MAX_DOCUMENT_INDENT_LEVEL;
-const DOCUMENT_WORD_SINGLE_LINE_HEIGHT = 1.15;
-const DocumentParagraphFormatting = Extension.create({
-    name: 'documentParagraphFormatting',
-    addGlobalAttributes () {
-        return [
-            {
-                types: [
-                    'paragraph',
-                    'heading'
-                ],
-                attributes: {
-                    lineHeight: {
-                        default: null,
-                        parseHTML: (element)=>normalizedLineHeight(element.style.lineHeight),
-                        renderHTML: (attributes)=>{
-                            const lineHeight = normalizedLineHeight(attributes.lineHeight);
-                            return lineHeight ? {
-                                style: `line-height: ${lineHeight}`
-                            } : {};
-                        }
-                    },
-                    lineRule: {
-                        default: null,
-                        parseHTML: (element)=>normalizedLineRule(element.dataset.officeLineRule),
-                        renderHTML: (attributes)=>{
-                            const lineRule = normalizedLineRule(attributes.lineRule);
-                            return lineRule ? {
-                                'data-office-line-rule': lineRule
-                            } : {};
-                        }
-                    },
-                    autoLineHeight: {
-                        default: null,
-                        parseHTML: (element)=>normalizedAutoLineHeight(element.dataset.officeAutoLineHeight),
-                        renderHTML: (attributes)=>'auto' === normalizedLineRule(attributes.lineRule) ? renderDocumentAutoLineHeight(attributes.lineHeight, attributes.autoLineHeight) : {}
-                    },
-                    spaceBefore: pointSpacingAttribute('spaceBefore', 'officeSpaceBefore', 'data-office-space-before', 'margin-top'),
-                    spaceAfter: pointSpacingAttribute('spaceAfter', 'officeSpaceAfter', 'data-office-space-after', 'margin-bottom'),
-                    indentLevel: {
-                        default: 0,
-                        parseHTML: (element)=>parsedIndentLevel(element.dataset.officeIndentLevel, element.style.marginLeft),
-                        renderHTML: (attributes)=>{
-                            const indentLevel = normalizedIndentLevel(attributes.indentLevel);
-                            return indentLevel ? {
-                                'data-office-indent-level': String(indentLevel),
-                                style: `margin-left: ${indentLevel * DOCUMENT_INDENT_STEP_PX}px`
-                            } : {};
-                        }
-                    },
-                    rightIndent: {
-                        default: 0,
-                        parseHTML: (element)=>parsedIndentPixels(element.dataset.officeIndentRight, element.style.marginRight),
-                        renderHTML: (attributes)=>{
-                            const rightIndent = normalizedIndentPixels(attributes.rightIndent);
-                            return rightIndent ? {
-                                'data-office-indent-right': formatPixelValue(rightIndent),
-                                style: `margin-right: ${rightIndent}px`
-                            } : {};
-                        }
-                    },
-                    firstLineIndent: {
-                        default: 0,
-                        parseHTML: (element)=>{
-                            const left = parsedIndentLevel(element.dataset.officeIndentLevel, element.style.marginLeft);
-                            return normalizedFirstLineIndent(parsedSignedIndentPixels(element.dataset.officeIndentFirstLine, element.style.textIndent), left * DOCUMENT_INDENT_STEP_PX);
-                        },
-                        renderHTML: (attributes)=>{
-                            const left = normalizedIndentLevel(attributes.indentLevel) * DOCUMENT_INDENT_STEP_PX;
-                            const firstLineIndent = normalizedFirstLineIndent(attributes.firstLineIndent, left);
-                            return firstLineIndent ? {
-                                'data-office-indent-first-line': formatPixelValue(firstLineIndent),
-                                style: `text-indent: ${firstLineIndent}px`
-                            } : {};
-                        }
-                    },
-                    keepLines: directBooleanAttribute('keepLines', 'officeKeepLines', 'data-office-keep-lines'),
-                    keepWithNext: directBooleanAttribute('keepWithNext', 'officeKeepWithNext', 'data-office-keep-with-next'),
-                    pageBreakBefore: directBooleanAttribute('pageBreakBefore', 'officePageBreakBefore', 'data-office-page-break-before'),
-                    widowControl: directBooleanAttribute('widowControl', 'officeWidowControl', 'data-office-widow-control')
-                }
-            },
-            {
-                types: [
-                    'paragraph',
-                    'heading',
-                    'listItem'
-                ],
-                attributes: {
-                    paragraphDirection: paragraphDirectionAttribute()
-                }
-            }
-        ];
-    },
-    addCommands () {
-        return {
-            changeDocumentIndent: (direction)=>(props)=>changeDocumentIndentCommand(props, direction),
-            clearDocumentParagraphPagination: (options = {})=>(props)=>clearDocumentParagraphPaginationCommand(props, options),
-            clearDocumentFormatting: ()=>(props)=>clearDocumentFormattingCommand(props),
-            setDocumentIndentLevel: (indentLevel, options = {})=>(props)=>setDocumentIndentLevelCommand(props, indentLevel, options),
-            setDocumentLineHeight: (lineHeight)=>(props)=>setDocumentLineHeightCommand(props, lineHeight),
-            setDocumentParagraphDirection: (direction, options = {})=>(props)=>setDocumentParagraphDirectionCommand(props, direction, options),
-            setDocumentParagraphIndent: (indent, options = {})=>(props)=>setDocumentParagraphIndentCommand(props, indent, options),
-            setDocumentParagraphPagination: (pagination, options = {})=>(props)=>setDocumentParagraphPaginationCommand(props, pagination, options),
-            setDocumentParagraphSpacing: (spacing, options = {})=>(props)=>setDocumentParagraphSpacingCommand(props, spacing, options)
-        };
-    }
-});
-function canChangeDocumentIndent(editor, direction) {
-    if (editor.isActive('listItem')) {
-        const canChangeListLevel = direction > 0 ? editor.can().chain().focus().sinkListItem('listItem').run() : editor.can().chain().focus().liftListItem('listItem').run();
-        if (canChangeListLevel) return true;
-    }
-    const current = documentIndentLevel(editor);
-    return direction > 0 ? current < MAX_DOCUMENT_INDENT_LEVEL : current > 0;
-}
-function documentIndentLevel(editor) {
-    return documentParagraphIndent(editor).left / DOCUMENT_INDENT_STEP_PX;
-}
-function documentParagraphIndent(editor) {
-    const attributes = editor.isActive('heading') ? editor.getAttributes('heading') : editor.getAttributes('paragraph');
-    return normalizeDocumentParagraphIndent({
-        left: normalizedIndentLevel(attributes.indentLevel) * DOCUMENT_INDENT_STEP_PX,
-        right: normalizedIndentPixels(attributes.rightIndent),
-        firstLine: normalizedSignedIndentPixels(attributes.firstLineIndent)
-    });
-}
-function documentParagraphPagination(editor) {
-    const attributes = activeParagraphAttributes(editor);
-    return {
-        keepLines: directBoolean(attributes.keepLines) ?? false,
-        keepWithNext: directBoolean(attributes.keepWithNext) ?? editor.isActive('heading'),
-        pageBreakBefore: directBoolean(attributes.pageBreakBefore) ?? false,
-        widowControl: directBoolean(attributes.widowControl) ?? true
-    };
-}
-function documentParagraphDirection(editor) {
-    const attributes = editor.isActive('listItem') ? editor.getAttributes('listItem') : activeParagraphAttributes(editor);
-    return normalizeDocumentParagraphDirection(attributes.paragraphDirection) ?? 'ltr';
-}
-function documentParagraphSpacing(editor) {
-    const attributes = activeParagraphAttributes(editor);
-    return {
-        before: normalizedPointSpacing(attributes.spaceBefore),
-        after: normalizedPointSpacing(attributes.spaceAfter),
-        lineHeight: normalizedLineHeight(attributes.lineHeight),
-        lineRule: normalizedLineRule(attributes.lineRule)
-    };
-}
-function normalizeDocumentParagraphIndent(indent) {
-    const left = normalizedIndentLevel(indent.left / DOCUMENT_INDENT_STEP_PX) * DOCUMENT_INDENT_STEP_PX;
-    return {
-        left,
-        right: normalizedIndentPixels(indent.right),
-        firstLine: normalizedFirstLineIndent(indent.firstLine, left)
-    };
-}
-function normalizeDocumentParagraphDirection(value) {
-    if ('string' != typeof value) return null;
-    const normalized = value.trim().toLowerCase();
-    return 'ltr' === normalized || 'rtl' === normalized ? normalized : null;
-}
-function setDocumentLineHeightCommand({ chain }, lineHeight) {
-    const value = normalizedLineHeight(lineHeight);
-    const lineRule = value ? lineRuleForLineHeight(value) : null;
-    const attributes = {
-        lineHeight: value,
-        lineRule,
-        autoLineHeight: 'auto' === lineRule ? documentAutoLineHeight(value) : null
-    };
-    return chain().focus().updateAttributes('paragraph', attributes).updateAttributes('heading', attributes).run();
-}
-function changeDocumentIndentCommand(props, direction) {
-    const { can, chain, editor } = props;
-    if (editor.isActive('listItem')) {
-        const canChangeListLevel = direction > 0 ? can().chain().focus().sinkListItem('listItem').run() : can().chain().focus().liftListItem('listItem').run();
-        if (canChangeListLevel) return direction > 0 ? chain().focus().sinkListItem('listItem').run() : chain().focus().liftListItem('listItem').run();
-    }
-    const current = documentIndentLevel(editor);
-    const next = normalizedIndentLevel(current + direction);
-    if (next === current) return false;
-    return setDocumentIndentLevelCommand(props, next, {});
-}
-function setDocumentIndentLevelCommand(props, indentLevel, options) {
-    const current = documentParagraphIndent(props.editor);
-    return setDocumentParagraphIndentCommand(props, {
-        ...current,
-        left: normalizedIndentLevel(indentLevel) * DOCUMENT_INDENT_STEP_PX
-    }, options);
-}
-function setDocumentParagraphIndentCommand({ chain, editor }, indent, options) {
-    const nodeTypes = activeParagraphNodeTypes(editor);
-    if (!nodeTypes.length) return false;
-    const normalized = normalizeDocumentParagraphIndent(indent);
-    const attributes = {
-        indentLevel: normalized.left / DOCUMENT_INDENT_STEP_PX,
-        rightIndent: normalized.right,
-        firstLineIndent: normalized.firstLine
-    };
-    let commandChain = chain();
-    if (false !== options.restoreFocus) commandChain = commandChain.focus();
-    for (const nodeType of nodeTypes)commandChain = commandChain.updateAttributes(nodeType, attributes);
-    return commandChain.run();
-}
-function setDocumentParagraphDirectionCommand({ chain, editor }, direction, options) {
-    const nodeTypes = activeParagraphDirectionNodeTypes(editor);
-    const value = normalizeDocumentParagraphDirection(direction);
-    if (!nodeTypes.length || !value) return false;
-    let commandChain = chain();
-    if (false !== options.restoreFocus) commandChain = commandChain.focus();
-    for (const nodeType of nodeTypes)commandChain = commandChain.updateAttributes(nodeType, {
-        paragraphDirection: value
-    });
-    return commandChain.run();
-}
-function setDocumentParagraphPaginationCommand({ chain, editor }, pagination, options) {
-    const nodeTypes = activeParagraphNodeTypes(editor);
-    if (!nodeTypes.length) return false;
-    const attributes = {};
-    for (const key of documentParagraphPaginationKeys)if (Object.hasOwn(pagination, key)) attributes[key] = Boolean(pagination[key]);
-    if (!Object.keys(attributes).length) return false;
-    let commandChain = chain();
-    if (false !== options.restoreFocus) commandChain = commandChain.focus();
-    for (const nodeType of nodeTypes)commandChain = commandChain.updateAttributes(nodeType, attributes);
-    return commandChain.run();
-}
-function clearDocumentParagraphPaginationCommand({ chain, editor }, options) {
-    const nodeTypes = activeParagraphNodeTypes(editor);
-    if (!nodeTypes.length) return false;
-    const attributes = {
-        keepLines: null,
-        keepWithNext: null,
-        pageBreakBefore: null,
-        widowControl: null
-    };
-    let commandChain = chain();
-    if (false !== options.restoreFocus) commandChain = commandChain.focus();
-    for (const nodeType of nodeTypes)commandChain = commandChain.updateAttributes(nodeType, attributes);
-    return commandChain.run();
-}
-function setDocumentParagraphSpacingCommand({ chain, editor }, spacing, options) {
-    const nodeTypes = activeParagraphNodeTypes(editor);
-    if (!nodeTypes.length) return false;
-    const lineHeight = normalizedLineHeight(spacing.lineHeight);
-    const lineRule = normalizedLineRule(spacing.lineRule) ?? (lineHeight ? lineRuleForLineHeight(lineHeight) : null);
-    const attributes = {
-        spaceBefore: normalizedPointSpacing(spacing.before),
-        spaceAfter: normalizedPointSpacing(spacing.after),
-        lineHeight,
-        lineRule,
-        autoLineHeight: 'auto' === lineRule ? documentAutoLineHeight(lineHeight) : null
-    };
-    let commandChain = chain();
-    if (false !== options.restoreFocus) commandChain = commandChain.focus();
-    for (const nodeType of nodeTypes)commandChain = commandChain.updateAttributes(nodeType, attributes);
-    return commandChain.run();
-}
-function clearDocumentFormattingCommand({ chain, editor }) {
-    let commandChain = chain().focus().unsetAllMarks();
-    if (!editor.isActive('listItem')) commandChain = commandChain.setParagraph();
-    return commandChain.unsetTextAlign().updateAttributes('paragraph', {
-        indentLevel: 0,
-        rightIndent: 0,
-        firstLineIndent: 0,
-        lineHeight: null,
-        lineRule: null,
-        autoLineHeight: null,
-        paragraphDirection: null,
-        spaceBefore: null,
-        spaceAfter: null,
-        keepLines: null,
-        keepWithNext: null,
-        pageBreakBefore: null,
-        widowControl: null,
-        tabStops: null
-    }).updateAttributes('listItem', {
-        paragraphDirection: null
-    }).run();
-}
-function parsedIndentLevel(dataValue, marginLeft) {
-    if (dataValue) return normalizedIndentLevel(dataValue);
-    const pixels = cssPixels(marginLeft);
-    return normalizedIndentLevel(pixels ? Math.round(pixels / DOCUMENT_INDENT_STEP_PX) : 0);
-}
-function normalizedIndentLevel(value) {
-    const number = Number(value);
-    if (!Number.isFinite(number)) return 0;
-    return Math.min(MAX_DOCUMENT_INDENT_LEVEL, Math.max(0, Math.round(4 * number) / 4));
-}
-function normalizedLineHeight(value) {
-    if ('string' != typeof value) return null;
-    const normalized = value.trim();
-    if (!normalized || 'normal' === normalized) return null;
-    return /^(?:\d+(?:\.\d+)?|\d+(?:\.\d+)?(?:px|pt|%))$/i.test(normalized) ? normalized : null;
-}
-function documentAutoLineHeight(value) {
-    const multiple = lineHeightMultiple(value);
-    if (null === multiple) return null;
-    return formatLineMetric(multiple * DOCUMENT_WORD_SINGLE_LINE_HEIGHT);
-}
-function documentAutoLineLeadingShift(value) {
-    const multiple = lineHeightMultiple(value);
-    if (null === multiple) return null;
-    return formatLineMetric((1 - multiple) * DOCUMENT_WORD_SINGLE_LINE_HEIGHT / 2);
-}
-function renderDocumentAutoLineHeight(lineHeight, autoLineHeight = documentAutoLineHeight(lineHeight)) {
-    const renderedLineHeight = normalizedAutoLineHeight(autoLineHeight) ?? documentAutoLineHeight(lineHeight);
-    if (null === renderedLineHeight) return {};
-    const multiple = lineHeightMultiple(lineHeight);
-    const shift = documentAutoLineLeadingShift(lineHeight);
-    return {
-        'data-office-auto-line-height': String(formatLineMetric(renderedLineHeight)),
-        style: [
-            `--work-document-office-auto-line-height: ${formatLineMetric(renderedLineHeight)}`,
-            ...null === multiple ? [] : [
-                `--work-document-office-auto-line-multiple: ${formatLineMetric(multiple)}`
-            ],
-            ...null === shift ? [] : [
-                `--work-document-office-auto-line-shift: ${formatLineMetric(shift)}em`
-            ]
-        ].join('; ')
-    };
-}
-function lineHeightMultiple(value) {
-    const normalized = normalizedLineHeight(value);
-    if (!normalized) return null;
-    const percentage = /^(\d+(?:\.\d+)?)%$/.exec(normalized);
-    const multiple = percentage ? Number(percentage[1]) / 100 : /^\d+(?:\.\d+)?$/.test(normalized) ? Number(normalized) : NaN;
-    return Number.isFinite(multiple) && multiple > 0 ? multiple : null;
-}
-function normalizedAutoLineHeight(value) {
-    if (null == value || '' === value) return null;
-    const number = Number(value);
-    return Number.isFinite(number) && number > 0 && number <= 20 ? formatLineMetric(number) : null;
-}
-function formatLineMetric(value) {
-    return Number(value.toFixed(4));
-}
-function normalizedLineRule(value) {
-    if ('auto' === value || 'exact' === value || 'atLeast' === value) return value;
-    if ('exactly' === value) return 'exact';
-    return null;
-}
-function lineRuleForLineHeight(value) {
-    return /(?:px|pt)$/i.test(value) ? 'exact' : 'auto';
-}
-function pointSpacingAttribute(modelKey, datasetKey, htmlName, cssProperty) {
-    return {
-        default: null,
-        parseHTML: (element)=>parsedPointSpacing(element.dataset[datasetKey], 'margin-top' === cssProperty ? element.style.marginTop : element.style.marginBottom),
-        renderHTML: (attributes)=>{
-            const value = normalizedPointSpacing(attributes[modelKey]);
-            if (null === value) return {};
-            const formatted = formatPointValue(value);
-            return {
-                [htmlName]: formatted,
-                style: `${cssProperty}: ${formatted}pt`
-            };
-        }
-    };
-}
-function parsedPointSpacing(dataValue, cssValue) {
-    if (void 0 !== dataValue) return normalizedPointSpacing(dataValue);
-    const match = /^(-?\d+(?:\.\d+)?)(px|pt|mm|cm|in)?$/i.exec(cssValue.trim());
-    if (!match) return null;
-    const amount = Number(match[1]);
-    if (!Number.isFinite(amount)) return null;
-    const unit = match[2]?.toLowerCase() ?? 'px';
-    const points = 'pt' === unit ? amount : 'mm' === unit ? 72 * amount / 25.4 : 'cm' === unit ? 72 * amount / 2.54 : 'in' === unit ? 72 * amount : 0.75 * amount;
-    return normalizedPointSpacing(points);
-}
-function normalizedPointSpacing(value) {
-    if (null == value || '' === value) return null;
-    const number = Number(value);
-    if (!Number.isFinite(number)) return null;
-    return Math.min(720, Math.max(0, Math.round(4 * number) / 4));
-}
-function formatPointValue(value) {
-    return Number(value.toFixed(2)).toString();
-}
-function cssPixels(value) {
-    const match = /^(-?\d+(?:\.\d+)?)(px|pt)?$/i.exec(value.trim());
-    if (!match) return 0;
-    const amount = Number(match[1]);
-    if (!Number.isFinite(amount)) return 0;
-    return match[2]?.toLowerCase() === 'pt' ? amount / 0.75 : amount;
-}
-function parsedIndentPixels(dataValue, cssValue) {
-    return normalizedIndentPixels(void 0 === dataValue ? cssPixels(cssValue) : dataValue);
-}
-function parsedSignedIndentPixels(dataValue, cssValue) {
-    return normalizedSignedIndentPixels(void 0 === dataValue ? cssPixels(cssValue) : dataValue);
-}
-function normalizedIndentPixels(value) {
-    const number = Number(value);
-    if (!Number.isFinite(number)) return 0;
-    return Math.min(MAX_DOCUMENT_INDENT_PX, Math.max(0, Math.round(number)));
-}
-function normalizedSignedIndentPixels(value) {
-    const number = Number(value);
-    if (!Number.isFinite(number)) return 0;
-    return Math.min(MAX_DOCUMENT_INDENT_PX, Math.max(-MAX_DOCUMENT_INDENT_PX, Math.round(number)));
-}
-function normalizedFirstLineIndent(value, leftIndent) {
-    return Math.max(-leftIndent, Math.min(MAX_DOCUMENT_INDENT_PX, normalizedSignedIndentPixels(value)));
-}
-function formatPixelValue(value) {
-    return Number(value.toFixed(2)).toString();
-}
-function activeParagraphAttributes(editor) {
-    return editor.isActive('heading') ? editor.getAttributes('heading') : editor.getAttributes('paragraph');
-}
-function paragraphDirectionAttribute() {
-    return {
-        default: null,
-        parseHTML: (element)=>normalizeDocumentParagraphDirection(element.getAttribute('dir') ?? element.style.direction),
-        renderHTML: (attributes)=>{
-            const direction = normalizeDocumentParagraphDirection(attributes.paragraphDirection);
-            return direction ? {
-                dir: direction
-            } : {};
-        }
-    };
-}
-function directBooleanAttribute(modelKey, datasetKey, htmlName) {
-    return {
-        default: null,
-        parseHTML: (element)=>directBoolean(element.dataset[datasetKey]),
-        renderHTML: (attributes)=>{
-            const value = directBoolean(attributes[modelKey]);
-            return null === value ? {} : {
-                [htmlName]: String(value)
-            };
-        }
-    };
-}
-const documentParagraphPaginationKeys = [
-    'keepLines',
-    'keepWithNext',
-    'pageBreakBefore',
-    'widowControl'
-];
-function directBoolean(value) {
-    if (true === value || 'true' === value || '1' === value) return true;
-    if (false === value || 'false' === value || '0' === value) return false;
-    return null;
-}
-function activeParagraphNodeTypes(editor) {
-    const nodeTypes = new Set();
-    if (editor.isActive('paragraph')) nodeTypes.add('paragraph');
-    if (editor.isActive('heading')) nodeTypes.add('heading');
-    const { from, to } = editor.state.selection;
-    if (from !== to) editor.state.doc.nodesBetween(from, to, (node)=>{
-        if ('paragraph' === node.type.name) nodeTypes.add('paragraph');
-        if ('heading' === node.type.name) nodeTypes.add('heading');
-    });
-    return [
-        ...nodeTypes
-    ];
-}
-function activeParagraphDirectionNodeTypes(editor) {
-    const { from, to } = editor.state.selection;
-    if (from === to) return editor.isActive('listItem') ? [
-        'listItem'
-    ] : activeParagraphNodeTypes(editor);
-    const nodeTypes = new Set();
-    editor.state.doc.nodesBetween(from, to, (node, _position, parent)=>{
-        if ('listItem' === node.type.name) nodeTypes.add('listItem');
-        if ('paragraph' === node.type.name && parent?.type.name !== 'listItem') nodeTypes.add('paragraph');
-        if ('heading' === node.type.name) nodeTypes.add('heading');
-    });
-    return [
-        ...nodeTypes
-    ];
-}
-const DOCUMENT_WORD_DEFAULT_SINGLE_LINE_HEIGHT = 1.15;
-const DOCUMENT_WORD_LINE_HEIGHT_FACTORS = new Map([
-    [
-        'arial',
-        1.15
-    ],
-    [
-        'times new roman',
-        1.15
-    ],
-    [
-        'calibri',
-        1.2207
-    ],
-    [
-        'segoe ui',
-        1.3301
-    ],
-    [
-        'microsoft yahei',
-        1.7143
-    ],
-    [
-        'microsoft yahei ui',
-        1.7143
-    ],
-    [
-        'simsun',
-        1.2976
-    ],
-    [
-        'simhei',
-        1.2976
-    ],
-    [
-        'fangsong',
-        1.2976
-    ],
-    [
-        'kaiti',
-        1.2976
-    ],
-    [
-        'dengxian',
-        1.3548
-    ]
-]);
-function documentWordLineHeightFactor(fontFamily) {
-    if ('string' != typeof fontFamily) return DOCUMENT_WORD_DEFAULT_SINGLE_LINE_HEIGHT;
-    const family = firstCssFontFamily(fontFamily).toLocaleLowerCase();
-    return DOCUMENT_WORD_LINE_HEIGHT_FACTORS.get(family) ?? DOCUMENT_WORD_DEFAULT_SINGLE_LINE_HEIGHT;
-}
-function normalizedDocumentWordLineHeightFactor(value) {
-    if (null == value || '' === value) return null;
-    const factor = Number(value);
-    if (!Number.isFinite(factor) || factor < 0.5 || factor > 4) return null;
-    return Number(factor.toFixed(4));
-}
-const DocumentTextStyle = TextStyle.extend({
-    addAttributes () {
-        return {
-            wordLineHeightFactor: {
-                default: null,
-                parseHTML: (element)=>normalizedDocumentWordLineHeightFactor(element.dataset.officeWordLineHeightFactor ?? element.style.getPropertyValue('--work-document-word-line-height-factor')),
-                renderHTML: (attributes)=>{
-                    const factor = normalizedDocumentWordLineHeightFactor(attributes.wordLineHeightFactor);
-                    if (null === factor) return {};
-                    return {
-                        'data-office-word-line-height-factor': String(factor),
-                        style: `--work-document-word-line-height-factor: ${factor}`
-                    };
-                }
-            },
-            wordSnapToGrid: {
-                default: null,
-                parseHTML: (element)=>normalizedBoolean(element.dataset.officeWordSnapToGrid),
-                renderHTML: (attributes)=>{
-                    const value = normalizedBoolean(attributes.wordSnapToGrid);
-                    return null === value ? {} : {
-                        'data-office-word-snap-to-grid': String(value)
-                    };
-                }
-            }
-        };
-    }
-});
-const DocumentFontFamily = font_family.extend({
-    addCommands () {
-        return {
-            setFontFamily: (fontFamily)=>({ chain })=>chain().setMark('textStyle', {
-                        fontFamily,
-                        wordLineHeightFactor: documentWordLineHeightFactor(fontFamily)
-                    }).run(),
-            unsetFontFamily: ()=>({ chain })=>chain().setMark('textStyle', {
-                        fontFamily: null,
-                        wordLineHeightFactor: null
-                    }).removeEmptyTextStyle().run()
-        };
-    }
-});
-function firstCssFontFamily(value) {
-    const source = value.trim();
-    if (!source) return '';
-    const quote = source[0];
-    if ('"' === quote || "'" === quote) {
-        const end = source.indexOf(quote, 1);
-        if (end > 0) return source.slice(1, end).trim();
-    }
-    return (source.split(',')[0] ?? source).trim().replace(/^(['"])(.*)\1$/, '$2');
-}
-function normalizedBoolean(value) {
-    if (true === value || 'true' === value || '1' === value) return true;
-    if (false === value || 'false' === value || '0' === value) return false;
-    return null;
-}
-export { DocumentFontFamily, DocumentParagraphFormatting, DocumentTextStyle, canChangeDocumentIndent, documentAutoLineHeight, documentParagraphDirection, documentParagraphIndent, documentParagraphPagination, documentParagraphSpacing, documentWordLineHeightFactor, normalizeDocumentParagraphIndent, renderDocumentAutoLineHeight };