@marimo-team/islands 0.21.2-dev64 → 0.21.2-dev70

package/src/components/data-table/range-focus/__tests__/use-cell-range-selection.test.ts

@@ -0,0 +1,119 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { describe, expect, it } from "vitest";
+import { isInteractiveTarget } from "../use-cell-range-selection";
+
+function createMouseEvent(
+  target: HTMLElement,
+  currentTarget: HTMLElement,
+): React.MouseEvent {
+  return { target, currentTarget } as unknown as React.MouseEvent;
+}
+
+describe("isInteractiveTarget", () => {
+  it("returns false when target is the cell itself", () => {
+    const cell = document.createElement("td");
+    expect(isInteractiveTarget(createMouseEvent(cell, cell))).toBe(false);
+  });
+
+  it("returns false when clicking plain text inside a cell", () => {
+    const cell = document.createElement("td");
+    const span = document.createElement("span");
+    cell.append(span);
+    expect(isInteractiveTarget(createMouseEvent(span, cell))).toBe(false);
+  });
+
+  it.each([
+    "input",
+    "button",
+    "select",
+    "textarea",
+  ])("returns true when clicking a <%s>", (tag) => {
+    const cell = document.createElement("td");
+    const el = document.createElement(tag);
+    cell.append(el);
+    expect(isInteractiveTarget(createMouseEvent(el, cell))).toBe(true);
+  });
+
+  it("returns true when clicking an <a> link", () => {
+    const cell = document.createElement("td");
+    const a = document.createElement("a");
+    a.href = "#";
+    cell.append(a);
+    expect(isInteractiveTarget(createMouseEvent(a, cell))).toBe(true);
+  });
+
+  it("returns true when clicking a <label>", () => {
+    const cell = document.createElement("td");
+    const label = document.createElement("label");
+    cell.append(label);
+    expect(isInteractiveTarget(createMouseEvent(label, cell))).toBe(true);
+  });
+
+  it('returns true for element with role="checkbox"', () => {
+    const cell = document.createElement("td");
+    const div = document.createElement("div");
+    div.setAttribute("role", "checkbox");
+    cell.append(div);
+    expect(isInteractiveTarget(createMouseEvent(div, cell))).toBe(true);
+  });
+
+  it('returns true for element with role="button"', () => {
+    const cell = document.createElement("td");
+    const div = document.createElement("div");
+    div.setAttribute("role", "button");
+    cell.append(div);
+    expect(isInteractiveTarget(createMouseEvent(div, cell))).toBe(true);
+  });
+
+  it('returns true for contenteditable="true"', () => {
+    const cell = document.createElement("td");
+    const div = document.createElement("div");
+    div.setAttribute("contenteditable", "true");
+    cell.append(div);
+    expect(isInteractiveTarget(createMouseEvent(div, cell))).toBe(true);
+  });
+
+  it("returns true when clicking a child nested inside an interactive element", () => {
+    const cell = document.createElement("td");
+    const button = document.createElement("button");
+    const icon = document.createElement("span");
+    button.append(icon);
+    cell.append(button);
+    expect(isInteractiveTarget(createMouseEvent(icon, cell))).toBe(true);
+  });
+
+  it("returns true when clicking inside a marimo-ui-element", () => {
+    const cell = document.createElement("td");
+    const marimoEl = document.createElement("marimo-ui-element");
+    const inner = document.createElement("div");
+    marimoEl.append(inner);
+    cell.append(marimoEl);
+    expect(isInteractiveTarget(createMouseEvent(inner, cell))).toBe(true);
+  });
+
+  it("returns true when clicking the marimo-ui-element itself", () => {
+    const cell = document.createElement("td");
+    const marimoEl = document.createElement("marimo-ui-element");
+    cell.append(marimoEl);
+    expect(isInteractiveTarget(createMouseEvent(marimoEl, cell))).toBe(true);
+  });
+
+  it("returns false when clicking a non-interactive div", () => {
+    const cell = document.createElement("td");
+    const wrapper = document.createElement("div");
+    const text = document.createElement("span");
+    wrapper.append(text);
+    cell.append(wrapper);
+    expect(isInteractiveTarget(createMouseEvent(text, cell))).toBe(false);
+  });
+
+  it("returns false when target is a non-Element (e.g. Text node)", () => {
+    const cell = document.createElement("td");
+    const textNode = document.createTextNode("hello");
+    cell.append(textNode);
+    expect(isInteractiveTarget(createMouseEvent(textNode as never, cell))).toBe(
+      false,
+    );
+  });
+});

