@a3s-lab/office 0.1.0 → 0.2.2

package/dist/0~4750.js

@@ -0,0 +1,939 @@
+import { Extension, ResizableNodeView, mergeAttributes } from "@tiptap/core";
+import extension_image from "@tiptap/extension-image";
+import { closeHistory } from "@tiptap/pm/history";
+import { NodeSelection } from "@tiptap/pm/state";
+import { TableMap, isInTable, selectedRect } from "@tiptap/pm/tables";
+const DEFAULT_IMAGE_LAYOUT = 'inline';
+const DEFAULT_IMAGE_ALIGNMENT = 'center';
+const DEFAULT_WRAP_DISTANCE_MILLIMETERS = 3;
+const MAX_WRAP_DISTANCE_MILLIMETERS = 25;
+const DEFAULT_LOCK_ASPECT_RATIO = true;
+const DocumentImage = extension_image.extend({
+    addCommands () {
+        return {
+            ...this.parent?.() ?? {},
+            setDocumentImageProperties: (value, options = {})=>({ chain, state, tr })=>{
+                    if (!isDocumentImageSelection(state.selection)) return false;
+                    const attributes = documentImageAttributesForChanges(value);
+                    if (!Object.keys(attributes).length) return false;
+                    closeHistory(tr);
+                    let commandChain = chain();
+                    if (false !== options.restoreFocus) commandChain = commandChain.focus();
+                    return commandChain.updateAttributes('image', attributes).run();
+                },
+            setDocumentImageAlternativeText: (alternativeText, options = {})=>({ commands })=>commands.setDocumentImageProperties({
+                        alternativeText
+                    }, options),
+            setDocumentImageLayoutOptions: (value, options = {})=>({ commands })=>commands.setDocumentImageProperties(value, options)
+        };
+    },
+    addAttributes () {
+        return {
+            ...this.parent?.(),
+            layout: {
+                default: DEFAULT_IMAGE_LAYOUT,
+                parseHTML: (element)=>normalizeDocumentImageLayout(element.getAttribute('data-office-image-layout')),
+                renderHTML: (attributes)=>({
+                        'data-office-image-layout': normalizeDocumentImageLayout(attributes.layout)
+                    })
+            },
+            alignment: {
+                default: DEFAULT_IMAGE_ALIGNMENT,
+                parseHTML: (element)=>normalizeDocumentImageAlignment(element.getAttribute('data-office-image-alignment')),
+                renderHTML: (attributes)=>({
+                        'data-office-image-alignment': normalizeDocumentImageAlignment(attributes.alignment)
+                    })
+            },
+            wrapDistance: {
+                default: DEFAULT_WRAP_DISTANCE_MILLIMETERS,
+                parseHTML: (element)=>normalizeDocumentImageWrapDistance(element.getAttribute('data-office-image-wrap-distance')),
+                renderHTML: (attributes)=>{
+                    const distance = normalizeDocumentImageWrapDistance(attributes.wrapDistance);
+                    return {
+                        'data-office-image-wrap-distance': formatImageLayoutNumber(distance),
+                        style: `--work-document-image-wrap-distance:${formatImageLayoutNumber(distance)}mm`
+                    };
+                }
+            },
+            lockAspectRatio: {
+                default: DEFAULT_LOCK_ASPECT_RATIO,
+                parseHTML: (element)=>normalizeDocumentImageLockAspectRatio(element.getAttribute('data-office-image-lock-aspect-ratio')),
+                renderHTML: (attributes)=>({
+                        'data-office-image-lock-aspect-ratio': String(normalizeDocumentImageLockAspectRatio(attributes.lockAspectRatio))
+                    })
+            }
+        };
+    },
+    addNodeView () {
+        const resize = this.options.resize;
+        if (false === resize || !resize.enabled || "u" < typeof document) return null;
+        const { directions, minWidth, minHeight, alwaysPreserveAspectRatio } = resize;
+        return ({ node, getPos, HTMLAttributes, editor })=>{
+            const element = document.createElement('img');
+            element.draggable = false;
+            applyInitialImageHtmlAttributes(element, HTMLAttributes);
+            element.style.visibility = 'hidden';
+            element.style.pointerEvents = 'none';
+            const reveal = ()=>{
+                element.style.visibility = '';
+                element.style.pointerEvents = '';
+            };
+            element.addEventListener('load', reveal);
+            element.addEventListener('error', reveal);
+            let container = null;
+            const sync = (updatedNode)=>{
+                syncDocumentImageNodeView(element, container, updatedNode.attrs);
+            };
+            const nodeView = new ResizableNodeView({
+                element,
+                editor,
+                node,
+                getPos,
+                onResize: (width, height)=>{
+                    element.style.width = `${width}px`;
+                    element.style.height = `${height}px`;
+                },
+                onCommit: (width, height)=>{
+                    const position = getPos();
+                    if (void 0 === position) return;
+                    editor.chain().setNodeSelection(position).updateAttributes(this.name, {
+                        width,
+                        height
+                    }).run();
+                },
+                onUpdate: (updatedNode)=>{
+                    if (updatedNode.type !== node.type) return false;
+                    if (!sameDocumentImageResizeConfiguration(node, updatedNode)) return false;
+                    sync(updatedNode);
+                    return true;
+                },
+                options: {
+                    directions,
+                    min: {
+                        width: minWidth,
+                        height: minHeight
+                    },
+                    preserveAspectRatio: null === node.attrs.lockAspectRatio || void 0 === node.attrs.lockAspectRatio ? true === alwaysPreserveAspectRatio : normalizeDocumentImageLockAspectRatio(node.attrs.lockAspectRatio)
+                }
+            });
+            container = nodeView.dom;
+            sync(node);
+            if (element.complete) reveal();
+            return nodeView;
+        };
+    }
+});
+function documentImageLayoutOptions(editor) {
+    const attributes = editor.getAttributes('image');
+    return normalizeDocumentImageLayoutOptions(attributes);
+}
+function documentImageProperties(editor) {
+    const attributes = editor.getAttributes('image');
+    return {
+        ...normalizeDocumentImageLayoutOptions(attributes),
+        width: normalizeDocumentImageDimension(attributes.width),
+        height: normalizeDocumentImageDimension(attributes.height),
+        lockAspectRatio: normalizeDocumentImageLockAspectRatio(attributes.lockAspectRatio),
+        alternativeText: documentImageAlternativeText(editor)
+    };
+}
+function documentImageAlternativeText(editor) {
+    if (!editor.isActive('image')) return '';
+    const attributes = editor.getAttributes('image');
+    const value = 'string' == typeof attributes.alt ? attributes.alt : 'string' == typeof attributes.title ? attributes.title : '';
+    return value.trim();
+}
+function documentImageLayoutFromElement(element) {
+    return normalizeDocumentImageLayoutOptions({
+        layout: element.getAttribute('data-office-image-layout'),
+        alignment: element.getAttribute('data-office-image-alignment'),
+        wrapDistance: element.getAttribute('data-office-image-wrap-distance')
+    });
+}
+function normalizeDocumentImageLayoutOptions(value) {
+    return {
+        layout: normalizeDocumentImageLayout(value.layout),
+        alignment: normalizeDocumentImageAlignment(value.alignment),
+        wrapDistance: normalizeDocumentImageWrapDistance(value.wrapDistance)
+    };
+}
+function normalizeDocumentImageLayout(value) {
+    return 'square' === value || 'topBottom' === value ? value : DEFAULT_IMAGE_LAYOUT;
+}
+function normalizeDocumentImageAlignment(value) {
+    return 'left' === value || 'right' === value ? value : DEFAULT_IMAGE_ALIGNMENT;
+}
+function normalizeDocumentImageWrapDistance(value) {
+    const number = 'number' == typeof value ? value : 'string' == typeof value && value.trim() ? Number(value) : DEFAULT_WRAP_DISTANCE_MILLIMETERS;
+    if (!Number.isFinite(number)) return DEFAULT_WRAP_DISTANCE_MILLIMETERS;
+    return Math.round(2 * Math.min(MAX_WRAP_DISTANCE_MILLIMETERS, Math.max(0, number))) / 2;
+}
+function normalizeDocumentImageDimension(value) {
+    if (null == value || '' === value) return null;
+    const number = 'number' == typeof value ? value : Number(value);
+    return Number.isFinite(number) && number > 0 ? Math.round(100 * number) / 100 : null;
+}
+function normalizeDocumentImageLockAspectRatio(value) {
+    return false === value || 'false' === value || 0 === value || '0' === value ? false : DEFAULT_LOCK_ASPECT_RATIO;
+}
+function formatImageLayoutNumber(value) {
+    return Number(value.toFixed(2)).toString();
+}
+function documentImageAttributesForChanges(value) {
+    const attributes = {};
+    if (Object.hasOwn(value, 'width')) attributes.width = normalizeDocumentImageDimension(value.width);
+    if (Object.hasOwn(value, 'height')) attributes.height = normalizeDocumentImageDimension(value.height);
+    if (Object.hasOwn(value, 'lockAspectRatio')) attributes.lockAspectRatio = normalizeDocumentImageLockAspectRatio(value.lockAspectRatio);
+    if (Object.hasOwn(value, 'layout')) attributes.layout = normalizeDocumentImageLayout(value.layout);
+    if (Object.hasOwn(value, 'alignment')) attributes.alignment = normalizeDocumentImageAlignment(value.alignment);
+    if (Object.hasOwn(value, 'wrapDistance')) attributes.wrapDistance = normalizeDocumentImageWrapDistance(value.wrapDistance);
+    if (Object.hasOwn(value, 'alternativeText')) {
+        const alternativeText = value.alternativeText?.trim() ?? '';
+        attributes.alt = alternativeText || null;
+        attributes.title = alternativeText || null;
+    }
+    return attributes;
+}
+function isDocumentImageSelection(selection) {
+    return selection instanceof NodeSelection && 'image' === selection.node.type.name;
+}
+function sameDocumentImageResizeConfiguration(initial, current) {
+    return normalizeDocumentImageDimension(initial.attrs.width) === normalizeDocumentImageDimension(current.attrs.width) && normalizeDocumentImageDimension(initial.attrs.height) === normalizeDocumentImageDimension(current.attrs.height) && normalizeDocumentImageLockAspectRatio(initial.attrs.lockAspectRatio) === normalizeDocumentImageLockAspectRatio(current.attrs.lockAspectRatio);
+}
+function applyInitialImageHtmlAttributes(element, attributes) {
+    const merged = mergeAttributes(attributes);
+    for (const [name, value] of Object.entries(merged))if (null != value && 'width' !== name && 'height' !== name) element.setAttribute(name, String(value));
+}
+function syncDocumentImageNodeView(element, container, attributes) {
+    const layout = normalizeDocumentImageLayout(attributes.layout);
+    const alignment = normalizeDocumentImageAlignment(attributes.alignment);
+    const wrapDistance = normalizeDocumentImageWrapDistance(attributes.wrapDistance);
+    const lockAspectRatio = normalizeDocumentImageLockAspectRatio(attributes.lockAspectRatio);
+    setOptionalImageAttribute(element, 'src', attributes.src);
+    setOptionalImageAttribute(element, 'alt', attributes.alt);
+    setOptionalImageAttribute(element, 'title', attributes.title);
+    element.dataset.officeImageLayout = layout;
+    element.dataset.officeImageAlignment = alignment;
+    element.dataset.officeImageWrapDistance = formatImageLayoutNumber(wrapDistance);
+    element.dataset.officeImageLockAspectRatio = String(lockAspectRatio);
+    element.style.setProperty('--work-document-image-wrap-distance', `${formatImageLayoutNumber(wrapDistance)}mm`);
+    syncImageDimension(element, 'width', attributes.width);
+    syncImageDimension(element, 'height', attributes.height);
+    if (!container) return;
+    container.dataset.officeImageLayout = layout;
+    container.dataset.officeImageAlignment = alignment;
+    container.dataset.officeImageWrapDistance = formatImageLayoutNumber(wrapDistance);
+    container.dataset.officeImageLockAspectRatio = String(lockAspectRatio);
+    container.style.setProperty('--work-document-image-wrap-distance', `${formatImageLayoutNumber(wrapDistance)}mm`);
+}
+function setOptionalImageAttribute(element, name, value) {
+    if ('string' == typeof value && value) element.setAttribute(name, value);
+    else element.removeAttribute(name);
+}
+function syncImageDimension(element, dimension, value) {
+    const pixels = 'number' == typeof value ? value : Number(value);
+    if (Number.isFinite(pixels) && pixels > 0) {
+        element.style[dimension] = `${pixels}px`;
+        element.setAttribute(dimension, String(Math.round(pixels)));
+        return;
+    }
+    element.style.removeProperty(dimension);
+    element.removeAttribute(dimension);
+}
+const MAX_DOCUMENT_TAB_POSITION_PX = 4096;
+const MAX_DOCUMENT_TAB_STOPS = 64;
+const DocumentParagraphTabStops = Extension.create({
+    name: 'documentParagraphTabStops',
+    addGlobalAttributes () {
+        return [
+            {
+                types: [
+                    'paragraph',
+                    'heading'
+                ],
+                attributes: {
+                    tabStops: {
+                        default: null,
+                        parseHTML: (element)=>normalizeDocumentTabStops(element.dataset.officeTabStops),
+                        renderHTML: (attributes)=>{
+                            const tabStops = normalizeDocumentTabStops(attributes.tabStops);
+                            return tabStops.length ? {
+                                'data-office-tab-stops': serializeDocumentTabStops(tabStops)
+                            } : {};
+                        }
+                    }
+                }
+            }
+        ];
+    },
+    addCommands () {
+        return {
+            setDocumentParagraphTabStops: (tabStops, options = {})=>({ chain, editor })=>{
+                    const nodeTypes = activeParagraphNodeTypes(editor);
+                    if (!nodeTypes.length) return false;
+                    const normalized = normalizeDocumentTabStops(tabStops);
+                    let commandChain = chain();
+                    if (false !== options.restoreFocus) commandChain = commandChain.focus();
+                    for (const nodeType of nodeTypes)commandChain = commandChain.updateAttributes(nodeType, {
+                        tabStops: normalized.length ? normalized : null
+                    });
+                    return commandChain.run();
+                }
+        };
+    }
+});
+function documentParagraphTabStops(editor) {
+    return normalizeDocumentTabStops(activeParagraphAttributes(editor).tabStops);
+}
+function normalizeDocumentTabStops(value) {
+    const source = parsedTabStopSource(value);
+    const byPosition = new Map();
+    for (const candidate of source.slice(0, 4 * MAX_DOCUMENT_TAB_STOPS)){
+        if (!isRecord(candidate)) continue;
+        const rawPosition = Number(candidate.position);
+        if (!Number.isFinite(rawPosition) || rawPosition <= 0) continue;
+        const position = normalizedTabPosition(rawPosition);
+        if (!(position <= 0)) byPosition.set(position, {
+            position,
+            alignment: normalizedTabAlignment(candidate.alignment),
+            leader: normalizedTabLeader(candidate.leader)
+        });
+    }
+    return Array.from(byPosition.values()).sort((left, right)=>left.position - right.position).slice(0, MAX_DOCUMENT_TAB_STOPS);
+}
+function serializeDocumentTabStops(value) {
+    return JSON.stringify(normalizeDocumentTabStops(value));
+}
+function normalizedTabPosition(value) {
+    if (!Number.isFinite(value)) return 0;
+    return Math.min(MAX_DOCUMENT_TAB_POSITION_PX, Math.max(0, Math.round(100 * value) / 100));
+}
+function nextDocumentTabAlignment(alignment) {
+    if ('left' === alignment) return 'center';
+    if ('center' === alignment) return 'right';
+    if ('right' === alignment) return 'decimal';
+    return 'left';
+}
+function parsedTabStopSource(value) {
+    if (Array.isArray(value)) return value;
+    if ('string' != typeof value || !value.trim()) return [];
+    try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed) ? parsed : [];
+    } catch  {
+        return [];
+    }
+}
+function normalizedTabAlignment(value) {
+    return 'center' === value || 'right' === value || 'decimal' === value ? value : 'left';
+}
+function normalizedTabLeader(value) {
+    return 'dot' === value || 'hyphen' === value || 'underscore' === value || 'middleDot' === value ? value : 'none';
+}
+function activeParagraphAttributes(editor) {
+    return editor.isActive('heading') ? editor.getAttributes('heading') : editor.getAttributes('paragraph');
+}
+function activeParagraphNodeTypes(editor) {
+    const types = [];
+    if (editor.isActive('paragraph')) types.push('paragraph');
+    if (editor.isActive('heading')) types.push('heading');
+    return types;
+}
+function isRecord(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+const BORDER_EDGES = [
+    'top',
+    'right',
+    'bottom',
+    'left'
+];
+function uniformDocumentTableBorders(border) {
+    return {
+        top: {
+            ...border
+        },
+        right: {
+            ...border
+        },
+        bottom: {
+            ...border
+        },
+        left: {
+            ...border
+        }
+    };
+}
+function documentTableBordersFromAttributes(attributes, fallback) {
+    const candidate = attributes.borders;
+    if (!candidate || 'object' != typeof candidate || Array.isArray(candidate)) return uniformDocumentTableBorders(fallback);
+    const record = candidate;
+    return {
+        top: normalizeDocumentTableBorder(record.top) ?? {
+            ...fallback
+        },
+        right: normalizeDocumentTableBorder(record.right) ?? {
+            ...fallback
+        },
+        bottom: normalizeDocumentTableBorder(record.bottom) ?? {
+            ...fallback
+        },
+        left: normalizeDocumentTableBorder(record.left) ?? {
+            ...fallback
+        }
+    };
+}
+function documentTableBordersFromElement(element, fallback) {
+    const uniform = documentTableBorderFromElement(element, fallback);
+    return {
+        top: documentTableEdgeFromElement(element, 'top', uniform),
+        right: documentTableEdgeFromElement(element, 'right', uniform),
+        bottom: documentTableEdgeFromElement(element, 'bottom', uniform),
+        left: documentTableEdgeFromElement(element, 'left', uniform)
+    };
+}
+function renderDocumentTableBorders(borders) {
+    const normalized = documentTableBordersFromAttributes({
+        borders
+    }, borders.top);
+    const representative = uniformDocumentTableBorder(normalized) ?? normalized.top;
+    const attributes = {
+        'data-office-cell-border-color': representative.color,
+        'data-office-cell-border-style': representative.style,
+        'data-office-cell-border-width': String(representative.width)
+    };
+    for (const edge of BORDER_EDGES){
+        const border = normalized[edge];
+        attributes[`data-office-cell-border-${edge}-color`] = border.color;
+        attributes[`data-office-cell-border-${edge}-style`] = border.style;
+        attributes[`data-office-cell-border-${edge}-width`] = String(border.width);
+    }
+    const uniform = uniformDocumentTableBorder(normalized);
+    attributes.style = uniform ? `border: ${documentTableBorderCss(uniform)}` : BORDER_EDGES.map((edge)=>`border-${edge}: ${documentTableBorderCss(normalized[edge])}`).join('; ');
+    return attributes;
+}
+function uniformDocumentTableBorder(borders) {
+    const first = borders.top;
+    return BORDER_EDGES.every((edge)=>sameDocumentTableBorder(borders[edge], first)) ? first : null;
+}
+function normalizeDocumentTableBorder(value) {
+    if (!value || 'object' != typeof value || Array.isArray(value)) return null;
+    const record = value;
+    const color = normalizeTableColor(String(record.color ?? ''));
+    const style = normalizeDocumentTableBorderStyle(String(record.style ?? ''));
+    const width = normalizeDocumentTableBorderWidth(record.width);
+    if (!color || !style || null === width) return null;
+    return {
+        color,
+        style,
+        width: 'none' === style ? 0 : width
+    };
+}
+function normalizeTableColor(value) {
+    const trimmed = value?.trim().toLowerCase();
+    if (!trimmed) return null;
+    if (/^#[0-9a-f]{3}$/.test(trimmed)) return `#${trimmed.slice(1).split('').map((part)=>`${part}${part}`).join('')}`;
+    if (/^#[0-9a-f]{6}$/.test(trimmed)) return trimmed;
+    const rgb = /^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/.exec(trimmed);
+    if (!rgb) return null;
+    const channels = rgb.slice(1, 4).map(Number);
+    if (channels.some((channel)=>channel < 0 || channel > 255)) return null;
+    return `#${channels.map((channel)=>channel.toString(16).padStart(2, '0')).join('')}`;
+}
+function normalizeDocumentTableBorderStyle(value) {
+    if ('solid' === value || 'dashed' === value || 'dotted' === value || 'double' === value || 'none' === value) return value;
+    return null;
+}
+function normalizeDocumentTableBorderWidth(value) {
+    const width = 'number' == typeof value ? value : Number.parseFloat(String(value ?? '').replace(/px$/i, ''));
+    if (!Number.isFinite(width) || width < 0 || width > 6) return null;
+    return Math.round(2 * width) / 2;
+}
+function setSelectedDocumentTableBorders({ dispatch, state }, target, requestedBorder) {
+    const border = normalizeDocumentTableBorder(requestedBorder);
+    const context = selectedTableBorderContext(state);
+    if (!border || !context) return false;
+    const transaction = state.tr;
+    const positions = context.map.cellsInRect(context.rectangle);
+    for (const relativePosition of positions){
+        const position = context.tableStart + relativePosition;
+        const cell = transaction.doc.nodeAt(position);
+        if (!cell || !isTableCell(cell)) continue;
+        const cellRectangle = context.map.findCell(relativePosition);
+        const edges = documentTableBorderTargetEdges(target, cellRectangle, context.rectangle);
+        if (!edges.length) continue;
+        const fallback = documentTableBorderFromAttributes(cell.attrs);
+        const borders = documentTableBordersFromAttributes(cell.attrs, fallback);
+        for (const edge of edges)borders[edge] = {
+            ...border
+        };
+        const representative = uniformDocumentTableBorder(borders) ?? borders.top;
+        transaction.setNodeMarkup(position, void 0, {
+            ...cell.attrs,
+            borderColor: representative.color,
+            borderStyle: representative.style,
+            borderWidth: representative.width,
+            borders
+        });
+    }
+    if (dispatch && transaction.docChanged) dispatch(transaction.scrollIntoView());
+    return true;
+}
+function selectedTableBorderContext(state) {
+    const selection = state.selection;
+    if (selection instanceof NodeSelection && 'table' === selection.node.type.spec.tableRole) {
+        const map = TableMap.get(selection.node);
+        return {
+            tableStart: selection.from + 1,
+            map,
+            rectangle: {
+                left: 0,
+                right: map.width,
+                top: 0,
+                bottom: map.height
+            }
+        };
+    }
+    if (!isInTable(state)) return null;
+    const rectangle = selectedRect(state);
+    return {
+        tableStart: rectangle.tableStart,
+        map: rectangle.map,
+        rectangle
+    };
+}
+function documentTableBorderTargetEdges(target, cell, selection) {
+    if ('all' === target) return [
+        ...BORDER_EDGES
+    ];
+    const edges = [];
+    const outside = 'outside' === target;
+    const inside = 'inside' === target;
+    if ('top' === target && cell.top === selection.top || outside && cell.top === selection.top || (inside || 'insideHorizontal' === target) && cell.top > selection.top) edges.push('top');
+    if ('right' === target && cell.right === selection.right || outside && cell.right === selection.right || (inside || 'insideVertical' === target) && cell.right < selection.right) edges.push('right');
+    if ('bottom' === target && cell.bottom === selection.bottom || outside && cell.bottom === selection.bottom || (inside || 'insideHorizontal' === target) && cell.bottom < selection.bottom) edges.push('bottom');
+    if ('left' === target && cell.left === selection.left || outside && cell.left === selection.left || (inside || 'insideVertical' === target) && cell.left > selection.left) edges.push('left');
+    return edges;
+}
+function documentTableBorderFromAttributes(attributes) {
+    return {
+        color: normalizeTableColor(String(attributes.borderColor ?? '')) ?? '#cfd5df',
+        style: normalizeDocumentTableBorderStyle(String(attributes.borderStyle ?? '')) ?? 'solid',
+        width: normalizeDocumentTableBorderWidth(attributes.borderWidth) ?? 1
+    };
+}
+function documentTableBorderFromElement(element, fallback) {
+    const style = normalizeDocumentTableBorderStyle(element.dataset.officeCellBorderStyle || element.style.borderStyle) ?? fallback.style;
+    return {
+        color: normalizeTableColor(element.dataset.officeCellBorderColor || element.style.borderColor) ?? fallback.color,
+        style,
+        width: 'none' === style ? 0 : normalizeDocumentTableBorderWidth(element.dataset.officeCellBorderWidth || element.style.borderWidth) ?? fallback.width
+    };
+}
+function documentTableEdgeFromElement(element, edge, fallback) {
+    const datasetPrefix = `officeCellBorder${capitalize(edge)}`;
+    const style = normalizeDocumentTableBorderStyle(element.dataset[`${datasetPrefix}Style`] || element.style.getPropertyValue(`border-${edge}-style`)) ?? fallback.style;
+    return {
+        color: normalizeTableColor(element.dataset[`${datasetPrefix}Color`] || element.style.getPropertyValue(`border-${edge}-color`)) ?? fallback.color,
+        style,
+        width: 'none' === style ? 0 : normalizeDocumentTableBorderWidth(element.dataset[`${datasetPrefix}Width`] || element.style.getPropertyValue(`border-${edge}-width`)) ?? fallback.width
+    };
+}
+function documentTableBorderCss(border) {
+    return 'none' === border.style || 0 === border.width ? '0px none transparent' : `${border.width}px ${border.style} ${border.color}`;
+}
+function sameDocumentTableBorder(left, right) {
+    return left.color === right.color && left.style === right.style && left.width === right.width;
+}
+function isTableCell(node) {
+    return 'cell' === node.type.spec.tableRole || 'header_cell' === node.type.spec.tableRole;
+}
+function capitalize(value) {
+    return `${value.slice(0, 1).toUpperCase()}${value.slice(1)}`;
+}
+const MAX_TABLE_SIZE = 100000;
+const MAX_CELL_MARGIN = 1000;
+const TABLE_MARGIN_DATASET_KEYS = {
+    top: 'officeTableCellMarginTop',
+    right: 'officeTableCellMarginRight',
+    bottom: 'officeTableCellMarginBottom',
+    left: 'officeTableCellMarginLeft'
+};
+const CELL_MARGIN_DATASET_KEYS = {
+    top: 'officeCellMarginTop',
+    right: 'officeCellMarginRight',
+    bottom: 'officeCellMarginBottom',
+    left: 'officeCellMarginLeft'
+};
+const TABLE_MARGIN_CSS_PROPERTIES = {
+    top: '--work-table-cell-margin-top',
+    right: '--work-table-cell-margin-right',
+    bottom: '--work-table-cell-margin-bottom',
+    left: '--work-table-cell-margin-left'
+};
+const CELL_PADDING_STYLE_PROPERTIES = {
+    top: 'paddingTop',
+    right: 'paddingRight',
+    bottom: 'paddingBottom',
+    left: 'paddingLeft'
+};
+const DEFAULT_DOCUMENT_TABLE_CELL_MARGINS = {
+    top: 0,
+    right: 7.2,
+    bottom: 0,
+    left: 7.2
+};
+const DEFAULT_DOCUMENT_TABLE_GEOMETRY = {
+    layout: 'autofit',
+    width: {
+        type: 'percent',
+        value: 100
+    },
+    alignment: 'left',
+    indent: 0,
+    cellMargins: DEFAULT_DOCUMENT_TABLE_CELL_MARGINS
+};
+function normalizeDocumentTableGeometry(value, legacyLayoutMode) {
+    if (!work_document_table_geometry_isRecord(value)) return geometryForLegacyLayoutMode(legacyLayoutMode);
+    const layout = normalizeDocumentTableLayoutAlgorithm(value.layout);
+    const width = normalizeDocumentTablePreferredWidth(value.width);
+    const alignment = normalizeDocumentTableAlignment(value.alignment);
+    const indent = normalizeDimension(value.indent, MAX_TABLE_SIZE);
+    const cellMargins = normalizeDocumentTableCellMargins(value.cellMargins);
+    return {
+        layout: layout ?? DEFAULT_DOCUMENT_TABLE_GEOMETRY.layout,
+        width: width ?? clonePreferredWidth(DEFAULT_DOCUMENT_TABLE_GEOMETRY.width),
+        alignment: alignment ?? DEFAULT_DOCUMENT_TABLE_GEOMETRY.alignment,
+        indent: indent ?? DEFAULT_DOCUMENT_TABLE_GEOMETRY.indent,
+        cellMargins: cellMargins ?? cloneCellMargins(DEFAULT_DOCUMENT_TABLE_CELL_MARGINS)
+    };
+}
+function normalizeDocumentTableLayoutMode(value) {
+    return 'contents' === value || 'fixed' === value ? value : 'window';
+}
+function normalizeDocumentTableLayoutAlgorithm(value) {
+    return 'autofit' === value || 'fixed' === value ? value : null;
+}
+function normalizeDocumentTableAlignment(value) {
+    return 'center' === value || 'right' === value || 'left' === value ? value : null;
+}
+function normalizeDocumentTableProperties(value) {
+    if (!work_document_table_geometry_isRecord(value)) return null;
+    const width = normalizeDocumentTablePreferredWidth(value.width);
+    const alignment = normalizeDocumentTableAlignment(value.alignment);
+    const indent = normalizeDimension(value.indent, MAX_TABLE_SIZE);
+    return width && alignment && null !== indent ? {
+        width,
+        alignment,
+        indent
+    } : null;
+}
+function normalizeDocumentTableCellMargins(value) {
+    if (!work_document_table_geometry_isRecord(value)) return null;
+    const margins = normalizeDocumentTableCellMarginOverrides(value);
+    if (!margins || !hasAllMarginSides(margins)) return null;
+    return margins;
+}
+function normalizeDocumentTableCellMarginOverrides(value) {
+    if (!work_document_table_geometry_isRecord(value)) return null;
+    const margins = {};
+    for (const side of marginSides()){
+        const normalized = normalizeDimension(value[side], MAX_CELL_MARGIN);
+        if (null !== normalized) margins[side] = normalized;
+    }
+    return Object.keys(margins).length ? margins : null;
+}
+function documentTableLayoutMode(geometry) {
+    if ('autofit' === geometry.layout && 'auto' === geometry.width.type) return 'contents';
+    if ('autofit' === geometry.layout && 'percent' === geometry.width.type && 100 === geometry.width.value) return 'window';
+    return 'fixed';
+}
+function documentTableGeometryForLayoutMode(mode, current, renderedTableWidth) {
+    if ('contents' === mode) return {
+        ...current,
+        layout: 'autofit',
+        width: {
+            type: 'auto',
+            value: null
+        }
+    };
+    if ('window' === mode) return {
+        ...current,
+        layout: 'autofit',
+        width: {
+            type: 'percent',
+            value: 100
+        }
+    };
+    const rendered = normalizePositiveDimension(renderedTableWidth, MAX_TABLE_SIZE);
+    return {
+        ...current,
+        layout: 'fixed',
+        width: rendered ? {
+            type: 'pixels',
+            value: rendered
+        } : 'pixels' === current.width.type ? clonePreferredWidth(current.width) : {
+            type: 'auto',
+            value: null
+        }
+    };
+}
+function documentTableGeometryFromElement(table) {
+    const rawLayout = table.dataset.officeTableLayout;
+    const exactLayout = normalizeDocumentTableLayoutAlgorithm(rawLayout);
+    const legacyMode = 'window' === rawLayout || 'contents' === rawLayout || 'fixed' === rawLayout ? rawLayout : void 0;
+    const width = preferredWidthFromElement(table, legacyMode);
+    const margins = tableCellMarginsFromElement(table);
+    const alignment = normalizeDocumentTableAlignment(table.dataset.officeTableAlignment);
+    const indent = normalizeDimension(table.dataset.officeTableIndent, MAX_TABLE_SIZE);
+    const hasGeometryAttributes = Boolean(rawLayout || table.dataset.officeTableWidthType || table.dataset.officeTableWidth || table.dataset.officeTableAlignment || table.dataset.officeTableIndent || margins);
+    if (!hasGeometryAttributes) return cloneGeometry(DEFAULT_DOCUMENT_TABLE_GEOMETRY);
+    return {
+        layout: exactLayout ?? ('fixed' === legacyMode ? 'fixed' : 'autofit'),
+        width,
+        alignment: alignment ?? DEFAULT_DOCUMENT_TABLE_GEOMETRY.alignment,
+        indent: indent ?? DEFAULT_DOCUMENT_TABLE_GEOMETRY.indent,
+        cellMargins: margins ?? cloneCellMargins(DEFAULT_DOCUMENT_TABLE_CELL_MARGINS)
+    };
+}
+function renderDocumentTableGeometry(value, legacyLayoutMode) {
+    const geometry = normalizeDocumentTableGeometry(value, legacyLayoutMode);
+    return {
+        'data-office-table-layout': geometry.layout,
+        'data-office-table-width-type': geometry.width.type,
+        ...null === geometry.width.value ? {} : {
+            'data-office-table-width': formatNumber(geometry.width.value)
+        },
+        'data-office-table-alignment': geometry.alignment,
+        'data-office-table-indent': formatNumber(geometry.indent),
+        'data-office-table-cell-margin-top': formatNumber(geometry.cellMargins.top),
+        'data-office-table-cell-margin-right': formatNumber(geometry.cellMargins.right),
+        'data-office-table-cell-margin-bottom': formatNumber(geometry.cellMargins.bottom),
+        'data-office-table-cell-margin-left': formatNumber(geometry.cellMargins.left),
+        style: documentTableGeometryStyle(geometry)
+    };
+}
+function applyDocumentTableGeometryToElement(table, value, legacyLayoutMode) {
+    const geometry = normalizeDocumentTableGeometry(value, legacyLayoutMode);
+    const rendered = renderDocumentTableGeometry(geometry);
+    for (const attributeName of tableGeometryAttributeNames())table.removeAttribute(attributeName);
+    for (const [name, attributeValue] of Object.entries(rendered))if ('style' !== name) table.setAttribute(name, attributeValue);
+    table.style.removeProperty('table-layout');
+    table.style.removeProperty('width');
+    table.style.removeProperty('margin-left');
+    table.style.removeProperty('margin-right');
+    for (const property of Object.values(TABLE_MARGIN_CSS_PROPERTIES))table.style.removeProperty(property);
+    for (const declaration of rendered.style.split(';').map((part)=>part.trim()).filter(Boolean)){
+        const separator = declaration.indexOf(':');
+        if (!(separator < 0)) table.style.setProperty(declaration.slice(0, separator).trim(), declaration.slice(separator + 1).trim());
+    }
+    if ('auto' !== geometry.width.type) table.style.removeProperty('min-width');
+}
+function documentTableCellMarginOverridesFromElement(cell) {
+    const margins = {};
+    for (const side of marginSides()){
+        const datasetValue = cell.dataset[CELL_MARGIN_DATASET_KEYS[side]];
+        const styleValue = cell.style[CELL_PADDING_STYLE_PROPERTIES[side]];
+        const normalized = normalizeDimension(datasetValue, MAX_CELL_MARGIN) ?? cssPixels(styleValue);
+        if (null !== normalized) margins[side] = normalized;
+    }
+    return Object.keys(margins).length ? margins : null;
+}
+function renderDocumentTableCellMarginOverrides(value) {
+    const margins = normalizeDocumentTableCellMarginOverrides(value);
+    if (!margins) return {};
+    const attributes = {};
+    const styles = [];
+    for (const side of marginSides()){
+        const margin = margins[side];
+        if (void 0 !== margin) {
+            attributes[`data-office-cell-margin-${side}`] = formatNumber(margin);
+            styles.push(`padding-${side}: ${formatNumber(margin)}px`);
+        }
+    }
+    return {
+        ...attributes,
+        style: styles.join('; ')
+    };
+}
+function preferredWidthFromElement(table, legacyMode) {
+    const type = normalizePreferredWidthType(table.dataset.officeTableWidthType);
+    const value = normalizePositiveDimension(table.dataset.officeTableWidth, MAX_TABLE_SIZE);
+    if ('auto' === type) return {
+        type,
+        value: null
+    };
+    if (type && null !== value) return {
+        type,
+        value
+    };
+    const styleWidth = cssPreferredWidth(table.style.width);
+    if (styleWidth) return styleWidth;
+    if ('contents' === legacyMode) return {
+        type: 'auto',
+        value: null
+    };
+    if ('fixed' === legacyMode) {
+        const columnWidth = firstRowColumnWidth(table);
+        return null === columnWidth ? {
+            type: 'auto',
+            value: null
+        } : {
+            type: 'pixels',
+            value: columnWidth
+        };
+    }
+    return clonePreferredWidth(DEFAULT_DOCUMENT_TABLE_GEOMETRY.width);
+}
+function tableCellMarginsFromElement(table) {
+    const margins = {};
+    for (const side of marginSides()){
+        const datasetValue = table.dataset[TABLE_MARGIN_DATASET_KEYS[side]];
+        const cssValue = table.style.getPropertyValue(TABLE_MARGIN_CSS_PROPERTIES[side]);
+        const normalized = normalizeDimension(datasetValue, MAX_CELL_MARGIN) ?? cssPixels(cssValue);
+        if (null !== normalized) margins[side] = normalized;
+    }
+    return hasAllMarginSides(margins) ? margins : null;
+}
+function documentTableGeometryStyle(geometry) {
+    const styles = [
+        `table-layout: ${'fixed' === geometry.layout ? 'fixed' : 'auto'}`
+    ];
+    if ('percent' === geometry.width.type && null !== geometry.width.value) styles.push(`width: ${formatNumber(geometry.width.value)}%`);
+    else if ('pixels' === geometry.width.type && null !== geometry.width.value) styles.push(`width: ${formatNumber(geometry.width.value)}px`);
+    if ('center' === geometry.alignment) styles.push('margin-left: auto', 'margin-right: auto');
+    else if ('right' === geometry.alignment) styles.push('margin-left: auto', 'margin-right: 0px');
+    else styles.push(`margin-left: ${formatNumber(geometry.indent)}px`, 'margin-right: auto');
+    for (const side of marginSides())styles.push(`${TABLE_MARGIN_CSS_PROPERTIES[side]}: ${formatNumber(geometry.cellMargins[side])}px`);
+    return styles.join('; ');
+}
+function geometryForLegacyLayoutMode(value) {
+    const mode = normalizeDocumentTableLayoutMode(value);
+    if ('contents' === mode) return {
+        ...cloneGeometry(DEFAULT_DOCUMENT_TABLE_GEOMETRY),
+        width: {
+            type: 'auto',
+            value: null
+        }
+    };
+    if ('fixed' === mode) return {
+        ...cloneGeometry(DEFAULT_DOCUMENT_TABLE_GEOMETRY),
+        layout: 'fixed',
+        width: {
+            type: 'auto',
+            value: null
+        }
+    };
+    return cloneGeometry(DEFAULT_DOCUMENT_TABLE_GEOMETRY);
+}
+function normalizeDocumentTablePreferredWidth(value) {
+    if (!work_document_table_geometry_isRecord(value)) return null;
+    const type = normalizePreferredWidthType(value.type);
+    if (!type) return null;
+    if ('auto' === type) return {
+        type,
+        value: null
+    };
+    const width = normalizePositiveDimension(value.value, MAX_TABLE_SIZE);
+    return null === width ? null : {
+        type,
+        value: width
+    };
+}
+function normalizePreferredWidthType(value) {
+    return 'auto' === value || 'percent' === value || 'pixels' === value ? value : null;
+}
+function normalizeDimension(value, maximum) {
+    const numeric = 'number' == typeof value ? value : 'string' == typeof value && value.trim() ? Number(value) : NaN;
+    if (!Number.isFinite(numeric) || numeric < 0 || numeric > maximum) return null;
+    return Math.round(100 * numeric) / 100;
+}
+function normalizePositiveDimension(value, maximum) {
+    const normalized = normalizeDimension(value, maximum);
+    return null !== normalized && normalized > 0 ? normalized : null;
+}
+function cssPixels(value) {
+    const match = /^(-?\d+(?:\.\d+)?)px$/i.exec(value.trim());
+    return match ? normalizeDimension(match[1], MAX_CELL_MARGIN) : null;
+}
+function cssPreferredWidth(value) {
+    const normalized = value.trim();
+    const percentage = /^(\d+(?:\.\d+)?)%$/.exec(normalized);
+    if (percentage) {
+        const width = normalizePositiveDimension(percentage[1], MAX_TABLE_SIZE);
+        return null === width ? null : {
+            type: 'percent',
+            value: width
+        };
+    }
+    const pixels = /^(\d+(?:\.\d+)?)px$/.exec(normalized);
+    if (pixels) {
+        const width = normalizePositiveDimension(pixels[1], MAX_TABLE_SIZE);
+        return null === width ? null : {
+            type: 'pixels',
+            value: width
+        };
+    }
+    return 'auto' === normalized ? {
+        type: 'auto',
+        value: null
+    } : null;
+}
+function firstRowColumnWidth(table) {
+    const row = table.querySelector('tr');
+    if (!row) return null;
+    let total = 0;
+    for (const cell of Array.from(row.querySelectorAll(':scope > th, :scope > td'))){
+        const raw = cell.getAttribute('colwidth');
+        if (!raw) return null;
+        const widths = raw.split(',').map((part)=>normalizePositiveDimension(part, MAX_TABLE_SIZE));
+        if (!widths.length || widths.some((width)=>null === width)) return null;
+        total += widths.reduce((sum, width)=>sum + Number(width), 0);
+    }
+    return total > 0 ? Math.round(100 * total) / 100 : null;
+}
+function tableGeometryAttributeNames() {
+    return [
+        'data-office-table-layout',
+        'data-office-table-width-type',
+        'data-office-table-width',
+        'data-office-table-alignment',
+        'data-office-table-indent',
+        ...marginSides().map((side)=>`data-office-table-cell-margin-${side}`)
+    ];
+}
+function marginSides() {
+    return [
+        'top',
+        'right',
+        'bottom',
+        'left'
+    ];
+}
+function hasAllMarginSides(value) {
+    return marginSides().every((side)=>void 0 !== value[side]);
+}
+function cloneGeometry(value) {
+    return {
+        ...value,
+        width: clonePreferredWidth(value.width),
+        cellMargins: cloneCellMargins(value.cellMargins)
+    };
+}
+function clonePreferredWidth(value) {
+    return {
+        ...value
+    };
+}
+function cloneCellMargins(value) {
+    return {
+        ...value
+    };
+}
+function formatNumber(value) {
+    return String(Math.round(100 * value) / 100);
+}
+function work_document_table_geometry_isRecord(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+export { DEFAULT_DOCUMENT_TABLE_CELL_MARGINS, DEFAULT_DOCUMENT_TABLE_GEOMETRY, DocumentImage, DocumentParagraphTabStops, applyDocumentTableGeometryToElement, documentImageLayoutFromElement, documentImageLayoutOptions, documentImageProperties, documentParagraphTabStops, documentTableBordersFromAttributes, documentTableBordersFromElement, documentTableCellMarginOverridesFromElement, documentTableGeometryForLayoutMode, documentTableGeometryFromElement, documentTableLayoutMode, nextDocumentTabAlignment, normalizeDocumentImageAlignment, normalizeDocumentImageLayoutOptions, normalizeDocumentTabStops, normalizeDocumentTableAlignment, normalizeDocumentTableBorderStyle, normalizeDocumentTableBorderWidth, normalizeDocumentTableCellMarginOverrides, normalizeDocumentTableCellMargins, normalizeDocumentTableGeometry, normalizeDocumentTableProperties, normalizeTableColor, normalizedTabPosition, renderDocumentTableBorders, renderDocumentTableCellMarginOverrides, renderDocumentTableGeometry, serializeDocumentTabStops, setSelectedDocumentTableBorders, uniformDocumentTableBorder, uniformDocumentTableBorders };