code-languages 1.18.0 → 1.20.0

package/dist/api.cjs

@@ -122,6 +122,44 @@ var init_ada = __esm({
   }
 });
 
+// src/languages/antlr.ts
+var antlr_exports = {};
+__export(antlr_exports, {
+  antlr: () => antlr
+});
+var antlr;
+var init_antlr = __esm({
+  "src/languages/antlr.ts"() {
+    antlr = {
+      slug: "antlr",
+      publishedDate: "1989-02-01",
+      extensions: [".g4"],
+      author: "Terence Parr",
+      website: "https://www.antlr.org",
+      paradigms: ["declarative", "grammar", "parser generation"],
+      tooling: {
+        runtimes: ["ANTLR Tool", "ANTLR Runtime"],
+        packageManagers: ["Maven", "npm", "NuGet", "pip"],
+        ecosystems: ["Compilers", "Language Tools", "Static Analysis"]
+      },
+      version: "4.13.2",
+      logo: "https://raw.githubusercontent.com/vscode-icons/vscode-icons/master/icons/file_type_antlr.svg",
+      i18n: {
+        en: {
+          name: "ANTLR Grammar",
+          description: "A grammar notation used with ANTLR to generate lexers, parsers, and language tools.",
+          longDescription: "ANTLR grammars describe lexical tokens and parser rules for programming languages, data formats, query languages, and domain-specific syntaxes.\n\nThe generated parsers are used in compilers, interpreters, code analyzers, migration tools, editors, and other systems that need structured language recognition."
+        },
+        es: {
+          name: "ANTLR Grammar",
+          description: "Una notacion de gramaticas usada con ANTLR para generar lexers, parsers y herramientas de lenguaje.",
+          longDescription: "Las gramaticas ANTLR describen tokens lexicos y reglas de parser para lenguajes de programacion, formatos de datos, lenguajes de consulta y sintaxis especificas de dominio.\n\nLos parsers generados se usan en compiladores, interpretes, analizadores de codigo, herramientas de migracion, editores y otros sistemas que necesitan reconocer lenguajes de forma estructurada."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/apex.ts
 var apex_exports = {};
 __export(apex_exports, {
@@ -160,6 +198,156 @@ var init_apex = __esm({
   }
 });
 
+// src/languages/apl.ts
+var apl_exports = {};
+__export(apl_exports, {
+  apl: () => apl
+});
+var apl;
+var init_apl = __esm({
+  "src/languages/apl.ts"() {
+    apl = {
+      slug: "apl",
+      publishedDate: "1966-11-01",
+      extensions: [".apl", ".dyalog"],
+      author: "Kenneth E. Iverson",
+      website: "https://www.dyalog.com",
+      paradigms: ["array", "functional", "interactive"],
+      tooling: {
+        runtimes: ["Dyalog APL", "GNU APL", "NARS2000"],
+        ecosystems: ["Array Programming", "Data Analysis", "Financial Computing"]
+      },
+      version: "ISO/IEC 13751:2001",
+      logo: "https://raw.githubusercontent.com/vscode-icons/vscode-icons/master/icons/file_type_apl.svg",
+      i18n: {
+        en: {
+          name: "APL",
+          description: "An array-oriented language known for concise symbolic notation and interactive use.",
+          longDescription: "APL centers computation around arrays, higher-order operations, and a compact mathematical notation that can express complex transformations in very little code.\n\nIt has influenced many array languages and remains useful in exploratory analysis, financial modeling, algorithm design, and systems where terse interactive computation is valuable."
+        },
+        es: {
+          name: "APL",
+          description: "Un lenguaje orientado a arreglos conocido por su notacion simbolica concisa y uso interactivo.",
+          longDescription: "APL centra la computacion en arreglos, operaciones de orden superior y una notacion matematica compacta que puede expresar transformaciones complejas en muy poco codigo.\n\nHa influido en muchos lenguajes de arreglos y sigue siendo util en analisis exploratorio, modelos financieros, diseno de algoritmos y sistemas donde la computacion interactiva concisa aporta valor."
+        }
+      }
+    };
+  }
+});
+
+// src/languages/applescript.ts
+var applescript_exports = {};
+__export(applescript_exports, {
+  applescript: () => applescript
+});
+var applescript;
+var init_applescript = __esm({
+  "src/languages/applescript.ts"() {
+    applescript = {
+      slug: "applescript",
+      publishedDate: "1993-10-01",
+      extensions: [".applescript", ".scpt", ".scptd"],
+      author: "Apple Inc.",
+      website: "https://developer.apple.com/library/archive/documentation/AppleScript/Conceptual/AppleScriptX/AppleScriptX.html",
+      paradigms: ["scripting", "automation", "event-driven"],
+      tooling: {
+        runtimes: ["macOS", "osascript", "Script Editor"],
+        ecosystems: ["macOS", "Desktop Automation"]
+      },
+      version: "2.8",
+      logo: "https://raw.githubusercontent.com/vscode-icons/vscode-icons/master/icons/file_type_applescript.svg",
+      i18n: {
+        en: {
+          name: "AppleScript",
+          description: "A macOS scripting language for automating applications through Apple events.",
+          longDescription: "AppleScript provides an English-like syntax for controlling scriptable macOS applications, files, windows, workflows, and system services.\n\nIt is commonly used for desktop automation, publishing workflows, batch operations, application glue code, and user-facing scripts that coordinate multiple Mac apps."
+        },
+        es: {
+          name: "AppleScript",
+          description: "Un lenguaje de scripting de macOS para automatizar aplicaciones mediante Apple events.",
+          longDescription: "AppleScript ofrece una sintaxis similar al ingles para controlar aplicaciones scriptables de macOS, archivos, ventanas, flujos de trabajo y servicios del sistema.\n\nSe usa comunmente para automatizacion de escritorio, flujos editoriales, operaciones por lotes, codigo de integracion entre aplicaciones y scripts de usuario que coordinan varias apps de Mac."
+        }
+      }
+    };
+  }
+});
+
+// src/languages/arduino.ts
+var arduino_exports = {};
+__export(arduino_exports, {
+  arduino: () => arduino
+});
+var arduino;
+var init_arduino = __esm({
+  "src/languages/arduino.ts"() {
+    arduino = {
+      slug: "arduino",
+      publishedDate: "2005-01-01",
+      extensions: [".ino", ".pde"],
+      author: "Arduino",
+      website: "https://www.arduino.cc",
+      paradigms: ["imperative", "procedural", "embedded"],
+      tooling: {
+        runtimes: ["Arduino Core", "Microcontroller Firmware"],
+        packageManagers: ["Arduino Library Manager", "PlatformIO"],
+        ecosystems: ["Embedded", "IoT", "Prototyping"]
+      },
+      version: "Arduino API 1.0",
+      logo: "https://raw.githubusercontent.com/vscode-icons/vscode-icons/master/icons/file_type_arduino.svg",
+      i18n: {
+        en: {
+          name: "Arduino Sketch",
+          description: "A C/C++-based sketch format for programming Arduino boards and embedded devices.",
+          longDescription: "Arduino sketches wrap embedded C and C++ development in a beginner-friendly project model with setup and loop entry points, board cores, and hardware libraries.\n\nThey are widely used for electronics prototyping, education, robotics, sensors, IoT devices, and small firmware projects that interact directly with physical components."
+        },
+        es: {
+          name: "Arduino Sketch",
+          description: "Un formato de sketch basado en C/C++ para programar placas Arduino y dispositivos embebidos.",
+          longDescription: "Los sketches de Arduino envuelven el desarrollo embebido en C y C++ en un modelo de proyecto accesible con puntos de entrada setup y loop, cores de placas y bibliotecas de hardware.\n\nSe usan ampliamente para prototipos electronicos, educacion, robotica, sensores, dispositivos IoT y pequenos proyectos de firmware que interactuan directamente con componentes fisicos."
+        }
+      }
+    };
+  }
+});
+
+// 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, {
@@ -274,6 +462,43 @@ var init_astro = __esm({
   }
 });
 
+// src/languages/autohotkey.ts
+var autohotkey_exports = {};
+__export(autohotkey_exports, {
+  autohotkey: () => autohotkey
+});
+var autohotkey;
+var init_autohotkey = __esm({
+  "src/languages/autohotkey.ts"() {
+    autohotkey = {
+      slug: "autohotkey",
+      publishedDate: "2003-11-10",
+      extensions: [".ahk", ".ah2"],
+      author: "Chris Mallett",
+      website: "https://www.autohotkey.com",
+      paradigms: ["scripting", "automation", "event-driven", "imperative"],
+      tooling: {
+        runtimes: ["AutoHotkey"],
+        ecosystems: ["Windows", "Desktop Automation"]
+      },
+      version: "2.0",
+      logo: "https://raw.githubusercontent.com/vscode-icons/vscode-icons/master/icons/file_type_autohotkey.svg",
+      i18n: {
+        en: {
+          name: "AutoHotkey",
+          description: "A Windows scripting language for hotkeys, macros, automation, and small utilities.",
+          longDescription: "AutoHotkey scripts automate Windows workflows through hotkeys, text expansion, GUI automation, window management, keyboard and mouse control, and custom utility scripts.\n\nIt is popular for personal productivity, repetitive task automation, quick desktop tooling, application launchers, and accessibility-oriented workflows."
+        },
+        es: {
+          name: "AutoHotkey",
+          description: "Un lenguaje de scripting para Windows orientado a atajos, macros, automatizacion y utilidades pequenas.",
+          longDescription: "Los scripts de AutoHotkey automatizan flujos de Windows mediante atajos, expansion de texto, automatizacion de GUI, gestion de ventanas, control de teclado y mouse, y utilidades personalizadas.\n\nEs popular para productividad personal, automatizacion de tareas repetitivas, herramientas rapidas de escritorio, lanzadores de aplicaciones y flujos orientados a accesibilidad."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/awk.ts
 var awk_exports = {};
 __export(awk_exports, {
@@ -387,6 +612,44 @@ 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, {
@@ -425,6 +688,44 @@ var init_bicep = __esm({
   }
 });
 
+// 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, {
@@ -613,6 +914,44 @@ var init_coffeescript = __esm({
   }
 });
 
+// src/languages/coldfusion.ts
+var coldfusion_exports = {};
+__export(coldfusion_exports, {
+  coldfusion: () => coldfusion
+});
+var coldfusion;
+var init_coldfusion = __esm({
+  "src/languages/coldfusion.ts"() {
+    coldfusion = {
+      slug: "coldfusion",
+      publishedDate: "1995-07-01",
+      extensions: [".cfm", ".cfml", ".cfc"],
+      author: "Allaire / Adobe",
+      website: "https://www.adobe.com/products/coldfusion-family.html",
+      paradigms: ["tag-based", "object-oriented", "scripting", "web"],
+      tooling: {
+        runtimes: ["Adobe ColdFusion", "Lucee"],
+        packageManagers: ["CommandBox"],
+        ecosystems: ["Web", "JVM", "Enterprise"]
+      },
+      version: "ColdFusion 2025",
+      logo: "https://raw.githubusercontent.com/vscode-icons/vscode-icons/master/icons/file_type_cf.svg",
+      i18n: {
+        en: {
+          name: "ColdFusion",
+          description: "A JVM-based web language and platform using CFML tags, scripts, and components.",
+          longDescription: "ColdFusion uses CFML to build server-rendered web applications, APIs, scheduled jobs, and enterprise integrations with a mix of tag-based markup and script syntax.\n\nIts ecosystem includes Adobe ColdFusion, Lucee, CFML components, database access, templating, mail, file processing, and tooling for long-lived business applications."
+        },
+        es: {
+          name: "ColdFusion",
+          description: "Un lenguaje y plataforma web sobre JVM que usa etiquetas, scripts y componentes CFML.",
+          longDescription: "ColdFusion usa CFML para crear aplicaciones web renderizadas en servidor, APIs, tareas programadas e integraciones empresariales con una mezcla de marcado basado en etiquetas y sintaxis de script.\n\nSu ecosistema incluye Adobe ColdFusion, Lucee, componentes CFML, acceso a bases de datos, plantillas, correo, procesamiento de archivos y herramientas para aplicaciones de negocio de larga vida."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/cpp.ts
 var cpp_exports = {};
 __export(cpp_exports, {
@@ -836,6 +1175,44 @@ var init_cue = __esm({
   }
 });
 
+// src/languages/cython.ts
+var cython_exports = {};
+__export(cython_exports, {
+  cython: () => cython
+});
+var cython;
+var init_cython = __esm({
+  "src/languages/cython.ts"() {
+    cython = {
+      slug: "cython",
+      publishedDate: "2007-07-28",
+      extensions: [".pyx", ".pxd", ".pxi"],
+      author: "Robert Bradshaw, Stefan Behnel, Dag Sverre Seljebotn, Greg Ewing, et al.",
+      website: "https://cython.org",
+      paradigms: ["object-oriented", "imperative", "procedural"],
+      tooling: {
+        runtimes: ["CPython"],
+        packageManagers: ["pip", "conda", "Poetry"],
+        ecosystems: ["Python", "Native Extensions", "Scientific Computing"]
+      },
+      version: "3.1.4",
+      logo: "https://raw.githubusercontent.com/vscode-icons/vscode-icons/master/icons/file_type_cython.svg",
+      i18n: {
+        en: {
+          name: "Cython",
+          description: "A Python superset for compiling typed Python-like code into C extension modules.",
+          longDescription: "Cython extends Python with optional static types, C declarations, and direct calls into C and C++ APIs, allowing Python code to be compiled into native extension modules.\n\nIt is widely used to speed up numeric code, wrap native libraries, build scientific Python packages, and write performance-sensitive components while keeping Python-like syntax."
+        },
+        es: {
+          name: "Cython",
+          description: "Un superconjunto de Python para compilar codigo tipado similar a Python como extensiones en C.",
+          longDescription: "Cython extiende Python con tipos estaticos opcionales, declaraciones de C y llamadas directas a APIs de C y C++, permitiendo compilar codigo Python en modulos de extension nativos.\n\nSe usa ampliamente para acelerar codigo numerico, envolver bibliotecas nativas, crear paquetes cientificos de Python y escribir componentes sensibles al rendimiento manteniendo una sintaxis parecida a Python."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/d.ts
 var d_exports = {};
 __export(d_exports, {
@@ -1025,6 +1402,44 @@ var init_elm = __esm({
   }
 });
 
+// src/languages/erb.ts
+var erb_exports = {};
+__export(erb_exports, {
+  erb: () => erb
+});
+var erb;
+var init_erb = __esm({
+  "src/languages/erb.ts"() {
+    erb = {
+      slug: "erb",
+      publishedDate: "2000-01-01",
+      extensions: [".erb", ".rhtml", ".html.erb"],
+      author: "Masatoshi Seki / Ruby",
+      website: "https://ruby-doc.org/stdlib/erb/",
+      paradigms: ["templating", "embedded", "markup"],
+      tooling: {
+        runtimes: ["Ruby", "Ruby on Rails"],
+        packageManagers: ["RubyGems", "Bundler"],
+        ecosystems: ["Web", "Ruby", "Static Sites"]
+      },
+      version: "Ruby stdlib",
+      logo: "https://commons.wikimedia.org/wiki/Special:FilePath/Ruby_logo.svg",
+      i18n: {
+        en: {
+          name: "ERB",
+          description: "A Ruby templating system for embedding Ruby code inside text documents.",
+          longDescription: "ERB templates combine plain text, HTML, XML, or configuration output with embedded Ruby expressions and control flow markers.\n\nThey are commonly used in Ruby on Rails views, static site generators, configuration generation, email templates, and any Ruby workflow that needs programmable text rendering."
+        },
+        es: {
+          name: "ERB",
+          description: "Un sistema de plantillas de Ruby para incrustar codigo Ruby dentro de documentos de texto.",
+          longDescription: "Las plantillas ERB combinan texto plano, HTML, XML o salidas de configuracion con expresiones Ruby incrustadas y marcadores de control de flujo.\n\nSe usan comunmente en vistas de Ruby on Rails, generadores de sitios estaticos, generacion de configuracion, plantillas de correo y cualquier flujo Ruby que necesite renderizado programable de texto."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/erlang.ts
 var erlang_exports = {};
 __export(erlang_exports, {
@@ -1101,6 +1516,43 @@ var init_fennel = __esm({
   }
 });
 
+// src/languages/forth.ts
+var forth_exports = {};
+__export(forth_exports, {
+  forth: () => forth
+});
+var forth;
+var init_forth = __esm({
+  "src/languages/forth.ts"() {
+    forth = {
+      slug: "forth",
+      publishedDate: "1970-01-01",
+      extensions: [".fs", ".fth", ".forth", ".4th"],
+      author: "Charles H. Moore",
+      website: "https://forth-standard.org",
+      paradigms: ["stack-based", "concatenative", "procedural", "interactive"],
+      tooling: {
+        runtimes: ["Gforth", "SwiftForth", "VFX Forth"],
+        ecosystems: ["Embedded", "Firmware", "Language Implementation"]
+      },
+      version: "Forth 2012",
+      logo: "https://upload.wikimedia.org/wikipedia/commons/a/a5/Gforth_Logo.png",
+      i18n: {
+        en: {
+          name: "Forth",
+          description: "A stack-based extensible language used for embedded systems, firmware, and tooling.",
+          longDescription: "Forth programs are built from small words that operate on a data stack, encouraging interactive development, compact runtimes, and language extension from within the program itself.\n\nIt has a long history in embedded systems, boot firmware, instrumentation, space hardware, and custom control environments where simplicity and direct hardware access matter."
+        },
+        es: {
+          name: "Forth",
+          description: "Un lenguaje extensible basado en pila usado en sistemas embebidos, firmware y herramientas.",
+          longDescription: "Los programas Forth se construyen con palabras pequenas que operan sobre una pila de datos, fomentando desarrollo interactivo, runtimes compactos y extension del lenguaje desde el propio programa.\n\nTiene una larga historia en sistemas embebidos, firmware de arranque, instrumentacion, hardware espacial y entornos de control personalizados donde importan la simplicidad y el acceso directo al hardware."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/fortran.ts
 var fortran_exports = {};
 __export(fortran_exports, {
@@ -1632,6 +2084,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, {
@@ -1848,6 +2338,44 @@ var init_json = __esm({
   }
 });
 
+// src/languages/jsonnet.ts
+var jsonnet_exports = {};
+__export(jsonnet_exports, {
+  jsonnet: () => jsonnet
+});
+var jsonnet;
+var init_jsonnet = __esm({
+  "src/languages/jsonnet.ts"() {
+    jsonnet = {
+      slug: "jsonnet",
+      publishedDate: "2014-04-01",
+      extensions: [".jsonnet", ".libsonnet"],
+      author: "Google",
+      website: "https://jsonnet.org",
+      paradigms: ["functional", "declarative", "configuration"],
+      tooling: {
+        runtimes: ["Jsonnet", "go-jsonnet"],
+        packageManagers: ["jsonnet-bundler"],
+        ecosystems: ["Configuration", "Kubernetes", "Infrastructure"]
+      },
+      version: "0.21.0",
+      logo: "https://jsonnet.org/img/isologo.svg",
+      i18n: {
+        en: {
+          name: "Jsonnet",
+          description: "A data templating language for generating JSON and related configuration formats.",
+          longDescription: "Jsonnet adds variables, functions, imports, conditionals, object composition, and other programming constructs to a JSON-like syntax for generating structured data.\n\nIt is commonly used for Kubernetes manifests, infrastructure configuration, application settings, and reusable configuration libraries where plain JSON becomes repetitive."
+        },
+        es: {
+          name: "Jsonnet",
+          description: "Un lenguaje de plantillas de datos para generar JSON y formatos de configuracion relacionados.",
+          longDescription: "Jsonnet agrega variables, funciones, imports, condicionales, composicion de objetos y otros constructos de programacion a una sintaxis similar a JSON para generar datos estructurados.\n\nSe usa comunmente en manifiestos de Kubernetes, configuracion de infraestructura, ajustes de aplicaciones y bibliotecas reutilizables de configuracion cuando JSON plano se vuelve repetitivo."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/julia.ts
 var julia_exports = {};
 __export(julia_exports, {
@@ -2752,6 +3280,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, {
@@ -2866,6 +3432,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, {
@@ -3241,6 +3845,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, {
@@ -3576,6 +4218,44 @@ 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, {
@@ -3614,6 +4294,44 @@ var init_verilog = __esm({
   }
 });
 
+// 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, {
@@ -3728,6 +4446,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, {
@@ -3987,32 +4743,44 @@ var init_zsh = __esm({
 init_abap();
 init_actionscript();
 init_ada();
+init_antlr();
 init_apex();
+init_apl();
+init_applescript();
+init_arduino();
+init_asciidoc();
 init_asp();
 init_assembly();
 init_astro();
+init_autohotkey();
 init_awk();
 init_bash();
 init_batch();
+init_bazel();
 init_bicep();
+init_blade();
 init_c();
 init_clojure();
 init_cmake();
 init_cobol();
 init_coffeescript();
+init_coldfusion();
 init_cpp();
 init_crystal();
 init_csharp();
 init_css();
 init_cuda();
 init_cue();
+init_cython();
 init_d();
 init_dart();
 init_dockerfile();
 init_elixir();
 init_elm();
+init_erb();
 init_erlang();
 init_fennel();
+init_forth();
 init_fortran();
 init_fsharp();
 init_gdscript();
@@ -4027,12 +4795,14 @@ init_handlebars();
 init_haskell();
 init_haxe();
 init_hcl();
+init_hlsl();
 init_html();
 init_ini();
 init_java();
 init_javascript();
 init_jinja();
 init_json();
+init_jsonnet();
 init_julia();
 init_jupyter_notebook();
 init_kotlin();
@@ -4057,9 +4827,11 @@ init_perl();
 init_php();
 init_plantuml();
 init_powershell();
+init_prolog();
 init_protobuf();
 init_pug();
 init_python();
+init_qml();
 init_r();
 init_racket();
 init_razor();
@@ -4070,6 +4842,7 @@ init_scala();
 init_scss();
 init_solidity();
 init_sql();
+init_starlark();
 init_svelte();
 init_svg();
 init_svn();
@@ -4079,10 +4852,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();
@@ -4094,18 +4870,27 @@ var languages = [
   abap,
   actionscript,
   ada,
+  antlr,
   apex,
+  apl,
+  applescript,
+  arduino,
+  asciidoc,
   asp,
   astro,
   assembly,
   awk,
+  autohotkey,
   bash,
   batch,
+  bazel,
   bicep,
+  blade,
   c,
   cmake,
   clojure,
   coffeescript,
+  coldfusion,
   cobol,
   cpp,
   csharp,
@@ -4113,14 +4898,17 @@ var languages = [
   css,
   cue,
   cuda,
+  cython,
   d,
   dart,
   dockerfile,
   elixir,
   elm,
+  erb,
   erlang,
   fennel,
   fortran,
+  forth,
   fsharp,
   gdscript,
   git,
@@ -4134,12 +4922,14 @@ var languages = [
   haskell,
   haxe,
   hcl,
+  hlsl,
   html,
   ini,
   java,
   javascript,
   jinja,
   json,
+  jsonnet,
   jupyterNotebook,
   julia,
   kotlin,
@@ -4165,9 +4955,11 @@ var languages = [
   php,
   plantuml,
   powershell,
+  prolog,
   protobuf,
   pug,
   python,
+  qml,
   r,
   racket,
   razor,
@@ -4178,6 +4970,7 @@ var languages = [
   scss,
   solidity,
   sql,
+  starlark,
   svg,
   svelte,
   swift,
@@ -4186,10 +4979,13 @@ var languages = [
   toml,
   twig,
   typescript,
+  typst,
   verilog,
+  vhdl,
   visualBasic,
   vue,
   webassembly,
+  wgsl,
   xaml,
   xml,
   xquery,
@@ -4256,21 +5052,33 @@ var languageIndex = [
   { slug: "abap", extensions: [".abap"] },
   { slug: "actionscript", extensions: [".as"] },
   { slug: "ada", extensions: [".adb", ".ads", ".ada"] },
+  { slug: "antlr", extensions: [".g4"] },
   { slug: "apex", extensions: [".cls", ".trigger"] },
+  { slug: "apl", extensions: [".apl", ".dyalog"] },
+  { slug: "applescript", extensions: [".applescript", ".scpt", ".scptd"] },
+  { slug: "arduino", extensions: [".ino", ".pde"] },
+  { 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"] },
   { slug: "awk", extensions: [".awk"] },
+  { slug: "autohotkey", extensions: [".ahk", ".ah2"] },
   {
     slug: "bash",
     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"] },
   { slug: "coffeescript", extensions: [".coffee", ".litcoffee", ".cson"] },
+  { slug: "coldfusion", extensions: [".cfm", ".cfml", ".cfc"] },
   { slug: "cobol", extensions: [".cob", ".cbl", ".cobol", ".cpy"] },
   { slug: "cpp", extensions: [".cpp", ".cc", ".cxx", ".h", ".hpp", ".hh", ".hxx"] },
   { slug: "csharp", extensions: [".cs", ".csx"] },
@@ -4278,11 +5086,13 @@ var languageIndex = [
   { slug: "css", extensions: [".css"] },
   { slug: "cue", extensions: [".cue"] },
   { slug: "cuda", extensions: [".cu", ".cuh"] },
+  { slug: "cython", extensions: [".pyx", ".pxd", ".pxi"] },
   { slug: "d", extensions: [".d", ".di"] },
   { slug: "dart", extensions: [".dart"] },
   { slug: "dockerfile", extensions: ["Dockerfile", ".dockerfile"] },
   { slug: "elixir", extensions: [".ex", ".exs", ".eex", ".leex", ".heex"] },
   { slug: "elm", extensions: [".elm"] },
+  { slug: "erb", extensions: [".erb", ".rhtml", ".html.erb"] },
   {
     slug: "erlang",
     extensions: [".erl", ".hrl", ".app.src", ".escript", ".xrl", ".yrl", "rebar.config"]
@@ -4292,6 +5102,7 @@ var languageIndex = [
     slug: "fortran",
     extensions: [".f", ".for", ".ftn", ".f90", ".f95", ".f03", ".f08", ".f18", ".f23"]
   },
+  { slug: "forth", extensions: [".fs", ".fth", ".forth", ".4th"] },
   { slug: "fsharp", extensions: [".fs", ".fsi", ".fsx", ".fsscript"] },
   { slug: "gdscript", extensions: [".gd"] },
   { slug: "git", extensions: [".git", ".gitignore", ".gitattributes", ".gitmodules", ".gitkeep"] },
@@ -4308,12 +5119,14 @@ var languageIndex = [
   { 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: "jsonnet", extensions: [".jsonnet", ".libsonnet"] },
   { slug: "jupyter-notebook", extensions: [".ipynb"] },
   { slug: "julia", extensions: [".jl"] },
   { slug: "kotlin", extensions: [".kt", ".kts"] },
@@ -4339,9 +5152,11 @@ var languageIndex = [
   { 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"] },
@@ -4355,6 +5170,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"] },
@@ -4363,10 +5179,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"] },
@@ -4382,33 +5201,45 @@ var languageLoaders = {
   abap: () => Promise.resolve().then(() => (init_abap(), abap_exports)).then((module) => module.abap),
   actionscript: () => Promise.resolve().then(() => (init_actionscript(), actionscript_exports)).then((module) => module.actionscript),
   ada: () => Promise.resolve().then(() => (init_ada(), ada_exports)).then((module) => module.ada),
+  antlr: () => Promise.resolve().then(() => (init_antlr(), antlr_exports)).then((module) => module.antlr),
   apex: () => Promise.resolve().then(() => (init_apex(), apex_exports)).then((module) => module.apex),
+  apl: () => Promise.resolve().then(() => (init_apl(), apl_exports)).then((module) => module.apl),
+  applescript: () => Promise.resolve().then(() => (init_applescript(), applescript_exports)).then((module) => module.applescript),
+  arduino: () => Promise.resolve().then(() => (init_arduino(), arduino_exports)).then((module) => module.arduino),
+  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),
+  autohotkey: () => Promise.resolve().then(() => (init_autohotkey(), autohotkey_exports)).then((module) => module.autohotkey),
   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),
   cobol: () => Promise.resolve().then(() => (init_cobol(), cobol_exports)).then((module) => module.cobol),
   coffeescript: () => Promise.resolve().then(() => (init_coffeescript(), coffeescript_exports)).then((module) => module.coffeescript),
+  coldfusion: () => Promise.resolve().then(() => (init_coldfusion(), coldfusion_exports)).then((module) => module.coldfusion),
   cpp: () => Promise.resolve().then(() => (init_cpp(), cpp_exports)).then((module) => module.cpp),
   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),
+  cython: () => Promise.resolve().then(() => (init_cython(), cython_exports)).then((module) => module.cython),
   d: () => Promise.resolve().then(() => (init_d(), d_exports)).then((module) => module.d),
   dart: () => Promise.resolve().then(() => (init_dart(), dart_exports)).then((module) => module.dart),
   dockerfile: () => Promise.resolve().then(() => (init_dockerfile(), dockerfile_exports)).then((module) => module.dockerfile),
   elixir: () => Promise.resolve().then(() => (init_elixir(), elixir_exports)).then((module) => module.elixir),
   elm: () => Promise.resolve().then(() => (init_elm(), elm_exports)).then((module) => module.elm),
+  erb: () => Promise.resolve().then(() => (init_erb(), erb_exports)).then((module) => module.erb),
   erlang: () => Promise.resolve().then(() => (init_erlang(), erlang_exports)).then((module) => module.erlang),
   fennel: () => Promise.resolve().then(() => (init_fennel(), fennel_exports)).then((module) => module.fennel),
   fortran: () => Promise.resolve().then(() => (init_fortran(), fortran_exports)).then((module) => module.fortran),
+  forth: () => Promise.resolve().then(() => (init_forth(), forth_exports)).then((module) => module.forth),
   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),
@@ -4422,12 +5253,14 @@ var languageLoaders = {
   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),
+  jsonnet: () => Promise.resolve().then(() => (init_jsonnet(), jsonnet_exports)).then((module) => module.jsonnet),
   "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),
@@ -4453,9 +5286,11 @@ var languageLoaders = {
   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),
@@ -4466,6 +5301,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),
@@ -4474,10 +5310,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),