@marimo-team/frontend 0.23.7-dev1 → 0.23.7-dev11

package/src/plugins/impl/vega/resolve-data.ts

@@ -1,6 +1,7 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
 import { asRemoteURL } from "@/core/runtime/config";
+import { Semaphore } from "@/utils/semaphore";
 import { vegaLoadData } from "./loader";
 import type {
   FacetedUnitSpec,
@@ -17,6 +18,8 @@ type AnySpec =
   | UnitSpec<Field>
   | GenericFacetSpec<FacetedUnitSpec<Field>, LayerSpec<Field>, Field>;
 
+const VEGA_DATA_FETCH_CONCURRENCY = 5;
+
 /**
  * Given a VegaLite spec with URL data, resolve the data and return a new spec with the resolved data.
  *
@@ -30,6 +33,9 @@ export async function resolveVegaSpecData(
   }
 
   const datasets = "datasets" in spec ? { ...spec.datasets } : {};
+  // Single semaphore shared across the whole spec so total in-flight fetches
+  // (across all nested layers/hconcat/vconcat) stay bounded.
+  const fetchSem = new Semaphore(VEGA_DATA_FETCH_CONCURRENCY);
 
   const traverse = async <T extends AnySpec>(spec: T): Promise<T> => {
     if (!spec) {
@@ -80,7 +86,8 @@ export async function resolveVegaSpecData(
     } catch {
       return spec;
     }
-    const data = await vegaLoadData(url.href, spec.data.format);
+    const format = spec.data.format;
+    const data = await fetchSem.run(() => vegaLoadData(url.href, format));
 
     datasets[url.pathname] = data;
 

package/src/plugins/layout/__test__/MermaidPlugin.test.ts

@@ -0,0 +1,50 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { describe, expect, test } from "vitest";
+import { MermaidPlugin } from "../mermaid/MermaidPlugin";
+
+describe("MermaidPlugin validator", () => {
+  test("accepts optional theme and theme_variables", () => {
+    const plugin = new MermaidPlugin();
+    const result = plugin.validator.safeParse({
+      diagram: "graph TD\nA --> B",
+      theme: "base",
+      theme_variables: {
+        primaryColor: "#E8EEF5",
+        lineColor: "#475569",
+      },
+    });
+
+    expect(result.success).toBe(true);
+    if (!result.success) {
+      return;
+    }
+
+    expect(result.data).toEqual({
+      diagram: "graph TD\nA --> B",
+      theme: "base",
+      theme_variables: {
+        primaryColor: "#E8EEF5",
+        lineColor: "#475569",
+      },
+    });
+  });
+
+  test("accepts any string as theme", () => {
+    const plugin = new MermaidPlugin();
+    const result = plugin.validator.safeParse({
+      diagram: "graph TD\nA --> B",
+      theme: "invalid",
+    });
+
+    expect(result.success).toBe(true);
+    if (!result.success) {
+      return;
+    }
+
+    expect(result.data).toEqual({
+      diagram: "graph TD\nA --> B",
+      theme: "invalid",
+    });
+  });
+});

package/src/plugins/layout/mermaid/MermaidPlugin.tsx

@@ -9,6 +9,8 @@ import type {
 
 interface Data {
   diagram: string;
+  theme?: string;
+  theme_variables?: Record<string, string>;
 }
 
 export class MermaidPlugin implements IStatelessPlugin<Data> {
@@ -16,10 +18,18 @@ export class MermaidPlugin implements IStatelessPlugin<Data> {
 
   validator = z.object({
     diagram: z.string(),
+    theme: z.string().optional(),
+    theme_variables: z.record(z.string(), z.string()).optional(),
   });
 
   render(props: IStatelessPluginProps<Data>): JSX.Element {
-    return <LazyMermaid diagram={props.data.diagram} />;
+    return (
+      <LazyMermaid
+        diagram={props.data.diagram}
+        theme={props.data.theme}
+        themeVariables={props.data.theme_variables}
+      />
+    );
   }
 }
 

package/src/plugins/layout/mermaid/mermaid.tsx

@@ -10,6 +10,8 @@ import { Logger } from "@/utils/Logger";
 
 interface Props {
   diagram: string;
+  theme?: string;
+  themeVariables?: Record<string, string>;
   config?: MermaidConfig;
 }
 
@@ -62,14 +64,16 @@ function randomAlpha() {
   ).join("");
 }
 
-const Mermaid: React.FC<Props> = ({ diagram }) => {
+const Mermaid: React.FC<Props> = ({ diagram, theme, themeVariables }) => {
   // oxlint-disable-next-line react/hook-use-state
   const [id] = useState(() => randomAlpha());
 
   const darkMode = useTheme().theme === "dark";
+  const resolvedTheme = theme ?? (darkMode ? "dark" : "forest");
   mermaid.initialize({
     ...DEFAULT_CONFIG,
-    theme: darkMode ? "dark" : "forest",
+    theme: resolvedTheme as MermaidConfig["theme"],
+    themeVariables,
     darkMode: darkMode,
   });
 
@@ -86,7 +90,7 @@ const Mermaid: React.FC<Props> = ({ diagram }) => {
       });
 
     return result.svg;
-  }, [trimmedDiagram, id, darkMode]);
+  }, [trimmedDiagram, id, darkMode, resolvedTheme, themeVariables]);
 
   if (error) {
     return <ErrorBanner error={error} />;

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

@@ -0,0 +1,218 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+import { describe, expect, it } from "vitest";
+import { Deferred } from "../Deferred";
+import { mapWithConcurrency, Semaphore } from "../semaphore";
+
+describe("Semaphore", () => {
+  it("rejects invalid permit counts", () => {
+    expect(() => new Semaphore(0)).toThrow();
+    expect(() => new Semaphore(-1)).toThrow();
+    expect(() => new Semaphore(1.5)).toThrow();
+  });
+
+  it("resolves run() with the function's value", async () => {
+    const sem = new Semaphore(1);
+    await expect(sem.run(async () => 42)).resolves.toBe(42);
+    expect(sem.available).toBe(1);
+    expect(sem.pending).toBe(0);
+  });
+
+  it("releases the permit when run() rejects", async () => {
+    const sem = new Semaphore(1);
+    await expect(
+      sem.run(async () => {
+        throw new Error("boom");
+      }),
+    ).rejects.toThrow("boom");
+    expect(sem.available).toBe(1);
+  });
+
+  it("caps concurrent in-flight tasks at `permits`", async () => {
+    const sem = new Semaphore(3);
+    let inFlight = 0;
+    let maxInFlight = 0;
+    const gates = Array.from({ length: 10 }, () => new Deferred<void>());
+
+    const tasks = gates.map((gate) =>
+      sem.run(async () => {
+        inFlight++;
+        maxInFlight = Math.max(maxInFlight, inFlight);
+        await gate.promise;
+        inFlight--;
+      }),
+    );
+
+    // Let microtasks run so the first batch is scheduled.
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(maxInFlight).toBe(3);
+    expect(sem.available).toBe(0);
+    expect(sem.pending).toBe(7);
+
+    // Release them all and confirm everyone finishes.
+    for (const gate of gates) {
+      gate.resolve();
+    }
+    await Promise.all(tasks);
+    expect(maxInFlight).toBe(3);
+    expect(sem.available).toBe(3);
+    expect(sem.pending).toBe(0);
+  });
+
+  it("releases waiters in FIFO order", async () => {
+    const sem = new Semaphore(1);
+    const order: number[] = [];
+    const hold = new Deferred<void>();
+
+    // First holder takes the only permit and parks on `hold`.
+    const first = sem.run(async () => {
+      order.push(0);
+      await hold.promise;
+    });
+
+    // Queue three more in known order.
+    const rest = [1, 2, 3].map((i) =>
+      sem.run(async () => {
+        order.push(i);
+      }),
+    );
+
+    await Promise.resolve();
+    expect(order).toEqual([0]);
+    expect(sem.pending).toBe(3);
+
+    hold.resolve();
+    await Promise.all([first, ...rest]);
+    expect(order).toEqual([0, 1, 2, 3]);
+  });
+
+  it("throws on release() beyond initial permit count", () => {
+    const sem = new Semaphore(2);
+    expect(() => sem.release()).toThrow(/more times than acquire/);
+  });
+
+  it("supports manual acquire/release", async () => {
+    const sem = new Semaphore(2);
+    await sem.acquire();
+    await sem.acquire();
+    expect(sem.available).toBe(0);
+
+    let resolved = false;
+    const waiter = sem.acquire().then(() => {
+      resolved = true;
+    });
+    await Promise.resolve();
+    expect(resolved).toBe(false);
+
+    sem.release();
+    await waiter;
+    expect(resolved).toBe(true);
+
+    sem.release();
+    sem.release();
+    expect(sem.available).toBe(2);
+  });
+});
+
+describe("mapWithConcurrency", () => {
+  it("returns [] for empty input without invoking fn", async () => {
+    let called = 0;
+    const result = await mapWithConcurrency([], 5, async () => {
+      called++;
+      return 1;
+    });
+    expect(result).toEqual([]);
+    expect(called).toBe(0);
+  });
+
+  it("preserves input order in the result", async () => {
+    const input = [10, 20, 30, 40, 50];
+    const result = await mapWithConcurrency(input, 2, async (n) => {
+      // Reverse the natural completion order so we'd notice if order broke.
+      await new Promise((r) => setTimeout(r, input.length - input.indexOf(n)));
+      return n * 2;
+    });
+    expect(result).toEqual([20, 40, 60, 80, 100]);
+  });
+
+  it("respects the concurrency cap", async () => {
+    let inFlight = 0;
+    let maxInFlight = 0;
+    const items = Array.from({ length: 20 }, (_, i) => i);
+    const gates = items.map(() => new Deferred<void>());
+
+    const result = mapWithConcurrency(items, 4, async (i) => {
+      inFlight++;
+      maxInFlight = Math.max(maxInFlight, inFlight);
+      await gates[i].promise;
+      inFlight--;
+      return i;
+    });
+
+    // Flush microtasks so the first batch enters fn().
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(maxInFlight).toBe(4);
+
+    // Releasing one gate should let exactly one queued task enter fn().
+    for (const gate of gates) {
+      gate.resolve();
+    }
+    await result;
+    expect(maxInFlight).toBe(4);
+  });
+
+  it("lets in-flight tasks complete after the first rejection", async () => {
+    const completed: number[] = [];
+    const gates = [0, 1, 2, 3, 4].map(() => new Deferred<void>());
+
+    const result = mapWithConcurrency([0, 1, 2, 3, 4], 5, async (i) => {
+      await gates[i].promise;
+      if (i === 0) {
+        throw new Error("first failed");
+      }
+      completed.push(i);
+      return i;
+    });
+
+    // Reject the first one; the other 4 are still gated.
+    gates[0].resolve();
+    // Drain the rejection (catch so it doesn't escape the test).
+    await expect(result).rejects.toThrow("first failed");
+
+    // The other tasks were already in-flight when the rejection happened;
+    // they should still resolve when their gates open.
+    for (let i = 1; i < gates.length; i++) {
+      gates[i].resolve();
+    }
+    // Yield so the remaining sem.run() finallys run.
+    await new Promise((r) => setTimeout(r, 0));
+    expect(completed.toSorted()).toEqual([1, 2, 3, 4]);
+  });
+
+  it("rejects on the first error", async () => {
+    await expect(
+      mapWithConcurrency([1, 2, 3], 2, async (n) => {
+        if (n === 2) {
+          throw new Error("nope");
+        }
+        return n;
+      }),
+    ).rejects.toThrow("nope");
+  });
+
+  it("throws on invalid concurrency, even for empty input", () => {
+    expect(() => mapWithConcurrency([1, 2, 3], 0, async (n) => n)).toThrow();
+    expect(() => mapWithConcurrency([], 0, async (n: number) => n)).toThrow();
+  });
+
+  it("passes the index to fn", async () => {
+    const result = await mapWithConcurrency(
+      ["a", "b", "c"],
+      2,
+      async (item, index) => `${index}:${item}`,
+    );
+    expect(result).toEqual(["0:a", "1:b", "2:c"]);
+  });
+});

package/src/utils/fileToBase64.ts

@@ -1,5 +1,9 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
+import { mapWithConcurrency } from "./semaphore";
+
+const FILE_READ_CONCURRENCY = 5;
+
 /**
  * Converts a Blob or File to either a base64-encoded string or a data URL.
  *
@@ -35,11 +39,8 @@ export function blobToString(
  * Returns a promised array of tuples [file name, file contents].
  */
 export function filesToBase64(files: File[]): Promise<[string, string][]> {
-  return Promise.all(
-    files.map((file) =>
-      blobToString(file, "base64").then(
-        (contents) => [file.name, contents] as [string, string],
-      ),
-    ),
-  );
+  return mapWithConcurrency(files, FILE_READ_CONCURRENCY, async (file) => {
+    const contents = await blobToString(file, "base64");
+    return [file.name, contents] as [string, string];
+  });
 }

package/src/utils/semaphore.ts

@@ -0,0 +1,88 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+/**
+ * Counting semaphore that gates async work to at most `permits` in-flight
+ * tasks. Waiters are released in FIFO order.
+ */
+export class Semaphore {
+  private readonly maxPermits: number;
+  private permits: number;
+  private waiters: Array<() => void> = [];
+
+  constructor(permits: number) {
+    if (!Number.isInteger(permits) || permits < 1) {
+      throw new Error(
+        `Semaphore permits must be a positive integer, got ${permits}`,
+      );
+    }
+    this.maxPermits = permits;
+    this.permits = permits;
+  }
+
+  /** Permits currently available. */
+  get available(): number {
+    return this.permits;
+  }
+
+  /** Number of waiters queued for a permit. */
+  get pending(): number {
+    return this.waiters.length;
+  }
+
+  acquire(): Promise<void> {
+    if (this.permits > 0) {
+      this.permits--;
+      return Promise.resolve();
+    }
+    return new Promise<void>((resolve) => {
+      this.waiters.push(resolve);
+    });
+  }
+
+  release(): void {
+    const next = this.waiters.shift();
+    if (next) {
+      next();
+      return;
+    }
+    if (this.permits >= this.maxPermits) {
+      throw new Error(
+        "Semaphore.release() called more times than acquire() — refusing to exceed initial permit count",
+      );
+    }
+    this.permits++;
+  }
+
+  /** Acquire a permit, run `fn`, then release the permit. */
+  async run<T>(fn: () => Promise<T>): Promise<T> {
+    await this.acquire();
+    try {
+      return await fn();
+    } finally {
+      this.release();
+    }
+  }
+}
+
+/**
+ * Map over `items` with bounded parallelism. Preserves input order in the
+ * result. Rejects as soon as the first task rejects (like `Promise.all`);
+ * already-started tasks keep running to completion in the background but
+ * their results are dropped.
+ */
+// oxlint-disable-next-line marimo/prefer-object-params -- map-style helper, mirrors Array.prototype.map
+export function mapWithConcurrency<T, R>(
+  items: readonly T[],
+  concurrency: number,
+  fn: (item: T, index: number) => Promise<R>,
+): Promise<R[]> {
+  // Validate concurrency before the empty-input fast path so misconfiguration
+  // is never silently accepted.
+  const sem = new Semaphore(concurrency);
+  if (items.length === 0) {
+    return Promise.resolve([]);
+  }
+  return Promise.all(
+    items.map((item, index) => sem.run(() => fn(item, index))),
+  );
+}

package/dist/assets/LazyAnyLanguageCodeMirror-BF3xpDgO.js

@@ -1,2 +0,0 @@
-const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["./any-language-editor-C9DM60EN.js","./copy-icon-BYNydU7b.js","./button-D9nb17Rw.js","./useEventListener-BR0C1MaI.js","./compiler-runtime-B3qBwwSJ.js","./react-Bj1aDYRI.js","./chunk-LvLJmgfZ.js","./jsx-runtime-BqBOg78p.js","./cn-DCUzRj2J.js","./clsx-Dz_KRrWq.js","./tooltip-Gcwqb_SK.js","./fullscreen-BDxedMYP.js","./react-dom-CSu739Rf.js","./dist-BoOh2kN5.js","./use-toast-T0_cQDma.js","./copy-BCF-tANo.js","./check-BH35Ndha.js","./createLucideIcon-D5guW7EU.js","./copy-BwrPA9zQ.js","./error-banner-C6aBa98y.js","./alert-dialog-BGBdrcqJ.js","./errors-TZBmrJmc.js","./zod-H_cgTO0M.js","./dist-DS5RCKZO.js","./dist-BrR4M-k3.js","./dist-VjDnmGCZ.js","./dist-9g-_Ln9y.js","./dist-HlsDto3K.js","./dist-DBiqbYe-.js","./dist-E6ttb8td.js","./dist-DBBYmRY4.js","./dist-DggusHaA.js","./dist-DQOq2Tf-.js","./dist-CGDn0y-i.js","./dist-B324sPca.js","./dist-CsEqrZxx.js","./dist-_XomGjg6.js","./dist-ooLAQ9IK.js","./dist-HW7R98td.js","./esm-BmrwxxCo.js","./extends-B2LJnKU3.js","./objectWithoutPropertiesLoose-DaPAPabU.js","./dist-CHcznzB-.js","./esm-BRNC35J6.js","./dist-CEUFTp7U.js","./dist-_qPWf6sD.js","./dist-B96NwXcp.js","./dist-C9ZB41s2.js","./dist-rzeRelEY.js","./dist-D6wwIjcW.js","./apl-T0uH_RjM.js","./asciiarmor-D3ol7c2G.js","./asn1-DA-fXXsk.js","./brainfuck-exn1QR7H.js","./clike-BK27e5qn.js","./clojure-Df1U5nhC.js","./cmake-DrCf0yvp.js","./cobol-BWxHqof4.js","./coffeescript-nKvg8y_U.js","./commonlisp-Dm562cBV.js","./crystal-CrCmK2Cb.js","./css-jpfGFPDE.js","./cypher-RQ5M28al.js","./d-CNQ_nPqU.js","./diff-DOODcY7A.js","./dtd-CRYKjxdR.js","./dylan-Bg0sO2y3.js","./ecl-DaBeV7OZ.js","./eiffel-BtJc6fqQ.js","./elm-D9Rly7Qq.js","./erlang-FZMRuv-7.js","./factor-BbYo7zsD.js","./simple-mode-BJAT_N3M.js","./forth-C6jh4lHA.js","./fortran-DuxTe5qi.js","./gas-D7RWbiQ0.js","./gherkin-DV4l4nlf.js","./groovy-Ij7mXzwd.js","./haskell-BT_ZNgUJ.js","./haxe-DYYwGmM8.js","./idl-CjBvIccU.js","./javascript-DQz7szA1.js","./julia-U0NSUEwm.js","./livescript-D7jeebX7.js","./lua-CT4vrRvN.js","./mathematica-DmzlinOc.js","./mbox-DYDL20A1.js","./mirc-6LiBC6Dw.js","./mllike-orSu1SHG.js","./modelica-BsibU-7c.js","./mscgen-vX4NsSXf.js","./mumps-DIZYQE11.js","./nsis-Cr8jf68z.js","./ntriples-CwlUIE0o.js","./octave-BWtN_wao.js","./oz-CJMVKlqL.js","./pascal-C9rPtth-.js","./perl-CF7pKLbl.js","./pig-Bu0nn8JT.js","./powershell-Bzwpi8yQ.js","./properties-Cfh_Lj0j.js","./protobuf-Vz3fs9Hb.js","./pug-CKg66ZCy.js","./puppet-JwSHf4DX.js","./python-BRHQZrcc.js","./q-DWFQ7YI_.js","./r-DHkTNFL2.js","./rpm-zbaZz_dk.js","./ruby-COvM5Bj_.js","./sas-Be8P6y_s.js","./scheme-B9Zors0b.js","./shell-CaaQwZ-W.js","./sieve-CdflT_3W.js","./smalltalk-CRO88y3z.js","./sparql-DEker8ZS.js","./stex-CtmkcLz7.js","./stylus-DAJwnVOa.js","./swift-D5F-FU3-.js","./tcl-DirNbhYm.js","./textile-DhHo4rKl.js","./toml-CrP9HWVu.js","./troff-BWD1WiE0.js","./ttcn-cfg-jzTcqwRW.js","./ttcn-CQzcRj0D.js","./turtle-BAqH2D2z.js","./vb-CrUpzy4g.js","./vbscript-DEuHZ0Y0.js","./velocity-D99sTvXl.js","./verilog-XWBMMjwd.js","./vhdl-BAGmVXDV.js","./webidl-xagG_7hd.js","./xquery-B8Mguhly.js","./yacas-XW2NxGKw.js","./z80-DhICfTcL.js"])))=>i.map(i=>d[i]);
-import{s as e}from"./chunk-LvLJmgfZ.js";import{t as i}from"./react-Bj1aDYRI.js";import{t as o}from"./createLucideIcon-D5guW7EU.js";import{t as m}from"./preload-helper-DItdS47A.js";let r,a,s=(async()=>{r=o("between-horizontal-start",[["rect",{width:"13",height:"7",x:"8",y:"3",rx:"1",key:"pkso9a"}],["path",{d:"m2 9 3 3-3 3",key:"1agib5"}],["rect",{width:"13",height:"7",x:"8",y:"14",rx:"1",key:"1q5fc1"}]]),a=(0,e(i(),1).lazy)(()=>m(()=>import("./any-language-editor-C9DM60EN.js").then(async t=>(await t.__tla,t)),__vite__mapDeps([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133]),import.meta.url))})();export{s as __tla,r as n,a as t};

