@marimo-team/islands 0.21.2-dev0 → 0.21.2-dev100

package/src/utils/__tests__/download.test.tsx

@@ -1,7 +1,8 @@
 /* Copyright 2026 Marimo. All rights reserved. */
+
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { Mocks } from "@/__mocks__/common";
-import type { CellId } from "@/core/cells/ids";
+import { cellId } from "@/__tests__/branded";
 import { CellOutputId } from "@/core/cells/ids";
 import {
   downloadAsPDF,
@@ -218,7 +219,7 @@ describe("getImageDataUrlForCell", () => {
   beforeEach(() => {
     vi.clearAllMocks();
     mockElement = document.createElement("div");
-    mockElement.id = CellOutputId.create("cell-1" as CellId);
+    mockElement.id = CellOutputId.create(cellId("cell-1"));
     document.body.append(mockElement);
   });
 
@@ -227,7 +228,7 @@ describe("getImageDataUrlForCell", () => {
   });
 
   it("should return undefined if element is not found", async () => {
-    const result = await getImageDataUrlForCell("nonexistent" as CellId);
+    const result = await getImageDataUrlForCell(cellId("nonexistent"));
 
     expect(result).toBeUndefined();
     expect(Logger.error).toHaveBeenCalledWith(
@@ -238,7 +239,7 @@ describe("getImageDataUrlForCell", () => {
   it("should capture screenshot and return data URL", async () => {
     vi.mocked(toPng).mockResolvedValue(mockDataUrl);
 
-    const result = await getImageDataUrlForCell("cell-1" as CellId);
+    const result = await getImageDataUrlForCell(cellId("cell-1"));
 
     expect(result).toBe(mockDataUrl);
     expect(toPng).toHaveBeenCalledWith(
@@ -253,7 +254,7 @@ describe("getImageDataUrlForCell", () => {
   it("should pass style options to prevent clipping", async () => {
     vi.mocked(toPng).mockResolvedValue(mockDataUrl);
 
-    await getImageDataUrlForCell("cell-1" as CellId);
+    await getImageDataUrlForCell(cellId("cell-1"));
 
     expect(toPng).toHaveBeenCalledWith(
       mockElement,
@@ -274,7 +275,7 @@ describe("getImageDataUrlForCell", () => {
     });
     vi.mocked(toPng).mockResolvedValue(mockDataUrl);
 
-    await getImageDataUrlForCell("cell-1" as CellId);
+    await getImageDataUrlForCell(cellId("cell-1"));
 
     expect(toPng).toHaveBeenCalledWith(
       mockElement,
@@ -287,7 +288,7 @@ describe("getImageDataUrlForCell", () => {
   it("should pass scrollbar hiding styles via extraStyleContent", async () => {
     vi.mocked(toPng).mockResolvedValue(mockDataUrl);
 
-    await getImageDataUrlForCell("cell-1" as CellId);
+    await getImageDataUrlForCell(cellId("cell-1"));
 
     expect(toPng).toHaveBeenCalledWith(
       mockElement,
@@ -302,7 +303,7 @@ describe("getImageDataUrlForCell", () => {
     mockElement.style.maxHeight = "100px";
     vi.mocked(toPng).mockResolvedValue(mockDataUrl);
 
-    await getImageDataUrlForCell("cell-1" as CellId);
+    await getImageDataUrlForCell(cellId("cell-1"));
 
     // DOM should remain unchanged
     expect(mockElement.style.overflow).toBe("hidden");
@@ -312,7 +313,7 @@ describe("getImageDataUrlForCell", () => {
   it("should throw error on failure", async () => {
     vi.mocked(toPng).mockRejectedValue(new Error("Capture failed"));
 
-    await expect(getImageDataUrlForCell("cell-1" as CellId)).rejects.toThrow(
+    await expect(getImageDataUrlForCell(cellId("cell-1"))).rejects.toThrow(
       "Capture failed",
     );
   });
@@ -320,13 +321,13 @@ describe("getImageDataUrlForCell", () => {
   it("should handle concurrent captures correctly", async () => {
     // Create a second element
     const mockElement2 = document.createElement("div");
-    mockElement2.id = CellOutputId.create("cell-2" as CellId);
+    mockElement2.id = CellOutputId.create(cellId("cell-2"));
     document.body.append(mockElement2);
 
     vi.mocked(toPng).mockResolvedValue(mockDataUrl);
 
-    const capture1 = getImageDataUrlForCell("cell-1" as CellId);
-    const capture2 = getImageDataUrlForCell("cell-2" as CellId);
+    const capture1 = getImageDataUrlForCell(cellId("cell-1"));
+    const capture2 = getImageDataUrlForCell(cellId("cell-2"));
 
     await Promise.all([capture1, capture2]);
 
@@ -437,8 +438,8 @@ describe("downloadHTMLAsImage", () => {
     await downloadHTMLAsImage({ element: mockElement, filename: "test" });
 
     expect(toast).toHaveBeenCalledWith({
-      title: "Error",
-      description: "Failed to download as PNG.",
+      title: "Failed to download as PNG",
+      description: "Failed",
       variant: "danger",
     });
   });
@@ -461,7 +462,7 @@ describe("downloadCellOutputAsImage", () => {
   beforeEach(() => {
     vi.clearAllMocks();
     mockElement = document.createElement("div");
-    mockElement.id = CellOutputId.create("cell-1" as CellId);
+    mockElement.id = CellOutputId.create(cellId("cell-1"));
     mockAppEl = document.createElement("div");
     mockAppEl.id = "App";
     // Mock scrollTo since jsdom doesn't implement it
@@ -486,7 +487,7 @@ describe("downloadCellOutputAsImage", () => {
   });
 
   it("should show error toast if element not found", async () => {
-    await downloadCellOutputAsImage("nonexistent" as CellId, "test");
+    await downloadCellOutputAsImage(cellId("nonexistent"), "test");
 
     expect(toPng).not.toHaveBeenCalled();
     expect(Logger.error).toHaveBeenCalledWith(
@@ -502,7 +503,7 @@ describe("downloadCellOutputAsImage", () => {
   it("should show error toast if toPng fails", async () => {
     vi.mocked(toPng).mockRejectedValue(new Error("Screenshot failed"));
 
-    await downloadCellOutputAsImage("cell-1" as CellId, "result");
+    await downloadCellOutputAsImage(cellId("cell-1"), "result");
 
     expect(toast).toHaveBeenCalledWith({
       title: "Failed to download PNG",
@@ -514,7 +515,7 @@ describe("downloadCellOutputAsImage", () => {
   it("should download cell output as image", async () => {
     vi.mocked(toPng).mockResolvedValue(mockDataUrl);
 
-    await downloadCellOutputAsImage("cell-1" as CellId, "result");
+    await downloadCellOutputAsImage(cellId("cell-1"), "result");
 
     expect(toPng).toHaveBeenCalledWith(
       mockElement,
@@ -529,7 +530,7 @@ describe("downloadCellOutputAsImage", () => {
   it("should pass style options to toPng for full content capture", async () => {
     vi.mocked(toPng).mockResolvedValue(mockDataUrl);
 
-    await downloadCellOutputAsImage("cell-1" as CellId, "result");
+    await downloadCellOutputAsImage(cellId("cell-1"), "result");
 
     expect(toPng).toHaveBeenCalledWith(
       mockElement,
@@ -547,7 +548,7 @@ describe("downloadCellOutputAsImage", () => {
     mockElement.style.maxHeight = "100px";
     vi.mocked(toPng).mockResolvedValue(mockDataUrl);
 
-    await downloadCellOutputAsImage("cell-1" as CellId, "result");
+    await downloadCellOutputAsImage(cellId("cell-1"), "result");
 
     // DOM should remain unchanged
     expect(mockElement.style.overflow).toBe("hidden");

package/src/utils/__tests__/objects.test.ts

@@ -260,4 +260,38 @@ describe("Objects", () => {
       expect(result).toEqual({ a: 1, b: 2 });
     });
   });
+
+  describe("pick", () => {
+    it("should pick specified keys", () => {
+      const obj = { a: 1, b: 2, c: 3 };
+      expect(Objects.pick(obj, ["a", "c"])).toEqual({ a: 1, c: 3 });
+    });
+
+    it("should omit keys not present on the object", () => {
+      const obj = { a: 1, b: 2 };
+      expect(Objects.pick(obj, ["a", "z"])).toEqual({ a: 1 });
+    });
+
+    it("should preserve undefined values for existing keys", () => {
+      const obj = { a: undefined, b: 2 };
+      const result = Objects.pick(obj, ["a", "b"]);
+      expect(result).toEqual({ a: undefined, b: 2 });
+      expect("a" in result).toBe(true);
+    });
+
+    it("should not pick inherited properties", () => {
+      const parent = { inherited: true };
+      const obj = Object.create(parent);
+      obj.own = 1;
+      expect(Objects.pick(obj, ["own", "inherited"])).toEqual({ own: 1 });
+    });
+
+    it("should return empty object when picking no keys", () => {
+      expect(Objects.pick({ a: 1 }, [])).toEqual({});
+    });
+
+    it("should handle empty object", () => {
+      expect(Objects.pick({}, ["a"])).toEqual({});
+    });
+  });
 });

package/src/utils/__tests__/strings.test.ts

@@ -1,6 +1,6 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 import { describe, expect, it } from "vitest";
-import { decodeUtf8, Strings } from "../strings";
+import { capitalize, decodeUtf8, Strings } from "../strings";
 
 describe("Strings", () => {
   describe("startCase", () => {
@@ -58,6 +58,32 @@ describe("Strings", () => {
   });
 });
 
+describe("capitalize", () => {
+  it("capitalizes the first character", () => {
+    expect(capitalize("hello")).toBe("Hello");
+  });
+
+  it("returns empty string for empty input", () => {
+    expect(capitalize("")).toBe("");
+  });
+
+  it("handles already-capitalized strings", () => {
+    expect(capitalize("Hello")).toBe("Hello");
+  });
+
+  it("handles single character", () => {
+    expect(capitalize("a")).toBe("A");
+  });
+
+  it("preserves the rest of the string", () => {
+    expect(capitalize("hELLO")).toBe("HELLO");
+  });
+
+  it("handles non-letter first character", () => {
+    expect(capitalize("123abc")).toBe("123abc");
+  });
+});
+
 describe("decodeUtf8", () => {
   it("decodes UTF-8 array to string", () => {
     const encoder = new TextEncoder();

package/src/utils/arrays.ts

@@ -61,6 +61,73 @@ export const Arrays = {
   },
 };
 
+/**
+ * Create an array of numbers from 0 to length - 1.
+ */
+export function range(length: number): number[] {
+  return Array.from({ length }, (_, i) => i);
+}
+
+/**
+ * Remove duplicate values from an array.
+ */
+export function uniq<T>(arr: readonly T[]): T[] {
+  return [...new Set(arr)];
+}
+
+/**
+ * Sort an array by a key function, returning a new array.
+ */
+export function sortBy<T>(
+  arr: readonly T[],
+  key: (item: T) => string | number | undefined | null,
+): T[] {
+  // Decorate/sort/undecorate to compute keys once per element
+  return arr
+    .map((item) => [key(item), item] as const)
+    .sort(([ka], [kb]) => {
+      // Nullish values sort last
+      if (ka == null && kb == null) {
+        return 0;
+      }
+      if (ka == null) {
+        return 1;
+      }
+      if (kb == null) {
+        return -1;
+      }
+      if (ka < kb) {
+        return -1;
+      }
+      if (ka > kb) {
+        return 1;
+      }
+      return 0;
+    })
+    .map(([, item]) => item);
+}
+
+/**
+ * Split an array into two groups based on a predicate.
+ * Returns [pass, fail] where pass contains items that match
+ * and fail contains items that don't.
+ */
+export function partition<T>(
+  arr: readonly T[],
+  predicate: (item: T) => boolean,
+): [T[], T[]] {
+  const pass: T[] = [];
+  const fail: T[] = [];
+  for (const item of arr) {
+    if (predicate(item)) {
+      pass.push(item);
+    } else {
+      fail.push(item);
+    }
+  }
+  return [pass, fail];
+}
+
 export function arrayToggle<T>(arr: T[], item: T): T[] {
   if (!arr) {
     return [item];

package/src/utils/copy.ts

@@ -2,21 +2,34 @@
 import { Logger } from "./Logger";
 
 /**
- * Tries to copy text to the clipboard using the navigator.clipboard API.
- * If that fails, it falls back to prompting the user to copy.
+ * Copy text to the clipboard. When `html` is provided, writes both
+ * text/html and text/plain so rich content (e.g. hyperlinks) is
+ * preserved when pasting into apps like Excel or Google Sheets.
  *
  * As of 2024-10-29, Safari does not support navigator.clipboard.writeText
  * when running localhost http.
  */
-export async function copyToClipboard(text: string) {
+export async function copyToClipboard(text: string, html?: string) {
   if (navigator.clipboard === undefined) {
     Logger.warn("navigator.clipboard is not supported");
     window.prompt("Copy to clipboard: Ctrl+C, Enter", text);
     return;
   }
 
-  await navigator.clipboard.writeText(text).catch(async () => {
-    // Fallback to prompt
+  if (html && navigator.clipboard.write) {
+    try {
+      const item = new ClipboardItem({
+        "text/html": new Blob([html], { type: "text/html" }),
+        "text/plain": new Blob([text], { type: "text/plain" }),
+      });
+      await navigator.clipboard.write([item]);
+      return;
+    } catch {
+      Logger.warn("Failed to write rich text, falling back to plain text");
+    }
+  }
+
+  await navigator.clipboard.writeText(text).catch(() => {
     Logger.warn("Failed to copy to clipboard using navigator.clipboard");
     window.prompt("Copy to clipboard: Ctrl+C, Enter", text);
   });

package/src/utils/createReducer.ts

@@ -7,12 +7,7 @@ import { Logger } from "@/utils/Logger";
 
 export type NoInfer<T> = [T][T extends any ? 0 : never];
 
-interface ReducerAction<T> {
-  type: string;
-  payload: T;
-}
-
-type Dispatch = (action: ReducerAction<any>) => void;
+type Dispatch<RH> = (action: ReducerActionOf<RH>) => void;
 type IfUnknown<T, Y, N> = unknown extends T ? Y : N;
 
 type ReducerHandler<State, Payload> = (state: State, payload: Payload) => State;
@@ -27,6 +22,19 @@ type ReducerActions<RH extends ReducerHandlers<any>> = {
     : never;
 };
 
+/** Helper for typing middleware that receives dispatched actions. */
+export type DispatchedActionOf<T> = {
+  [Key in keyof T]: T[Key] extends (payload: infer P) => any
+    ? { type: Key; payload: P }
+    : never;
+}[keyof T & string];
+
+type ReducerActionOf<RH> = {
+  [Type in keyof RH]: RH[Type] extends ReducerHandler<any, infer Payload>
+    ? { type: Type; payload: Payload }
+    : never;
+}[keyof RH & string];
+
 export interface ReducerCreatorResult<
   State,
   RH extends ReducerHandlers<State>,
@@ -38,7 +46,7 @@ export interface ReducerCreatorResult<
   /**
    * Given a dispatch function, returns an object containing all the actions.
    */
-  createActions: (dispatch: Dispatch) => ReducerActions<RH>;
+  createActions: (dispatch: Dispatch<RH>) => ReducerActions<RH>;
 }
 
 /**
@@ -49,7 +57,7 @@ export function createReducer<
   RH extends ReducerHandlers<NoInfer<State>>,
 >(initialState: () => State, reducers: RH): ReducerCreatorResult<State, RH> {
   return {
-    reducer: (state, action: ReducerAction<RH>) => {
+    reducer: (state, action: ReducerActionOf<RH>) => {
       state = state || initialState();
       if (action.type in reducers) {
         return reducers[action.type](state, action.payload);
@@ -58,11 +66,11 @@ export function createReducer<
       Logger.error(`Action type ${action.type} is not defined in reducers.`);
       return state;
     },
-    createActions: (dispatch: Dispatch) => {
+    createActions: (dispatch: Dispatch<RH>) => {
       const actions = {} as ReducerActions<RH>;
       for (const type in reducers) {
         (actions as any)[type] = (payload: any) => {
-          dispatch({ type, payload });
+          dispatch({ type, payload } as any);
         };
       }
       return actions;
@@ -70,31 +78,34 @@ export function createReducer<
   };
 }
 
-type Middleware<State> = (
+type Middleware<State, RH> = (
   prevState: State,
   newState: State,
-  action: ReducerAction<any>,
+  action: ReducerActionOf<RH>,
 ) => void;
 
 export function createReducerAndAtoms<
   State,
   RH extends ReducerHandlers<NoInfer<State>>,
->(initialState: () => State, reducers: RH, middleware?: Middleware<State>[]) {
+>(
+  initialState: () => State,
+  reducers: RH,
+  middleware?: Middleware<State, NoInfer<RH>>[],
+) {
+  const allMiddleware = [...(middleware ?? [])];
+  const addMiddleware = (mw: Middleware<State, RH>) => {
+    allMiddleware.push(mw);
+  };
   const { reducer, createActions } = createReducer(initialState, reducers);
 
-  const reducerWithMiddleware = (state: State, action: ReducerAction<any>) => {
+  const reducerWithMiddleware = (state: State, action: ReducerActionOf<RH>) => {
     try {
       const newState = reducer(state, action);
-      if (middleware) {
-        for (const mw of middleware) {
-          try {
-            mw(state, newState, action);
-          } catch (error) {
-            Logger.error(
-              `Error in middleware for action ${action.type}:`,
-              error,
-            );
-          }
+      for (const mw of allMiddleware) {
+        try {
+          mw(state, newState, action);
+        } catch (error) {
+          Logger.error(`Error in middleware for action ${action.type}:`, error);
         }
       }
       return newState;
@@ -108,13 +119,21 @@ export function createReducerAndAtoms<
   // map of SetAtom => Actions
   const actionsMap = new WeakMap();
 
-  function useActions(): ReducerActions<RH> {
+  function useActions(
+    options: { skipMiddleware?: boolean } = {},
+  ): ReducerActions<RH> {
     const setState = useSetAtom(valueAtom);
 
+    if (options.skipMiddleware === true) {
+      return createActions((action: ReducerActionOf<RH>) => {
+        setState((state: State) => reducer(state, action));
+      });
+    }
+
     if (!actionsMap.has(setState)) {
       actionsMap.set(
         setState,
-        createActions((action: ReducerAction<any>) => {
+        createActions((action: ReducerActionOf<RH>) => {
           setState((state: State) => reducerWithMiddleware(state, action));
         }),
       );
@@ -126,6 +145,7 @@ export function createReducerAndAtoms<
 
   return {
     reducer: reducerWithMiddleware,
+    addMiddleware,
     createActions,
     valueAtom,
     useActions,

package/src/utils/download.ts

@@ -156,10 +156,11 @@ export async function downloadHTMLAsImage(opts: {
     // Get screenshot
     const dataUrl = await toPng(element);
     downloadByURL(dataUrl, Filenames.toPNG(filename));
-  } catch {
+  } catch (error) {
+    Logger.error("Error downloading as PNG", error);
     toast({
-      title: "Error",
-      description: "Failed to download as PNG.",
+      title: "Failed to download as PNG",
+      description: prettyError(error),
       variant: "danger",
     });
   } finally {

package/src/utils/html-to-image.ts

@@ -140,6 +140,11 @@ export const necessaryStyleProperties = [
   "cursor",
 ];
 
+// 1x1 transparent PNG as a fallback for images that fail to embed (e.g., cross-origin).
+// Without this, failed embeds leave external URLs in the cloned DOM, which taints the canvas.
+const TRANSPARENT_PIXEL =
+  "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVQI12NgAAIABQABNjN9GQAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAAA0lEQVQI12P4z8BQDwAEgAF/QualIQAAAABJRU5ErkJggg==";
+
 /**
  * Default options for html-to-image conversions.
  * These handle common edge cases like filtering out toolbars and logging errors.
@@ -162,6 +167,7 @@ export const defaultHtmlToImageOptions: HtmlToImageOptions = {
       return true;
     }
   },
+  imagePlaceholder: TRANSPARENT_PIXEL,
   onImageErrorHandler: (event) => {
     Logger.error("Error loading image:", event);
   },

package/src/utils/json/base64.ts

@@ -1,5 +1,6 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
+import type { components } from "@marimo-team/marimo-api";
 import type { NotificationMessageData } from "@/core/kernel/messages";
 import type { TypedString } from "../typed";
 
@@ -11,9 +12,9 @@ export type JsonString<T = unknown> = TypedString<"Json"> & {
 };
 
 /**
- * A base64-encoded string.
+ * A base64-encoded string — derived from the generated OpenAPI schema.
  */
-export type Base64String = TypedString<"Base64">;
+export type Base64String = components["schemas"]["Base64String"];
 
 /**
  * A data URL string.
@@ -120,7 +121,6 @@ export function dataViewToBase64(dataView: DataView): Base64String {
 export function safeExtractSetUIElementMessageBuffers(
   notification: NotificationMessageData<"send-ui-element-message">,
 ): readonly DataView[] {
-  // @ts-expect-error - TypeScript doesn't know that these strings are actually base64 strings
   const strs: Base64String[] = notification.buffers ?? [];
   return strs.map(base64ToDataView);
 }

package/src/utils/objects.ts

@@ -105,4 +105,18 @@ export const Objects = {
     const set = new Set<K>(keys);
     return Objects.filter(obj, (_, key) => !set.has(key));
   },
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  pick<V extends Record<string, any>, K extends string>(
+    obj: V,
+    keys: readonly K[],
+  ): Pick<V, K & keyof V> {
+    const result = {} as Record<string, unknown>;
+    for (const key of keys) {
+      if (Object.hasOwn(obj, key)) {
+        result[key] = obj[key];
+      }
+    }
+    return result as Pick<V, K & keyof V>;
+  },
 };

package/src/utils/strings.ts

@@ -1,28 +1,48 @@
 /* Copyright 2026 Marimo. All rights reserved. */
-import { startCase } from "lodash-es";
 import { Logger } from "./Logger";
 
-export const Strings = {
-  /**
-   * startCase that can handle non-letters
-   */
-  startCase: (str: string): string => {
-    if (!str) {
-      return "";
-    }
+/**
+ * Capitalize the first character of a string.
+ */
+export function capitalize(str: string): string {
+  if (!str) {
+    return "";
+  }
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
 
-    if (typeof str !== "string") {
-      Logger.error(str);
-      throw new TypeError(`Expected string, got ${typeof str}`);
-    }
+/**
+ * Convert a string to start case (capitalize each word).
+ * Handles camelCase, snake_case, kebab-case, and space-separated strings.
+ * Returns the original string unchanged if it contains no letters.
+ */
+export function startCase(str: string): string {
+  if (!str) {
+    return "";
+  }
 
-    // If has no letters, return the string
-    if (!/[A-Za-z]/.test(str)) {
-      return str;
-    }
+  if (typeof str !== "string") {
+    Logger.error(str);
+    throw new TypeError(`Expected string, got ${typeof str}`);
+  }
 
-    return startCase(str);
-  },
+  // If has no letters, return the string as-is
+  if (!/[A-Za-z]/.test(str)) {
+    return str;
+  }
+
+  return str
+    .replaceAll(/([\da-z])([A-Z])/g, "$1 $2") // camelCase → camel Case
+    .replaceAll(/([A-Z]+)([A-Z][a-z])/g, "$1 $2") // ABCDef → ABC Def
+    .replaceAll(/[\s_-]+/g, " ") // snake_case/kebab-case → spaces
+    .trim()
+    .split(" ")
+    .map(capitalize)
+    .join(" ");
+}
+
+export const Strings = {
+  startCase,
 
   htmlEscape: (str: string | undefined): string | undefined => {
     if (!str) {

package/src/utils/traceback.ts

@@ -98,10 +98,12 @@ export function getTracebackInfo(domNode: DOMNode): TracebackInfo | null {
           10,
         );
         if (domNode.firstChild.nodeValue?.includes("__marimo__")) {
-          const cellId = /__marimo__cell_(\w+)_/.exec(
+          const maybeCellId = /__marimo__cell_(\w+)_/.exec(
             domNode.firstChild.nodeValue,
-          )?.[1] as CellId;
-          if (cellId && lineNumber) {
+          )?.[1];
+          if (maybeCellId && lineNumber) {
+            // @ts-expect-error - Custom parser above will return valid cell ids
+            const cellId: CellId = maybeCellId;
             return { kind: "cell", cellId, lineNumber };
           }
         } else {

package/dist/_arrayReduce-BfFy684W.js

@@ -1,9 +0,0 @@
-function arrayReduce(e, t, n, r) {
-  var i = -1, a = e == null ? 0 : e.length;
-  for (r && a && (n = e[++i]); ++i < a; ) n = t(n, e[i], i, e);
-  return n;
-}
-var _arrayReduce_default = arrayReduce;
-export {
-  _arrayReduce_default as t
-};