@mcp-z/mcp-sheets 1.0.7 → 1.1.0

package/dist/cjs/spreadsheet/markdown-runs.js

@@ -0,0 +1,441 @@
+/**
+ * Inline Markdown → Google Sheets textFormatRuns
+ *
+ * The Sheets values API can only write plain text or formulas — it cannot set
+ * `textFormatRuns`, so plain-text URLs are never linkified and `=HYPERLINK()`
+ * only ever produces one link per cell. Multiple distinct clickable links (or
+ * any other rich text) inside a single cell require `textFormatRuns`, which is
+ * only settable via `spreadsheets.batchUpdate` → `updateCells`. This module
+ * parses a small, deliberately restricted subset of inline markdown into plain
+ * text plus the `textFormatRuns` needed to render it.
+ *
+ * Supported inline constructs:
+ *   - `[label](url)` and bare `http(s)://` URLs -> `format.link.uri`
+ *   - `**bold**` / `__bold__`                    -> `format.bold`
+ *   - `*italic*` / `_italic_`                     -> `format.italic`
+ *   - `~~strikethrough~~`                         -> `format.strikethrough`
+ *   - `\X` escapes any of the delimiter characters above to a literal `X`
+ *
+ * Everything else (headers, lists, tables, backticks, unmatched delimiters,
+ * ...) is passed through as literal text. This module never throws on
+ * malformed markdown — graceful degradation to literal text is the contract.
+ *
+ * A note on indices: Google Sheets `textFormatRuns[].startIndex` is defined in
+ * UTF-16 code units. JavaScript string indexing (`str[i]`, `str.length`,
+ * `str.slice()`) already operates on UTF-16 code units, so plain indexing is
+ * exactly correct here. Do NOT iterate with `[...str]` or any other code-point
+ * aware iteration — that would silently misalign indices for any text
+ * containing astral characters (e.g. emoji), which are represented as
+ * surrogate pairs (2 code units).
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get buildTextFormatRuns () {
+        return buildTextFormatRuns;
+    },
+    get parseInlineMarkdown () {
+        return parseInlineMarkdown;
+    }
+});
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+// Default styling applied to link runs so they read as clickable links (Sheets'
+// own link color), matching what Sheets applies automatically for =HYPERLINK().
+var LINK_BLUE = {
+    red: 0.06666667,
+    green: 0.33333334,
+    blue: 0.8
+};
+// Matched against a suffix of the input (anchored with ^), so `.exec` always tests position 0.
+var MD_LINK = /^\[([^\]]*?)\]\(\s*(<[^>]+>|[^)\s]+)(?:\s+"[^"]*")?\s*\)/;
+var BARE_URL = /^https?:\/\/[^\s<>"'()[\]]+/;
+// Characters that may be backslash-escaped to a literal (the delimiter chars this
+// parser recognizes as syntax, plus the backslash itself).
+var ESCAPABLE = new Set([
+    '\\',
+    '*',
+    '_',
+    '~',
+    '[',
+    ']',
+    '(',
+    ')'
+]);
+/** Trailing punctuation that is almost certainly prose, not part of a bare URL. */ function trimTrailingPunctuation(url) {
+    return url.replace(/[.,;:!?]+$/, '');
+}
+var isWhitespaceOrEdge = function isWhitespaceOrEdge(ch) {
+    return ch === undefined || /\s/.test(ch);
+};
+var isWordChar = function isWordChar(ch) {
+    return ch !== undefined && /[A-Za-z0-9]/.test(ch);
+};
+/**
+ * Simplified CommonMark flanking rules — without these, whitespace-flanked
+ * delimiters pair up ("3 * 4 * 5" would italicize " 4 ") and intraword
+ * underscores become emphasis ("user_id and account_id" would italicize
+ * "id and account" and delete the underscores). Both are silent data
+ * corruption for ordinary spreadsheet content, so:
+ *   - a delimiter can OPEN emphasis only if not followed by whitespace/end
+ *   - a delimiter can CLOSE emphasis only if not preceded by whitespace/start
+ *   - `_`/`__` additionally can never open after, or close before, a word
+ *     character (intraword underscores are literal, per CommonMark)
+ * Intraword `*` is intentionally still allowed (`a*b*c` emphasizes `b`),
+ * matching CommonMark.
+ */ function delimiterFlanking(_kind, raw, prev, next) {
+    var underscore = raw.startsWith('_');
+    var canOpen = !isWhitespaceOrEdge(next) && !(underscore && isWordChar(prev));
+    var canClose = !isWhitespaceOrEdge(prev) && !(underscore && isWordChar(next));
+    return {
+        canOpen: canOpen,
+        canClose: canClose
+    };
+}
+/**
+ * Scans the raw markdown left-to-right into a flat token stream: literal text
+ * runs, resolved links (markdown-link or bare-URL), and emphasis delimiters.
+ * Emphasis delimiters are emitted as opaque tokens here — whether a given
+ * delimiter is an opener, a closer, or unmatched (and thus literal) is decided
+ * in a second pass, since that requires seeing the whole stream.
+ */ function tokenize(markdown) {
+    var tokens = [];
+    var buffer = '';
+    var flush = function flush() {
+        if (buffer) {
+            tokens.push({
+                type: 'text',
+                value: buffer
+            });
+            buffer = '';
+        }
+    };
+    var i = 0;
+    while(i < markdown.length){
+        var ch = markdown[i];
+        var next = markdown[i + 1];
+        // Backslash escapes: \* \_ \~ \[ \] \( \) \\  -> literal char, never treated as syntax.
+        if (ch === '\\' && next !== undefined && ESCAPABLE.has(next)) {
+            buffer += next;
+            i += 2;
+            continue;
+        }
+        // Markdown links: [label](url) — checked before bare URLs so the label wins.
+        var linkMatch = MD_LINK.exec(markdown.slice(i));
+        if (linkMatch) {
+            var _linkMatch_, _linkMatch_1;
+            flush();
+            var rawLabel = ((_linkMatch_ = linkMatch[1]) !== null && _linkMatch_ !== void 0 ? _linkMatch_ : '').trim();
+            var uri = ((_linkMatch_1 = linkMatch[2]) !== null && _linkMatch_1 !== void 0 ? _linkMatch_1 : '').replace(/^<|>$/g, '');
+            tokens.push({
+                type: 'link',
+                label: rawLabel.length > 0 ? rawLabel : uri,
+                uri: uri
+            });
+            i += linkMatch[0].length;
+            continue;
+        }
+        // Bare http(s) URLs — the URL itself becomes the label.
+        if (ch === 'h') {
+            var bareMatch = BARE_URL.exec(markdown.slice(i));
+            if (bareMatch) {
+                flush();
+                var raw = bareMatch[0];
+                var uri1 = trimTrailingPunctuation(raw);
+                tokens.push({
+                    type: 'link',
+                    label: uri1,
+                    uri: uri1
+                });
+                // Trailing punctuation trimmed off the URL is not part of the link — keep it as literal text.
+                if (uri1.length < raw.length) buffer += raw.slice(uri1.length);
+                i += raw.length;
+                continue;
+            }
+        }
+        // Emphasis delimiters — longest first: ** and __ (bold) and ~~ (strikethrough) before * and _ (italic).
+        // The delimiter's width is fixed BEFORE the flanking check: a ** that fails
+        // flanking is two literal asterisks, never reinterpreted as two * delimiters.
+        var two = markdown.slice(i, i + 2);
+        var kind = two === '**' || two === '__' ? 'bold' : two === '~~' ? 'strikethrough' : ch === '*' || ch === '_' ? 'italic' : undefined;
+        if (kind !== undefined) {
+            var raw1 = kind === 'italic' ? ch : two;
+            var _delimiterFlanking = delimiterFlanking(kind, raw1, markdown[i - 1], markdown[i + raw1.length]), canOpen = _delimiterFlanking.canOpen, canClose = _delimiterFlanking.canClose;
+            if (canOpen || canClose) {
+                flush();
+                tokens.push({
+                    type: 'delim',
+                    kind: kind,
+                    raw: raw1,
+                    canOpen: canOpen,
+                    canClose: canClose
+                });
+            } else {
+                // Fails flanking on both sides — literal text (e.g. " * " or intraword "_").
+                buffer += raw1;
+            }
+            i += raw1.length;
+            continue;
+        }
+        buffer += ch;
+        i += 1;
+    }
+    flush();
+    return tokens;
+}
+// ---------------------------------------------------------------------------
+// Delimiter matching (unmatched delimiters degrade to literal text)
+// ---------------------------------------------------------------------------
+/** Matches emphasis delimiter tokens by kind using a simple open/close stack (assumes well-nested markdown). */ function matchDelimiters(tokens) {
+    var stack = [];
+    var openerToCloser = new Map();
+    tokens.forEach(function(token, index) {
+        if (token.type !== 'delim') return;
+        var top = stack[stack.length - 1];
+        if (token.canClose && top && top.kind === token.kind) {
+            stack.pop();
+            openerToCloser.set(top.tokenIndex, index);
+        } else if (token.canOpen) {
+            stack.push({
+                kind: token.kind,
+                tokenIndex: index
+            });
+        }
+    // Can neither close the current context nor open — stays unmatched (literal).
+    });
+    // Anything left on the stack never closed — leave unmatched (rendered literally by the caller).
+    return openerToCloser;
+}
+var FORMAT_FOR_KIND = {
+    bold: {
+        bold: true
+    },
+    italic: {
+        italic: true
+    },
+    strikethrough: {
+        strikethrough: true
+    }
+};
+/** Walks the token stream, resolving matched delimiter pairs into spans and unmatched ones into literal text. */ function buildTextAndSpans(tokens) {
+    var openerToCloser = matchDelimiters(tokens);
+    var closerToOpener = new Map();
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = openerToCloser[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _step_value = _sliced_to_array(_step.value, 2), opener = _step_value[0], closer = _step_value[1];
+            closerToOpener.set(closer, opener);
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    var text = '';
+    var spans = [];
+    var openerStart = new Map(); // opener token index -> plain-text start offset
+    tokens.forEach(function(token, index) {
+        if (token.type === 'text') {
+            text += token.value;
+            return;
+        }
+        if (token.type === 'link') {
+            var start = text.length;
+            text += token.label;
+            spans.push({
+                start: start,
+                end: text.length,
+                format: {
+                    link: {
+                        uri: token.uri
+                    }
+                }
+            });
+            return;
+        }
+        // Emphasis delimiter token.
+        if (openerToCloser.has(index)) {
+            // Matched opener — record where its span begins; the delimiter itself is consumed (not emitted).
+            openerStart.set(index, text.length);
+            return;
+        }
+        var openerIndex = closerToOpener.get(index);
+        if (openerIndex !== undefined) {
+            // Matched closer — emit the span from the recorded opener position to here.
+            var start1 = openerStart.get(openerIndex);
+            if (start1 === undefined) {
+                throw new Error('markdown-runs: internal error — emphasis opener position was not recorded');
+            }
+            spans.push({
+                start: start1,
+                end: text.length,
+                format: FORMAT_FOR_KIND[token.kind]
+            });
+            return;
+        }
+        // Unmatched delimiter — no syntactic partner, so it degrades to its literal characters.
+        text += token.raw;
+    });
+    return {
+        text: text,
+        spans: spans
+    };
+}
+function parseInlineMarkdown(markdown) {
+    var tokens = tokenize(markdown);
+    var _buildTextAndSpans = buildTextAndSpans(tokens), text = _buildTextAndSpans.text, spans = _buildTextAndSpans.spans;
+    var linkCount = spans.filter(function(span) {
+        return span.format.link !== undefined;
+    }).length;
+    return {
+        text: text,
+        spans: spans,
+        linkCount: linkCount
+    };
+}
+function buildTextFormatRuns(parsed) {
+    var styleLinks = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
+    var _runs_;
+    var text = parsed.text, spans = parsed.spans;
+    if (text.length === 0) return [];
+    var boundaries = new Set();
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = spans[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var span = _step.value;
+            boundaries.add(span.start);
+            if (span.end < text.length) boundaries.add(span.end);
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    var sortedBoundaries = _to_consumable_array(boundaries).sort(function(a, b) {
+        return a - b;
+    });
+    var runs = sortedBoundaries.map(function(startIndex) {
+        var format = {};
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = spans[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var span = _step.value;
+                if (span.start <= startIndex && startIndex < span.end) {
+                    Object.assign(format, span.format);
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        if (styleLinks && format.link) {
+            format.underline = true;
+            format.foregroundColorStyle = {
+                rgbColor: LINK_BLUE
+            };
+        }
+        return {
+            startIndex: startIndex,
+            format: format
+        };
+    });
+    if (runs.length === 0 || ((_runs_ = runs[0]) === null || _runs_ === void 0 ? void 0 : _runs_.startIndex) !== 0) {
+        runs.unshift({
+            startIndex: 0,
+            format: {}
+        });
+    }
+    return runs;
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/spreadsheet/markdown-runs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/mcp-z/mcp-sheets/src/spreadsheet/markdown-runs.ts"],"sourcesContent":["/**\n * Inline Markdown → Google Sheets textFormatRuns\n *\n * The Sheets values API can only write plain text or formulas — it cannot set\n * `textFormatRuns`, so plain-text URLs are never linkified and `=HYPERLINK()`\n * only ever produces one link per cell. Multiple distinct clickable links (or\n * any other rich text) inside a single cell require `textFormatRuns`, which is\n * only settable via `spreadsheets.batchUpdate` → `updateCells`. This module\n * parses a small, deliberately restricted subset of inline markdown into plain\n * text plus the `textFormatRuns` needed to render it.\n *\n * Supported inline constructs:\n *   - `[label](url)` and bare `http(s)://` URLs -> `format.link.uri`\n *   - `**bold**` / `__bold__`                    -> `format.bold`\n *   - `*italic*` / `_italic_`                     -> `format.italic`\n *   - `~~strikethrough~~`                         -> `format.strikethrough`\n *   - `\\X` escapes any of the delimiter characters above to a literal `X`\n *\n * Everything else (headers, lists, tables, backticks, unmatched delimiters,\n * ...) is passed through as literal text. This module never throws on\n * malformed markdown — graceful degradation to literal text is the contract.\n *\n * A note on indices: Google Sheets `textFormatRuns[].startIndex` is defined in\n * UTF-16 code units. JavaScript string indexing (`str[i]`, `str.length`,\n * `str.slice()`) already operates on UTF-16 code units, so plain indexing is\n * exactly correct here. Do NOT iterate with `[...str]` or any other code-point\n * aware iteration — that would silently misalign indices for any text\n * containing astral characters (e.g. emoji), which are represented as\n * surrogate pairs (2 code units).\n */\n\nimport type { sheets_v4 } from 'googleapis';\n\n// Default styling applied to link runs so they read as clickable links (Sheets'\n// own link color), matching what Sheets applies automatically for =HYPERLINK().\nconst LINK_BLUE: sheets_v4.Schema$Color = { red: 0.06666667, green: 0.33333334, blue: 0.8 };\n\n// ---------------------------------------------------------------------------\n// Public types\n// ---------------------------------------------------------------------------\n\n/** A formatting span over `text`, in UTF-16 code unit coordinates (half-open: [start, end)). */\nexport interface MarkdownSpan {\n  start: number;\n  end: number;\n  format: sheets_v4.Schema$TextFormat;\n}\n\nexport interface ParsedMarkdown {\n  /** Plain text with all markdown syntax stripped (or literalized). */\n  text: string;\n  /** Formatting spans over `text`. May overlap/nest (e.g. a bold span wrapping a link span). */\n  spans: MarkdownSpan[];\n  /** Number of link spans found (spans whose format has `link` set). */\n  linkCount: number;\n}\n\n// ---------------------------------------------------------------------------\n// Tokenizer\n// ---------------------------------------------------------------------------\n\ntype EmphasisKind = 'bold' | 'italic' | 'strikethrough';\n\ntype Token = { type: 'text'; value: string } | { type: 'link'; label: string; uri: string } | { type: 'delim'; kind: EmphasisKind; raw: string; canOpen: boolean; canClose: boolean };\n\n// Matched against a suffix of the input (anchored with ^), so `.exec` always tests position 0.\nconst MD_LINK = /^\\[([^\\]]*?)\\]\\(\\s*(<[^>]+>|[^)\\s]+)(?:\\s+\"[^\"]*\")?\\s*\\)/;\nconst BARE_URL = /^https?:\\/\\/[^\\s<>\"'()[\\]]+/;\n\n// Characters that may be backslash-escaped to a literal (the delimiter chars this\n// parser recognizes as syntax, plus the backslash itself).\nconst ESCAPABLE = new Set(['\\\\', '*', '_', '~', '[', ']', '(', ')']);\n\n/** Trailing punctuation that is almost certainly prose, not part of a bare URL. */\nfunction trimTrailingPunctuation(url: string): string {\n  return url.replace(/[.,;:!?]+$/, '');\n}\n\nconst isWhitespaceOrEdge = (ch: string | undefined): boolean => ch === undefined || /\\s/.test(ch);\nconst isWordChar = (ch: string | undefined): boolean => ch !== undefined && /[A-Za-z0-9]/.test(ch);\n\n/**\n * Simplified CommonMark flanking rules — without these, whitespace-flanked\n * delimiters pair up (\"3 * 4 * 5\" would italicize \" 4 \") and intraword\n * underscores become emphasis (\"user_id and account_id\" would italicize\n * \"id and account\" and delete the underscores). Both are silent data\n * corruption for ordinary spreadsheet content, so:\n *   - a delimiter can OPEN emphasis only if not followed by whitespace/end\n *   - a delimiter can CLOSE emphasis only if not preceded by whitespace/start\n *   - `_`/`__` additionally can never open after, or close before, a word\n *     character (intraword underscores are literal, per CommonMark)\n * Intraword `*` is intentionally still allowed (`a*b*c` emphasizes `b`),\n * matching CommonMark.\n */\nfunction delimiterFlanking(_kind: EmphasisKind, raw: string, prev: string | undefined, next: string | undefined): { canOpen: boolean; canClose: boolean } {\n  const underscore = raw.startsWith('_');\n  const canOpen = !isWhitespaceOrEdge(next) && !(underscore && isWordChar(prev));\n  const canClose = !isWhitespaceOrEdge(prev) && !(underscore && isWordChar(next));\n  return { canOpen, canClose };\n}\n\n/**\n * Scans the raw markdown left-to-right into a flat token stream: literal text\n * runs, resolved links (markdown-link or bare-URL), and emphasis delimiters.\n * Emphasis delimiters are emitted as opaque tokens here — whether a given\n * delimiter is an opener, a closer, or unmatched (and thus literal) is decided\n * in a second pass, since that requires seeing the whole stream.\n */\nfunction tokenize(markdown: string): Token[] {\n  const tokens: Token[] = [];\n  let buffer = '';\n  const flush = () => {\n    if (buffer) {\n      tokens.push({ type: 'text', value: buffer });\n      buffer = '';\n    }\n  };\n\n  let i = 0;\n  while (i < markdown.length) {\n    const ch = markdown[i] as string;\n    const next = markdown[i + 1];\n\n    // Backslash escapes: \\* \\_ \\~ \\[ \\] \\( \\) \\\\  -> literal char, never treated as syntax.\n    if (ch === '\\\\' && next !== undefined && ESCAPABLE.has(next)) {\n      buffer += next;\n      i += 2;\n      continue;\n    }\n\n    // Markdown links: [label](url) — checked before bare URLs so the label wins.\n    const linkMatch = MD_LINK.exec(markdown.slice(i));\n    if (linkMatch) {\n      flush();\n      const rawLabel = (linkMatch[1] ?? '').trim();\n      const uri = (linkMatch[2] ?? '').replace(/^<|>$/g, '');\n      tokens.push({ type: 'link', label: rawLabel.length > 0 ? rawLabel : uri, uri });\n      i += linkMatch[0].length;\n      continue;\n    }\n\n    // Bare http(s) URLs — the URL itself becomes the label.\n    if (ch === 'h') {\n      const bareMatch = BARE_URL.exec(markdown.slice(i));\n      if (bareMatch) {\n        flush();\n        const raw = bareMatch[0];\n        const uri = trimTrailingPunctuation(raw);\n        tokens.push({ type: 'link', label: uri, uri });\n        // Trailing punctuation trimmed off the URL is not part of the link — keep it as literal text.\n        if (uri.length < raw.length) buffer += raw.slice(uri.length);\n        i += raw.length;\n        continue;\n      }\n    }\n\n    // Emphasis delimiters — longest first: ** and __ (bold) and ~~ (strikethrough) before * and _ (italic).\n    // The delimiter's width is fixed BEFORE the flanking check: a ** that fails\n    // flanking is two literal asterisks, never reinterpreted as two * delimiters.\n    const two = markdown.slice(i, i + 2);\n    const kind: EmphasisKind | undefined = two === '**' || two === '__' ? 'bold' : two === '~~' ? 'strikethrough' : ch === '*' || ch === '_' ? 'italic' : undefined;\n    if (kind !== undefined) {\n      const raw = kind === 'italic' ? ch : two;\n      const { canOpen, canClose } = delimiterFlanking(kind, raw, markdown[i - 1], markdown[i + raw.length]);\n      if (canOpen || canClose) {\n        flush();\n        tokens.push({ type: 'delim', kind, raw, canOpen, canClose });\n      } else {\n        // Fails flanking on both sides — literal text (e.g. \" * \" or intraword \"_\").\n        buffer += raw;\n      }\n      i += raw.length;\n      continue;\n    }\n\n    buffer += ch;\n    i += 1;\n  }\n  flush();\n  return tokens;\n}\n\n// ---------------------------------------------------------------------------\n// Delimiter matching (unmatched delimiters degrade to literal text)\n// ---------------------------------------------------------------------------\n\n/** Matches emphasis delimiter tokens by kind using a simple open/close stack (assumes well-nested markdown). */\nfunction matchDelimiters(tokens: Token[]): Map<number, number> {\n  const stack: { kind: EmphasisKind; tokenIndex: number }[] = [];\n  const openerToCloser = new Map<number, number>();\n\n  tokens.forEach((token, index) => {\n    if (token.type !== 'delim') return;\n    const top = stack[stack.length - 1];\n    if (token.canClose && top && top.kind === token.kind) {\n      stack.pop();\n      openerToCloser.set(top.tokenIndex, index);\n    } else if (token.canOpen) {\n      stack.push({ kind: token.kind, tokenIndex: index });\n    }\n    // Can neither close the current context nor open — stays unmatched (literal).\n  });\n\n  // Anything left on the stack never closed — leave unmatched (rendered literally by the caller).\n  return openerToCloser;\n}\n\nconst FORMAT_FOR_KIND: Record<EmphasisKind, sheets_v4.Schema$TextFormat> = {\n  bold: { bold: true },\n  italic: { italic: true },\n  strikethrough: { strikethrough: true },\n};\n\n/** Walks the token stream, resolving matched delimiter pairs into spans and unmatched ones into literal text. */\nfunction buildTextAndSpans(tokens: Token[]): { text: string; spans: MarkdownSpan[] } {\n  const openerToCloser = matchDelimiters(tokens);\n  const closerToOpener = new Map<number, number>();\n  for (const [opener, closer] of openerToCloser) closerToOpener.set(closer, opener);\n\n  let text = '';\n  const spans: MarkdownSpan[] = [];\n  const openerStart = new Map<number, number>(); // opener token index -> plain-text start offset\n\n  tokens.forEach((token, index) => {\n    if (token.type === 'text') {\n      text += token.value;\n      return;\n    }\n\n    if (token.type === 'link') {\n      const start = text.length;\n      text += token.label;\n      spans.push({ start, end: text.length, format: { link: { uri: token.uri } } });\n      return;\n    }\n\n    // Emphasis delimiter token.\n    if (openerToCloser.has(index)) {\n      // Matched opener — record where its span begins; the delimiter itself is consumed (not emitted).\n      openerStart.set(index, text.length);\n      return;\n    }\n    const openerIndex = closerToOpener.get(index);\n    if (openerIndex !== undefined) {\n      // Matched closer — emit the span from the recorded opener position to here.\n      const start = openerStart.get(openerIndex);\n      if (start === undefined) {\n        throw new Error('markdown-runs: internal error — emphasis opener position was not recorded');\n      }\n      spans.push({ start, end: text.length, format: FORMAT_FOR_KIND[token.kind] });\n      return;\n    }\n    // Unmatched delimiter — no syntactic partner, so it degrades to its literal characters.\n    text += token.raw;\n  });\n\n  return { text, spans };\n}\n\n// ---------------------------------------------------------------------------\n// Public API\n// ---------------------------------------------------------------------------\n\n/** Parses inline markdown into plain text plus formatting spans (see module docs for the supported subset). */\nexport function parseInlineMarkdown(markdown: string): ParsedMarkdown {\n  const tokens = tokenize(markdown);\n  const { text, spans } = buildTextAndSpans(tokens);\n  const linkCount = spans.filter((span) => span.format.link !== undefined).length;\n  return { text, spans, linkCount };\n}\n\n/**\n * Builds `textFormatRuns` from parsed markdown spans.\n *\n * Three Sheets API rules drive this, and are easy to get wrong:\n *   1. A run's format persists to the end of the string unless a later run\n *      resets it with an empty `format: {}` — runs are NOT scoped to a range.\n *   2. A run must never be emitted at `startIndex === text.length`: a span\n *      that reaches the end of the string needs no \"turn it off\" run, because\n *      there's no text left for stray formatting to leak into.\n *   3. Runs must be listed in strictly increasing `startIndex` order, with no\n *      two runs sharing an index.\n *\n * The approach: collect every index where the set of \"active\" spans changes\n * (every span start, and every span end that isn't end-of-string), merge the\n * formats of all spans active at each such index into one run, then ensure\n * there is a run at index 0 — either a span already starts there, or an\n * explicit empty-format baseline is prepended so the cell doesn't inherit any\n * pre-existing rich text formatting.\n */\nexport function buildTextFormatRuns(parsed: ParsedMarkdown, styleLinks = true): sheets_v4.Schema$TextFormatRun[] {\n  const { text, spans } = parsed;\n  if (text.length === 0) return [];\n\n  const boundaries = new Set<number>();\n  for (const span of spans) {\n    boundaries.add(span.start);\n    if (span.end < text.length) boundaries.add(span.end);\n  }\n  const sortedBoundaries = [...boundaries].sort((a, b) => a - b);\n\n  const runs: sheets_v4.Schema$TextFormatRun[] = sortedBoundaries.map((startIndex) => {\n    const format: sheets_v4.Schema$TextFormat = {};\n    for (const span of spans) {\n      if (span.start <= startIndex && startIndex < span.end) {\n        Object.assign(format, span.format);\n      }\n    }\n    if (styleLinks && format.link) {\n      format.underline = true;\n      format.foregroundColorStyle = { rgbColor: LINK_BLUE };\n    }\n    return { startIndex, format };\n  });\n\n  if (runs.length === 0 || runs[0]?.startIndex !== 0) {\n    runs.unshift({ startIndex: 0, format: {} });\n  }\n\n  return runs;\n}\n"],"names":["buildTextFormatRuns","parseInlineMarkdown","LINK_BLUE","red","green","blue","MD_LINK","BARE_URL","ESCAPABLE","Set","trimTrailingPunctuation","url","replace","isWhitespaceOrEdge","ch","undefined","test","isWordChar","delimiterFlanking","_kind","raw","prev","next","underscore","startsWith","canOpen","canClose","tokenize","markdown","tokens","buffer","flush","push","type","value","i","length","has","linkMatch","exec","slice","rawLabel","trim","uri","label","bareMatch","two","kind","matchDelimiters","stack","openerToCloser","Map","forEach","token","index","top","pop","set","tokenIndex","FORMAT_FOR_KIND","bold","italic","strikethrough","buildTextAndSpans","closerToOpener","opener","closer","text","spans","openerStart","start","end","format","link","openerIndex","get","Error","linkCount","filter","span","parsed","styleLinks","runs","boundaries","add","sortedBoundaries","sort","a","b","map","startIndex","Object","assign","underline","foregroundColorStyle","rgbColor","unshift"],"mappings":"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"}

package/dist/cjs/spreadsheet/range-operations.d.cts

@@ -122,7 +122,7 @@ export declare function buildValuesBatchUpdateRequest(requests: Array<{
     valueInputOption: "RAW" | "USER_ENTERED";
     data: {
         range: string;
-        values: (string | number | boolean)[][];
+        values: (string | number | boolean | null | undefined)[][];
         majorDimension: "ROWS" | "COLUMNS";
     }[];
     includeValuesInResponse: boolean;

package/dist/cjs/spreadsheet/range-operations.d.ts

@@ -122,7 +122,7 @@ export declare function buildValuesBatchUpdateRequest(requests: Array<{
     valueInputOption: "RAW" | "USER_ENTERED";
     data: {
         range: string;
-        values: (string | number | boolean)[][];
+        values: (string | number | boolean | null | undefined)[][];
         majorDimension: "ROWS" | "COLUMNS";
     }[];
     includeValuesInResponse: boolean;