@a3s-lab/office 0.1.0

package/dist/0~7048.js

@@ -0,0 +1,2110 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useId, useRef, useState } from "react";
+import { Check, ChevronDown, ChevronUp } from "lucide-react";
+import { Dialog } from "./0~4595.js";
+import { button_Button, office_text_field_OfficeTextField, office_text_field_OfficeTextArea } from "./0~9512.js";
+function CollectionState({ children, icon, actions, tone = 'neutral', role, className = '' }) {
+    return /*#__PURE__*/ jsxs("div", {
+        className: `ds-collection-state ${tone}${className ? ` ${className}` : ''}`,
+        role: role,
+        children: [
+            icon && /*#__PURE__*/ jsx("span", {
+                className: "ds-collection-state-icon",
+                "aria-hidden": "true",
+                children: icon
+            }),
+            /*#__PURE__*/ jsx("span", {
+                children: children
+            }),
+            actions && /*#__PURE__*/ jsx("span", {
+                className: "ds-collection-state-actions",
+                children: actions
+            })
+        ]
+    });
+}
+const ACTIVE_OVERLAY_SELECTOR = '.ds-dialog-backdrop, .ds-popover.open, [role="menu"]';
+const ESCAPE_CONSUMER_SELECTOR = '[data-office-escape-consumer="true"]';
+const OFFICE_TASK_PANE_MODAL_QUERY = '(max-width: 900px)';
+function officeTaskPaneOwnsEscape(event) {
+    return 'Escape' === event.key && !event.defaultPrevented && !(event.target instanceof Element && event.target.closest(ESCAPE_CONSUMER_SELECTOR)) && !document.querySelector(ACTIVE_OVERLAY_SELECTOR);
+}
+function handleOfficeTaskPaneKeyDown(event, onClose) {
+    if (!officeTaskPaneOwnsEscape(event.nativeEvent)) return;
+    event.preventDefault();
+    event.stopPropagation();
+    onClose();
+}
+function useOfficeTaskPaneEscape(active, onClose) {
+    useEffect(()=>{
+        if (!active) return;
+        const closeFromEscape = (event)=>{
+            if (!officeTaskPaneOwnsEscape(event)) return;
+            event.preventDefault();
+            event.stopPropagation();
+            onClose();
+        };
+        document.addEventListener('keydown', closeFromEscape, true);
+        return ()=>document.removeEventListener('keydown', closeFromEscape, true);
+    }, [
+        active,
+        onClose
+    ]);
+}
+function useOfficeTaskPaneModal() {
+    const [matches, setMatches] = useState(officeTaskPaneModalMatches);
+    useEffect(()=>{
+        if ("u" < typeof window || 'function' != typeof window.matchMedia) return;
+        const mediaQuery = window.matchMedia(OFFICE_TASK_PANE_MODAL_QUERY);
+        const update = ()=>setMatches(mediaQuery.matches);
+        update();
+        if ('function' == typeof mediaQuery.addEventListener) {
+            mediaQuery.addEventListener('change', update);
+            return ()=>mediaQuery.removeEventListener('change', update);
+        }
+        mediaQuery.addListener(update);
+        return ()=>mediaQuery.removeListener(update);
+    }, []);
+    return matches;
+}
+function officeTaskPaneModalMatches() {
+    if ("u" < typeof window || 'function' != typeof window.matchMedia) return false;
+    return window.matchMedia(OFFICE_TASK_PANE_MODAL_QUERY).matches;
+}
+function useOfficeDialog() {
+    const [request, setRequest] = useState(null);
+    const sequence = useRef(0);
+    const promptResolver = useRef(null);
+    const noticeResolver = useRef(null);
+    const confirmResolver = useRef(null);
+    const invokerRef = useRef(null);
+    const releaseInvokerTimer = useRef(null);
+    const promptFieldId = useId();
+    const retainInvoker = useCallback(()=>{
+        if (null !== releaseInvokerTimer.current) window.clearTimeout(releaseInvokerTimer.current);
+        releaseInvokerTimer.current = null;
+        if (!invokerRef.current?.isConnected) invokerRef.current = document.activeElement instanceof HTMLElement ? document.activeElement : null;
+    }, []);
+    const releaseInvoker = useCallback(()=>{
+        if (null !== releaseInvokerTimer.current) window.clearTimeout(releaseInvokerTimer.current);
+        releaseInvokerTimer.current = window.setTimeout(()=>{
+            invokerRef.current = null;
+            releaseInvokerTimer.current = null;
+        }, 0);
+    }, []);
+    const closePrompt = useCallback((value)=>{
+        promptResolver.current?.(value);
+        promptResolver.current = null;
+        setRequest(null);
+        releaseInvoker();
+    }, [
+        releaseInvoker
+    ]);
+    const closeNotice = useCallback(()=>{
+        noticeResolver.current?.();
+        noticeResolver.current = null;
+        setRequest(null);
+        releaseInvoker();
+    }, [
+        releaseInvoker
+    ]);
+    const closeConfirm = useCallback((confirmed)=>{
+        confirmResolver.current?.(confirmed);
+        confirmResolver.current = null;
+        setRequest(null);
+        releaseInvoker();
+    }, [
+        releaseInvoker
+    ]);
+    const prompt = useCallback((options)=>new Promise((resolve)=>{
+            retainInvoker();
+            promptResolver.current?.(null);
+            noticeResolver.current?.();
+            confirmResolver.current?.(false);
+            promptResolver.current = resolve;
+            noticeResolver.current = null;
+            confirmResolver.current = null;
+            setRequest({
+                id: ++sequence.current,
+                kind: 'prompt',
+                title: options.title,
+                description: options.description,
+                value: options.initialValue ?? '',
+                fieldLabel: options.fieldLabel ?? options.title,
+                placeholder: options.placeholder,
+                multiline: options.multiline,
+                inputMode: options.inputMode,
+                confirmLabel: options.confirmLabel ?? '确定',
+                requiredMessage: true === options.required ? '请填写此项。' : 'string' == typeof options.required ? options.required : void 0,
+                validate: options.validate,
+                restoreFocusTarget: options.restoreFocusTarget,
+                touched: false
+            });
+        }), [
+        retainInvoker
+    ]);
+    const notice = useCallback((options)=>new Promise((resolve)=>{
+            retainInvoker();
+            promptResolver.current?.(null);
+            noticeResolver.current?.();
+            confirmResolver.current?.(false);
+            promptResolver.current = null;
+            noticeResolver.current = resolve;
+            confirmResolver.current = null;
+            setRequest({
+                id: ++sequence.current,
+                kind: 'notice',
+                title: options.title,
+                description: options.description,
+                confirmLabel: options.confirmLabel ?? '知道了',
+                restoreFocusTarget: options.restoreFocusTarget
+            });
+        }), [
+        retainInvoker
+    ]);
+    const confirm = useCallback((options)=>new Promise((resolve)=>{
+            retainInvoker();
+            promptResolver.current?.(null);
+            noticeResolver.current?.();
+            confirmResolver.current?.(false);
+            promptResolver.current = null;
+            noticeResolver.current = null;
+            confirmResolver.current = resolve;
+            setRequest({
+                id: ++sequence.current,
+                kind: 'confirm',
+                title: options.title,
+                description: options.description,
+                confirmLabel: options.confirmLabel ?? '继续',
+                cancelLabel: options.cancelLabel ?? '取消',
+                confirmTone: options.confirmTone ?? 'primary',
+                restoreFocusTarget: options.restoreFocusTarget
+            });
+        }), [
+        retainInvoker
+    ]);
+    useEffect(()=>()=>{
+            promptResolver.current?.(null);
+            noticeResolver.current?.();
+            confirmResolver.current?.(false);
+            if (null !== releaseInvokerTimer.current) window.clearTimeout(releaseInvokerTimer.current);
+        }, []);
+    const promptError = request?.kind === 'prompt' ? promptValidationMessage(request) : null;
+    const visiblePromptError = request?.kind === 'prompt' && request.touched ? promptError : null;
+    const submitPrompt = ()=>{
+        if (!request || 'prompt' !== request.kind) return;
+        if (promptValidationMessage(request)) return void setRequest({
+            ...request,
+            touched: true
+        });
+        closePrompt(request.value);
+    };
+    const dialog = request ? /*#__PURE__*/ jsx(Dialog, {
+        title: request.title,
+        description: request.description,
+        className: "work-office-dialog",
+        focusKey: request.id,
+        restoreFocusTarget: ()=>request.restoreFocusTarget?.() ?? invokerRef.current,
+        onClose: ()=>'prompt' === request.kind ? closePrompt(null) : 'confirm' === request.kind ? closeConfirm(false) : closeNotice(),
+        footer: 'prompt' === request.kind ? /*#__PURE__*/ jsxs(Fragment, {
+            children: [
+                /*#__PURE__*/ jsx(button_Button, {
+                    tone: "quiet",
+                    onClick: ()=>closePrompt(null),
+                    children: "取消"
+                }),
+                /*#__PURE__*/ jsx(button_Button, {
+                    tone: "primary",
+                    disabled: Boolean(promptError),
+                    onClick: submitPrompt,
+                    children: request.confirmLabel
+                })
+            ]
+        }) : 'confirm' === request.kind ? /*#__PURE__*/ jsxs(Fragment, {
+            children: [
+                /*#__PURE__*/ jsx(button_Button, {
+                    tone: "quiet",
+                    onClick: ()=>closeConfirm(false),
+                    children: request.cancelLabel
+                }),
+                /*#__PURE__*/ jsx(button_Button, {
+                    tone: request.confirmTone,
+                    onClick: ()=>closeConfirm(true),
+                    children: request.confirmLabel
+                })
+            ]
+        }) : /*#__PURE__*/ jsx(button_Button, {
+            tone: "primary",
+            onClick: closeNotice,
+            children: request.confirmLabel
+        }),
+        children: 'prompt' === request.kind && /*#__PURE__*/ jsxs("label", {
+            className: "work-office-dialog-field",
+            htmlFor: promptFieldId,
+            children: [
+                /*#__PURE__*/ jsx("span", {
+                    className: "work-office-dialog-field-label",
+                    children: request.fieldLabel
+                }),
+                request.multiline ? /*#__PURE__*/ jsx(office_text_field_OfficeTextArea, {
+                    id: promptFieldId,
+                    "aria-label": request.fieldLabel,
+                    "aria-invalid": Boolean(visiblePromptError) || void 0,
+                    value: request.value,
+                    placeholder: request.placeholder,
+                    onChange: (event)=>setRequest({
+                            ...request,
+                            value: event.target.value,
+                            touched: true
+                        }),
+                    onBlur: ()=>setRequest({
+                            ...request,
+                            touched: true
+                        }),
+                    onKeyDown: (event)=>{
+                        if ('Enter' === event.key && (event.metaKey || event.ctrlKey)) {
+                            event.preventDefault();
+                            submitPrompt();
+                        }
+                    }
+                }) : /*#__PURE__*/ jsx(office_text_field_OfficeTextField, {
+                    id: promptFieldId,
+                    "aria-label": request.fieldLabel,
+                    "aria-invalid": Boolean(visiblePromptError) || void 0,
+                    value: request.value,
+                    inputMode: request.inputMode,
+                    placeholder: request.placeholder,
+                    onChange: (event)=>setRequest({
+                            ...request,
+                            value: event.target.value,
+                            touched: true
+                        }),
+                    onBlur: ()=>setRequest({
+                            ...request,
+                            touched: true
+                        }),
+                    onKeyDown: (event)=>{
+                        if ('Enter' === event.key) {
+                            event.preventDefault();
+                            submitPrompt();
+                        }
+                    }
+                }),
+                visiblePromptError && /*#__PURE__*/ jsx("span", {
+                    className: "work-office-dialog-field-error",
+                    role: "alert",
+                    children: visiblePromptError
+                })
+            ]
+        })
+    }, request.id) : null;
+    return {
+        prompt,
+        notice,
+        confirm,
+        dialog
+    };
+}
+function promptValidationMessage(request) {
+    if (!request.value.trim() && request.requiredMessage) return request.requiredMessage;
+    return request.validate?.(request.value) ?? null;
+}
+function OfficeNumberField({ ariaLabel, value, onValueChange, onCommit, onCancel, min, max, step = 1, disabled = false, className = '', placeholder, escapeConsumer = false, validationInvalid = false }) {
+    const commitInProgressRef = useRef(false);
+    const numericValue = '' === value ? null : Number(value);
+    const invalid = validationInvalid || null !== numericValue && (!Number.isFinite(numericValue) || void 0 !== min && numericValue < min || void 0 !== max && numericValue > max);
+    const changeBy = (direction)=>{
+        const current = Number(value);
+        const fallback = min ?? 0;
+        const next = clampNumber(Number.isFinite(current) ? current + step * direction : fallback, min, max);
+        const formatted = formatSteppedNumber(next, step);
+        onValueChange(formatted);
+        onCommit?.(formatted);
+    };
+    return /*#__PURE__*/ jsxs("div", {
+        className: `work-office-number-field ${className}`.trim(),
+        children: [
+            /*#__PURE__*/ jsx("input", {
+                type: "text",
+                inputMode: "decimal",
+                "aria-label": ariaLabel,
+                "aria-invalid": invalid || void 0,
+                "data-office-escape-consumer": escapeConsumer || void 0,
+                value: value,
+                disabled: disabled,
+                placeholder: placeholder,
+                onChange: (event)=>onValueChange(event.target.value),
+                onBlur: (event)=>{
+                    if (commitInProgressRef.current) return;
+                    onCommit?.(event.currentTarget.value);
+                },
+                onKeyDown: (event)=>{
+                    if ('ArrowUp' === event.key) {
+                        event.preventDefault();
+                        changeBy(1);
+                    } else if ('ArrowDown' === event.key) {
+                        event.preventDefault();
+                        changeBy(-1);
+                    } else if ('Enter' === event.key && onCommit && !event.nativeEvent.isComposing) {
+                        event.preventDefault();
+                        event.stopPropagation();
+                        commitInProgressRef.current = true;
+                        try {
+                            onCommit(event.currentTarget.value);
+                        } finally{
+                            commitInProgressRef.current = false;
+                        }
+                    } else if ('Escape' === event.key && escapeConsumer && onCancel) {
+                        event.preventDefault();
+                        event.stopPropagation();
+                        onCancel();
+                    }
+                }
+            }),
+            /*#__PURE__*/ jsxs("span", {
+                className: "work-office-number-steppers",
+                children: [
+                    /*#__PURE__*/ jsx("button", {
+                        type: "button",
+                        "aria-label": `增加${ariaLabel}`,
+                        disabled: disabled,
+                        onMouseDown: (event)=>event.preventDefault(),
+                        onClick: ()=>changeBy(1),
+                        children: /*#__PURE__*/ jsx(ChevronUp, {
+                            size: 10
+                        })
+                    }),
+                    /*#__PURE__*/ jsx("button", {
+                        type: "button",
+                        "aria-label": `减少${ariaLabel}`,
+                        disabled: disabled,
+                        onMouseDown: (event)=>event.preventDefault(),
+                        onClick: ()=>changeBy(-1),
+                        children: /*#__PURE__*/ jsx(ChevronDown, {
+                            size: 10
+                        })
+                    })
+                ]
+            })
+        ]
+    });
+}
+function CommittedOfficeNumberField({ value, normalizeValue, onValueCommit, formatValue = defaultNumberFormat, ...fieldProps }) {
+    const controlledDraft = void 0 === value ? '' : formatValue(value);
+    const [draft, setDraft] = useState(controlledDraft);
+    const normalizedDraft = safelyNormalizeOfficeNumberDraft(normalizeValue, draft);
+    useEffect(()=>setDraft(controlledDraft), [
+        controlledDraft
+    ]);
+    const commit = (rawValue)=>{
+        const normalized = safelyNormalizeOfficeNumberDraft(normalizeValue, rawValue);
+        if (null === normalized || void 0 !== normalized && !Number.isFinite(normalized)) return void setDraft(controlledDraft);
+        const normalizedDraft = void 0 === normalized ? '' : formatValue(normalized);
+        setDraft(normalizedDraft);
+        if (!Object.is(normalized, value)) onValueCommit(normalized);
+    };
+    return /*#__PURE__*/ jsx(OfficeNumberField, {
+        ...fieldProps,
+        escapeConsumer: draft !== controlledDraft,
+        validationInvalid: null === normalizedDraft,
+        value: draft,
+        onValueChange: setDraft,
+        onCommit: commit,
+        onCancel: ()=>setDraft(controlledDraft)
+    });
+}
+function clampNumber(value, min, max) {
+    return Math.min(max ?? 1 / 0, Math.max(min ?? -1 / 0, value));
+}
+function formatSteppedNumber(value, step) {
+    const decimalPlaces = Math.max(0, (String(step).split('.')[1] ?? '').length);
+    return 0 === decimalPlaces ? String(Math.round(value)) : value.toFixed(decimalPlaces).replace(/\.?0+$/, '');
+}
+function defaultNumberFormat(value) {
+    return String(value);
+}
+function safelyNormalizeOfficeNumberDraft(normalizeValue, draft) {
+    try {
+        return normalizeValue(draft);
+    } catch  {
+        return null;
+    }
+}
+function OfficeCheckbox({ ariaLabel, checked, onCheckedChange, children, disabled = false, className = '' }) {
+    return /*#__PURE__*/ jsxs("label", {
+        className: `work-office-checkbox ${checked ? 'checked' : ''} ${disabled ? 'disabled' : ''} ${className}`.trim(),
+        children: [
+            /*#__PURE__*/ jsx("input", {
+                type: "checkbox",
+                "aria-label": ariaLabel,
+                checked: checked,
+                disabled: disabled,
+                onChange: (event)=>onCheckedChange(event.target.checked)
+            }),
+            /*#__PURE__*/ jsx("span", {
+                className: "work-office-checkbox-box",
+                "aria-hidden": "true",
+                children: checked && /*#__PURE__*/ jsx(Check, {
+                    size: 11
+                })
+            }),
+            /*#__PURE__*/ jsx("span", {
+                className: "work-office-checkbox-label",
+                children: children
+            })
+        ]
+    });
+}
+const officeFontFamilies = [
+    {
+        id: 'microsoft-yahei',
+        name: 'Microsoft YaHei',
+        cssValue: '"Microsoft YaHei"',
+        cssFamily: '"Microsoft YaHei", "PingFang SC", sans-serif',
+        label: '微软雅黑',
+        group: '中文字体'
+    },
+    {
+        id: 'pingfang-sc',
+        name: 'PingFang SC',
+        cssValue: '"PingFang SC"',
+        cssFamily: '"PingFang SC", "Microsoft YaHei", sans-serif',
+        label: '苹方',
+        group: '中文字体'
+    },
+    {
+        id: 'simsun',
+        name: 'SimSun',
+        cssValue: 'SimSun',
+        cssFamily: 'SimSun, "Songti SC", serif',
+        label: '宋体',
+        group: '中文字体'
+    },
+    {
+        id: 'stsong',
+        name: 'STSong',
+        cssValue: 'STSong',
+        cssFamily: 'STSong, "Songti SC", SimSun, serif',
+        label: '华文宋体',
+        group: '中文字体'
+    },
+    {
+        id: 'simhei',
+        name: 'SimHei',
+        cssValue: 'SimHei',
+        cssFamily: 'SimHei, "Heiti SC", sans-serif',
+        label: '黑体',
+        group: '中文字体'
+    },
+    {
+        id: 'stheiti',
+        name: 'STHeiti',
+        cssValue: 'STHeiti',
+        cssFamily: 'STHeiti, "Heiti SC", SimHei, sans-serif',
+        label: '华文黑体',
+        group: '中文字体'
+    },
+    {
+        id: 'kaiti',
+        name: 'KaiTi',
+        cssValue: 'KaiTi',
+        cssFamily: 'KaiTi, "Kaiti SC", serif',
+        label: '楷体',
+        group: '中文字体'
+    },
+    {
+        id: 'fangsong',
+        name: 'FangSong',
+        cssValue: 'FangSong',
+        cssFamily: 'FangSong, STFangsong, serif',
+        label: '仿宋',
+        group: '中文字体'
+    },
+    {
+        id: 'hiragino-sans-gb',
+        name: 'Hiragino Sans GB',
+        cssValue: '"Hiragino Sans GB"',
+        cssFamily: '"Hiragino Sans GB", "PingFang SC", sans-serif',
+        label: '冬青黑体',
+        group: '中文字体'
+    },
+    {
+        id: 'aptos',
+        name: 'Aptos',
+        cssValue: 'Aptos',
+        cssFamily: 'Aptos, sans-serif',
+        label: 'Aptos',
+        group: '西文字体'
+    },
+    {
+        id: 'calibri',
+        name: 'Calibri',
+        cssValue: 'Calibri',
+        cssFamily: 'Calibri',
+        label: 'Calibri',
+        group: '西文字体'
+    },
+    {
+        id: 'arial',
+        name: 'Arial',
+        cssValue: 'Arial',
+        cssFamily: 'Arial, sans-serif',
+        label: 'Arial',
+        group: '西文字体'
+    },
+    {
+        id: 'helvetica',
+        name: 'Helvetica',
+        cssValue: 'Helvetica',
+        cssFamily: 'Helvetica, Arial, sans-serif',
+        label: 'Helvetica',
+        group: '西文字体'
+    },
+    {
+        id: 'times-new-roman',
+        name: 'Times New Roman',
+        cssValue: '"Times New Roman"',
+        cssFamily: '"Times New Roman", Times, serif',
+        label: 'Times New Roman',
+        group: '西文字体'
+    },
+    {
+        id: 'georgia',
+        name: 'Georgia',
+        cssValue: 'Georgia',
+        cssFamily: 'Georgia, "Times New Roman", serif',
+        label: 'Georgia',
+        group: '西文字体'
+    },
+    {
+        id: 'cambria',
+        name: 'Cambria',
+        cssValue: 'Cambria',
+        cssFamily: 'Cambria, Georgia, serif',
+        label: 'Cambria',
+        group: '西文字体'
+    },
+    {
+        id: 'garamond',
+        name: 'Garamond',
+        cssValue: 'Garamond',
+        cssFamily: 'Garamond, Georgia, serif',
+        label: 'Garamond',
+        group: '西文字体'
+    },
+    {
+        id: 'verdana',
+        name: 'Verdana',
+        cssValue: 'Verdana',
+        cssFamily: 'Verdana, Arial, sans-serif',
+        label: 'Verdana',
+        group: '西文字体'
+    },
+    {
+        id: 'tahoma',
+        name: 'Tahoma',
+        cssValue: 'Tahoma',
+        cssFamily: 'Tahoma, Verdana, sans-serif',
+        label: 'Tahoma',
+        group: '西文字体'
+    },
+    {
+        id: 'trebuchet-ms',
+        name: 'Trebuchet MS',
+        cssValue: '"Trebuchet MS"',
+        cssFamily: '"Trebuchet MS", Arial, sans-serif',
+        label: 'Trebuchet MS',
+        group: '西文字体'
+    },
+    {
+        id: 'sf-mono',
+        name: 'SFMono-Regular',
+        cssValue: 'SFMono-Regular',
+        cssFamily: 'SFMono-Regular, Menlo, Consolas, monospace',
+        label: 'SF Mono',
+        group: '等宽字体'
+    },
+    {
+        id: 'menlo',
+        name: 'Menlo',
+        cssValue: 'Menlo',
+        cssFamily: 'Menlo, SFMono-Regular, Consolas, monospace',
+        label: 'Menlo',
+        group: '等宽字体'
+    },
+    {
+        id: 'consolas',
+        name: 'Consolas',
+        cssValue: 'Consolas',
+        cssFamily: 'Consolas, "Courier New", monospace',
+        label: 'Consolas',
+        group: '等宽字体'
+    },
+    {
+        id: 'courier-new',
+        name: 'Courier New',
+        cssValue: '"Courier New"',
+        cssFamily: '"Courier New", Courier, monospace',
+        label: 'Courier New',
+        group: '等宽字体'
+    },
+    {
+        id: 'monaco',
+        name: 'Monaco',
+        cssValue: 'Monaco',
+        cssFamily: 'Monaco, Menlo, Consolas, monospace',
+        label: 'Monaco',
+        group: '等宽字体'
+    }
+];
+function officeFontFamilyLabel(value) {
+    const firstFamily = value.split(',')[0]?.trim() || value.trim();
+    return firstFamily.replace(/^(['"])(.*)\1$/, '$2');
+}
+function normalizeOfficeFontFamily(value) {
+    return officeFontFamilyLabel(value).toLocaleLowerCase();
+}
+const MAX_LAYOUT_BLOCKS = 10000;
+const MAX_LAYOUT_EXTENT = 1000000;
+const MAX_LAYOUT_PAGE_INDEX = 1000000;
+function layoutOfficeDocumentInJavaScript(request) {
+    validateLayoutRequest(request);
+    const availableHeight = Math.max(1, request.page.height - request.page.marginTop - request.page.marginBottom);
+    const pages = [
+        emptyPage(request.startPageIndex, availableHeight)
+    ];
+    let index = 0;
+    while(index < request.blocks.length){
+        const block = request.blocks[index];
+        if (void 0 !== block.flowCount) {
+            const end = index + block.flowCount;
+            layoutFlow(request.blocks.slice(index, end), request.blocks.slice(end), pages, availableHeight, end < request.blocks.length);
+            index = end;
+        } else {
+            layoutSingleBlock(block, request.blocks.slice(index + 1), pages, availableHeight, index + 1 < request.blocks.length);
+            index += 1;
+        }
+    }
+    if (pages.length > 1 && pages.at(-1)?.placements.length === 0) pages.pop();
+    return {
+        protocol: 15,
+        kind: 'layoutResult',
+        requestId: request.requestId,
+        revision: request.revision,
+        documentRevision: request.documentRevision,
+        startPageIndex: request.startPageIndex,
+        engine: "javascript",
+        pages,
+        breaks: layoutBreaks(pages, request)
+    };
+}
+function validateLayoutRequest(request) {
+    if (15 !== request.protocol) throw kernelError('office.kernel.protocol_unsupported', `Office kernel protocol ${request.protocol} is unsupported.`);
+    if ('layout' !== request.kind) throw kernelError('office.kernel.request_kind_invalid', 'The Office kernel only accepts layout requests at this boundary.');
+    if (!Number.isSafeInteger(request.requestId) || request.requestId < 0 || !Number.isSafeInteger(request.revision) || request.revision < 0 || !Number.isSafeInteger(request.documentRevision) || request.documentRevision < 0 || !Number.isSafeInteger(request.startPageIndex) || request.startPageIndex < 0) throw kernelError('office.kernel.revision_invalid', 'Request, layout, and document revisions must be non-negative safe integers.');
+    if (request.startPageIndex > MAX_LAYOUT_PAGE_INDEX) throw kernelError('office.kernel.page_index_invalid', `startPageIndex may not exceed ${MAX_LAYOUT_PAGE_INDEX}.`);
+    if (request.blocks.length > MAX_LAYOUT_BLOCKS) throw kernelError('office.kernel.block_limit_exceeded', `A layout request may contain at most ${MAX_LAYOUT_BLOCKS} blocks.`);
+    for (const [name, value] of Object.entries(request.page))validateExtent(`page.${name}`, value);
+    if (request.page.width <= request.page.marginLeft + request.page.marginRight) throw kernelError('office.kernel.page_width_invalid', 'Page width must be greater than its horizontal margins.');
+    if (request.page.height <= request.page.marginTop + request.page.marginBottom) throw kernelError('office.kernel.page_height_invalid', 'Page height must leave a positive body area.');
+    const blockIds = new Set();
+    for (const block of request.blocks){
+        if (!block.id.trim() || block.id.length > 256) throw kernelError('office.kernel.block_id_invalid', 'Every layout block requires a non-empty ID of at most 256 bytes.');
+        if (blockIds.has(block.id)) throw kernelError('office.kernel.block_id_duplicate', `Layout block ID '${block.id}' is duplicated.`);
+        blockIds.add(block.id);
+        validateExtent('block.height', block.height);
+        validateFlowMetadata(block);
+    }
+    validateFlowSequences(request.blocks);
+}
+function layoutSingleBlock(block, next, pages, availableHeight, hasMoreBlocks) {
+    let current = pages.at(-1);
+    let currentHasContent = current.placements.length > 0;
+    if (block.breakBefore && currentHasContent) {
+        current = emptyPage(nextPageIndex(pages), availableHeight);
+        pages.push(current);
+        currentHasContent = false;
+    }
+    const remaining = Math.max(0, availableHeight - current.usedHeight);
+    const nextHeight = nextBlockPreviewHeight(next);
+    const groupedHeight = block.height + (block.keepWithNext ? nextHeight : 0);
+    const shouldAdvance = currentHasContent && (block.height > remaining || (block.keepTogether || block.keepWithNext) && groupedHeight <= availableHeight && groupedHeight > remaining);
+    if (shouldAdvance) {
+        current = emptyPage(nextPageIndex(pages), availableHeight);
+        pages.push(current);
+    }
+    placeFragment(block, current, availableHeight);
+    if (block.breakAfter && hasMoreBlocks) pages.push(emptyPage(nextPageIndex(pages), availableHeight));
+}
+function layoutFlow(blocks, next, pages, availableHeight, hasMoreBlocks) {
+    const first = blocks[0];
+    const last = blocks.at(-1);
+    if (first.breakBefore && pages.at(-1)?.placements.length) pages.push(emptyPage(nextPageIndex(pages), availableHeight));
+    const totalHeight = fragmentHeight(blocks, 0, blocks.length);
+    const nextHeight = last.keepWithNext ? nextBlockPreviewHeight(next) : 0;
+    let current = pages.at(-1);
+    const repeatHeaderCount = first.repeatHeaderCount ?? 0;
+    const repeatHeaderHeight = first.repeatHeaderHeight ?? 0;
+    const groupedHeight = totalHeight + nextHeight;
+    if (first.keepTogether && current.placements.length && groupedHeight <= availableHeight && groupedHeight > Math.max(0, availableHeight - current.usedHeight)) {
+        current = emptyPage(nextPageIndex(pages), availableHeight);
+        pages.push(current);
+    }
+    if (repeatHeaderCount > 0 && repeatHeaderCount < blocks.length) {
+        const leadingHeight = fragmentHeight(blocks, 0, repeatHeaderCount + 1);
+        const remainingHeight = Math.max(0, availableHeight - current.usedHeight);
+        if (current.placements.length > 0 && leadingHeight <= availableHeight && leadingHeight > remainingHeight) {
+            current = emptyPage(nextPageIndex(pages), availableHeight);
+            pages.push(current);
+        }
+    }
+    const minimum = Math.max(1, first.minimumFragmentsPerPage ?? 1);
+    let cursor = 0;
+    while(cursor < blocks.length){
+        current = pages.at(-1);
+        if (cursor >= repeatHeaderCount && cursor > 0 && repeatHeaderHeight > 0 && 0 === current.placements.length && 0 === current.usedHeight) current.usedHeight = repeatHeaderHeight;
+        const currentHasContent = current.placements.length > 0;
+        const remainingHeight = Math.max(0, availableHeight - current.usedHeight);
+        const remainingFragments = blocks.length - cursor;
+        const remainingFlowHeight = fragmentHeight(blocks, cursor, blocks.length);
+        if (nextHeight > 0 && currentHasContent && remainingFlowHeight <= remainingHeight && remainingFlowHeight + nextHeight > remainingHeight && remainingFlowHeight + nextHeight <= availableHeight) {
+            pages.push(emptyPage(nextPageIndex(pages), availableHeight));
+            continue;
+        }
+        let fitting = fragmentsFitting(blocks, cursor, blocks.length, remainingHeight);
+        if (fitting === remainingFragments) {
+            placeFragments(blocks, cursor, blocks.length, current, availableHeight);
+            cursor = blocks.length;
+            continue;
+        }
+        if (0 === fitting) {
+            if (currentHasContent) {
+                pages.push(emptyPage(nextPageIndex(pages), availableHeight));
+                continue;
+            }
+            fitting = 1;
+        }
+        if (remainingFragments > minimum) fitting = Math.min(fitting, remainingFragments - minimum);
+        const minimumHere = Math.min(minimum, remainingFragments);
+        if (fitting < minimumHere && currentHasContent) {
+            pages.push(emptyPage(nextPageIndex(pages), availableHeight));
+            continue;
+        }
+        fitting = Math.max(1, fitting);
+        placeFragments(blocks, cursor, cursor + fitting, current, availableHeight);
+        cursor += fitting;
+        if (cursor < blocks.length) pages.push(emptyPage(nextPageIndex(pages), availableHeight));
+    }
+    if (last.breakAfter && hasMoreBlocks) pages.push(emptyPage(nextPageIndex(pages), availableHeight));
+}
+function nextBlockPreviewHeight(blocks) {
+    const first = blocks[0];
+    if (!first || first.breakBefore) return 0;
+    const count = Math.min(2, first.flowCount ?? 1);
+    return fragmentHeight(blocks, 0, count);
+}
+function fragmentsFitting(blocks, start, end, availableHeight) {
+    let used = 0;
+    let count = 0;
+    for(let index = start; index < end; index += 1){
+        const block = blocks[index];
+        if (used + block.height > availableHeight) break;
+        used += block.height;
+        count += 1;
+    }
+    return count;
+}
+function placeFragments(blocks, start, end, page, availableHeight) {
+    for(let index = start; index < end; index += 1)placeFragment(blocks[index], page, availableHeight);
+}
+function fragmentHeight(blocks, start, end) {
+    let height = 0;
+    for(let index = start; index < end; index += 1)height += blocks[index].height;
+    return height;
+}
+function placeFragment(block, page, availableHeight) {
+    const y = page.usedHeight;
+    page.placements.push({
+        blockId: block.id,
+        y,
+        height: block.height,
+        overflow: block.height > availableHeight || y + block.height > availableHeight
+    });
+    page.usedHeight += block.height;
+}
+function validateFlowMetadata(block) {
+    const values = [
+        block.flowId,
+        block.flowIndex,
+        block.flowCount,
+        block.minimumFragmentsPerPage
+    ];
+    const repeatValues = [
+        block.repeatHeaderCount,
+        block.repeatHeaderHeight
+    ];
+    if (values.every((value)=>void 0 === value) && repeatValues.every((value)=>void 0 === value)) return;
+    if (values.some((value)=>void 0 === value)) throw kernelError('office.kernel.flow_metadata_incomplete', 'Flow metadata requires flowId, flowIndex, flowCount, and minimumFragmentsPerPage.');
+    if ('string' != typeof block.flowId || !block.flowId.trim() || block.flowId.length > 256) throw kernelError('office.kernel.flow_id_invalid', 'Every layout flow requires a non-empty ID of at most 256 bytes.');
+    if (!Number.isSafeInteger(block.flowIndex) || !Number.isSafeInteger(block.flowCount) || block.flowCount <= 0 || block.flowIndex < 0 || block.flowIndex >= block.flowCount) throw kernelError('office.kernel.flow_index_invalid', 'Flow indices must be within a non-empty flow.');
+    if (!Number.isSafeInteger(block.minimumFragmentsPerPage) || block.minimumFragmentsPerPage <= 0 || block.minimumFragmentsPerPage > block.flowCount) throw kernelError('office.kernel.flow_minimum_invalid', 'minimumFragmentsPerPage must be within the flow fragment count.');
+    if (repeatValues.every((value)=>void 0 === value)) return;
+    if (repeatValues.some((value)=>void 0 === value)) throw kernelError('office.kernel.repeat_header_metadata_incomplete', 'Repeated table headers require repeatHeaderCount and repeatHeaderHeight.');
+    if (!Number.isSafeInteger(block.repeatHeaderCount) || block.repeatHeaderCount <= 0 || block.repeatHeaderCount >= block.flowCount) throw kernelError('office.kernel.repeat_header_count_invalid', 'repeatHeaderCount must identify a non-empty header before the body rows.');
+    validateExtent('block.repeatHeaderHeight', block.repeatHeaderHeight);
+    if (block.repeatHeaderHeight <= 0) throw kernelError('office.kernel.repeat_header_height_invalid', 'repeatHeaderHeight must be greater than zero.');
+}
+function validateFlowSequences(blocks) {
+    const flowIds = new Set();
+    let index = 0;
+    while(index < blocks.length){
+        const block = blocks[index];
+        if (void 0 === block.flowId) {
+            index += 1;
+            continue;
+        }
+        if (0 !== block.flowIndex) throw kernelError('office.kernel.flow_sequence_invalid', 'A layout flow must begin with fragment index zero.');
+        if (flowIds.has(block.flowId)) throw kernelError('office.kernel.flow_id_duplicate', `Layout flow ID '${block.flowId}' is duplicated.`);
+        flowIds.add(block.flowId);
+        const count = block.flowCount;
+        const repeatHeaderCount = block.repeatHeaderCount;
+        const repeatHeaderHeight = block.repeatHeaderHeight;
+        const flow = blocks.slice(index, index + count);
+        if (flow.length !== count) throw kernelError('office.kernel.flow_sequence_invalid', 'A layout flow must contain its declared number of fragments.');
+        flow.forEach((fragment, flowIndex)=>{
+            if (fragment.flowId !== block.flowId || fragment.flowIndex !== flowIndex || fragment.flowCount !== count || fragment.minimumFragmentsPerPage !== block.minimumFragmentsPerPage || fragment.repeatHeaderCount !== repeatHeaderCount || fragment.repeatHeaderHeight !== repeatHeaderHeight) throw kernelError('office.kernel.flow_sequence_invalid', 'Layout flow fragments must be consecutive and consistently indexed.');
+            if (flowIndex > 0 && fragment.breakBefore) throw kernelError('office.kernel.flow_break_invalid', 'Only the first flow fragment may request breakBefore.');
+            if (flowIndex + 1 < count && fragment.breakAfter) throw kernelError('office.kernel.flow_break_invalid', 'Only the last flow fragment may request breakAfter.');
+        });
+        index += count;
+    }
+}
+function emptyPage(index, availableHeight) {
+    return {
+        index,
+        usedHeight: 0,
+        availableHeight,
+        placements: []
+    };
+}
+function nextPageIndex(pages) {
+    return (pages.at(-1)?.index ?? -1) + 1;
+}
+function layoutBreaks(pages, request) {
+    return pages.slice(1).flatMap((page, localIndex)=>{
+        const beforeBlockId = page.placements[0]?.blockId;
+        const previous = pages[localIndex];
+        if (!beforeBlockId || !previous) return [];
+        const remainingBodyHeight = Math.max(0, previous.availableHeight - previous.usedHeight);
+        return [
+            {
+                beforeBlockId,
+                pageIndex: page.index,
+                remainingBodyHeight,
+                spacerHeight: remainingBodyHeight + request.page.marginBottom + request.page.pageGap + request.page.marginTop
+            }
+        ];
+    });
+}
+function validateExtent(name, value) {
+    if (!Number.isFinite(value) || value < 0 || value > MAX_LAYOUT_EXTENT) throw kernelError('office.kernel.extent_invalid', `${name} must be a finite non-negative number.`);
+}
+function kernelError(code, message) {
+    return Object.assign(new Error(message), {
+        code
+    });
+}
+const MAX_PRESENTATION_ELEMENTS = 10000;
+const MAX_PRESENTATION_EXTENT = 1000000;
+const MAX_PRESENTATION_SNAP_THRESHOLD = 10;
+const PRESENTATION_SLIDE_EXTENT = 100;
+const PRESENTATION_SNAP_EPSILON = 0.000001;
+function resolveOfficePresentationGeometryInJavaScript(request) {
+    validatePresentationGeometryRequest(request);
+    const operation = request.operation;
+    const resolved = 'alignToSlide' === operation.type ? {
+        elements: request.elements.map((element)=>alignElementToSlide(element, operation.alignment)),
+        guides: []
+    } : snapPresentationElement(request.elements, operation.movingElementId, operation.mode, operation.thresholdX, operation.thresholdY);
+    return {
+        protocol: 15,
+        kind: 'presentationGeometryResult',
+        requestId: request.requestId,
+        revision: request.revision,
+        documentRevision: request.documentRevision,
+        engine: "javascript",
+        ...resolved
+    };
+}
+function alignElementToSlide(element, alignment) {
+    const maximumX = Math.max(0, PRESENTATION_SLIDE_EXTENT - element.width);
+    const maximumY = Math.max(0, PRESENTATION_SLIDE_EXTENT - element.height);
+    switch(alignment){
+        case 'left':
+            return {
+                ...element,
+                x: 0
+            };
+        case 'center':
+            return {
+                ...element,
+                x: maximumX / 2
+            };
+        case 'right':
+            return {
+                ...element,
+                x: maximumX
+            };
+        case 'top':
+            return {
+                ...element,
+                y: 0
+            };
+        case 'middle':
+            return {
+                ...element,
+                y: maximumY / 2
+            };
+        case 'bottom':
+            return {
+                ...element,
+                y: maximumY
+            };
+    }
+}
+function snapPresentationElement(elements, movingElementId, mode, thresholdX, thresholdY) {
+    const moving = elements.find((element)=>element.id === movingElementId);
+    if (!moving) throw office_kernel_presentation_fallback_kernelError('office.kernel.moving_element_missing', `Presentation element '${movingElementId}' does not exist.`);
+    const xSnap = presentationSnapForAxis(moving, elements, 'x', mode, thresholdX);
+    const ySnap = presentationSnapForAxis(moving, elements, 'y', mode, thresholdY);
+    const snapped = applyPresentationSnap(moving, mode, xSnap, ySnap);
+    const guides = [
+        ...xSnap && presentationSnapApplied(moving, snapped, mode, 'x', xSnap.delta) ? [
+            xSnap.guide
+        ] : [],
+        ...ySnap && presentationSnapApplied(moving, snapped, mode, 'y', ySnap.delta) ? [
+            ySnap.guide
+        ] : []
+    ];
+    return {
+        elements: elements.map((element)=>element.id === movingElementId ? snapped : element),
+        guides
+    };
+}
+function presentationSnapForAxis(moving, elements, axis, mode, threshold) {
+    const targets = [
+        ...[
+            0,
+            PRESENTATION_SLIDE_EXTENT / 2,
+            PRESENTATION_SLIDE_EXTENT
+        ].map((position)=>({
+                position,
+                guide: {
+                    axis,
+                    position,
+                    source: 'slide'
+                }
+            })),
+        ...elements.flatMap((element)=>element.id === moving.id ? [] : presentationElementAnchors(element, axis).map((position)=>({
+                    position,
+                    guide: {
+                        axis,
+                        position,
+                        source: 'element',
+                        targetId: element.id
+                    }
+                })))
+    ];
+    let best = null;
+    for (const movingPosition of presentationMovingAnchors(moving, axis, mode))for (const target of targets){
+        const delta = target.position - movingPosition;
+        const distance = Math.abs(delta);
+        if (distance <= threshold && !presentationResizeSnapCollapsesElement(moving, axis, mode, delta) && (!best || distance < best.distance - PRESENTATION_SNAP_EPSILON)) best = {
+            delta,
+            distance,
+            guide: target.guide
+        };
+    }
+    return best ? {
+        delta: best.delta,
+        guide: best.guide
+    } : null;
+}
+function presentationResizeSnapCollapsesElement(element, axis, mode, delta) {
+    if ('resize' !== mode) return false;
+    const size = 'x' === axis ? element.width : element.height;
+    return size + delta <= 0;
+}
+function presentationMovingAnchors(element, axis, mode) {
+    const start = 'x' === axis ? element.x : element.y;
+    const size = 'x' === axis ? element.width : element.height;
+    return 'resize' === mode ? [
+        start + size
+    ] : [
+        start,
+        start + size / 2,
+        start + size
+    ];
+}
+function presentationElementAnchors(element, axis) {
+    const start = 'x' === axis ? element.x : element.y;
+    const size = 'x' === axis ? element.width : element.height;
+    return [
+        start,
+        start + size / 2,
+        start + size
+    ];
+}
+function applyPresentationSnap(element, mode, xSnap, ySnap) {
+    if ('move' === mode) return {
+        ...element,
+        x: clampPresentationExtent(element.x + (xSnap?.delta ?? 0), PRESENTATION_SLIDE_EXTENT - element.width),
+        y: clampPresentationExtent(element.y + (ySnap?.delta ?? 0), PRESENTATION_SLIDE_EXTENT - element.height)
+    };
+    return {
+        ...element,
+        width: clampPresentationExtent(element.width + (xSnap?.delta ?? 0), PRESENTATION_SLIDE_EXTENT - element.x),
+        height: clampPresentationExtent(element.height + (ySnap?.delta ?? 0), PRESENTATION_SLIDE_EXTENT - element.y)
+    };
+}
+function presentationSnapApplied(before, after, mode, axis, delta) {
+    const applied = 'move' === mode ? 'x' === axis ? after.x - before.x : after.y - before.y : 'x' === axis ? after.width - before.width : after.height - before.height;
+    return Math.abs(applied - delta) <= PRESENTATION_SNAP_EPSILON;
+}
+function clampPresentationExtent(value, maximum) {
+    return Math.min(Math.max(value, 0), Math.max(0, maximum));
+}
+function validatePresentationGeometryRequest(request) {
+    if (15 !== request.protocol) throw office_kernel_presentation_fallback_kernelError('office.kernel.protocol_unsupported', `Office kernel protocol ${request.protocol} is unsupported.`);
+    if ('presentationGeometry' !== request.kind) throw office_kernel_presentation_fallback_kernelError('office.kernel.request_kind_invalid', 'The presentation geometry kernel received an invalid request kind.');
+    for (const [name, value] of [
+        [
+            'requestId',
+            request.requestId
+        ],
+        [
+            'revision',
+            request.revision
+        ],
+        [
+            'documentRevision',
+            request.documentRevision
+        ]
+    ])if (!Number.isSafeInteger(value) || value < 0) throw office_kernel_presentation_fallback_kernelError('office.kernel.revision_invalid', `${name} must be a non-negative safe integer.`);
+    if (request.elements.length > MAX_PRESENTATION_ELEMENTS) throw office_kernel_presentation_fallback_kernelError('office.kernel.element_limit_exceeded', `A presentation geometry request may contain at most ${MAX_PRESENTATION_ELEMENTS} elements.`);
+    if ('snapElement' === request.operation.type) {
+        if (!request.operation.movingElementId.trim()) throw office_kernel_presentation_fallback_kernelError('office.kernel.moving_element_invalid', 'A presentation snap request requires a moving element ID.');
+        for (const [name, value] of [
+            [
+                'thresholdX',
+                request.operation.thresholdX
+            ],
+            [
+                'thresholdY',
+                request.operation.thresholdY
+            ]
+        ])if (!Number.isFinite(value) || value < 0 || value > MAX_PRESENTATION_SNAP_THRESHOLD) throw office_kernel_presentation_fallback_kernelError('office.kernel.snap_threshold_invalid', `${name} must be between 0 and ${MAX_PRESENTATION_SNAP_THRESHOLD}.`);
+    }
+    const ids = new Set();
+    for (const element of request.elements){
+        if (!element.id.trim() || element.id.length > 256) throw office_kernel_presentation_fallback_kernelError('office.kernel.element_id_invalid', 'Every presentation element requires a non-empty ID of at most 256 bytes.');
+        if (ids.has(element.id)) throw office_kernel_presentation_fallback_kernelError('office.kernel.element_id_duplicate', `Presentation element ID '${element.id}' is duplicated.`);
+        ids.add(element.id);
+        for (const [name, value] of [
+            [
+                'x',
+                element.x
+            ],
+            [
+                'y',
+                element.y
+            ],
+            [
+                'width',
+                element.width
+            ],
+            [
+                'height',
+                element.height
+            ]
+        ])if (!Number.isFinite(value) || value < 0 || value > MAX_PRESENTATION_EXTENT) throw office_kernel_presentation_fallback_kernelError('office.kernel.extent_invalid', `element.${name} must be a finite non-negative number.`);
+        if (element.width <= 0 || element.height <= 0) throw office_kernel_presentation_fallback_kernelError('office.kernel.element_size_invalid', 'Presentation element width and height must be positive.');
+    }
+}
+function office_kernel_presentation_fallback_kernelError(code, message) {
+    return Object.assign(new Error(message), {
+        code
+    });
+}
+const browserScalarFunctionArities = new Map([
+    [
+        'ABS',
+        [
+            1,
+            1
+        ]
+    ],
+    [
+        'AND',
+        [
+            1,
+            255
+        ]
+    ],
+    [
+        'AVERAGE',
+        [
+            1,
+            255
+        ]
+    ],
+    [
+        'COLUMN',
+        [
+            0,
+            0
+        ]
+    ],
+    [
+        'CONCAT',
+        [
+            1,
+            255
+        ]
+    ],
+    [
+        'CONCATENATE',
+        [
+            1,
+            255
+        ]
+    ],
+    [
+        'COUNT',
+        [
+            1,
+            255
+        ]
+    ],
+    [
+        'COUNTA',
+        [
+            1,
+            255
+        ]
+    ],
+    [
+        'FALSE',
+        [
+            0,
+            0
+        ]
+    ],
+    [
+        'IF',
+        [
+            2,
+            3
+        ]
+    ],
+    [
+        'IFERROR',
+        [
+            2,
+            2
+        ]
+    ],
+    [
+        'MAX',
+        [
+            1,
+            255
+        ]
+    ],
+    [
+        'MIN',
+        [
+            1,
+            255
+        ]
+    ],
+    [
+        'MOD',
+        [
+            2,
+            2
+        ]
+    ],
+    [
+        'NA',
+        [
+            0,
+            0
+        ]
+    ],
+    [
+        'NOT',
+        [
+            1,
+            1
+        ]
+    ],
+    [
+        'OR',
+        [
+            1,
+            255
+        ]
+    ],
+    [
+        'PI',
+        [
+            0,
+            0
+        ]
+    ],
+    [
+        'POWER',
+        [
+            2,
+            2
+        ]
+    ],
+    [
+        'ROUND',
+        [
+            2,
+            2
+        ]
+    ],
+    [
+        'ROW',
+        [
+            0,
+            0
+        ]
+    ],
+    [
+        'SQRT',
+        [
+            1,
+            1
+        ]
+    ],
+    [
+        'SUM',
+        [
+            1,
+            255
+        ]
+    ],
+    [
+        'TRUE',
+        [
+            0,
+            0
+        ]
+    ]
+]);
+function normalizeSpreadsheetFunctionName(name) {
+    let normalized = name.toUpperCase();
+    while(normalized.startsWith('_XLFN.') || normalized.startsWith('_XLWS.'))normalized = normalized.slice(6);
+    return normalized;
+}
+function normalizeFormulaForFortuneParser(formula) {
+    const source = formula.replace(/^=/, '');
+    let output = '';
+    let cursor = 0;
+    let bracketDepth = 0;
+    while(cursor < source.length){
+        const character = source[cursor] ?? '';
+        if ('"' === character || "'" === character) {
+            const quote = character;
+            output += quote;
+            cursor += 1;
+            while(cursor < source.length){
+                const quoted = source[cursor] ?? '';
+                output += quoted;
+                cursor += 1;
+                if (quoted !== quote) continue;
+                if (source[cursor] === quote) {
+                    output += quote;
+                    cursor += 1;
+                    continue;
+                }
+                break;
+            }
+            continue;
+        }
+        if ('[' === character) {
+            bracketDepth += 1;
+            output += character;
+            cursor += 1;
+            continue;
+        }
+        if (']' === character && bracketDepth > 0) {
+            bracketDepth -= 1;
+            output += character;
+            cursor += 1;
+            continue;
+        }
+        if (0 === bracketDepth && isAsciiFormulaNameStart(character)) {
+            const start = cursor;
+            cursor += 1;
+            while(cursor < source.length && isAsciiFormulaNameContinue(source[cursor] ?? ''))cursor += 1;
+            const token = source.slice(start, cursor);
+            const normalized = token.toUpperCase();
+            const normalizedFunction = normalizeSpreadsheetFunctionName(token);
+            const previous = adjacentNonWhitespace(source, start - 1, -1);
+            const next = adjacentNonWhitespace(source, cursor, 1);
+            if ('(' === next && normalizedFunction !== normalized) output += normalizedFunction;
+            else if (('TRUE' === normalized || 'FALSE' === normalized) && '!' !== previous && '!' !== next && '(' !== next) output += `${token}()`;
+            else output += token;
+            continue;
+        }
+        output += character;
+        cursor += 1;
+    }
+    return output;
+}
+function adjacentNonWhitespace(value, start, direction) {
+    let cursor = start;
+    while(cursor >= 0 && cursor < value.length){
+        const character = value[cursor];
+        if (character && !/\s/u.test(character)) return character;
+        cursor += direction;
+    }
+}
+function isAsciiFormulaNameStart(value) {
+    return /[A-Za-z_]/u.test(value);
+}
+function isAsciiFormulaNameContinue(value) {
+    return /[A-Za-z0-9_.]/u.test(value);
+}
+const office_kernel_spreadsheet_protocol_OFFICE_KERNEL_SPREADSHEET_MAX_ROWS = 1048576;
+const spreadsheetErrors = new Set([
+    '#BLOCKED!',
+    '#BUSY!',
+    '#CALC!',
+    '#CONNECT!',
+    '#DIV/0!',
+    '#FIELD!',
+    '#GETTING_DATA',
+    '#N/A',
+    '#NAME?',
+    '#NULL!',
+    '#NUM!',
+    '#PYTHON!',
+    '#REF!',
+    '#SPILL!',
+    '#UNKNOWN!',
+    '#VALUE!'
+]);
+new TextEncoder();
+function isOfficeKernelSpreadsheetError(value) {
+    return 'string' == typeof value && spreadsheetErrors.has(value);
+}
+const MAX_SPREADSHEET_INPUT_CELLS = 100000;
+const MAX_SPREADSHEET_FORMULA_CHARACTERS = 8192;
+const MAX_SPREADSHEET_SHEETS = 1024;
+const MAX_SPREADSHEET_IDENTIFIER_BYTES = 256;
+const MAX_UNSIGNED_32_BIT_INTEGER = 4294967295;
+function validateSpreadsheetCalculationRequest(request) {
+    if (15 !== request.protocol) throw office_kernel_spreadsheet_fallback_validation_kernelError('office.kernel.protocol_unsupported', `Office kernel protocol ${request.protocol} is unsupported.`);
+    if ('spreadsheetCalculation' !== request.kind) throw office_kernel_spreadsheet_fallback_validation_kernelError('office.kernel.request_kind_invalid', 'The Spreadsheet kernel only accepts calculation requests.');
+    if (!unsigned32BitInteger(request.requestId) || !unsigned32BitInteger(request.revision) || !nonNegativeSafeInteger(request.documentRevision)) throw office_kernel_spreadsheet_fallback_validation_kernelError('office.kernel.revision_invalid', 'Request, calculation, and document revisions must be non-negative safe integers.');
+    if (request.sheets.length > MAX_SPREADSHEET_SHEETS) throw office_kernel_spreadsheet_fallback_validation_kernelError('office.kernel.spreadsheet.sheet_limit_exceeded', `A Spreadsheet calculation request may contain at most ${MAX_SPREADSHEET_SHEETS} sheets.`);
+    const totalCells = request.sheets.reduce((count, sheet)=>count + sheet.cells.length, 0);
+    if (totalCells > MAX_SPREADSHEET_INPUT_CELLS) throw office_kernel_spreadsheet_fallback_validation_kernelError('office.kernel.spreadsheet.cell_limit_exceeded', `A Spreadsheet calculation request may contain at most ${MAX_SPREADSHEET_INPUT_CELLS} populated cells.`);
+    if (request.targets && request.targets.length > MAX_SPREADSHEET_INPUT_CELLS) throw office_kernel_spreadsheet_fallback_validation_kernelError('office.kernel.spreadsheet.target_limit_exceeded', `A Spreadsheet calculation request may contain at most ${MAX_SPREADSHEET_INPUT_CELLS} targets.`);
+    const sheetIds = new Set();
+    const sheetNames = new Set();
+    for (const sheet of request.sheets){
+        const normalizedName = sheet.name.toLowerCase();
+        if (!sheet.id.trim() || utf8ByteLength(sheet.id) > MAX_SPREADSHEET_IDENTIFIER_BYTES || !sheet.name.trim() || utf8ByteLength(sheet.name) > MAX_SPREADSHEET_IDENTIFIER_BYTES || sheetIds.has(sheet.id) || sheetNames.has(normalizedName)) throw office_kernel_spreadsheet_fallback_validation_kernelError('office.kernel.spreadsheet.sheet_invalid', 'Spreadsheet sheet IDs and names must be unique and non-empty.');
+        sheetIds.add(sheet.id);
+        sheetNames.add(normalizedName);
+        const coordinates = new Set();
+        for (const cell of sheet.cells){
+            const key = `${cell.row}:${cell.column}`;
+            if (!boundedSpreadsheetIndex(cell.row, office_kernel_spreadsheet_protocol_OFFICE_KERNEL_SPREADSHEET_MAX_ROWS) || !boundedSpreadsheetIndex(cell.column, 16384) || coordinates.has(key)) throw office_kernel_spreadsheet_fallback_validation_kernelError('office.kernel.spreadsheet.cell_invalid', 'Spreadsheet cells require unique, bounded row and column coordinates.');
+            coordinates.add(key);
+            validateSpreadsheetValue(cell.value);
+            if (void 0 !== cell.formula && (0 === cell.formula.length || Array.from(cell.formula).length > MAX_SPREADSHEET_FORMULA_CHARACTERS)) throw office_kernel_spreadsheet_fallback_validation_kernelError('office.kernel.spreadsheet.formula_invalid', `Spreadsheet formulas must contain 1-${MAX_SPREADSHEET_FORMULA_CHARACTERS} characters.`);
+        }
+    }
+    for (const target of request.targets ?? [])if (!sheetIds.has(target.sheetId) || !boundedSpreadsheetIndex(target.row, office_kernel_spreadsheet_protocol_OFFICE_KERNEL_SPREADSHEET_MAX_ROWS) || !boundedSpreadsheetIndex(target.column, 16384)) throw office_kernel_spreadsheet_fallback_validation_kernelError('office.kernel.spreadsheet.target_invalid', 'Spreadsheet calculation targets must reference an existing, bounded cell.');
+}
+function boundedSpreadsheetIndex(value, exclusiveMaximum) {
+    return Number.isSafeInteger(value) && value >= 0 && value < exclusiveMaximum;
+}
+function validateSpreadsheetValue(value) {
+    if ('number' === value.kind && !Number.isFinite(value.value)) throw office_kernel_spreadsheet_fallback_validation_kernelError('office.kernel.spreadsheet.value_invalid', 'Spreadsheet numeric values must be finite.');
+    if ('text' === value.kind && utf8ByteLength(value.value) > 32767) throw office_kernel_spreadsheet_fallback_validation_kernelError('office.kernel.spreadsheet.value_invalid', "Spreadsheet text values may contain at most 32767 UTF-8 bytes.");
+    if ('error' === value.kind && !isOfficeKernelSpreadsheetError(value.value)) throw office_kernel_spreadsheet_fallback_validation_kernelError('office.kernel.spreadsheet.value_invalid', `Spreadsheet error value '${value.value}' is not recognized.`);
+}
+function nonNegativeSafeInteger(value) {
+    return Number.isSafeInteger(value) && value >= 0;
+}
+function unsigned32BitInteger(value) {
+    return nonNegativeSafeInteger(value) && value <= MAX_UNSIGNED_32_BIT_INTEGER;
+}
+function utf8ByteLength(value) {
+    return new TextEncoder().encode(value).byteLength;
+}
+function office_kernel_spreadsheet_fallback_validation_kernelError(code, message) {
+    return Object.assign(new Error(message), {
+        code
+    });
+}
+const textEncoder = new TextEncoder();
+function spreadsheetValueFromParser(value) {
+    if (Array.isArray(value)) {
+        const first = value[0];
+        return spreadsheetValueFromParser(Array.isArray(first) ? first[0] : first);
+    }
+    if (null == value || '' === value) return {
+        kind: 'blank'
+    };
+    if ('number' == typeof value) return Number.isFinite(value) ? {
+        kind: 'number',
+        value: Object.is(value, -0) ? 0 : value
+    } : {
+        kind: 'error',
+        value: '#NUM!'
+    };
+    if ('boolean' == typeof value) return {
+        kind: 'boolean',
+        value
+    };
+    if (value instanceof Error) return {
+        kind: 'error',
+        value: spreadsheetError(value.message)
+    };
+    if ('string' == typeof value && !value.startsWith('#')) {
+        const error = recognizedSpreadsheetError(value);
+        if (error) return {
+            kind: 'error',
+            value: error
+        };
+    }
+    const text = String(value);
+    return textEncoder.encode(text).byteLength <= 32767 ? {
+        kind: 'text',
+        value: text
+    } : {
+        kind: 'error',
+        value: '#VALUE!'
+    };
+}
+function spreadsheetValueForParser(value) {
+    switch(value.kind){
+        case 'blank':
+            return null;
+        case 'number':
+        case 'text':
+        case 'boolean':
+            return value.value;
+        case 'error':
+            return new Error(value.value);
+    }
+}
+function spreadsheetError(value) {
+    return recognizedSpreadsheetError(value) ?? '#VALUE!';
+}
+function recognizedSpreadsheetError(value) {
+    const normalized = value.startsWith('#') ? value : `#${value}`;
+    const withSuffix = '#DIV/0' === normalized ? '#DIV/0!' : normalized;
+    return isOfficeKernelSpreadsheetError(withSuffix) ? withSuffix : null;
+}
+function evaluateParserIfError(parameters) {
+    const [value, fallback = null] = parameters;
+    return isParserErrorValue(value) ? fallback : value;
+}
+function isParserErrorValue(value) {
+    if (value instanceof Error) return true;
+    if ('string' != typeof value || value.startsWith('#')) return false;
+    const normalized = `#${value}`;
+    const withSuffix = '#DIV/0' === normalized ? '#DIV/0!' : normalized;
+    return isOfficeKernelSpreadsheetError(withSuffix);
+}
+async function calculateSpreadsheetInJavaScript(request) {
+    validateSpreadsheetCalculationRequest(request);
+    const formulaParser = await import("@fortune-sheet/formula-parser");
+    const evaluator = new JavaScriptSpreadsheetEvaluator(request, formulaParser);
+    return evaluator.calculate();
+}
+class JavaScriptSpreadsheetEvaluator {
+    request;
+    formulaParser;
+    cells = new Map();
+    sheetsByName = new Map();
+    states = new Map();
+    stack = [];
+    calculationOrder = [];
+    issues = [];
+    constructor(request, formulaParser){
+        this.request = request;
+        this.formulaParser = formulaParser;
+        for (const sheet of request.sheets){
+            this.sheetsByName.set(sheet.name.toLowerCase(), sheet);
+            for (const cell of sheet.cells)this.cells.set(cellKey(sheet.id, cell.row, cell.column), {
+                cell,
+                sheet
+            });
+        }
+    }
+    calculate() {
+        const targets = this.request.targets?.length ? this.request.targets : this.request.sheets.flatMap((sheet)=>sheet.cells.flatMap((cell)=>cell.formula ? [
+                    {
+                        sheetId: sheet.id,
+                        row: cell.row,
+                        column: cell.column
+                    }
+                ] : []).sort((left, right)=>left.row - right.row || left.column - right.column));
+        for (const target of targets)this.evaluateCoordinate(target);
+        const cells = this.calculationOrder.flatMap((coordinate)=>{
+            const state = this.states.get(coordinateKey(coordinate));
+            return state?.successful ? [
+                {
+                    ...coordinate,
+                    value: state.value
+                }
+            ] : [];
+        });
+        return {
+            protocol: 15,
+            kind: 'spreadsheetCalculationResult',
+            requestId: this.request.requestId,
+            revision: this.request.revision,
+            documentRevision: this.request.documentRevision,
+            engine: "javascript",
+            cells,
+            calculationOrder: this.calculationOrder.filter((coordinate)=>this.states.get(coordinateKey(coordinate))?.successful),
+            issues: this.issues
+        };
+    }
+    evaluateCoordinate(coordinate) {
+        const key = coordinateKey(coordinate);
+        const cached = this.states.get(key);
+        if (cached) return cached.value;
+        const indexed = this.cells.get(key);
+        if (!indexed) return {
+            kind: 'blank'
+        };
+        if (!indexed.cell.formula) return indexed.cell.value;
+        const cycleStart = this.stack.indexOf(key);
+        if (cycleStart >= 0) {
+            this.markCycle(cycleStart);
+            return this.states.get(key)?.value ?? indexed.cell.value;
+        }
+        if (this.stack.length >= 64) {
+            this.recordState(key, indexed.cell.value, false, calculationIssue(coordinate, 'office.kernel.spreadsheet.dependency_depth_exceeded', "Spreadsheet formula dependency depth may not exceed 64."));
+            return indexed.cell.value;
+        }
+        this.stack.push(key);
+        let state;
+        try {
+            state = this.evaluateFormula(coordinate, indexed);
+        } finally{
+            this.stack.pop();
+        }
+        const cycleState = this.states.get(key);
+        if (cycleState) return cycleState.value;
+        this.recordState(key, state.value, state.successful, state.issue);
+        return state.value;
+    }
+    evaluateFormula(coordinate, indexed) {
+        const formula = indexed.cell.formula ?? '';
+        const parser = new this.formulaParser.Parser();
+        let unresolvedDependency = false;
+        let unsupportedReference = false;
+        let unsupportedFunction;
+        let materializedRangeCells = 0;
+        parser.setFunction('IFERROR', evaluateParserIfError).setFunction('ROW', (parameters)=>parameters.length ? null : coordinate.row + 1).setFunction('COLUMN', (parameters)=>parameters.length ? null : coordinate.column + 1);
+        parser.on('callFunction', (name, parameters)=>{
+            const normalized = normalizeSpreadsheetFunctionName(name);
+            const arity = browserScalarFunctionArities.get(normalized);
+            if (!arity || parameters.length < arity[0] || parameters.length > arity[1]) unsupportedFunction ??= name.toUpperCase();
+        });
+        parser.on('callCellValue', (cell, _options, done)=>{
+            const dependency = this.resolveCoordinate(indexed.sheet, cell);
+            if (!dependency) {
+                unsupportedReference = true;
+                done(null);
+                return;
+            }
+            const value = this.evaluateCoordinate(dependency);
+            if (this.dependencyRequiresCompatibility(dependency)) unresolvedDependency = true;
+            done(spreadsheetValueForParser(value));
+        });
+        parser.on('callRangeValue', (start, end, _options, done)=>{
+            done(this.rangeValues(indexed.sheet, start, end, ()=>{
+                unresolvedDependency = true;
+            }, ()=>{
+                unsupportedReference = true;
+            }, (cells)=>{
+                if (cells > 100000 - materializedRangeCells) return false;
+                materializedRangeCells += cells;
+                return true;
+            }));
+        });
+        const parsed = parser.parse(normalizeFormulaForFortuneParser(formula), {
+            sheetId: indexed.sheet.id
+        });
+        if (unsupportedFunction) return failedEvaluation(indexed.cell.value, calculationIssue(coordinate, 'office.kernel.spreadsheet.formula_unsupported', `Formula function '${unsupportedFunction}' is not supported.`));
+        if (unsupportedReference) return failedEvaluation(indexed.cell.value, calculationIssue(coordinate, 'office.kernel.spreadsheet.formula_unsupported', 'A formula reference cannot be materialized by the browser fallback.'));
+        if (unresolvedDependency) return failedEvaluation(indexed.cell.value, calculationIssue(coordinate, 'office.kernel.spreadsheet.dependency_unresolved', 'A formula dependency requires compatibility calculation.'));
+        if (parsed.error) {
+            const error = recognizedSpreadsheetError(parsed.error);
+            if (error) return {
+                successful: true,
+                value: {
+                    kind: 'error',
+                    value: error
+                }
+            };
+            return failedEvaluation(indexed.cell.value, calculationIssue(coordinate, 'office.kernel.spreadsheet.formula_invalid', 'Formula calculation failed with #VALUE!.'));
+        }
+        return {
+            successful: true,
+            value: spreadsheetValueFromParser(parsed.result)
+        };
+    }
+    rangeValues(currentSheet, start, end, onUnresolvedDependency, onUnsupportedReference, reserveRangeCells) {
+        const startCoordinate = this.resolveCoordinate(currentSheet, start);
+        const endCoordinate = this.resolveCoordinate(currentSheet, end);
+        if (!startCoordinate || !endCoordinate || startCoordinate.sheetId !== endCoordinate.sheetId) {
+            onUnsupportedReference();
+            return [];
+        }
+        const rowStart = Math.min(startCoordinate.row, endCoordinate.row);
+        const rowEnd = Math.max(startCoordinate.row, endCoordinate.row);
+        const columnStart = Math.min(startCoordinate.column, endCoordinate.column);
+        const columnEnd = Math.max(startCoordinate.column, endCoordinate.column);
+        const cells = (rowEnd - rowStart + 1) * (columnEnd - columnStart + 1);
+        if (cells > 100000 || !reserveRangeCells(cells)) {
+            onUnsupportedReference();
+            return [];
+        }
+        const values = [];
+        for(let row = rowStart; row <= rowEnd; row += 1){
+            const rowValues = [];
+            for(let column = columnStart; column <= columnEnd; column += 1){
+                const dependency = {
+                    sheetId: startCoordinate.sheetId,
+                    row,
+                    column
+                };
+                const value = this.evaluateCoordinate(dependency);
+                if (this.dependencyRequiresCompatibility(dependency)) {
+                    onUnresolvedDependency();
+                    return [];
+                }
+                rowValues.push(spreadsheetValueForParser(value));
+            }
+            values.push(rowValues);
+        }
+        return values;
+    }
+    dependencyRequiresCompatibility(coordinate) {
+        const state = this.states.get(coordinateKey(coordinate));
+        return state?.successful === false;
+    }
+    resolveCoordinate(currentSheet, coordinate) {
+        const sheet = coordinate.sheetName ? this.sheetsByName.get(coordinate.sheetName.toLowerCase()) : currentSheet;
+        if (!sheet || !boundedSpreadsheetIndex(coordinate.row.index, office_kernel_spreadsheet_protocol_OFFICE_KERNEL_SPREADSHEET_MAX_ROWS) || !boundedSpreadsheetIndex(coordinate.column.index, 16384)) return null;
+        return {
+            sheetId: sheet.id,
+            row: coordinate.row.index,
+            column: coordinate.column.index
+        };
+    }
+    recordState(key, value, successful, issue) {
+        if (this.states.has(key)) return;
+        this.states.set(key, {
+            value,
+            successful,
+            issue
+        });
+        const indexed = this.cells.get(key);
+        if (indexed?.cell.formula) this.calculationOrder.push({
+            sheetId: indexed.sheet.id,
+            row: indexed.cell.row,
+            column: indexed.cell.column
+        });
+        if (issue) this.issues.push(issue);
+    }
+    markCycle(start) {
+        for (const key of this.stack.slice(start)){
+            const indexed = this.cells.get(key);
+            if (indexed) this.recordState(key, indexed.cell.value, false, calculationIssue({
+                sheetId: indexed.sheet.id,
+                row: indexed.cell.row,
+                column: indexed.cell.column
+            }, 'office.kernel.spreadsheet.circular_reference', 'Formula dependency cycle is not supported by this calculation pass.'));
+        }
+    }
+}
+function failedEvaluation(value, issue) {
+    return {
+        successful: false,
+        value,
+        issue
+    };
+}
+function calculationIssue(cell, code, message) {
+    return {
+        cell,
+        code,
+        message
+    };
+}
+function coordinateKey(coordinate) {
+    return cellKey(coordinate.sheetId, coordinate.row, coordinate.column);
+}
+function cellKey(sheetId, row, column) {
+    return `${sheetId}\u0000${row}\u0000${column}`;
+}
+async function calculateSpreadsheetSessionInJavaScript(request, sheets) {
+    const calculationRequest = {
+        protocol: request.protocol,
+        kind: 'spreadsheetCalculation',
+        requestId: request.requestId,
+        revision: request.revision,
+        documentRevision: request.documentRevision,
+        sheets,
+        targets: 'targets' === request.calculation.kind ? request.calculation.targets : void 0
+    };
+    const result = await calculateSpreadsheetInJavaScript(calculationRequest);
+    const formulaKeys = new Set(sheets.flatMap((sheet)=>sheet.cells.flatMap((cell)=>cell.formula ? [
+                `${sheet.id}\u0000${cell.row}\u0000${cell.column}`
+            ] : [])));
+    const dirtyFormulaCellCount = 'targets' === request.calculation.kind ? new Set(request.calculation.targets.flatMap((target)=>{
+        const key = `${target.sheetId}\u0000${target.row}\u0000${target.column}`;
+        return formulaKeys.has(key) ? [
+            key
+        ] : [];
+    })).size : formulaKeys.size;
+    return {
+        ...result,
+        kind: 'spreadsheetSessionCalculationResult',
+        stats: {
+            updateKind: request.update.kind,
+            calculationScope: request.calculation.kind,
+            formulaCellCount: formulaKeys.size,
+            dirtyFormulaCellCount,
+            evaluatedFormulaCellCount: result.calculationOrder.length,
+            reusedFormulaCellCount: 0,
+            dependencyEdgeCount: 0
+        }
+    };
+}
+function layoutOfficeTextInJavaScript(request) {
+    return {
+        protocol: 15,
+        kind: 'textLayoutResult',
+        requestId: request.requestId,
+        revision: request.revision,
+        documentRevision: request.documentRevision,
+        engine: "javascript",
+        layouts: [],
+        unsupportedParagraphIds: request.paragraphs.map((paragraph)=>paragraph.id)
+    };
+}
+const OFFICE_KERNEL_WORKER_TIMEOUT_MS = 10000;
+function createOfficeKernelClient(wasmUrl, fonts = []) {
+    return new BrowserOfficeKernelClient(wasmUrl, fonts);
+}
+class BrowserOfficeKernelClient {
+    worker = null;
+    nextRequestId = 1;
+    pendingLayouts = new Map();
+    pendingPresentationGeometry = new Map();
+    pendingTextLayouts = new Map();
+    pendingSpreadsheetCalculations = new Map();
+    pendingSpreadsheetSessionCalculations = new Map();
+    disposed = false;
+    constructor(wasmUrl, fonts = []){
+        if ("u" < typeof Worker) return;
+        try {
+            this.worker = new Worker(new URL('./office-kernel.worker.js', import.meta.url), {
+                name: 'a3s-office-kernel'
+            });
+            this.worker.addEventListener('message', this.handleMessage);
+            this.worker.addEventListener('error', this.handleWorkerFailure);
+            this.worker.postMessage({
+                kind: 'initialize',
+                wasmUrl,
+                fonts
+            });
+        } catch  {
+            this.worker = null;
+        }
+    }
+    layout(input, signal) {
+        if (this.disposed) return Promise.reject(disposedError());
+        const request = {
+            protocol: 15,
+            kind: 'layout',
+            requestId: this.nextRequestId++,
+            revision: input.revision,
+            documentRevision: input.documentRevision,
+            startPageIndex: input.startPageIndex ?? 0,
+            page: input.page,
+            blocks: input.blocks
+        };
+        if (signal?.aborted) return Promise.reject(abortError());
+        if (!this.worker) return office_kernel_client_fallbackRequest(request, signal, layoutOfficeDocumentInJavaScript);
+        return new Promise((resolve, reject)=>{
+            const pending = {
+                request,
+                resolve,
+                reject
+            };
+            this.attachPendingRequest(this.pendingLayouts, pending, signal);
+            this.worker?.postMessage({
+                kind: 'layout',
+                request
+            });
+        });
+    }
+    presentationGeometry(input, signal) {
+        if (this.disposed) return Promise.reject(disposedError());
+        const request = {
+            protocol: 15,
+            kind: 'presentationGeometry',
+            requestId: this.nextRequestId++,
+            revision: input.revision,
+            documentRevision: input.documentRevision,
+            operation: input.operation,
+            elements: input.elements
+        };
+        if (signal?.aborted) return Promise.reject(abortError());
+        if (!this.worker) return office_kernel_client_fallbackRequest(request, signal, resolveOfficePresentationGeometryInJavaScript);
+        return new Promise((resolve, reject)=>{
+            const pending = {
+                request,
+                resolve,
+                reject
+            };
+            this.attachPendingRequest(this.pendingPresentationGeometry, pending, signal);
+            this.worker?.postMessage({
+                kind: 'presentationGeometry',
+                request
+            });
+        });
+    }
+    textLayout(input, signal) {
+        if (this.disposed) return Promise.reject(disposedError());
+        const request = {
+            protocol: 15,
+            kind: 'textLayout',
+            requestId: this.nextRequestId++,
+            revision: input.revision,
+            documentRevision: input.documentRevision,
+            paragraphs: input.paragraphs
+        };
+        if (signal?.aborted) return Promise.reject(abortError());
+        if (!this.worker) return office_kernel_client_fallbackRequest(request, signal, layoutOfficeTextInJavaScript);
+        return new Promise((resolve, reject)=>{
+            const pending = {
+                request,
+                resolve,
+                reject
+            };
+            this.attachPendingRequest(this.pendingTextLayouts, pending, signal);
+            this.worker?.postMessage({
+                kind: 'textLayout',
+                request
+            });
+        });
+    }
+    spreadsheetCalculation(input, signal) {
+        if (this.disposed) return Promise.reject(disposedError());
+        const request = {
+            protocol: 15,
+            kind: 'spreadsheetCalculation',
+            requestId: this.nextRequestId++,
+            revision: input.revision,
+            documentRevision: input.documentRevision,
+            sheets: input.sheets,
+            targets: input.targets
+        };
+        if (signal?.aborted) return Promise.reject(abortError());
+        if (!this.worker) return office_kernel_client_fallbackRequest(request, signal, calculateSpreadsheetInJavaScript);
+        return new Promise((resolve, reject)=>{
+            const pending = {
+                request,
+                resolve,
+                reject
+            };
+            this.attachPendingRequest(this.pendingSpreadsheetCalculations, pending, signal);
+            this.worker?.postMessage({
+                kind: 'spreadsheetCalculation',
+                request
+            });
+        });
+    }
+    spreadsheetSessionCalculation(input, signal) {
+        if (this.disposed) return Promise.reject(disposedError());
+        const request = {
+            protocol: 15,
+            kind: 'spreadsheetSessionCalculation',
+            requestId: this.nextRequestId++,
+            revision: input.revision,
+            documentRevision: input.documentRevision,
+            update: input.update,
+            calculation: input.calculation
+        };
+        if (signal?.aborted) return Promise.reject(abortError());
+        if (!this.worker) return fallbackSpreadsheetSessionCalculation(request, input.fallbackSheets, signal);
+        return new Promise((resolve, reject)=>{
+            const pending = {
+                request,
+                fallbackSheets: input.fallbackSheets,
+                resolve,
+                reject
+            };
+            this.attachPendingRequest(this.pendingSpreadsheetSessionCalculations, pending, signal);
+            this.worker?.postMessage({
+                kind: 'spreadsheetSessionCalculation',
+                request
+            });
+        });
+    }
+    dispose() {
+        if (this.disposed) return;
+        this.disposed = true;
+        this.worker?.removeEventListener('message', this.handleMessage);
+        this.worker?.removeEventListener('error', this.handleWorkerFailure);
+        this.worker?.terminate();
+        this.worker = null;
+        this.rejectPendingRequests(this.pendingLayouts, disposedError());
+        this.rejectPendingRequests(this.pendingPresentationGeometry, disposedError());
+        this.rejectPendingRequests(this.pendingTextLayouts, disposedError());
+        this.rejectPendingRequests(this.pendingSpreadsheetCalculations, disposedError());
+        this.rejectPendingRequests(this.pendingSpreadsheetSessionCalculations, disposedError());
+    }
+    attachPendingRequest(pendingRequests, pending, signal) {
+        const requestId = pending.request.requestId;
+        if (signal) {
+            pending.signal = signal;
+            const onAbort = ()=>{
+                pendingRequests.delete(requestId);
+                releasePendingRequest(pending);
+                this.worker?.postMessage({
+                    kind: 'cancel',
+                    requestId
+                });
+                pending.reject(abortError());
+            };
+            signal.addEventListener('abort', onAbort, {
+                once: true
+            });
+            pending.removeAbortListener = ()=>signal.removeEventListener('abort', onAbort);
+        }
+        pending.timeout = setTimeout(this.handleWorkerFailure, OFFICE_KERNEL_WORKER_TIMEOUT_MS);
+        pendingRequests.set(requestId, pending);
+    }
+    rejectPendingRequests(pendingRequests, error) {
+        for (const pending of pendingRequests.values()){
+            releasePendingRequest(pending);
+            pending.reject(error);
+        }
+        pendingRequests.clear();
+    }
+    handleMessage = (event)=>{
+        if ('response' !== event.data.kind) return;
+        const response = event.data.response;
+        const layout = this.pendingLayouts.get(response.requestId);
+        const geometry = this.pendingPresentationGeometry.get(response.requestId);
+        const textLayout = this.pendingTextLayouts.get(response.requestId);
+        const spreadsheetCalculation = this.pendingSpreadsheetCalculations.get(response.requestId);
+        const spreadsheetSessionCalculation = this.pendingSpreadsheetSessionCalculations.get(response.requestId);
+        const pending = layout ?? geometry ?? textLayout ?? spreadsheetCalculation ?? spreadsheetSessionCalculation;
+        if (!pending) return;
+        this.pendingLayouts.delete(response.requestId);
+        this.pendingPresentationGeometry.delete(response.requestId);
+        this.pendingTextLayouts.delete(response.requestId);
+        this.pendingSpreadsheetCalculations.delete(response.requestId);
+        this.pendingSpreadsheetSessionCalculations.delete(response.requestId);
+        releasePendingRequest(pending);
+        if ('error' === response.kind) return void pending.reject(Object.assign(new Error(response.error.message), {
+            code: response.error.code
+        }));
+        if ('layoutResult' === response.kind && layout) return void layout.resolve(response);
+        if ('presentationGeometryResult' === response.kind && geometry) return void geometry.resolve(response);
+        if ('textLayoutResult' === response.kind && textLayout) return void textLayout.resolve(response);
+        if ('spreadsheetCalculationResult' === response.kind && spreadsheetCalculation) return void spreadsheetCalculation.resolve(response);
+        if ('spreadsheetSessionCalculationResult' === response.kind && spreadsheetSessionCalculation) return void spreadsheetSessionCalculation.resolve(response);
+        pending.reject(new Error('Office kernel response kind did not match.'));
+    };
+    handleWorkerFailure = ()=>{
+        const layouts = [
+            ...this.pendingLayouts.values()
+        ];
+        const geometryRequests = [
+            ...this.pendingPresentationGeometry.values()
+        ];
+        const textLayoutRequests = [
+            ...this.pendingTextLayouts.values()
+        ];
+        const spreadsheetCalculations = [
+            ...this.pendingSpreadsheetCalculations.values()
+        ];
+        const spreadsheetSessionCalculations = [
+            ...this.pendingSpreadsheetSessionCalculations.values()
+        ];
+        this.pendingLayouts.clear();
+        this.pendingPresentationGeometry.clear();
+        this.pendingTextLayouts.clear();
+        this.pendingSpreadsheetCalculations.clear();
+        this.pendingSpreadsheetSessionCalculations.clear();
+        this.worker?.terminate();
+        this.worker = null;
+        for (const pending of layouts){
+            releasePendingRequest(pending);
+            office_kernel_client_fallbackRequest(pending.request, pending.signal, layoutOfficeDocumentInJavaScript).then(pending.resolve, pending.reject);
+        }
+        for (const pending of geometryRequests){
+            releasePendingRequest(pending);
+            office_kernel_client_fallbackRequest(pending.request, pending.signal, resolveOfficePresentationGeometryInJavaScript).then(pending.resolve, pending.reject);
+        }
+        for (const pending of textLayoutRequests){
+            releasePendingRequest(pending);
+            office_kernel_client_fallbackRequest(pending.request, pending.signal, layoutOfficeTextInJavaScript).then(pending.resolve, pending.reject);
+        }
+        for (const pending of spreadsheetCalculations){
+            releasePendingRequest(pending);
+            office_kernel_client_fallbackRequest(pending.request, pending.signal, calculateSpreadsheetInJavaScript).then(pending.resolve, pending.reject);
+        }
+        for (const pending of spreadsheetSessionCalculations){
+            releasePendingRequest(pending);
+            fallbackSpreadsheetSessionCalculation(pending.request, pending.fallbackSheets, pending.signal).then(pending.resolve, pending.reject);
+        }
+    };
+}
+async function fallbackSpreadsheetSessionCalculation(request, sheets, signal) {
+    return office_kernel_client_fallbackRequest({
+        request,
+        sheets
+    }, signal, ({ request: fallbackRequest, sheets: fallbackSheets })=>calculateSpreadsheetSessionInJavaScript(fallbackRequest, fallbackSheets));
+}
+async function office_kernel_client_fallbackRequest(request, signal, execute) {
+    if (signal?.aborted) throw abortError();
+    const result = await execute(request);
+    if (signal?.aborted) throw abortError();
+    return result;
+}
+function releasePendingRequest(pending) {
+    pending.removeAbortListener?.();
+    if (void 0 !== pending.timeout) clearTimeout(pending.timeout);
+}
+function abortError() {
+    return new DOMException('Office kernel request was cancelled.', 'AbortError');
+}
+function disposedError() {
+    return new Error('Office kernel client is disposed.');
+}
+export { CollectionState, CommittedOfficeNumberField, OfficeCheckbox, OfficeNumberField, createOfficeKernelClient, handleOfficeTaskPaneKeyDown, isOfficeKernelSpreadsheetError, normalizeOfficeFontFamily, officeFontFamilies, officeFontFamilyLabel, office_kernel_spreadsheet_protocol_OFFICE_KERNEL_SPREADSHEET_MAX_ROWS, useOfficeDialog, useOfficeTaskPaneEscape, useOfficeTaskPaneModal };