@dxos/plugin-sheet 0.6.8-main.046e6cf

package/dist/lib/browser/SheetContainer-H22IDJ43.mjs

@@ -0,0 +1,3740 @@
+import {
+  SheetModel,
+  addressFromA1Notation,
+  addressToA1Notation,
+  columnLetter,
+  inRange,
+  posEquals,
+  rangeToA1Notation,
+  useComputeGraph
+} from "./chunk-AT2FJXQX.mjs";
+import {
+  ValueTypeEnum
+} from "./chunk-6VPEAUG6.mjs";
+import "./chunk-JRL5LGCE.mjs";
+
+// packages/plugins/plugin-sheet/src/components/SheetContainer.tsx
+import React4 from "react";
+import { mx as mx3 } from "@dxos/react-ui-theme";
+
+// packages/plugins/plugin-sheet/src/components/Sheet/Sheet.tsx
+import { DndContext, DragOverlay, KeyboardSensor, MouseSensor, TouchSensor, useDraggable, useDroppable, useSensor, useSensors } from "@dnd-kit/core";
+import { restrictToHorizontalAxis, restrictToVerticalAxis } from "@dnd-kit/modifiers";
+import { getEventCoordinates, useCombinedRefs } from "@dnd-kit/utilities";
+import { Function as FunctionIcon } from "@phosphor-icons/react";
+import { Resizable } from "re-resizable";
+import React3, { forwardRef, useEffect as useEffect3, useImperativeHandle, useRef, useState as useState4 } from "react";
+import { createPortal } from "react-dom";
+import { useResizeDetector } from "react-resize-detector";
+import { debounce } from "@dxos/async";
+import { fullyQualifiedId, createDocAccessor } from "@dxos/client/echo";
+import { log } from "@dxos/log";
+import { createAttendableAttributes } from "@dxos/react-ui-attention";
+import { mx as mx2 } from "@dxos/react-ui-theme";
+
+// packages/plugins/plugin-sheet/src/components/Sheet/grid.ts
+import { useEffect, useState } from "react";
+var axisWidth = "calc(var(--rail-size)-2px)";
+var axisHeight = 34;
+var minWidth = 40;
+var maxWidth = 800;
+var minHeight = axisHeight;
+var maxHeight = 400;
+var defaultWidth = 200;
+var defaultHeight = minHeight;
+var CELL_DATA_KEY = "cell";
+var useGridLayout = ({ scroller, size, rows, columns, rowSizes, columnSizes }) => {
+  const [rowPositions, setRowPositions] = useState([]);
+  useEffect(() => {
+    if (!rowSizes) {
+      return;
+    }
+    let y = 0;
+    setRowPositions(rows.map((idx, i) => {
+      const height2 = rowSizes?.[idx] ?? defaultHeight;
+      const top = y;
+      y += height2 - 1;
+      return {
+        row: i,
+        top,
+        height: height2
+      };
+    }));
+  }, [
+    rows,
+    rowSizes
+  ]);
+  const [columnPositions, setColumnPositions] = useState([]);
+  useEffect(() => {
+    if (!columns) {
+      return;
+    }
+    let x = 0;
+    setColumnPositions(columns.map((idx, i) => {
+      const width2 = columnSizes?.[idx] ?? defaultWidth;
+      const left = x;
+      x += width2 - 1;
+      return {
+        column: i,
+        left,
+        width: width2
+      };
+    }));
+  }, [
+    columns,
+    columnSizes
+  ]);
+  const height = rowPositions.length ? rowPositions[rowPositions.length - 1].top + rowPositions[rowPositions.length - 1].height : 0;
+  const width = columnPositions.length ? columnPositions[columnPositions.length - 1].left + columnPositions[columnPositions.length - 1].width : 0;
+  const [{ rowRange, columnRange }, setWindow] = useState({
+    rowRange: [],
+    columnRange: []
+  });
+  useEffect(() => {
+    const handleScroll = () => {
+      if (!scroller) {
+        return;
+      }
+      const { scrollLeft: left, scrollTop: top, clientWidth: width2, clientHeight: height2 } = scroller;
+      let rowStart = 0;
+      let rowEnd = 0;
+      for (let i = 0; i < rowPositions.length; i++) {
+        const row = rowPositions[i];
+        if (row.top <= top) {
+          rowStart = i;
+        }
+        if (row.top + row.height >= top + height2) {
+          rowEnd = i;
+          break;
+        }
+      }
+      let columnStart = 0;
+      let columnEnd = 0;
+      for (let i = 0; i < columnPositions.length; i++) {
+        const column = columnPositions[i];
+        if (column.left <= left) {
+          columnStart = i;
+        }
+        if (column.left + column.width >= left + width2) {
+          columnEnd = i;
+          break;
+        }
+      }
+      const overscan = 5;
+      setWindow({
+        rowRange: rowPositions.slice(Math.max(0, rowStart - overscan), Math.min(rowPositions.length, rowEnd + overscan)),
+        columnRange: columnPositions.slice(Math.max(0, columnStart - overscan), Math.min(columnPositions.length, columnEnd + overscan))
+      });
+    };
+    scroller?.addEventListener("scroll", handleScroll);
+    handleScroll();
+    return () => {
+      scroller?.removeEventListener("scroll", handleScroll);
+    };
+  }, [
+    size.width,
+    size.height,
+    rowPositions,
+    columnPositions
+  ]);
+  return {
+    width,
+    height,
+    rowRange,
+    columnRange
+  };
+};
+var getCellAtPointer = (event) => {
+  const element = document.elementFromPoint(event.clientX, event.clientY);
+  const root = element?.closest(`[data-${CELL_DATA_KEY}]`);
+  if (root) {
+    const value = root.dataset[CELL_DATA_KEY];
+    if (value) {
+      return addressFromA1Notation(value);
+    }
+  }
+};
+var getCellElement = (root, cell) => {
+  const pos = addressToA1Notation(cell);
+  return root.querySelector(`[data-${CELL_DATA_KEY}="${pos}"]`);
+};
+
+// packages/plugins/plugin-sheet/src/components/Sheet/nav.ts
+import { useState as useState2 } from "react";
+var handleNav = (ev, cursor, range, size) => {
+  if (cursor && ev.shiftKey) {
+    const opposite = range?.to ?? {
+      ...cursor
+    };
+    switch (ev.key) {
+      case "ArrowUp": {
+        if (opposite.row > 0) {
+          opposite.row -= 1;
+        }
+        break;
+      }
+      case "ArrowDown": {
+        if (opposite.row < size.numRows - 1) {
+          opposite.row += 1;
+        }
+        break;
+      }
+      case "ArrowLeft": {
+        if (opposite.column > 0) {
+          opposite.column -= 1;
+        }
+        break;
+      }
+      case "ArrowRight": {
+        if (opposite.column < size.numColumns - 1) {
+          opposite.column += 1;
+        }
+        break;
+      }
+    }
+    return {
+      cursor,
+      range: {
+        from: cursor,
+        to: opposite
+      }
+    };
+  }
+  const next = handleArrowNav(ev, cursor, size);
+  return {
+    cursor: next
+  };
+};
+var handleArrowNav = (ev, cursor, { numRows, numColumns }) => {
+  switch (ev.key) {
+    case "ArrowUp":
+      if (cursor === void 0) {
+        return {
+          row: 0,
+          column: 0
+        };
+      } else if (cursor.row > 0) {
+        return {
+          row: ev.metaKey ? 0 : cursor.row - 1,
+          column: cursor.column
+        };
+      }
+      break;
+    case "ArrowDown":
+      if (cursor === void 0) {
+        return {
+          row: 0,
+          column: 0
+        };
+      } else if (cursor.row < numRows - 1) {
+        return {
+          row: ev.metaKey ? numRows - 1 : cursor.row + 1,
+          column: cursor.column
+        };
+      }
+      break;
+    case "ArrowLeft":
+      if (cursor === void 0) {
+        return {
+          row: 0,
+          column: 0
+        };
+      } else if (cursor.column > 0) {
+        return {
+          row: cursor.row,
+          column: ev.metaKey ? 0 : cursor.column - 1
+        };
+      }
+      break;
+    case "ArrowRight":
+      if (cursor === void 0) {
+        return {
+          row: 0,
+          column: 0
+        };
+      } else if (cursor.column < numColumns - 1) {
+        return {
+          row: cursor.row,
+          column: ev.metaKey ? numColumns - 1 : cursor.column + 1
+        };
+      }
+      break;
+    case "Home":
+      return {
+        row: 0,
+        column: 0
+      };
+    case "End":
+      return {
+        row: numRows - 1,
+        column: numColumns - 1
+      };
+  }
+};
+var useRangeSelect = (cb) => {
+  const [from, setFrom] = useState2();
+  const [to, setTo] = useState2();
+  const onMouseDown = (ev) => {
+    const current = getCellAtPointer(ev);
+    setFrom(current);
+    if (current) {
+      setTimeout(() => cb("start", {
+        from: current
+      }));
+    }
+  };
+  const onMouseMove = (ev) => {
+    if (from) {
+      let current = getCellAtPointer(ev);
+      if (posEquals(current, from)) {
+        current = void 0;
+      }
+      setTo(current);
+      setTimeout(() => cb("move", {
+        from,
+        to: current
+      }));
+    }
+  };
+  const onMouseUp = (ev) => {
+    if (from) {
+      let current = getCellAtPointer(ev);
+      if (posEquals(current, from)) {
+        current = void 0;
+      }
+      setFrom(void 0);
+      setTo(void 0);
+      setTimeout(() => cb("end", current ? {
+        from,
+        to: current
+      } : void 0));
+    }
+  };
+  return {
+    range: from ? {
+      from,
+      to
+    } : void 0,
+    handlers: {
+      onMouseDown,
+      onMouseMove,
+      onMouseUp
+    }
+  };
+};
+
+// packages/plugins/plugin-sheet/src/components/Sheet/sheet-context.tsx
+import React, { createContext, useContext, useState as useState3, useEffect as useEffect2 } from "react";
+import { invariant } from "@dxos/invariant";
+
+// packages/plugins/plugin-sheet/src/components/Sheet/formatting.ts
+var FormattingModel = class {
+  constructor(model) {
+    this.model = model;
+  }
+  /**
+  * Get formatted string value and className for cell.
+  */
+  getFormatting(cell) {
+    const value = this.model.getValue(cell);
+    if (value === void 0 || value === null) {
+      return {};
+    }
+    const locales = void 0;
+    const idx = this.model.addressToIndex(cell);
+    let formatting = this.model.sheet.formatting?.[idx] ?? {};
+    const classNames = [
+      ...formatting?.classNames ?? []
+    ];
+    for (const [idx2, _formatting] of Object.entries(this.model.sheet.formatting)) {
+      const range = this.model.rangeFromIndex(idx2);
+      if (inRange(range, cell)) {
+        if (_formatting.classNames) {
+          classNames.push(..._formatting.classNames);
+        }
+        if (_formatting.type) {
+          formatting = _formatting;
+        }
+      }
+    }
+    const defaultNumber = "justify-end font-mono";
+    const type = formatting?.type ?? this.model.getValueType(cell);
+    switch (type) {
+      case ValueTypeEnum.Boolean: {
+        return {
+          value: value.toLocaleString().toUpperCase(),
+          classNames: [
+            ...classNames,
+            value ? "!text-green-500" : "!text-orange-500"
+          ]
+        };
+      }
+      case ValueTypeEnum.Number: {
+        return {
+          value: value.toLocaleString(locales),
+          classNames: [
+            ...classNames,
+            defaultNumber
+          ]
+        };
+      }
+      case ValueTypeEnum.Percent: {
+        return {
+          value: value * 100 + "%",
+          classNames: [
+            ...classNames,
+            defaultNumber
+          ]
+        };
+      }
+      case ValueTypeEnum.Currency: {
+        return {
+          value: value.toLocaleString(locales, {
+            style: "currency",
+            currency: "USD",
+            minimumFractionDigits: 2,
+            maximumFractionDigits: 2
+          }),
+          classNames: [
+            ...classNames,
+            defaultNumber
+          ]
+        };
+      }
+      case ValueTypeEnum.DateTime: {
+        const date = this.model.toLocalDate(value);
+        return {
+          value: date.toLocaleString(locales),
+          classNames
+        };
+      }
+      case ValueTypeEnum.Date: {
+        const date = this.model.toLocalDate(value);
+        return {
+          value: date.toLocaleDateString(locales),
+          classNames
+        };
+      }
+      case ValueTypeEnum.Time: {
+        const date = this.model.toLocalDate(value);
+        return {
+          value: date.toLocaleTimeString(locales),
+          classNames
+        };
+      }
+      default: {
+        return {
+          value: String(value),
+          classNames
+        };
+      }
+    }
+  }
+};
+
+// packages/plugins/plugin-sheet/src/components/Sheet/sheet-context.tsx
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/plugins/plugin-sheet/src/components/Sheet/sheet-context.tsx";
+var SheetContext = /* @__PURE__ */ createContext(null);
+var useSheetContext = () => {
+  const context = useContext(SheetContext);
+  invariant(context, void 0, {
+    F: __dxlog_file,
+    L: 39,
+    S: void 0,
+    A: [
+      "context",
+      ""
+    ]
+  });
+  return context;
+};
+var SheetContextProvider = ({ children, sheet, space, readonly, onInfo }) => {
+  const graph = useComputeGraph(space);
+  const [cursor, setCursor] = useState3();
+  const [range, setRange] = useState3();
+  const [editing, setEditing] = useState3(false);
+  const [[model, formatting] = [], setModels] = useState3(void 0);
+  useEffect2(() => {
+    let model2;
+    let formatting2;
+    const t = setTimeout(async () => {
+      model2 = new SheetModel(graph, sheet, {
+        readonly
+      });
+      await model2.initialize();
+      formatting2 = new FormattingModel(model2);
+      setModels([
+        model2,
+        formatting2
+      ]);
+    });
+    return () => {
+      clearTimeout(t);
+      void model2?.destroy();
+    };
+  }, [
+    graph,
+    readonly
+  ]);
+  if (!model || !formatting) {
+    return null;
+  }
+  return /* @__PURE__ */ React.createElement(SheetContext.Provider, {
+    value: {
+      model,
+      formatting,
+      cursor,
+      setCursor,
+      range,
+      setRange,
+      editing,
+      setEditing,
+      // TODO(burdon): Change to event.
+      onInfo
+    }
+  }, children);
+};
+
+// packages/plugins/plugin-sheet/src/components/Sheet/util.ts
+var getRelativeClientRect = (root, element) => {
+  const rootRect = root.getBoundingClientRect();
+  const elementRect = element.getBoundingClientRect();
+  return new DOMRect(elementRect.left - rootRect.left + root.scrollLeft, elementRect.top - rootRect.top + root.scrollTop, elementRect.width, elementRect.height);
+};
+var getRectUnion = (b1, b2) => {
+  return {
+    left: Math.min(b1.left, b2.left),
+    top: Math.min(b1.top, b2.top),
+    width: Math.abs(b1.left - b2.left) + (b1.left > b2.left ? b1.width : b2.width),
+    height: Math.abs(b1.top - b2.top) + (b1.height > b2.height ? b1.height : b2.height)
+  };
+};
+var scrollIntoView = (scrollContainer, el) => {
+  el.scrollIntoView({
+    block: "nearest",
+    inline: "nearest"
+  });
+  const cellBounds = el.getBoundingClientRect();
+  const scrollerBounds = scrollContainer.getBoundingClientRect();
+  if (cellBounds.top < scrollerBounds.top) {
+    scrollContainer.scrollTop -= scrollerBounds.top - cellBounds.top;
+  } else if (cellBounds.bottom >= scrollerBounds.bottom - 1) {
+    scrollContainer.scrollTop += 2 + scrollerBounds.bottom - cellBounds.bottom;
+  }
+  if (cellBounds.left < scrollerBounds.left) {
+    scrollContainer.scrollLeft -= scrollerBounds.left - cellBounds.left;
+  } else if (cellBounds.right >= scrollerBounds.right) {
+    scrollContainer.scrollLeft += 2 + scrollerBounds.right - cellBounds.right;
+  }
+};
+
+// packages/plugins/plugin-sheet/src/components/CellEditor/CellEditor.tsx
+import { EditorView, keymap } from "@codemirror/view";
+import React2 from "react";
+import { useThemeContext } from "@dxos/react-ui";
+import { createBasicExtensions, createThemeExtensions, preventNewline, useTextEditor } from "@dxos/react-ui-editor";
+var editorKeys = ({ onNav, onClose }) => {
+  return keymap.of([
+    {
+      key: "ArrowUp",
+      run: (editor) => {
+        const value = editor.state.doc.toString();
+        onNav?.(value, {
+          key: "ArrowUp"
+        });
+        return !!onNav;
+      }
+    },
+    {
+      key: "ArrowDown",
+      run: (editor) => {
+        const value = editor.state.doc.toString();
+        onNav?.(value, {
+          key: "ArrowDown"
+        });
+        return !!onNav;
+      }
+    },
+    {
+      key: "ArrowLeft",
+      run: (editor) => {
+        const value = editor.state.doc.toString();
+        onNav?.(value, {
+          key: "ArrowLeft"
+        });
+        return !!onNav;
+      }
+    },
+    {
+      key: "ArrowRight",
+      run: (editor) => {
+        const value = editor.state.doc.toString();
+        onNav?.(value, {
+          key: "ArrowRight"
+        });
+        return !!onNav;
+      }
+    },
+    {
+      key: "Enter",
+      run: (editor) => {
+        onClose(editor.state.doc.toString());
+        return true;
+      }
+    },
+    {
+      key: "Escape",
+      run: () => {
+        onClose(void 0);
+        return true;
+      }
+    }
+  ]);
+};
+var CellEditor = ({ value, extension, autoFocus, onBlur }) => {
+  const { themeMode } = useThemeContext();
+  const { parentRef } = useTextEditor(() => {
+    return {
+      autoFocus,
+      initialValue: value,
+      selection: {
+        anchor: value?.length ?? 0
+      },
+      extensions: [
+        extension ?? [],
+        preventNewline,
+        EditorView.focusChangeEffect.of((_, focusing) => {
+          if (!focusing) {
+            onBlur?.({
+              type: "blur"
+            });
+          }
+          return null;
+        }),
+        createBasicExtensions({
+          lineWrapping: false
+        }),
+        createThemeExtensions({
+          themeMode,
+          slots: {
+            editor: {
+              className: "flex w-full [&>.cm-scroller]:scrollbar-none"
+            },
+            content: {
+              className: "!px-2 !py-1"
+            }
+          }
+        })
+      ]
+    };
+  }, [
+    extension
+  ]);
+  return /* @__PURE__ */ React2.createElement("div", {
+    ref: parentRef,
+    className: "flex w-full"
+  });
+};
+
+// packages/plugins/plugin-sheet/src/components/CellEditor/extension.ts
+import { acceptCompletion, autocompletion, completionStatus, startCompletion } from "@codemirror/autocomplete";
+import { HighlightStyle, syntaxHighlighting } from "@codemirror/language";
+import { Facet } from "@codemirror/state";
+import { ViewPlugin, keymap as keymap2 } from "@codemirror/view";
+import { tags } from "@lezer/highlight";
+import { spreadsheet } from "codemirror-lang-spreadsheet";
+import { mx } from "@dxos/react-ui-theme";
+
+// packages/plugins/plugin-sheet/src/components/CellEditor/functions.ts
+var functions = {
+  Array: [
+    {
+      function: "ARRAYFORMULA",
+      description: "Enables the array arithmetic mode for a single formula.",
+      syntax: "ARRAYFORMULA(Formula)"
+    },
+    {
+      function: "FILTER",
+      description: "Filters an array, based on multiple conditions (boolean arrays).",
+      syntax: "FILTER(SourceArray, BoolArray1, BoolArray2, ...BoolArrayN)"
+    },
+    {
+      function: "ARRAY_CONSTRAIN",
+      description: "Truncates an array to given dimensions.",
+      syntax: "ARRAY_CONSTRAIN(Array, Height, Width)"
+    }
+  ],
+  "Date and time": [
+    {
+      function: "DATE",
+      description: "Returns the specified date as the number of full days since nullDate.",
+      syntax: "DATE(Year, Month, Day)"
+    },
+    {
+      function: "DATEDIF",
+      description: "Calculates distance between two dates, in provided unit parameter.",
+      syntax: "DATEDIF(Date1, Date2, Units)"
+    },
+    {
+      function: "DATEVALUE",
+      description: "Parses a date string and returns it as the number of full days since nullDate.",
+      syntax: "DATEVALUE(Datestring)"
+    },
+    {
+      function: "DAY",
+      description: "Returns the day of the given date value.",
+      syntax: "DAY(Number)"
+    },
+    {
+      function: "DAYS",
+      description: "Calculates the difference between two date values.",
+      syntax: "DAYS(Date2, Date1)"
+    },
+    {
+      function: "DAYS360",
+      description: "Calculates the difference between two date values in days, in 360-day basis.",
+      syntax: "DAYS360(Date2, Date1[, Format])"
+    },
+    {
+      function: "EDATE",
+      description: "Shifts the given startdate by given number of months and returns it as the number of full days since nullDate.",
+      syntax: "EDATE(Startdate, Months)"
+    },
+    {
+      function: "EOMONTH",
+      description: "Returns the date of the last day of a month which falls months away from the start date.",
+      syntax: "EOMONTH(Startdate, Months)"
+    },
+    {
+      function: "HOUR",
+      description: "Returns hour component of given time.",
+      syntax: "HOUR(Time)"
+    },
+    {
+      function: "INTERVAL",
+      description: "Returns interval string from given number of seconds.",
+      syntax: "INTERVAL(Seconds)"
+    },
+    {
+      function: "ISOWEEKNUM",
+      description: "Returns an ISO week number that corresponds to the week of year.",
+      syntax: "ISOWEEKNUM(Date)"
+    },
+    {
+      function: "MINUTE",
+      description: "Returns minute component of given time.",
+      syntax: "MINUTE(Time)"
+    },
+    {
+      function: "MONTH",
+      description: "Returns the month for the given date value.",
+      syntax: "MONTH(Number)"
+    },
+    {
+      function: "NETWORKDAYS",
+      description: "Returns the number of working days between two given dates.",
+      syntax: "NETWORKDAYS(Date1, Date2[, Holidays])"
+    },
+    {
+      function: "NETWORKDAYS.INTL",
+      description: "Returns the number of working days between two given dates.",
+      syntax: "NETWORKDAYS.INTL(Date1, Date2[, Mode [, Holidays]])"
+    },
+    {
+      function: "NOW",
+      description: "Returns current date + time as a number of days since nullDate.",
+      syntax: "NOW()"
+    },
+    {
+      function: "SECOND",
+      description: "Returns second component of given time.",
+      syntax: "SECOND(Time)"
+    },
+    {
+      function: "TIME",
+      description: "Returns the number that represents a given time as a fraction of full day.",
+      syntax: "TIME(Hour, Minute, Second)"
+    },
+    {
+      function: "TIMEVALUE",
+      description: "Parses a time string and returns a number that represents it as a fraction of a full day.",
+      syntax: "TIMEVALUE(Timestring)"
+    },
+    {
+      function: "TODAY",
+      description: "Returns an integer representing the current date as the number of full days since nullDate.",
+      syntax: "TODAY()"
+    },
+    {
+      function: "WEEKDAY",
+      description: "Computes a number between 1-7 representing the day of week.",
+      syntax: "WEEKDAY(Date, Type)"
+    },
+    {
+      function: "WEEKNUM",
+      description: "Returns a week number that corresponds to the week of year.",
+      syntax: "WEEKNUM(Date, Type)"
+    },
+    {
+      function: "WORKDAY",
+      description: "Returns the working day number of days from start day.",
+      syntax: "WORKDAY(Date, Shift[, Holidays])"
+    },
+    {
+      function: "WORKDAY.INTL",
+      description: "Returns the working day number of days from start day.",
+      syntax: "WORKDAY.INTL(Date, Shift[, Mode[, Holidays]])"
+    },
+    {
+      function: "YEAR",
+      description: "Returns the year as a number according to the internal calculation rules.",
+      syntax: "YEAR(Number)"
+    },
+    {
+      function: "YEARFRAC",
+      description: "Computes the difference between two date values, in fraction of years.",
+      syntax: "YEARFRAC(Date2, Date1[, Format])"
+    }
+  ],
+  Engineering: [
+    {
+      function: "BIN2DEC",
+      description: "The result is the decimal number for the binary number entered.",
+      syntax: "BIN2DEC(Number)"
+    },
+    {
+      function: "BIN2HEX",
+      description: "The result is the hexadecimal number for the binary number entered.",
+      syntax: "BIN2HEX(Number, Places)"
+    },
+    {
+      function: "BIN2OCT",
+      description: "The result is the octal number for the binary number entered.",
+      syntax: "BIN2OCT(Number, Places)"
+    },
+    {
+      function: "BITAND",
+      description: "Returns a bitwise logical 'and' of the parameters.",
+      syntax: "BITAND(Number1, Number2)"
+    },
+    {
+      function: "BITLSHIFT",
+      description: "Shifts a number left by n bits.",
+      syntax: "BITLSHIFT(Number, Shift)"
+    },
+    {
+      function: "BITOR",
+      description: "Returns a bitwise logical 'or' of the parameters.",
+      syntax: "BITOR(Number1, Number2)"
+    },
+    {
+      function: "BITRSHIFT",
+      description: "Shifts a number right by n bits.",
+      syntax: "BITRSHIFT(Number, Shift)"
+    },
+    {
+      function: "BITXOR",
+      description: "Returns a bitwise logical 'exclusive or' of the parameters.",
+      syntax: "BITXOR(Number1, Number2)"
+    },
+    {
+      function: "COMPLEX",
+      description: "Returns complex number from Re and Im parts.",
+      syntax: "COMPLEX(Re, Im[, Symbol])"
+    },
+    {
+      function: "DEC2BIN",
+      description: "Returns the binary number for the decimal number entered between \u2013512 and 511.",
+      syntax: "DEC2BIN(Number, Places)"
+    },
+    {
+      function: "DEC2HEX",
+      description: "Returns the hexadecimal number for the decimal number entered.",
+      syntax: "DEC2HEX(Number, Places)"
+    },
+    {
+      function: "DEC2OCT",
+      description: "Returns the octal number for the decimal number entered.",
+      syntax: "DEC2OCT(Number, Places)"
+    },
+    {
+      function: "DELTA",
+      description: "Returns TRUE (1) if both numbers are equal, otherwise returns FALSE (0).",
+      syntax: "DELTA(Number_1, Number_2)"
+    },
+    {
+      function: "ERF",
+      description: "Returns values of the Gaussian error integral.",
+      syntax: "ERF(Lower_Limit, Upper_Limit)"
+    },
+    {
+      function: "ERFC",
+      description: "Returns complementary values of the Gaussian error integral between x and infinity.",
+      syntax: "ERFC(Lower_Limit)"
+    },
+    {
+      function: "HEX2BIN",
+      description: "The result is the binary number for the hexadecimal number entered.",
+      syntax: "HEX2BIN(Number, Places)"
+    },
+    {
+      function: "HEX2DEC",
+      description: "The result is the decimal number for the hexadecimal number entered.",
+      syntax: "HEX2DEC(Number)"
+    },
+    {
+      function: "HEX2OCT",
+      description: "The result is the octal number for the hexadecimal number entered.",
+      syntax: "HEX2OCT(Number, Places)"
+    },
+    {
+      function: "IMABS",
+      description: "Returns module of a complex number.",
+      syntax: "IMABS(Complex)"
+    },
+    {
+      function: "IMAGINARY",
+      description: "Returns imaginary part of a complex number.",
+      syntax: "IMAGINARY(Complex)"
+    },
+    {
+      function: "IMARGUMENT",
+      description: "Returns argument of a complex number.",
+      syntax: "IMARGUMENT(Complex)"
+    },
+    {
+      function: "IMCONJUGATE",
+      description: "Returns conjugate of a complex number.",
+      syntax: "IMCONJUGATE(Complex)"
+    },
+    {
+      function: "IMCOS",
+      description: "Returns cosine of a complex number.",
+      syntax: "IMCOS(Complex)"
+    },
+    {
+      function: "IMCOSH",
+      description: "Returns hyperbolic cosine of a complex number.",
+      syntax: "IMCOSH(Complex)"
+    },
+    {
+      function: "IMCOT",
+      description: "Returns cotangens of a complex number.",
+      syntax: "IMCOT(Complex)"
+    },
+    {
+      function: "IMCSC",
+      description: "Returns cosecans of a complex number.",
+      syntax: "IMCSC(Complex)"
+    },
+    {
+      function: "IMCSCH",
+      description: "Returns hyperbolic cosecans of a complex number.",
+      syntax: "IMCSCH(Complex)"
+    },
+    {
+      function: "IMDIV",
+      description: "Divides two complex numbers.",
+      syntax: "IMDIV(Complex1, Complex2)"
+    },
+    {
+      function: "IMEXP",
+      description: "Returns exponent of a complex number.",
+      syntax: "IMEXP(Complex)"
+    },
+    {
+      function: "IMLN",
+      description: "Returns natural logarithm of a complex number.",
+      syntax: "IMLN(Complex)"
+    },
+    {
+      function: "IMLOG2",
+      description: "Returns binary logarithm of a complex number.",
+      syntax: "IMLOG2(Complex)"
+    },
+    {
+      function: "IMLOG10",
+      description: "Returns base-10 logarithm of a complex number.",
+      syntax: "IMLOG10(Complex)"
+    },
+    {
+      function: "IMPOWER",
+      description: "Returns a complex number raised to a given power.",
+      syntax: "IMPOWER(Complex, Number)"
+    },
+    {
+      function: "IMPRODUCT",
+      description: "Multiplies complex numbers.",
+      syntax: "IMPRODUCT(Complex1, Complex2, ...ComplexN)"
+    },
+    {
+      function: "IMREAL",
+      description: "Returns real part of a complex number.",
+      syntax: "IMREAL(Complex)"
+    },
+    {
+      function: "IMSEC",
+      description: "Returns the secant of a complex number.",
+      syntax: "IMSEC(Complex)"
+    },
+    {
+      function: "IMSECH",
+      description: "Returns the hyperbolic secant of a complex number.",
+      syntax: "IMSECH(Complex)"
+    },
+    {
+      function: "IMSIN",
+      description: "Returns sine of a complex number.",
+      syntax: "IMSIN(Complex)"
+    },
+    {
+      function: "IMSINH",
+      description: "Returns hyperbolic sine of a complex number.",
+      syntax: "IMSINH(Complex)"
+    },
+    {
+      function: "IMSQRT",
+      description: "Returns a square root of a complex number.",
+      syntax: "IMSQRT(Complex)"
+    },
+    {
+      function: "IMSUB",
+      description: "Subtracts two complex numbers.",
+      syntax: "IMSUB(Complex1, Complex2)"
+    },
+    {
+      function: "IMSUM",
+      description: "Adds complex numbers.",
+      syntax: "IMSUM(Complex1, Complex2, ..ComplexN)"
+    },
+    {
+      function: "IMTAN",
+      description: "Returns the tangent of a complex number.",
+      syntax: "IMTAN(Complex)"
+    },
+    {
+      function: "OCT2BIN",
+      description: "The result is the binary number for the octal number entered.",
+      syntax: "OCT2BIN(Number, Places)"
+    },
+    {
+      function: "OCT2DEC",
+      description: "The result is the decimal number for the octal number entered.",
+      syntax: "OCT2DEC(Number)"
+    },
+    {
+      function: "OCT2HEX",
+      description: "The result is the hexadecimal number for the octal number entered.",
+      syntax: "OCT2HEX(Number, Places)"
+    }
+  ],
+  Information: [
+    {
+      function: "ISBINARY",
+      description: "Returns TRUE if provided value is a valid binary number.",
+      syntax: "ISBINARY(Value)"
+    },
+    {
+      function: "ISBLANK",
+      description: "Returns TRUE if the reference to a cell is blank.",
+      syntax: "ISBLANK(Value)"
+    },
+    {
+      function: "ISERR",
+      description: "Returns TRUE if the value is error value except #N/A!.",
+      syntax: "ISERR(Value)"
+    },
+    {
+      function: "ISERROR",
+      description: "Returns TRUE if the value is general error value.",
+      syntax: "ISERROR(Value)"
+    },
+    {
+      function: "ISEVEN",
+      description: "Returns TRUE if the value is an even integer, or FALSE if the value is odd.",
+      syntax: "ISEVEN(Value)"
+    },
+    {
+      function: "ISFORMULA",
+      description: "Checks whether referenced cell is a formula.",
+      syntax: "ISFORMULA(Value)"
+    },
+    {
+      function: "ISLOGICAL",
+      description: "Tests for a logical value (TRUE or FALSE).",
+      syntax: "ISLOGICAL(Value)"
+    },
+    {
+      function: "ISNA",
+      description: "Returns TRUE if the value is #N/A! error.",
+      syntax: "ISNA(Value)"
+    },
+    {
+      function: "ISNONTEXT",
+      description: "Tests if the cell contents are text or numbers, and returns FALSE if the contents are text.",
+      syntax: "ISNONTEXT(Value)"
+    },
+    {
+      function: "ISNUMBER",
+      description: "Returns TRUE if the value refers to a number.",
+      syntax: "ISNUMBER(Value)"
+    },
+    {
+      function: "ISODD",
+      description: "Returns TRUE if the value is odd, or FALSE if the number is even.",
+      syntax: "ISODD(Value)"
+    },
+    {
+      function: "ISREF",
+      description: "Returns TRUE if provided value is #REF! error.",
+      syntax: "ISREF(Value)"
+    },
+    {
+      function: "ISTEXT",
+      description: "Returns TRUE if the cell contents reference text.",
+      syntax: "ISTEXT(Value)"
+    },
+    {
+      function: "SHEET",
+      description: "Returns sheet number of a given value or a formula sheet number if no argument is provided.",
+      syntax: "SHEET([Value])"
+    },
+    {
+      function: "SHEETS",
+      description: "Returns number of sheet of a given reference or number of all sheets in workbook when no argument is provided.",
+      syntax: "SHEETS([Value])"
+    },
+    {
+      function: "NA",
+      description: "Returns #N/A! error value.",
+      syntax: "NA(Value)"
+    }
+  ],
+  Financial: [
+    {
+      function: "CUMIPMT",
+      description: "Returns the cumulative interest paid on a loan between a start period and an end period.",
+      syntax: "CUMIPMT(Rate, Nper, Pv, Start, End, type)"
+    },
+    {
+      function: "CUMPRINC",
+      description: "Returns the cumulative principal paid on a loan between a start period and an end period.",
+      syntax: "CUMPRINC(Rate, Nper, Pv, Start, End, Type)"
+    },
+    {
+      function: "DB",
+      description: "Returns the depreciation of an asset for a period using the fixed-declining balance method.",
+      syntax: "DB(Cost, Salvage, Life, Period[, Month])"
+    },
+    {
+      function: "DDB",
+      description: "Returns the depreciation of an asset for a period using the double-declining balance method.",
+      syntax: "DDB(Cost, Salvage, Life, Period[, Factor])"
+    },
+    {
+      function: "DOLLARDE",
+      description: "Converts a price entered with a special notation to a price displayed as a decimal number.",
+      syntax: "DOLLARDE(Price, Fraction)"
+    },
+    {
+      function: "DOLLARFR",
+      description: "Converts a price displayed as a decimal number to a price entered with a special notation.",
+      syntax: "DOLLARFR(Price, Fraction)"
+    },
+    {
+      function: "EFFECT",
+      description: "Calculates the effective annual interest rate from a nominal interest rate and the number of compounding periods per year.",
+      syntax: "EFFECT(Nominal_rate, Npery)"
+    },
+    {
+      function: "FV",
+      description: "Returns the future value of an investment.",
+      syntax: "FV(Rate, Nper, Pmt[, Pv,[ Type]])"
+    },
+    {
+      function: "FVSCHEDULE",
+      description: "Returns the future value of an investment based on a rate schedule.",
+      syntax: "FVSCHEDULE(Pv, Schedule)"
+    },
+    {
+      function: "IPMT",
+      description: "Returns the interest portion of a given loan payment in a given payment period.",
+      syntax: "IPMT(Rate, Per, Nper, Pv[, Fv[, Type]])"
+    },
+    {
+      function: "ISPMT",
+      description: "Returns the interest paid for a given period of an investment with equal principal payments.",
+      syntax: "ISPMT(Rate, Per, Nper, Value)"
+    },
+    {
+      function: "MIRR",
+      description: "Returns modified internal value for cashflows.",
+      syntax: "MIRR(Flows, FRate, RRate)"
+    },
+    {
+      function: "NOMINAL",
+      description: "Returns the nominal interest rate.",
+      syntax: "NOMINAL(Effect_rate, Npery)"
+    },
+    {
+      function: "NPER",
+      description: "Returns the number of periods for an investment assuming periodic, constant payments and a constant interest rate.",
+      syntax: "NPER(Rate, Pmt, Pv[, Fv[, Type]])"
+    },
+    {
+      function: "NPV",
+      description: "Returns net present value.",
+      syntax: "NPV(Rate, Value1, Value2, ...ValueN)"
+    },
+    {
+      function: "PDURATION",
+      description: "Returns number of periods to reach specific value.",
+      syntax: "PDURATION(Rate, Pv, Fv)"
+    },
+    {
+      function: "PMT",
+      description: "Returns the periodic payment for a loan.",
+      syntax: "PMT(Rate, Nper, Pv[, Fv[, Type]])"
+    },
+    {
+      function: "PPMT",
+      description: "Calculates the principal portion of a given loan payment.",
+      syntax: "PPMT(Rate, Per, Nper, Pv[, Fv[, Type]])"
+    },
+    {
+      function: "PV",
+      description: "Returns the present value of an investment.",
+      syntax: "PV(Rate, Nper, Pmt[, Fv[, Type]])"
+    },
+    {
+      function: "RATE",
+      description: "Returns the interest rate per period of an annuity.",
+      syntax: "RATE(Nper, Pmt, Pv[, Fv[, Type[, guess]]])"
+    },
+    {
+      function: "RRI",
+      description: "Returns an equivalent interest rate for the growth of an investment.",
+      syntax: "RRI(Nper, Pv, Fv)"
+    },
+    {
+      function: "SLN",
+      description: "Returns the depreciation of an asset for one period, based on a straight-line method.",
+      syntax: "SLN(Cost, Salvage, Life)"
+    },
+    {
+      function: "SYD",
+      description: "Returns the 'sum-of-years' depreciation for an asset in a period.",
+      syntax: "SYD(Cost, Salvage, Life, Period)"
+    },
+    {
+      function: "TBILLEQ",
+      description: "Returns the bond-equivalent yield for a Treasury bill.",
+      syntax: "TBILLEQ(Settlement, Maturity, Discount)"
+    },
+    {
+      function: "TBILLPRICE",
+      description: "Returns the price per $100 face value for a Treasury bill.",
+      syntax: "TBILLPRICE(Settlement, Maturity, Discount)"
+    },
+    {
+      function: "TBILLYIELD",
+      description: "Returns the yield for a Treasury bill.",
+      syntax: "TBILLYIELD(Settlement, Maturity, Price)"
+    },
+    {
+      function: "XNPV",
+      description: "Returns net present value.",
+      syntax: "XNPV(Rate, Payments, Dates)"
+    }
+  ],
+  Logical: [
+    {
+      function: "AND",
+      description: "Returns TRUE if all arguments are TRUE.",
+      syntax: "AND(Logical_value1, Logical_value2, ...Logical_valueN)"
+    },
+    {
+      function: "FALSE",
+      description: "Returns the logical value FALSE.",
+      syntax: "FALSE()"
+    },
+    {
+      function: "IF",
+      description: "Specifies a logical test to be performed.",
+      syntax: "IF(Test, Then_value, Otherwise_value)"
+    },
+    {
+      function: "IFS",
+      description: "Evaluates multiple logical tests and returns a value that corresponds to the first true condition.",
+      syntax: "IFS(Condition1, Value1 [, Condition2, Value2 [, ...ConditionN, ValueN]])"
+    },
+    {
+      function: "IFNA",
+      description: "Returns the value if the cell does not contains the #N/A (value not available) error value, or the alternative value if it does.",
+      syntax: "IFNA(Value, Alternate_value)"
+    },
+    {
+      function: "IFERROR",
+      description: "Returns the value if the cell does not contains an error value, or the alternative value if it does.",
+      syntax: "IFERROR(Value, Alternate_value)"
+    },
+    {
+      function: "NOT",
+      description: "Complements (inverts) a logical value.",
+      syntax: "NOT(Logicalvalue)"
+    },
+    {
+      function: "SWITCH",
+      description: "Evaluates a list of arguments, consisting of an expression followed by a value.",
+      syntax: "SWITCH(Expression1, Value1 [, Expression2, Value2 [, ...ExpressionN, ValueN]])"
+    },
+    {
+      function: "OR",
+      description: "Returns TRUE if at least one argument is TRUE.",
+      syntax: "OR(Logical_value1, Logical_value2, ...Logical_valueN)"
+    },
+    {
+      function: "TRUE",
+      description: "The logical value is set to TRUE.",
+      syntax: "TRUE()"
+    },
+    {
+      function: "XOR",
+      description: "Returns true if an odd number of arguments evaluates to TRUE.",
+      syntax: "XOR(Logical_value1, Logical_value2, ...Logical_valueN)"
+    }
+  ],
+  "Lookup and reference": [
+    {
+      function: "ADDRESS",
+      description: "Returns a cell reference as a string.",
+      syntax: "ADDRESS(Row, Column[, AbsoluteRelativeMode[, UseA1Notation[, Sheet]]])"
+    },
+    {
+      function: "CHOOSE",
+      description: "Uses an index to return a value from a list of values.",
+      syntax: "CHOOSE(Index, Value1, Value2, ...ValueN)"
+    },
+    {
+      function: "COLUMN",
+      description: "Returns column number of a given reference or formula reference if argument not provided.",
+      syntax: "COLUMNS([Reference])"
+    },
+    {
+      function: "COLUMNS",
+      description: "Returns the number of columns in the given reference.",
+      syntax: "COLUMNS(Array)"
+    },
+    {
+      function: "FORMULATEXT",
+      description: "Returns a formula in a given cell as a string.",
+      syntax: "FORMULATEXT(Reference)"
+    },
+    {
+      function: "HLOOKUP",
+      description: "Searches horizontally with reference to adjacent cells to the bottom.",
+      syntax: "HLOOKUP(Search_Criterion, Array, Index, Sort_Order)"
+    },
+    {
+      function: "HYPERLINK",
+      description: "Stores the url in the cell's metadata.",
+      syntax: "HYPERLINK(Url[, LinkLabel])"
+    },
+    {
+      function: "INDEX",
+      description: "Returns the contents of a cell specified by row and column number. The column number is optional and defaults to 1.",
+      syntax: "INDEX(Range, Row [, Column])"
+    },
+    {
+      function: "MATCH",
+      description: "Returns the relative position of an item in an array that matches a specified value.",
+      syntax: "MATCH(Searchcriterion, Lookuparray [, MatchType])"
+    },
+    {
+      function: "OFFSET",
+      description: "Returns the value of a cell offset by a certain number of rows and columns from a given reference point.",
+      syntax: "OFFSET(Reference, Rows, Columns, Height, Width)"
+    },
+    {
+      function: "ROW",
+      description: "Returns row number of a given reference or formula reference if argument not provided.",
+      syntax: "ROW([Reference])"
+    },
+    {
+      function: "ROWS",
+      description: "Returns the number of rows in the given reference.",
+      syntax: "ROWS(Array)"
+    },
+    {
+      function: "VLOOKUP",
+      description: "Searches vertically with reference to adjacent cells to the right.",
+      syntax: "VLOOKUP(Search_Criterion, Array, Index, Sort_Order)"
+    }
+  ],
+  "Math and trigonometry": [
+    {
+      function: "ABS",
+      description: "Returns the absolute value of a number.",
+      syntax: "ABS(Number)"
+    },
+    {
+      function: "ACOS",
+      description: "Returns the inverse trigonometric cosine of a number.",
+      syntax: "ACOS(Number)"
+    },
+    {
+      function: "ACOSH",
+      description: "Returns the inverse hyperbolic cosine of a number.",
+      syntax: "ACOSH(Number)"
+    },
+    {
+      function: "ACOT",
+      description: "Returns the inverse trigonometric cotangent of a number.",
+      syntax: "ACOT(Number)"
+    },
+    {
+      function: "ACOTH",
+      description: "Returns the inverse hyperbolic cotangent of a number.",
+      syntax: "ACOTH(Number)"
+    },
+    {
+      function: "ARABIC",
+      description: "Converts number from roman form.",
+      syntax: "ARABIC(String)"
+    },
+    {
+      function: "ASIN",
+      description: "Returns the inverse trigonometric sine of a number.",
+      syntax: "ASIN(Number)"
+    },
+    {
+      function: "ASINH",
+      description: "Returns the inverse hyperbolic sine of a number.",
+      syntax: "ASINH(Number)"
+    },
+    {
+      function: "ATAN",
+      description: "Returns the inverse trigonometric tangent of a number.",
+      syntax: "ATAN(Number)"
+    },
+    {
+      function: "ATAN2",
+      description: "Returns the inverse trigonometric tangent of the specified x and y coordinates.",
+      syntax: "ATAN2(Numberx, Numbery)"
+    },
+    {
+      function: "ATANH",
+      description: "Returns the inverse hyperbolic tangent of a number.",
+      syntax: "ATANH(Number)"
+    },
+    {
+      function: "BASE",
+      description: "Converts a positive integer to a specified base into a text from the numbering system.",
+      syntax: "BASE(Number, Radix, [Minimumlength])"
+    },
+    {
+      function: "CEILING",
+      description: "Rounds a number up to the nearest multiple of Significance.",
+      syntax: "CEILING(Number, Significance)"
+    },
+    {
+      function: "CEILING.MATH",
+      description: "Rounds a number up to the nearest multiple of Significance.",
+      syntax: "CEILING.MATH(Number[, Significance[, Mode]])"
+    },
+    {
+      function: "CEILING.PRECISE",
+      description: "Rounds a number up to the nearest multiple of Significance.",
+      syntax: "CEILING.PRECISE(Number[, Significance])"
+    },
+    {
+      function: "COMBIN",
+      description: "Returns number of combinations (without repetitions).",
+      syntax: "COMBIN(Number, Number)"
+    },
+    {
+      function: "COMBINA",
+      description: "Returns number of combinations (with repetitions).",
+      syntax: "COMBINA(Number, Number)"
+    },
+    {
+      function: "COS",
+      description: "Returns the cosine of the given angle (in radians).",
+      syntax: "COS(Number)"
+    },
+    {
+      function: "COSH",
+      description: "Returns the hyperbolic cosine of the given value.",
+      syntax: "COSH(Number)"
+    },
+    {
+      function: "COT",
+      description: "Returns the cotangent of the given angle (in radians).",
+      syntax: "COT(Number)"
+    },
+    {
+      function: "COTH",
+      description: "Returns the hyperbolic cotangent of the given value.",
+      syntax: "COTH(Number)"
+    },
+    {
+      function: "COUNTUNIQUE",
+      description: "Counts the number of unique values in a list of specified values and ranges.",
+      syntax: "COUNTUNIQUE(Value1, Value2, ...ValueN)"
+    },
+    {
+      function: "CSC",
+      description: "Returns the cosecans of the given angle (in radians).",
+      syntax: "CSC(Number)"
+    },
+    {
+      function: "CSCH",
+      description: "Returns the hyperbolic cosecant of the given value.",
+      syntax: "CSCH(Number)"
+    },
+    {
+      function: "DECIMAL",
+      description: "Converts text with characters from a number system to a positive integer in the base radix given.",
+      syntax: 'DECIMAL("Text", Radix)'
+    },
+    {
+      function: "DEGREES",
+      description: "Converts radians into degrees.",
+      syntax: "DEGREES(Number)"
+    },
+    {
+      function: "EVEN",
+      description: "Rounds a positive number up to the next even integer and a negative number down to the next even integer.",
+      syntax: "EVEN(Number)"
+    },
+    {
+      function: "EXP",
+      description: "Returns constant e raised to the power of a number.",
+      syntax: "EXP(Number)"
+    },
+    {
+      function: "FACT",
+      description: "Returns a factorial of a number.",
+      syntax: "FACT(Number)"
+    },
+    {
+      function: "FACTDOUBLE",
+      description: "Returns a double factorial of a number.",
+      syntax: "FACTDOUBLE(Number)"
+    },
+    {
+      function: "FLOOR",
+      description: "Rounds a number down to the nearest multiple of Significance.",
+      syntax: "FLOOR(Number, Significance)"
+    },
+    {
+      function: "FLOOR.MATH",
+      description: "Rounds a number down to the nearest multiple of Significance.",
+      syntax: "FLOOR.MATH(Number[, Significance[, Mode]])"
+    },
+    {
+      function: "FLOOR.PRECISE",
+      description: "Rounds a number down to the nearest multiple of Significance.",
+      syntax: "FLOOR.PRECISE(Number[, Significance])"
+    },
+    {
+      function: "GCD",
+      description: "Computes greatest common divisor of numbers.",
+      syntax: "GCD(Number1, Number2, ...NumberN)"
+    },
+    {
+      function: "INT",
+      description: "Rounds a number down to the nearest integer.",
+      syntax: "INT(Number)"
+    },
+    {
+      function: "ISO.CEILING",
+      description: "Rounds a number up to the nearest multiple of Significance.",
+      syntax: "ISO.CEILING(Number[, Significance])"
+    },
+    {
+      function: "LCM",
+      description: "Computes least common multiplicity of numbers.",
+      syntax: "LCM(Number1, Number2, ...NumberN)"
+    },
+    {
+      function: "LN",
+      description: "Returns the natural logarithm based on the constant e of a number.",
+      syntax: "LN(Number)"
+    },
+    {
+      function: "LOG",
+      description: "Returns the logarithm of a number to the specified base.",
+      syntax: "LOG(Number, Base)"
+    },
+    {
+      function: "LOG10",
+      description: "Returns the base-10 logarithm of a number.",
+      syntax: "LOG10(Number)"
+    },
+    {
+      function: "MOD",
+      description: "Returns the remainder when one integer is divided by another.",
+      syntax: "MOD(Dividend, Divisor)"
+    },
+    {
+      function: "MROUND",
+      description: "Rounds number to the nearest multiplicity.",
+      syntax: "MROUND(Number, Base)"
+    },
+    {
+      function: "MULTINOMIAL",
+      description: "Returns number of multiset combinations.",
+      syntax: "MULTINOMIAL(Number1, Number2, ...NumberN)"
+    },
+    {
+      function: "ODD",
+      description: "Rounds a positive number up to the nearest odd integer and a negative number down to the nearest odd integer.",
+      syntax: "ODD(Number)"
+    },
+    {
+      function: "PI",
+      description: "Returns 3.14159265358979, the value of the mathematical constant PI to 14 decimal places.",
+      syntax: "PI()"
+    },
+    {
+      function: "POWER",
+      description: "Returns a number raised to another number.",
+      syntax: "POWER(Base, Exponent)"
+    },
+    {
+      function: "PRODUCT",
+      description: "Returns product of numbers.",
+      syntax: "PRODUCT(Number1, Number2, ...NumberN)"
+    },
+    {
+      function: "QUOTIENT",
+      description: "Returns integer part of a division.",
+      syntax: "QUOTIENT(Dividend, Divisor)"
+    },
+    {
+      function: "RADIANS",
+      description: "Converts degrees to radians.",
+      syntax: "RADIANS(Number)"
+    },
+    {
+      function: "RAND",
+      description: "Returns a random number between 0 and 1.",
+      syntax: "RAND()"
+    },
+    {
+      function: "RANDBETWEEN",
+      description: "Returns a random integer between two numbers.",
+      syntax: "RAND(Lowerbound, Upperbound)"
+    },
+    {
+      function: "ROMAN",
+      description: "Converts number to roman form.",
+      syntax: "ROMAN(Number[, Mode])"
+    },
+    {
+      function: "ROUND",
+      description: "Rounds a number to a certain number of decimal places.",
+      syntax: "ROUND(Number, Count)"
+    },
+    {
+      function: "ROUNDDOWN",
+      description: "Rounds a number down, toward zero, to a certain precision.",
+      syntax: "ROUNDDOWN(Number, Count)"
+    },
+    {
+      function: "ROUNDUP",
+      description: "Rounds a number up, away from zero, to a certain precision.",
+      syntax: "ROUNDUP(Number, Count)"
+    },
+    {
+      function: "SEC",
+      description: "Returns the secant of the given angle (in radians).",
+      syntax: "SEC(Number)"
+    },
+    {
+      function: "SECH",
+      description: "Returns the hyperbolic secant of the given angle (in radians).",
+      syntax: "SEC(Number)"
+    },
+    {
+      function: "SERIESSUM",
+      description: "Evaluates series at a point.",
+      syntax: "SERIESSUM(Number, Number, Number, Coefficients)"
+    },
+    {
+      function: "SIN",
+      description: "Returns the sine of the given angle (in radians).",
+      syntax: "SIN(Number)"
+    },
+    {
+      function: "SINH",
+      description: "Returns the hyperbolic sine of the given value.",
+      syntax: "SINH(Number)"
+    },
+    {
+      function: "SIGN",
+      description: "Returns sign of a number.",
+      syntax: "SIGN(Number)"
+    },
+    {
+      function: "SQRT",
+      description: "Returns the positive square root of a number.",
+      syntax: "SQRT(Number)"
+    },
+    {
+      function: "SQRTPI",
+      description: "Returns sqrt of number times pi.",
+      syntax: "SQRTPI(Number)"
+    },
+    {
+      function: "SUBTOTAL",
+      description: "Computes aggregation using function specified by number.",
+      syntax: "SUBTOTAL(Function, Number1, Number2, ...NumberN)"
+    },
+    {
+      function: "SUM",
+      description: "Sums up the values of the specified cells.",
+      syntax: "SUM(Number1, Number2, ...NumberN)"
+    },
+    {
+      function: "SUMIF",
+      description: "Sums up the values of cells that belong to the specified range and meet the specified condition.",
+      syntax: "SUMIF(Range, Criteria, Sumrange)"
+    },
+    {
+      function: "SUMIFS",
+      description: "Sums up the values of cells that belong to the specified range and meet the specified sets of conditions.",
+      syntax: "SUMIFS(Sum_Range, Criterion_range1, Criterion1 [, Criterion_range2, Criterion2 [, ...Criterion_rangeN, CriterionN]])"
+    },
+    {
+      function: "SUMPRODUCT",
+      description: "Multiplies corresponding elements in the given arrays, and returns the sum of those products.",
+      syntax: "SUMPRODUCT(Array1, Array2, ...ArrayN)"
+    },
+    {
+      function: "SUMSQ",
+      description: "Returns the sum of the squares of the arguments",
+      syntax: "SUMSQ(Number1, Number2, ...NumberN)"
+    },
+    {
+      function: "SUMX2MY2",
+      description: "Returns the sum of the square differences.",
+      syntax: "SUMX2MY2(Range1, Range2)"
+    },
+    {
+      function: "SUMX2PY2",
+      description: "Returns the sum of the square sums.",
+      syntax: "SUMX2PY2(Range1, Range2)"
+    },
+    {
+      function: "SUMXMY2",
+      description: "Returns the sum of the square of differences.",
+      syntax: "SUMXMY2(Range1, Range2)"
+    },
+    {
+      function: "TAN",
+      description: "Returns the tangent of the given angle (in radians).",
+      syntax: "TAN(Number)"
+    },
+    {
+      function: "TANH",
+      description: "Returns the hyperbolic tangent of the given value.",
+      syntax: "TANH(Number)"
+    },
+    {
+      function: "TRUNC",
+      description: "Truncates a number by removing decimal places.",
+      syntax: "TRUNC(Number, Count)"
+    }
+  ],
+  "Matrix functions": [
+    {
+      function: "MMULT",
+      description: "Calculates the array product of two arrays.",
+      syntax: "MMULT(Array, Array)"
+    },
+    {
+      function: "MEDIANPOOL",
+      description: "Calculates a smaller range which is a median of a Window_size, in a given Range, for every Stride element.",
+      syntax: "MEDIANPOOL(Range, Window_size, Stride)"
+    },
+    {
+      function: "MAXPOOL",
+      description: "Calculates a smaller range which is a maximum of a Window_size, in a given Range, for every Stride element.",
+      syntax: "MAXPOOL(Range, Window_size, Stride)"
+    },
+    {
+      function: "TRANSPOSE",
+      description: "Transposes the rows and columns of an array.",
+      syntax: "TRANSPOSE(Array)"
+    }
+  ],
+  Operator: [
+    {
+      function: "HF.ADD",
+      description: "Adds two values.",
+      syntax: "HF.ADD(Number, Number)"
+    },
+    {
+      function: "HF.CONCAT",
+      description: "Concatenates two strings.",
+      syntax: "HF.CONCAT(String, String)"
+    },
+    {
+      function: "HF.DIVIDE",
+      description: "Divides two values.",
+      syntax: "HF.DIVIDE(Number, Number)"
+    },
+    {
+      function: "HF.EQ",
+      description: "Tests two values for equality.",
+      syntax: "HF.EQ(Value, Value)"
+    },
+    {
+      function: "HF.LTE",
+      description: "Tests two values for less-equal relation.",
+      syntax: "HF.LEQ(Value, Value)"
+    },
+    {
+      function: "HF.LT",
+      description: "Tests two values for less-than relation.",
+      syntax: "HF.LT(Value, Value)"
+    },
+    {
+      function: "HF.GTE",
+      description: "Tests two values for greater-equal relation.",
+      syntax: "HF.GEQ(Value, Value)"
+    },
+    {
+      function: "HF.GT",
+      description: "Tests two values for greater-than relation.",
+      syntax: "HF.GT(Value, Value)"
+    },
+    {
+      function: "HF.MINUS",
+      description: "Subtracts two values.",
+      syntax: "HF.MINUS(Number, Number)"
+    },
+    {
+      function: "HF.MULTIPLY",
+      description: "Multiplies two values.",
+      syntax: "HF.MULTIPLY(Number, Number)"
+    },
+    {
+      function: "HF.NE",
+      description: "Tests two values for inequality.",
+      syntax: "HF.NE(Value, Value)"
+    },
+    {
+      function: "HF.POW",
+      description: "Computes power of two values.",
+      syntax: "HF.POW(Number, Number)"
+    },
+    {
+      function: "HF.UMINUS",
+      description: "Negates the value.",
+      syntax: "HF.UMINUS(Number)"
+    },
+    {
+      function: "HF.UNARY_PERCENT",
+      description: "Applies percent operator.",
+      syntax: "HF.UNARY_PERCENT(Number)"
+    },
+    {
+      function: "HF.UPLUS",
+      description: "Applies unary plus.",
+      syntax: "HF.UPLUS(Number)"
+    }
+  ],
+  Statistical: [
+    {
+      function: "AVEDEV",
+      description: "Returns the average deviation of the arguments.",
+      syntax: "AVEDEV(Number1, Number2, ...NumberN)"
+    },
+    {
+      function: "AVERAGE",
+      description: "Returns the average of the arguments.",
+      syntax: "AVERAGE(Number1, Number2, ...NumberN)"
+    },
+    {
+      function: "AVERAGEA",
+      description: "Returns the average of the arguments.",
+      syntax: "AVERAGEA(Value1, Value2, ...ValueN)"
+    },
+    {
+      function: "AVERAGEIF",
+      description: "Returns the arithmetic mean of all cells in a range that satisfy a given condition.",
+      syntax: "AVERAGEIF(Range, Criterion [, Average_Range ])"
+    },
+    {
+      function: "BESSELI",
+      description: "Returns value of Bessel function.",
+      syntax: "BESSELI(x, n)"
+    },
+    {
+      function: "BESSELJ",
+      description: "Returns value of Bessel function.",
+      syntax: "BESSELJ(x, n)"
+    },
+    {
+      function: "BESSELK",
+      description: "Returns value of Bessel function.",
+      syntax: "BESSELK(x, n)"
+    },
+    {
+      function: "BESSELY",
+      description: "Returns value of Bessel function.",
+      syntax: "BESSELY(x, n)"
+    },
+    {
+      function: "BETA.DIST",
+      description: "Returns the density of Beta distribution.",
+      syntax: "BETA.DIST(Number1, Number2, Number3, Boolean[, Number4[, Number5]])"
+    },
+    {
+      function: "BETADIST",
+      description: "Returns the density of Beta distribution.",
+      syntax: "BETADIST(Number1, Number2, Number3, Boolean[, Number4[, Number5]])"
+    },
+    {
+      function: "BETA.INV",
+      description: "Returns the inverse Beta distribution value.",
+      syntax: "BETA.INV(Number1, Number2, Number3[, Number4[, Number5]])"
+    },
+    {
+      function: "BETAINV",
+      description: "Returns the inverse of Beta distribution value.",
+      syntax: "BETAINV(Number1, Number2, Number3[, Number4[, Number5]])"
+    },
+    {
+      function: "BINOM.DIST",
+      description: "Returns density of binomial distribution.",
+      syntax: "BINOM.DIST(Number1, Number2, Number3, Boolean)"
+    },
+    {
+      function: "BINOMDIST",
+      description: "Returns density of binomial distribution.",
+      syntax: "BINOMDIST(Number1, Number2, Number3, Boolean)"
+    },
+    {
+      function: "BINOM.INV",
+      description: "Returns inverse binomial distribution value.",
+      syntax: "BINOM.INV(Number1, Number2, Number3)"
+    },
+    {
+      function: "CHIDIST",
+      description: "Returns probability of chi-square right-side distribution.",
+      syntax: "CHIDIST(X, Degrees)"
+    },
+    {
+      function: "CHIINV",
+      description: "Returns inverse of chi-square right-side distribution.",
+      syntax: "CHIINV(P, Degrees)"
+    },
+    {
+      function: "CHIINVRT",
+      description: "Returns inverse of chi-square right-side distribution.",
+      syntax: "CHIINVRT(P, Degrees)"
+    },
+    {
+      function: "CHISQ.DIST",
+      description: "Returns value of chi-square distribution.",
+      syntax: "CHISQ.DIST(X, Degrees, Mode)"
+    },
+    {
+      function: "CHIDISTRT",
+      description: "Returns probability of chi-square right-side distribution.",
+      syntax: "CHIDISTRT(X, Degrees)"
+    },
+    {
+      function: "CHISQ.DIST.RT",
+      description: "Returns probability of chi-square right-side distribution.",
+      syntax: "CHISQ.DIST.RT(X, Degrees)"
+    },
+    {
+      function: "CHISQ.INV",
+      description: "Returns inverse of chi-square distribution.",
+      syntax: "CHISQ.INV.RT(P, Degrees)"
+    },
+    {
+      function: "CHISQ.INV.RT",
+      description: "Returns inverse of chi-square right-side distribution.",
+      syntax: "CHISQ.INV.RT(P, Degrees)"
+    },
+    {
+      function: "CHISQ.TEST",
+      description: "Returns chi-squared-test value for a dataset.",
+      syntax: "CHISQ.TEST(Array1, Array2)"
+    },
+    {
+      function: "CHITEST",
+      description: "Returns chi-squared-test value for a dataset.",
+      syntax: "CHITEST(Array1, Array2)"
+    },
+    {
+      function: "CONFIDENCE",
+      description: "Returns upper confidence bound for normal distribution.",
+      syntax: "CONFIDENCE(Alpha, Stdev, Size)"
+    },
+    {
+      function: "CONFIDENCE.NORM",
+      description: "Returns upper confidence bound for normal distribution.",
+      syntax: "CONFIDENCE.NORM(Alpha, Stdev, Size)"
+    },
+    {
+      function: "CONFIDENCE.T",
+      description: "Returns upper confidence bound for T distribution.",
+      syntax: "CONFIDENCE.T(Alpha, Stdev, Size)"
+    },
+    {
+      function: "CORREL",
+      description: "Returns the correlation coefficient between two data sets.",
+      syntax: "CORREL(Data1, Data2)"
+    },
+    {
+      function: "COUNT",
+      description: "Counts how many numbers are in the list of arguments.",
+      syntax: "COUNT(Value1, Value2, ...ValueN)"
+    },
+    {
+      function: "COUNTA",
+      description: "Counts how many values are in the list of arguments.",
+      syntax: "COUNTA(Value1, Value2, ...ValueN)"
+    },
+    {
+      function: "COUNTBLANK",
+      description: "Returns the number of empty cells.",
+      syntax: "COUNTBLANK(Range)"
+    },
+    {
+      function: "COUNTIF",
+      description: "Returns the number of cells that meet with certain criteria within a cell range.",
+      syntax: "COUNTIF(Range, Criteria)"
+    },
+    {
+      function: "COUNTIFS",
+      description: "Returns the count of rows or columns that meet criteria in multiple ranges.",
+      syntax: "COUNTIFS(Range1, Criterion1 [, Range2, Criterion2 [, ...RangeN, CriterionN]])"
+    },
+    {
+      function: "COVAR",
+      description: "Returns the covariance between two data sets, population normalized.",
+      syntax: "COVAR(Data1, Data2)"
+    },
+    {
+      function: "COVARIANCE.P",
+      description: "Returns the covariance between two data sets, population normalized.",
+      syntax: "COVARIANCE.P(Data1, Data2)"
+    },
+    {
+      function: "COVARIANCEP",
+      description: "Returns the covariance between two data sets, population normalized.",
+      syntax: "COVARIANCEP(Data1, Data2)"
+    },
+    {
+      function: "COVARIANCE.S",
+      description: "Returns the covariance between two data sets, sample normalized.",
+      syntax: "COVARIANCE.S(Data1, Data2)"
+    },
+    {
+      function: "COVARIANCES",
+      description: "Returns the covariance between two data sets, sample normalized.",
+      syntax: "COVARIANCES(Data1, Data2)"
+    },
+    {
+      function: "CRITBINOM",
+      description: "Returns inverse binomial distribution value.",
+      syntax: "CRITBINOM(Number1, Number2, Number3)"
+    },
+    {
+      function: "DEVSQ",
+      description: "Returns sum of squared deviations.",
+      syntax: "DEVSQ(Number1, Number2, ...NumberN)"
+    },
+    {
+      function: "EXPON.DIST",
+      description: "Returns density of an exponential distribution.",
+      syntax: "EXPON.DIST(Number1, Number2, Boolean)"
+    },
+    {
+      function: "EXPONDIST",
+      description: "Returns density of an exponential distribution.",
+      syntax: "EXPONDIST(Number1, Number2, Boolean)"
+    },
+    {
+      function: "FDIST",
+      description: "Returns probability of F right-side distribution.",
+      syntax: "FDIST(X, Degree1, Degree2)"
+    },
+    {
+      function: "FINV",
+      description: "Returns inverse of F right-side distribution.",
+      syntax: "FINV(P, Degree1, Degree2)"
+    },
+    {
+      function: "F.DIST",
+      description: "Returns value of F distribution.",
+      syntax: "F.DIST(X, Degree1, Degree2, Mode)"
+    },
+    {
+      function: "F.DIST.RT",
+      description: "Returns probability of F right-side distribution.",
+      syntax: "F.DIST.RT(X, Degree1, Degree2)"
+    },
+    {
+      function: "FDISTRT",
+      description: "Returns probability of F right-side distribution.",
+      syntax: "FDISTRT(X, Degree1, Degree2)"
+    },
+    {
+      function: "F.INV",
+      description: "Returns inverse of F distribution.",
+      syntax: "F.INV.RT(P, Degree1, Degree2)"
+    },
+    {
+      function: "F.INV.RT",
+      description: "Returns inverse of F right-side distribution.",
+      syntax: "F.INV.RT(P, Degree1, Degree2)"
+    },
+    {
+      function: "FINVRT",
+      description: "Returns inverse of F right-side distribution.",
+      syntax: "FINVRT(P, Degree1, Degree2)"
+    },
+    {
+      function: "FISHER",
+      description: "Returns Fisher transformation value.",
+      syntax: "FISHER(Number)"
+    },
+    {
+      function: "FISHERINV",
+      description: "Returns inverse Fisher transformation value.",
+      syntax: "FISHERINV(Number)"
+    },
+    {
+      function: "F.TEST",
+      description: "Returns f-test value for a dataset.",
+      syntax: "Z.TEST(Array1, Array2)"
+    },
+    {
+      function: "FTEST",
+      description: "Returns f-test value for a dataset.",
+      syntax: "ZTEST(Array1, Array2)"
+    },
+    {
+      function: "GAMMA",
+      description: "Returns value of Gamma function.",
+      syntax: "GAMMA(Number)"
+    },
+    {
+      function: "GAMMA.DIST",
+      description: "Returns density of Gamma distribution.",
+      syntax: "GAMMA.DIST(Number1, Number2, Number3, Boolean)"
+    },
+    {
+      function: "GAMMADIST",
+      description: "Returns density of Gamma distribution.",
+      syntax: "GAMMADIST(Number1, Number2, Number3, Boolean)"
+    },
+    {
+      function: "GAMMALN",
+      description: "Returns natural logarithm of Gamma function.",
+      syntax: "GAMMALN(Number)"
+    },
+    {
+      function: "GAMMALN.PRECISE",
+      description: "Returns natural logarithm of Gamma function.",
+      syntax: "GAMMALN.PRECISE(Number)"
+    },
+    {
+      function: "GAMMA.INV",
+      description: "Returns inverse Gamma distribution value.",
+      syntax: "GAMMA.INV(Number1, Number2, Number3)"
+    },
+    {
+      function: "GAMMAINV",
+      description: "Returns inverse Gamma distribution value.",
+      syntax: "GAMMAINV(Number1, Number2, Number3)"
+    },
+    {
+      function: "GAUSS",
+      description: "Returns the probability of gaussian variable fall more than this many times standard deviation from mean.",
+      syntax: "GAUSS(Number)"
+    },
+    {
+      function: "GEOMEAN",
+      description: "Returns the geometric average.",
+      syntax: "GEOMEAN(Number1, Number2, ...NumberN)"
+    },
+    {
+      function: "HARMEAN",
+      description: "Returns the harmonic average.",
+      syntax: "HARMEAN(Number1, Number2, ...NumberN)"
+    },
+    {
+      function: "HYPGEOMDIST",
+      description: "Returns density of hypergeometric distribution.",
+      syntax: "HYPGEOMDIST(Number1, Number2, Number3, Number4, Boolean)"
+    },
+    {
+      function: "HYPGEOM.DIST",
+      description: "Returns density of hypergeometric distribution.",
+      syntax: "HYPGEOM.DIST(Number1, Number2, Number3, Number4, Boolean)"
+    },
+    {
+      function: "LARGE",
+      description: "Returns k-th largest value in a range.",
+      syntax: "LARGE(Range, K)"
+    },
+    {
+      function: "LOGNORM.DIST",
+      description: "Returns density of lognormal distribution.",
+      syntax: "LOGNORM.DIST(X, Mean, Stddev, Mode)"
+    },
+    {
+      function: "LOGNORMDIST",
+      description: "Returns density of lognormal distribution.",
+      syntax: "LOGNORMDIST(X, Mean, Stddev, Mode)"
+    },
+    {
+      function: "LOGNORM.INV",
+      description: "Returns value of inverse lognormal distribution.",
+      syntax: "LOGNORM.INV(P, Mean, Stddev)"
+    },
+    {
+      function: "LOGNORMINV",
+      description: "Returns value of inverse lognormal distribution.",
+      syntax: "LOGNORMINV(P, Mean, Stddev)"
+    },
+    {
+      function: "LOGINV",
+      description: "Returns value of inverse lognormal distribution.",
+      syntax: "LOGINV(P, Mean, Stddev)"
+    },
+    {
+      function: "MAX",
+      description: "Returns the maximum value in a list of arguments.",
+      syntax: "MAX(Number1, Number2, ...NumberN)"
+    },
+    {
+      function: "MAXA",
+      description: "Returns the maximum value in a list of arguments.",
+      syntax: "MAXA(Value1, Value2, ...ValueN)"
+    },
+    {
+      function: "MAXIFS",
+      description: "Returns the maximum value of the cells in a range that meet a set of criteria.",
+      syntax: "MAXIFS(Max_Range, Criterion_range1, Criterion1 [, Criterion_range2, Criterion2 [, ...Criterion_rangeN, CriterionN]])"
+    },
+    {
+      function: "MEDIAN",
+      description: "Returns the median of a set of numbers.",
+      syntax: "MEDIAN(Number1, Number2, ...NumberN)"
+    },
+    {
+      function: "MIN",
+      description: "Returns the minimum value in a list of arguments.",
+      syntax: "MIN(Number1, Number2, ...NumberN)"
+    },
+    {
+      function: "MINA",
+      description: "Returns the minimum value in a list of arguments.",
+      syntax: "MINA(Value1, Value2, ...ValueN)"
+    },
+    {
+      function: "MINIFS",
+      description: "Returns the minimum value of the cells in a range that meet a set of criteria.",
+      syntax: "MINIFS(Min_Range, Criterion_range1, Criterion1 [, Criterion_range2, Criterion2 [, ...Criterion_rangeN, CriterionN]])"
+    },
+    {
+      function: "NEGBINOM.DIST",
+      description: "Returns density of negative binomial distribution.",
+      syntax: "NEGBINOM.DIST(Number1, Number2, Number3, Mode)"
+    },
+    {
+      function: "NEGBINOMDIST",
+      description: "Returns density of negative binomial distribution.",
+      syntax: "NEGBINOMDIST(Number1, Number2, Number3, Mode)"
+    },
+    {
+      function: "NORM.DIST",
+      description: "Returns density of normal distribution.",
+      syntax: "NORM.DIST(X, Mean, Stddev, Mode)"
+    },
+    {
+      function: "NORMDIST",
+      description: "Returns density of normal distribution.",
+      syntax: "NORMDIST(X, Mean, Stddev, Mode)"
+    },
+    {
+      function: "NORM.S.DIST",
+      description: "Returns density of normal distribution.",
+      syntax: "NORM.S.DIST(X, Mode)"
+    },
+    {
+      function: "NORMDIST",
+      description: "Returns density of normal distribution.",
+      syntax: "NORMSDIST(X, Mode)"
+    },
+    {
+      function: "NORM.INV",
+      description: "Returns value of inverse normal distribution.",
+      syntax: "NORM.INV(P, Mean, Stddev)"
+    },
+    {
+      function: "NORMINV",
+      description: "Returns value of inverse normal distribution.",
+      syntax: "NORMINV(P, Mean, Stddev)"
+    },
+    {
+      function: "NORM.S.INV",
+      description: "Returns value of inverse normal distribution.",
+      syntax: "NORM.S.INV(P)"
+    },
+    {
+      function: "NORMSINV",
+      description: "Returns value of inverse normal distribution.",
+      syntax: "NORMSINV(P)"
+    },
+    {
+      function: "PEARSON",
+      description: "Returns the correlation coefficient between two data sets.",
+      syntax: "PEARSON(Data1, Data2)"
+    },
+    {
+      function: "PHI",
+      description: "Returns probability density of normal distribution.",
+      syntax: "PHI(X)"
+    },
+    {
+      function: "POISSON",
+      description: "Returns density of Poisson distribution.",
+      syntax: "POISSON(X, Mean, Mode)"
+    },
+    {
+      function: "POISSON.DIST",
+      description: "Returns density of Poisson distribution.",
+      syntax: "POISSON.DIST(X, Mean, Mode)"
+    },
+    {
+      function: "POISSONDIST",
+      description: "Returns density of Poisson distribution.",
+      syntax: "POISSONDIST(X, Mean, Mode)"
+    },
+    {
+      function: "RSQ",
+      description: "Returns the squared correlation coefficient between two data sets.",
+      syntax: "RSQ(Data1, Data2)"
+    },
+    {
+      function: "SKEW",
+      description: "Returns skewness of a sample.",
+      syntax: "SKEW(Number1, Number2, ...NumberN)"
+    },
+    {
+      function: "SKEW.P",
+      description: "Returns skewness of a population.",
+      syntax: "SKEW.P(Number1, Number2, ...NumberN)"
+    },
+    {
+      function: "SKEWP",
+      description: "Returns skewness of a population.",
+      syntax: "SKEWP(Number1, Number2, ...NumberN)"
+    },
+    {
+      function: "SLOPE",
+      description: "Returns the slope of a linear regression line.",
+      syntax: "SLOPE(Array1, Array2)"
+    },
+    {
+      function: "SMALL",
+      description: "Returns k-th smallest value in a range.",
+      syntax: "SMALL(Range, K)"
+    },
+    {
+      function: "STANDARDIZE",
+      description: "Returns normalized value with respect to expected value and standard deviation.",
+      syntax: "STANDARDIZE(X, Mean, Stddev)"
+    },
+    {
+      function: "STDEV",
+      description: "Returns standard deviation of a sample.",
+      syntax: "STDEV(Value1, Value2, ...ValueN)"
+    },
+    {
+      function: "STDEVA",
+      description: "Returns standard deviation of a sample.",
+      syntax: "STDEVA(Value1, Value2, ...ValueN)"
+    },
+    {
+      function: "STDEVP",
+      description: "Returns standard deviation of a population.",
+      syntax: "STDEVP(Value1, Value2, ...ValueN)"
+    },
+    {
+      function: "STDEV.P",
+      description: "Returns standard deviation of a population.",
+      syntax: "STDEV.P(Value1, Value2, ...ValueN)"
+    },
+    {
+      function: "STDEVPA",
+      description: "Returns standard deviation of a population.",
+      syntax: "STDEVPA(Value1, Value2, ...ValueN)"
+    },
+    {
+      function: "STDEV.S",
+      description: "Returns standard deviation of a sample.",
+      syntax: "STDEV.S(Value1, Value2, ...ValueN)"
+    },
+    {
+      function: "STDEVS",
+      description: "Returns standard deviation of a sample.",
+      syntax: "STDEVS(Value1, Value2, ...ValueN)"
+    },
+    {
+      function: "STEYX",
+      description: "Returns standard error for predicted of the predicted y value for each x value.",
+      syntax: "STEYX(Array1, Array2)"
+    },
+    {
+      function: "TDIST",
+      description: "Returns density of Student-t distribution, both-sided or right-tailed.",
+      syntax: "TDIST(X, Degrees, Mode)"
+    },
+    {
+      function: "T.DIST",
+      description: "Returns density of Student-t distribution.",
+      syntax: "T.DIST(X, Degrees, Mode)"
+    },
+    {
+      function: "T.DIST.2T",
+      description: "Returns density of Student-t distribution, both-sided.",
+      syntax: "T.DIST.2T(X, Degrees)"
+    },
+    {
+      function: "TDIST2T",
+      description: "Returns density of Student-t distribution, both-sided.",
+      syntax: "TDIST2T(X, Degrees)"
+    },
+    {
+      function: "T.DIST.RT",
+      description: "Returns density of Student-t distribution, right-tailed.",
+      syntax: "T.DIST.RT(X, Degrees)"
+    },
+    {
+      function: "TDISTRT",
+      description: "Returns density of Student-t distribution, right-tailed.",
+      syntax: "TDISTRT(X, Degrees)"
+    },
+    {
+      function: "TINV",
+      description: "Returns inverse Student-t distribution, both-sided.",
+      syntax: "TINV(P, Degrees)"
+    },
+    {
+      function: "T.INV",
+      description: "Returns inverse Student-t distribution.",
+      syntax: "T.INV(P, Degrees)"
+    },
+    {
+      function: "T.INV.2T",
+      description: "Returns inverse Student-t distribution, both-sided.",
+      syntax: "T.INV.2T(P, Degrees)"
+    },
+    {
+      function: "TINV2T",
+      description: "Returns inverse Student-t distribution, both-sided.",
+      syntax: "TINV2T(P, Degrees)"
+    },
+    {
+      function: "TTEST",
+      description: "Returns t-test value for a dataset.",
+      syntax: "TTEST(Array1, Array2)"
+    },
+    {
+      function: "T.TEST",
+      description: "Returns t-test value for a dataset.",
+      syntax: "T.TEST(Array1, Array2)"
+    },
+    {
+      function: "VAR",
+      description: "Returns variance of a sample.",
+      syntax: "VAR(Value1, Value2, ...ValueN)"
+    },
+    {
+      function: "VARA",
+      description: "Returns variance of a sample.",
+      syntax: "VARA(Value1, Value2, ...ValueN)"
+    },
+    {
+      function: "VARP",
+      description: "Returns variance of a population.",
+      syntax: "VARP(Value1, Value2, ...ValueN)"
+    },
+    {
+      function: "VAR.P",
+      description: "Returns variance of a population.",
+      syntax: "VAR.P(Value1, Value2, ...ValueN)"
+    },
+    {
+      function: "VARPA",
+      description: "Returns variance of a population.",
+      syntax: "VARPA(Value1, Value2, ...ValueN)"
+    },
+    {
+      function: "VAR.S",
+      description: "Returns variance of a sample.",
+      syntax: "VAR.S(Value1, Value2, ...ValueN)"
+    },
+    {
+      function: "VARS",
+      description: "Returns variance of a sample.",
+      syntax: "VARS(Value1, Value2, ...ValueN)"
+    },
+    {
+      function: "WEIBULL",
+      description: "Returns density of Weibull distribution.",
+      syntax: "WEIBULL(Number1, Number2, Number3, Boolean)"
+    },
+    {
+      function: "WEIBULL.DIST",
+      description: "Returns density of Weibull distribution.",
+      syntax: "WEIBULL.DIST(Number1, Number2, Number3, Boolean)"
+    },
+    {
+      function: "WEIBULLDIST",
+      description: "Returns density of Weibull distribution.",
+      syntax: "WEIBULLDIST(Number1, Number2, Number3, Boolean)"
+    },
+    {
+      function: "Z.TEST",
+      description: "Returns z-test value for a dataset.",
+      syntax: "Z.TEST(Array, X[, Sigma])"
+    },
+    {
+      function: "ZTEST",
+      description: "Returns z-test value for a dataset.",
+      syntax: "ZTEST(Array, X[, Sigma])"
+    }
+  ],
+  Text: [
+    {
+      function: "CHAR",
+      description: "Converts a number into a character according to the current code table.",
+      syntax: "CHAR(Number)"
+    },
+    {
+      function: "CLEAN",
+      description: 'Returns text that has been "cleaned" of line breaks and other non-printable characters.',
+      syntax: 'CLEAN("Text")'
+    },
+    {
+      function: "CODE",
+      description: "Returns a numeric code for the first character in a text string.",
+      syntax: 'CODE("Text")'
+    },
+    {
+      function: "CONCATENATE",
+      description: "Combines several text strings into one string.",
+      syntax: 'CONCATENATE("Text1", "Text2", ..."TextN")'
+    },
+    {
+      function: "EXACT",
+      description: "Returns TRUE if both text strings are exactly the same.",
+      syntax: "EXACT(Text, Text)"
+    },
+    {
+      function: "FIND",
+      description: "Returns the location of one text string inside another.",
+      syntax: 'FIND( "Text1", "Text2"[, Number])'
+    },
+    {
+      function: "LEFT",
+      description: "Extracts a given number of characters from the left side of a text string.",
+      syntax: 'LEFT("Text", Number)'
+    },
+    {
+      function: "LEN",
+      description: "Returns length of a given text.",
+      syntax: 'LEN("Text")'
+    },
+    {
+      function: "LOWER",
+      description: "Returns text converted to lowercase.",
+      syntax: "LOWER(Text)"
+    },
+    {
+      function: "MID",
+      description: "Returns substring of a given length starting from Start_position.",
+      syntax: "MID(Text, Start_position, Length)"
+    },
+    {
+      function: "PROPER",
+      description: "Capitalizes words given text string.",
+      syntax: 'PROPER("Text")'
+    },
+    {
+      function: "REPLACE",
+      description: "Replaces substring of a text of a given length that starts at given position.",
+      syntax: "REPLACE(Text, Start_position, Length, New_text)"
+    },
+    {
+      function: "REPT",
+      description: "Repeats text a given number of times.",
+      syntax: 'REPT("Text", Number)'
+    },
+    {
+      function: "RIGHT",
+      description: "Extracts a given number of characters from the right side of a text string.",
+      syntax: 'RIGHT("Text", Number)'
+    },
+    {
+      function: "SEARCH",
+      description: "Returns the location of Search_string inside Text. Case-insensitive. Allows the use of wildcards.",
+      syntax: "SEARCH(Search_string, Text[, Start_position])"
+    },
+    {
+      function: "SPLIT",
+      description: "Divides the provided text using the space character as a separator and returns the substring at the zero-based position specified by the second argument.",
+      syntax: "SPLIT(Text, Index)"
+    },
+    {
+      function: "SUBSTITUTE",
+      description: "Returns string where occurrences of Old_text are replaced by New_text. Replaces only specific occurrence if last parameter is provided.",
+      syntax: "SUBSTITUTE(Text, Old_text, New_text, [Occurrence])"
+    },
+    {
+      function: "T",
+      description: "Returns text if given value is text, empty string otherwise.",
+      syntax: "T(Value)"
+    },
+    {
+      function: "TEXT",
+      description: "Converts a number into text according to a given format.",
+      syntax: "TEXT(Number, Format)"
+    },
+    {
+      function: "TRIM",
+      description: "Strips extra spaces from text.",
+      syntax: 'TRIM("Text")'
+    },
+    {
+      function: "UNICHAR",
+      description: "Returns the character created by using provided code point.",
+      syntax: "UNICHAR(Number)"
+    },
+    {
+      function: "UNICODE",
+      description: "Returns the Unicode code point of a first character of a text.",
+      syntax: "UNICODE(Text)"
+    },
+    {
+      function: "UPPER",
+      description: "Returns text converted to uppercase.",
+      syntax: "UPPER(Text)"
+    }
+  ]
+};
+
+// packages/plugins/plugin-sheet/src/components/CellEditor/extension.ts
+var highlightStyles = HighlightStyle.define([
+  // Function.
+  {
+    tag: tags.name,
+    class: "text-primary-500"
+  },
+  // Range.
+  {
+    tag: tags.tagName,
+    class: "text-pink-500"
+  },
+  // Values.
+  {
+    tag: tags.number,
+    class: "text-teal-500"
+  },
+  {
+    tag: tags.bool,
+    class: "text-teal-500"
+  },
+  {
+    tag: tags.string,
+    class: "text-teal-500"
+  },
+  // Error.
+  {
+    tag: tags.invalid,
+    class: "text-neutral-500"
+  }
+]);
+var languageFacet = Facet.define();
+var sheetExtension = ({ functions: functions2 }) => {
+  const { extension, language } = spreadsheet({
+    idiom: "en-US",
+    decimalSeparator: "."
+  });
+  const functionInfo = Object.entries(functions).reduce((map, [section, values]) => {
+    values.forEach(({ function: id, ...props }) => {
+      map.set(id, {
+        function: id,
+        ...props,
+        section
+      });
+    });
+    return map;
+  }, /* @__PURE__ */ new Map());
+  const createCompletion = (name) => {
+    const { section, description, syntax } = functionInfo.get(name) ?? {
+      section: "Custom"
+    };
+    return {
+      section,
+      label: name,
+      info: () => {
+        if (!description && !syntax) {
+          return null;
+        }
+        const root = document.createElement("div");
+        root.className = "flex flex-col gap-2 text-sm";
+        const title = document.createElement("h2");
+        title.innerText = name;
+        title.className = "text-lg font-mono text-primary-500";
+        root.appendChild(title);
+        if (description) {
+          const info = document.createElement("p");
+          info.innerText = description;
+          info.className = "fg-subdued";
+          root.appendChild(info);
+        }
+        if (syntax) {
+          const detail = document.createElement("pre");
+          detail.innerText = syntax;
+          detail.className = "whitespace-pre-wrap text-green-500";
+          root.appendChild(detail);
+        }
+        return root;
+      },
+      apply: (view, completion, from, to) => {
+        const insertParens = to === view.state.doc.toString().length;
+        view.dispatch(view.state.update({
+          changes: {
+            from,
+            to,
+            insert: completion.label + (insertParens ? "()" : "")
+          },
+          selection: {
+            anchor: from + completion.label.length + 1
+          }
+        }));
+      }
+    };
+  };
+  return [
+    extension,
+    languageFacet.of(language),
+    language.data.of({
+      autocomplete: (context) => {
+        if (context.state.doc.toString()[0] !== "=") {
+          return null;
+        }
+        const match = context.matchBefore(/\w*/);
+        if (!match || match.from === match.to) {
+          return null;
+        }
+        const text = match.text.toUpperCase();
+        if (!context.explicit && match.text.length < 2) {
+          return null;
+        }
+        return {
+          from: match.from,
+          options: functions2?.filter((name) => name.startsWith(text)).map((name) => createCompletion(name)) ?? []
+        };
+      }
+    }),
+    syntaxHighlighting(highlightStyles),
+    autocompletion({
+      aboveCursor: false,
+      defaultKeymap: true,
+      activateOnTyping: true,
+      // NOTE: Useful for debugging.
+      closeOnBlur: false,
+      icons: false,
+      tooltipClass: () => mx(
+        // TODO(burdon): Factor out fragments.
+        // TODO(burdon): Size to make width same as column.
+        "!-left-[1px] !top-[33px] !-m-0 border !border-t-0 [&>ul]:!min-w-[198px]",
+        "[&>ul>li[aria-selected]]:!bg-primary-700",
+        "border-neutral-200 dark:border-neutral-700"
+      )
+    }),
+    keymap2.of([
+      {
+        key: "Tab",
+        run: (view) => {
+          return completionStatus(view.state) === "active" ? acceptCompletion(view) : startCompletion(view);
+        }
+      }
+    ])
+  ];
+};
+var rangeExtension = (onInit) => {
+  let view;
+  let activeRange;
+  const provider = (range) => {
+    if (activeRange) {
+      view.dispatch(view.state.update({
+        changes: {
+          ...activeRange,
+          insert: range.toString()
+        },
+        selection: {
+          anchor: activeRange.from + range.length
+        }
+      }));
+    }
+    view.focus();
+  };
+  return ViewPlugin.fromClass(class {
+    constructor(_view) {
+      view = _view;
+      onInit(provider);
+    }
+    update(view2) {
+      const { anchor } = view2.state.selection.ranges[0];
+      activeRange = void 0;
+      const [language] = view2.state.facet(languageFacet);
+      const { topNode } = language.parser.parse(view2.state.doc.toString());
+      visitTree(topNode, ({ type, from, to }) => {
+        if (from <= anchor && to >= anchor) {
+          switch (type.name) {
+            case "Function": {
+              activeRange = {
+                from: to,
+                to
+              };
+              break;
+            }
+            case "RangeToken":
+            case "CellToken":
+              activeRange = {
+                from,
+                to
+              };
+              return true;
+          }
+        }
+        return false;
+      });
+      if (!activeRange && view2.state.doc.toString()[0] === "=") {
+        activeRange = {
+          from: 1,
+          to: view2.state.doc.toString().length
+        };
+      }
+    }
+  });
+};
+var visitTree = (node, callback) => {
+  if (callback(node)) {
+    return true;
+  }
+  for (let child = node.firstChild; child !== null; child = child.nextSibling) {
+    if (visitTree(child, callback)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+// packages/plugins/plugin-sheet/src/components/Sheet/Sheet.tsx
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/plugins/plugin-sheet/src/components/Sheet/Sheet.tsx";
+var fragments = {
+  axis: "bg-neutral-50 text-neutral-800 dark:bg-neutral-800 dark:text-neutral-200 text-xs select-none",
+  axisSelected: "bg-neutral-100 dark:bg-neutral-900 text-black dark:text-white",
+  cell: "dark:bg-neutral-850",
+  cellSelected: "bg-neutral-50 dark:bg-neutral-900 text-black dark:text-white border !border-primary-500",
+  border: "border-neutral-200 dark:border-neutral-700"
+};
+var SheetRoot = ({ children, ...props }) => {
+  return /* @__PURE__ */ React3.createElement(SheetContextProvider, props, children);
+};
+var SheetMain = /* @__PURE__ */ forwardRef(({ classNames, numRows, numColumns }, forwardRef2) => {
+  const { model, cursor, setCursor, setRange, setEditing } = useSheetContext();
+  const { rowsRef, columnsRef, contentRef } = useScrollHandlers();
+  const [rows, setRows] = useState4([
+    ...model.sheet.rows
+  ]);
+  const [columns, setColumns] = useState4([
+    ...model.sheet.columns
+  ]);
+  useEffect3(() => {
+    const rowsAccessor = createDocAccessor(model.sheet, [
+      "rows"
+    ]);
+    const columnsAccessor = createDocAccessor(model.sheet, [
+      "columns"
+    ]);
+    const handleUpdate = debounce(() => {
+      setRows([
+        ...model.sheet.rows
+      ]);
+      setColumns([
+        ...model.sheet.columns
+      ]);
+    }, 100);
+    rowsAccessor.handle.addListener("change", handleUpdate);
+    columnsAccessor.handle.addListener("change", handleUpdate);
+    handleUpdate();
+    return () => {
+      rowsAccessor.handle.removeListener("change", handleUpdate);
+      columnsAccessor.handle.removeListener("change", handleUpdate);
+    };
+  }, [
+    model
+  ]);
+  useEffect3(() => {
+    model.reset();
+  }, [
+    rows,
+    columns
+  ]);
+  const handleMoveRows = (from, to, num = 1) => {
+    const cursorIdx = cursor ? model.addressToIndex(cursor) : void 0;
+    const [rows2] = model.sheet.rows.splice(from, num);
+    model.sheet.rows.splice(to, 0, rows2);
+    if (cursorIdx) {
+      setCursor(model.addressFromIndex(cursorIdx));
+    }
+    setRows([
+      ...model.sheet.rows
+    ]);
+  };
+  const handleMoveColumns = (from, to, num = 1) => {
+    const cursorIdx = cursor ? model.addressToIndex(cursor) : void 0;
+    const columns2 = model.sheet.columns.splice(from, num);
+    model.sheet.columns.splice(to, 0, ...columns2);
+    if (cursorIdx) {
+      setCursor(model.addressFromIndex(cursorIdx));
+    }
+    setColumns([
+      ...model.sheet.columns
+    ]);
+  };
+  const [rowSizes, setRowSizes] = useState4();
+  const [columnSizes, setColumnSizes] = useState4();
+  useEffect3(() => {
+    const rowAccessor = createDocAccessor(model.sheet, [
+      "rowMeta"
+    ]);
+    const columnAccessor = createDocAccessor(model.sheet, [
+      "columnMeta"
+    ]);
+    const handleUpdate = debounce(() => {
+      const mapSizes = (values) => values.reduce((map, [idx, meta]) => {
+        if (meta.size) {
+          map[idx] = meta.size;
+        }
+        return map;
+      }, {});
+      setRowSizes(mapSizes(Object.entries(model.sheet.rowMeta)));
+      setColumnSizes(mapSizes(Object.entries(model.sheet.columnMeta)));
+    }, 100);
+    rowAccessor.handle.addListener("change", handleUpdate);
+    columnAccessor.handle.addListener("change", handleUpdate);
+    handleUpdate();
+    return () => {
+      rowAccessor.handle.removeListener("change", handleUpdate);
+      columnAccessor.handle.removeListener("change", handleUpdate);
+    };
+  }, [
+    model
+  ]);
+  const handleResizeRow = (idx, size, save) => {
+    if (save) {
+      model.sheet.rowMeta[idx] ??= {};
+      model.sheet.rowMeta[idx].size = size;
+    } else {
+      setRowSizes((sizes) => ({
+        ...sizes,
+        [idx]: size
+      }));
+    }
+  };
+  const handleResizeColumn = (idx, size, save) => {
+    if (save) {
+      model.sheet.columnMeta[idx] ??= {};
+      model.sheet.columnMeta[idx].size = size;
+    } else {
+      setColumnSizes((sizes) => ({
+        ...sizes,
+        [idx]: size
+      }));
+    }
+  };
+  return /* @__PURE__ */ React3.createElement("div", {
+    role: "none",
+    className: mx2("grid grid-cols-[calc(var(--rail-size)-2px)_1fr] grid-rows-[32px_1fr_32px] bs-full is-full overflow-hidden", fragments.border, classNames)
+  }, /* @__PURE__ */ React3.createElement(GridCorner, {
+    onClick: () => {
+      setCursor(void 0);
+      setRange(void 0);
+      setEditing(false);
+    }
+  }), /* @__PURE__ */ React3.createElement(SheetColumns, {
+    ref: columnsRef,
+    columns,
+    sizes: columnSizes,
+    selected: cursor?.column,
+    onSelect: (column) => setCursor(cursor?.column === column ? void 0 : {
+      row: -1,
+      column
+    }),
+    onResize: handleResizeColumn,
+    onMove: handleMoveColumns
+  }), /* @__PURE__ */ React3.createElement(SheetRows, {
+    ref: rowsRef,
+    rows,
+    sizes: rowSizes,
+    selected: cursor?.row,
+    onSelect: (row) => setCursor(cursor?.row === row ? void 0 : {
+      row,
+      column: -1
+    }),
+    onResize: handleResizeRow,
+    onMove: handleMoveRows
+  }), /* @__PURE__ */ React3.createElement(SheetGrid, {
+    ref: contentRef,
+    size: {
+      numRows: numRows ?? rows.length,
+      numColumns: numColumns ?? columns.length
+    },
+    rows,
+    columns,
+    rowSizes,
+    columnSizes
+  }), /* @__PURE__ */ React3.createElement(GridCorner, null), /* @__PURE__ */ React3.createElement(SheetStatusBar, null));
+});
+var useScrollHandlers = () => {
+  const rowsRef = useRef(null);
+  const columnsRef = useRef(null);
+  const contentRef = useRef(null);
+  useEffect3(() => {
+    const handleRowsScroll = (ev) => {
+      const { scrollTop } = ev.target;
+      if (!rowsRef.current.dataset.locked) {
+        contentRef.current.scrollTop = scrollTop;
+      }
+    };
+    const handleColumnsScroll = (ev) => {
+      const { scrollLeft } = ev.target;
+      if (!columnsRef.current.dataset.locked) {
+        contentRef.current.scrollLeft = scrollLeft;
+      }
+    };
+    const handleContentScroll = (ev) => {
+      const { scrollTop, scrollLeft } = ev.target;
+      rowsRef.current.scrollTop = scrollTop;
+      columnsRef.current.scrollLeft = scrollLeft;
+    };
+    const rows = rowsRef.current;
+    const columns = columnsRef.current;
+    const content = contentRef.current;
+    rows.addEventListener("scroll", handleRowsScroll);
+    columns.addEventListener("scroll", handleColumnsScroll);
+    content.addEventListener("scroll", handleContentScroll);
+    return () => {
+      rows.removeEventListener("scroll", handleRowsScroll);
+      columns.removeEventListener("scroll", handleColumnsScroll);
+      content.removeEventListener("scroll", handleContentScroll);
+    };
+  }, []);
+  return {
+    rowsRef,
+    columnsRef,
+    contentRef
+  };
+};
+var GridCorner = (props) => {
+  return /* @__PURE__ */ React3.createElement("div", {
+    className: fragments.axis,
+    ...props
+  });
+};
+var MovingOverlay = ({ label }) => {
+  return /* @__PURE__ */ React3.createElement("div", {
+    className: "flex w-full h-full justify-center items-center text-sm p-1 bg-primary-500/50 cursor-pointer"
+  }, label);
+};
+var mouseConstraints = {
+  distance: 10
+};
+var touchConstraints = {
+  delay: 250,
+  tolerance: 5
+};
+var SheetRows = /* @__PURE__ */ forwardRef(({ rows, sizes, selected, onSelect, onResize, onMove }, forwardRef2) => {
+  const mouseSensor = useSensor(MouseSensor, {
+    activationConstraint: mouseConstraints
+  });
+  const touchSensor = useSensor(TouchSensor, {
+    activationConstraint: touchConstraints
+  });
+  const keyboardSensor = useSensor(KeyboardSensor, {});
+  const sensors = useSensors(mouseSensor, touchSensor, keyboardSensor);
+  const [active, setActive] = useState4(null);
+  const handleDragStart = ({ active: active2 }) => {
+    setActive(active2);
+  };
+  const handleDragEnd = ({ over, active: active2 }) => {
+    if (over && over.id !== active2.id) {
+      setActive(null);
+      onMove?.(active2.data.current.index, over.data.current.index);
+    }
+  };
+  const snapToCenter = ({ activatorEvent, draggingNodeRect, transform }) => {
+    if (draggingNodeRect && activatorEvent) {
+      const activatorCoordinates = getEventCoordinates(activatorEvent);
+      if (!activatorCoordinates) {
+        return transform;
+      }
+      const offset = activatorCoordinates.y - draggingNodeRect.top;
+      return {
+        ...transform,
+        y: transform.y + offset - draggingNodeRect.height / 2
+      };
+    }
+    return transform;
+  };
+  return /* @__PURE__ */ React3.createElement("div", {
+    className: "relative flex grow overflow-hidden"
+  }, /* @__PURE__ */ React3.createElement("div", {
+    className: mx2("z-20 absolute inset-0 border-y pointer-events-none", fragments.border),
+    style: {
+      width: axisWidth
+    }
+  }), /* @__PURE__ */ React3.createElement("div", {
+    ref: forwardRef2,
+    role: "rowheader",
+    className: "grow overflow-y-auto scrollbar-none"
+  }, /* @__PURE__ */ React3.createElement(DndContext, {
+    sensors,
+    modifiers: [
+      restrictToVerticalAxis,
+      snapToCenter
+    ],
+    onDragStart: handleDragStart,
+    onDragEnd: handleDragEnd
+  }, /* @__PURE__ */ React3.createElement("div", {
+    className: "flex flex-col",
+    style: {
+      width: axisWidth
+    }
+  }, rows.map((idx, index) => /* @__PURE__ */ React3.createElement(GridRowCell, {
+    key: idx,
+    idx,
+    index,
+    label: String(index + 1),
+    size: sizes?.[idx] ?? defaultHeight,
+    resize: index < rows.length - 1,
+    selected: selected === index,
+    onResize,
+    onSelect
+  }))), /* @__PURE__ */ createPortal(/* @__PURE__ */ React3.createElement(DragOverlay, null, active && /* @__PURE__ */ React3.createElement(MovingOverlay, {
+    label: String(active.data.current.index + 1)
+  })), document.body))));
+});
+var GridRowCell = ({ idx, index, label, size, resize, selected, onSelect, onResize }) => {
+  const { setNodeRef: setDroppableNodeRef } = useDroppable({
+    id: idx,
+    data: {
+      index
+    }
+  });
+  const { setNodeRef: setDraggableNodeRef, attributes, listeners, isDragging, over } = useDraggable({
+    id: idx,
+    data: {
+      index
+    }
+  });
+  const setNodeRef = useCombinedRefs(setDroppableNodeRef, setDraggableNodeRef);
+  const [initialSize, setInitialSize] = useState4(size);
+  const [resizing, setResizing] = useState4(false);
+  const scrollHandler = useRef();
+  const handleResizeStart = (_ev, _dir, elementRef) => {
+    const scrollContainer = elementRef.closest('[role="rowheader"]');
+    const scrollTop = scrollContainer.scrollTop;
+    scrollHandler.current = (ev) => ev.target.scrollTop = scrollTop;
+    scrollContainer.addEventListener("scroll", scrollHandler.current);
+    scrollContainer.dataset.locked = "true";
+    setResizing(true);
+  };
+  const handleResize = (_ev, _dir, _elementRef, { height }) => {
+    onResize?.(idx, initialSize + height);
+  };
+  const handleResizeStop = (_ev, _dir, elementRef, { height }) => {
+    const scrollContainer = elementRef.closest('[role="rowheader"]');
+    scrollContainer.removeEventListener("scroll", scrollHandler.current);
+    delete scrollContainer.dataset.locked;
+    scrollHandler.current = void 0;
+    setInitialSize(initialSize + height);
+    onResize?.(idx, initialSize + height, true);
+    setResizing(false);
+  };
+  return /* @__PURE__ */ React3.createElement(Resizable, {
+    enable: {
+      bottom: resize
+    },
+    size: {
+      height: size - 1
+    },
+    minHeight: minHeight - 1,
+    maxHeight,
+    onResizeStart: handleResizeStart,
+    onResize: handleResize,
+    onResizeStop: handleResizeStop
+  }, /* @__PURE__ */ React3.createElement("div", {
+    ref: setNodeRef,
+    ...attributes,
+    ...listeners,
+    className: mx2("flex h-full items-center justify-center cursor-pointer", "border-t focus-visible:outline-none", fragments.border, fragments.axis, selected && fragments.axisSelected, isDragging && fragments.axisSelected),
+    onClick: () => onSelect?.(index)
+  }, /* @__PURE__ */ React3.createElement("span", {
+    className: "flex w-full justify-center"
+  }, label), over?.id === idx && !isDragging && /* @__PURE__ */ React3.createElement("div", {
+    className: "z-20 absolute top-0 w-full min-h-[4px] border-b-4 border-primary-500"
+  }), resizing && /* @__PURE__ */ React3.createElement("div", {
+    className: "z-20 absolute bottom-0 w-full min-h-[4px] border-b-4 border-primary-500"
+  })));
+};
+var SheetColumns = /* @__PURE__ */ forwardRef(({ columns, sizes, selected, onSelect, onResize, onMove }, forwardRef2) => {
+  const mouseSensor = useSensor(MouseSensor, {
+    activationConstraint: mouseConstraints
+  });
+  const touchSensor = useSensor(TouchSensor, {
+    activationConstraint: touchConstraints
+  });
+  const keyboardSensor = useSensor(KeyboardSensor, {});
+  const sensors = useSensors(mouseSensor, touchSensor, keyboardSensor);
+  const [active, setActive] = useState4(null);
+  const handleDragStart = ({ active: active2 }) => {
+    setActive(active2);
+  };
+  const handleDragEnd = ({ active: active2, over }) => {
+    if (over && over.id !== active2.id) {
+      setActive(null);
+      onMove?.(active2.data.current.index, over.data.current.index);
+    }
+  };
+  const snapToCenter = ({ activatorEvent, draggingNodeRect, transform }) => {
+    if (draggingNodeRect && activatorEvent) {
+      const activatorCoordinates = getEventCoordinates(activatorEvent);
+      if (!activatorCoordinates) {
+        return transform;
+      }
+      const offset = activatorCoordinates.x - draggingNodeRect.left;
+      return {
+        ...transform,
+        x: transform.x + offset - draggingNodeRect.width / 2
+      };
+    }
+    return transform;
+  };
+  return /* @__PURE__ */ React3.createElement("div", {
+    className: "relative flex grow overflow-hidden"
+  }, /* @__PURE__ */ React3.createElement("div", {
+    className: mx2("z-20 absolute inset-0 border-x pointer-events-none", fragments.border),
+    style: {
+      height: axisHeight
+    }
+  }), /* @__PURE__ */ React3.createElement("div", {
+    ref: forwardRef2,
+    role: "columnheader",
+    className: "grow overflow-x-auto scrollbar-none"
+  }, /* @__PURE__ */ React3.createElement(DndContext, {
+    autoScroll: {
+      enabled: true
+    },
+    sensors,
+    modifiers: [
+      restrictToHorizontalAxis,
+      snapToCenter
+    ],
+    onDragStart: handleDragStart,
+    onDragEnd: handleDragEnd
+  }, /* @__PURE__ */ React3.createElement("div", {
+    className: "flex h-full",
+    style: {
+      height: axisHeight
+    }
+  }, columns.map((idx, index) => /* @__PURE__ */ React3.createElement(GridColumnCell, {
+    key: idx,
+    idx,
+    index,
+    label: columnLetter(index),
+    size: sizes?.[idx] ?? defaultWidth,
+    resize: index < columns.length - 1,
+    selected: selected === index,
+    onResize,
+    onSelect
+  }))), /* @__PURE__ */ createPortal(/* @__PURE__ */ React3.createElement(DragOverlay, null, active && /* @__PURE__ */ React3.createElement(MovingOverlay, {
+    label: columnLetter(active.data.current.index)
+  })), document.body))));
+});
+var GridColumnCell = ({ idx, index, label, size, resize, selected, onSelect, onResize }) => {
+  const { setNodeRef: setDroppableNodeRef } = useDroppable({
+    id: idx,
+    data: {
+      index
+    }
+  });
+  const { setNodeRef: setDraggableNodeRef, attributes, listeners, over, isDragging } = useDraggable({
+    id: idx,
+    data: {
+      index
+    }
+  });
+  const setNodeRef = useCombinedRefs(setDroppableNodeRef, setDraggableNodeRef);
+  const [initialSize, setInitialSize] = useState4(size);
+  const [resizing, setResizing] = useState4(false);
+  const scrollHandler = useRef();
+  const handleResizeStart = (_ev, _dir, elementRef) => {
+    const scrollContainer = elementRef.closest('[role="columnheader"]');
+    const scrollLeft = scrollContainer.scrollLeft;
+    scrollHandler.current = (ev) => ev.target.scrollLeft = scrollLeft;
+    scrollContainer.addEventListener("scroll", scrollHandler.current);
+    scrollContainer.dataset.locked = "true";
+    setResizing(true);
+  };
+  const handleResize = (_ev, _dir, _elementRef, { width }) => {
+    onResize?.(idx, initialSize + width);
+  };
+  const handleResizeStop = (_ev, _dir, elementRef, { width }) => {
+    const scrollContainer = elementRef.closest('[role="columnheader"]');
+    scrollContainer.removeEventListener("scroll", scrollHandler.current);
+    delete scrollContainer.dataset.locked;
+    scrollHandler.current = void 0;
+    setInitialSize(initialSize + width);
+    onResize?.(idx, initialSize + width, true);
+    setResizing(false);
+  };
+  return /* @__PURE__ */ React3.createElement(Resizable, {
+    enable: {
+      right: resize
+    },
+    size: {
+      width: size - 1
+    },
+    minWidth: minWidth - 1,
+    maxWidth,
+    onResizeStart: handleResizeStart,
+    onResize: handleResize,
+    onResizeStop: handleResizeStop
+  }, /* @__PURE__ */ React3.createElement("div", {
+    ref: setNodeRef,
+    ...attributes,
+    ...listeners,
+    className: mx2("flex h-full items-center justify-center cursor-pointer", "border-l focus-visible:outline-none", fragments.border, fragments.axis, selected && fragments.axisSelected, isDragging && fragments.axisSelected),
+    onClick: () => onSelect?.(index)
+  }, /* @__PURE__ */ React3.createElement("span", {
+    className: "flex w-full justify-center"
+  }, label), over?.id === idx && !isDragging && /* @__PURE__ */ React3.createElement("div", {
+    className: "z-20 absolute left-0 h-full min-w-[4px] border-l-4 border-primary-500"
+  }), resizing && /* @__PURE__ */ React3.createElement("div", {
+    className: "z-20 absolute right-0 h-full min-h-[4px] border-l-4 border-primary-500"
+  })));
+};
+var SheetGrid = /* @__PURE__ */ forwardRef(({ size, rows, columns, rowSizes, columnSizes }, forwardRef2) => {
+  const { ref: containerRef, width: containerWidth = 0, height: containerHeight = 0 } = useResizeDetector({
+    refreshRate: 200
+  });
+  const scrollerRef = useRef(null);
+  useImperativeHandle(forwardRef2, () => scrollerRef.current);
+  const { model, cursor, range, editing, setCursor, setRange, setEditing, onInfo } = useSheetContext();
+  const initialText = useRef();
+  const quickEdit = useRef(false);
+  const [, forceUpdate] = useState4({});
+  useEffect3(() => {
+    const unsubscribe = model.update.on(() => {
+      log("updated", {
+        id: model.id
+      }, {
+        F: __dxlog_file2,
+        L: 734,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      forceUpdate({});
+    });
+    return () => {
+      unsubscribe();
+    };
+  }, [
+    model
+  ]);
+  const inputRef = useRef(null);
+  const handleKeyDown = (ev) => {
+    const isMacOS = /Mac|iPhone|iPod|iPad/.test(navigator.userAgent);
+    if (cursor && (isMacOS && ev.metaKey || ev.ctrlKey)) {
+      switch (ev.key) {
+        case "x": {
+          model.cut(range ?? {
+            from: cursor
+          });
+          return;
+        }
+        case "c": {
+          model.copy(range ?? {
+            from: cursor
+          });
+          return;
+        }
+        case "v": {
+          model.paste(cursor);
+          return;
+        }
+        case "z": {
+          if (ev.shiftKey) {
+            model.redo();
+          } else {
+            model.undo();
+          }
+          return;
+        }
+      }
+    }
+    switch (ev.key) {
+      case "ArrowUp":
+      case "ArrowDown":
+      case "ArrowLeft":
+      case "ArrowRight":
+      case "Home":
+      case "End": {
+        const next = handleNav(ev, cursor, range, size);
+        setRange(next.range);
+        if (next.cursor) {
+          setCursor(next.cursor);
+          const element = getCellElement(scrollerRef.current, next.cursor);
+          if (element) {
+            scrollIntoView(scrollerRef.current, element);
+          }
+        }
+        break;
+      }
+      case "Backspace": {
+        if (cursor) {
+          if (range) {
+            model.clear(range);
+          } else {
+            model.setValue(cursor, null);
+          }
+        }
+        break;
+      }
+      case "Escape": {
+        setRange(void 0);
+        break;
+      }
+      case "Enter": {
+        ev.stopPropagation();
+        if (cursor) {
+          setEditing(true);
+        }
+        break;
+      }
+      case "?": {
+        onInfo?.();
+        break;
+      }
+      default: {
+        if (ev.key.length === 1) {
+          initialText.current = ev.key;
+          quickEdit.current = true;
+          setEditing(true);
+        }
+      }
+    }
+  };
+  const { handlers } = useRangeSelect((event, range2) => {
+    switch (event) {
+      case "start": {
+        setRange(void 0);
+        break;
+      }
+      default: {
+        setRange(range2);
+      }
+    }
+  });
+  const { width, height, rowRange, columnRange } = useGridLayout({
+    scroller: scrollerRef.current,
+    size: {
+      width: containerWidth,
+      height: containerHeight
+    },
+    rows,
+    columns,
+    rowSizes,
+    columnSizes
+  });
+  const qualifiedSubjectId = fullyQualifiedId(model.sheet);
+  const attendableAttrs = createAttendableAttributes(qualifiedSubjectId);
+  return /* @__PURE__ */ React3.createElement("div", {
+    ref: containerRef,
+    role: "grid",
+    className: "relative flex grow overflow-hidden"
+  }, /* @__PURE__ */ React3.createElement("div", {
+    className: mx2("z-20 absolute inset-0 border pointer-events-none", fragments.border)
+  }), /* @__PURE__ */ React3.createElement("div", {
+    ref: scrollerRef,
+    className: "grow overflow-auto scrollbar-thin"
+  }, /* @__PURE__ */ React3.createElement("div", {
+    className: "relative select-none",
+    style: {
+      width,
+      height
+    },
+    onClick: () => inputRef.current?.focus(),
+    ...handlers
+  }, scrollerRef.current && /* @__PURE__ */ React3.createElement(SelectionOverlay, {
+    root: scrollerRef.current
+  }), rowRange.map(({ row, top, height: height2 }) => {
+    return columnRange.map(({ column, left, width: width2 }) => {
+      const style = {
+        position: "absolute",
+        top,
+        left,
+        width: width2,
+        height: height2
+      };
+      const cell = {
+        row,
+        column
+      };
+      const id = addressToA1Notation(cell);
+      const idx = model.addressToIndex(cell);
+      const active = posEquals(cursor, cell);
+      if (active && editing) {
+        const value = initialText.current ?? model.getCellText(cell) ?? "";
+        const handleClose = (value2) => {
+          initialText.current = void 0;
+          quickEdit.current = false;
+          if (value2 !== void 0) {
+            model.setValue(cell, value2);
+            const next = handleArrowNav({
+              key: "ArrowDown",
+              metaKey: false
+            }, cursor, size);
+            if (next) {
+              setCursor(next);
+            }
+          }
+          inputRef.current?.focus();
+          setEditing(false);
+        };
+        const handleNav2 = (value2, { key }) => {
+          initialText.current = void 0;
+          model.setValue(cell, value2 ?? null);
+          const next = handleArrowNav({
+            key,
+            metaKey: false
+          }, cursor, size);
+          if (next) {
+            setCursor(next);
+          }
+          inputRef.current?.focus();
+          setEditing(false);
+        };
+        return /* @__PURE__ */ React3.createElement(GridCellEditor, {
+          key: idx,
+          value,
+          style,
+          onNav: quickEdit.current ? handleNav2 : void 0,
+          onClose: handleClose
+        });
+      }
+      return /* @__PURE__ */ React3.createElement(SheetCell, {
+        key: id,
+        id,
+        cell,
+        active,
+        style,
+        onSelect: (cell2, edit) => {
+          setEditing(edit);
+          setCursor(cell2);
+        }
+      });
+    });
+  }))), /* @__PURE__ */ createPortal(/* @__PURE__ */ React3.createElement("input", {
+    ref: inputRef,
+    autoFocus: true,
+    className: "absolute w-[1px] h-[1px] bg-transparent outline-none border-none caret-transparent",
+    onKeyDown: handleKeyDown,
+    ...attendableAttrs
+  }), document.body));
+});
+var SelectionOverlay = ({ root }) => {
+  const { range } = useSheetContext();
+  if (!range) {
+    return null;
+  }
+  const c1 = getCellElement(root, range.from);
+  const c2 = range.to ? getCellElement(root, range.to) : c1;
+  if (!c1 || !c2) {
+    return null;
+  }
+  const b1 = getRelativeClientRect(root, c1);
+  const b2 = getRelativeClientRect(root, c2);
+  const bounds = getRectUnion(b1, b2);
+  return /* @__PURE__ */ React3.createElement("div", {
+    role: "none",
+    style: bounds,
+    className: "z-10 absolute pointer-events-none bg-primary-500/20 border border-primary-500/50"
+  });
+};
+var SheetCell = ({ id, cell, style, active, onSelect }) => {
+  const { formatting, editing, setRange } = useSheetContext();
+  const { value, classNames } = formatting.getFormatting(cell);
+  return /* @__PURE__ */ React3.createElement("div", {
+    [`data-${CELL_DATA_KEY}`]: id,
+    role: "cell",
+    style,
+    className: mx2("flex w-full h-full truncate items-center border cursor-pointer", "px-2 py-1", fragments.cell, fragments.border, active && [
+      "z-20",
+      fragments.cellSelected
+    ], classNames),
+    onClick: () => {
+      if (editing) {
+        setRange?.({
+          from: cell
+        });
+      } else {
+        onSelect?.(cell, false);
+      }
+    },
+    onDoubleClick: () => onSelect?.(cell, true)
+  }, value);
+};
+var GridCellEditor = ({ style, value, onNav, onClose }) => {
+  const { model, range } = useSheetContext();
+  const notifier = useRef();
+  useEffect3(() => {
+    if (range) {
+      notifier.current?.(rangeToA1Notation(range));
+    }
+  }, [
+    range
+  ]);
+  const [extension] = useState4(() => {
+    return [
+      editorKeys({
+        onNav,
+        onClose
+      }),
+      sheetExtension({
+        functions: model.functions
+      }),
+      rangeExtension((fn) => notifier.current = fn)
+    ];
+  });
+  return /* @__PURE__ */ React3.createElement("div", {
+    role: "cell",
+    style,
+    className: mx2("z-20 flex", fragments.cellSelected),
+    onClick: (ev) => ev.stopPropagation()
+  }, /* @__PURE__ */ React3.createElement(CellEditor, {
+    autoFocus: true,
+    value,
+    extension
+  }));
+};
+var SheetStatusBar = () => {
+  const { model, cursor, range } = useSheetContext();
+  let value;
+  let isFormula = false;
+  if (cursor) {
+    value = model.getCellValue(cursor);
+    if (typeof value === "string" && value.charAt(0) === "=") {
+      value = model.mapFormulaIndicesToRefs(value);
+      isFormula = true;
+    } else if (value != null) {
+      value = String(value);
+    }
+  }
+  return /* @__PURE__ */ React3.createElement("div", {
+    className: mx2("flex shrink-0 justify-between items-center px-4 py-1 text-sm border-x", fragments.border)
+  }, /* @__PURE__ */ React3.createElement("div", {
+    className: "flex gap-4 items-center"
+  }, /* @__PURE__ */ React3.createElement("div", {
+    className: "flex w-16 items-center font-mono"
+  }, range && rangeToA1Notation(range) || cursor && addressToA1Notation(cursor)), /* @__PURE__ */ React3.createElement("div", {
+    className: "flex gap-2 items-center"
+  }, /* @__PURE__ */ React3.createElement(FunctionIcon, {
+    className: mx2("text-green-500", isFormula ? "visible" : "invisible")
+  }), /* @__PURE__ */ React3.createElement("span", {
+    className: "font-mono"
+  }, value))));
+};
+var SheetDebug = () => {
+  const { model, cursor, range } = useSheetContext();
+  const [, forceUpdate] = useState4({});
+  useEffect3(() => {
+    const accessor = createDocAccessor(model.sheet, []);
+    const handleUpdate = () => forceUpdate({});
+    accessor.handle.addListener("change", handleUpdate);
+    handleUpdate();
+    return () => {
+      accessor.handle.removeListener("change", handleUpdate);
+    };
+  }, [
+    model
+  ]);
+  return /* @__PURE__ */ React3.createElement("div", {
+    className: mx2("z-20 absolute right-0 top-20 bottom-20 w-[30rem] overflow-auto scrollbar-thin", "border text-xs bg-neutral-50 dark:bg-black text-cyan-500 font-mono p-1 opacity-80", fragments.border)
+  }, /* @__PURE__ */ React3.createElement("pre", {
+    className: "whitespace-pre-wrap"
+  }, JSON.stringify({
+    cursor,
+    range,
+    cells: model.sheet.cells,
+    rowMeta: model.sheet.rowMeta,
+    columnMeta: model.sheet.columnMeta,
+    formatting: model.sheet.formatting
+  }, void 0, 2)));
+};
+var Sheet = {
+  Root: SheetRoot,
+  Main: SheetMain,
+  Rows: SheetRows,
+  Columns: SheetColumns,
+  Grid: SheetGrid,
+  Cell: SheetCell,
+  StatusBar: SheetStatusBar,
+  Debug: SheetDebug
+};
+
+// packages/plugins/plugin-sheet/src/components/SheetContainer.tsx
+var SheetContainer = ({ sheet, space, role, coordinate = {
+  part: "main",
+  entryId: ""
+} }) => {
+  return /* @__PURE__ */ React4.createElement("div", {
+    role: "none",
+    className: mx3(role === "section" && "aspect-square", role === "article" && "row-span-2")
+  }, /* @__PURE__ */ React4.createElement(Sheet.Root, {
+    sheet,
+    space
+  }, /* @__PURE__ */ React4.createElement(Sheet.Main, {
+    // TODO(burdon): Standardize for other components (e.g., table).
+    classNames: [
+      coordinate.part !== "solo" && "border-is",
+      role === "section" && "border-y border-is"
+    ]
+  })));
+};
+var SheetContainer_default = SheetContainer;
+export {
+  SheetContainer_default as default
+};
+//# sourceMappingURL=SheetContainer-H22IDJ43.mjs.map