@arborium/arborium 2.4.6 → 2.5.0

package/dist/arborium.js

@@ -1,4 +1,4 @@
-const x = "2.4.6", $ = [
+const x = "2.5.0", $ = [
   "ada",
   "agda",
   "asciidoc",
@@ -97,7 +97,359 @@ const x = "2.4.6", $ = [
   "yuri",
   "zig",
   "zsh"
-], L = {
+], R = [
+  {
+    name: "attribute",
+    tag: "at"
+  },
+  {
+    name: "constant",
+    tag: "co"
+  },
+  {
+    name: "constant.builtin",
+    tag: "co",
+    parentTag: "co"
+  },
+  {
+    name: "constructor",
+    tag: "cr"
+  },
+  {
+    name: "function.builtin",
+    tag: "fb",
+    parentTag: "f"
+  },
+  {
+    name: "function",
+    tag: "f"
+  },
+  {
+    name: "function.method",
+    tag: "f",
+    parentTag: "f"
+  },
+  {
+    name: "keyword",
+    tag: "k"
+  },
+  {
+    name: "keyword.conditional",
+    tag: "k",
+    parentTag: "k"
+  },
+  {
+    name: "keyword.coroutine",
+    tag: "k",
+    parentTag: "k"
+  },
+  {
+    name: "keyword.debug",
+    tag: "k",
+    parentTag: "k"
+  },
+  {
+    name: "keyword.exception",
+    tag: "k",
+    parentTag: "k"
+  },
+  {
+    name: "keyword.function",
+    tag: "k",
+    parentTag: "k"
+  },
+  {
+    name: "keyword.import",
+    tag: "k",
+    parentTag: "k"
+  },
+  {
+    name: "keyword.operator",
+    tag: "o",
+    parentTag: "k"
+  },
+  {
+    name: "keyword.repeat",
+    tag: "k",
+    parentTag: "k"
+  },
+  {
+    name: "keyword.return",
+    tag: "k",
+    parentTag: "k"
+  },
+  {
+    name: "keyword.type",
+    tag: "k",
+    parentTag: "k"
+  },
+  {
+    name: "operator",
+    tag: "o"
+  },
+  {
+    name: "property",
+    tag: "pr"
+  },
+  {
+    name: "punctuation",
+    tag: "p"
+  },
+  {
+    name: "punctuation.bracket",
+    tag: "p",
+    parentTag: "p"
+  },
+  {
+    name: "punctuation.delimiter",
+    tag: "p",
+    parentTag: "p"
+  },
+  {
+    name: "punctuation.special",
+    tag: "p",
+    parentTag: "p"
+  },
+  {
+    name: "string",
+    tag: "s"
+  },
+  {
+    name: "string.special",
+    tag: "s",
+    parentTag: "s"
+  },
+  {
+    name: "tag",
+    tag: "tg"
+  },
+  {
+    name: "tag.delimiter",
+    tag: "tg",
+    parentTag: "tg"
+  },
+  {
+    name: "tag.error",
+    tag: "err",
+    parentTag: "tg"
+  },
+  {
+    name: "type",
+    tag: "t"
+  },
+  {
+    name: "type.builtin",
+    tag: "t",
+    parentTag: "t"
+  },
+  {
+    name: "type.qualifier",
+    tag: "t",
+    parentTag: "t"
+  },
+  {
+    name: "variable",
+    tag: "v"
+  },
+  {
+    name: "variable.builtin",
+    tag: "v",
+    parentTag: "v"
+  },
+  {
+    name: "variable.parameter",
+    tag: "v",
+    parentTag: "v"
+  },
+  {
+    name: "comment",
+    tag: "c"
+  },
+  {
+    name: "comment.documentation",
+    tag: "c",
+    parentTag: "c"
+  },
+  {
+    name: "macro",
+    tag: "m"
+  },
+  {
+    name: "label",
+    tag: "l"
+  },
+  {
+    name: "diff.addition",
+    tag: "da"
+  },
+  {
+    name: "diff.deletion",
+    tag: "dd"
+  },
+  {
+    name: "number",
+    tag: "n"
+  },
+  {
+    name: "text.literal",
+    tag: "tl"
+  },
+  {
+    name: "text.emphasis",
+    tag: "em"
+  },
+  {
+    name: "text.strong",
+    tag: "st"
+  },
+  {
+    name: "text.uri",
+    tag: "tu"
+  },
+  {
+    name: "text.reference",
+    tag: "tr"
+  },
+  {
+    name: "string.escape",
+    tag: "se",
+    parentTag: "s"
+  },
+  {
+    name: "text.title",
+    tag: "tt"
+  },
+  {
+    name: "text.strikethrough",
+    tag: "ts"
+  },
+  {
+    name: "spell",
+    tag: ""
+  },
+  {
+    name: "embedded",
+    tag: "eb"
+  },
+  {
+    name: "error",
+    tag: "err"
+  },
+  {
+    name: "namespace",
+    tag: "ns"
+  },
+  {
+    name: "include",
+    tag: "k",
+    parentTag: "k"
+  },
+  {
+    name: "storageclass",
+    tag: "k",
+    parentTag: "k"
+  },
+  {
+    name: "repeat",
+    tag: "k",
+    parentTag: "k"
+  },
+  {
+    name: "conditional",
+    tag: "k",
+    parentTag: "k"
+  },
+  {
+    name: "exception",
+    tag: "k",
+    parentTag: "k"
+  },
+  {
+    name: "preproc",
+    tag: "pp"
+  },
+  {
+    name: "none",
+    tag: ""
+  },
+  {
+    name: "character",
+    tag: "ch",
+    parentTag: "s"
+  },
+  {
+    name: "character.special",
+    tag: "ch",
+    parentTag: "ch"
+  },
+  {
+    name: "variable.member",
+    tag: "pr",
+    parentTag: "v"
+  },
+  {
+    name: "function.definition",
+    tag: "f",
+    parentTag: "f"
+  },
+  {
+    name: "type.definition",
+    tag: "t",
+    parentTag: "t"
+  },
+  {
+    name: "function.call",
+    tag: "f",
+    parentTag: "f"
+  },
+  {
+    name: "keyword.modifier",
+    tag: "k",
+    parentTag: "k"
+  },
+  {
+    name: "keyword.directive",
+    tag: "k",
+    parentTag: "k"
+  },
+  {
+    name: "string.regexp",
+    tag: "sr",
+    parentTag: "s"
+  },
+  {
+    name: "nospell",
+    tag: ""
+  },
+  {
+    name: "float",
+    tag: "n",
+    parentTag: "n"
+  },
+  {
+    name: "boolean",
+    tag: "bo",
+    parentTag: "co"
+  }
+];
+function y(t, e) {
+  const a = [...e].sort((r, i) => r.start - i.start);
+  let n = "", s = 0;
+  for (const r of a) {
+    if (r.start < s) continue;
+    r.start > s && (n += f(t.slice(s, r.start)));
+    const i = L(r.capture), c = f(t.slice(r.start, r.end));
+    i ? n += `<a-${i}>${c}</a-${i}>` : n += c, s = r.end;
+  }
+  return s < t.length && (n += f(t.slice(s))), n;
+}
+function L(t) {
+  return t.startsWith("keyword") || t === "include" || t === "conditional" ? "k" : t.startsWith("function") || t.startsWith("method") ? "f" : t.startsWith("string") || t === "character" ? "s" : t.startsWith("comment") ? "c" : t.startsWith("type") ? "t" : t.startsWith("variable") ? "v" : t.startsWith("number") || t === "float" ? "n" : t.startsWith("operator") ? "o" : t.startsWith("punctuation") ? "p" : t.startsWith("tag") ? "tg" : t.startsWith("attribute") ? "at" : null;
+}
+function f(t) {
+  return t.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+const v = {
   manual: !1,
   theme: "one-dark",
   selector: "pre code",
@@ -106,158 +458,160 @@ const x = "2.4.6", $ = [
   // Precise version from manifest
   pluginsUrl: "",
   // Empty means use bundled manifest
-  hostUrl: ""
+  hostUrl: "",
   // Empty means use CDN based on version
+  resolveJs: ({ baseUrl: t, path: e }) => import(
+    /* @vite-ignore */
+    `${t}/${e}`
+  ),
+  resolveWasm: ({ baseUrl: t, path: e }) => fetch(`${t}/${e}`)
 };
-let p = null, f = null, o = { ...L };
-const g = /* @__PURE__ */ new Map(), j = new Set($);
-let l = null, b = null;
+let p = null, m = null, o = { ...v };
+const h = /* @__PURE__ */ new Map(), T = new Set($);
+let l = null, u = null;
 async function _() {
   if (o.pluginsUrl)
-    return b || (b = (async () => {
+    return u || (u = (async () => {
       console.debug(`[arborium] Loading local plugins manifest from: ${o.pluginsUrl}`);
-      const s = await fetch(o.pluginsUrl);
-      if (!s.ok)
-        throw new Error(`Failed to load plugins.json: ${s.status}`);
-      l = await s.json(), console.debug(`[arborium] Loaded local manifest with ${l?.entries.length} entries`);
-    })(), b);
+      const t = await fetch(o.pluginsUrl);
+      if (!t.ok)
+        throw new Error(`Failed to load plugins.json: ${t.status}`);
+      l = await t.json(), console.debug(`[arborium] Loaded local manifest with ${l?.entries.length} entries`);
+    })(), u);
 }
-function U(s) {
+function U(t) {
   if (l) {
-    const a = l.entries.find((r) => r.language === s);
-    if (a)
-      return a.local_js.substring(0, a.local_js.lastIndexOf("/"));
+    const s = l.entries.find((r) => r.language === t);
+    if (s)
+      return s.local_js.substring(0, s.local_js.lastIndexOf("/"));
   }
-  const e = o.cdn, t = o.version;
+  const e = o.cdn, a = o.version;
   let n;
-  return e === "jsdelivr" ? n = "https://cdn.jsdelivr.net/npm" : e === "unpkg" ? n = "https://unpkg.com" : n = e, `${n}/@arborium/${s}@${t}`;
+  return e === "jsdelivr" ? n = "https://cdn.jsdelivr.net/npm" : e === "unpkg" ? n = "https://unpkg.com" : n = e, `${n}/@arborium/${t}@${a}`;
 }
-async function w(s) {
-  const e = g.get(s);
+async function w(t) {
+  const e = h.get(t);
   if (e)
-    return console.debug(`[arborium] Grammar '${s}' found in cache`), e;
-  if (await _(), !j.has(s) && !l?.entries.some((t) => t.language === s))
-    return console.debug(`[arborium] Grammar '${s}' not available`), null;
+    return console.debug(`[arborium] Grammar '${t}' found in cache`), e;
+  if (await _(), !T.has(t) && !l?.entries.some((a) => a.language === t))
+    return console.debug(`[arborium] Grammar '${t}' not available`), null;
   try {
-    const t = U(s), n = `${t}/grammar.js`, a = `${t}/grammar_bg.wasm`;
-    console.debug(`[arborium] Loading grammar '${s}' from ${n}`);
-    const r = await import(
-      /* @vite-ignore */
-      n
-    );
-    await r.default(a);
-    const i = r.language_id();
-    i !== s && console.warn(`[arborium] Language ID mismatch: expected '${s}', got '${i}'`);
-    const c = r.injection_languages(), y = {
-      languageId: s,
+    const a = U(t), n = o.resolveJs === v.resolveJs ? ` from ${a}/grammar.js` : "";
+    console.debug(`[arborium] Loading grammar '${t}'${n}`);
+    const s = await o.resolveJs({ language: t, baseUrl: a, path: "grammar.js" }), r = await o.resolveWasm({ language: t, baseUrl: a, path: "grammar_bg.wasm" });
+    await s.default({ module_or_path: r });
+    const i = s.language_id();
+    i !== t && console.warn(`[arborium] Language ID mismatch: expected '${t}', got '${i}'`);
+    const c = s.injection_languages(), k = {
+      languageId: t,
       injectionLanguages: c,
-      module: r,
-      parse: (k) => {
-        const m = r.create_session();
+      module: s,
+      parse: (j) => {
+        const d = s.create_session();
         try {
-          r.set_text(m, k);
-          const u = r.parse(m);
+          s.set_text(d, j);
+          const g = s.parse(d);
           return {
-            spans: u.spans || [],
-            injections: u.injections || []
+            spans: g.spans || [],
+            injections: g.injections || []
           };
-        } catch (u) {
-          return console.error("[arborium] Parse error:", u), { spans: [], injections: [] };
+        } catch (g) {
+          return console.error("[arborium] Parse error:", g), { spans: [], injections: [] };
         } finally {
-          r.free_session(m);
+          s.free_session(d);
         }
       }
     };
-    return g.set(s, y), console.debug(`[arborium] Grammar '${s}' loaded successfully`), y;
-  } catch (t) {
-    return console.error(`[arborium] Failed to load grammar '${s}':`, t), null;
+    return h.set(t, k), console.debug(`[arborium] Grammar '${t}' loaded successfully`), k;
+  } catch (a) {
+    return console.error(`[arborium] Failed to load grammar '${t}':`, a), null;
   }
 }
-const d = /* @__PURE__ */ new Map();
-let T = 1;
-function E() {
+const b = /* @__PURE__ */ new Map();
+let E = 1;
+function W() {
   window.arboriumHost = {
     /** Check if a language is available (sync) */
-    isLanguageAvailable(s) {
-      return j.has(s) || g.has(s);
+    isLanguageAvailable(t) {
+      return T.has(t) || h.has(t);
     },
     /** Load a grammar and return a handle (async) */
-    async loadGrammar(s) {
-      const e = await w(s);
+    async loadGrammar(t) {
+      const e = await w(t);
       if (!e) return 0;
-      for (const [n, a] of d)
-        if (a === e) return n;
-      const t = T++;
-      return d.set(t, e), t;
+      for (const [n, s] of b)
+        if (s === e) return n;
+      const a = E++;
+      return b.set(a, e), a;
     },
     /** Parse text using a grammar handle (sync) */
-    parse(s, e) {
-      const t = d.get(s);
-      return t ? t.parse(e) : { spans: [], injections: [] };
+    parse(t, e) {
+      const a = b.get(t);
+      return a ? a.parse(e) : { spans: [], injections: [] };
     }
   };
 }
 function S() {
   if (o.hostUrl)
     return o.hostUrl;
-  const s = o.cdn, e = o.version;
-  let t;
-  s === "jsdelivr" ? t = "https://cdn.jsdelivr.net/npm" : s === "unpkg" ? t = "https://unpkg.com" : t = s;
+  const t = o.cdn, e = o.version;
+  let a;
+  t === "jsdelivr" ? a = "https://cdn.jsdelivr.net/npm" : t === "unpkg" ? a = "https://unpkg.com" : a = t;
   const n = e === "latest" ? "" : `@${e}`;
-  return `${t}/@arborium/arborium${n}/dist`;
+  return `${a}/@arborium/arborium${n}/dist`;
 }
-async function W() {
-  return p || f || (f = (async () => {
-    E();
-    const s = S(), e = `${s}/arborium_host.js`, t = `${s}/arborium_host_bg.wasm`;
+async function q() {
+  return p || m || (m = (async () => {
+    W();
+    const t = S(), e = `${t}/arborium_host.js`, a = `${t}/arborium_host_bg.wasm`;
     console.debug(`[arborium] Loading host from ${e}`);
     try {
       const n = await import(
         /* @vite-ignore */
         e
       );
-      return await n.default(t), p = {
+      return await n.default(a), p = {
         highlight: n.highlight,
         isLanguageAvailable: n.isLanguageAvailable
       }, console.debug("[arborium] Host loaded successfully"), p;
     } catch (n) {
       return console.error("[arborium] Failed to load host:", n), null;
     }
-  })(), f);
+  })(), m);
 }
-async function R(s, e, t) {
-  const n = await W();
+async function H(t, e, a) {
+  const n = await q();
   if (n)
     try {
-      return n.highlight(s, e);
+      return n.highlight(t, e);
     } catch (i) {
       console.warn("Host highlight failed, falling back to JS:", i);
     }
-  const a = await w(s);
-  if (!a)
-    return h(e);
-  const r = a.parse(e);
-  return v(e, r.spans);
+  const s = await w(t);
+  if (!s)
+    return f(e);
+  const r = s.parse(e);
+  return y(e, r.spans);
 }
-async function H(s, e) {
-  const t = await w(s);
-  if (!t) return null;
-  const { module: n } = t;
+async function M(t, e) {
+  const a = await w(t);
+  if (!a) return null;
+  const { module: n } = a;
   return {
-    languageId: () => t.languageId,
-    injectionLanguages: () => t.injectionLanguages,
-    highlight: async (a) => {
-      const r = t.parse(a);
-      return v(a, r.spans);
+    languageId: () => a.languageId,
+    injectionLanguages: () => a.injectionLanguages,
+    highlight: async (s) => {
+      const r = a.parse(s);
+      return y(s, r.spans);
     },
-    parse: (a) => t.parse(a),
+    parse: (s) => a.parse(s),
     createSession: () => {
-      const a = n.create_session();
+      const s = n.create_session();
       return {
-        setText: (r) => n.set_text(a, r),
+        setText: (r) => n.set_text(s, r),
         parse: () => {
           try {
-            const r = n.parse(a);
+            const r = n.parse(s);
             return {
               spans: r.spans || [],
               injections: r.injections || []
@@ -266,35 +620,18 @@ async function H(s, e) {
             return console.error("[arborium] Session parse error:", r), { spans: [], injections: [] };
           }
         },
-        cancel: () => n.cancel(a),
-        free: () => n.free_session(a)
+        cancel: () => n.cancel(s),
+        free: () => n.free_session(s)
       };
     },
     dispose: () => {
     }
   };
 }
-function v(s, e) {
-  const t = [...e].sort((r, i) => r.start - i.start);
-  let n = "", a = 0;
-  for (const r of t) {
-    if (r.start < a) continue;
-    r.start > a && (n += h(s.slice(a, r.start)));
-    const i = C(r.capture), c = h(s.slice(r.start, r.end));
-    i ? n += `<a-${i}>${c}</a-${i}>` : n += c, a = r.end;
-  }
-  return a < s.length && (n += h(s.slice(a))), n;
-}
-function C(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 h(s) {
-  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-}
-function M(s) {
-  return s ? { ...o, ...s } : { ...o };
+function P(t) {
+  return t ? { ...o, ...t } : { ...o };
 }
-const I = [
+const C = [
   [/^#!.*\bpython[23]?\b/, "python"],
   [/^#!.*\bnode\b/, "javascript"],
   [/^#!.*\bdeno\b/, "typescript"],
@@ -307,7 +644,7 @@ const I = [
   [/^#!.*\bsh\b/, "bash"],
   [/^#!.*\blua\b/, "lua"],
   [/^#!.*\bawk\b/, "awk"]
-], q = [
+], I = [
   // Rust - distinctive keywords
   [/\b(fn|impl|trait|pub\s+fn|let\s+mut|&mut|->)\b/, "rust"],
   // Go - distinctive keywords
@@ -367,22 +704,22 @@ const I = [
   // Zig
   [/\b(pub\s+fn|const\s+\w+\s*=|@import\(|comptime)\b/, "zig"]
 ];
-function P(s) {
-  const e = s.split(`
+function A(t) {
+  const e = t.split(`
 `)[0];
-  for (const [t, n] of I)
-    if (t.test(e))
+  for (const [a, n] of C)
+    if (a.test(e))
       return n;
-  for (const [t, n] of q)
-    if (t.test(s))
+  for (const [a, n] of I)
+    if (a.test(t))
       return n;
   return null;
 }
-function A(s) {
-  const e = s.match(/\blanguage-(\w+)\b/);
+function G(t) {
+  const e = t.match(/\blanguage-(\w+)\b/);
   if (e) return e[1];
-  const t = s.match(/\blang-(\w+)\b/);
-  if (t) return t[1];
+  const a = t.match(/\blang-(\w+)\b/);
+  if (a) return a[1];
   const n = /* @__PURE__ */ new Set([
     "rust",
     "javascript",
@@ -419,12 +756,12 @@ function A(s) {
     "console",
     "sh"
   ]);
-  for (const a of s.split(/\s+/))
-    if (n.has(a.toLowerCase()))
-      return a.toLowerCase();
+  for (const s of t.split(/\s+/))
+    if (n.has(s.toLowerCase()))
+      return s.toLowerCase();
   return null;
 }
-function G(s) {
+function F(t) {
   const e = {
     js: "javascript",
     ts: "typescript",
@@ -445,18 +782,19 @@ function G(s) {
     plaintext: "text",
     plain: "text",
     txt: "text"
-  }, t = s.toLowerCase();
-  return e[t] || t;
+  }, a = t.toLowerCase();
+  return e[a] || a;
 }
 export {
   $ as availableLanguages,
-  P as detectLanguage,
-  A as extractLanguageFromClass,
-  M as getConfig,
-  R as highlight,
-  H as loadGrammar,
-  G as normalizeLanguage,
+  A as detectLanguage,
+  G as extractLanguageFromClass,
+  P as getConfig,
+  H as highlight,
+  R as highlights,
+  M as loadGrammar,
+  F as normalizeLanguage,
   x as pluginVersion,
-  v as spansToHtml
+  y as spansToHtml
 };
 //# sourceMappingURL=arborium.js.map