@arborium/arborium 2.12.4 → 2.14.0

package/dist/arborium.js

@@ -1,4 +1,4 @@
-const L = [
+const _ = [
   [/^#!.*\bpython[23]?\b/, "python"],
   [/^#!.*\bnode\b/, "javascript"],
   [/^#!.*\bdeno\b/, "typescript"],
@@ -74,20 +74,20 @@ const L = [
 function M(e) {
   const t = e.split(`
 `)[0];
-  for (const [a, r] of L)
-    if (a.test(t))
-      return r;
-  for (const [a, r] of $)
-    if (a.test(e))
-      return r;
+  for (const [r, s] of _)
+    if (r.test(t))
+      return s;
+  for (const [r, s] of $)
+    if (r.test(e))
+      return s;
   return null;
 }
 function R(e) {
   const t = e.match(/\blanguage-(\w+)\b/);
   if (t) return t[1];
-  const a = e.match(/\blang-(\w+)\b/);
-  if (a) return a[1];
-  const r = /* @__PURE__ */ new Set([
+  const r = e.match(/\blang-(\w+)\b/);
+  if (r) return r[1];
+  const s = /* @__PURE__ */ new Set([
     "rust",
     "javascript",
     "typescript",
@@ -123,12 +123,12 @@ function R(e) {
     "console",
     "sh"
   ]);
-  for (const n of e.split(/\s+/))
-    if (r.has(n.toLowerCase()))
-      return n.toLowerCase();
+  for (const a of e.split(/\s+/))
+    if (s.has(a.toLowerCase()))
+      return a.toLowerCase();
   return null;
 }
-function H(e) {
+function F(e) {
   const t = {
     js: "javascript",
     ts: "typescript",
@@ -149,10 +149,10 @@ function H(e) {
     plaintext: "text",
     plain: "text",
     txt: "text"
-  }, a = e.toLowerCase();
-  return t[a] || a;
+  }, r = e.toLowerCase();
+  return t[r] || r;
 }
-const _ = "2.12.4", U = [
+const L = "2.14.0", U = [
   "ada",
   "agda",
   "asciidoc",
@@ -255,7 +255,7 @@ const _ = "2.12.4", U = [
   "yuri",
   "zig",
   "zsh"
-], F = [
+], J = [
   {
     name: "attribute",
     tag: "at"
@@ -589,243 +589,286 @@ const _ = "2.12.4", U = [
     tag: "cb"
   }
 ];
-function E(e) {
+function P(e) {
   return e.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
-const T = {
+const j = {
   manual: !1,
   theme: "one-dark",
   selector: "pre code",
   cdn: "jsdelivr",
-  version: _,
+  version: L,
   // Precise version from manifest
   pluginsUrl: "",
   // Empty means use bundled manifest
   hostUrl: "",
   // Empty means use CDN based on version
   logger: console,
+  resolveHostJs: ({ baseUrl: e, path: t }) => import(
+    /* @vite-ignore */
+    `${e}/${t}`
+  ),
+  resolveHostWasm: ({ baseUrl: e, path: t }) => fetch(`${e}/${t}`),
   resolveJs: ({ baseUrl: e, path: t }) => import(
     /* @vite-ignore */
     `${e}/${t}`
   ),
   resolveWasm: ({ baseUrl: e, path: t }) => fetch(`${e}/${t}`)
 };
-let g = null, p = null, u = { ...T };
-const y = /* @__PURE__ */ new Map(), h = /* @__PURE__ */ new Map(), d = new Set(U);
-let l = null, m = null;
-async function k(e) {
+let m = null, d = null, f = { ...j };
+const h = /* @__PURE__ */ new Map(), k = /* @__PURE__ */ new Map(), p = new Set(U);
+let c = null, b = null;
+async function T(e) {
   if (e.pluginsUrl)
-    return m || (m = (async () => {
+    return b || (b = (async () => {
       e.logger.debug(`[arborium] Loading local plugins manifest from: ${e.pluginsUrl}`);
       const t = await fetch(e.pluginsUrl);
       if (!t.ok)
         throw new Error(`Failed to load plugins.json: ${t.status}`);
-      l = await t.json(), e.logger.debug(`[arborium] Loaded local manifest with ${l?.entries.length} entries`);
-    })(), m);
+      c = await t.json(), e.logger.debug(`[arborium] Loaded local manifest with ${c?.entries.length} entries`);
+    })(), b);
 }
-function P(e, t) {
-  if (l) {
-    const s = l.entries.find((o) => o.language === e);
-    if (s)
-      return s.local_js.substring(0, s.local_js.lastIndexOf("/"));
+function E(e, t) {
+  if (c) {
+    const n = c.entries.find((l) => l.language === e);
+    if (n)
+      return n.local_js.substring(0, n.local_js.lastIndexOf("/"));
   }
-  const a = t.cdn, r = t.version;
-  let n;
-  return a === "jsdelivr" ? n = "https://cdn.jsdelivr.net/npm" : a === "unpkg" ? n = "https://unpkg.com" : n = a, `${n}/@arborium/${e}@${r}`;
+  const r = t.cdn, s = t.version;
+  let a;
+  return r === "jsdelivr" ? a = "https://cdn.jsdelivr.net/npm" : r === "unpkg" ? a = "https://unpkg.com" : a = r, `${a}/@arborium/${e}@${s}`;
 }
-async function j(e, t) {
-  const a = y.get(e);
-  if (a)
-    return t.logger.debug(`[arborium] Grammar '${e}' found in cache`), a;
+async function x(e, t) {
   const r = h.get(e);
   if (r)
-    return t.logger.debug(`[arborium] Grammar '${e}' already loading, waiting...`), r;
-  const n = q(e, t);
-  h.set(e, n);
+    return t.logger.debug(`[arborium] Grammar '${e}' found in cache`), r;
+  const s = k.get(e);
+  if (s)
+    return t.logger.debug(`[arborium] Grammar '${e}' already loading, waiting...`), s;
+  const a = H(e, t);
+  k.set(e, a);
   try {
-    return await n;
+    return await a;
   } finally {
-    h.delete(e);
+    k.delete(e);
   }
 }
-async function q(e, t) {
-  if (await k(t), !d.has(e) && !l?.entries.some((a) => a.language === e))
+async function H(e, t) {
+  if (await T(t), !p.has(e) && !c?.entries.some((r) => r.language === e))
     return t.logger.debug(`[arborium] Grammar '${e}' not available`), null;
   try {
-    const a = P(e, t), r = t.resolveJs === T.resolveJs ? ` from ${a}/grammar.js` : "";
-    t.logger.debug(`[arborium] Loading grammar '${e}'${r}`);
-    const n = await t.resolveJs({
+    const r = E(e, t), s = t.resolveJs === j.resolveJs ? ` from ${r}/grammar.js` : "";
+    t.logger.debug(`[arborium] Loading grammar '${e}'${s}`);
+    const a = await t.resolveJs({
       language: e,
-      baseUrl: a,
+      baseUrl: r,
       path: "grammar.js"
-    }), s = await t.resolveWasm({ language: e, baseUrl: a, path: "grammar_bg.wasm" });
-    await n.default({ module_or_path: s });
-    const o = n.language_id();
-    o !== e && t.logger.warn(`[arborium] Language ID mismatch: expected '${e}', got '${o}'`);
-    const x = n.injection_languages(), v = {
+    }), n = await t.resolveWasm({ language: e, baseUrl: r, path: "grammar_bg.wasm" });
+    await a.default({ module_or_path: n });
+    const l = a.language_id();
+    l !== e && t.logger.warn(`[arborium] Language ID mismatch: expected '${e}', got '${l}'`);
+    const w = a.injection_languages(), y = {
       languageId: e,
-      injectionLanguages: x,
-      module: n,
+      injectionLanguages: w,
+      module: a,
       // UTF-8 parsing for Rust host
-      parseUtf8: (f) => {
-        const c = n.create_session();
+      parseUtf8: (g) => {
+        const i = a.create_session();
         try {
-          n.set_text(c, f);
-          const i = n.parse(c);
+          a.set_text(i, g);
+          const o = a.parse(i);
           return {
-            spans: i.spans || [],
-            injections: i.injections || []
+            spans: o.spans || [],
+            injections: o.injections || []
           };
-        } catch (i) {
-          return t.logger.error("[arborium] Parse error:", i), { spans: [], injections: [] };
+        } catch (o) {
+          return t.logger.error("[arborium] Parse error:", o), { spans: [], injections: [] };
         } finally {
-          n.free_session(c);
+          a.free_session(i);
         }
       },
       // UTF-16 parsing for JavaScript public API
-      parseUtf16: (f) => {
-        const c = n.create_session();
+      parseUtf16: (g) => {
+        const i = a.create_session();
         try {
-          n.set_text(c, f);
-          const i = n.parse_utf16(c);
+          a.set_text(i, g);
+          const o = a.parse_utf16(i);
           return {
-            spans: i.spans || [],
-            injections: i.injections || []
+            spans: o.spans || [],
+            injections: o.injections || []
           };
-        } catch (i) {
-          return t.logger.error("[arborium] Parse error:", i), { spans: [], injections: [] };
+        } catch (o) {
+          return t.logger.error("[arborium] Parse error:", o), { spans: [], injections: [] };
         } finally {
-          n.free_session(c);
+          a.free_session(i);
         }
       }
     };
-    return y.set(e, v), t.logger.debug(`[arborium] Grammar '${e}' loaded successfully`), v;
-  } catch (a) {
-    return t.logger.error(`[arborium] Failed to load grammar '${e}':`, a), null;
+    return h.set(e, y), t.logger.debug(`[arborium] Grammar '${e}' loaded successfully`), y;
+  } catch (r) {
+    return t.logger.error(`[arborium] Failed to load grammar '${e}':`, r), null;
   }
 }
-const w = /* @__PURE__ */ new Map();
-let C = 1;
-function I(e) {
-  window.arboriumHost = {
+const v = /* @__PURE__ */ new Map();
+let I = 1;
+function q(e) {
+  globalThis.arboriumHost = {
     /** Check if a language is available (sync) */
     isLanguageAvailable(t) {
-      return d.has(t) || y.has(t);
+      return p.has(t) || h.has(t);
     },
     /** Load a grammar and return a handle (async) */
     async loadGrammar(t) {
-      const a = await j(t, e);
-      if (!a) return 0;
-      for (const [n, s] of w)
-        if (s === a) return n;
-      const r = C++;
-      return w.set(r, a), r;
+      const r = await x(t, e);
+      if (!r) return 0;
+      for (const [a, n] of v)
+        if (n === r) return a;
+      const s = I++;
+      return v.set(s, r), s;
     },
     /** Parse text using a grammar handle (sync) - returns UTF-8 offsets for Rust host */
-    parse(t, a) {
-      const r = w.get(t);
-      return r ? r.parseUtf8(a) : { spans: [], injections: [] };
+    parse(t, r) {
+      const s = v.get(t);
+      return s ? s.parseUtf8(r) : { spans: [], injections: [] };
     }
   };
 }
-function S(e) {
+function C(e) {
   if (e.hostUrl)
     return e.hostUrl;
-  const t = e.cdn, a = e.version;
-  let r;
-  t === "jsdelivr" ? r = "https://cdn.jsdelivr.net/npm" : t === "unpkg" ? r = "https://unpkg.com" : r = t;
-  const n = a === "latest" ? "" : `@${a}`;
-  return `${r}/@arborium/arborium${n}/dist`;
+  const t = e.cdn, r = e.version;
+  let s;
+  t === "jsdelivr" ? s = "https://cdn.jsdelivr.net/npm" : t === "unpkg" ? s = "https://unpkg.com" : s = t;
+  const a = r === "latest" ? "" : `@${r}`;
+  return `${s}/@arborium/arborium${a}/dist`;
 }
-async function A(e) {
-  return g || p || (p = (async () => {
-    I(e);
-    const t = S(e), a = `${t}/arborium_host.js`, r = `${t}/arborium_host_bg.wasm`;
-    e.logger.debug(`[arborium] Loading host from ${a}`);
+async function G(e) {
+  return m || d || (d = (async () => {
+    q(e);
+    const t = C(e), r = e.resolveHostJs === j.resolveHostJs ? ` from ${t}/arborium_host.js` : "";
+    e.logger.debug(`[arborium] Loading host${r}`);
     try {
-      const n = await import(
-        /* @vite-ignore */
-        a
-      );
-      return await n.default(r), g = {
-        highlight: n.highlight,
-        isLanguageAvailable: n.isLanguageAvailable
-      }, e.logger.debug("[arborium] Host loaded successfully"), g;
-    } catch (n) {
-      return e.logger.error("[arborium] Failed to load host:", n), null;
+      const s = await e.resolveHostJs({ baseUrl: t, path: "arborium_host.js" }), a = await e.resolveHostWasm({ baseUrl: t, path: "arborium_host_bg.wasm" });
+      return await s.default({ module_or_path: a }), m = {
+        highlight: s.highlight,
+        isLanguageAvailable: s.isLanguageAvailable
+      }, e.logger.debug("[arborium] Host loaded successfully"), m;
+    } catch (s) {
+      return e.logger.error("[arborium] Failed to load host:", s), null;
     }
-  })(), p);
+  })(), d);
 }
-async function G(e, t, a) {
-  const r = b(a), n = await A(r);
-  if (n)
+async function S(e, t, r) {
+  const s = u(r), a = await G(s);
+  if (a)
     try {
-      return n.highlight(e, t);
-    } catch (s) {
-      r.logger.error("[arborium] Host highlight failed:", s);
+      return a.highlight(e, t);
+    } catch (n) {
+      s.logger.error("[arborium] Host highlight failed:", n);
     }
-  return E(t);
+  return P(t);
 }
-async function z(e, t) {
-  const a = b(t), r = await j(e, a);
-  if (!r) return null;
-  const { module: n } = r;
+async function A(e, t) {
+  const r = u(t), s = await x(e, r);
+  if (!s) return null;
+  const { module: a } = s;
   return {
-    languageId: () => r.languageId,
-    injectionLanguages: () => r.injectionLanguages,
-    highlight: async (s) => G(e, s, t),
+    languageId: () => s.languageId,
+    injectionLanguages: () => s.injectionLanguages,
+    highlight: async (n) => S(e, n, t),
     // Public API returns UTF-16 offsets for JavaScript compatibility
-    parse: (s) => r.parseUtf16(s),
+    parse: (n) => s.parseUtf16(n),
     createSession: () => {
-      const s = n.create_session();
+      const n = a.create_session();
       return {
-        setText: (o) => n.set_text(s, o),
+        setText: (l) => a.set_text(n, l),
         // Session.parse() returns UTF-16 offsets for JavaScript compatibility
         parse: () => {
           try {
-            const o = n.parse_utf16(s);
+            const l = a.parse_utf16(n);
             return {
-              spans: o.spans || [],
-              injections: o.injections || []
+              spans: l.spans || [],
+              injections: l.injections || []
             };
-          } catch (o) {
-            return a.logger.error("[arborium] Session parse error:", o), { spans: [], injections: [] };
+          } catch (l) {
+            return r.logger.error("[arborium] Session parse error:", l), { spans: [], injections: [] };
           }
         },
-        cancel: () => n.cancel(s),
-        free: () => n.free_session(s)
+        cancel: () => a.cancel(n),
+        free: () => a.free_session(n)
       };
     },
     dispose: () => {
     }
   };
 }
-function b(e) {
-  return e ? { ...u, ...e } : { ...u };
+async function z(e, t, r) {
+  const s = u(r), a = e;
+  await a.default({ module_or_path: t });
+  const n = a.language_id(), l = a.injection_languages(), w = {
+    languageId: n,
+    injectionLanguages: l,
+    module: a,
+    parseUtf8: (g) => {
+      const i = a.create_session();
+      try {
+        a.set_text(i, g);
+        const o = a.parse(i);
+        return {
+          spans: o.spans || [],
+          injections: o.injections || []
+        };
+      } catch (o) {
+        return s.logger.error("[arborium] Parse error:", o), { spans: [], injections: [] };
+      } finally {
+        a.free_session(i);
+      }
+    },
+    parseUtf16: (g) => {
+      const i = a.create_session();
+      try {
+        a.set_text(i, g);
+        const o = a.parse_utf16(i);
+        return {
+          spans: o.spans || [],
+          injections: o.injections || []
+        };
+      } catch (o) {
+        return s.logger.error("[arborium] Parse error:", o), { spans: [], injections: [] };
+      } finally {
+        a.free_session(i);
+      }
+    }
+  };
+  return h.set(n, w), p.add(n), s.logger.debug(`[arborium] Grammar '${n}' registered`), await A(n, r);
+}
+function u(e) {
+  return e ? { ...f, ...e } : { ...f };
 }
 function N(e) {
-  u = { ...u, ...e };
+  f = { ...f, ...e };
 }
 async function O(e, t) {
-  const a = b(t);
-  return await k(a), d.has(e) || (l?.entries.some((r) => r.language === e) ?? !1);
+  const r = u(t);
+  return await T(r), p.has(e) || (c?.entries.some((s) => s.language === e) ?? !1);
 }
-async function B(e) {
-  const t = b(e);
-  return await k(t), l ? l.entries.map((a) => a.language) : Array.from(d);
+async function W(e) {
+  const t = u(e);
+  return await T(t), c ? c.entries.map((r) => r.language) : Array.from(p);
 }
 export {
   U as availableLanguages,
   M as detectLanguage,
   R as extractLanguageFromClass,
-  B as getAvailableLanguages,
-  b as getConfig,
-  G as highlight,
-  F as highlights,
+  W as getAvailableLanguages,
+  u as getConfig,
+  S as highlight,
+  J as highlights,
   O as isLanguageAvailable,
-  z as loadGrammar,
-  H as normalizeLanguage,
-  _ as pluginVersion,
+  A as loadGrammar,
+  F as normalizeLanguage,
+  L as pluginVersion,
+  z as registerGrammar,
   N as setConfig
 };
 //# sourceMappingURL=arborium.js.map