@arborium/arborium 2.4.7 → 2.6.0

package/dist/arborium.js

@@ -1,4 +1,4 @@
-const x = "2.4.7", $ = [
+const L = "2.6.0", _ = [
   "ada",
   "agda",
   "asciidoc",
@@ -71,6 +71,7 @@ const x = "2.4.7", $ = [
   "scala",
   "scheme",
   "scss",
+  "solidity",
   "sparql",
   "sql",
   "ssh-config",
@@ -97,204 +98,544 @@ const x = "2.4.7", $ = [
   "yuri",
   "zig",
   "zsh"
-], L = {
+], M = [
+  {
+    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, a) {
+  const r = [...a].sort((n, o) => n.start - o.start);
+  let e = "", s = 0;
+  for (const n of r) {
+    if (n.start < s) continue;
+    n.start > s && (e += u(t.slice(s, n.start)));
+    const o = U(n.capture), i = u(t.slice(n.start, n.end));
+    o ? e += `<a-${o}>${i}</a-${o}>` : e += i, s = n.end;
+  }
+  return s < t.length && (e += u(t.slice(s))), e;
+}
+function U(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 u(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",
   cdn: "jsdelivr",
-  version: x,
+  version: L,
   // Precise version from manifest
   pluginsUrl: "",
   // Empty means use bundled manifest
-  hostUrl: ""
+  hostUrl: "",
   // Empty means use CDN based on version
+  resolveJs: ({ baseUrl: t, path: a }) => import(
+    /* @vite-ignore */
+    `${t}/${a}`
+  ),
+  resolveWasm: ({ baseUrl: t, path: a }) => fetch(`${t}/${a}`)
 };
-let p = null, f = null, o = { ...L };
-const g = /* @__PURE__ */ new Map(), j = new Set($);
-let l = null, b = null;
-async function _() {
-  if (o.pluginsUrl)
-    return b || (b = (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);
+let p = null, g = null, d = { ...v };
+const h = /* @__PURE__ */ new Map(), T = new Set(_);
+let l = null, m = null;
+async function E(t) {
+  if (t.pluginsUrl)
+    return m || (m = (async () => {
+      console.debug(`[arborium] Loading local plugins manifest from: ${t.pluginsUrl}`);
+      const a = await fetch(t.pluginsUrl);
+      if (!a.ok)
+        throw new Error(`Failed to load plugins.json: ${a.status}`);
+      l = await a.json(), console.debug(`[arborium] Loaded local manifest with ${l?.entries.length} entries`);
+    })(), m);
 }
-function U(s) {
+function W(t, a) {
   if (l) {
-    const a = l.entries.find((r) => r.language === s);
-    if (a)
-      return a.local_js.substring(0, a.local_js.lastIndexOf("/"));
+    const n = l.entries.find((o) => o.language === t);
+    if (n)
+      return n.local_js.substring(0, n.local_js.lastIndexOf("/"));
   }
-  const e = o.cdn, t = 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}`;
+  const r = a.cdn, e = a.version;
+  let s;
+  return r === "jsdelivr" ? s = "https://cdn.jsdelivr.net/npm" : r === "unpkg" ? s = "https://unpkg.com" : s = r, `${s}/@arborium/${t}@${e}`;
 }
-async function w(s) {
-  const e = g.get(s);
-  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;
+async function w(t, a) {
+  const r = h.get(t);
+  if (r)
+    return console.debug(`[arborium] Grammar '${t}' found in cache`), r;
+  if (await E(a), !T.has(t) && !l?.entries.some((e) => e.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,
-      injectionLanguages: c,
-      module: r,
-      parse: (k) => {
-        const m = r.create_session();
+    const e = W(t, a), s = a.resolveJs === v.resolveJs ? ` from ${e}/grammar.js` : "";
+    console.debug(`[arborium] Loading grammar '${t}'${s}`);
+    const n = await a.resolveJs({ language: t, baseUrl: e, path: "grammar.js" }), o = await a.resolveWasm({ language: t, baseUrl: e, path: "grammar_bg.wasm" });
+    await n.default({ module_or_path: o });
+    const i = n.language_id();
+    i !== t && console.warn(`[arborium] Language ID mismatch: expected '${t}', got '${i}'`);
+    const x = n.injection_languages(), k = {
+      languageId: t,
+      injectionLanguages: x,
+      module: n,
+      parse: ($) => {
+        const b = n.create_session();
         try {
-          r.set_text(m, k);
-          const u = r.parse(m);
+          n.set_text(b, $);
+          const c = n.parse(b);
           return {
-            spans: u.spans || [],
-            injections: u.injections || []
+            spans: c.spans || [],
+            injections: c.injections || []
           };
-        } catch (u) {
-          return console.error("[arborium] Parse error:", u), { spans: [], injections: [] };
+        } catch (c) {
+          return console.error("[arborium] Parse error:", c), { spans: [], injections: [] };
         } finally {
-          r.free_session(m);
+          n.free_session(b);
         }
       }
     };
-    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 (e) {
+    return console.error(`[arborium] Failed to load grammar '${t}':`, e), null;
   }
 }
-const d = /* @__PURE__ */ new Map();
-let T = 1;
-function E() {
+const f = /* @__PURE__ */ new Map();
+let C = 1;
+function S(t) {
   window.arboriumHost = {
     /** Check if a language is available (sync) */
-    isLanguageAvailable(s) {
-      return j.has(s) || g.has(s);
+    isLanguageAvailable(a) {
+      return T.has(a) || h.has(a);
     },
     /** Load a grammar and return a handle (async) */
-    async loadGrammar(s) {
-      const e = await w(s);
-      if (!e) return 0;
-      for (const [n, a] of d)
-        if (a === e) return n;
-      const t = T++;
-      return d.set(t, e), t;
+    async loadGrammar(a) {
+      const r = await w(a, t);
+      if (!r) return 0;
+      for (const [s, n] of f)
+        if (n === r) return s;
+      const e = C++;
+      return f.set(e, r), e;
     },
     /** Parse text using a grammar handle (sync) */
-    parse(s, e) {
-      const t = d.get(s);
-      return t ? t.parse(e) : { spans: [], injections: [] };
+    parse(a, r) {
+      const e = f.get(a);
+      return e ? e.parse(r) : { 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 n = e === "latest" ? "" : `@${e}`;
-  return `${t}/@arborium/arborium${n}/dist`;
+function q(t) {
+  if (t.hostUrl)
+    return t.hostUrl;
+  const a = t.cdn, r = t.version;
+  let e;
+  a === "jsdelivr" ? e = "https://cdn.jsdelivr.net/npm" : a === "unpkg" ? e = "https://unpkg.com" : e = a;
+  const s = r === "latest" ? "" : `@${r}`;
+  return `${e}/@arborium/arborium${s}/dist`;
 }
-async function W() {
-  return p || f || (f = (async () => {
-    E();
-    const s = S(), e = `${s}/arborium_host.js`, t = `${s}/arborium_host_bg.wasm`;
-    console.debug(`[arborium] Loading host from ${e}`);
+async function I(t) {
+  return p || g || (g = (async () => {
+    S(t);
+    const a = q(t), r = `${a}/arborium_host.js`, e = `${a}/arborium_host_bg.wasm`;
+    console.debug(`[arborium] Loading host from ${r}`);
     try {
-      const n = await import(
+      const s = await import(
         /* @vite-ignore */
-        e
+        r
       );
-      return await n.default(t), p = {
-        highlight: n.highlight,
-        isLanguageAvailable: n.isLanguageAvailable
+      return await s.default(e), p = {
+        highlight: s.highlight,
+        isLanguageAvailable: s.isLanguageAvailable
       }, console.debug("[arborium] Host loaded successfully"), p;
-    } catch (n) {
-      return console.error("[arborium] Failed to load host:", n), null;
+    } catch (s) {
+      return console.error("[arborium] Failed to load host:", s), null;
     }
-  })(), f);
+  })(), g);
 }
-async function R(s, e, t) {
-  const n = await W();
-  if (n)
+async function P(t, a, r) {
+  const e = j(r), s = await I(e);
+  if (s)
     try {
-      return n.highlight(s, e);
+      return s.highlight(t, a);
     } 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 n = await w(t, e);
+  if (!n)
+    return u(a);
+  const o = n.parse(a);
+  return y(a, o.spans);
 }
-async function H(s, e) {
-  const t = await w(s);
-  if (!t) return null;
-  const { module: n } = t;
+async function A(t, a) {
+  const r = j(a), e = await w(t, r);
+  if (!e) return null;
+  const { module: s } = e;
   return {
-    languageId: () => t.languageId,
-    injectionLanguages: () => t.injectionLanguages,
-    highlight: async (a) => {
-      const r = t.parse(a);
-      return v(a, r.spans);
+    languageId: () => e.languageId,
+    injectionLanguages: () => e.injectionLanguages,
+    highlight: async (n) => {
+      const o = e.parse(n);
+      return y(n, o.spans);
     },
-    parse: (a) => t.parse(a),
+    parse: (n) => e.parse(n),
     createSession: () => {
-      const a = n.create_session();
+      const n = s.create_session();
       return {
-        setText: (r) => n.set_text(a, r),
+        setText: (o) => s.set_text(n, o),
         parse: () => {
           try {
-            const r = n.parse(a);
+            const o = s.parse(n);
             return {
-              spans: r.spans || [],
-              injections: r.injections || []
+              spans: o.spans || [],
+              injections: o.injections || []
             };
-          } catch (r) {
-            return console.error("[arborium] Session parse error:", r), { spans: [], injections: [] };
+          } catch (o) {
+            return console.error("[arborium] Session parse error:", o), { spans: [], injections: [] };
           }
         },
-        cancel: () => n.cancel(a),
-        free: () => n.free_session(a)
+        cancel: () => s.cancel(n),
+        free: () => s.free_session(n)
       };
     },
     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 j(t) {
+  return t ? { ...d, ...t } : { ...d };
 }
-function M(s) {
-  return s ? { ...o, ...s } : { ...o };
+function G(t) {
+  d = { ...d, ...t };
 }
-const I = [
+const R = [
   [/^#!.*\bpython[23]?\b/, "python"],
   [/^#!.*\bnode\b/, "javascript"],
   [/^#!.*\bdeno\b/, "typescript"],
@@ -307,7 +648,7 @@ const I = [
   [/^#!.*\bsh\b/, "bash"],
   [/^#!.*\blua\b/, "lua"],
   [/^#!.*\bawk\b/, "awk"]
-], q = [
+], H = [
   // Rust - distinctive keywords
   [/\b(fn|impl|trait|pub\s+fn|let\s+mut|&mut|->)\b/, "rust"],
   // Go - distinctive keywords
@@ -367,23 +708,23 @@ const I = [
   // Zig
   [/\b(pub\s+fn|const\s+\w+\s*=|@import\(|comptime)\b/, "zig"]
 ];
-function P(s) {
-  const e = s.split(`
+function F(t) {
+  const a = t.split(`
 `)[0];
-  for (const [t, n] of I)
-    if (t.test(e))
-      return n;
-  for (const [t, n] of q)
-    if (t.test(s))
-      return n;
+  for (const [r, e] of R)
+    if (r.test(a))
+      return e;
+  for (const [r, e] of H)
+    if (r.test(t))
+      return e;
   return null;
 }
-function A(s) {
-  const e = s.match(/\blanguage-(\w+)\b/);
-  if (e) return e[1];
-  const t = s.match(/\blang-(\w+)\b/);
-  if (t) return t[1];
-  const n = /* @__PURE__ */ new Set([
+function O(t) {
+  const a = t.match(/\blanguage-(\w+)\b/);
+  if (a) return a[1];
+  const r = t.match(/\blang-(\w+)\b/);
+  if (r) return r[1];
+  const e = /* @__PURE__ */ new Set([
     "rust",
     "javascript",
     "typescript",
@@ -419,13 +760,13 @@ 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 (e.has(s.toLowerCase()))
+      return s.toLowerCase();
   return null;
 }
-function G(s) {
-  const e = {
+function z(t) {
+  const a = {
     js: "javascript",
     ts: "typescript",
     py: "python",
@@ -445,18 +786,20 @@ function G(s) {
     plaintext: "text",
     plain: "text",
     txt: "text"
-  }, t = s.toLowerCase();
-  return e[t] || t;
+  }, r = t.toLowerCase();
+  return a[r] || r;
 }
 export {
-  $ as availableLanguages,
-  P as detectLanguage,
-  A as extractLanguageFromClass,
-  M as getConfig,
-  R as highlight,
-  H as loadGrammar,
-  G as normalizeLanguage,
-  x as pluginVersion,
-  v as spansToHtml
+  _ as availableLanguages,
+  F as detectLanguage,
+  O as extractLanguageFromClass,
+  j as getConfig,
+  P as highlight,
+  M as highlights,
+  A as loadGrammar,
+  z as normalizeLanguage,
+  L as pluginVersion,
+  G as setConfig,
+  y as spansToHtml
 };
 //# sourceMappingURL=arborium.js.map