@rowsncolumns/ui 15.0.38

package/dist/cjs/editor-pm/helpers.js

@@ -0,0 +1,1170 @@
+import { __assign, __read, __spreadArray, __values } from "tslib";
+import { cleanupColumnName } from "@rowsncolumns/calculator";
+import { tokenVocabulary } from "@rowsncolumns/fast-formula-parser";
+import { CELL_SUGGESTION_PREFIX, CELL_SUGGESTION_SUFFIX, } from "../editor/constants";
+/**
+ * Converts string to ProseMirror document
+ * @param str
+ * @param schema
+ * @returns
+ */
+export var deserializeString = function (str, schema) {
+    try {
+        if (typeof str === "object") {
+            str = tryParseRichText(str);
+        }
+        // Validate input
+        if (typeof str !== "string") {
+            console.warn("deserializeString: input is not a string, using empty string");
+            str = "";
+        }
+        // Sanitize string - remove null characters and other problematic chars
+        str = str
+            .replace(/\0/g, "")
+            .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "");
+        var lines = str.split("\n");
+        var nodes = lines.map(function (line) {
+            return schema.node("line", null, line ? [schema.text(line)] : []);
+        });
+        return schema.node("doc", null, nodes);
+    }
+    catch (error) {
+        console.error("Error deserializing string:", error);
+        // Return empty document as fallback
+        return schema.node("doc", null, [schema.node("line", null, [])]);
+    }
+};
+export var tryParseRichText = function (str) {
+    var _a;
+    // Temporary workaround for .richText
+    if ("richText" in str) {
+        str = (_a = str === null || str === void 0 ? void 0 : str.richText) === null || _a === void 0 ? void 0 : _a.map(function (value) { return value.text; }).join("");
+    }
+    else {
+        str = "Unable to parse string";
+    }
+    return str;
+};
+/**
+ * Converts ProseMirror document to string
+ * @param doc
+ * @returns
+ */
+export var serializeEditorValue = function (doc) {
+    var text = "";
+    doc.content.forEach(function (node, offset, index) {
+        if (node.type.name === "line") {
+            if (index > 0)
+                text += "\n";
+            // Serialize line content, handling mention nodes properly
+            var lineText_1 = "";
+            node.content.forEach(function (child) {
+                if (child.type.name === "mention") {
+                    // Serialize mention as just the label
+                    lineText_1 += child.attrs.label;
+                }
+                else if (child.isText) {
+                    // Regular text node
+                    lineText_1 += child.text;
+                }
+            });
+            text += lineText_1;
+        }
+    });
+    return text;
+};
+/**
+ * Extracts text format runs from ProseMirror document
+ * @param doc ProseMirror document node
+ * @returns Array of TextFormatRun objects
+ */
+export var extractTextFormatRuns = function (doc) {
+    if (!doc) {
+        return undefined;
+    }
+    var formatRuns = [];
+    var currentIndex = 0;
+    doc.content.forEach(function (node, _, lineIndex) {
+        if (node.type.name === "line") {
+            if (lineIndex > 0) {
+                // Add newline character to index
+                currentIndex++;
+            }
+            // First pass: collect all child nodes with their start positions
+            var childNodes_1 = [];
+            var nodeIndex_1 = currentIndex;
+            node.content.forEach(function (child) {
+                childNodes_1.push({
+                    node: child,
+                    startIndex: nodeIndex_1,
+                });
+                // Calculate the next start index based on the node type
+                if (child.type.name === "mention") {
+                    // For mentions, use just the label length for positioning
+                    nodeIndex_1 += child.attrs.label.length;
+                }
+                else if (child.isText && child.text) {
+                    nodeIndex_1 += child.text.length;
+                }
+            });
+            // Second pass: create format runs using next child's start index as end boundary
+            childNodes_1.forEach(function (childData, index) {
+                var child = childData.node, startIndex = childData.startIndex;
+                // Calculate endIndex using next child's startIndex, or end of line
+                var nextChild = childNodes_1[index + 1];
+                var endIndex = nextChild ? nextChild.startIndex : nodeIndex_1;
+                if (child.type.name === "mention") {
+                    formatRuns.push({
+                        startIndex: startIndex,
+                        endIndex: endIndex,
+                        nodeType: "mention",
+                        mention: __assign({}, child.attrs),
+                    });
+                }
+                else if (child.isText && child.text) {
+                    if (child.marks && child.marks.length > 0) {
+                        // Extract format from marks
+                        var format_1 = {};
+                        child.marks.forEach(function (mark) {
+                            switch (mark.type.name) {
+                                case "bold":
+                                    format_1.bold = true;
+                                    break;
+                                case "italic":
+                                    format_1.italic = true;
+                                    break;
+                                case "underline":
+                                    format_1.underline = true;
+                                    break;
+                                case "strikethrough":
+                                    format_1.strikethrough = true;
+                                    break;
+                                case "superscript":
+                                    format_1.baselineOffset = "superscript";
+                                    break;
+                                case "subscript":
+                                    format_1.baselineOffset = "subscript";
+                                    break;
+                                case "color":
+                                    format_1.color = mark.attrs.color;
+                                    break;
+                                case "fontSize":
+                                    format_1.fontSize = mark.attrs.size;
+                                    break;
+                                case "fontFamily":
+                                    format_1.fontFamily = mark.attrs.family;
+                                    break;
+                            }
+                        });
+                        formatRuns.push({
+                            startIndex: startIndex,
+                            endIndex: endIndex,
+                            format: format_1,
+                            nodeType: "text",
+                        });
+                    }
+                    else {
+                        // Plain text without formatting
+                        formatRuns.push({
+                            startIndex: startIndex,
+                            endIndex: endIndex,
+                            format: {},
+                            nodeType: "text",
+                        });
+                    }
+                }
+            });
+            currentIndex = nodeIndex_1;
+        }
+    });
+    // Filter out text nodes with empty format objects
+    var filteredRuns = formatRuns.filter(function (run) {
+        if (run.nodeType === "text" && Object.keys(run.format).length === 0) {
+            return false;
+        }
+        return true;
+    });
+    return filteredRuns.length === 0 ? undefined : filteredRuns;
+};
+export var applyTextFormatRuns = function (text, formatRuns, schema, resolveColor) {
+    // Handle empty text case
+    if (text === "") {
+        return schema.nodes.doc.create(null, [schema.nodes.line.create(null, [])]);
+    }
+    // If no format runs, create simple document with plain text
+    if (!formatRuns || (formatRuns === null || formatRuns === void 0 ? void 0 : formatRuns.length) === 0) {
+        var lines_1 = text.split("\n");
+        var lineNodes_1 = lines_1.map(function (lineText) {
+            return schema.nodes.line.create(null, lineText ? [schema.text(lineText)] : []);
+        });
+        return schema.nodes.doc.create(null, lineNodes_1);
+    }
+    var sortedFormatRuns = __spreadArray([], __read(formatRuns), false).sort(function (a, b) { return a.startIndex - b.startIndex || a.endIndex - b.endIndex; });
+    var createMarks = function (formatRun) {
+        var marks = [];
+        // Engine-emitted runs (rnc window cells) can omit `format` on the
+        // unformatted gap runs between styled spans.
+        if (!formatRun.format) {
+            return marks;
+        }
+        if (formatRun.format.bold) {
+            marks.push(schema.marks.bold.create());
+        }
+        if (formatRun.format.italic) {
+            marks.push(schema.marks.italic.create());
+        }
+        if (formatRun.format.underline) {
+            marks.push(schema.marks.underline.create());
+        }
+        if (formatRun.format.strikethrough) {
+            marks.push(schema.marks.strikethrough.create());
+        }
+        if (formatRun.format.color) {
+            var css = typeof formatRun.format.color === "string"
+                ? formatRun.format.color
+                : resolveColor === null || resolveColor === void 0 ? void 0 : resolveColor(formatRun.format.color);
+            if (css) {
+                marks.push(schema.marks.color.create({ color: css }));
+            }
+        }
+        if (formatRun.format.baselineOffset === "superscript") {
+            marks.push(schema.marks.superscript.create());
+        }
+        else if (formatRun.format.baselineOffset === "subscript") {
+            marks.push(schema.marks.subscript.create());
+        }
+        if (formatRun.format.fontSize != null) {
+            marks.push(schema.marks.fontSize.create({ size: formatRun.format.fontSize }));
+        }
+        if (formatRun.format.fontFamily) {
+            marks.push(schema.marks.fontFamily.create({ family: formatRun.format.fontFamily }));
+        }
+        return marks;
+    };
+    // Split text into lines
+    var lines = text.split("\n");
+    var lineNodes = [];
+    var currentTextIndex = 0;
+    var _loop_1 = function (lineIndex) {
+        var e_1, _a;
+        var lineText = lines[lineIndex];
+        var lineContent = [];
+        if (lineIndex > 0) {
+            // Account for newline character
+            currentTextIndex++;
+        }
+        var lineStartIndex = currentTextIndex;
+        var lineEndIndex = currentTextIndex + lineText.length;
+        // Get format runs that overlap this line. Runs may span newlines,
+        // but ProseMirror stores each line separately, so split by line.
+        var lineFormatRuns = sortedFormatRuns.filter(function (run) { return run.startIndex < lineEndIndex && run.endIndex > lineStartIndex; });
+        if (lineFormatRuns.length === 0 && lineText.length > 0) {
+            // No formatting, create plain text node
+            lineContent.push(schema.text(lineText));
+        }
+        else if (lineText.length > 0) {
+            // Process format runs for this line
+            var processedIndex = lineStartIndex;
+            try {
+                for (var lineFormatRuns_1 = (e_1 = void 0, __values(lineFormatRuns)), lineFormatRuns_1_1 = lineFormatRuns_1.next(); !lineFormatRuns_1_1.done; lineFormatRuns_1_1 = lineFormatRuns_1.next()) {
+                    var formatRun = lineFormatRuns_1_1.value;
+                    var runStart = Math.max(formatRun.startIndex, lineStartIndex);
+                    var runEnd = Math.min(formatRun.endIndex, lineEndIndex);
+                    if (runEnd <= runStart || processedIndex >= lineEndIndex) {
+                        continue;
+                    }
+                    // Add any unformatted text before this run
+                    if (processedIndex < runStart) {
+                        var unformattedText = text.substring(processedIndex, runStart);
+                        if (unformattedText) {
+                            lineContent.push(schema.text(unformattedText));
+                        }
+                    }
+                    if (formatRun.nodeType === "mention") {
+                        // Create mention node from format run data
+                        if (formatRun.mention && formatRun.startIndex >= lineStartIndex) {
+                            lineContent.push(schema.nodes.mention.create({
+                                label: formatRun.mention.label,
+                                value: formatRun.mention.value,
+                            }));
+                            // Since mentions are now stored as just the label, advance by label length
+                            processedIndex = runStart + formatRun.mention.label.length;
+                        }
+                    }
+                    else {
+                        // Any non-mention run is a text run. xlsx-imported runs (rnc
+                        // engine and excel-parser) omit `nodeType`, so an exact
+                        // `=== "text"` check skipped them entirely — processedIndex
+                        // never advanced and the gap/tail fillers re-emitted the
+                        // already-covered text (e.g. "kpmg" painting as "kpmgkpmg").
+                        var runText = text.substring(Math.max(processedIndex, runStart), runEnd);
+                        if (runText) {
+                            lineContent.push(schema.text(runText, createMarks(formatRun)));
+                            processedIndex = runEnd;
+                        }
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (lineFormatRuns_1_1 && !lineFormatRuns_1_1.done && (_a = lineFormatRuns_1.return)) _a.call(lineFormatRuns_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            // Add any remaining unformatted text at the end of the line
+            if (processedIndex < lineEndIndex) {
+                var remainingText = text.substring(processedIndex, lineEndIndex);
+                if (remainingText) {
+                    lineContent.push(schema.text(remainingText));
+                }
+            }
+        }
+        // Create line node
+        lineNodes.push(schema.nodes.line.create(null, lineContent));
+        currentTextIndex += lineText.length;
+    };
+    for (var lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+        _loop_1(lineIndex);
+    }
+    // Create document
+    return schema.nodes.doc.create(null, lineNodes);
+};
+/**
+ * Applies a `TextFormat` patch to the editor's CURRENT SELECTION as marks —
+ * the per-run counterpart of the toolbar's cell-level `onChangeFormatting`.
+ * This is what makes the toolbar's bold/superscript/font-size controls format
+ * just the selected span while the cell editor is open, the way Cmd+B already
+ * does through the keymap.
+ *
+ * Semantics per key (only keys PRESENT on `format` are touched):
+ * - `bold`/`italic`/`underline`/`strikethrough`: TOGGLE against the
+ *   selection's own mark state (same rule as prosemirror-commands
+ *   `toggleMark`: any marked text in range → remove, else add) — the caller's
+ *   cell-level boolean is ignored because it describes the cell, not the span.
+ * - `baselineOffset`: if the selection already carries the target offset the
+ *   pair is cleared; otherwise the target replaces both (mutually exclusive).
+ * - `fontSize`/`fontFamily`/`color`: SET to the given value (clear on nullish).
+ *   Theme-object colors resolve through `resolveColor`.
+ *
+ * A collapsed selection applies the change to the stored marks, so it affects
+ * what is typed next — Google Sheets behavior.
+ *
+ * Returns `false` (and dispatches nothing) when `format` carries none of the
+ * run-representable keys, so the caller can fall back to cell-level formatting.
+ */
+export var applyTextFormatToSelection = function (state, dispatch, format, schema, resolveColor) {
+    var e_2, _a;
+    var _b;
+    var _c = state.selection, from = _c.from, to = _c.to, empty = _c.empty;
+    var cursorMarks = (_b = state.storedMarks) !== null && _b !== void 0 ? _b : state.selection.$from.marks();
+    var tr = state.tr;
+    var handled = false;
+    var hasMark = function (markType) {
+        return empty
+            ? markType.isInSet(cursorMarks) != null
+            : state.doc.rangeHasMark(from, to, markType);
+    };
+    var add = function (mark) {
+        tr = empty ? tr.addStoredMark(mark) : tr.addMark(from, to, mark);
+    };
+    var remove = function (markType) {
+        tr = empty ? tr.removeStoredMark(markType) : tr.removeMark(from, to, markType);
+    };
+    try {
+        for (var _d = __values(["bold", "italic", "underline", "strikethrough"]), _e = _d.next(); !_e.done; _e = _d.next()) {
+            var key = _e.value;
+            if (!(key in format))
+                continue;
+            handled = true;
+            var markType = schema.marks[key];
+            if (hasMark(markType)) {
+                remove(markType);
+            }
+            else {
+                add(markType.create());
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    if ("baselineOffset" in format) {
+        handled = true;
+        var target = format.baselineOffset;
+        var targetType = target ? schema.marks[target] : undefined;
+        var alreadyOn = targetType ? hasMark(targetType) : false;
+        remove(schema.marks.superscript);
+        remove(schema.marks.subscript);
+        if (targetType && !alreadyOn) {
+            add(targetType.create());
+        }
+    }
+    if ("fontSize" in format) {
+        handled = true;
+        remove(schema.marks.fontSize);
+        if (format.fontSize != null) {
+            add(schema.marks.fontSize.create({ size: format.fontSize }));
+        }
+    }
+    if ("fontFamily" in format) {
+        handled = true;
+        remove(schema.marks.fontFamily);
+        if (format.fontFamily) {
+            add(schema.marks.fontFamily.create({ family: format.fontFamily }));
+        }
+    }
+    if ("color" in format) {
+        handled = true;
+        remove(schema.marks.color);
+        var css = typeof format.color === "string"
+            ? format.color
+            : format.color
+                ? resolveColor === null || resolveColor === void 0 ? void 0 : resolveColor(format.color)
+                : undefined;
+        if (css) {
+            add(schema.marks.color.create({ color: css }));
+        }
+    }
+    if (!handled) {
+        return false;
+    }
+    dispatch === null || dispatch === void 0 ? void 0 : dispatch(tr);
+    return true;
+};
+/**
+ * Effective fontSize (pt) of the current selection, or `null` when the
+ * selection carries no fontSize mark. A collapsed selection reads the stored
+ * marks (what the next typed character would get); a range reads the marks of
+ * the first text node in the range, matching how the run is rendered.
+ */
+export var getSelectionFontSize = function (state) {
+    var _a, _b;
+    var _c = state.selection, from = _c.from, to = _c.to, empty = _c.empty;
+    var marks = null;
+    if (empty) {
+        marks = (_a = state.storedMarks) !== null && _a !== void 0 ? _a : state.selection.$from.marks();
+    }
+    else {
+        state.doc.nodesBetween(from, to, function (node) {
+            if (marks)
+                return false;
+            if (node.isText) {
+                marks = node.marks;
+                return false;
+            }
+            return true;
+        });
+    }
+    var mark = marks === null || marks === void 0 ? void 0 : marks.find(function (m) { return m.type.name === "fontSize"; });
+    var size = (_b = mark === null || mark === void 0 ? void 0 : mark.attrs) === null || _b === void 0 ? void 0 : _b.size;
+    return typeof size === "number" && Number.isFinite(size) ? size : null;
+};
+/**
+ * Get current cursor position
+ * @param state
+ * @returns
+ */
+export var getCursorPosition = function (state) {
+    try {
+        var selection = state.selection;
+        if (!selection || !selection.empty) {
+            return undefined;
+        }
+        // Bounds checking
+        var pos = selection.from;
+        if (pos < 0 || pos > state.doc.content.size) {
+            console.warn("Invalid cursor position: ".concat(pos, ", doc size: ").concat(state.doc.content.size));
+            return undefined;
+        }
+        return pos;
+    }
+    catch (error) {
+        console.warn("Error getting cursor position:", error);
+        return undefined;
+    }
+};
+/**
+ * Get currently focused token
+ * @param position
+ * @param tokens
+ * @returns
+ */
+export var getActiveToken = function (position, tokens) {
+    return tokens.find(function (token) { return token.endColumn >= position; });
+};
+export var enableCellSelection = function (position, cursorPos, tokens) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+    if (!Number.isFinite(cursorPos) || !tokens.length) {
+        return false;
+    }
+    var _q = __read(getSurroundingTokens(position, tokens), 3), prev = _q[0], active = _q[1], next = _q[2];
+    var isStringLike = function (token) {
+        return !!token &&
+            (token.tokenType.name === tokenVocabulary.String.name ||
+                token.tokenType.name === tokenVocabulary.UnterminatedStringStart.name ||
+                token.image === '"');
+    };
+    var isCoveringPosition = function (token) {
+        var _a, _b;
+        return isStringLike(token) &&
+            position >= ((_a = token === null || token === void 0 ? void 0 : token.startColumn) !== null && _a !== void 0 ? _a : position) &&
+            position <= ((_b = token === null || token === void 0 ? void 0 : token.endColumn) !== null && _b !== void 0 ? _b : position);
+    };
+    if (isStringLike(active) || isStringLike(next) || isCoveringPosition(prev)) {
+        return false;
+    }
+    var isEmptyFunctionCall = (prev === null || prev === void 0 ? void 0 : prev.tokenType.name) === tokenVocabulary.Function.name &&
+        (active === null || active === void 0 ? void 0 : active.tokenType.name) === tokenVocabulary.CloseParen.name &&
+        ((_a = prev.image) !== null && _a !== void 0 ? _a : "").endsWith("(") &&
+        ((_b = active.startColumn) !== null && _b !== void 0 ? _b : 0) === ((_c = prev.endColumn) !== null && _c !== void 0 ? _c : -1) + 1;
+    if (isEmptyFunctionCall) {
+        return false;
+    }
+    var isAfterCloseParen = (active === null || active === void 0 ? void 0 : active.tokenType.name) === tokenVocabulary.CloseParen.name &&
+        cursorPos === position + 1;
+    if (isAfterCloseParen) {
+        return false;
+    }
+    var prevAllowed = prev &&
+        CELL_SUGGESTION_PREFIX.includes(prev.tokenType.name) &&
+        position > ((_d = prev.endColumn) !== null && _d !== void 0 ? _d : -Infinity);
+    // The cursor must actually be inside (or at the trailing edge of) the
+    // active token for it to count as the prefix that enables cell
+    // selection. Without the `position >= startColumn` guard, a cursor
+    // positioned BEFORE the active token (e.g. caret at index 0 of `=$12`)
+    // would still treat the leading `=` as the prefix and flip the editor
+    // into cell-suggestion mode. Calculator columns are 1-indexed while
+    // `position` (offsetInLine) is 0-indexed, so cursor-just-before-token
+    // satisfies `position < startColumn`.
+    var activeAllowed = active &&
+        CELL_SUGGESTION_PREFIX.includes(active.tokenType.name) &&
+        position >= ((_e = active.startColumn) !== null && _e !== void 0 ? _e : Infinity) &&
+        position <= ((_f = active.endColumn) !== null && _f !== void 0 ? _f : position);
+    var prefixToken = prevAllowed ? prev : activeAllowed ? active : undefined;
+    if (!prefixToken) {
+        return false;
+    }
+    var isActiveReferenceStart = active &&
+        isReferenceToken(active) &&
+        position + 1 === ((_g = active.startColumn) !== null && _g !== void 0 ? _g : position + 1);
+    if (isActiveReferenceStart) {
+        return false;
+    }
+    var isNextReferenceStart = next &&
+        isReferenceToken(next) &&
+        position + 1 === ((_h = next.startColumn) !== null && _h !== void 0 ? _h : position + 1);
+    if (isNextReferenceStart) {
+        return false;
+    }
+    if (next && !CELL_SUGGESTION_SUFFIX.includes(next.tokenType.name)) {
+        return false;
+    }
+    var activeType = (_j = active === null || active === void 0 ? void 0 : active.tokenType) === null || _j === void 0 ? void 0 : _j.name;
+    var isInsideReference = isReferenceToken(active) &&
+        position >= ((_k = active === null || active === void 0 ? void 0 : active.startColumn) !== null && _k !== void 0 ? _k : position) &&
+        position <= ((_l = active === null || active === void 0 ? void 0 : active.endColumn) !== null && _l !== void 0 ? _l : position);
+    var isInsideFunctionName = false;
+    if (activeType === tokenVocabulary.Function.name && active) {
+        var start = (_m = active.startColumn) !== null && _m !== void 0 ? _m : position;
+        var nameEnd = (_o = active.endColumn) !== null && _o !== void 0 ? _o : position;
+        var image = (_p = active.image) !== null && _p !== void 0 ? _p : "";
+        if (image.endsWith("(") && image.length > 1) {
+            var nameLength = image.length - 1;
+            nameEnd = start + nameLength - 1;
+        }
+        isInsideFunctionName = position >= start && position <= nameEnd;
+    }
+    if (isInsideReference ||
+        isInsideFunctionName ||
+        activeType === tokenVocabulary.String.name ||
+        activeType === tokenVocabulary.UnterminatedStringStart.name ||
+        activeType === tokenVocabulary.Number.name ||
+        activeType === tokenVocabulary.Boolean.name) {
+        return false;
+    }
+    return true;
+};
+/**
+ * Get prev, current and next tokens using a position
+ * @param position
+ * @param tokens
+ * @returns
+ */
+export var getSurroundingTokens = function (position, tokens) {
+    var activeToken = getActiveToken(position, tokens);
+    return [
+        getPreviousToken(position, tokens),
+        activeToken,
+        getNextToken(position, tokens, activeToken),
+    ];
+};
+/**
+ * Get the previous token from the current position
+ * @param position
+ * @param tokens
+ * @returns
+ */
+export var getPreviousToken = function (position, tokens) {
+    var e_3, _a;
+    var previous;
+    try {
+        for (var tokens_1 = __values(tokens), tokens_1_1 = tokens_1.next(); !tokens_1_1.done; tokens_1_1 = tokens_1.next()) {
+            var token = tokens_1_1.value;
+            if (token.endColumn < position) {
+                previous = token;
+                continue;
+            }
+            if (token.startColumn <= position && token.endColumn >= position) {
+                return previous;
+            }
+            if (token.startColumn > position) {
+                break;
+            }
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (tokens_1_1 && !tokens_1_1.done && (_a = tokens_1.return)) _a.call(tokens_1);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    return previous;
+};
+/**
+ * Get next token from position
+ * @param position
+ * @param tokens
+ * @returns
+ */
+export var getNextToken = function (position, tokens, activeToken) {
+    return tokens.find(function (token) {
+        if (activeToken && token === activeToken) {
+            return false;
+        }
+        var start = token.startColumn && token.startColumn > 0
+            ? token.startColumn - 1
+            : token.startOffset;
+        return start !== undefined && start >= position;
+    });
+};
+/**
+ * Is current token a cell token
+ * @param token
+ * @returns
+ */
+export var isCellToken = function (token) {
+    return token.tokenType.name === tokenVocabulary.Cell.name || token.selection;
+};
+export var isTableColumnToken = function (token) {
+    return token.tokenType.name === tokenVocabulary.TableColumnName.name;
+};
+export var isTableNameToken = function (token) {
+    return token.tokenType.name === tokenVocabulary.TableName.name;
+};
+export var isNamedRangeToken = function (token) {
+    return token.tokenType.name === tokenVocabulary.Name.name;
+};
+export var isStringToken = function (token) {
+    return token.tokenType.name === tokenVocabulary.String.name;
+};
+export var isNumberToken = function (token) {
+    return token.tokenType.name === tokenVocabulary.Number.name;
+};
+var isReferenceToken = function (token) {
+    if (!token)
+        return false;
+    return (isCellToken(token) ||
+        isTableColumnToken(token) ||
+        isTableNameToken(token) ||
+        isNamedRangeToken(token) ||
+        token.tokenType.name === tokenVocabulary.Column.name);
+};
+/**
+ * Check if token is a cell reference with property (e.g., A1.title or A1.)
+ * @param token
+ * @returns
+ */
+export var getPropertyStartIndex = function (token) {
+    if (!(token === null || token === void 0 ? void 0 : token.image)) {
+        return -1;
+    }
+    if (token.tokenType.name === tokenVocabulary.Cell.name ||
+        token.tokenType.name === tokenVocabulary.Name.name) {
+        return token.image.indexOf(".");
+    }
+    if (token.tokenType.name === tokenVocabulary.TableColumnName.name ||
+        token.tokenType.name === tokenVocabulary.SpecialItem.name ||
+        token.tokenType.name === tokenVocabulary.TableName.name) {
+        var lastClosingBracket = token.image.lastIndexOf("]");
+        if (lastClosingBracket === -1) {
+            return -1;
+        }
+        return token.image.indexOf(".", lastClosingBracket + 1);
+    }
+    return -1;
+};
+export var hasPropertyReference = function (token) {
+    var index = getPropertyStartIndex(token);
+    return index !== -1;
+};
+/**
+ * Get current active function
+ * @param curToken
+ * @param tokens
+ */
+export var getActiveFunctionToken = function (curToken, tokens) {
+    if (!curToken)
+        return void 0;
+    var i = tokens.findIndex(function (token) { return token === curToken; });
+    var fn;
+    var skip = 0;
+    while (i > 0) {
+        var token = tokens[i];
+        if (token.tokenType.name === tokenVocabulary.CloseParen.name) {
+            skip++;
+        }
+        if (token.tokenType.name === tokenVocabulary.Function.name) {
+            if (skip > 0) {
+                skip--;
+            }
+            else {
+                fn = token;
+                break;
+            }
+        }
+        i--;
+    }
+    return fn;
+};
+/**
+ * get selection index from activetoken
+ * @param activeToken
+ * @returns
+ */
+export var getActiveSelectionIndex = function (activeToken) {
+    var _a;
+    return (activeToken === null || activeToken === void 0 ? void 0 : activeToken.structured) ||
+        (activeToken === null || activeToken === void 0 ? void 0 : activeToken.isNamedRange) ||
+        (activeToken === null || activeToken === void 0 ? void 0 : activeToken.selection)
+        ? (_a = activeToken.index) !== null && _a !== void 0 ? _a : -1
+        : -1;
+};
+/**
+ * Suggestion token
+ * @param position
+ * @param activeToken
+ * @param view
+ * @returns
+ */
+export var getActiveSuggestionToken = function (position, activeToken, view) {
+    var _a, _b;
+    // If the token is already a function, lets ignore
+    if (!activeToken ||
+        activeToken.tokenType.name === tokenVocabulary.Function.name) {
+        return undefined;
+    }
+    var propertyStart = hasPropertyReference(activeToken)
+        ? getPropertyStartIndex(activeToken)
+        : -1;
+    if (propertyStart !== -1 && (activeToken === null || activeToken === void 0 ? void 0 : activeToken.image) != null) {
+        var propertyImage = activeToken.image.slice(propertyStart + 1);
+        var propertyStartOffset = ((_a = activeToken.startOffset) !== null && _a !== void 0 ? _a : 0) + propertyStart + 1;
+        var propertyStartColumn = ((_b = activeToken.startColumn) !== null && _b !== void 0 ? _b : 0) + propertyStart + 1;
+        var suggestionToken = __assign(__assign({}, activeToken), { image: propertyImage, startOffset: propertyStartOffset, endOffset: propertyStartOffset + propertyImage.length, startColumn: propertyStartColumn, endColumn: propertyStartColumn + propertyImage.length });
+        suggestionToken.basePropertyToken = activeToken;
+        return suggestionToken;
+    }
+    // Named ranges.
+    // Resolved named ranges have `index` property. If its resolved,
+    // lets not show suggestions anymore
+    if (activeToken.tokenType.name === tokenVocabulary.Name.name &&
+        activeToken.index !== undefined) {
+        return undefined;
+    }
+    // For tables
+    if (activeToken.tokenType.name === tokenVocabulary.TableName.name ||
+        activeToken.tokenType.name === tokenVocabulary.TableColumnName.name) {
+        try {
+            var result = getWordAtPosition(view.state, position);
+            if ((result === null || result === void 0 ? void 0 : result.end) === position) {
+                return undefined;
+            }
+            // Use the token's image directly for cleanup
+            // This avoids complex ProseMirror position calculations
+            var tokenImage = activeToken.image || "";
+            var tableNameLength = activeToken.tableName
+                ? activeToken.tableName.length + 1
+                : 0;
+            if (!tokenImage) {
+                return undefined;
+            }
+            var cleanupImage = cleanupColumnName(tokenImage);
+            var change = tokenImage.length - cleanupImage.length;
+            return __assign(__assign({}, activeToken), { startOffset: activeToken.startOffset + tableNameLength + change, image: cleanupImage });
+        }
+        catch (error) {
+            console.warn("Error processing table suggestion token:", error);
+            return activeToken;
+        }
+    }
+    return activeToken.tokenType.name === tokenVocabulary.TableColumnName.name ||
+        activeToken.tokenType.name === tokenVocabulary.Column.name ||
+        activeToken.tokenType.name === tokenVocabulary.Name.name ||
+        activeToken.tokenType.name === tokenVocabulary.Function.name ||
+        activeToken.tokenType.name === tokenVocabulary.UnterminatedStringStart.name
+        ? activeToken
+        : undefined;
+};
+export var resolveCellPropertyToken = function (activeToken, tokens) {
+    if (hasPropertyReference(activeToken)) {
+        return activeToken;
+    }
+    if (!activeToken) {
+        return undefined;
+    }
+    var index = tokens.findIndex(function (token) { return token === activeToken; });
+    if (index === -1) {
+        return undefined;
+    }
+    for (var i = index - 1; i >= 0; i--) {
+        var token = tokens[i];
+        if (token.tokenType.name === tokenVocabulary.Cell.name ||
+            token.tokenType.name === tokenVocabulary.TableColumnName.name ||
+            token.tokenType.name === tokenVocabulary.TableName.name) {
+            if (hasPropertyReference(token)) {
+                return token;
+            }
+        }
+    }
+    return undefined;
+};
+/**
+ * Get active table token
+ * @param position
+ * @param activeToken
+ * @param tokens
+ * @param view
+ * @param isEdge
+ * @returns
+ */
+export var getActiveTableToken = function (position, activeToken, tokens, view, isEdge) {
+    if (!activeToken)
+        return undefined;
+    var table = void 0;
+    // Get character before cursor - use tokenized content for consistency
+    var state = view.state;
+    var fullContent = state.doc.textContent;
+    // Map position back to the original content
+    // For now, use simple approach since position is within tokenized text
+    var previousCharacter = position > 0 && fullContent.length > position - 1
+        ? fullContent.charAt(position - 1)
+        : "";
+    var isFocusOutsideToken = position > activeToken.endColumn;
+    // Table1[Column]<--
+    if (isEdge && previousCharacter === "]") {
+        return undefined;
+    }
+    // Table[Column]   <--- token with spaces
+    if (activeToken.tokenType.name === tokenVocabulary.TableName.name &&
+        !isFocusOutsideToken) {
+        return activeToken;
+    }
+    // [  <--- Square with space
+    if (activeToken.tokenType.name === tokenVocabulary.OpenSquareParen.name &&
+        !isFocusOutsideToken) {
+        table = activeToken;
+    }
+    var i = tokens.findIndex(function (token) { return token === activeToken; });
+    while (i > 0) {
+        var token = tokens[i];
+        // User starts with [ or [Column
+        if (token.tokenType.name === tokenVocabulary.OpenSquareParen.name ||
+            token.tokenType.name === tokenVocabulary.TableColumnName.name) {
+            var previousToken = tokens[i - 1];
+            if (!previousToken ||
+                CELL_SUGGESTION_PREFIX.indexOf(previousToken.tokenType.name) !== -1) {
+                return token;
+            }
+        }
+        // Find tableName by going back from the
+        // current location
+        if ([
+            tokenVocabulary.Name.name,
+            tokenVocabulary.OpenSquareParen.name,
+            tokenVocabulary.CloseSquareParen.name,
+            tokenVocabulary.Colon.name,
+            tokenVocabulary.Column.name,
+        ].indexOf(token.tokenType.name) !== -1) {
+            i--;
+            continue;
+        }
+        // Exclude certain tokens that should not be inside
+        // a structured reference
+        if (CELL_SUGGESTION_SUFFIX.indexOf(token.tokenType.name) !== -1 ||
+            CELL_SUGGESTION_PREFIX.indexOf(token.tokenType.name) !== -1) {
+            return undefined;
+        }
+        // Found table
+        if (token.tokenType.name === tokenVocabulary.TableName.name) {
+            table = token;
+            break;
+        }
+        i--;
+    }
+    return table;
+};
+/**
+ * Get current parameter index that use is focused on
+ * @param curToken
+ * @param functionToken
+ * @param tokens
+ */
+export var getParameterIndex = function (curToken, functionToken, tokens) {
+    var startIndex = tokens.findIndex(function (token) { return token === curToken; });
+    var endIndex = tokens.findIndex(function (token) { return token === functionToken; });
+    var count = 0;
+    /* Skips nested functions */
+    var skip = 0;
+    // Fix for =SUMX2MY2({1, 2, 3}, {4, 5, 6}), Store indices we should skip
+    var replace = false;
+    var skipCommaIndices = [];
+    for (var i = tokens.length - 1; i >= 0; i--) {
+        var token = tokens[i];
+        if (token.image === "}") {
+            replace = true;
+        }
+        else if (token.image === "{") {
+            replace = false;
+        }
+        else {
+            if (replace) {
+                skipCommaIndices.push(i);
+            }
+        }
+    }
+    while (startIndex > endIndex) {
+        var token = tokens[startIndex];
+        if (token.image === ")") {
+            skip++;
+        }
+        else if (token.tokenType.name === "Comma" &&
+            skip === 0 &&
+            !(skipCommaIndices.indexOf(startIndex) !== -1)) {
+            count++;
+        }
+        if (token.tokenType.name === "Function") {
+            if (skip > 0)
+                skip--;
+        }
+        startIndex--;
+    }
+    return count;
+};
+export var getFunctionParameters = function (input, functionToken) {
+    var _a;
+    if (!functionToken) {
+        return { parameters: [], ranges: [] };
+    }
+    var searchStart = (_a = functionToken.startColumn) !== null && _a !== void 0 ? _a : 0;
+    var openIndex = input.indexOf("(", searchStart);
+    if (openIndex === -1) {
+        return { parameters: [], ranges: [] };
+    }
+    var depth = 0;
+    var closeIndex = -1;
+    for (var i = openIndex; i < input.length; i++) {
+        var ch = input[i];
+        if (ch === "(")
+            depth++;
+        else if (ch === ")") {
+            depth--;
+            if (depth === 0) {
+                closeIndex = i;
+                break;
+            }
+        }
+    }
+    // If user hasn't typed the closing paren yet, use the end of the string
+    if (closeIndex === -1) {
+        closeIndex = input.length;
+    }
+    if (closeIndex <= openIndex) {
+        return { parameters: [], ranges: [] };
+    }
+    var argsSlice = input.slice(openIndex + 1, closeIndex);
+    var parameters = [];
+    var ranges = [];
+    var start = 0;
+    var brace = 0;
+    var bracket = 0;
+    var paren = 0;
+    var inSingle = false;
+    var inDouble = false;
+    var pushParam = function (endIndex) {
+        var raw = argsSlice.slice(start, endIndex);
+        var leading = raw.length - raw.trimStart().length;
+        var trailing = raw.length - raw.trimEnd().length;
+        var absoluteStart = openIndex + 1 + start + leading;
+        var absoluteEnd = openIndex + 1 + endIndex - trailing;
+        parameters.push(raw.trim());
+        ranges.push({ start: absoluteStart, end: absoluteEnd });
+    };
+    for (var i = 0; i <= argsSlice.length; i++) {
+        var ch = argsSlice[i];
+        if (i === argsSlice.length ||
+            (ch === "," &&
+                paren === 0 &&
+                brace === 0 &&
+                bracket === 0 &&
+                !inSingle &&
+                !inDouble)) {
+            pushParam(i);
+            start = i + 1;
+            continue;
+        }
+        if (ch === "'" && !inDouble) {
+            inSingle = !inSingle;
+            continue;
+        }
+        if (ch === '"' && !inSingle) {
+            inDouble = !inDouble;
+            continue;
+        }
+        if (inSingle || inDouble)
+            continue;
+        if (ch === "(")
+            paren++;
+        else if (ch === ")")
+            paren--;
+        else if (ch === "{")
+            brace++;
+        else if (ch === "}")
+            brace--;
+        else if (ch === "[")
+            bracket++;
+        else if (ch === "]")
+            bracket--;
+    }
+    return { parameters: parameters, ranges: ranges };
+};
+/**
+ * Get content and offset for tokenization, handling both single and multi-line scenarios
+ * @param state ProseMirror editor state
+ * @param cursorPos Current cursor position
+ * @returns Object with line content and offset within that content
+ */
+export var getTokenizationContent = function (state, cursorPos) {
+    try {
+        // Validate cursor position
+        if (cursorPos < 0 || cursorPos > state.doc.content.size) {
+            console.warn("Invalid cursor position: ".concat(cursorPos, ", doc size: ").concat(state.doc.content.size));
+            return {
+                line: state.doc.textContent || "",
+                offsetInLine: 0,
+            };
+        }
+        var $pos = state.doc.resolve(cursorPos);
+        // Strategy 1: For typical spreadsheet formulas, tokenize entire content
+        // This works best when content is a single formula that may span lines
+        var fullContent = state.doc.textContent;
+        if (fullContent.startsWith("=") || fullContent.length <= 1000) {
+            // This looks like a formula or is short enough to tokenize entirely
+            // Calculate position in the full text content
+            // Need to account for ProseMirror's document structure vs plain text
+            var textPosition_1 = 0;
+            var found_1 = false;
+            state.doc.descendants(function (node, pos) {
+                var _a;
+                if (found_1)
+                    return false;
+                if (node.isText) {
+                    if (pos <= cursorPos && cursorPos <= pos + node.nodeSize) {
+                        // Cursor is within this text node
+                        textPosition_1 += cursorPos - pos;
+                        found_1 = true;
+                        return false;
+                    }
+                    else if (pos + node.nodeSize < cursorPos) {
+                        // This text node is before cursor position
+                        textPosition_1 += ((_a = node.text) === null || _a === void 0 ? void 0 : _a.length) || 0;
+                    }
+                }
+                return !found_1;
+            });
+            return {
+                line: fullContent,
+                offsetInLine: Math.max(0, textPosition_1),
+            };
+        }
+        // Strategy 2: For non-formula content, use current line approach
+        // This works better for multi-line text that isn't a single formula
+        var parent_1 = $pos.parent;
+        if (parent_1 && parent_1.isTextblock) {
+            var lineStart = $pos.start($pos.depth);
+            var offsetInLine = Math.max(0, cursorPos - lineStart);
+            return {
+                line: parent_1.textContent || "",
+                offsetInLine: offsetInLine,
+            };
+        }
+        // Strategy 3: Fallback to full content with simple position mapping
+        return {
+            line: fullContent,
+            offsetInLine: Math.max(0, Math.min(cursorPos, fullContent.length)),
+        };
+    }
+    catch (error) {
+        console.warn("Error getting tokenization content:", error);
+        // Safe fallback
+        var safeContent = state.doc.textContent || "";
+        return {
+            line: safeContent,
+            offsetInLine: Math.max(0, Math.min(cursorPos, safeContent.length)),
+        };
+    }
+};
+/**
+ * Cleanup function token to remove parentheses
+ * @param text
+ */
+export var cleanFunctionToken = function (text) {
+    return text.replace(new RegExp(/\(|\)/, "gi"), "");
+};
+// Alternative approach using ProseMirror's built-in word detection:
+function getWordAtPosition(editorState, pos) {
+    var doc = editorState.doc;
+    var $pos = doc.resolve(pos);
+    // Use ProseMirror's word pattern matching
+    var wordRE = /\w+/g;
+    var textNode = $pos.parent;
+    var textContent = textNode.textContent;
+    var localPos = $pos.parentOffset;
+    var match;
+    var wordStart = null;
+    var wordEnd = null;
+    // Find all word matches and determine which one contains our position
+    while ((match = wordRE.exec(textContent)) !== null) {
+        var matchStart = match.index;
+        var matchEnd = match.index + match[0].length;
+        if (localPos >= matchStart && localPos <= matchEnd) {
+            wordStart = $pos.start() + matchStart;
+            wordEnd = $pos.start() + matchEnd;
+            break;
+        }
+    }
+    if (wordStart === null || wordEnd === null) {
+        return undefined;
+    }
+    var wordText = doc.textBetween(wordStart, wordEnd, " ");
+    return {
+        start: wordStart,
+        end: wordEnd,
+        text: wordText,
+    };
+}