code-languages 1.17.0 → 1.19.0

package/dist/api.cjs

@@ -160,6 +160,44 @@ var init_apex = __esm({
   }
 });
 
+// src/languages/asciidoc.ts
+var asciidoc_exports = {};
+__export(asciidoc_exports, {
+  asciidoc: () => asciidoc
+});
+var asciidoc;
+var init_asciidoc = __esm({
+  "src/languages/asciidoc.ts"() {
+    asciidoc = {
+      slug: "asciidoc",
+      publishedDate: "2002-11-25",
+      extensions: [".adoc", ".asciidoc", ".asc"],
+      author: "Stuart Rackham / AsciiDoc Working Group",
+      website: "https://asciidoc.org",
+      paradigms: ["markup", "documentation", "declarative", "publishing"],
+      tooling: {
+        runtimes: ["Asciidoctor", "Asciidoctor.js", "Antora"],
+        packageManagers: ["RubyGems", "npm", "Maven"],
+        ecosystems: ["Documentation", "Publishing", "Technical Writing", "Static Sites"]
+      },
+      version: "pre-spec",
+      logo: "https://cdn.simpleicons.org/asciidoctor/E40046",
+      i18n: {
+        en: {
+          name: "AsciiDoc",
+          description: "A plain-text markup language for technical documentation, books, and publishing.",
+          longDescription: "AsciiDoc is a readable markup language for writing structured documents with sections, attributes, lists, tables, admonitions, cross references, includes, source blocks, and rich publishing metadata. It is designed to remain comfortable in plain text while supporting professional output formats.\n\nIt is used for product documentation, books, technical manuals, API guides, knowledge bases, Antora documentation sites, and publishing workflows that need semantic source files under version control."
+        },
+        es: {
+          name: "AsciiDoc",
+          description: "Un lenguaje de marcado en texto plano para documentacion tecnica, libros y publicacion.",
+          longDescription: "AsciiDoc es un lenguaje de marcado legible para escribir documentos estructurados con secciones, atributos, listas, tablas, admoniciones, referencias cruzadas, includes, bloques de codigo y metadatos de publicacion. Esta pensado para ser comodo en texto plano y aun asi soportar salidas profesionales.\n\nSe usa en documentacion de producto, libros, manuales tecnicos, guias de API, bases de conocimiento, sitios Antora y flujos de publicacion que necesitan archivos fuente semanticos bajo control de versiones."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/asp.ts
 var asp_exports = {};
 __export(asp_exports, {
@@ -387,6 +425,120 @@ var init_batch = __esm({
   }
 });
 
+// src/languages/bazel.ts
+var bazel_exports = {};
+__export(bazel_exports, {
+  bazel: () => bazel
+});
+var bazel;
+var init_bazel = __esm({
+  "src/languages/bazel.ts"() {
+    bazel = {
+      slug: "bazel",
+      publishedDate: "2015-03-25",
+      extensions: ["BUILD.bazel", "WORKSPACE", "WORKSPACE.bazel", "MODULE.bazel"],
+      author: "Google / Bazel contributors",
+      website: "https://bazel.build",
+      paradigms: ["declarative", "build-configuration", "hermetic", "monorepo"],
+      tooling: {
+        runtimes: ["Bazel"],
+        packageManagers: ["Bzlmod", "Bazel Central Registry"],
+        ecosystems: ["Build Systems", "Monorepos", "CI/CD", "Polyglot Repositories"]
+      },
+      version: "9.0.2",
+      logo: "https://cdn.simpleicons.org/bazel/43A047",
+      i18n: {
+        en: {
+          name: "Bazel",
+          description: "A build and test configuration language for fast, reproducible multi-language builds.",
+          longDescription: "Bazel files describe packages, targets, dependencies, toolchains, platforms, modules, and build rules for Bazel's hermetic build graph. BUILD and MODULE files are declarative, while extension logic is commonly written in Starlark.\n\nIt is used in monorepos, large-scale CI systems, polyglot projects, remote execution workflows, reproducible builds, dependency graph analysis, and teams that need consistent builds across machines and languages."
+        },
+        es: {
+          name: "Bazel",
+          description: "Un lenguaje de configuracion de build y test para compilaciones rapidas y reproducibles.",
+          longDescription: "Los archivos Bazel describen paquetes, targets, dependencias, toolchains, plataformas, modulos y reglas para el grafo de build hermetico de Bazel. Los archivos BUILD y MODULE son declarativos, mientras que la logica de extension suele escribirse en Starlark.\n\nSe usa en monorepos, sistemas CI a gran escala, proyectos poliglota, remote execution, builds reproducibles, analisis de grafos de dependencias y equipos que necesitan builds consistentes entre maquinas y lenguajes."
+        }
+      }
+    };
+  }
+});
+
+// src/languages/bicep.ts
+var bicep_exports = {};
+__export(bicep_exports, {
+  bicep: () => bicep
+});
+var bicep;
+var init_bicep = __esm({
+  "src/languages/bicep.ts"() {
+    bicep = {
+      slug: "bicep",
+      publishedDate: "2020-09-01",
+      extensions: [".bicep", ".bicepparam"],
+      author: "Microsoft",
+      website: "https://github.com/Azure/bicep",
+      paradigms: ["declarative", "infrastructure-as-code", "configuration"],
+      tooling: {
+        runtimes: ["Azure Resource Manager"],
+        packageManagers: ["Azure Verified Modules", "Bicep Registry"],
+        ecosystems: ["Azure", "Cloud", "DevOps", "Infrastructure as Code"]
+      },
+      version: "0.43.8",
+      logo: "https://cdn.jsdelivr.net/gh/homarr-labs/dashboard-icons/svg/azure-bicep.svg",
+      i18n: {
+        en: {
+          name: "Bicep",
+          description: "A declarative language for describing Azure infrastructure as code.",
+          longDescription: "Bicep is a domain-specific language for authoring Azure Resource Manager deployments with a concise syntax, modules, parameters, symbolic names, loops, conditions, and type-aware tooling. It compiles to ARM templates while giving authors a friendlier source format.\n\nIt is used for repeatable Azure infrastructure deployments, platform engineering, cloud governance, reusable modules, CI/CD provisioning, and environment-specific resource definitions."
+        },
+        es: {
+          name: "Bicep",
+          description: "Un lenguaje declarativo para describir infraestructura de Azure como codigo.",
+          longDescription: "Bicep es un lenguaje de dominio especifico para crear despliegues de Azure Resource Manager con sintaxis concisa, modulos, parametros, nombres simbolicos, bucles, condiciones y tooling con tipos. Compila a plantillas ARM y ofrece un formato fuente mas comodo.\n\nSe usa para despliegues repetibles de infraestructura en Azure, platform engineering, gobierno cloud, modulos reutilizables, aprovisionamiento en CI/CD y definiciones de recursos por entorno."
+        }
+      }
+    };
+  }
+});
+
+// src/languages/blade.ts
+var blade_exports = {};
+__export(blade_exports, {
+  blade: () => blade
+});
+var blade;
+var init_blade = __esm({
+  "src/languages/blade.ts"() {
+    blade = {
+      slug: "blade",
+      publishedDate: "2011-06-09",
+      extensions: [".blade.php"],
+      author: "Taylor Otwell / Laravel",
+      website: "https://laravel.com/docs/blade",
+      paradigms: ["templating", "server-side", "component-oriented", "declarative"],
+      tooling: {
+        runtimes: ["PHP", "Laravel"],
+        packageManagers: ["Composer"],
+        ecosystems: ["Laravel", "PHP", "Web", "Server-rendered UI"]
+      },
+      version: "Laravel 12.x",
+      logo: "https://cdn.simpleicons.org/laravel/FF2D20",
+      i18n: {
+        en: {
+          name: "Blade",
+          description: "Laravel's server-side template language for views, components, and layouts.",
+          longDescription: "Blade is Laravel's template language for composing PHP views with directives, layouts, sections, stacks, components, slots, conditionals, loops, includes, escaping, and custom compiler extensions. It keeps templates close to HTML while integrating deeply with Laravel features.\n\nIt is used for Laravel applications, server-rendered interfaces, form views, email templates, reusable UI components, admin panels, and PHP projects that rely on Laravel's view layer."
+        },
+        es: {
+          name: "Blade",
+          description: "El lenguaje de plantillas de Laravel para vistas, componentes y layouts en servidor.",
+          longDescription: "Blade es el lenguaje de plantillas de Laravel para componer vistas PHP con directivas, layouts, secciones, stacks, componentes, slots, condicionales, bucles, includes, escapado y extensiones del compilador. Mantiene las plantillas cerca de HTML y se integra de forma profunda con Laravel.\n\nSe usa en aplicaciones Laravel, interfaces renderizadas en servidor, vistas de formularios, plantillas de email, componentes UI reutilizables, paneles administrativos y proyectos PHP que dependen de la capa de vistas de Laravel."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/c.ts
 var c_exports = {};
 __export(c_exports, {
@@ -760,6 +912,44 @@ var init_cuda = __esm({
   }
 });
 
+// src/languages/cue.ts
+var cue_exports = {};
+__export(cue_exports, {
+  cue: () => cue
+});
+var cue;
+var init_cue = __esm({
+  "src/languages/cue.ts"() {
+    cue = {
+      slug: "cue",
+      publishedDate: "2019-02-27",
+      extensions: [".cue"],
+      author: "Marcel van Lohuizen / CUE contributors",
+      website: "https://cue.dev",
+      paradigms: ["declarative", "constraint-based", "data-validation", "configuration"],
+      tooling: {
+        runtimes: ["CUE CLI", "Go"],
+        packageManagers: ["Go modules"],
+        ecosystems: ["Configuration", "Validation", "Kubernetes", "DevOps"]
+      },
+      version: "0.16.1",
+      logo: "https://avatars.githubusercontent.com/u/43867057?s=200&v=4",
+      i18n: {
+        en: {
+          name: "CUE",
+          description: "A constraint-based language for configuration, data validation, and generation.",
+          longDescription: "CUE combines configuration data, schemas, validation rules, and policy constraints in one language. Its values can be incomplete, unified, exported, and checked against structural constraints, making it useful for managing complex data definitions.\n\nIt is used with Kubernetes manifests, JSON, YAML, OpenAPI, Protobuf, CI configuration, infrastructure definitions, and systems that need one source of truth for data shape and validation."
+        },
+        es: {
+          name: "CUE",
+          description: "Un lenguaje basado en restricciones para configuracion, validacion y generacion de datos.",
+          longDescription: "CUE combina datos de configuracion, esquemas, reglas de validacion y restricciones de politica en un solo lenguaje. Sus valores pueden estar incompletos, unificarse, exportarse y comprobarse contra restricciones estructurales, lo que ayuda a gestionar definiciones de datos complejas.\n\nSe usa con manifiestos Kubernetes, JSON, YAML, OpenAPI, Protobuf, configuracion de CI, definiciones de infraestructura y sistemas que necesitan una fuente unica para forma y validacion de datos."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/d.ts
 var d_exports = {};
 __export(d_exports, {
@@ -1101,6 +1291,44 @@ var init_fsharp = __esm({
   }
 });
 
+// src/languages/gdscript.ts
+var gdscript_exports = {};
+__export(gdscript_exports, {
+  gdscript: () => gdscript
+});
+var gdscript;
+var init_gdscript = __esm({
+  "src/languages/gdscript.ts"() {
+    gdscript = {
+      slug: "gdscript",
+      publishedDate: "2014-12-15",
+      extensions: [".gd"],
+      author: "Juan Linietsky, Ariel Manzur / Godot contributors",
+      website: "https://docs.godotengine.org/en/stable/tutorials/scripting/gdscript/",
+      paradigms: ["object-oriented", "imperative", "event-driven", "scripting"],
+      tooling: {
+        runtimes: ["Godot Engine"],
+        packageManagers: ["Godot Asset Library"],
+        ecosystems: ["Game Development", "2D Games", "3D Games"]
+      },
+      version: "4.6",
+      logo: "https://cdn.simpleicons.org/godotengine/478CBF",
+      i18n: {
+        en: {
+          name: "GDScript",
+          description: "Godot Engine's integrated scripting language for gameplay and editor logic.",
+          longDescription: "GDScript is a high-level scripting language built for Godot Engine. It uses indentation-based syntax, dynamic and optional static typing, signals, scene-node integration, coroutines, resources, and editor-aware tooling tailored to game development.\n\nIt is used to implement gameplay, UI behavior, tools, animation logic, prototypes, editor plugins, and scripts that interact closely with Godot scenes and engine APIs."
+        },
+        es: {
+          name: "GDScript",
+          description: "El lenguaje de scripting integrado de Godot Engine para gameplay y logica de editor.",
+          longDescription: "GDScript es un lenguaje de scripting de alto nivel creado para Godot Engine. Usa sintaxis basada en indentacion, tipado dinamico y estatico opcional, senales, integracion con nodos de escena, corrutinas, recursos y tooling del editor orientado al desarrollo de juegos.\n\nSe usa para implementar gameplay, comportamiento de UI, herramientas, logica de animacion, prototipos, plugins del editor y scripts que interactuan de cerca con escenas y APIs de Godot."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/git.ts
 var git_exports = {};
 __export(git_exports, {
@@ -1366,6 +1594,44 @@ var init_groovy = __esm({
   }
 });
 
+// src/languages/handlebars.ts
+var handlebars_exports = {};
+__export(handlebars_exports, {
+  handlebars: () => handlebars
+});
+var handlebars;
+var init_handlebars = __esm({
+  "src/languages/handlebars.ts"() {
+    handlebars = {
+      slug: "handlebars",
+      publishedDate: "2010-07-01",
+      extensions: [".hbs", ".handlebars"],
+      author: "Yehuda Katz / Handlebars contributors",
+      website: "https://handlebarsjs.com",
+      paradigms: ["templating", "declarative", "logic-less"],
+      tooling: {
+        runtimes: ["Node.js", "Browser"],
+        packageManagers: ["npm", "Yarn", "pnpm"],
+        ecosystems: ["Web", "Email Templates", "Static Sites"]
+      },
+      version: "4.7.9",
+      logo: "https://cdn.simpleicons.org/handlebarsdotjs/000000",
+      i18n: {
+        en: {
+          name: "Handlebars",
+          description: "A logic-light template language for rendering HTML and text from data.",
+          longDescription: "Handlebars is a template language and JavaScript runtime that extends Mustache with helpers, block expressions, partials, precompilation, and escaping. It keeps templates focused on presentation while letting helpers supply reusable behavior.\n\nIt is used for server-rendered HTML, client-side views, static site generation, transactional email, documentation tools, and build systems that need predictable text generation from structured data."
+        },
+        es: {
+          name: "Handlebars",
+          description: "Un lenguaje de plantillas con poca logica para renderizar HTML y texto desde datos.",
+          longDescription: "Handlebars es un lenguaje de plantillas y runtime JavaScript que extiende Mustache con helpers, expresiones de bloque, partials, precompilacion y escapado. Mantiene las plantillas centradas en la presentacion y deja que los helpers aporten comportamiento reutilizable.\n\nSe usa para HTML renderizado en servidor, vistas de cliente, generacion de sitios estaticos, email transaccional, herramientas de documentacion y sistemas de build que generan texto desde datos estructurados."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/haskell.ts
 var haskell_exports = {};
 __export(haskell_exports, {
@@ -1480,6 +1746,44 @@ var init_hcl = __esm({
   }
 });
 
+// src/languages/hlsl.ts
+var hlsl_exports = {};
+__export(hlsl_exports, {
+  hlsl: () => hlsl
+});
+var hlsl;
+var init_hlsl = __esm({
+  "src/languages/hlsl.ts"() {
+    hlsl = {
+      slug: "hlsl",
+      publishedDate: "2002-12-01",
+      extensions: [".hlsl", ".fx", ".fxh", ".hlsli"],
+      author: "Microsoft",
+      website: "https://learn.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl",
+      paradigms: ["shader", "data-parallel", "graphics", "procedural"],
+      tooling: {
+        runtimes: ["Direct3D", "DirectX Shader Compiler", "Game Engines"],
+        packageManagers: ["NuGet", "vcpkg"],
+        ecosystems: ["Graphics", "Game Development", "GPU Programming", "DirectX"]
+      },
+      version: "Shader Model 6.9",
+      logo: "https://cdn.jsdelivr.net/gh/vscode-icons/vscode-icons@master/icons/file_type_hlsl.svg",
+      i18n: {
+        en: {
+          name: "HLSL",
+          description: "Microsoft's High-Level Shading Language for programmable graphics pipelines.",
+          longDescription: "HLSL is a shader language for Direct3D and related graphics pipelines. It provides C-like syntax, vector and matrix types, textures, samplers, constant buffers, semantics, intrinsics, and shader stages for vertex, pixel, compute, geometry, hull, domain, mesh, amplification, and ray tracing workloads.\n\nIt is used in Windows games, rendering engines, GPU compute tasks, visual effects, real-time simulations, DirectX tools, and cross-compiled shader workflows that target modern graphics hardware."
+        },
+        es: {
+          name: "HLSL",
+          description: "El High-Level Shading Language de Microsoft para pipelines graficos programables.",
+          longDescription: "HLSL es un lenguaje de shaders para Direct3D y pipelines graficos relacionados. Ofrece sintaxis similar a C, tipos vectoriales y matriciales, texturas, samplers, constant buffers, semanticas, intrinsics y etapas de shader para vertex, pixel, compute, geometry, hull, domain, mesh, amplification y ray tracing.\n\nSe usa en juegos Windows, motores de rendering, tareas GPU compute, efectos visuales, simulaciones en tiempo real, herramientas DirectX y flujos de shaders cross-compiled hacia hardware grafico moderno."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/html.ts
 var html_exports = {};
 __export(html_exports, {
@@ -1625,6 +1929,44 @@ var init_javascript = __esm({
   }
 });
 
+// src/languages/jinja.ts
+var jinja_exports = {};
+__export(jinja_exports, {
+  jinja: () => jinja
+});
+var jinja;
+var init_jinja = __esm({
+  "src/languages/jinja.ts"() {
+    jinja = {
+      slug: "jinja",
+      publishedDate: "2008-07-17",
+      extensions: [".jinja", ".jinja2", ".j2"],
+      author: "Armin Ronacher / Pallets",
+      website: "https://jinja.palletsprojects.com",
+      paradigms: ["templating", "declarative", "server-side", "scripting"],
+      tooling: {
+        runtimes: ["Python"],
+        packageManagers: ["pip", "Poetry", "uv"],
+        ecosystems: ["Python", "Flask", "Ansible", "Web"]
+      },
+      version: "3.1.6",
+      logo: "https://cdn.simpleicons.org/jinja/B41717",
+      i18n: {
+        en: {
+          name: "Jinja",
+          description: "A Python template language used for web views, automation, and configuration.",
+          longDescription: "Jinja is a template engine for Python with inheritance, blocks, includes, macros, filters, tests, autoescaping, sandboxing, and whitespace control. Its syntax is expressive enough for reusable views while keeping application logic outside templates.\n\nIt is widely used in Flask applications, Ansible templates, static site generators, documentation systems, email rendering, configuration generation, and automation workflows."
+        },
+        es: {
+          name: "Jinja",
+          description: "Un lenguaje de plantillas para Python usado en vistas web, automatizacion y configuracion.",
+          longDescription: "Jinja es un motor de plantillas para Python con herencia, bloques, includes, macros, filtros, tests, autoescapado, sandboxing y control de espacios. Su sintaxis permite vistas reutilizables sin llevar la logica de aplicacion a las plantillas.\n\nSe usa ampliamente en aplicaciones Flask, plantillas de Ansible, generadores de sitios estaticos, sistemas de documentacion, renderizado de email, generacion de configuracion y flujos de automatizacion."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/json.ts
 var json_exports = {};
 __export(json_exports, {
@@ -1810,6 +2152,44 @@ var init_less = __esm({
   }
 });
 
+// src/languages/liquid.ts
+var liquid_exports = {};
+__export(liquid_exports, {
+  liquid: () => liquid
+});
+var liquid;
+var init_liquid = __esm({
+  "src/languages/liquid.ts"() {
+    liquid = {
+      slug: "liquid",
+      publishedDate: "2006-06-01",
+      extensions: [".liquid"],
+      author: "Shopify",
+      website: "https://shopify.github.io/liquid/",
+      paradigms: ["templating", "declarative", "logic-less", "server-side"],
+      tooling: {
+        runtimes: ["Ruby", "Node.js", "Shopify"],
+        packageManagers: ["RubyGems", "npm"],
+        ecosystems: ["Shopify", "Jekyll", "Static Sites", "E-commerce"]
+      },
+      version: "10.21.1",
+      logo: "https://cdn.simpleicons.org/shopify/7AB55C",
+      i18n: {
+        en: {
+          name: "Liquid",
+          description: "A safe template language used by Shopify, Jekyll, and content-driven sites.",
+          longDescription: "Liquid is a template language designed to expose controlled data to templates through tags, objects, filters, loops, conditions, and includes. It favors predictable rendering and constrained logic so non-developers can safely customize content presentation.\n\nIt is used in Shopify themes, Jekyll sites, GitHub Pages, storefront customization, content management systems, email templates, and static publishing workflows."
+        },
+        es: {
+          name: "Liquid",
+          description: "Un lenguaje de plantillas seguro usado por Shopify, Jekyll y sitios basados en contenido.",
+          longDescription: "Liquid es un lenguaje de plantillas disenado para exponer datos controlados mediante tags, objetos, filtros, bucles, condiciones e includes. Prioriza renderizado predecible y logica limitada para que personas no desarrolladoras puedan personalizar la presentacion de contenido con seguridad.\n\nSe usa en temas de Shopify, sitios Jekyll, GitHub Pages, personalizacion de tiendas, sistemas de gestion de contenido, plantillas de email y flujos de publicacion estatica."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/lisp.ts
 var lisp_exports = {};
 __export(lisp_exports, {
@@ -1994,6 +2374,82 @@ var init_matlab = __esm({
   }
 });
 
+// src/languages/mdx.ts
+var mdx_exports = {};
+__export(mdx_exports, {
+  mdx: () => mdx
+});
+var mdx;
+var init_mdx = __esm({
+  "src/languages/mdx.ts"() {
+    mdx = {
+      slug: "mdx",
+      publishedDate: "2018-03-23",
+      extensions: [".mdx"],
+      author: "MDX contributors",
+      website: "https://mdxjs.com",
+      paradigms: ["markup", "component-oriented", "declarative", "documentation"],
+      tooling: {
+        runtimes: ["React", "Node.js"],
+        packageManagers: ["npm", "Yarn", "pnpm"],
+        ecosystems: ["Documentation", "React", "Static Sites", "Content"]
+      },
+      version: "3.1.1",
+      logo: "https://cdn.simpleicons.org/mdx/1B1F24",
+      i18n: {
+        en: {
+          name: "MDX",
+          description: "A Markdown-based format that embeds JSX components in content documents.",
+          longDescription: "MDX combines Markdown prose with JSX expressions and components, allowing documents to include interactive examples, imports, exports, and component-driven layouts. It is commonly compiled into JavaScript for React-based rendering pipelines.\n\nIt is used in documentation sites, design systems, blogs, tutorials, component demos, content platforms, and static site generators that need prose and UI components in the same source file."
+        },
+        es: {
+          name: "MDX",
+          description: "Un formato basado en Markdown que inserta componentes JSX en documentos de contenido.",
+          longDescription: "MDX combina prosa Markdown con expresiones y componentes JSX, permitiendo que los documentos incluyan ejemplos interactivos, imports, exports y layouts basados en componentes. Normalmente se compila a JavaScript para pipelines de renderizado con React.\n\nSe usa en sitios de documentacion, sistemas de diseno, blogs, tutoriales, demos de componentes, plataformas de contenido y generadores de sitios estaticos que necesitan prosa y UI en el mismo archivo fuente."
+        }
+      }
+    };
+  }
+});
+
+// src/languages/mermaid.ts
+var mermaid_exports = {};
+__export(mermaid_exports, {
+  mermaid: () => mermaid
+});
+var mermaid;
+var init_mermaid = __esm({
+  "src/languages/mermaid.ts"() {
+    mermaid = {
+      slug: "mermaid",
+      publishedDate: "2014-11-04",
+      extensions: [".mmd", ".mermaid"],
+      author: "Knut Sveidqvist / Mermaid contributors",
+      website: "https://mermaid.js.org",
+      paradigms: ["declarative", "diagramming", "markup"],
+      tooling: {
+        runtimes: ["Browser", "Node.js"],
+        packageManagers: ["npm", "Yarn", "pnpm"],
+        ecosystems: ["Documentation", "Markdown", "Diagrams", "Knowledge Management"]
+      },
+      version: "11.11.0",
+      logo: "https://cdn.simpleicons.org/mermaid/FF3670",
+      i18n: {
+        en: {
+          name: "Mermaid",
+          description: "A text-based diagram language for flowcharts, sequences, timelines, and more.",
+          longDescription: "Mermaid is a diagramming language that renders structured text into diagrams such as flowcharts, sequence diagrams, class diagrams, state diagrams, entity relationship diagrams, gantt charts, timelines, and mind maps. It is designed to live comfortably beside Markdown documentation.\n\nIt is used in READMEs, architecture notes, wikis, documentation sites, issue trackers, knowledge bases, and workflows where diagrams should be versioned as plain text."
+        },
+        es: {
+          name: "Mermaid",
+          description: "Un lenguaje textual de diagramas para flujos, secuencias, lineas de tiempo y mas.",
+          longDescription: "Mermaid es un lenguaje de diagramacion que renderiza texto estructurado como diagramas de flujo, secuencia, clases, estados, entidad-relacion, gantt, lineas de tiempo y mapas mentales. Esta pensado para convivir comodamente con documentacion Markdown.\n\nSe usa en READMEs, notas de arquitectura, wikis, sitios de documentacion, issue trackers, bases de conocimiento y flujos donde los diagramas deben versionarse como texto plano."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/meson.ts
 var meson_exports = {};
 __export(meson_exports, {
@@ -2372,6 +2828,44 @@ var init_php = __esm({
   }
 });
 
+// src/languages/plantuml.ts
+var plantuml_exports = {};
+__export(plantuml_exports, {
+  plantuml: () => plantuml
+});
+var plantuml;
+var init_plantuml = __esm({
+  "src/languages/plantuml.ts"() {
+    plantuml = {
+      slug: "plantuml",
+      publishedDate: "2009-04-17",
+      extensions: [".puml", ".plantuml", ".iuml"],
+      author: "Arnaud Roques / PlantUML contributors",
+      website: "https://plantuml.com",
+      paradigms: ["declarative", "diagramming", "modeling"],
+      tooling: {
+        runtimes: ["Java", "PlantUML Server"],
+        packageManagers: ["Maven", "Gradle", "npm"],
+        ecosystems: ["UML", "Architecture", "Documentation", "Diagrams"]
+      },
+      version: "1.2026.3",
+      logo: "https://plantuml.com/logo3.png",
+      i18n: {
+        en: {
+          name: "PlantUML",
+          description: "A text-based diagram language for UML, architecture, and documentation diagrams.",
+          longDescription: "PlantUML is a diagram language and renderer for sequence, class, activity, component, state, object, deployment, timing, mind map, and architecture diagrams. It lets teams keep diagrams in source control and generate images from compact text.\n\nIt is used in software architecture documentation, design reviews, technical specs, wikis, CI-generated diagrams, and projects that prefer versionable diagrams over manually edited drawing files."
+        },
+        es: {
+          name: "PlantUML",
+          description: "Un lenguaje textual de diagramas para UML, arquitectura y documentacion.",
+          longDescription: "PlantUML es un lenguaje y renderer de diagramas para secuencia, clases, actividad, componentes, estados, objetos, despliegue, timing, mapas mentales y arquitectura. Permite mantener diagramas en control de versiones y generar imagenes desde texto compacto.\n\nSe usa en documentacion de arquitectura de software, revisiones de diseno, especificaciones tecnicas, wikis, diagramas generados en CI y proyectos que prefieren diagramas versionables a archivos de dibujo editados manualmente."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/powershell.ts
 var powershell_exports = {};
 __export(powershell_exports, {
@@ -2410,6 +2904,44 @@ var init_powershell = __esm({
   }
 });
 
+// src/languages/prolog.ts
+var prolog_exports = {};
+__export(prolog_exports, {
+  prolog: () => prolog
+});
+var prolog;
+var init_prolog = __esm({
+  "src/languages/prolog.ts"() {
+    prolog = {
+      slug: "prolog",
+      publishedDate: "1972-01-01",
+      extensions: [".pl", ".pro", ".prolog", ".P"],
+      author: "Alain Colmerauer, Philippe Roussel, Robert Kowalski",
+      website: "https://www.swi-prolog.org",
+      paradigms: ["logic", "declarative", "relational", "constraint"],
+      tooling: {
+        runtimes: ["SWI-Prolog", "GNU Prolog", "Scryer Prolog"],
+        packageManagers: ["SWI-Prolog pack"],
+        ecosystems: ["Logic Programming", "AI", "Expert Systems", "Constraint Solving"]
+      },
+      version: "SWI-Prolog 10.0",
+      logo: "https://www.swi-prolog.org/icons/swipl.png",
+      i18n: {
+        en: {
+          name: "Prolog",
+          description: "A logic programming language based on facts, rules, queries, and unification.",
+          longDescription: "Prolog expresses programs as relations using facts, rules, terms, predicates, unification, backtracking, recursion, and constraint logic programming. Rather than spelling out step-by-step control flow, programs describe what is true and let the engine search for solutions.\n\nIt is used for symbolic AI, expert systems, theorem proving, language processing, rule engines, planning, scheduling, constraint solving, education, and domains where relational reasoning is more natural than imperative control flow."
+        },
+        es: {
+          name: "Prolog",
+          description: "Un lenguaje de programacion logica basado en hechos, reglas, consultas y unificacion.",
+          longDescription: "Prolog expresa programas como relaciones usando hechos, reglas, terminos, predicados, unificacion, backtracking, recursion y programacion logica con restricciones. En vez de detallar flujo de control paso a paso, los programas describen que es verdadero y el motor busca soluciones.\n\nSe usa en IA simbolica, sistemas expertos, demostracion de teoremas, procesamiento de lenguaje, motores de reglas, planificacion, scheduling, resolucion de restricciones, educacion y dominios donde el razonamiento relacional es mas natural que el control imperativo."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/protobuf.ts
 var protobuf_exports = {};
 __export(protobuf_exports, {
@@ -2524,6 +3056,44 @@ var init_python = __esm({
   }
 });
 
+// src/languages/qml.ts
+var qml_exports = {};
+__export(qml_exports, {
+  qml: () => qml
+});
+var qml;
+var init_qml = __esm({
+  "src/languages/qml.ts"() {
+    qml = {
+      slug: "qml",
+      publishedDate: "2009-01-01",
+      extensions: [".qml", ".qmltypes", ".qmlproject"],
+      author: "Qt Company / Qt Project",
+      website: "https://doc.qt.io/qt-6/qmlapplications.html",
+      paradigms: ["declarative", "reactive", "component-oriented", "ui"],
+      tooling: {
+        runtimes: ["Qt", "Qt Quick"],
+        packageManagers: ["Conan", "vcpkg", "Qt Installer"],
+        ecosystems: ["Desktop UI", "Embedded UI", "Mobile UI", "Qt"]
+      },
+      version: "Qt 6.11.1",
+      logo: "https://cdn.simpleicons.org/qt/41CD52",
+      i18n: {
+        en: {
+          name: "QML",
+          description: "Qt's declarative language for building fluid, component-based user interfaces.",
+          longDescription: "QML is a declarative language for Qt Quick applications, combining object trees, properties, bindings, signals, states, animations, JavaScript expressions, and reusable components. It is designed for building dynamic interfaces that connect naturally to C++ and Qt APIs.\n\nIt is used in desktop applications, embedded devices, mobile interfaces, automotive displays, industrial controls, media systems, and cross-platform Qt projects that need responsive and animated UI layers."
+        },
+        es: {
+          name: "QML",
+          description: "El lenguaje declarativo de Qt para crear interfaces fluidas basadas en componentes.",
+          longDescription: "QML es un lenguaje declarativo para aplicaciones Qt Quick que combina arboles de objetos, propiedades, bindings, senales, estados, animaciones, expresiones JavaScript y componentes reutilizables. Esta pensado para crear interfaces dinamicas que se conectan de forma natural con C++ y las APIs de Qt.\n\nSe usa en aplicaciones de escritorio, dispositivos embebidos, interfaces moviles, pantallas automotrices, controles industriales, sistemas multimedia y proyectos Qt multiplataforma que necesitan capas UI responsivas y animadas."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/r.ts
 var r_exports = {};
 __export(r_exports, {
@@ -2899,6 +3469,44 @@ var init_sql = __esm({
   }
 });
 
+// src/languages/starlark.ts
+var starlark_exports = {};
+__export(starlark_exports, {
+  starlark: () => starlark
+});
+var starlark;
+var init_starlark = __esm({
+  "src/languages/starlark.ts"() {
+    starlark = {
+      slug: "starlark",
+      publishedDate: "2015-03-25",
+      extensions: [".bzl", ".star", ".sky"],
+      author: "Google / Bazel contributors",
+      website: "https://bazel.build/rules/language",
+      paradigms: ["scripting", "configuration", "deterministic", "imperative"],
+      tooling: {
+        runtimes: ["Bazel", "Buck2", "Starlark Go"],
+        packageManagers: ["Bzlmod", "Bazel Central Registry"],
+        ecosystems: ["Build Systems", "Configuration", "Monorepos", "Tooling"]
+      },
+      version: "Bazel Starlark",
+      logo: "https://cdn.simpleicons.org/bazel/43A047",
+      i18n: {
+        en: {
+          name: "Starlark",
+          description: "A deterministic Python-like scripting language for build and configuration tools.",
+          longDescription: "Starlark is a small, deterministic language with Python-like syntax, designed to be embedded in larger applications. It supports functions, lists, dictionaries, comprehensions, modules, and controlled evaluation while avoiding features that make builds or configuration unpredictable.\n\nIt is best known as Bazel's extension language for rules, macros, repositories, and module extensions, but it is also embedded in other build systems and tools that need safe, reproducible scripting."
+        },
+        es: {
+          name: "Starlark",
+          description: "Un lenguaje de scripting determinista similar a Python para herramientas de build y configuracion.",
+          longDescription: "Starlark es un lenguaje pequeno y determinista con sintaxis similar a Python, disenado para embeberse en aplicaciones mas grandes. Soporta funciones, listas, diccionarios, comprehensions, modulos y evaluacion controlada, evitando caracteristicas que vuelven impredecibles los builds o la configuracion.\n\nEs conocido principalmente como el lenguaje de extension de Bazel para reglas, macros, repositorios y extensiones de modulos, pero tambien se integra en otros sistemas de build y herramientas que necesitan scripting seguro y reproducible."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/svelte.ts
 var svelte_exports = {};
 __export(svelte_exports, {
@@ -3234,6 +3842,120 @@ var init_typescript = __esm({
   }
 });
 
+// src/languages/typst.ts
+var typst_exports = {};
+__export(typst_exports, {
+  typst: () => typst
+});
+var typst;
+var init_typst = __esm({
+  "src/languages/typst.ts"() {
+    typst = {
+      slug: "typst",
+      publishedDate: "2023-03-21",
+      extensions: [".typ"],
+      author: "Typst GmbH / Typst contributors",
+      website: "https://typst.app",
+      paradigms: ["markup", "typesetting", "functional", "scripting"],
+      tooling: {
+        runtimes: ["Typst CLI", "Typst Web App"],
+        packageManagers: ["Typst Packages"],
+        ecosystems: ["Publishing", "Academic Writing", "Documentation", "Typesetting"]
+      },
+      version: "0.14.1",
+      logo: "https://cdn.simpleicons.org/typst/239DAD",
+      i18n: {
+        en: {
+          name: "Typst",
+          description: "A modern markup and scripting language for typesetting documents and PDFs.",
+          longDescription: "Typst combines lightweight markup, layout primitives, functions, variables, packages, math notation, bibliographies, templates, and scripting in a fast typesetting system. It aims to make professional document production more programmable and approachable than traditional TeX workflows.\n\nIt is used for academic papers, reports, books, resumes, lecture notes, templates, technical documents, and publishing workflows that need reproducible PDF generation from readable source files."
+        },
+        es: {
+          name: "Typst",
+          description: "Un lenguaje moderno de marcado y scripting para componer documentos y PDFs.",
+          longDescription: "Typst combina marcado liviano, primitivas de layout, funciones, variables, paquetes, notacion matematica, bibliografias, templates y scripting en un sistema rapido de composicion. Busca hacer la produccion profesional de documentos mas programable y accesible que los flujos tradicionales con TeX.\n\nSe usa para articulos academicos, reportes, libros, CVs, apuntes de clase, templates, documentos tecnicos y flujos de publicacion que necesitan generar PDFs reproducibles desde archivos fuente legibles."
+        }
+      }
+    };
+  }
+});
+
+// src/languages/verilog.ts
+var verilog_exports = {};
+__export(verilog_exports, {
+  verilog: () => verilog
+});
+var verilog;
+var init_verilog = __esm({
+  "src/languages/verilog.ts"() {
+    verilog = {
+      slug: "verilog",
+      publishedDate: "1984-01-01",
+      extensions: [".v", ".vh", ".sv", ".svh"],
+      author: "Phil Moorby / Gateway Design Automation",
+      website: "https://standards.ieee.org/standard/1800-2023.html",
+      paradigms: ["hardware-description", "concurrent", "event-driven", "verification"],
+      tooling: {
+        runtimes: ["FPGA Toolchains", "ASIC EDA Tools", "Simulators"],
+        packageManagers: ["FuseSoC"],
+        ecosystems: ["Hardware Design", "FPGA", "ASIC", "Verification"]
+      },
+      version: "IEEE 1800-2023",
+      logo: "https://cdn.jsdelivr.net/gh/vscode-icons/vscode-icons@master/icons/file_type_verilog.svg",
+      i18n: {
+        en: {
+          name: "Verilog/SystemVerilog",
+          description: "A hardware description and verification language for digital circuits and systems.",
+          longDescription: "Verilog and SystemVerilog describe digital hardware at behavioral, register-transfer, and gate levels. The language supports modules, signals, continuous assignments, procedural blocks, timing, testbenches, assertions, interfaces, classes, and constrained random verification.\n\nIt is used for FPGA designs, ASIC development, hardware simulation, synthesis, verification environments, reusable IP blocks, and electronic design automation workflows."
+        },
+        es: {
+          name: "Verilog/SystemVerilog",
+          description: "Un lenguaje de descripcion y verificacion de hardware para circuitos y sistemas digitales.",
+          longDescription: "Verilog y SystemVerilog describen hardware digital en niveles conductual, register-transfer y de compuertas. El lenguaje soporta modulos, senales, asignaciones continuas, bloques procedurales, timing, testbenches, assertions, interfaces, clases y verificacion aleatoria restringida.\n\nSe usa en disenos FPGA, desarrollo ASIC, simulacion de hardware, sintesis, entornos de verificacion, bloques IP reutilizables y flujos de automatizacion de diseno electronico."
+        }
+      }
+    };
+  }
+});
+
+// src/languages/vhdl.ts
+var vhdl_exports = {};
+__export(vhdl_exports, {
+  vhdl: () => vhdl
+});
+var vhdl;
+var init_vhdl = __esm({
+  "src/languages/vhdl.ts"() {
+    vhdl = {
+      slug: "vhdl",
+      publishedDate: "1987-01-01",
+      extensions: [".vhd", ".vhdl"],
+      author: "U.S. Department of Defense / IEEE",
+      website: "https://standards.ieee.org/standard/1076-2019.html",
+      paradigms: ["hardware-description", "concurrent", "dataflow", "verification"],
+      tooling: {
+        runtimes: ["FPGA Toolchains", "ASIC EDA Tools", "Simulators"],
+        packageManagers: ["VUnit", "FuseSoC"],
+        ecosystems: ["Hardware Design", "FPGA", "ASIC", "Verification"]
+      },
+      version: "IEEE 1076-2019",
+      logo: "https://cdn.jsdelivr.net/gh/vscode-icons/vscode-icons@master/icons/file_type_vhdl.svg",
+      i18n: {
+        en: {
+          name: "VHDL",
+          description: "A hardware description and verification language for digital electronic systems.",
+          longDescription: "VHDL describes digital systems using entities, architectures, signals, processes, concurrent statements, packages, generics, configurations, testbenches, and strongly typed design units. It supports simulation, synthesis, and verification across multiple abstraction levels.\n\nIt is used for FPGA development, ASIC design, hardware verification, reusable IP blocks, digital signal processing, safety-critical hardware, and electronic design automation workflows."
+        },
+        es: {
+          name: "VHDL",
+          description: "Un lenguaje de descripcion y verificacion de hardware para sistemas electronicos digitales.",
+          longDescription: "VHDL describe sistemas digitales usando entidades, arquitecturas, senales, procesos, sentencias concurrentes, paquetes, generics, configuraciones, testbenches y unidades de diseno fuertemente tipadas. Soporta simulacion, sintesis y verificacion en varios niveles de abstraccion.\n\nSe usa en desarrollo FPGA, diseno ASIC, verificacion de hardware, bloques IP reutilizables, procesamiento digital de senales, hardware critico para seguridad y flujos de automatizacion de diseno electronico."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/visual-basic.ts
 var visual_basic_exports = {};
 __export(visual_basic_exports, {
@@ -3348,6 +4070,44 @@ var init_webassembly = __esm({
   }
 });
 
+// src/languages/wgsl.ts
+var wgsl_exports = {};
+__export(wgsl_exports, {
+  wgsl: () => wgsl
+});
+var wgsl;
+var init_wgsl = __esm({
+  "src/languages/wgsl.ts"() {
+    wgsl = {
+      slug: "wgsl",
+      publishedDate: "2021-05-18",
+      extensions: [".wgsl"],
+      author: "W3C GPU for the Web Working Group",
+      website: "https://www.w3.org/TR/WGSL/",
+      paradigms: ["shader", "data-parallel", "graphics", "gpu-compute"],
+      tooling: {
+        runtimes: ["WebGPU", "Browsers", "wgpu"],
+        packageManagers: ["npm", "Cargo"],
+        ecosystems: ["WebGPU", "Graphics", "GPU Programming", "Web"]
+      },
+      version: "Candidate Recommendation Draft 2026-05-07",
+      logo: "https://cdn.simpleicons.org/webgpu/005A9C",
+      i18n: {
+        en: {
+          name: "WGSL",
+          description: "The WebGPU Shading Language for portable browser and native GPU programs.",
+          longDescription: "WGSL is the shader language for WebGPU, designed for predictable validation, portability, and safety across graphics backends. It includes explicit types, address spaces, entry points, bindings, uniforms, storage buffers, textures, workgroups, and built-in functions for graphics and compute shaders.\n\nIt is used in WebGPU applications, browser rendering, native wgpu projects, visualization tools, compute workloads, creative coding, and graphics engines that target portable GPU execution."
+        },
+        es: {
+          name: "WGSL",
+          description: "El lenguaje de shading de WebGPU para programas GPU portables en navegador y nativo.",
+          longDescription: "WGSL es el lenguaje de shaders de WebGPU, disenado para validacion predecible, portabilidad y seguridad entre backends graficos. Incluye tipos explicitos, address spaces, entry points, bindings, uniforms, storage buffers, texturas, workgroups y funciones integradas para shaders graficos y compute.\n\nSe usa en aplicaciones WebGPU, rendering en navegador, proyectos nativos con wgpu, herramientas de visualizacion, cargas compute, creative coding y motores graficos que apuntan a ejecucion GPU portable."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/xaml.ts
 var xaml_exports = {};
 __export(xaml_exports, {
@@ -3608,12 +4368,16 @@ init_abap();
 init_actionscript();
 init_ada();
 init_apex();
+init_asciidoc();
 init_asp();
 init_assembly();
 init_astro();
 init_awk();
 init_bash();
 init_batch();
+init_bazel();
+init_bicep();
+init_blade();
 init_c();
 init_clojure();
 init_cmake();
@@ -3624,6 +4388,7 @@ init_crystal();
 init_csharp();
 init_css();
 init_cuda();
+init_cue();
 init_d();
 init_dart();
 init_dockerfile();
@@ -3633,6 +4398,7 @@ init_erlang();
 init_fennel();
 init_fortran();
 init_fsharp();
+init_gdscript();
 init_git();
 init_gleam();
 init_glsl();
@@ -3640,23 +4406,29 @@ init_go();
 init_gradle();
 init_graphql();
 init_groovy();
+init_handlebars();
 init_haskell();
 init_haxe();
 init_hcl();
+init_hlsl();
 init_html();
 init_ini();
 init_java();
 init_javascript();
+init_jinja();
 init_json();
 init_julia();
 init_jupyter_notebook();
 init_kotlin();
 init_less();
+init_liquid();
 init_lisp();
 init_lua();
 init_makefile();
 init_markdown();
 init_matlab();
+init_mdx();
+init_mermaid();
 init_meson();
 init_metal();
 init_nginx();
@@ -3667,10 +4439,13 @@ init_ocaml();
 init_pascal();
 init_perl();
 init_php();
+init_plantuml();
 init_powershell();
+init_prolog();
 init_protobuf();
 init_pug();
 init_python();
+init_qml();
 init_r();
 init_racket();
 init_razor();
@@ -3681,6 +4456,7 @@ init_scala();
 init_scss();
 init_solidity();
 init_sql();
+init_starlark();
 init_svelte();
 init_svg();
 init_svn();
@@ -3690,9 +4466,13 @@ init_tex();
 init_toml();
 init_twig();
 init_typescript();
+init_typst();
+init_verilog();
+init_vhdl();
 init_visual_basic();
 init_vue();
 init_webassembly();
+init_wgsl();
 init_xaml();
 init_xml();
 init_xquery();
@@ -3705,12 +4485,16 @@ var languages = [
   actionscript,
   ada,
   apex,
+  asciidoc,
   asp,
   astro,
   assembly,
   awk,
   bash,
   batch,
+  bazel,
+  bicep,
+  blade,
   c,
   cmake,
   clojure,
@@ -3720,6 +4504,7 @@ var languages = [
   csharp,
   crystal,
   css,
+  cue,
   cuda,
   d,
   dart,
@@ -3730,6 +4515,7 @@ var languages = [
   fennel,
   fortran,
   fsharp,
+  gdscript,
   git,
   gleam,
   go,
@@ -3737,23 +4523,29 @@ var languages = [
   glsl,
   graphql,
   groovy,
+  handlebars,
   haskell,
   haxe,
   hcl,
+  hlsl,
   html,
   ini,
   java,
   javascript,
+  jinja,
   json,
   jupyterNotebook,
   julia,
   kotlin,
   less,
+  liquid,
   lisp,
   lua,
   makefile,
   matlab,
   markdown,
+  mdx,
+  mermaid,
   meson,
   metal,
   svn,
@@ -3765,10 +4557,13 @@ var languages = [
   pascal,
   perl,
   php,
+  plantuml,
   powershell,
+  prolog,
   protobuf,
   pug,
   python,
+  qml,
   r,
   racket,
   razor,
@@ -3779,6 +4574,7 @@ var languages = [
   scss,
   solidity,
   sql,
+  starlark,
   svg,
   svelte,
   swift,
@@ -3787,9 +4583,13 @@ var languages = [
   toml,
   twig,
   typescript,
+  typst,
+  verilog,
+  vhdl,
   visualBasic,
   vue,
   webassembly,
+  wgsl,
   xaml,
   xml,
   xquery,
@@ -3857,6 +4657,7 @@ var languageIndex = [
   { slug: "actionscript", extensions: [".as"] },
   { slug: "ada", extensions: [".adb", ".ads", ".ada"] },
   { slug: "apex", extensions: [".cls", ".trigger"] },
+  { slug: "asciidoc", extensions: [".adoc", ".asciidoc", ".asc"] },
   { slug: "asp", extensions: [".asp", ".aspx", ".ascx", ".ashx", ".asmx", ".master"] },
   { slug: "astro", extensions: [".astro"] },
   { slug: "assembly", extensions: [".asm", ".s", ".S", ".inc"] },
@@ -3866,6 +4667,12 @@ var languageIndex = [
     extensions: [".sh", ".bash", ".bashrc", ".bash_profile", ".bash_login", ".profile"]
   },
   { slug: "batch", extensions: [".bat", ".cmd"] },
+  {
+    slug: "bazel",
+    extensions: ["BUILD.bazel", "WORKSPACE", "WORKSPACE.bazel", "MODULE.bazel"]
+  },
+  { slug: "bicep", extensions: [".bicep", ".bicepparam"] },
+  { slug: "blade", extensions: [".blade.php"] },
   { slug: "c", extensions: [".c", ".h"] },
   { slug: "cmake", extensions: ["CMakeLists.txt", ".cmake"] },
   { slug: "clojure", extensions: [".clj", ".cljs", ".cljc", ".edn", ".bb"] },
@@ -3875,6 +4682,7 @@ var languageIndex = [
   { slug: "csharp", extensions: [".cs", ".csx"] },
   { slug: "crystal", extensions: [".cr"] },
   { slug: "css", extensions: [".css"] },
+  { slug: "cue", extensions: [".cue"] },
   { slug: "cuda", extensions: [".cu", ".cuh"] },
   { slug: "d", extensions: [".d", ".di"] },
   { slug: "dart", extensions: [".dart"] },
@@ -3891,6 +4699,7 @@ var languageIndex = [
     extensions: [".f", ".for", ".ftn", ".f90", ".f95", ".f03", ".f08", ".f18", ".f23"]
   },
   { slug: "fsharp", extensions: [".fs", ".fsi", ".fsx", ".fsscript"] },
+  { slug: "gdscript", extensions: [".gd"] },
   { slug: "git", extensions: [".git", ".gitignore", ".gitattributes", ".gitmodules", ".gitkeep"] },
   { slug: "gleam", extensions: [".gleam"] },
   { slug: "go", extensions: [".go"] },
@@ -3901,23 +4710,29 @@ var languageIndex = [
   },
   { slug: "graphql", extensions: [".graphql", ".gql", ".graphqls"] },
   { slug: "groovy", extensions: [".groovy", ".gvy", ".gy", ".gsh"] },
+  { slug: "handlebars", extensions: [".hbs", ".handlebars"] },
   { slug: "haskell", extensions: [".hs", ".lhs", ".hsc", ".hs-boot", ".hsig", ".cabal"] },
   { slug: "haxe", extensions: [".hx", ".hxml"] },
   { slug: "hcl", extensions: [".hcl", ".tf", ".tfvars", ".pkr.hcl", ".nomad"] },
+  { slug: "hlsl", extensions: [".hlsl", ".fx", ".fxh", ".hlsli"] },
   { slug: "html", extensions: [".html", ".htm"] },
   { slug: "ini", extensions: [".ini"] },
   { slug: "java", extensions: [".java"] },
   { slug: "javascript", extensions: [".js", ".mjs", ".cjs", ".jsx"] },
+  { slug: "jinja", extensions: [".jinja", ".jinja2", ".j2"] },
   { slug: "json", extensions: [".json"] },
   { slug: "jupyter-notebook", extensions: [".ipynb"] },
   { slug: "julia", extensions: [".jl"] },
   { slug: "kotlin", extensions: [".kt", ".kts"] },
   { slug: "less", extensions: [".less"] },
+  { slug: "liquid", extensions: [".liquid"] },
   { slug: "lisp", extensions: [".lisp", ".lsp", ".cl", ".asd"] },
   { slug: "lua", extensions: [".lua", ".rockspec"] },
   { slug: "makefile", extensions: ["Makefile", "makefile", "GNUmakefile", ".mk", ".mak"] },
   { slug: "matlab", extensions: [".m", ".mlx"] },
   { slug: "markdown", extensions: [".md", ".markdown", ".mdown", ".mkd"] },
+  { slug: "mdx", extensions: [".mdx"] },
+  { slug: "mermaid", extensions: [".mmd", ".mermaid"] },
   { slug: "meson", extensions: ["meson.build", "meson_options.txt", "meson.options", ".wrap"] },
   { slug: "metal", extensions: [".metal"] },
   { slug: "svn", extensions: [".svn", "svnserve.conf"] },
@@ -3929,10 +4744,13 @@ var languageIndex = [
   { slug: "pascal", extensions: [".pas", ".pp", ".inc", ".lpr", ".dpr", ".dfm"] },
   { slug: "perl", extensions: [".pl", ".pm", ".pod", ".t", ".psgi"] },
   { slug: "php", extensions: [".php", ".phtml", ".php3", ".php4", ".php5", ".phps"] },
+  { slug: "plantuml", extensions: [".puml", ".plantuml", ".iuml"] },
   { slug: "powershell", extensions: [".ps1", ".psm1", ".psd1", ".ps1xml"] },
+  { slug: "prolog", extensions: [".pl", ".pro", ".prolog", ".P"] },
   { slug: "protobuf", extensions: [".proto"] },
   { slug: "pug", extensions: [".pug", ".jade"] },
   { slug: "python", extensions: [".py", ".pyw"] },
+  { slug: "qml", extensions: [".qml", ".qmltypes", ".qmlproject"] },
   { slug: "r", extensions: [".r", ".R", ".rmd", ".Rmd", ".qmd", ".Rprofile"] },
   { slug: "racket", extensions: [".rkt", ".rktd", ".rktl", ".scrbl"] },
   { slug: "razor", extensions: [".cshtml", ".razor"] },
@@ -3946,6 +4764,7 @@ var languageIndex = [
   { slug: "scss", extensions: [".scss", ".sass"] },
   { slug: "solidity", extensions: [".sol"] },
   { slug: "sql", extensions: [".sql"] },
+  { slug: "starlark", extensions: [".bzl", ".star", ".sky"] },
   { slug: "svg", extensions: [".svg", ".svgz"] },
   { slug: "svelte", extensions: [".svelte"] },
   { slug: "swift", extensions: [".swift"] },
@@ -3954,9 +4773,13 @@ var languageIndex = [
   { slug: "toml", extensions: [".toml"] },
   { slug: "twig", extensions: [".twig"] },
   { slug: "typescript", extensions: [".ts", ".tsx", ".mts", ".cts"] },
+  { slug: "typst", extensions: [".typ"] },
+  { slug: "verilog", extensions: [".v", ".vh", ".sv", ".svh"] },
+  { slug: "vhdl", extensions: [".vhd", ".vhdl"] },
   { slug: "visual-basic", extensions: [".vb"] },
   { slug: "vue", extensions: [".vue"] },
   { slug: "webassembly", extensions: [".wasm", ".wat"] },
+  { slug: "wgsl", extensions: [".wgsl"] },
   { slug: "xaml", extensions: [".xaml", ".baml"] },
   { slug: "xml", extensions: [".xml", ".xsd", ".xsl", ".xslt"] },
   { slug: "xquery", extensions: [".xq", ".xql", ".xqm", ".xquery", ".xqy"] },
@@ -3973,12 +4796,16 @@ var languageLoaders = {
   actionscript: () => Promise.resolve().then(() => (init_actionscript(), actionscript_exports)).then((module) => module.actionscript),
   ada: () => Promise.resolve().then(() => (init_ada(), ada_exports)).then((module) => module.ada),
   apex: () => Promise.resolve().then(() => (init_apex(), apex_exports)).then((module) => module.apex),
+  asciidoc: () => Promise.resolve().then(() => (init_asciidoc(), asciidoc_exports)).then((module) => module.asciidoc),
   asp: () => Promise.resolve().then(() => (init_asp(), asp_exports)).then((module) => module.asp),
   assembly: () => Promise.resolve().then(() => (init_assembly(), assembly_exports)).then((module) => module.assembly),
   astro: () => Promise.resolve().then(() => (init_astro(), astro_exports)).then((module) => module.astro),
   awk: () => Promise.resolve().then(() => (init_awk(), awk_exports)).then((module) => module.awk),
   bash: () => Promise.resolve().then(() => (init_bash(), bash_exports)).then((module) => module.bash),
   batch: () => Promise.resolve().then(() => (init_batch(), batch_exports)).then((module) => module.batch),
+  bazel: () => Promise.resolve().then(() => (init_bazel(), bazel_exports)).then((module) => module.bazel),
+  bicep: () => Promise.resolve().then(() => (init_bicep(), bicep_exports)).then((module) => module.bicep),
+  blade: () => Promise.resolve().then(() => (init_blade(), blade_exports)).then((module) => module.blade),
   c: () => Promise.resolve().then(() => (init_c(), c_exports)).then((module) => module.c),
   cmake: () => Promise.resolve().then(() => (init_cmake(), cmake_exports)).then((module) => module.cmake),
   clojure: () => Promise.resolve().then(() => (init_clojure(), clojure_exports)).then((module) => module.clojure),
@@ -3988,6 +4815,7 @@ var languageLoaders = {
   csharp: () => Promise.resolve().then(() => (init_csharp(), csharp_exports)).then((module) => module.csharp),
   crystal: () => Promise.resolve().then(() => (init_crystal(), crystal_exports)).then((module) => module.crystal),
   css: () => Promise.resolve().then(() => (init_css(), css_exports)).then((module) => module.css),
+  cue: () => Promise.resolve().then(() => (init_cue(), cue_exports)).then((module) => module.cue),
   cuda: () => Promise.resolve().then(() => (init_cuda(), cuda_exports)).then((module) => module.cuda),
   d: () => Promise.resolve().then(() => (init_d(), d_exports)).then((module) => module.d),
   dart: () => Promise.resolve().then(() => (init_dart(), dart_exports)).then((module) => module.dart),
@@ -3998,6 +4826,7 @@ var languageLoaders = {
   fennel: () => Promise.resolve().then(() => (init_fennel(), fennel_exports)).then((module) => module.fennel),
   fortran: () => Promise.resolve().then(() => (init_fortran(), fortran_exports)).then((module) => module.fortran),
   fsharp: () => Promise.resolve().then(() => (init_fsharp(), fsharp_exports)).then((module) => module.fsharp),
+  gdscript: () => Promise.resolve().then(() => (init_gdscript(), gdscript_exports)).then((module) => module.gdscript),
   git: () => Promise.resolve().then(() => (init_git(), git_exports)).then((module) => module.git),
   gleam: () => Promise.resolve().then(() => (init_gleam(), gleam_exports)).then((module) => module.gleam),
   go: () => Promise.resolve().then(() => (init_go(), go_exports)).then((module) => module.go),
@@ -4005,23 +4834,29 @@ var languageLoaders = {
   glsl: () => Promise.resolve().then(() => (init_glsl(), glsl_exports)).then((module) => module.glsl),
   graphql: () => Promise.resolve().then(() => (init_graphql(), graphql_exports)).then((module) => module.graphql),
   groovy: () => Promise.resolve().then(() => (init_groovy(), groovy_exports)).then((module) => module.groovy),
+  handlebars: () => Promise.resolve().then(() => (init_handlebars(), handlebars_exports)).then((module) => module.handlebars),
   haskell: () => Promise.resolve().then(() => (init_haskell(), haskell_exports)).then((module) => module.haskell),
   haxe: () => Promise.resolve().then(() => (init_haxe(), haxe_exports)).then((module) => module.haxe),
   hcl: () => Promise.resolve().then(() => (init_hcl(), hcl_exports)).then((module) => module.hcl),
+  hlsl: () => Promise.resolve().then(() => (init_hlsl(), hlsl_exports)).then((module) => module.hlsl),
   html: () => Promise.resolve().then(() => (init_html(), html_exports)).then((module) => module.html),
   ini: () => Promise.resolve().then(() => (init_ini(), ini_exports)).then((module) => module.ini),
   java: () => Promise.resolve().then(() => (init_java(), java_exports)).then((module) => module.java),
   javascript: () => Promise.resolve().then(() => (init_javascript(), javascript_exports)).then((module) => module.javascript),
+  jinja: () => Promise.resolve().then(() => (init_jinja(), jinja_exports)).then((module) => module.jinja),
   json: () => Promise.resolve().then(() => (init_json(), json_exports)).then((module) => module.json),
   "jupyter-notebook": () => Promise.resolve().then(() => (init_jupyter_notebook(), jupyter_notebook_exports)).then((module) => module.jupyterNotebook),
   julia: () => Promise.resolve().then(() => (init_julia(), julia_exports)).then((module) => module.julia),
   kotlin: () => Promise.resolve().then(() => (init_kotlin(), kotlin_exports)).then((module) => module.kotlin),
   less: () => Promise.resolve().then(() => (init_less(), less_exports)).then((module) => module.less),
+  liquid: () => Promise.resolve().then(() => (init_liquid(), liquid_exports)).then((module) => module.liquid),
   lisp: () => Promise.resolve().then(() => (init_lisp(), lisp_exports)).then((module) => module.lisp),
   lua: () => Promise.resolve().then(() => (init_lua(), lua_exports)).then((module) => module.lua),
   makefile: () => Promise.resolve().then(() => (init_makefile(), makefile_exports)).then((module) => module.makefile),
   matlab: () => Promise.resolve().then(() => (init_matlab(), matlab_exports)).then((module) => module.matlab),
   markdown: () => Promise.resolve().then(() => (init_markdown(), markdown_exports)).then((module) => module.markdown),
+  mdx: () => Promise.resolve().then(() => (init_mdx(), mdx_exports)).then((module) => module.mdx),
+  mermaid: () => Promise.resolve().then(() => (init_mermaid(), mermaid_exports)).then((module) => module.mermaid),
   meson: () => Promise.resolve().then(() => (init_meson(), meson_exports)).then((module) => module.meson),
   metal: () => Promise.resolve().then(() => (init_metal(), metal_exports)).then((module) => module.metal),
   svn: () => Promise.resolve().then(() => (init_svn(), svn_exports)).then((module) => module.svn),
@@ -4033,10 +4868,13 @@ var languageLoaders = {
   pascal: () => Promise.resolve().then(() => (init_pascal(), pascal_exports)).then((module) => module.pascal),
   perl: () => Promise.resolve().then(() => (init_perl(), perl_exports)).then((module) => module.perl),
   php: () => Promise.resolve().then(() => (init_php(), php_exports)).then((module) => module.php),
+  plantuml: () => Promise.resolve().then(() => (init_plantuml(), plantuml_exports)).then((module) => module.plantuml),
   powershell: () => Promise.resolve().then(() => (init_powershell(), powershell_exports)).then((module) => module.powershell),
+  prolog: () => Promise.resolve().then(() => (init_prolog(), prolog_exports)).then((module) => module.prolog),
   protobuf: () => Promise.resolve().then(() => (init_protobuf(), protobuf_exports)).then((module) => module.protobuf),
   pug: () => Promise.resolve().then(() => (init_pug(), pug_exports)).then((module) => module.pug),
   python: () => Promise.resolve().then(() => (init_python(), python_exports)).then((module) => module.python),
+  qml: () => Promise.resolve().then(() => (init_qml(), qml_exports)).then((module) => module.qml),
   r: () => Promise.resolve().then(() => (init_r(), r_exports)).then((module) => module.r),
   racket: () => Promise.resolve().then(() => (init_racket(), racket_exports)).then((module) => module.racket),
   razor: () => Promise.resolve().then(() => (init_razor(), razor_exports)).then((module) => module.razor),
@@ -4047,6 +4885,7 @@ var languageLoaders = {
   scss: () => Promise.resolve().then(() => (init_scss(), scss_exports)).then((module) => module.scss),
   solidity: () => Promise.resolve().then(() => (init_solidity(), solidity_exports)).then((module) => module.solidity),
   sql: () => Promise.resolve().then(() => (init_sql(), sql_exports)).then((module) => module.sql),
+  starlark: () => Promise.resolve().then(() => (init_starlark(), starlark_exports)).then((module) => module.starlark),
   svelte: () => Promise.resolve().then(() => (init_svelte(), svelte_exports)).then((module) => module.svelte),
   svg: () => Promise.resolve().then(() => (init_svg(), svg_exports)).then((module) => module.svg),
   swift: () => Promise.resolve().then(() => (init_swift(), swift_exports)).then((module) => module.swift),
@@ -4055,9 +4894,13 @@ var languageLoaders = {
   toml: () => Promise.resolve().then(() => (init_toml(), toml_exports)).then((module) => module.toml),
   twig: () => Promise.resolve().then(() => (init_twig(), twig_exports)).then((module) => module.twig),
   typescript: () => Promise.resolve().then(() => (init_typescript(), typescript_exports)).then((module) => module.typescript),
+  typst: () => Promise.resolve().then(() => (init_typst(), typst_exports)).then((module) => module.typst),
+  verilog: () => Promise.resolve().then(() => (init_verilog(), verilog_exports)).then((module) => module.verilog),
+  vhdl: () => Promise.resolve().then(() => (init_vhdl(), vhdl_exports)).then((module) => module.vhdl),
   "visual-basic": () => Promise.resolve().then(() => (init_visual_basic(), visual_basic_exports)).then((module) => module.visualBasic),
   vue: () => Promise.resolve().then(() => (init_vue(), vue_exports)).then((module) => module.vue),
   webassembly: () => Promise.resolve().then(() => (init_webassembly(), webassembly_exports)).then((module) => module.webassembly),
+  wgsl: () => Promise.resolve().then(() => (init_wgsl(), wgsl_exports)).then((module) => module.wgsl),
   xaml: () => Promise.resolve().then(() => (init_xaml(), xaml_exports)).then((module) => module.xaml),
   xml: () => Promise.resolve().then(() => (init_xml(), xml_exports)).then((module) => module.xml),
   xquery: () => Promise.resolve().then(() => (init_xquery(), xquery_exports)).then((module) => module.xquery),