package/dist/assets/apl-m-AMVo9Q.js

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

package/dist/assets/asciiarmor-BCgPMx-s.js

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

package/dist/assets/asn1-f2_lxsgc.js

@@ -1 +0,0 @@
-import{t as a}from"./asn1-DA-fXXsk.js";export{a as asn1};

package/dist/assets/brainfuck-ZYebo2B9.js

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

package/dist/assets/channel-CWEEnT6g.js

@@ -1 +0,0 @@
-import{et as r,tt as e}from"./chunk-ABZYJK2D-BInZW7OW.js";var o=(t,a)=>e.lang.round(r.parse(t)[a]);export{o as t};

package/dist/assets/chunk-55IACEB6-DD051KDZ.js

@@ -1 +0,0 @@
-import{u as r}from"./src-nKy6a3tt.js";import{n}from"./src-CmKhyEBC.js";var a=n((e,o)=>{let t;return o==="sandbox"&&(t=r("#i"+e)),r(o==="sandbox"?t.nodes()[0].contentDocument.body:"body").select(`[id="${e}"]`)},"getDiagramElement");export{a as t};

package/dist/assets/classDiagram-2ON5EDUG-CBbpzZPu.js

@@ -1 +0,0 @@
-import"./purify.es-DBmVz-Wl.js";import"./src-nKy6a3tt.js";import"./chunk-S3R3BYOJ-DGKPoF4U.js";import{n as t}from"./src-CmKhyEBC.js";import"./chunk-ABZYJK2D-BInZW7OW.js";import"./chunk-HN2XXSSU-BBxJMYrA.js";import"./chunk-CVBHYZKI-Brsoob-W.js";import"./chunk-ATLVNIR6-_9Zaw7IP.js";import"./dist-DxxvVPQH.js";import"./chunk-JA3XYJ7Z-C6cvGHie.js";import"./chunk-JZLCHNYA-BM-e2D_8.js";import"./chunk-QXUST7PY-Q2jlSUop.js";import"./chunk-N4CR4FBY-BREYOeLP.js";import"./chunk-FMBD7UC4-Bt9icXTy.js";import"./chunk-55IACEB6-DD051KDZ.js";import"./chunk-QN33PNHL-DwGffwWu.js";import{i,n as o,r as m,t as p}from"./chunk-B4BG7PRW-Bg43tpY1.js";var a={parser:o,get db(){return new p},renderer:m,styles:i,init:t(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{a as diagram};

package/dist/assets/classDiagram-v2-WZHVMYZB-B0cWCuuo.js

@@ -1 +0,0 @@
-import"./purify.es-DBmVz-Wl.js";import"./src-nKy6a3tt.js";import"./chunk-S3R3BYOJ-DGKPoF4U.js";import{n as t}from"./src-CmKhyEBC.js";import"./chunk-ABZYJK2D-BInZW7OW.js";import"./chunk-HN2XXSSU-BBxJMYrA.js";import"./chunk-CVBHYZKI-Brsoob-W.js";import"./chunk-ATLVNIR6-_9Zaw7IP.js";import"./dist-DxxvVPQH.js";import"./chunk-JA3XYJ7Z-C6cvGHie.js";import"./chunk-JZLCHNYA-BM-e2D_8.js";import"./chunk-QXUST7PY-Q2jlSUop.js";import"./chunk-N4CR4FBY-BREYOeLP.js";import"./chunk-FMBD7UC4-Bt9icXTy.js";import"./chunk-55IACEB6-DD051KDZ.js";import"./chunk-QN33PNHL-DwGffwWu.js";import{i,n as o,r as m,t as p}from"./chunk-B4BG7PRW-Bg43tpY1.js";var a={parser:o,get db(){return new p},renderer:m,styles:i,init:t(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{a as diagram};

package/dist/assets/clojure-NE6UT6b9.js

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

package/dist/assets/cmake-7TIUAxVu.js

@@ -1 +0,0 @@
-import{t as a}from"./cmake-DrCf0yvp.js";export{a as cmake};

package/dist/assets/cobol-BdI6-uBH.js

@@ -1 +0,0 @@
-import{t as o}from"./cobol-BWxHqof4.js";export{o as cobol};

package/dist/assets/coffeescript-CLx5m4GS.js

@@ -1 +0,0 @@
-import{t as e}from"./coffeescript-nKvg8y_U.js";export{e as coffeeScript};

package/dist/assets/commonlisp-8d9AwdCm.js

@@ -1 +0,0 @@
-import{t as o}from"./commonlisp-Dm562cBV.js";export{o as commonLisp};

package/dist/assets/crystal-Bn-cOTHZ.js

@@ -1 +0,0 @@
-import{t as r}from"./crystal-CrCmK2Cb.js";export{r as crystal};

package/dist/assets/cypher-DnT9gfY3.js

@@ -1 +0,0 @@
-import{t as r}from"./cypher-RQ5M28al.js";export{r as cypher};

package/dist/assets/d-DCjbmG72.js

@@ -1 +0,0 @@
-import{t as o}from"./d-CNQ_nPqU.js";export{o as d};

package/dist/assets/diff-DtVdhdPz.js

@@ -1 +0,0 @@
-import{t as f}from"./diff-DOODcY7A.js";export{f as diff};

package/dist/assets/dist-BkhaSQrg.js

@@ -1 +0,0 @@
-import"./dist-BrR4M-k3.js";import{n as a,t}from"./dist-D6wwIjcW.js";export{t as wast,a as wastLanguage};

package/dist/assets/dist-_KQbcsP1.js

@@ -1 +0,0 @@
-import"./dist-BrR4M-k3.js";import{n as a,t as o}from"./dist-DBBYmRY4.js";export{o as java,a as javaLanguage};

package/dist/assets/dist-bvHsEZ9m.js

@@ -1 +0,0 @@
-import"./dist-BrR4M-k3.js";import{n as p,t as a}from"./dist-DS5RCKZO.js";export{a as cpp,p as cppLanguage};

package/dist/assets/dist-jLyLmWUE.js

@@ -1 +0,0 @@
-import"./dist-BrR4M-k3.js";import{n as r,t}from"./dist-CsEqrZxx.js";export{t as rust,r as rustLanguage};

package/dist/assets/dtd-CHKGQo-k.js

@@ -1 +0,0 @@
-import{t}from"./dtd-CRYKjxdR.js";export{t as dtd};

package/dist/assets/dylan-DKXsKw9e.js

@@ -1 +0,0 @@
-import{t as a}from"./dylan-Bg0sO2y3.js";export{a as dylan};

package/dist/assets/ecl-BJuToLkm.js

@@ -1 +0,0 @@
-import{t as e}from"./ecl-DaBeV7OZ.js";export{e as ecl};

package/dist/assets/eiffel-Bs0gRCeB.js

@@ -1 +0,0 @@
-import{t as e}from"./eiffel-BtJc6fqQ.js";export{e as eiffel};

package/dist/assets/elm-BXUbhN4m.js

@@ -1 +0,0 @@
-import{t as e}from"./elm-D9Rly7Qq.js";export{e as elm};

package/dist/assets/erlang-B9b7RAaI.js

@@ -1 +0,0 @@
-import{t as r}from"./erlang-FZMRuv-7.js";export{r as erlang};

package/dist/assets/factor-C2NWkG3V.js

@@ -1 +0,0 @@
-import{t as o}from"./factor-BbYo7zsD.js";export{o as factor};