@arborium/arborium 2.10.0 → 2.12.0

package/dist/arborium.js

@@ -1,4 +1,158 @@
-const U = "2.10.0", _ = [
+const L = [
+  [/^#!.*\bpython[23]?\b/, "python"],
+  [/^#!.*\bnode\b/, "javascript"],
+  [/^#!.*\bdeno\b/, "typescript"],
+  [/^#!.*\bbun\b/, "typescript"],
+  [/^#!.*\bruby\b/, "ruby"],
+  [/^#!.*\bperl\b/, "perl"],
+  [/^#!.*\bphp\b/, "php"],
+  [/^#!.*\bbash\b/, "bash"],
+  [/^#!.*\bzsh\b/, "zsh"],
+  [/^#!.*\bsh\b/, "bash"],
+  [/^#!.*\blua\b/, "lua"],
+  [/^#!.*\bawk\b/, "awk"]
+], $ = [
+  // Rust - distinctive keywords
+  [/\b(fn|impl|trait|pub\s+fn|let\s+mut|&mut|->)\b/, "rust"],
+  // Go - distinctive keywords
+  [/\b(func|package\s+\w+|import\s+\(|go\s+func|chan\s+\w+)\b/, "go"],
+  // Python - distinctive patterns
+  [/\b(def\s+\w+\s*\(|import\s+\w+|from\s+\w+\s+import|class\s+\w+:)\b/, "python"],
+  // TypeScript - distinctive type annotations
+  [/:\s*(string|number|boolean|void)\b|\binterface\s+\w+\s*\{/, "typescript"],
+  // JavaScript - distinctive patterns (after TS check)
+  [/\b(const|let|var)\s+\w+\s*=|function\s+\w+\s*\(|=>\s*\{/, "javascript"],
+  // Ruby - distinctive keywords
+  [/\b(def\s+\w+|end\b|do\s*\|.*\||puts\s+|require\s+['"])\b/, "ruby"],
+  // Java - distinctive patterns
+  [/\b(public\s+class|private\s+\w+|System\.out\.println)\b/, "java"],
+  // C++ - distinctive patterns
+  [/\b(#include\s*<|std::|template\s*<|nullptr|cout\s*<<)\b/, "cpp"],
+  // C - distinctive patterns (after C++ check)
+  [/\b(#include\s*[<"]|printf\s*\(|int\s+main\s*\(|void\s+\w+\s*\()\b/, "c"],
+  // C# - distinctive patterns
+  [/\b(namespace\s+\w+|using\s+System|public\s+static\s+void)\b/, "c-sharp"],
+  // PHP - distinctive patterns
+  [/<\?php|\$\w+\s*=/, "php"],
+  // Swift - distinctive patterns
+  [/\b(func\s+\w+|var\s+\w+:\s*\w+|let\s+\w+:\s*\w+|@objc)\b/, "swift"],
+  // Kotlin - distinctive patterns
+  [/\b(fun\s+\w+|val\s+\w+|var\s+\w+:|data\s+class)\b/, "kotlin"],
+  // Scala - distinctive patterns
+  [/\b(def\s+\w+|val\s+\w+|var\s+\w+|object\s+\w+|case\s+class)\b/, "scala"],
+  // Haskell - distinctive patterns
+  [/\b(module\s+\w+|import\s+qualified|data\s+\w+\s*=|::\s*\w+\s*->)\b/, "haskell"],
+  // Elixir - distinctive patterns
+  [/\b(defmodule\s+\w+|def\s+\w+|defp\s+\w+|\|>)\b/, "elixir"],
+  // Lua - distinctive patterns
+  [/\b(local\s+\w+\s*=|function\s+\w+\.\w+|require\s*\()\b/, "lua"],
+  // SQL - distinctive patterns
+  [/\b(SELECT\s+.*\s+FROM|INSERT\s+INTO|CREATE\s+TABLE|ALTER\s+TABLE)\b/i, "sql"],
+  // Shell/Bash - distinctive patterns
+  [/\b(if\s+\[\s*|then\b|fi\b|echo\s+["']|export\s+\w+=)\b/, "bash"],
+  // YAML - distinctive patterns
+  [/^\s*[\w-]+:\s*[\w\-"'[{]|^---\s*$/, "yaml"],
+  // JSON - distinctive patterns
+  [/^\s*\{[\s\S]*"[\w-]+":\s*/, "json"],
+  // TOML - distinctive patterns
+  [/^\s*\[[\w.-]+\]\s*$|^\s*\w+\s*=\s*["'\d\[]/, "toml"],
+  // HTML - distinctive patterns
+  [/<(!DOCTYPE|html|head|body|div|span|p|a\s)/i, "html"],
+  // CSS - distinctive patterns
+  [/^\s*[\w.#@][\w\s,#.:>+~-]*\{[^}]*\}|@media\s|@import\s/, "css"],
+  // Markdown - distinctive patterns
+  [/^#{1,6}\s+\w|^\s*[-*+]\s+\w|^\s*\d+\.\s+\w|```\w*\n/, "markdown"],
+  // XML - distinctive patterns
+  [/<\?xml|<[\w:-]+\s+xmlns/, "xml"],
+  // Dockerfile
+  [/^FROM\s+\w+|^RUN\s+|^COPY\s+|^ENTRYPOINT\s+/m, "dockerfile"],
+  // Nginx config
+  [/\b(server\s*\{|location\s+[\/~]|proxy_pass\s+)\b/, "nginx"],
+  // Zig
+  [/\b(pub\s+fn|const\s+\w+\s*=|@import\(|comptime)\b/, "zig"]
+];
+function M(e) {
+  const t = e.split(`
+`)[0];
+  for (const [a, s] of L)
+    if (a.test(t))
+      return s;
+  for (const [a, s] of $)
+    if (a.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 s = /* @__PURE__ */ new Set([
+    "rust",
+    "javascript",
+    "typescript",
+    "python",
+    "ruby",
+    "go",
+    "java",
+    "c",
+    "cpp",
+    "csharp",
+    "php",
+    "swift",
+    "kotlin",
+    "scala",
+    "haskell",
+    "elixir",
+    "lua",
+    "sql",
+    "bash",
+    "shell",
+    "yaml",
+    "json",
+    "toml",
+    "html",
+    "css",
+    "xml",
+    "markdown",
+    "dockerfile",
+    "nginx",
+    "zig",
+    "text",
+    "plaintext",
+    "console",
+    "sh"
+  ]);
+  for (const n of e.split(/\s+/))
+    if (s.has(n.toLowerCase()))
+      return n.toLowerCase();
+  return null;
+}
+function H(e) {
+  const t = {
+    js: "javascript",
+    ts: "typescript",
+    py: "python",
+    rb: "ruby",
+    rs: "rust",
+    sh: "bash",
+    shell: "bash",
+    yml: "yaml",
+    cs: "c-sharp",
+    csharp: "c-sharp",
+    "c++": "cpp",
+    "c#": "c-sharp",
+    "f#": "fsharp",
+    dockerfile: "dockerfile",
+    docker: "dockerfile",
+    makefile: "make",
+    plaintext: "text",
+    plain: "text",
+    txt: "text"
+  }, a = e.toLowerCase();
+  return t[a] || a;
+}
+const _ = "2.12.0", U = [
   "ada",
   "agda",
   "asciidoc",
@@ -78,6 +232,7 @@ const U = "2.10.0", _ = [
   "sql",
   "ssh-config",
   "starlark",
+  "styx",
   "svelte",
   "swift",
   "textproto",
@@ -100,7 +255,7 @@ const U = "2.10.0", _ = [
   "yuri",
   "zig",
   "zsh"
-], H = [
+], F = [
   {
     name: "attribute",
     tag: "at"
@@ -433,215 +588,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 E(e) {
+  return e.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
-const j = {
+const T = {
   manual: !1,
   theme: "one-dark",
   selector: "pre code",
   cdn: "jsdelivr",
-  version: U,
+  version: _,
   // 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 = { ...T };
+const y = /* @__PURE__ */ new Map(), h = /* @__PURE__ */ new Map(), d = new Set(U);
+let l = null, u = null;
+async function k(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}`);
+      l = await t.json(), console.debug(`[arborium] Loaded local manifest with ${l?.entries.length} entries`);
+    })(), u);
 }
-function C(t, e) {
-  if (c) {
-    const r = c.entries.find((o) => o.language === t);
+function P(e, t) {
+  if (l) {
+    const r = l.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;
+  const a = t.cdn, s = t.version;
   let n;
-  return a === "jsdelivr" ? n = "https://cdn.jsdelivr.net/npm" : a === "unpkg" ? n = "https://unpkg.com" : n = a, `${n}/@arborium/${t}@${s}`;
+  return a === "jsdelivr" ? n = "https://cdn.jsdelivr.net/npm" : a === "unpkg" ? n = "https://unpkg.com" : n = a, `${n}/@arborium/${e}@${s}`;
 }
-async function v(t, e) {
-  const a = k.get(t);
+async function j(e, t) {
+  const a = y.get(e);
   if (a)
-    return console.debug(`[arborium] Grammar '${t}' found in cache`), a;
-  const s = w.get(t);
+    return console.debug(`[arborium] Grammar '${e}' found in cache`), a;
+  const s = h.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 n = q(e, t);
+  h.set(e, n);
   try {
     return await n;
   } finally {
-    w.delete(t);
+    h.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 q(e, t) {
+  if (await k(t), !d.has(e) && !l?.entries.some((a) => a.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" });
+    const a = P(e, t), s = t.resolveJs === T.resolveJs ? ` from ${a}/grammar.js` : "";
+    console.debug(`[arborium] Loading grammar '${e}'${s}`);
+    const n = await t.resolveJs({
+      language: e,
+      baseUrl: a,
+      path: "grammar.js"
+    }), r = await t.resolveWasm({ language: e, 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,
+    o !== e && console.warn(`[arborium] Language ID mismatch: expected '${e}', got '${o}'`);
+    const x = n.injection_languages(), v = {
+      languageId: e,
+      injectionLanguages: x,
       module: n,
-      parse: (m) => {
-        const h = n.create_session();
+      // UTF-8 parsing for Rust host
+      parseUtf8: (f) => {
+        const c = n.create_session();
         try {
-          n.set_text(h, m);
-          const p = n.parse(h);
+          n.set_text(c, f);
+          const i = n.parse(c);
           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);
+          n.free_session(c);
+        }
+      },
+      // UTF-16 parsing for JavaScript public API
+      parseUtf16: (f) => {
+        const c = n.create_session();
+        try {
+          n.set_text(c, f);
+          const i = n.parse_utf16(c);
+          return {
+            spans: i.spans || [],
+            injections: i.injections || []
+          };
+        } catch (i) {
+          return console.error("[arborium] Parse error:", i), { spans: [], injections: [] };
+        } finally {
+          n.free_session(c);
         }
       }
     };
-    return k.set(t, l), console.debug(`[arborium] Grammar '${t}' loaded successfully`), l;
+    return y.set(e, v), console.debug(`[arborium] Grammar '${e}' loaded successfully`), v;
   } catch (a) {
-    return console.error(`[arborium] Failed to load grammar '${t}':`, a), null;
+    return console.error(`[arborium] Failed to load grammar '${e}':`, a), null;
   }
 }
-const y = /* @__PURE__ */ new Map();
-let P = 1;
-function q(t) {
+const w = /* @__PURE__ */ new Map();
+let C = 1;
+function I(e) {
   window.arboriumHost = {
     /** Check if a language is available (sync) */
-    isLanguageAvailable(e) {
-      return $.has(e) || k.has(e);
+    isLanguageAvailable(t) {
+      return d.has(t) || y.has(t);
     },
     /** Load a grammar and return a handle (async) */
-    async loadGrammar(e) {
-      const a = await v(e, t);
+    async loadGrammar(t) {
+      const a = await j(t, e);
       if (!a) return 0;
-      for (const [n, r] of y)
+      for (const [n, r] of w)
         if (r === a) return n;
-      const s = P++;
-      return y.set(s, a), s;
+      const s = C++;
+      return w.set(s, a), 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, a) {
+      const s = w.get(t);
+      return s ? s.parseUtf8(a) : { spans: [], injections: [] };
     }
   };
 }
-function M(t) {
-  if (t.hostUrl)
-    return t.hostUrl;
-  const e = t.cdn, a = t.version;
+function S(e) {
+  if (e.hostUrl)
+    return e.hostUrl;
+  const t = e.cdn, a = e.version;
   let s;
-  e === "jsdelivr" ? s = "https://cdn.jsdelivr.net/npm" : e === "unpkg" ? s = "https://unpkg.com" : s = e;
+  t === "jsdelivr" ? s = "https://cdn.jsdelivr.net/npm" : t === "unpkg" ? s = "https://unpkg.com" : s = t;
   const n = a === "latest" ? "" : `@${a}`;
   return `${s}/@arborium/arborium${n}/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`;
+async function A(e) {
+  return p || m || (m = (async () => {
+    I(e);
+    const t = S(e), a = `${t}/arborium_host.js`, s = `${t}/arborium_host_bg.wasm`;
     console.debug(`[arborium] Loading host from ${a}`);
     try {
       const n = await import(
         /* @vite-ignore */
         a
       );
-      return await n.default(s), u = {
+      return await n.default(s), p = {
         highlight: n.highlight,
         isLanguageAvailable: n.isLanguageAvailable
-      }, console.debug("[arborium] Host loaded successfully"), u;
+      }, console.debug("[arborium] Host loaded successfully"), p;
     } catch (n) {
       return console.error("[arborium] Failed to load host:", n), null;
     }
-  })(), g);
+  })(), m);
 }
-async function F(t, e, a) {
-  const s = L(a), n = await A(s);
+async function G(e, t, a) {
+  const s = b(a), n = await A(s);
   if (n)
     try {
-      return n.highlight(t, e);
-    } catch (i) {
-      console.warn("Host highlight failed, falling back to JS:", i);
+      return n.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 E(t);
 }
-async function O(t, e) {
-  const a = L(e), s = await v(t, a);
+async function z(e, t) {
+  const a = b(t), s = await j(e, a);
   if (!s) return null;
   const { module: n } = 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) => G(e, r, t),
+    // Public API returns UTF-16 offsets for JavaScript compatibility
+    parse: (r) => s.parseUtf16(r),
     createSession: () => {
       const r = n.create_session();
       return {
         setText: (o) => n.set_text(r, o),
+        // Session.parse() returns UTF-16 offsets for JavaScript compatibility
         parse: () => {
           try {
-            const o = n.parse(r);
+            const o = n.parse_utf16(r);
             return {
               spans: o.spans || [],
               injections: o.injections || []
@@ -658,177 +799,32 @@ async function O(t, e) {
     }
   };
 }
-function L(t) {
-  return t ? { ...b, ...t } : { ...b };
+function b(e) {
+  return e ? { ...g, ...e } : { ...g };
 }
-function z(t) {
-  b = { ...b, ...t };
-}
-const G = [
-  [/^#!.*\bpython[23]?\b/, "python"],
-  [/^#!.*\bnode\b/, "javascript"],
-  [/^#!.*\bdeno\b/, "typescript"],
-  [/^#!.*\bbun\b/, "typescript"],
-  [/^#!.*\bruby\b/, "ruby"],
-  [/^#!.*\bperl\b/, "perl"],
-  [/^#!.*\bphp\b/, "php"],
-  [/^#!.*\bbash\b/, "bash"],
-  [/^#!.*\bzsh\b/, "zsh"],
-  [/^#!.*\bsh\b/, "bash"],
-  [/^#!.*\blua\b/, "lua"],
-  [/^#!.*\bawk\b/, "awk"]
-], R = [
-  // Rust - distinctive keywords
-  [/\b(fn|impl|trait|pub\s+fn|let\s+mut|&mut|->)\b/, "rust"],
-  // Go - distinctive keywords
-  [/\b(func|package\s+\w+|import\s+\(|go\s+func|chan\s+\w+)\b/, "go"],
-  // Python - distinctive patterns
-  [/\b(def\s+\w+\s*\(|import\s+\w+|from\s+\w+\s+import|class\s+\w+:)\b/, "python"],
-  // TypeScript - distinctive type annotations
-  [/:\s*(string|number|boolean|void)\b|\binterface\s+\w+\s*\{/, "typescript"],
-  // JavaScript - distinctive patterns (after TS check)
-  [/\b(const|let|var)\s+\w+\s*=|function\s+\w+\s*\(|=>\s*\{/, "javascript"],
-  // Ruby - distinctive keywords
-  [/\b(def\s+\w+|end\b|do\s*\|.*\||puts\s+|require\s+['"])\b/, "ruby"],
-  // Java - distinctive patterns
-  [/\b(public\s+class|private\s+\w+|System\.out\.println)\b/, "java"],
-  // C++ - distinctive patterns
-  [/\b(#include\s*<|std::|template\s*<|nullptr|cout\s*<<)\b/, "cpp"],
-  // C - distinctive patterns (after C++ check)
-  [/\b(#include\s*[<"]|printf\s*\(|int\s+main\s*\(|void\s+\w+\s*\()\b/, "c"],
-  // C# - distinctive patterns
-  [/\b(namespace\s+\w+|using\s+System|public\s+static\s+void)\b/, "c-sharp"],
-  // PHP - distinctive patterns
-  [/<\?php|\$\w+\s*=/, "php"],
-  // Swift - distinctive patterns
-  [/\b(func\s+\w+|var\s+\w+:\s*\w+|let\s+\w+:\s*\w+|@objc)\b/, "swift"],
-  // Kotlin - distinctive patterns
-  [/\b(fun\s+\w+|val\s+\w+|var\s+\w+:|data\s+class)\b/, "kotlin"],
-  // Scala - distinctive patterns
-  [/\b(def\s+\w+|val\s+\w+|var\s+\w+|object\s+\w+|case\s+class)\b/, "scala"],
-  // Haskell - distinctive patterns
-  [/\b(module\s+\w+|import\s+qualified|data\s+\w+\s*=|::\s*\w+\s*->)\b/, "haskell"],
-  // Elixir - distinctive patterns
-  [/\b(defmodule\s+\w+|def\s+\w+|defp\s+\w+|\|>)\b/, "elixir"],
-  // Lua - distinctive patterns
-  [/\b(local\s+\w+\s*=|function\s+\w+\.\w+|require\s*\()\b/, "lua"],
-  // SQL - distinctive patterns
-  [/\b(SELECT\s+.*\s+FROM|INSERT\s+INTO|CREATE\s+TABLE|ALTER\s+TABLE)\b/i, "sql"],
-  // Shell/Bash - distinctive patterns
-  [/\b(if\s+\[\s*|then\b|fi\b|echo\s+["']|export\s+\w+=)\b/, "bash"],
-  // YAML - distinctive patterns
-  [/^\s*[\w-]+:\s*[\w\-"'[{]|^---\s*$/, "yaml"],
-  // JSON - distinctive patterns
-  [/^\s*\{[\s\S]*"[\w-]+":\s*/, "json"],
-  // TOML - distinctive patterns
-  [/^\s*\[[\w.-]+\]\s*$|^\s*\w+\s*=\s*["'\d\[]/, "toml"],
-  // HTML - distinctive patterns
-  [/<(!DOCTYPE|html|head|body|div|span|p|a\s)/i, "html"],
-  // CSS - distinctive patterns
-  [/^\s*[\w.#@][\w\s,#.:>+~-]*\{[^}]*\}|@media\s|@import\s/, "css"],
-  // Markdown - distinctive patterns
-  [/^#{1,6}\s+\w|^\s*[-*+]\s+\w|^\s*\d+\.\s+\w|```\w*\n/, "markdown"],
-  // XML - distinctive patterns
-  [/<\?xml|<[\w:-]+\s+xmlns/, "xml"],
-  // Dockerfile
-  [/^FROM\s+\w+|^RUN\s+|^COPY\s+|^ENTRYPOINT\s+/m, "dockerfile"],
-  // Nginx config
-  [/\b(server\s*\{|location\s+[\/~]|proxy_pass\s+)\b/, "nginx"],
-  // Zig
-  [/\b(pub\s+fn|const\s+\w+\s*=|@import\(|comptime)\b/, "zig"]
-];
-function N(t) {
-  const e = t.split(`
-`)[0];
-  for (const [a, s] of G)
-    if (a.test(e))
-      return s;
-  for (const [a, s] of R)
-    if (a.test(t))
-      return s;
-  return null;
+function N(e) {
+  g = { ...g, ...e };
 }
-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];
-  const s = /* @__PURE__ */ new Set([
-    "rust",
-    "javascript",
-    "typescript",
-    "python",
-    "ruby",
-    "go",
-    "java",
-    "c",
-    "cpp",
-    "csharp",
-    "php",
-    "swift",
-    "kotlin",
-    "scala",
-    "haskell",
-    "elixir",
-    "lua",
-    "sql",
-    "bash",
-    "shell",
-    "yaml",
-    "json",
-    "toml",
-    "html",
-    "css",
-    "xml",
-    "markdown",
-    "dockerfile",
-    "nginx",
-    "zig",
-    "text",
-    "plaintext",
-    "console",
-    "sh"
-  ]);
-  for (const n of t.split(/\s+/))
-    if (s.has(n.toLowerCase()))
-      return n.toLowerCase();
-  return null;
+async function O(e, t) {
+  const a = b(t);
+  return await k(a), d.has(e) || (l?.entries.some((s) => s.language === e) ?? !1);
 }
-function J(t) {
-  const e = {
-    js: "javascript",
-    ts: "typescript",
-    py: "python",
-    rb: "ruby",
-    rs: "rust",
-    sh: "bash",
-    shell: "bash",
-    yml: "yaml",
-    cs: "c-sharp",
-    csharp: "c-sharp",
-    "c++": "cpp",
-    "c#": "c-sharp",
-    "f#": "fsharp",
-    dockerfile: "dockerfile",
-    docker: "dockerfile",
-    makefile: "make",
-    plaintext: "text",
-    plain: "text",
-    txt: "text"
-  }, a = t.toLowerCase();
-  return e[a] || a;
+async function B(e) {
+  const t = b(e);
+  return await k(t), l ? l.entries.map((a) => a.language) : Array.from(d);
 }
 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
+  U as availableLanguages,
+  M as detectLanguage,
+  R as extractLanguageFromClass,
+  B as getAvailableLanguages,
+  b as getConfig,
+  G as highlight,
+  F as highlights,
+  O as isLanguageAvailable,
+  z as loadGrammar,
+  H as normalizeLanguage,
+  _ as pluginVersion,
+  N as setConfig
 };
 //# sourceMappingURL=arborium.js.map