@arborium/arborium 2.11.0 → 2.12.1

package/dist/arborium.js

@@ -1,4 +1,158 @@
-const x = "2.11.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.1", U = [
   "ada",
   "agda",
   "asciidoc",
@@ -101,7 +255,7 @@ const x = "2.11.0", $ = [
   "yuri",
   "zig",
   "zsh"
-], R = [
+], F = [
   {
     name: "attribute",
     tag: "at"
@@ -435,15 +589,15 @@ const x = "2.11.0", $ = [
     tag: "cb"
   }
 ];
-function L(e) {
+function E(e) {
   return e.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
-const y = {
+const T = {
   manual: !1,
   theme: "one-dark",
   selector: "pre code",
   cdn: "jsdelivr",
-  version: x,
+  version: _,
   // Precise version from manifest
   pluginsUrl: "",
   // Empty means use bundled manifest
@@ -455,68 +609,68 @@ const y = {
   ),
   resolveWasm: ({ baseUrl: e, path: t }) => fetch(`${e}/${t}`)
 };
-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) {
+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}`);
-      c = await t.json(), console.debug(`[arborium] Loaded local manifest with ${c?.entries.length} entries`);
+      l = await t.json(), console.debug(`[arborium] Loaded local manifest with ${l?.entries.length} entries`);
     })(), u);
 }
-function U(e, t) {
-  if (c) {
-    const r = c.entries.find((o) => o.language === e);
+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 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}`;
+  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/${e}@${s}`;
 }
-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);
+async function j(e, t) {
+  const a = y.get(e);
+  if (a)
+    return console.debug(`[arborium] Grammar '${e}' found in cache`), a;
+  const s = h.get(e);
   if (s)
     return console.debug(`[arborium] Grammar '${e}' already loading, waiting...`), s;
-  const a = E(e, t);
-  b.set(e, a);
+  const n = q(e, t);
+  h.set(e, n);
   try {
-    return await a;
+    return await n;
   } finally {
-    b.delete(e);
+    h.delete(e);
   }
 }
-async function E(e, t) {
-  if (await _(t), !k.has(e) && !c?.entries.some((n) => n.language === e))
+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 n = U(e, t), s = t.resolveJs === y.resolveJs ? ` from ${n}/grammar.js` : "";
+    const a = P(e, t), s = t.resolveJs === T.resolveJs ? ` from ${a}/grammar.js` : "";
     console.debug(`[arborium] Loading grammar '${e}'${s}`);
-    const a = await t.resolveJs({
+    const n = await t.resolveJs({
       language: e,
-      baseUrl: n,
+      baseUrl: a,
       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();
+    }), 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 !== e && console.warn(`[arborium] Language ID mismatch: expected '${e}', got '${o}'`);
-    const j = a.injection_languages(), w = {
+    const x = n.injection_languages(), v = {
       languageId: e,
-      injectionLanguages: j,
-      module: a,
+      injectionLanguages: x,
+      module: n,
       // UTF-8 parsing for Rust host
-      parseUtf8: (d) => {
-        const l = a.create_session();
+      parseUtf8: (f) => {
+        const c = n.create_session();
         try {
-          a.set_text(l, d);
-          const i = a.parse(l);
+          n.set_text(c, f);
+          const i = n.parse(c);
           return {
             spans: i.spans || [],
             injections: i.injections || []
@@ -524,15 +678,15 @@ async function E(e, t) {
         } catch (i) {
           return console.error("[arborium] Parse error:", i), { spans: [], injections: [] };
         } finally {
-          a.free_session(l);
+          n.free_session(c);
         }
       },
       // UTF-16 parsing for JavaScript public API
-      parseUtf16: (d) => {
-        const l = a.create_session();
+      parseUtf16: (f) => {
+        const c = n.create_session();
         try {
-          a.set_text(l, d);
-          const i = a.parse_utf16(l);
+          n.set_text(c, f);
+          const i = n.parse_utf16(c);
           return {
             spans: i.spans || [],
             injections: i.injections || []
@@ -540,95 +694,95 @@ async function E(e, t) {
         } catch (i) {
           return console.error("[arborium] Parse error:", i), { spans: [], injections: [] };
         } finally {
-          a.free_session(l);
+          n.free_session(c);
         }
       }
     };
-    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;
+    return y.set(e, v), console.debug(`[arborium] Grammar '${e}' loaded successfully`), v;
+  } catch (a) {
+    return console.error(`[arborium] Failed to load grammar '${e}':`, a), null;
   }
 }
-const f = /* @__PURE__ */ new Map();
-let P = 1;
-function q(e) {
+const w = /* @__PURE__ */ new Map();
+let C = 1;
+function I(e) {
   window.arboriumHost = {
     /** Check if a language is available (sync) */
     isLanguageAvailable(t) {
-      return k.has(t) || h.has(t);
+      return d.has(t) || y.has(t);
     },
     /** Load a grammar and return a handle (async) */
     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 f.set(s, n), s;
+      const a = await j(t, e);
+      if (!a) return 0;
+      for (const [n, r] of w)
+        if (r === a) return n;
+      const s = C++;
+      return w.set(s, a), s;
     },
     /** 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: [] };
+    parse(t, a) {
+      const s = w.get(t);
+      return s ? s.parseUtf8(a) : { spans: [], injections: [] };
     }
   };
 }
-function C(e) {
+function S(e) {
   if (e.hostUrl)
     return e.hostUrl;
-  const t = e.cdn, n = e.version;
+  const t = e.cdn, a = e.version;
   let s;
   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`;
+  const n = a === "latest" ? "" : `@${a}`;
+  return `${s}/@arborium/arborium${n}/dist`;
 }
-async function I(e) {
+async function A(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}`);
+    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 a = await import(
+      const n = await import(
         /* @vite-ignore */
-        n
+        a
       );
-      return await a.default(s), p = {
-        highlight: a.highlight,
-        isLanguageAvailable: a.isLanguageAvailable
+      return await n.default(s), p = {
+        highlight: n.highlight,
+        isLanguageAvailable: n.isLanguageAvailable
       }, console.debug("[arborium] Host loaded successfully"), p;
-    } catch (a) {
-      return console.error("[arborium] Failed to load host:", a), null;
+    } catch (n) {
+      return console.error("[arborium] Failed to load host:", n), null;
     }
   })(), m);
 }
-async function S(e, t, n) {
-  const s = T(n), a = await I(s);
-  if (a)
+async function G(e, t, a) {
+  const s = b(a), n = await A(s);
+  if (n)
     try {
-      return a.highlight(e, t);
+      return n.highlight(e, t);
     } catch (r) {
       console.error("[arborium] Host highlight failed:", r);
     }
-  return L(t);
+  return E(t);
 }
-async function A(e, t) {
-  const n = T(t), s = await v(e, n);
+async function z(e, t) {
+  const a = b(t), s = await j(e, a);
   if (!s) return null;
-  const { module: a } = s;
+  const { module: n } = s;
   return {
     languageId: () => s.languageId,
     injectionLanguages: () => s.injectionLanguages,
-    highlight: async (r) => S(e, r, t),
+    highlight: async (r) => G(e, r, t),
     // Public API returns UTF-16 offsets for JavaScript compatibility
     parse: (r) => s.parseUtf16(r),
     createSession: () => {
-      const r = a.create_session();
+      const r = n.create_session();
       return {
-        setText: (o) => a.set_text(r, o),
+        setText: (o) => n.set_text(r, o),
         // Session.parse() returns UTF-16 offsets for JavaScript compatibility
         parse: () => {
           try {
-            const o = a.parse_utf16(r);
+            const o = n.parse_utf16(r);
             return {
               spans: o.spans || [],
               injections: o.injections || []
@@ -637,184 +791,40 @@ async function A(e, t) {
             return console.error("[arborium] Session parse error:", o), { spans: [], injections: [] };
           }
         },
-        cancel: () => a.cancel(r),
-        free: () => a.free_session(r)
+        cancel: () => n.cancel(r),
+        free: () => n.free_session(r)
       };
     },
     dispose: () => {
     }
   };
 }
-function T(e) {
+function b(e) {
   return e ? { ...g, ...e } : { ...g };
 }
-function H(e) {
+function N(e) {
   g = { ...g, ...e };
 }
-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"]
-], M = [
-  // 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 F(e) {
-  const t = e.split(`
-`)[0];
-  for (const [n, s] of G)
-    if (n.test(t))
-      return s;
-  for (const [n, s] of M)
-    if (n.test(e))
-      return s;
-  return null;
-}
-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",
-    "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 a of e.split(/\s+/))
-    if (s.has(a.toLowerCase()))
-      return a.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 N(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"
-  }, n = e.toLowerCase();
-  return t[n] || n;
+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,
-  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
+  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