@arborium/arborium 2.10.0 → 2.11.0

package/dist/arborium.js

@@ -1,4 +1,4 @@
-const U = "2.10.0", _ = [
+const x = "2.11.0", $ = [
   "ada",
   "agda",
   "asciidoc",
@@ -78,6 +78,7 @@ const U = "2.10.0", _ = [
   "sql",
   "ssh-config",
   "starlark",
+  "styx",
   "svelte",
   "swift",
   "textproto",
@@ -100,7 +101,7 @@ const U = "2.10.0", _ = [
   "yuri",
   "zig",
   "zsh"
-], H = [
+], R = [
   {
     name: "attribute",
     tag: "at"
@@ -433,215 +434,201 @@ const U = "2.10.0", _ = [
     name: "boolean",
     tag: "cb"
   }
-], T = new TextEncoder();
-function E(t) {
-  const e = T.encode(t), a = new Uint32Array(e.length + 1);
-  let s = 0, n = 0;
-  for (const r of t) {
-    a[s] = n;
-    const o = T.encode(r).length;
-    for (let i = 1; i < o; i++)
-      a[s + i] = n;
-    s += o, n += r.codePointAt(0) >= 65536 ? 2 : 1;
-  }
-  return a[s] = n, a;
-}
-function x(t, e) {
-  const a = E(t), n = [...e.map((i) => ({
-    ...i,
-    start: a[i.start] ?? i.start,
-    end: a[i.end] ?? i.end
-  }))].sort((i, l) => i.start - l.start);
-  let r = "", o = 0;
-  for (const i of n) {
-    if (i.start < o) continue;
-    i.start > o && (r += f(t.slice(o, i.start)));
-    const l = S(i.capture), m = f(t.slice(i.start, i.end));
-    l ? r += `<a-${l}>${m}</a-${l}>` : r += m, o = i.end;
-  }
-  return o < t.length && (r += f(t.slice(o))), r;
-}
-function S(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;");
+];
+function L(e) {
+  return e.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
-const j = {
+const y = {
   manual: !1,
   theme: "one-dark",
   selector: "pre code",
   cdn: "jsdelivr",
-  version: U,
+  version: x,
   // Precise version from manifest
   pluginsUrl: "",
   // Empty means use bundled manifest
   hostUrl: "",
   // Empty means use CDN based on version
-  resolveJs: ({ baseUrl: t, path: e }) => import(
+  resolveJs: ({ baseUrl: e, path: t }) => import(
     /* @vite-ignore */
-    `${t}/${e}`
+    `${e}/${t}`
   ),
-  resolveWasm: ({ baseUrl: t, path: e }) => fetch(`${t}/${e}`)
+  resolveWasm: ({ baseUrl: e, path: t }) => fetch(`${e}/${t}`)
 };
-let u = null, g = null, b = { ...j };
-const k = /* @__PURE__ */ new Map(), w = /* @__PURE__ */ new Map(), $ = new Set(_);
-let c = null, d = null;
-async function W(t) {
-  if (t.pluginsUrl)
-    return d || (d = (async () => {
-      console.debug(`[arborium] Loading local plugins manifest from: ${t.pluginsUrl}`);
-      const e = await fetch(t.pluginsUrl);
-      if (!e.ok)
-        throw new Error(`Failed to load plugins.json: ${e.status}`);
-      c = await e.json(), console.debug(`[arborium] Loaded local manifest with ${c?.entries.length} entries`);
-    })(), d);
+let p = null, m = null, g = { ...y };
+const h = /* @__PURE__ */ new Map(), b = /* @__PURE__ */ new Map(), k = new Set($);
+let c = null, u = null;
+async function _(e) {
+  if (e.pluginsUrl)
+    return u || (u = (async () => {
+      console.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}`);
+      c = await t.json(), console.debug(`[arborium] Loaded local manifest with ${c?.entries.length} entries`);
+    })(), u);
 }
-function C(t, e) {
+function U(e, t) {
   if (c) {
-    const r = c.entries.find((o) => o.language === t);
+    const r = c.entries.find((o) => o.language === e);
     if (r)
       return r.local_js.substring(0, r.local_js.lastIndexOf("/"));
   }
-  const a = e.cdn, s = e.version;
-  let n;
-  return a === "jsdelivr" ? n = "https://cdn.jsdelivr.net/npm" : a === "unpkg" ? n = "https://unpkg.com" : n = a, `${n}/@arborium/${t}@${s}`;
+  const n = t.cdn, s = t.version;
+  let a;
+  return n === "jsdelivr" ? a = "https://cdn.jsdelivr.net/npm" : n === "unpkg" ? a = "https://unpkg.com" : a = n, `${a}/@arborium/${e}@${s}`;
 }
-async function v(t, e) {
-  const a = k.get(t);
-  if (a)
-    return console.debug(`[arborium] Grammar '${t}' found in cache`), a;
-  const s = w.get(t);
+async function v(e, t) {
+  const n = h.get(e);
+  if (n)
+    return console.debug(`[arborium] Grammar '${e}' found in cache`), n;
+  const s = b.get(e);
   if (s)
-    return console.debug(`[arborium] Grammar '${t}' already loading, waiting...`), s;
-  const n = I(t, e);
-  w.set(t, n);
+    return console.debug(`[arborium] Grammar '${e}' already loading, waiting...`), s;
+  const a = E(e, t);
+  b.set(e, a);
   try {
-    return await n;
+    return await a;
   } finally {
-    w.delete(t);
+    b.delete(e);
   }
 }
-async function I(t, e) {
-  if (await W(e), !$.has(t) && !c?.entries.some((a) => a.language === t))
-    return console.debug(`[arborium] Grammar '${t}' not available`), null;
+async function E(e, t) {
+  if (await _(t), !k.has(e) && !c?.entries.some((n) => n.language === e))
+    return console.debug(`[arborium] Grammar '${e}' not available`), null;
   try {
-    const a = C(t, e), s = e.resolveJs === j.resolveJs ? ` from ${a}/grammar.js` : "";
-    console.debug(`[arborium] Loading grammar '${t}'${s}`);
-    const n = await e.resolveJs({ language: t, baseUrl: a, path: "grammar.js" }), r = await e.resolveWasm({ language: t, baseUrl: a, path: "grammar_bg.wasm" });
-    await n.default({ module_or_path: r });
-    const o = n.language_id();
-    o !== t && console.warn(`[arborium] Language ID mismatch: expected '${t}', got '${o}'`);
-    const i = n.injection_languages(), l = {
-      languageId: t,
-      injectionLanguages: i,
-      module: n,
-      parse: (m) => {
-        const h = n.create_session();
+    const n = U(e, t), s = t.resolveJs === y.resolveJs ? ` from ${n}/grammar.js` : "";
+    console.debug(`[arborium] Loading grammar '${e}'${s}`);
+    const a = await t.resolveJs({
+      language: e,
+      baseUrl: n,
+      path: "grammar.js"
+    }), r = await t.resolveWasm({ language: e, baseUrl: n, path: "grammar_bg.wasm" });
+    await a.default({ module_or_path: r });
+    const o = a.language_id();
+    o !== e && console.warn(`[arborium] Language ID mismatch: expected '${e}', got '${o}'`);
+    const j = a.injection_languages(), w = {
+      languageId: e,
+      injectionLanguages: j,
+      module: a,
+      // UTF-8 parsing for Rust host
+      parseUtf8: (d) => {
+        const l = a.create_session();
         try {
-          n.set_text(h, m);
-          const p = n.parse(h);
+          a.set_text(l, d);
+          const i = a.parse(l);
           return {
-            spans: p.spans || [],
-            injections: p.injections || []
+            spans: i.spans || [],
+            injections: i.injections || []
           };
-        } catch (p) {
-          return console.error("[arborium] Parse error:", p), { spans: [], injections: [] };
+        } catch (i) {
+          return console.error("[arborium] Parse error:", i), { spans: [], injections: [] };
         } finally {
-          n.free_session(h);
+          a.free_session(l);
+        }
+      },
+      // UTF-16 parsing for JavaScript public API
+      parseUtf16: (d) => {
+        const l = a.create_session();
+        try {
+          a.set_text(l, d);
+          const i = a.parse_utf16(l);
+          return {
+            spans: i.spans || [],
+            injections: i.injections || []
+          };
+        } catch (i) {
+          return console.error("[arborium] Parse error:", i), { spans: [], injections: [] };
+        } finally {
+          a.free_session(l);
         }
       }
     };
-    return k.set(t, l), console.debug(`[arborium] Grammar '${t}' loaded successfully`), l;
-  } catch (a) {
-    return console.error(`[arborium] Failed to load grammar '${t}':`, a), null;
+    return h.set(e, w), console.debug(`[arborium] Grammar '${e}' loaded successfully`), w;
+  } catch (n) {
+    return console.error(`[arborium] Failed to load grammar '${e}':`, n), null;
   }
 }
-const y = /* @__PURE__ */ new Map();
+const f = /* @__PURE__ */ new Map();
 let P = 1;
-function q(t) {
+function q(e) {
   window.arboriumHost = {
     /** Check if a language is available (sync) */
-    isLanguageAvailable(e) {
-      return $.has(e) || k.has(e);
+    isLanguageAvailable(t) {
+      return k.has(t) || h.has(t);
     },
     /** Load a grammar and return a handle (async) */
-    async loadGrammar(e) {
-      const a = await v(e, t);
-      if (!a) return 0;
-      for (const [n, r] of y)
-        if (r === a) return n;
+    async loadGrammar(t) {
+      const n = await v(t, e);
+      if (!n) return 0;
+      for (const [a, r] of f)
+        if (r === n) return a;
       const s = P++;
-      return y.set(s, a), s;
+      return f.set(s, n), s;
     },
-    /** Parse text using a grammar handle (sync) */
-    parse(e, a) {
-      const s = y.get(e);
-      return s ? s.parse(a) : { spans: [], injections: [] };
+    /** Parse text using a grammar handle (sync) - returns UTF-8 offsets for Rust host */
+    parse(t, n) {
+      const s = f.get(t);
+      return s ? s.parseUtf8(n) : { spans: [], injections: [] };
     }
   };
 }
-function M(t) {
-  if (t.hostUrl)
-    return t.hostUrl;
-  const e = t.cdn, a = t.version;
+function C(e) {
+  if (e.hostUrl)
+    return e.hostUrl;
+  const t = e.cdn, n = e.version;
   let s;
-  e === "jsdelivr" ? s = "https://cdn.jsdelivr.net/npm" : e === "unpkg" ? s = "https://unpkg.com" : s = e;
-  const n = a === "latest" ? "" : `@${a}`;
-  return `${s}/@arborium/arborium${n}/dist`;
+  t === "jsdelivr" ? s = "https://cdn.jsdelivr.net/npm" : t === "unpkg" ? s = "https://unpkg.com" : s = t;
+  const a = n === "latest" ? "" : `@${n}`;
+  return `${s}/@arborium/arborium${a}/dist`;
 }
-async function A(t) {
-  return u || g || (g = (async () => {
-    q(t);
-    const e = M(t), a = `${e}/arborium_host.js`, s = `${e}/arborium_host_bg.wasm`;
-    console.debug(`[arborium] Loading host from ${a}`);
+async function I(e) {
+  return p || m || (m = (async () => {
+    q(e);
+    const t = C(e), n = `${t}/arborium_host.js`, s = `${t}/arborium_host_bg.wasm`;
+    console.debug(`[arborium] Loading host from ${n}`);
     try {
-      const n = await import(
+      const a = await import(
         /* @vite-ignore */
-        a
+        n
       );
-      return await n.default(s), u = {
-        highlight: n.highlight,
-        isLanguageAvailable: n.isLanguageAvailable
-      }, console.debug("[arborium] Host loaded successfully"), u;
-    } catch (n) {
-      return console.error("[arborium] Failed to load host:", n), null;
+      return await a.default(s), p = {
+        highlight: a.highlight,
+        isLanguageAvailable: a.isLanguageAvailable
+      }, console.debug("[arborium] Host loaded successfully"), p;
+    } catch (a) {
+      return console.error("[arborium] Failed to load host:", a), null;
     }
-  })(), g);
+  })(), m);
 }
-async function F(t, e, a) {
-  const s = L(a), n = await A(s);
-  if (n)
+async function S(e, t, n) {
+  const s = T(n), a = await I(s);
+  if (a)
     try {
-      return n.highlight(t, e);
-    } catch (i) {
-      console.warn("Host highlight failed, falling back to JS:", i);
+      return a.highlight(e, t);
+    } catch (r) {
+      console.error("[arborium] Host highlight failed:", r);
     }
-  const r = await v(t, s);
-  if (!r)
-    return f(e);
-  const o = r.parse(e);
-  return x(e, o.spans);
+  return L(t);
 }
-async function O(t, e) {
-  const a = L(e), s = await v(t, a);
+async function A(e, t) {
+  const n = T(t), s = await v(e, n);
   if (!s) return null;
-  const { module: n } = s;
+  const { module: a } = s;
   return {
     languageId: () => s.languageId,
     injectionLanguages: () => s.injectionLanguages,
-    highlight: async (r) => {
-      const o = s.parse(r);
-      return x(r, o.spans);
-    },
-    parse: (r) => s.parse(r),
+    highlight: async (r) => S(e, r, t),
+    // Public API returns UTF-16 offsets for JavaScript compatibility
+    parse: (r) => s.parseUtf16(r),
     createSession: () => {
-      const r = n.create_session();
+      const r = a.create_session();
       return {
-        setText: (o) => n.set_text(r, o),
+        setText: (o) => a.set_text(r, o),
+        // Session.parse() returns UTF-16 offsets for JavaScript compatibility
         parse: () => {
           try {
-            const o = n.parse(r);
+            const o = a.parse_utf16(r);
             return {
               spans: o.spans || [],
               injections: o.injections || []
@@ -650,19 +637,19 @@ async function O(t, e) {
             return console.error("[arborium] Session parse error:", o), { spans: [], injections: [] };
           }
         },
-        cancel: () => n.cancel(r),
-        free: () => n.free_session(r)
+        cancel: () => a.cancel(r),
+        free: () => a.free_session(r)
       };
     },
     dispose: () => {
     }
   };
 }
-function L(t) {
-  return t ? { ...b, ...t } : { ...b };
+function T(e) {
+  return e ? { ...g, ...e } : { ...g };
 }
-function z(t) {
-  b = { ...b, ...t };
+function H(e) {
+  g = { ...g, ...e };
 }
 const G = [
   [/^#!.*\bpython[23]?\b/, "python"],
@@ -677,7 +664,7 @@ const G = [
   [/^#!.*\bsh\b/, "bash"],
   [/^#!.*\blua\b/, "lua"],
   [/^#!.*\bawk\b/, "awk"]
-], R = [
+], M = [
   // Rust - distinctive keywords
   [/\b(fn|impl|trait|pub\s+fn|let\s+mut|&mut|->)\b/, "rust"],
   // Go - distinctive keywords
@@ -737,22 +724,22 @@ const G = [
   // Zig
   [/\b(pub\s+fn|const\s+\w+\s*=|@import\(|comptime)\b/, "zig"]
 ];
-function N(t) {
-  const e = t.split(`
+function F(e) {
+  const t = e.split(`
 `)[0];
-  for (const [a, s] of G)
-    if (a.test(e))
+  for (const [n, s] of G)
+    if (n.test(t))
       return s;
-  for (const [a, s] of R)
-    if (a.test(t))
+  for (const [n, s] of M)
+    if (n.test(e))
       return s;
   return null;
 }
-function B(t) {
-  const e = t.match(/\blanguage-(\w+)\b/);
-  if (e) return e[1];
-  const a = t.match(/\blang-(\w+)\b/);
-  if (a) return a[1];
+function z(e) {
+  const t = e.match(/\blanguage-(\w+)\b/);
+  if (t) return t[1];
+  const n = e.match(/\blang-(\w+)\b/);
+  if (n) return n[1];
   const s = /* @__PURE__ */ new Set([
     "rust",
     "javascript",
@@ -789,13 +776,13 @@ function B(t) {
     "console",
     "sh"
   ]);
-  for (const n of t.split(/\s+/))
-    if (s.has(n.toLowerCase()))
-      return n.toLowerCase();
+  for (const a of e.split(/\s+/))
+    if (s.has(a.toLowerCase()))
+      return a.toLowerCase();
   return null;
 }
-function J(t) {
-  const e = {
+function N(e) {
+  const t = {
     js: "javascript",
     ts: "typescript",
     py: "python",
@@ -815,20 +802,19 @@ function J(t) {
     plaintext: "text",
     plain: "text",
     txt: "text"
-  }, a = t.toLowerCase();
-  return e[a] || a;
+  }, n = e.toLowerCase();
+  return t[n] || n;
 }
 export {
-  _ as availableLanguages,
-  N as detectLanguage,
-  B as extractLanguageFromClass,
-  L as getConfig,
-  F as highlight,
-  H as highlights,
-  O as loadGrammar,
-  J as normalizeLanguage,
-  U as pluginVersion,
-  z as setConfig,
-  x as spansToHtml
+  $ as availableLanguages,
+  F as detectLanguage,
+  z as extractLanguageFromClass,
+  T as getConfig,
+  S as highlight,
+  R as highlights,
+  A as loadGrammar,
+  N as normalizeLanguage,
+  x as pluginVersion,
+  H as setConfig
 };
 //# sourceMappingURL=arborium.js.map