@arborium/arborium 1.0.4 → 1.0.6

package/dist/arborium.js

@@ -1,13 +1,13 @@
-class I extends Error {
-  constructor(n) {
-    super(n), this.name = "WasiError";
+class U extends Error {
+  constructor(r) {
+    super(r), this.name = "WasiError";
   }
 }
-class k {
-  write(n) {
+class j {
+  write(r) {
     return BigInt(0);
   }
-  blockingWriteAndFlush(n) {
+  blockingWriteAndFlush(r) {
   }
   blockingFlush() {
   }
@@ -17,86 +17,181 @@ class k {
   subscribe() {
   }
 }
-class S {
-  read(n) {
+class E {
+  read(r) {
     return new Uint8Array(0);
   }
-  blockingRead(n) {
+  blockingRead(r) {
     return new Uint8Array(0);
   }
   subscribe() {
   }
 }
-function R() {
-  const s = new k(), n = new k(), e = new S(), t = {
+function T() {
+  const s = new j(), r = new j(), t = new E(), e = {
     getEnvironment: () => [],
     getArguments: () => []
-  }, r = {
-    exit: (a) => {
-      if (a.tag === "err")
-        throw new I(`WASI exit with error: ${a.val}`);
+  }, n = {
+    exit: (o) => {
+      if (o.tag === "err")
+        throw new U(`WASI exit with error: ${o.val}`);
     }
-  }, o = { getStdin: () => e }, i = { getStdout: () => s }, f = { getStderr: () => n }, w = {
+  }, a = { getStdin: () => t }, l = { getStdout: () => s }, m = { getStderr: () => r }, d = {
     now: () => {
-      const a = Date.now();
+      const o = Date.now();
       return {
-        seconds: BigInt(Math.floor(a / 1e3)),
-        nanoseconds: a % 1e3 * 1e6
+        seconds: BigInt(Math.floor(o / 1e3)),
+        nanoseconds: o % 1e3 * 1e6
       };
     },
     resolution: () => ({ seconds: BigInt(0), nanoseconds: 1e6 })
-  }, b = {
+  }, u = {
     Descriptor: class {
     },
     DirectoryEntryStream: class {
     },
     filesystemErrorCode: () => null
-  }, c = {
+  }, w = {
     getDirectories: () => []
-  }, d = { Error: I }, p = { InputStream: S, OutputStream: k }, m = {
-    getRandomBytes: (a) => {
-      const u = new Uint8Array(Number(a));
-      return crypto.getRandomValues(u), u;
+  }, f = { Error: U }, p = { InputStream: E, OutputStream: j }, i = {
+    getRandomBytes: (o) => {
+      const b = new Uint8Array(Number(o));
+      return crypto.getRandomValues(b), b;
     },
     getRandomU64: () => {
-      const a = new Uint8Array(8);
-      return crypto.getRandomValues(a), new DataView(a.buffer).getBigUint64(0, !0);
+      const o = new Uint8Array(8);
+      return crypto.getRandomValues(o), new DataView(o.buffer).getBigUint64(0, !0);
     }
   };
   return {
     // Unversioned (used by published grammars)
-    "wasi:cli/environment": t,
-    "wasi:cli/exit": r,
-    "wasi:cli/stdin": o,
-    "wasi:cli/stdout": i,
-    "wasi:cli/stderr": f,
-    "wasi:clocks/wall-clock": w,
-    "wasi:filesystem/types": b,
-    "wasi:filesystem/preopens": c,
-    "wasi:io/error": d,
+    "wasi:cli/environment": e,
+    "wasi:cli/exit": n,
+    "wasi:cli/stdin": a,
+    "wasi:cli/stdout": l,
+    "wasi:cli/stderr": m,
+    "wasi:clocks/wall-clock": d,
+    "wasi:filesystem/types": u,
+    "wasi:filesystem/preopens": w,
+    "wasi:io/error": f,
     "wasi:io/streams": p,
-    "wasi:random/random": m,
+    "wasi:random/random": i,
     // Versioned @0.2.3 (for newer builds)
-    "wasi:cli/environment@0.2.3": t,
-    "wasi:cli/exit@0.2.3": r,
-    "wasi:cli/stdin@0.2.3": o,
-    "wasi:cli/stdout@0.2.3": i,
-    "wasi:cli/stderr@0.2.3": f,
-    "wasi:clocks/wall-clock@0.2.3": w,
-    "wasi:filesystem/types@0.2.3": b,
-    "wasi:filesystem/preopens@0.2.3": c,
-    "wasi:io/error@0.2.3": d,
+    "wasi:cli/environment@0.2.3": e,
+    "wasi:cli/exit@0.2.3": n,
+    "wasi:cli/stdin@0.2.3": a,
+    "wasi:cli/stdout@0.2.3": l,
+    "wasi:cli/stderr@0.2.3": m,
+    "wasi:clocks/wall-clock@0.2.3": d,
+    "wasi:filesystem/types@0.2.3": u,
+    "wasi:filesystem/preopens@0.2.3": w,
+    "wasi:io/error@0.2.3": f,
     "wasi:io/streams@0.2.3": p,
-    "wasi:random/random@0.2.3": m
+    "wasi:random/random@0.2.3": i
   };
 }
-const C = {
+const A = {
   "arborium:grammar/types@0.1.0": {
     // Types are just interfaces, nothing to export
   }
-}, W = {
-  entries: []
-}, _ = {
+}, R = [
+  "ada",
+  "agda",
+  "asciidoc",
+  "asm",
+  "awk",
+  "bash",
+  "batch",
+  "c",
+  "c-sharp",
+  "caddy",
+  "capnp",
+  "clojure",
+  "cmake",
+  "commonlisp",
+  "cpp",
+  "css",
+  "d",
+  "dart",
+  "devicetree",
+  "diff",
+  "dockerfile",
+  "dot",
+  "elisp",
+  "elixir",
+  "elm",
+  "erlang",
+  "fish",
+  "fsharp",
+  "gleam",
+  "glsl",
+  "go",
+  "graphql",
+  "haskell",
+  "hcl",
+  "hlsl",
+  "html",
+  "idris",
+  "ini",
+  "java",
+  "javascript",
+  "jinja2",
+  "jq",
+  "json",
+  "julia",
+  "kdl",
+  "kotlin",
+  "lean",
+  "lua",
+  "markdown",
+  "matlab",
+  "meson",
+  "nginx",
+  "ninja",
+  "nix",
+  "objc",
+  "ocaml",
+  "perl",
+  "php",
+  "postscript",
+  "powershell",
+  "prolog",
+  "python",
+  "query",
+  "r",
+  "rescript",
+  "ron",
+  "ruby",
+  "rust",
+  "scala",
+  "scheme",
+  "scss",
+  "sparql",
+  "sql",
+  "ssh-config",
+  "starlark",
+  "svelte",
+  "swift",
+  "textproto",
+  "thrift",
+  "tlaplus",
+  "toml",
+  "tsx",
+  "typescript",
+  "typst",
+  "uiua",
+  "vb",
+  "verilog",
+  "vhdl",
+  "vim",
+  "vue",
+  "x86asm",
+  "xml",
+  "yaml",
+  "yuri",
+  "zig",
+  "zsh"
+], C = {
   manual: !1,
   theme: "one-dark",
   selector: "pre code",
@@ -108,176 +203,184 @@ const C = {
   hostUrl: ""
   // Empty means use CDN based on version
 };
-let g = null, h = null, l = { ..._ };
-const x = /* @__PURE__ */ new Map();
-let $ = W, y = null, L = new Set(W.entries.map((s) => s.language));
+let h = null, y = null, c = { ...C };
+const $ = /* @__PURE__ */ new Map(), I = new Set(R);
+let g = null, v = null;
 async function M() {
-  if (l.pluginsUrl)
-    return y || (y = (async () => {
-      console.debug(`[arborium] Loading plugins manifest from: ${l.pluginsUrl}`);
-      const s = await fetch(l.pluginsUrl);
+  if (c.pluginsUrl)
+    return v || (v = (async () => {
+      console.debug(`[arborium] Loading local plugins manifest from: ${c.pluginsUrl}`);
+      const s = await fetch(c.pluginsUrl);
       if (!s.ok)
         throw new Error(`Failed to load plugins.json: ${s.status}`);
-      $ = await s.json(), L = new Set($.entries.map((n) => n.language)), console.debug(`[arborium] Available languages: ${Array.from(L).join(", ")}`);
-    })(), y);
+      g = await s.json(), console.debug(`[arborium] Loaded local manifest with ${g?.entries.length} entries`);
+    })(), v);
+}
+function _(s) {
+  if (g) {
+    const e = g.entries.find((n) => n.language === s);
+    if (e)
+      return e.local_js;
+  }
+  const r = c.cdn;
+  let t;
+  return r === "jsdelivr" ? t = "https://cdn.jsdelivr.net/npm" : r === "unpkg" ? t = "https://unpkg.com" : t = r, `${t}/@arborium/${s}@1/grammar.js`;
 }
-async function E(s) {
-  const n = x.get(s);
-  if (n)
-    return console.debug(`[arborium] Grammar '${s}' found in cache`), n;
-  await M();
-  const e = $.entries.find((t) => t.language === s);
-  if (!e)
-    return console.debug(`[arborium] Grammar '${s}' not found in manifest`), null;
+async function L(s) {
+  const r = $.get(s);
+  if (r)
+    return console.debug(`[arborium] Grammar '${s}' found in cache`), r;
+  if (await M(), !I.has(s) && !g?.entries.some((t) => t.language === s))
+    return console.debug(`[arborium] Grammar '${s}' not available`), null;
   try {
-    const t = l.pluginsUrl ? e.local_js : e.cdn_js, r = t.substring(0, t.lastIndexOf("/"));
+    const t = _(s), e = t.substring(0, t.lastIndexOf("/"));
     console.debug(`[arborium] Loading grammar '${s}' from ${t}`);
-    const o = await import(
+    const n = await import(
       /* @vite-ignore */
       t
-    ), i = async (p) => {
-      const m = `${r}/${p}`, a = await fetch(m);
-      if (!a.ok)
-        throw new Error(`Failed to fetch WASM ${p}: ${a.status}`);
-      const u = await a.arrayBuffer();
-      return WebAssembly.compile(u);
-    }, w = {
-      ...R(),
-      ...C
-    }, b = await o.instantiate(i, w), c = b.plugin || b["arborium:grammar/plugin@0.1.0"];
-    if (!c)
+    ), a = async (f) => {
+      const p = `${e}/${f}`, i = await fetch(p);
+      if (!i.ok)
+        throw new Error(`Failed to fetch WASM ${f}: ${i.status}`);
+      const o = await i.arrayBuffer();
+      return WebAssembly.compile(o);
+    }, m = {
+      ...T(),
+      ...A
+    }, d = await n.instantiate(a, m), u = d.plugin || d["arborium:grammar/plugin@0.1.0"];
+    if (!u)
       return console.error(`Grammar '${s}' missing plugin interface`), null;
-    const d = {
+    const w = {
       languageId: s,
-      injectionLanguages: c.injectionLanguages?.() ?? [],
-      parse: (p) => {
-        const m = c.createSession();
+      injectionLanguages: u.injectionLanguages?.() ?? [],
+      parse: (f) => {
+        const p = u.createSession();
         try {
-          c.setText(m, p);
-          const a = c.parse(m);
-          if (a.tag === "err") {
-            const T = a.val;
-            return console.error(`[arborium] Parse error: ${T?.message}`), { spans: [], injections: [] };
+          u.setText(p, f);
+          const i = u.parse(p);
+          if (i.tag === "err") {
+            const W = i.val;
+            return console.error(`[arborium] Parse error: ${W?.message}`), { spans: [], injections: [] };
           }
-          const u = a.tag === "ok" ? a.val : a;
-          if (!u || typeof u != "object")
-            return console.error("[arborium] Unexpected parse result:", a), { spans: [], injections: [] };
-          const U = u;
+          const o = i.tag === "ok" ? i.val : i;
+          if (!o || typeof o != "object")
+            return console.error("[arborium] Unexpected parse result:", i), { spans: [], injections: [] };
+          const b = o;
           return {
-            spans: U.spans || [],
-            injections: U.injections || []
+            spans: b.spans || [],
+            injections: b.injections || []
           };
         } finally {
-          c.freeSession(m);
+          u.freeSession(p);
         }
       }
     };
-    return x.set(s, d), console.debug(`[arborium] Grammar '${s}' loaded successfully`), d;
+    return $.set(s, w), console.debug(`[arborium] Grammar '${s}' loaded successfully`), w;
   } catch (t) {
     return console.error(`[arborium] Failed to load grammar '${s}':`, t), null;
   }
 }
-const j = /* @__PURE__ */ new Map();
-let F = 1;
-function P() {
+const x = /* @__PURE__ */ new Map();
+let q = 1;
+function F() {
   window.arboriumHost = {
     /** Check if a language is available (sync) */
     isLanguageAvailable(s) {
-      return L.has(s) || x.has(s);
+      return I.has(s) || $.has(s);
     },
     /** Load a grammar and return a handle (async) */
     async loadGrammar(s) {
-      const n = await E(s);
-      if (!n) return 0;
-      for (const [t, r] of j)
-        if (r === n) return t;
-      const e = F++;
-      return j.set(e, n), e;
+      const r = await L(s);
+      if (!r) return 0;
+      for (const [e, n] of x)
+        if (n === r) return e;
+      const t = q++;
+      return x.set(t, r), t;
     },
     /** Parse text using a grammar handle (sync) */
-    parse(s, n) {
-      const e = j.get(s);
-      return e ? e.parse(n) : { spans: [], injections: [] };
+    parse(s, r) {
+      const t = x.get(s);
+      return t ? t.parse(r) : { spans: [], injections: [] };
     }
   };
 }
-function B() {
-  if (l.hostUrl)
-    return l.hostUrl;
-  const s = l.cdn, n = l.version;
-  let e;
-  s === "jsdelivr" ? e = "https://cdn.jsdelivr.net/npm" : s === "unpkg" ? e = "https://unpkg.com" : e = s;
-  const t = n === "latest" ? "" : `@${n}`;
-  return `${e}/@arborium/arborium${t}/dist`;
+function P() {
+  if (c.hostUrl)
+    return c.hostUrl;
+  const s = c.cdn, r = c.version;
+  let t;
+  s === "jsdelivr" ? t = "https://cdn.jsdelivr.net/npm" : s === "unpkg" ? t = "https://unpkg.com" : t = s;
+  const e = r === "latest" ? "" : `@${r}`;
+  return `${t}/@arborium/arborium${e}/dist`;
 }
-async function H() {
-  return g || h || (h = (async () => {
-    P();
-    const s = B(), n = `${s}/arborium_host.js`, e = `${s}/arborium_host_bg.wasm`;
-    console.debug(`[arborium] Loading host from ${n}`);
+async function B() {
+  return h || y || (y = (async () => {
+    F();
+    const s = P(), r = `${s}/arborium_host.js`, t = `${s}/arborium_host_bg.wasm`;
+    console.debug(`[arborium] Loading host from ${r}`);
     try {
-      const t = await import(
+      const e = await import(
         /* @vite-ignore */
-        n
+        r
       );
-      return await t.default(e), g = {
-        highlight: t.highlight,
-        isLanguageAvailable: t.isLanguageAvailable
-      }, console.debug("[arborium] Host loaded successfully"), g;
-    } catch (t) {
-      return console.error("[arborium] Failed to load host:", t), null;
+      return await e.default(t), h = {
+        highlight: e.highlight,
+        isLanguageAvailable: e.isLanguageAvailable
+      }, console.debug("[arborium] Host loaded successfully"), h;
+    } catch (e) {
+      return console.error("[arborium] Failed to load host:", e), null;
     }
-  })(), h);
+  })(), y);
 }
-async function D(s, n, e) {
-  const t = await H();
-  if (t)
+async function N(s, r, t) {
+  const e = await B();
+  if (e)
     try {
-      return t.highlight(s, n);
-    } catch (i) {
-      console.warn("Host highlight failed, falling back to JS:", i);
+      return e.highlight(s, r);
+    } catch (l) {
+      console.warn("Host highlight failed, falling back to JS:", l);
     }
-  const r = await E(s);
-  if (!r)
-    return v(n);
-  const o = r.parse(n);
-  return A(n, o.spans);
+  const n = await L(s);
+  if (!n)
+    return k(r);
+  const a = n.parse(r);
+  return S(r, a.spans);
 }
-async function q(s, n) {
-  const e = await E(s);
-  return e ? {
-    languageId: () => e.languageId,
-    injectionLanguages: () => e.injectionLanguages,
-    highlight: async (t) => {
-      const r = e.parse(t);
-      return A(t, r.spans);
+async function z(s, r) {
+  const t = await L(s);
+  return t ? {
+    languageId: () => t.languageId,
+    injectionLanguages: () => t.injectionLanguages,
+    highlight: async (e) => {
+      const n = t.parse(e);
+      return S(e, n.spans);
     },
-    parse: (t) => e.parse(t),
+    parse: (e) => t.parse(e),
     dispose: () => {
     }
   } : null;
 }
-function A(s, n) {
-  const e = [...n].sort((o, i) => o.start - i.start);
-  let t = "", r = 0;
-  for (const o of e) {
-    if (o.start < r) continue;
-    o.start > r && (t += v(s.slice(r, o.start)));
-    const i = G(o.capture), f = v(s.slice(o.start, o.end));
-    i ? t += `<a-${i}>${f}</a-${i}>` : t += f, r = o.end;
+function S(s, r) {
+  const t = [...r].sort((a, l) => a.start - l.start);
+  let e = "", n = 0;
+  for (const a of t) {
+    if (a.start < n) continue;
+    a.start > n && (e += k(s.slice(n, a.start)));
+    const l = G(a.capture), m = k(s.slice(a.start, a.end));
+    l ? e += `<a-${l}>${m}</a-${l}>` : e += m, n = a.end;
   }
-  return r < s.length && (t += v(s.slice(r))), t;
+  return n < s.length && (e += k(s.slice(n))), e;
 }
 function G(s) {
   return s.startsWith("keyword") || s === "include" || s === "conditional" ? "k" : s.startsWith("function") || s.startsWith("method") ? "f" : s.startsWith("string") || s === "character" ? "s" : s.startsWith("comment") ? "c" : s.startsWith("type") ? "t" : s.startsWith("variable") ? "v" : s.startsWith("number") || s === "float" ? "n" : s.startsWith("operator") ? "o" : s.startsWith("punctuation") ? "p" : s.startsWith("tag") ? "tg" : s.startsWith("attribute") ? "at" : null;
 }
-function v(s) {
+function k(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
-function z(s) {
-  return s ? { ...l, ...s } : { ...l };
+function D(s) {
+  return s ? { ...c, ...s } : { ...c };
 }
-const O = [
+const H = [
   [/^#!.*\bpython[23]?\b/, "python"],
   [/^#!.*\bnode\b/, "javascript"],
   [/^#!.*\bdeno\b/, "typescript"],
@@ -290,7 +393,7 @@ const O = [
   [/^#!.*\bsh\b/, "bash"],
   [/^#!.*\blua\b/, "lua"],
   [/^#!.*\bawk\b/, "awk"]
-], N = [
+], O = [
   // Rust - distinctive keywords
   [/\b(fn|impl|trait|pub\s+fn|let\s+mut|&mut|->)\b/, "rust"],
   // Go - distinctive keywords
@@ -351,22 +454,22 @@ const O = [
   [/\b(pub\s+fn|const\s+\w+\s*=|@import\(|comptime)\b/, "zig"]
 ];
 function Y(s) {
-  const n = s.split(`
+  const r = s.split(`
 `)[0];
-  for (const [e, t] of O)
-    if (e.test(n))
-      return t;
-  for (const [e, t] of N)
-    if (e.test(s))
-      return t;
+  for (const [t, e] of H)
+    if (t.test(r))
+      return e;
+  for (const [t, e] of O)
+    if (t.test(s))
+      return e;
   return null;
 }
 function V(s) {
-  const n = s.match(/\blanguage-(\w+)\b/);
-  if (n) return n[1];
-  const e = s.match(/\blang-(\w+)\b/);
-  if (e) return e[1];
-  const t = /* @__PURE__ */ new Set([
+  const r = s.match(/\blanguage-(\w+)\b/);
+  if (r) return r[1];
+  const t = s.match(/\blang-(\w+)\b/);
+  if (t) return t[1];
+  const e = /* @__PURE__ */ new Set([
     "rust",
     "javascript",
     "typescript",
@@ -402,13 +505,13 @@ function V(s) {
     "console",
     "sh"
   ]);
-  for (const r of s.split(/\s+/))
-    if (t.has(r.toLowerCase()))
-      return r.toLowerCase();
+  for (const n of s.split(/\s+/))
+    if (e.has(n.toLowerCase()))
+      return n.toLowerCase();
   return null;
 }
 function J(s) {
-  const n = {
+  const r = {
     js: "javascript",
     ts: "typescript",
     py: "python",
@@ -428,16 +531,16 @@ function J(s) {
     plaintext: "text",
     plain: "text",
     txt: "text"
-  }, e = s.toLowerCase();
-  return n[e] || e;
+  }, t = s.toLowerCase();
+  return r[t] || t;
 }
 export {
   Y as detectLanguage,
   V as extractLanguageFromClass,
-  z as getConfig,
-  D as highlight,
-  q as loadGrammar,
+  D as getConfig,
+  N as highlight,
+  z as loadGrammar,
   J as normalizeLanguage,
-  A as spansToHtml
+  S as spansToHtml
 };
 //# sourceMappingURL=arborium.js.map