package/src/components/data-table/range-focus/use-cell-range-selection.ts

@@ -91,6 +91,10 @@ export const useCellRangeSelection = <TData>({
         return;
       }
 
+      if (isInteractiveTarget(e)) {
+        return;
+      }
+
       actions.handleCellMouseDown({
         cell,
         isShiftKey: e.shiftKey,
@@ -122,3 +126,18 @@ export const useCellRangeSelection = <TData>({
     clearSelection: actions.clearSelection,
   };
 };
+
+const INTERACTIVE_SELECTOR =
+  'input, button, select, textarea, a, label, [role="checkbox"], [role="button"], [contenteditable="true"], marimo-ui-element';
+
+/**
+ * Skip cell selection when the click target is inside an interactive element
+ * (e.g. a checkbox or button rendered as rich cell content).
+ */
+export function isInteractiveTarget(e: React.MouseEvent): boolean {
+  const target = e.target;
+  if (target === e.currentTarget || !(target instanceof Element)) {
+    return false;
+  }
+  return target.closest(INTERACTIVE_SELECTOR) !== null;
+}

package/src/components/datasources/datasources.tsx

@@ -28,6 +28,7 @@ import {
   INTERNAL_SQL_ENGINES,
 } from "@/core/datasets/engines";
 import {
+  PreviewSQLSchemaList,
   PreviewSQLTable,
   PreviewSQLTableList,
 } from "@/core/datasets/request-registry";
@@ -80,6 +81,7 @@ const INDENT = {
   database: "pl-4",
   schemaEmpty: "pl-8",
   schema: "pl-7",
+  schemaLoading: "pl-8",
   tableLoading: "pl-11",
   tableSchemaless: "pl-8",
   tableWithSchema: "pl-12",
@@ -369,6 +371,49 @@ const SchemaList: React.FC<{
   hasSearch,
   searchValue,
 }) => {
+  const { addSchemaList } = useDataSourceActions();
+  const [schemasRequested, setSchemasRequested] = React.useState(false);
+
+  // Custom loading state, we need to wait for the data to propagate once requested
+  // useAsyncData's loading state may return false before data has propagated
+  const [schemasLoading, setSchemasLoading] = React.useState(false);
+
+  const { isPending, error } = useAsyncData(async () => {
+    if (schemas.length === 0 && engineName && !schemasRequested) {
+      setSchemasRequested(true);
+      setSchemasLoading(true);
+      try {
+        const previewSchemaList = await PreviewSQLSchemaList.request({
+          engine: engineName,
+          database: databaseName,
+        });
+
+        addSchemaList({
+          schemas: previewSchemaList.schemas ?? [],
+          sqlSchemaContext: {
+            engine: engineName,
+            database: databaseName,
+          },
+        });
+      } finally {
+        setSchemasLoading(false);
+      }
+    }
+  }, [schemas.length, engineName, databaseName, schemasRequested]);
+
+  if (isPending || schemasLoading) {
+    return (
+      <LoadingState
+        message="Loading schemas..."
+        className={INDENT.schemaLoading}
+      />
+    );
+  }
+
+  if (error) {
+    return <ErrorState error={error} className={INDENT.schemaLoading} />;
+  }
+
   if (schemas.length === 0) {
     return (
       <EmptyState

package/src/components/markdown/markdown-renderer.tsx

@@ -1,7 +1,6 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
 import { EditorView } from "@codemirror/view";
-import { math } from "@streamdown/math";
 import { useAtomValue } from "jotai";
 import { BetweenHorizontalStartIcon } from "lucide-react";
 import { memo, Suspense, useState } from "react";
@@ -13,6 +12,7 @@ import { useLastFocusedCellId } from "@/core/cells/focus";
 import { MarkdownLanguageAdapter } from "@/core/codemirror/language/languages/markdown";
 import { SQLLanguageAdapter } from "@/core/codemirror/language/languages/sql/sql";
 import { autoInstantiateAtom } from "@/core/config/config";
+import { useAsyncData } from "@/hooks/useAsyncData";
 import { LazyAnyLanguageCodeMirror } from "@/plugins/impl/code/LazyAnyLanguageCodeMirror";
 import { useTheme } from "@/theme/useTheme";
 import { copyToClipboard } from "@/utils/copy";
@@ -166,11 +166,27 @@ const COMPONENTS: Components = {
   },
 };
 
+// Lazy-load the math plugin to keep katex (~264 KB) out of the critical path.
+// The first render works without math; once loaded, it re-renders with math support.
+let mathPluginCache: StreamdownProps["plugins"] | undefined;
+const useMathPlugin = () => {
+  const { data: plugins } = useAsyncData(async () => {
+    if (mathPluginCache) {
+      return mathPluginCache;
+    }
+    const mod = await import("@streamdown/math");
+    mathPluginCache = { math: mod.math };
+    return mathPluginCache;
+  }, []);
+  return plugins;
+};
+
 export const MarkdownRenderer = memo(({ content }: { content: string }) => {
+  const plugins = useMathPlugin();
   return (
     <Streamdown
       components={COMPONENTS}
-      plugins={{ math }}
+      plugins={plugins}
       className="mo-markdown-renderer"
     >
       {content}

package/src/core/datasets/__tests__/data-source.test.ts

@@ -1,7 +1,7 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 import { beforeEach, describe, expect, it } from "vitest";
 import { variableName } from "@/__tests__/branded";
-import type { DataTable } from "@/core/kernel/messages";
+import type { DatabaseSchema, DataTable } from "@/core/kernel/messages";
 import type { VariableName } from "@/core/variables/types";
 import {
   type DataSourceConnection,
@@ -209,6 +209,93 @@ describe("filtering data sources", () => {
   });
 });
 
+describe("add schema list", () => {
+  const connections: DataSourceConnection[] = [
+    {
+      name: "conn1" as ConnectionName,
+      source: "sqlite",
+      display_name: "SQLite DB",
+      dialect: "sqlite",
+      databases: [
+        {
+          name: "db1",
+          schemas: [],
+          dialect: "sqlite",
+        },
+      ],
+    },
+  ];
+
+  // Helper function to add schema list
+  const addSchemaList = (
+    schemas: DatabaseSchema[],
+    engine: string,
+    database: string,
+  ) => {
+    return reducer(baseState, {
+      type: "addSchemaList",
+      payload: {
+        schemas,
+        sqlSchemaContext: { engine, database },
+      },
+    });
+  };
+
+  let baseState: DataSourceState;
+
+  beforeEach(() => {
+    baseState = addConnection(connections, baseState);
+    expect(baseState.connectionsMap.size).toBe(defaultConnSize + 1);
+  });
+
+  it("adds schema list to a specific database", () => {
+    const schemaList: DatabaseSchema[] = [
+      { name: "public", tables: [] },
+      { name: "analytics", tables: [] },
+    ];
+    const newState = addSchemaList(schemaList, "conn1", "db1");
+
+    const conn1 = newState.connectionsMap.get("conn1" as ConnectionName);
+    const db1 = conn1?.databases.find((db) => db.name === "db1");
+    expect(db1?.schemas).toEqual(schemaList);
+  });
+
+  it("updates schema list for a database", () => {
+    const schemaList: DatabaseSchema[] = [
+      { name: "public", tables: [] },
+      { name: "analytics", tables: [] },
+    ];
+    const newState = addSchemaList(schemaList, "conn1", "db1");
+
+    const conn1 = newState.connectionsMap.get("conn1" as ConnectionName);
+    const db1 = conn1?.databases.find((db) => db.name === "db1");
+    expect(db1?.schemas).toEqual(schemaList);
+
+    // update with new schema list
+    const newSchemaList: DatabaseSchema[] = [
+      { name: "public", tables: [] },
+      { name: "sales", tables: [] },
+    ];
+    const updatedState = addSchemaList(newSchemaList, "conn1", "db1");
+
+    const newConn = updatedState.connectionsMap.get("conn1" as ConnectionName);
+    const newDb1 = newConn?.databases.find((db) => db.name === "db1");
+    expect(newDb1?.schemas).toEqual(newSchemaList);
+  });
+
+  it("does not add schema list if database does not exist", () => {
+    const schemaList: DatabaseSchema[] = [
+      { name: "public", tables: [] },
+      { name: "analytics", tables: [] },
+    ];
+    const newState = addSchemaList(schemaList, "conn1", "non_existent_db");
+
+    const conn1 = newState.connectionsMap.get("conn1" as ConnectionName);
+    const db1 = conn1?.databases.find((db) => db.name === "db1");
+    expect(db1?.schemas.length).toBe(0);
+  });
+});
+
 describe("add table list", () => {
   const connections: DataSourceConnection[] = [
     {

package/src/core/datasets/data-source-connections.ts

@@ -5,6 +5,7 @@ import { isSchemaless } from "@/components/datasources/utils";
 import { createReducerAndAtoms } from "@/utils/createReducer";
 import { Logger } from "@/utils/Logger";
 import type {
+  DatabaseSchema,
   DataSourceConnection as DataSourceConnectionType,
   DataTable,
 } from "../kernel/messages";
@@ -43,6 +44,11 @@ export interface DataSourceState {
   connectionsMap: ConnectionsMap;
 }
 
+export interface SQLSchemaContext {
+  engine: string;
+  database: string;
+}
+
 export interface SQLTableContext {
   engine: string;
   database: string;
@@ -134,6 +140,44 @@ const {
     };
   },
 
+  // Add schema list to a specific database in a connection
+  addSchemaList: (
+    state: DataSourceState,
+    opts: {
+      schemas: DatabaseSchema[];
+      sqlSchemaContext: SQLSchemaContext;
+    },
+  ): DataSourceState => {
+    const { schemas, sqlSchemaContext } = opts;
+    const { connectionsMap, latestEngineSelected } = state;
+    const connectionName = sqlSchemaContext.engine as ConnectionName;
+    const conn = connectionsMap.get(connectionName);
+
+    if (!conn) {
+      return state;
+    }
+
+    const newMap = new Map(connectionsMap);
+    const newConn: DataSourceConnection = {
+      ...conn,
+      databases: conn.databases.map((db) => {
+        if (db.name !== sqlSchemaContext.database) {
+          return db;
+        }
+        return {
+          ...db,
+          schemas: schemas,
+        };
+      }),
+    };
+    newMap.set(connectionName, newConn);
+
+    return {
+      latestEngineSelected: latestEngineSelected,
+      connectionsMap: newMap,
+    };
+  },
+
   // Add table list to a specific schema in a connection
   addTableList: (
     state: DataSourceState,

package/src/core/datasets/request-registry.ts

@@ -1,5 +1,6 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 import type {
+  SQLSchemaListPreview,
   SQLTableListPreview,
   SQLTablePreview,
   ValidateSQLResult,
@@ -8,6 +9,7 @@ import { CachingRequestRegistry } from "../network/CachingRequestRegistry";
 import { DeferredRequestRegistry } from "../network/DeferredRequestRegistry";
 import { getRequestClient } from "../network/requests";
 import type {
+  ListSQLSchemasRequest,
   ListSQLTablesRequest,
   PreviewSQLTableRequest,
   ValidateSQLRequest,
@@ -28,6 +30,17 @@ export const PreviewSQLTable = new DeferredRequestRegistry<
   });
 });
 
+export const PreviewSQLSchemaList = new DeferredRequestRegistry<
+  Omit<ListSQLSchemasRequest, "requestId">,
+  SQLSchemaListPreview
+>("sql-schema-list-preview", async (requestId, req) => {
+  const client = getRequestClient();
+  await client.previewSQLSchemaList({
+    requestId: requestId,
+    ...req,
+  });
+});
+
 export const PreviewSQLTableList = new DeferredRequestRegistry<
   Omit<ListSQLTablesRequest, "requestId">,
   SQLTableListPreview

package/src/core/islands/bridge.ts

@@ -169,6 +169,7 @@ export class IslandsPyodideBridge implements RunRequests, EditRequests {
   previewDatasetColumn = throwNotImplemented;
   previewSQLTable = throwNotImplemented;
   previewSQLTableList = throwNotImplemented;
+  previewSQLSchemaList = throwNotImplemented;
   previewDataSourceConnection = throwNotImplemented;
   validateSQL = throwNotImplemented;
   openFile = throwNotImplemented;

package/src/core/islands/main.ts

@@ -121,6 +121,7 @@ export async function initialize() {
       case "data-column-preview":
       case "sql-table-preview":
       case "sql-table-list-preview":
+      case "sql-schema-list-preview":
       case "datasets":
       case "data-source-connections":
       case "validate-sql-result":

package/src/core/kernel/messages.ts

@@ -41,6 +41,8 @@ export type DataColumnPreview = NotificationMessageData<"data-column-preview">;
 export type SQLTablePreview = NotificationMessageData<"sql-table-preview">;
 export type SQLTableListPreview =
   NotificationMessageData<"sql-table-list-preview">;
+export type SQLSchemaListPreview =
+  NotificationMessageData<"sql-schema-list-preview">;
 export type ValidateSQLResult = NotificationMessageData<"validate-sql-result">;
 export type SecretKeysResult = NotificationMessageData<"secret-keys-result">;
 export type StartupLogs = NotificationMessageData<"startup-logs">;

package/src/core/network/requests-lazy.ts

@@ -112,6 +112,7 @@ const ACTIONS: Record<keyof AllRequests, Action> = {
   previewDatasetColumn: "waitForConnectionOpen",
   previewSQLTable: "waitForConnectionOpen",
   previewSQLTableList: "waitForConnectionOpen",
+  previewSQLSchemaList: "waitForConnectionOpen",
   previewDataSourceConnection: "waitForConnectionOpen",
   validateSQL: "waitForConnectionOpen",
   listStorageEntries: "waitForConnectionOpen",

package/src/core/network/requests-network.ts

@@ -244,6 +244,14 @@ export function createNetworkRequests(): EditRequests & RunRequests {
         })
         .then(handleResponseReturnNull);
     },
+    previewSQLSchemaList: (request) => {
+      return getClient()
+        .POST("/api/datasources/preview_sql_schema_list", {
+          body: request,
+          params: getParams(),
+        })
+        .then(handleResponseReturnNull);
+    },
     previewDataSourceConnection: (request) => {
       return getClient()
         .POST("/api/datasources/preview_datasource_connection", {

package/src/core/network/requests-static.ts

@@ -57,6 +57,7 @@ export function createStaticRequests(): EditRequests & RunRequests {
     previewDatasetColumn: throwNotInEditMode,
     previewSQLTable: throwNotInEditMode,
     previewSQLTableList: throwNotInEditMode,
+    previewSQLSchemaList: throwNotInEditMode,
     previewDataSourceConnection: throwNotInEditMode,
     validateSQL: throwNotInEditMode,
     openFile: throwNotInEditMode,

package/src/core/network/requests-toasting.tsx

@@ -42,6 +42,7 @@ export function createErrorToastingRequests(
     previewDatasetColumn: "Failed to fetch data sources",
     previewSQLTable: "Failed to fetch SQL table",
     previewSQLTableList: "Failed to fetch SQL table list",
+    previewSQLSchemaList: "Failed to fetch SQL schema list",
     previewDataSourceConnection: "Failed to preview data source connection",
     validateSQL: "Failed to validate SQL",
     openFile: "Failed to open file",

package/src/core/network/types.ts

@@ -59,6 +59,7 @@ export type PreviewDatasetColumnRequest =
   schemas["PreviewDatasetColumnRequest"];
 export type PreviewSQLTableRequest = schemas["PreviewSQLTableRequest"];
 export type ListSQLTablesRequest = schemas["ListSQLTablesRequest"];
+export type ListSQLSchemasRequest = schemas["ListSQLSchemasRequest"];
 export type ListDataSourceConnectionRequest =
   schemas["ListDataSourceConnectionRequest"];
 export type ValidateSQLRequest = schemas["ValidateSQLRequest"];
@@ -151,6 +152,7 @@ export interface EditRequests {
   previewDatasetColumn: (request: PreviewDatasetColumnRequest) => Promise<null>;
   previewSQLTable: (request: PreviewSQLTableRequest) => Promise<null>;
   previewSQLTableList: (request: ListSQLTablesRequest) => Promise<null>;
+  previewSQLSchemaList: (request: ListSQLSchemasRequest) => Promise<null>;
   previewDataSourceConnection: (
     request: ListDataSourceConnectionRequest,
   ) => Promise<null>;

package/src/core/wasm/bridge.ts

@@ -523,6 +523,16 @@ export class PyodideBridge implements RunRequests, EditRequests {
     return null;
   };
 
+  previewSQLSchemaList: EditRequests["previewSQLSchemaList"] = async (
+    request,
+  ) => {
+    await this.putControlRequest({
+      type: "list-sql-schemas",
+      ...request,
+    });
+    return null;
+  };
+
   previewDataSourceConnection: EditRequests["previewDataSourceConnection"] =
     async (request) => {
       await this.putControlRequest({

package/src/core/websocket/useMarimoKernelConnection.tsx

@@ -37,6 +37,7 @@ import { useSetAppConfig } from "../config/config";
 import { useDataSourceActions } from "../datasets/data-source-connections";
 import type { ConnectionName } from "../datasets/engines";
 import {
+  PreviewSQLSchemaList,
   PreviewSQLTable,
   PreviewSQLTableList,
   ValidateSQL,
@@ -288,6 +289,9 @@ export function useMarimoKernelConnection(opts: {
       case "sql-table-list-preview":
         PreviewSQLTableList.resolve(msg.data.request_id, msg.data);
         return;
+      case "sql-schema-list-preview":
+        PreviewSQLSchemaList.resolve(msg.data.request_id, msg.data);
+        return;
       case "validate-sql-result":
         ValidateSQL.resolve(msg.data.request_id as RequestId, msg.data);
         return;

package/dist/apl-Bw2VYJky.js

@@ -1,4 +0,0 @@
-import { t as apl } from "./apl-hy2nkDJ0.js";
-export {
-  apl
-};

package/dist/asciiarmor-eqY4ZaG6.js

@@ -1,4 +0,0 @@
-import { t as asciiArmor } from "./asciiarmor-Bp85a1XA.js";
-export {
-  asciiArmor
-};

package/dist/asn1-Ch439-Sl.js

@@ -1,4 +0,0 @@
-import { t as asn1 } from "./asn1-CCINh2Tb.js";
-export {
-  asn1
-};

package/dist/brainfuck-CYhvoM5D.js

@@ -1,4 +0,0 @@
-import { t as brainfuck } from "./brainfuck-CWERNqpi.js";
-export {
-  brainfuck
-};

package/dist/classDiagram-2ON5EDUG-BKvGPmV7.js

@@ -1,30 +0,0 @@
-import "./purify.es-Co_dANLh.js";
-import "./chunk-S3R3BYOJ-CQOhwRBS.js";
-import { r as __name } from "./src-Bf2iLOlr.js";
-import "./chunk-ABZYJK2D-DFnIGLNd.js";
-import "./chunk-HN2XXSSU-E3n-Ys7Z.js";
-import "./chunk-CVBHYZKI-B_c5YBcW.js";
-import "./chunk-ATLVNIR6-4HgRPLgX.js";
-import "./dist-BGdYVvOu.js";
-import "./chunk-JA3XYJ7Z-B9-EWihm.js";
-import "./chunk-JZLCHNYA-CIx__-bR.js";
-import "./chunk-QXUST7PY-CaiIvoL5.js";
-import "./chunk-N4CR4FBY-Cl9KH_W1.js";
-import "./chunk-FMBD7UC4-B34QcQBj.js";
-import "./chunk-55IACEB6-hJraQgx2.js";
-import "./chunk-QN33PNHL-DV6ID85v.js";
-import { i as styles_default, n as classDiagram_default, r as classRenderer_v3_unified_default, t as ClassDB } from "./chunk-B4BG7PRW-Bp8FDZTb.js";
-var diagram = {
-  parser: classDiagram_default,
-  get db() {
-    return new ClassDB();
-  },
-  renderer: classRenderer_v3_unified_default,
-  styles: styles_default,
-  init: /* @__PURE__ */ __name((e) => {
-    e.class || (e.class = {}), e.class.arrowMarkerAbsolute = e.arrowMarkerAbsolute;
-  }, "init")
-};
-export {
-  diagram
-};

package/dist/classDiagram-v2-WZHVMYZB-CUmRCVhz.js

@@ -1,30 +0,0 @@
-import "./purify.es-Co_dANLh.js";
-import "./chunk-S3R3BYOJ-CQOhwRBS.js";
-import { r as __name } from "./src-Bf2iLOlr.js";
-import "./chunk-ABZYJK2D-DFnIGLNd.js";
-import "./chunk-HN2XXSSU-E3n-Ys7Z.js";
-import "./chunk-CVBHYZKI-B_c5YBcW.js";
-import "./chunk-ATLVNIR6-4HgRPLgX.js";
-import "./dist-BGdYVvOu.js";
-import "./chunk-JA3XYJ7Z-B9-EWihm.js";
-import "./chunk-JZLCHNYA-CIx__-bR.js";
-import "./chunk-QXUST7PY-CaiIvoL5.js";
-import "./chunk-N4CR4FBY-Cl9KH_W1.js";
-import "./chunk-FMBD7UC4-B34QcQBj.js";
-import "./chunk-55IACEB6-hJraQgx2.js";
-import "./chunk-QN33PNHL-DV6ID85v.js";
-import { i as styles_default, n as classDiagram_default, r as classRenderer_v3_unified_default, t as ClassDB } from "./chunk-B4BG7PRW-Bp8FDZTb.js";
-var diagram = {
-  parser: classDiagram_default,
-  get db() {
-    return new ClassDB();
-  },
-  renderer: classRenderer_v3_unified_default,
-  styles: styles_default,
-  init: /* @__PURE__ */ __name((e) => {
-    e.class || (e.class = {}), e.class.arrowMarkerAbsolute = e.arrowMarkerAbsolute;
-  }, "init")
-};
-export {
-  diagram
-};

package/dist/clojure-Dlp86hGI.js

@@ -1,4 +0,0 @@
-import { t as clojure } from "./clojure-ygiDe_M6.js";
-export {
-  clojure
-};