code-languages 1.40.11 → 1.41.0

package/dist/api.js

@@ -76,6 +76,7 @@ var init_actionscript = __esm({
   "src/languages/actionscript.ts"() {
     actionscript = {
       slug: "actionscript",
+      status: "legacy",
       publishedDate: "1998-01-01",
       extensions: [".as"],
       author: "Gary Grossman / Macromedia",
@@ -252,6 +253,7 @@ var init_algol = __esm({
   "src/languages/algol.ts"() {
     algol = {
       slug: "algol",
+      status: "historical",
       publishedDate: "1958-01-01",
       extensions: [".alg", ".algol"],
       author: "ACM-GAMM committee",
@@ -358,6 +360,64 @@ var init_ampl = __esm({
   }
 });
 
+// src/languages/angelscript.ts
+var angelscript_exports = {};
+__export(angelscript_exports, {
+  angelscript: () => angelscript
+});
+var angelscript;
+var init_angelscript = __esm({
+  "src/languages/angelscript.ts"() {
+    angelscript = {
+      slug: "angelscript",
+      publishedDate: "2003-01-01",
+      extensions: [".as", ".angelscript"],
+      author: "Andreas Jonsson (AngelCode)",
+      website: "https://www.angelcode.com/angelscript",
+      paradigms: ["object-oriented", "procedural", "scripting"],
+      tooling: {
+        runtimes: ["AngelScript Engine"],
+        ecosystems: ["Game Development", "Embedded Scripting", "Modding"]
+      },
+      version: "2.36.1",
+      logo: "https://dummyimage.com/32x32/2D5FA0/ffffff.png&text=AS",
+      color: "#2D5FA0",
+      i18n: {
+        en: {
+          name: "AngelScript",
+          description: "A statically typed scripting language designed for embedding in C++ game engines.",
+          longDescription: "AngelScript is a scripting language designed to be embedded in C++ applications and game engines. It uses a syntax close to C++ and Java, making it familiar to game developers, while being compiled to bytecode and executed by a lightweight virtual machine with low overhead.\n\nCreated by Andreas Jonsson at AngelCode, the language provides strong typing, automatic memory management via reference counting, and a flexible registration API for exposing C++ classes and functions to scripts. It is used in commercial games and tools such as Crimsonland, Age of Wonders, and several modding communities."
+        },
+        es: {
+          name: "AngelScript",
+          description: "Lenguaje de scripting tipado estaticamente disenado para incrustar en motores de juego C++.",
+          longDescription: "AngelScript es un lenguaje de scripting disenado para incrustarse en aplicaciones C++ y motores de juego. Usa una sintaxis cercana a C++ y Java, familiar para desarrolladores de juegos, compilandose a bytecode y ejecutandose mediante una maquina virtual ligera con minima sobrecarga.\n\nCreado por Andreas Jonsson en AngelCode, el lenguaje ofrece tipado fuerte, gestion automatica de memoria mediante conteo de referencias y una API de registro flexible para exponer clases y funciones C++ a los scripts. Se usa en juegos comerciales y herramientas como Crimsonland, Age of Wonders y comunidades de mods."
+        },
+        it: {
+          name: "AngelScript",
+          description: "Linguaggio di scripting tipato staticamente progettato per essere incorporato in motori di gioco C++.",
+          longDescription: "AngelScript e un linguaggio di scripting progettato per essere incorporato in applicazioni C++ e motori di gioco. Usa una sintassi simile a C++ e Java, familiare agli sviluppatori di giochi, compilando a bytecode ed eseguito da una macchina virtuale leggera con basso overhead.\n\nCreato da Andreas Jonsson di AngelCode, il linguaggio offre tipizzazione statica, gestione automatica della memoria tramite conteggio dei riferimenti e un API di registrazione flessibile per esporre classi e funzioni C++ agli script. E usato in giochi commerciali come Crimsonland, Age of Wonders e comunita di modding."
+        },
+        fr: {
+          name: "AngelScript",
+          description: "Langage de script a typage statique concu pour etre integre dans les moteurs de jeu C++.",
+          longDescription: "AngelScript est un langage de script concu pour etre integre dans des applications C++ et des moteurs de jeu. Il utilise une syntaxe proche de C++ et Java, familiere aux developpeurs de jeux, avec une compilation en bytecode executee par une machine virtuelle legere a faible surcharge.\n\nCree par Andreas Jonsson chez AngelCode, le langage offre un typage statique, une gestion automatique de la memoire par comptage de references et une API d enregistrement flexible pour exposer des classes et fonctions C++ aux scripts. Il est utilise dans des jeux commerciaux comme Crimsonland, Age of Wonders et diverses communautes de mods."
+        },
+        de: {
+          name: "AngelScript",
+          description: "Statisch typisierte Skriptsprache fur die Einbettung in C++-Spiel-Engines.",
+          longDescription: "AngelScript ist eine Skriptsprache, die fur die Einbettung in C++-Anwendungen und Spiel-Engines entwickelt wurde. Sie verwendet eine Syntax ahnlich C++ und Java, die Spieleentwicklern vertraut ist, wird zu Bytecode kompiliert und von einer leichtgewichtigen virtuellen Maschine mit geringem Overhead ausgefuhrt.\n\nVon Andreas Jonsson bei AngelCode entwickelt, bietet die Sprache starke Typisierung, automatische Speicherverwaltung uber Referenzzahlung und eine flexible Registrierungs-API zum Bereitstellen von C++-Klassen und -Funktionen fur Skripte. Sie wird in kommerziellen Spielen wie Crimsonland, Age of Wonders und verschiedenen Modding-Communities eingesetzt."
+        },
+        pt: {
+          name: "AngelScript",
+          description: "Linguagem de script estaticamente tipada projetada para incorporacao em engines de jogos C++.",
+          longDescription: "AngelScript e uma linguagem de script projetada para ser incorporada em aplicacoes C++ e engines de jogos. Usa uma sintaxe proxima de C++ e Java, familiar a desenvolvedores de jogos, compilando para bytecode executado por uma maquina virtual leve com baixa sobrecarga.\n\nCriada por Andreas Jonsson na AngelCode, a linguagem oferece tipagem estatica, gerenciamento automatico de memoria por contagem de referencias e uma API de registro flexivel para expor classes e funcoes C++ aos scripts. E usada em jogos comerciais como Crimsonland, Age of Wonders e comunidades de mods."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/ante.ts
 var ante_exports = {};
 __export(ante_exports, {
@@ -368,6 +428,7 @@ var init_ante = __esm({
   "src/languages/ante.ts"() {
     ante = {
       slug: "ante",
+      status: "experimental",
       publishedDate: "2019-01-01",
       extensions: [".ante"],
       author: "Evan Haas",
@@ -651,6 +712,64 @@ var init_applescript = __esm({
   }
 });
 
+// src/languages/aql.ts
+var aql_exports = {};
+__export(aql_exports, {
+  aql: () => aql
+});
+var aql;
+var init_aql = __esm({
+  "src/languages/aql.ts"() {
+    aql = {
+      slug: "aql",
+      publishedDate: "2012-05-01",
+      extensions: [".aql"],
+      author: "ArangoDB GmbH",
+      website: "https://docs.arangodb.com/stable/aql/",
+      paradigms: ["query", "declarative"],
+      tooling: {
+        runtimes: ["ArangoDB"],
+        ecosystems: ["Graph databases", "Document databases"]
+      },
+      version: "ArangoDB AQL",
+      logo: "https://cdn.simpleicons.org/arangodb/DDE072",
+      color: "#16A34A",
+      i18n: {
+        en: {
+          name: "AQL",
+          description: "ArangoDB Query Language, a declarative query language for multi-model graph and document data.",
+          longDescription: "AQL is the ArangoDB Query Language used to query documents, graphs, key-value data, and search views in ArangoDB. It has SQL-like declarative structure while supporting graph traversal, document operations, aggregation, and expression-oriented data shaping.\n\nAQL is used in applications that need one query language across multiple data models. It is closely tied to ArangoDB server versions and the database features available in each release."
+        },
+        es: {
+          name: "AQL",
+          description: "Lenguaje declarativo de consultas de ArangoDB para datos de grafos, documentos y multiples modelos.",
+          longDescription: "AQL es el lenguaje de consultas de ArangoDB para consultar documentos, grafos, datos clave-valor y vistas de busqueda. Tiene una estructura declarativa parecida a SQL, con soporte para recorridos de grafos, operaciones sobre documentos, agregaciones y transformacion de datos mediante expresiones.\n\nAQL se usa en aplicaciones que necesitan un solo lenguaje de consulta para varios modelos de datos. Esta estrechamente ligado a las versiones del servidor ArangoDB y a las capacidades disponibles en cada lanzamiento."
+        },
+        it: {
+          name: "AQL",
+          description: "Linguaggio dichiarativo di query di ArangoDB per dati a grafo, documenti e modelli multipli.",
+          longDescription: "AQL e il linguaggio di query di ArangoDB usato per interrogare documenti, grafi, dati chiave-valore e viste di ricerca. Ha una struttura dichiarativa simile a SQL, con supporto per attraversamenti di grafi, operazioni sui documenti, aggregazioni e trasformazione dei dati tramite espressioni.\n\nAQL viene usato in applicazioni che richiedono un unico linguaggio di query per piu modelli di dati. E strettamente legato alle versioni del server ArangoDB e alle funzionalita disponibili in ogni rilascio."
+        },
+        fr: {
+          name: "AQL",
+          description: "Langage de requete declaratif d ArangoDB pour graphes, documents et donnees multi-modeles.",
+          longDescription: "AQL est le langage de requete d ArangoDB utilise pour interroger des documents, des graphes, des donnees cle-valeur et des vues de recherche. Il possede une structure declarative proche de SQL et prend en charge les parcours de graphes, les operations sur documents, les agregations et la mise en forme des donnees par expressions.\n\nAQL est utilise dans les applications qui ont besoin d un seul langage de requete pour plusieurs modeles de donnees. Il est etroitement lie aux versions du serveur ArangoDB et aux fonctionnalites disponibles dans chaque version."
+        },
+        de: {
+          name: "AQL",
+          description: "Deklarative Abfragesprache von ArangoDB fur Graph-, Dokument- und Multi-Model-Daten.",
+          longDescription: "AQL ist die ArangoDB Query Language zum Abfragen von Dokumenten, Graphen, Key-Value-Daten und Suchansichten in ArangoDB. Sie hat eine SQL-ahnliche deklarative Struktur und unterstutzt Graph-Traversierungen, Dokumentoperationen, Aggregationen und ausdrucksbasierte Datenformung.\n\nAQL wird in Anwendungen eingesetzt, die eine Abfragesprache fur mehrere Datenmodelle benotigen. Die Sprache ist eng an ArangoDB-Serverversionen und die darin verfugbaren Funktionen gebunden."
+        },
+        pt: {
+          name: "AQL",
+          description: "Linguagem declarativa de consulta do ArangoDB para grafos, documentos e dados multimodelo.",
+          longDescription: "AQL e a linguagem de consulta do ArangoDB usada para consultar documentos, grafos, dados chave-valor e visoes de busca. Ela tem uma estrutura declarativa semelhante a SQL, com suporte a percursos de grafos, operacoes em documentos, agregacoes e modelagem de dados baseada em expressoes.\n\nAQL e usada em aplicacoes que precisam de uma unica linguagem de consulta para varios modelos de dados. Ela esta ligada as versoes do servidor ArangoDB e aos recursos disponiveis em cada lancamento."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/arduino.ts
 var arduino_exports = {};
 __export(arduino_exports, {
@@ -710,64 +829,6 @@ var init_arduino = __esm({
   }
 });
 
-// src/languages/aql.ts
-var aql_exports = {};
-__export(aql_exports, {
-  aql: () => aql
-});
-var aql;
-var init_aql = __esm({
-  "src/languages/aql.ts"() {
-    aql = {
-      slug: "aql",
-      publishedDate: "2012-05-01",
-      extensions: [".aql"],
-      author: "ArangoDB GmbH",
-      website: "https://docs.arangodb.com/stable/aql/",
-      paradigms: ["query", "declarative"],
-      tooling: {
-        runtimes: ["ArangoDB"],
-        ecosystems: ["Graph databases", "Document databases"]
-      },
-      version: "ArangoDB AQL",
-      logo: "https://cdn.simpleicons.org/arangodb/DDE072",
-      color: "#16A34A",
-      i18n: {
-        en: {
-          name: "AQL",
-          description: "ArangoDB Query Language, a declarative query language for multi-model graph and document data.",
-          longDescription: "AQL is the ArangoDB Query Language used to query documents, graphs, key-value data, and search views in ArangoDB. It has SQL-like declarative structure while supporting graph traversal, document operations, aggregation, and expression-oriented data shaping.\n\nAQL is used in applications that need one query language across multiple data models. It is closely tied to ArangoDB server versions and the database features available in each release."
-        },
-        es: {
-          name: "AQL",
-          description: "Lenguaje declarativo de consultas de ArangoDB para datos de grafos, documentos y multiples modelos.",
-          longDescription: "AQL es el lenguaje de consultas de ArangoDB para consultar documentos, grafos, datos clave-valor y vistas de busqueda. Tiene una estructura declarativa parecida a SQL, con soporte para recorridos de grafos, operaciones sobre documentos, agregaciones y transformacion de datos mediante expresiones.\n\nAQL se usa en aplicaciones que necesitan un solo lenguaje de consulta para varios modelos de datos. Esta estrechamente ligado a las versiones del servidor ArangoDB y a las capacidades disponibles en cada lanzamiento."
-        },
-        it: {
-          name: "AQL",
-          description: "Linguaggio dichiarativo di query di ArangoDB per dati a grafo, documenti e modelli multipli.",
-          longDescription: "AQL e il linguaggio di query di ArangoDB usato per interrogare documenti, grafi, dati chiave-valore e viste di ricerca. Ha una struttura dichiarativa simile a SQL, con supporto per attraversamenti di grafi, operazioni sui documenti, aggregazioni e trasformazione dei dati tramite espressioni.\n\nAQL viene usato in applicazioni che richiedono un unico linguaggio di query per piu modelli di dati. E strettamente legato alle versioni del server ArangoDB e alle funzionalita disponibili in ogni rilascio."
-        },
-        fr: {
-          name: "AQL",
-          description: "Langage de requete declaratif d ArangoDB pour graphes, documents et donnees multi-modeles.",
-          longDescription: "AQL est le langage de requete d ArangoDB utilise pour interroger des documents, des graphes, des donnees cle-valeur et des vues de recherche. Il possede une structure declarative proche de SQL et prend en charge les parcours de graphes, les operations sur documents, les agregations et la mise en forme des donnees par expressions.\n\nAQL est utilise dans les applications qui ont besoin d un seul langage de requete pour plusieurs modeles de donnees. Il est etroitement lie aux versions du serveur ArangoDB et aux fonctionnalites disponibles dans chaque version."
-        },
-        de: {
-          name: "AQL",
-          description: "Deklarative Abfragesprache von ArangoDB fur Graph-, Dokument- und Multi-Model-Daten.",
-          longDescription: "AQL ist die ArangoDB Query Language zum Abfragen von Dokumenten, Graphen, Key-Value-Daten und Suchansichten in ArangoDB. Sie hat eine SQL-ahnliche deklarative Struktur und unterstutzt Graph-Traversierungen, Dokumentoperationen, Aggregationen und ausdrucksbasierte Datenformung.\n\nAQL wird in Anwendungen eingesetzt, die eine Abfragesprache fur mehrere Datenmodelle benotigen. Die Sprache ist eng an ArangoDB-Serverversionen und die darin verfugbaren Funktionen gebunden."
-        },
-        pt: {
-          name: "AQL",
-          description: "Linguagem declarativa de consulta do ArangoDB para grafos, documentos e dados multimodelo.",
-          longDescription: "AQL e a linguagem de consulta do ArangoDB usada para consultar documentos, grafos, dados chave-valor e visoes de busca. Ela tem uma estrutura declarativa semelhante a SQL, com suporte a percursos de grafos, operacoes em documentos, agregacoes e modelagem de dados baseada em expressoes.\n\nAQL e usada em aplicacoes que precisam de uma unica linguagem de consulta para varios modelos de dados. Ela esta ligada as versoes do servidor ArangoDB e aos recursos disponiveis em cada lancamento."
-        }
-      }
-    };
-  }
-});
-
 // src/languages/asciidoc.ts
 var asciidoc_exports = {};
 __export(asciidoc_exports, {
@@ -896,6 +957,7 @@ var init_assembly = __esm({
   "src/languages/assembly.ts"() {
     assembly = {
       slug: "assembly",
+      aliases: ["asm"],
       publishedDate: "1949-01-01",
       extensions: [".asm", ".s", ".S", ".inc"],
       author: "Machine architecture vendors and assembler implementers",
@@ -1003,64 +1065,6 @@ var init_assemblyscript = __esm({
   }
 });
 
-// src/languages/angelscript.ts
-var angelscript_exports = {};
-__export(angelscript_exports, {
-  angelscript: () => angelscript
-});
-var angelscript;
-var init_angelscript = __esm({
-  "src/languages/angelscript.ts"() {
-    angelscript = {
-      slug: "angelscript",
-      publishedDate: "2003-01-01",
-      extensions: [".as", ".angelscript"],
-      author: "Andreas Jonsson (AngelCode)",
-      website: "https://www.angelcode.com/angelscript",
-      paradigms: ["object-oriented", "procedural", "scripting"],
-      tooling: {
-        runtimes: ["AngelScript Engine"],
-        ecosystems: ["Game Development", "Embedded Scripting", "Modding"]
-      },
-      version: "2.36.1",
-      logo: "https://dummyimage.com/32x32/2D5FA0/ffffff.png&text=AS",
-      color: "#2D5FA0",
-      i18n: {
-        en: {
-          name: "AngelScript",
-          description: "A statically typed scripting language designed for embedding in C++ game engines.",
-          longDescription: "AngelScript is a scripting language designed to be embedded in C++ applications and game engines. It uses a syntax close to C++ and Java, making it familiar to game developers, while being compiled to bytecode and executed by a lightweight virtual machine with low overhead.\n\nCreated by Andreas Jonsson at AngelCode, the language provides strong typing, automatic memory management via reference counting, and a flexible registration API for exposing C++ classes and functions to scripts. It is used in commercial games and tools such as Crimsonland, Age of Wonders, and several modding communities."
-        },
-        es: {
-          name: "AngelScript",
-          description: "Lenguaje de scripting tipado estaticamente disenado para incrustar en motores de juego C++.",
-          longDescription: "AngelScript es un lenguaje de scripting disenado para incrustarse en aplicaciones C++ y motores de juego. Usa una sintaxis cercana a C++ y Java, familiar para desarrolladores de juegos, compilandose a bytecode y ejecutandose mediante una maquina virtual ligera con minima sobrecarga.\n\nCreado por Andreas Jonsson en AngelCode, el lenguaje ofrece tipado fuerte, gestion automatica de memoria mediante conteo de referencias y una API de registro flexible para exponer clases y funciones C++ a los scripts. Se usa en juegos comerciales y herramientas como Crimsonland, Age of Wonders y comunidades de mods."
-        },
-        it: {
-          name: "AngelScript",
-          description: "Linguaggio di scripting tipato staticamente progettato per essere incorporato in motori di gioco C++.",
-          longDescription: "AngelScript e un linguaggio di scripting progettato per essere incorporato in applicazioni C++ e motori di gioco. Usa una sintassi simile a C++ e Java, familiare agli sviluppatori di giochi, compilando a bytecode ed eseguito da una macchina virtuale leggera con basso overhead.\n\nCreato da Andreas Jonsson di AngelCode, il linguaggio offre tipizzazione statica, gestione automatica della memoria tramite conteggio dei riferimenti e un API di registrazione flessibile per esporre classi e funzioni C++ agli script. E usato in giochi commerciali come Crimsonland, Age of Wonders e comunita di modding."
-        },
-        fr: {
-          name: "AngelScript",
-          description: "Langage de script a typage statique concu pour etre integre dans les moteurs de jeu C++.",
-          longDescription: "AngelScript est un langage de script concu pour etre integre dans des applications C++ et des moteurs de jeu. Il utilise une syntaxe proche de C++ et Java, familiere aux developpeurs de jeux, avec une compilation en bytecode executee par une machine virtuelle legere a faible surcharge.\n\nCree par Andreas Jonsson chez AngelCode, le langage offre un typage statique, une gestion automatique de la memoire par comptage de references et une API d enregistrement flexible pour exposer des classes et fonctions C++ aux scripts. Il est utilise dans des jeux commerciaux comme Crimsonland, Age of Wonders et diverses communautes de mods."
-        },
-        de: {
-          name: "AngelScript",
-          description: "Statisch typisierte Skriptsprache fur die Einbettung in C++-Spiel-Engines.",
-          longDescription: "AngelScript ist eine Skriptsprache, die fur die Einbettung in C++-Anwendungen und Spiel-Engines entwickelt wurde. Sie verwendet eine Syntax ahnlich C++ und Java, die Spieleentwicklern vertraut ist, wird zu Bytecode kompiliert und von einer leichtgewichtigen virtuellen Maschine mit geringem Overhead ausgefuhrt.\n\nVon Andreas Jonsson bei AngelCode entwickelt, bietet die Sprache starke Typisierung, automatische Speicherverwaltung uber Referenzzahlung und eine flexible Registrierungs-API zum Bereitstellen von C++-Klassen und -Funktionen fur Skripte. Sie wird in kommerziellen Spielen wie Crimsonland, Age of Wonders und verschiedenen Modding-Communities eingesetzt."
-        },
-        pt: {
-          name: "AngelScript",
-          description: "Linguagem de script estaticamente tipada projetada para incorporacao em engines de jogos C++.",
-          longDescription: "AngelScript e uma linguagem de script projetada para ser incorporada em aplicacoes C++ e engines de jogos. Usa uma sintaxe proxima de C++ e Java, familiar a desenvolvedores de jogos, compilando para bytecode executado por uma maquina virtual leve com baixa sobrecarga.\n\nCriada por Andreas Jonsson na AngelCode, a linguagem oferece tipagem estatica, gerenciamento automatico de memoria por contagem de referencias e uma API de registro flexivel para expor classes e funcoes C++ aos scripts. E usada em jogos comerciais como Crimsonland, Age of Wonders e comunidades de mods."
-        }
-      }
-    };
-  }
-});
-
 // src/languages/astro.ts
 var astro_exports = {};
 __export(astro_exports, {
@@ -1130,6 +1134,7 @@ var init_austral = __esm({
   "src/languages/austral.ts"() {
     austral = {
       slug: "austral",
+      status: "experimental",
       publishedDate: "2021-01-01",
       extensions: [".aum", ".aui"],
       author: "Fernando Borretti",
@@ -1140,7 +1145,7 @@ var init_austral = __esm({
         ecosystems: ["Systems Programming", "Memory Safety", "Research"]
       },
       version: "0.1.0",
-      logo: "https://dummyimage.com/32x32/0F766E/ffffff.png&text=Au",
+      logo: "https://avatars.githubusercontent.com/u/17337956?v=4",
       color: "#0F766E",
       i18n: {
         en: {
@@ -1412,64 +1417,10 @@ var init_ballerina = __esm({
   }
 });
 
-// src/languages/basic.ts
-var basic_exports = {};
-__export(basic_exports, {
-  basic: () => basic
-});
-var basic;
-var init_basic = __esm({
-  "src/languages/basic.ts"() {
-    basic = {
-      slug: "basic",
-      publishedDate: "1964-05-01",
-      extensions: [".bas", ".bi", ".bb"],
-      author: "John G. Kemeny, Thomas E. Kurtz",
-      website: "https://freebasic.net",
-      paradigms: ["imperative", "procedural", "structured"],
-      version: "FreeBASIC 1.10.1",
-      logo: "https://avatars.githubusercontent.com/u/5598624?v=4",
-      color: "#00599C",
-      i18n: {
-        en: {
-          name: "BASIC",
-          description: "A family of general-purpose high-level programming languages designed for ease of use.",
-          longDescription: "BASIC (Beginners' All-purpose Symbolic Instruction Code) was designed in 1964 to enable non-science students to use computers.\n\nModern descendants include FreeBASIC, QB64, and Visual Basic. FreeBASIC remains actively maintained, offering compiled programs, inline assembly, and compatibility with classic BASIC code while adding modern structures like objects, pointers, and preprocessor directives."
-        },
-        es: {
-          name: "BASIC",
-          description: "Una familia de lenguajes de programaci\xF3n de alto nivel de prop\xF3sito general dise\xF1ados para la facilidad de uso.",
-          longDescription: "BASIC (Beginners' All-purpose Symbolic Instruction Code) fue dise\xF1ado en 1964 para permitir a estudiantes no cient\xEDficos usar computadoras.\n\nLos descendientes modernos incluyen FreeBASIC, QB64 y Visual Basic. FreeBASIC sigue mantenido activamente, ofreciendo programas compilados, ensamblador en l\xEDnea y compatibilidad con c\xF3digo BASIC cl\xE1sico, al tiempo que a\xF1ade estructuras modernas como objetos, punteros y directivas de preprocesador."
-        },
-        it: {
-          name: "BASIC",
-          description: "Una famiglia di linguaggi di programmazione di alto livello a uso generale progettati per la facilit\xE0 d'uso.",
-          longDescription: "BASIC (Beginners' All-purpose Symbolic Instruction Code) fu progettato nel 1964 per consentire agli studenti non scientifici di usare i computer.\n\nI discendenti moderni includono FreeBASIC, QB64 e Visual Basic. FreeBASIC e ancora attivamente mantenuto, offrendo programmi compilati, assembly inline e compatibilita con il codice BASIC classico, aggiungendo strutture moderne come oggetti, puntatori e direttive del preprocessore."
-        },
-        fr: {
-          name: "BASIC",
-          description: "Une famille de langages de programmation de haut niveau \xE0 usage g\xE9n\xE9ral con\xE7us pour la facilit\xE9 d'utilisation.",
-          longDescription: "BASIC (Beginners' All-purpose Symbolic Instruction Code) a \xE9t\xE9 con\xE7u en 1964 pour permettre aux \xE9tudiants non scientifiques d'utiliser des ordinateurs.\n\nLes descendants modernes comprennent FreeBASIC, QB64 et Visual Basic. FreeBASIC est encore activement maintenu, offrant des programmes compil\xE9s, de l'assembleur en ligne et une compatibilit\xE9 avec le code BASIC classique tout en ajoutant des structures modernes comme des objets, des pointeurs et des directives de pr\xE9processeur."
-        },
-        de: {
-          name: "BASIC",
-          description: "Eine Familie von allgemeinen Hochsprachen, die auf Benutzerfreundlichkeit ausgelegt sind.",
-          longDescription: "BASIC (Beginner's All-purpose Symbolic Instruction Code) wurde 1964 entwickelt, um Nicht-Informatikstudenten die Nutzung von Computern zu erm\xF6glichen.\n\nModerne Nachfolger sind FreeBASIC, QB64 und Visual Basic. FreeBASIC wird aktiv gepflegt und bietet kompilierte Programme, Inline-Assembler und Kompatibilit\xE4t mit klassischem BASIC-Code, w\xE4hrend moderne Strukturen wie Objekte, Zeiger und Pr\xE4prozessor-Direktiven hinzugef\xFCgt werden."
-        },
-        pt: {
-          name: "BASIC",
-          description: "Uma fam\xEDlia de linguagens de programa\xE7\xE3o de alto n\xEDvel de prop\xF3sito geral projetadas para facilidade de uso.",
-          longDescription: "BASIC (Beginners' All-purpose Symbolic Instruction Code) foi projetado em 1964 para permitir que estudantes de \xE1reas n\xE3o cient\xEDficas usassem computadores.\n\nOs descendentes modernos incluem FreeBASIC, QB64 e Visual Basic. O FreeBASIC ainda \xE9 ativamente mantido, oferecendo programas compilados, assembly inline e compatibilidade com c\xF3digo BASIC cl\xE1ssico, enquanto adiciona estruturas modernas como objetos, ponteiros e diretivas de pr\xE9-processador."
-        }
-      }
-    };
-  }
-});
-
-// src/languages/bash.ts
-var bash_exports = {};
-__export(bash_exports, {
-  bash: () => bash
+// src/languages/bash.ts
+var bash_exports = {};
+__export(bash_exports, {
+  bash: () => bash
 });
 var bash;
 var init_bash = __esm({
@@ -1525,6 +1476,60 @@ var init_bash = __esm({
   }
 });
 
+// src/languages/basic.ts
+var basic_exports = {};
+__export(basic_exports, {
+  basic: () => basic
+});
+var basic;
+var init_basic = __esm({
+  "src/languages/basic.ts"() {
+    basic = {
+      slug: "basic",
+      publishedDate: "1964-05-01",
+      extensions: [".bas", ".bi", ".bb"],
+      author: "John G. Kemeny, Thomas E. Kurtz",
+      website: "https://freebasic.net",
+      paradigms: ["imperative", "procedural", "structured"],
+      version: "FreeBASIC 1.10.1",
+      logo: "https://avatars.githubusercontent.com/u/5598624?v=4",
+      color: "#00599C",
+      i18n: {
+        en: {
+          name: "BASIC",
+          description: "A family of general-purpose high-level programming languages designed for ease of use.",
+          longDescription: "BASIC (Beginners' All-purpose Symbolic Instruction Code) was designed in 1964 to enable non-science students to use computers.\n\nModern descendants include FreeBASIC, QB64, and Visual Basic. FreeBASIC remains actively maintained, offering compiled programs, inline assembly, and compatibility with classic BASIC code while adding modern structures like objects, pointers, and preprocessor directives."
+        },
+        es: {
+          name: "BASIC",
+          description: "Una familia de lenguajes de programaci\xF3n de alto nivel de prop\xF3sito general dise\xF1ados para la facilidad de uso.",
+          longDescription: "BASIC (Beginners' All-purpose Symbolic Instruction Code) fue dise\xF1ado en 1964 para permitir a estudiantes no cient\xEDficos usar computadoras.\n\nLos descendientes modernos incluyen FreeBASIC, QB64 y Visual Basic. FreeBASIC sigue mantenido activamente, ofreciendo programas compilados, ensamblador en l\xEDnea y compatibilidad con c\xF3digo BASIC cl\xE1sico, al tiempo que a\xF1ade estructuras modernas como objetos, punteros y directivas de preprocesador."
+        },
+        it: {
+          name: "BASIC",
+          description: "Una famiglia di linguaggi di programmazione di alto livello a uso generale progettati per la facilit\xE0 d'uso.",
+          longDescription: "BASIC (Beginners' All-purpose Symbolic Instruction Code) fu progettato nel 1964 per consentire agli studenti non scientifici di usare i computer.\n\nI discendenti moderni includono FreeBASIC, QB64 e Visual Basic. FreeBASIC e ancora attivamente mantenuto, offrendo programmi compilati, assembly inline e compatibilita con il codice BASIC classico, aggiungendo strutture moderne come oggetti, puntatori e direttive del preprocessore."
+        },
+        fr: {
+          name: "BASIC",
+          description: "Une famille de langages de programmation de haut niveau \xE0 usage g\xE9n\xE9ral con\xE7us pour la facilit\xE9 d'utilisation.",
+          longDescription: "BASIC (Beginners' All-purpose Symbolic Instruction Code) a \xE9t\xE9 con\xE7u en 1964 pour permettre aux \xE9tudiants non scientifiques d'utiliser des ordinateurs.\n\nLes descendants modernes comprennent FreeBASIC, QB64 et Visual Basic. FreeBASIC est encore activement maintenu, offrant des programmes compil\xE9s, de l'assembleur en ligne et une compatibilit\xE9 avec le code BASIC classique tout en ajoutant des structures modernes comme des objets, des pointeurs et des directives de pr\xE9processeur."
+        },
+        de: {
+          name: "BASIC",
+          description: "Eine Familie von allgemeinen Hochsprachen, die auf Benutzerfreundlichkeit ausgelegt sind.",
+          longDescription: "BASIC (Beginner's All-purpose Symbolic Instruction Code) wurde 1964 entwickelt, um Nicht-Informatikstudenten die Nutzung von Computern zu erm\xF6glichen.\n\nModerne Nachfolger sind FreeBASIC, QB64 und Visual Basic. FreeBASIC wird aktiv gepflegt und bietet kompilierte Programme, Inline-Assembler und Kompatibilit\xE4t mit klassischem BASIC-Code, w\xE4hrend moderne Strukturen wie Objekte, Zeiger und Pr\xE4prozessor-Direktiven hinzugef\xFCgt werden."
+        },
+        pt: {
+          name: "BASIC",
+          description: "Uma fam\xEDlia de linguagens de programa\xE7\xE3o de alto n\xEDvel de prop\xF3sito geral projetadas para facilidade de uso.",
+          longDescription: "BASIC (Beginners' All-purpose Symbolic Instruction Code) foi projetado em 1964 para permitir que estudantes de \xE1reas n\xE3o cient\xEDficas usassem computadores.\n\nOs descendentes modernos incluem FreeBASIC, QB64 e Visual Basic. O FreeBASIC ainda \xE9 ativamente mantido, oferecendo programas compilados, assembly inline e compatibilidade com c\xF3digo BASIC cl\xE1ssico, enquanto adiciona estruturas modernas como objetos, ponteiros e diretivas de pr\xE9-processador."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/batch.ts
 var batch_exports = {};
 __export(batch_exports, {
@@ -1652,6 +1657,7 @@ var init_bcpl = __esm({
   "src/languages/bcpl.ts"() {
     bcpl = {
       slug: "bcpl",
+      status: "historical",
       publishedDate: "1967-01-01",
       extensions: [".bcpl"],
       author: "Martin Richards",
@@ -1700,6 +1706,64 @@ var init_bcpl = __esm({
   }
 });
 
+// src/languages/bibtex.ts
+var bibtex_exports = {};
+__export(bibtex_exports, {
+  bibtex: () => bibtex
+});
+var bibtex;
+var init_bibtex = __esm({
+  "src/languages/bibtex.ts"() {
+    bibtex = {
+      slug: "bibtex",
+      publishedDate: "1985-01-01",
+      extensions: [".bib", ".bibtex"],
+      author: "Oren Patashnik and Leslie Lamport",
+      website: "https://ctan.org/pkg/bibtex",
+      paradigms: ["data", "bibliography"],
+      tooling: {
+        runtimes: ["BibTeX", "Biber"],
+        ecosystems: ["TeX", "LaTeX", "Academic publishing"]
+      },
+      version: "stable",
+      logo: "https://upload.wikimedia.org/wikipedia/commons/9/92/LaTeX_logo.svg",
+      color: "#2563EB",
+      i18n: {
+        en: {
+          name: "BibTeX",
+          description: "A bibliography data format and toolchain used with TeX and LaTeX documents.",
+          longDescription: "BibTeX is both a bibliography processing program and a structured text format for citation records. Entries describe books, articles, proceedings, theses, and other sources with fields such as author, title, year, and publisher.\n\nIt is central to many TeX and LaTeX workflows, especially in academic publishing. BibTeX files can be edited by hand, exported by reference managers, and rendered through style files into formatted bibliographies."
+        },
+        es: {
+          name: "BibTeX",
+          description: "Formato de datos bibliograficos y herramienta usada con documentos TeX y LaTeX.",
+          longDescription: "BibTeX es un programa de procesamiento bibliografico y un formato de texto estructurado para registros de citas. Las entradas describen libros, articulos, actas, tesis y otras fuentes con campos como autor, titulo, ano y editorial.\n\nEs central en muchos flujos de TeX y LaTeX, sobre todo en publicacion academica. Los archivos BibTeX pueden editarse a mano, exportarse desde gestores de referencias y renderizarse con estilos como bibliografias formateadas."
+        },
+        it: {
+          name: "BibTeX",
+          description: "Formato di dati bibliografici e toolchain usati con documenti TeX e LaTeX.",
+          longDescription: "BibTeX e sia un programma di elaborazione bibliografica sia un formato testuale strutturato per record di citazioni. Le voci descrivono libri, articoli, atti, tesi e altre fonti con campi come autore, titolo, anno ed editore.\n\nE centrale in molti flussi TeX e LaTeX, specialmente nella pubblicazione accademica. I file BibTeX possono essere modificati a mano, esportati da gestori di riferimenti e resi tramite file di stile in bibliografie formattate."
+        },
+        fr: {
+          name: "BibTeX",
+          description: "Format de donnees bibliographiques et chaine d outils utilises avec TeX et LaTeX.",
+          longDescription: "BibTeX est a la fois un programme de traitement bibliographique et un format texte structure pour les citations. Les entrees decrivent livres, articles, actes, theses et autres sources avec des champs comme auteur, titre, annee et editeur.\n\nIl est central dans de nombreux flux TeX et LaTeX, surtout pour l edition academique. Les fichiers BibTeX peuvent etre modifies a la main, exportes par des gestionnaires de references et rendus via des styles en bibliographies formatees."
+        },
+        de: {
+          name: "BibTeX",
+          description: "Bibliografisches Datenformat und Werkzeugkette fur TeX- und LaTeX-Dokumente.",
+          longDescription: "BibTeX ist ein Bibliografieprogramm und ein strukturiertes Textformat fur Zitationsdaten. Eintrage beschreiben Bucher, Artikel, Tagungsbande, Arbeiten und andere Quellen mit Feldern wie Autor, Titel, Jahr und Verlag.\n\nEs ist zentral in vielen TeX- und LaTeX-Ablaufen, besonders im akademischen Publizieren. BibTeX-Dateien konnen von Hand gepflegt, aus Literaturverwaltungen exportiert und uber Stildateien zu formatierten Bibliografien gerendert werden."
+        },
+        pt: {
+          name: "BibTeX",
+          description: "Formato de dados bibliograficos e cadeia de ferramentas usada com TeX e LaTeX.",
+          longDescription: "BibTeX e ao mesmo tempo um programa de processamento bibliografico e um formato de texto estruturado para registros de citacao. As entradas descrevem livros, artigos, anais, teses e outras fontes com campos como autor, titulo, ano e editora.\n\nEle e central em muitos fluxos TeX e LaTeX, especialmente na publicacao academica. Arquivos BibTeX podem ser editados a mao, exportados por gerenciadores de referencias e renderizados por estilos em bibliografias formatadas."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/bicep.ts
 var bicep_exports = {};
 __export(bicep_exports, {
@@ -1759,64 +1823,6 @@ var init_bicep = __esm({
   }
 });
 
-// src/languages/bibtex.ts
-var bibtex_exports = {};
-__export(bibtex_exports, {
-  bibtex: () => bibtex
-});
-var bibtex;
-var init_bibtex = __esm({
-  "src/languages/bibtex.ts"() {
-    bibtex = {
-      slug: "bibtex",
-      publishedDate: "1985-01-01",
-      extensions: [".bib", ".bibtex"],
-      author: "Oren Patashnik and Leslie Lamport",
-      website: "https://ctan.org/pkg/bibtex",
-      paradigms: ["data", "bibliography"],
-      tooling: {
-        runtimes: ["BibTeX", "Biber"],
-        ecosystems: ["TeX", "LaTeX", "Academic publishing"]
-      },
-      version: "stable",
-      logo: "https://dummyimage.com/32x32/2563EB/ffffff.png&text=Bi",
-      color: "#2563EB",
-      i18n: {
-        en: {
-          name: "BibTeX",
-          description: "A bibliography data format and toolchain used with TeX and LaTeX documents.",
-          longDescription: "BibTeX is both a bibliography processing program and a structured text format for citation records. Entries describe books, articles, proceedings, theses, and other sources with fields such as author, title, year, and publisher.\n\nIt is central to many TeX and LaTeX workflows, especially in academic publishing. BibTeX files can be edited by hand, exported by reference managers, and rendered through style files into formatted bibliographies."
-        },
-        es: {
-          name: "BibTeX",
-          description: "Formato de datos bibliograficos y herramienta usada con documentos TeX y LaTeX.",
-          longDescription: "BibTeX es un programa de procesamiento bibliografico y un formato de texto estructurado para registros de citas. Las entradas describen libros, articulos, actas, tesis y otras fuentes con campos como autor, titulo, ano y editorial.\n\nEs central en muchos flujos de TeX y LaTeX, sobre todo en publicacion academica. Los archivos BibTeX pueden editarse a mano, exportarse desde gestores de referencias y renderizarse con estilos como bibliografias formateadas."
-        },
-        it: {
-          name: "BibTeX",
-          description: "Formato di dati bibliografici e toolchain usati con documenti TeX e LaTeX.",
-          longDescription: "BibTeX e sia un programma di elaborazione bibliografica sia un formato testuale strutturato per record di citazioni. Le voci descrivono libri, articoli, atti, tesi e altre fonti con campi come autore, titolo, anno ed editore.\n\nE centrale in molti flussi TeX e LaTeX, specialmente nella pubblicazione accademica. I file BibTeX possono essere modificati a mano, esportati da gestori di riferimenti e resi tramite file di stile in bibliografie formattate."
-        },
-        fr: {
-          name: "BibTeX",
-          description: "Format de donnees bibliographiques et chaine d outils utilises avec TeX et LaTeX.",
-          longDescription: "BibTeX est a la fois un programme de traitement bibliographique et un format texte structure pour les citations. Les entrees decrivent livres, articles, actes, theses et autres sources avec des champs comme auteur, titre, annee et editeur.\n\nIl est central dans de nombreux flux TeX et LaTeX, surtout pour l edition academique. Les fichiers BibTeX peuvent etre modifies a la main, exportes par des gestionnaires de references et rendus via des styles en bibliographies formatees."
-        },
-        de: {
-          name: "BibTeX",
-          description: "Bibliografisches Datenformat und Werkzeugkette fur TeX- und LaTeX-Dokumente.",
-          longDescription: "BibTeX ist ein Bibliografieprogramm und ein strukturiertes Textformat fur Zitationsdaten. Eintrage beschreiben Bucher, Artikel, Tagungsbande, Arbeiten und andere Quellen mit Feldern wie Autor, Titel, Jahr und Verlag.\n\nEs ist zentral in vielen TeX- und LaTeX-Ablaufen, besonders im akademischen Publizieren. BibTeX-Dateien konnen von Hand gepflegt, aus Literaturverwaltungen exportiert und uber Stildateien zu formatierten Bibliografien gerendert werden."
-        },
-        pt: {
-          name: "BibTeX",
-          description: "Formato de dados bibliograficos e cadeia de ferramentas usada com TeX e LaTeX.",
-          longDescription: "BibTeX e ao mesmo tempo um programa de processamento bibliografico e um formato de texto estruturado para registros de citacao. As entradas descrevem livros, artigos, anais, teses e outras fontes com campos como autor, titulo, ano e editora.\n\nEle e central em muitos fluxos TeX e LaTeX, especialmente na publicacao academica. Arquivos BibTeX podem ser editados a mao, exportados por gerenciadores de referencias e renderizados por estilos em bibliografias formatadas."
-        }
-      }
-    };
-  }
-});
-
 // src/languages/blade.ts
 var blade_exports = {};
 __export(blade_exports, {
@@ -1886,6 +1892,7 @@ var init_bosque = __esm({
   "src/languages/bosque.ts"() {
     bosque = {
       slug: "bosque",
+      status: "experimental",
       publishedDate: "2019-04-15",
       extensions: [".bsq"],
       author: "Microsoft Research",
@@ -2236,6 +2243,7 @@ var init_carbon = __esm({
   "src/languages/carbon.ts"() {
     carbon = {
       slug: "carbon",
+      status: "experimental",
       publishedDate: "2022-07-19",
       extensions: [".carbon"],
       author: "Carbon Language Project",
@@ -2764,6 +2772,7 @@ var init_coq = __esm({
   "src/languages/coq.ts"() {
     coq = {
       slug: "coq",
+      aliases: ["rocq"],
       publishedDate: "1989-01-01",
       extensions: [".v"],
       author: "INRIA / Rocq Prover Development Team",
@@ -2823,6 +2832,7 @@ var init_cpp = __esm({
   "src/languages/cpp.ts"() {
     cpp = {
       slug: "cpp",
+      aliases: ["c++", "cplusplus"],
       publishedDate: "1985-10-01",
       extensions: [".cpp", ".cc", ".cxx", ".h", ".hpp", ".hh", ".hxx"],
       author: "Bjarne Stroustrup",
@@ -2872,117 +2882,117 @@ var init_cpp = __esm({
   }
 });
 
-// src/languages/crystal.ts
-var crystal_exports = {};
-__export(crystal_exports, {
-  crystal: () => crystal
+// src/languages/cql.ts
+var cql_exports = {};
+__export(cql_exports, {
+  cql: () => cql
 });
-var crystal;
-var init_crystal = __esm({
-  "src/languages/crystal.ts"() {
-    crystal = {
-      slug: "crystal",
-      publishedDate: "2014-06-18",
-      extensions: [".cr"],
-      author: "Ary Borenszweig, Juan Wajnerman, Brian Cardiff / Crystal contributors",
-      website: "https://crystal-lang.org",
-      paradigms: ["object-oriented", "functional", "imperative", "concurrent"],
+var cql;
+var init_cql = __esm({
+  "src/languages/cql.ts"() {
+    cql = {
+      slug: "cql",
+      publishedDate: "2008-01-01",
+      extensions: [".cql"],
+      author: "Apache Cassandra project",
+      website: "https://cassandra.apache.org/doc/latest/cassandra/developing/cql/index.html",
+      paradigms: ["query", "declarative"],
       tooling: {
-        runtimes: ["Crystal"],
-        packageManagers: ["Shards"],
-        ecosystems: ["Web", "CLI", "Systems", "Native Applications"]
+        runtimes: ["Apache Cassandra"],
+        ecosystems: ["NoSQL", "Distributed databases"]
       },
-      version: "1.20.3",
-      logo: "https://cdn.simpleicons.org/crystal/000000",
-      color: "#000000",
+      version: "CQL 3",
+      logo: "https://cdn.simpleicons.org/apachecassandra/1287B1",
+      color: "#1287B1",
       i18n: {
         en: {
-          name: "Crystal",
-          description: "A compiled, statically typed language with Ruby-inspired syntax and native performance.",
-          longDescription: "Crystal is a general-purpose programming language with syntax inspired by Ruby, static type checking, type inference, macros, fibers, channels, C bindings, and native compilation. It aims to keep code expressive while catching type errors at compile time.\n\nIt is used for web services, command-line tools, automation, native applications, performance-sensitive backend systems, and projects that want Ruby-like ergonomics with a compiled toolchain."
+          name: "CQL",
+          description: "A SQL-like query language for Apache Cassandra tables and keyspaces.",
+          longDescription: "Cassandra Query Language is the primary interface for defining and querying data in Apache Cassandra. It models keyspaces, tables, columns, indexes, materialized views, and statements for reading and writing partitioned data.\n\nCQL looks familiar to SQL users, but its behavior follows Cassandra storage and distribution rules. Effective CQL design focuses on partition keys, clustering columns, denormalized tables, and queries shaped around access patterns."
         },
         es: {
-          name: "Crystal",
-          description: "Un lenguaje compilado y tipado estaticamente con sintaxis inspirada en Ruby y rendimiento nativo.",
-          longDescription: "Crystal es un lenguaje de programacion de proposito general con sintaxis inspirada en Ruby, verificacion estatica de tipos, inferencia de tipos, macros, fibers, channels, bindings con C y compilacion nativa. Busca mantener el codigo expresivo mientras detecta errores de tipos en compilacion.\n\nSe usa en servicios web, herramientas de linea de comandos, automatizacion, aplicaciones nativas, backends sensibles al rendimiento y proyectos que quieren ergonomia similar a Ruby con un toolchain compilado."
-        },
-        it: {
-          name: "Crystal",
-          description: "Un linguaggio compilato, con tipi statici, con sintassi ispirata a Ruby e prestazioni native.",
-          longDescription: "Crystal e un linguaggio di programmazione general-purpose con sintassi ispirata a Ruby, controllo dei tipi statico, inferenza dei tipi, macro, fibre, canali, binding C e compilazione nativa. Mira a mantenere il codice espressivo catturando errori di tipo a compile time.\n\nViene utilizzato per servizi web, strumenti da riga di comando, automazione, applicazioni native, sistemi backend sensibili alle prestazioni e progetti che desiderano l'ergonomia simile a Ruby con un toolchain compilato."
+          name: "CQL",
+          description: "Lenguaje de consultas tipo SQL para tablas y keyspaces de Apache Cassandra.",
+          longDescription: "Cassandra Query Language es la interfaz principal para definir y consultar datos en Apache Cassandra. Modela keyspaces, tablas, columnas, indices, vistas materializadas y sentencias para leer y escribir datos particionados.\n\nCQL resulta familiar para usuarios de SQL, pero su comportamiento sigue las reglas de almacenamiento y distribucion de Cassandra. Un buen diseno CQL se centra en claves de particion, columnas de ordenamiento, tablas desnormalizadas y consultas guiadas por patrones de acceso."
+        },
+        it: {
+          name: "CQL",
+          description: "Linguaggio di query simile a SQL per tabelle e keyspace Apache Cassandra.",
+          longDescription: "Cassandra Query Language e l interfaccia principale per definire e interrogare dati in Apache Cassandra. Modella keyspace, tabelle, colonne, indici, viste materializzate e istruzioni per leggere e scrivere dati partizionati.\n\nCQL risulta familiare agli utenti SQL, ma il suo comportamento segue le regole di archiviazione e distribuzione di Cassandra. Un buon design CQL si concentra su chiavi di partizione, colonne di clustering, tabelle denormalizzate e query modellate sui pattern di accesso."
         },
         fr: {
-          name: "Crystal",
-          description: "Un langage compile, de typage statique, avec une syntaxe inspiree de Ruby et des performances natives.",
-          longDescription: "Crystal est un langage de programmation general a usage, avec une syntaxe inspiree de Ruby, un controle de type statique, l'inference de type, des macros, des fibres, des canaux, des liaisons C et une compilation native. Il vise a maintenir le code expressif tout en detectant les erreurs de type au moment de la compilation. \n\nIl est utilise pour les services web, les outils en ligne de commande, l'automatisation, les applications natives, les systemes backend sensibles aux performances et les projets qui souhaitent une ergonomie similaire a Ruby avec un outil de compilation."
+          name: "CQL",
+          description: "Langage de requete proche de SQL pour tables et keyspaces Apache Cassandra.",
+          longDescription: "Cassandra Query Language est l interface principale pour definir et interroger les donnees dans Apache Cassandra. Il modelise keyspaces, tables, colonnes, index, vues materialisees et instructions pour lire et ecrire des donnees partitionnees.\n\nCQL parait familier aux utilisateurs SQL, mais son comportement suit les regles de stockage et de distribution de Cassandra. Une bonne conception CQL se concentre sur cles de partition, colonnes de clustering, tables denormalisees et requetes guidees par les acces."
         },
         de: {
-          name: "Crystal",
-          description: "Eine kompilierte, statisch typisierte Sprache mit Ruby-\xE4hnlicher Syntax und nativem Leistung.",
-          longDescription: "Crystal ist eine allgemeine Programmiersprache mit Syntax, die von Ruby inspiriert ist, statischer Typ\xFCberpr\xFCfung, Typinferenz, Makros, Fibers, Kan\xE4len, C-Bindings und nativem Kompilieren. Sie zielt darauf ab, Code ausdrucksstark zu halten und gleichzeitig Typfehler zur Kompilierzeit zu erkennen.\n\nEs wird f\xFCr Webdienste, Kommandozeilen-Tools, Automatisierung, native Anwendungen, performante Backend-Systeme und Projekte verwendet, die die Ergonomie von Ruby mit einer kompilierten Toolchain w\xFCnschen."
+          name: "CQL",
+          description: "SQL-ahnliche Abfragesprache fur Apache-Cassandra-Tabellen und Keyspaces.",
+          longDescription: "Cassandra Query Language ist die wichtigste Schnittstelle zum Definieren und Abfragen von Daten in Apache Cassandra. Sie modelliert Keyspaces, Tabellen, Spalten, Indizes, materialisierte Views und Anweisungen zum Lesen und Schreiben partitionierter Daten.\n\nCQL wirkt fur SQL-Nutzer vertraut, folgt aber den Speicher- und Verteilungsregeln von Cassandra. Gutes CQL-Design konzentriert sich auf Partitionsschlussel, Clustering-Spalten, denormalisierte Tabellen und Abfragen nach Zugriffsmustern."
         },
         pt: {
-          name: "Crystal",
-          description: "Linguagem compilada, estaticamente tipada com sintaxe inspirada em Ruby e desempenho nativo.",
-          longDescription: "Crystal \xE9 uma linguagem de programa\xE7\xE3o de prop\xF3sito geral com sintaxe inspirada em Ruby, verifica\xE7\xE3o est\xE1tica de tipos, infer\xEAncia de tipos, macros, fibras, canais, bindings C e compila\xE7\xE3o nativa. Seu objetivo \xE9 manter o c\xF3digo expressivo, capturando erros de tipo em tempo de compila\xE7\xE3o.\n\n\xC9 usada para servi\xE7os web, ferramentas de linha de comando, automa\xE7\xE3o, aplicativos nativos, sistemas de backend sens\xEDveis ao desempenho e projetos que desejam a ergonomia semelhante ao Ruby com uma ferramenta compilada."
+          name: "CQL",
+          description: "Linguagem de consulta parecida com SQL para tabelas e keyspaces Cassandra.",
+          longDescription: "Cassandra Query Language e a principal interface para definir e consultar dados no Apache Cassandra. Ela modela keyspaces, tabelas, colunas, indices, visoes materializadas e comandos para ler e gravar dados particionados.\n\nCQL parece familiar para usuarios de SQL, mas seu comportamento segue as regras de armazenamento e distribuicao do Cassandra. Bom design em CQL foca chaves de particao, colunas de clustering, tabelas desnormalizadas e consultas moldadas por padroes de acesso."
         }
       }
     };
   }
 });
 
-// src/languages/cql.ts
-var cql_exports = {};
-__export(cql_exports, {
-  cql: () => cql
+// src/languages/crystal.ts
+var crystal_exports = {};
+__export(crystal_exports, {
+  crystal: () => crystal
 });
-var cql;
-var init_cql = __esm({
-  "src/languages/cql.ts"() {
-    cql = {
-      slug: "cql",
-      publishedDate: "2008-01-01",
-      extensions: [".cql"],
-      author: "Apache Cassandra project",
-      website: "https://cassandra.apache.org/doc/latest/cassandra/developing/cql/index.html",
-      paradigms: ["query", "declarative"],
+var crystal;
+var init_crystal = __esm({
+  "src/languages/crystal.ts"() {
+    crystal = {
+      slug: "crystal",
+      publishedDate: "2014-06-18",
+      extensions: [".cr"],
+      author: "Ary Borenszweig, Juan Wajnerman, Brian Cardiff / Crystal contributors",
+      website: "https://crystal-lang.org",
+      paradigms: ["object-oriented", "functional", "imperative", "concurrent"],
       tooling: {
-        runtimes: ["Apache Cassandra"],
-        ecosystems: ["NoSQL", "Distributed databases"]
+        runtimes: ["Crystal"],
+        packageManagers: ["Shards"],
+        ecosystems: ["Web", "CLI", "Systems", "Native Applications"]
       },
-      version: "CQL 3",
-      logo: "https://cdn.simpleicons.org/apachecassandra/1287B1",
-      color: "#1287B1",
+      version: "1.20.3",
+      logo: "https://cdn.simpleicons.org/crystal/000000",
+      color: "#000000",
       i18n: {
         en: {
-          name: "CQL",
-          description: "A SQL-like query language for Apache Cassandra tables and keyspaces.",
-          longDescription: "Cassandra Query Language is the primary interface for defining and querying data in Apache Cassandra. It models keyspaces, tables, columns, indexes, materialized views, and statements for reading and writing partitioned data.\n\nCQL looks familiar to SQL users, but its behavior follows Cassandra storage and distribution rules. Effective CQL design focuses on partition keys, clustering columns, denormalized tables, and queries shaped around access patterns."
+          name: "Crystal",
+          description: "A compiled, statically typed language with Ruby-inspired syntax and native performance.",
+          longDescription: "Crystal is a general-purpose programming language with syntax inspired by Ruby, static type checking, type inference, macros, fibers, channels, C bindings, and native compilation. It aims to keep code expressive while catching type errors at compile time.\n\nIt is used for web services, command-line tools, automation, native applications, performance-sensitive backend systems, and projects that want Ruby-like ergonomics with a compiled toolchain."
         },
         es: {
-          name: "CQL",
-          description: "Lenguaje de consultas tipo SQL para tablas y keyspaces de Apache Cassandra.",
-          longDescription: "Cassandra Query Language es la interfaz principal para definir y consultar datos en Apache Cassandra. Modela keyspaces, tablas, columnas, indices, vistas materializadas y sentencias para leer y escribir datos particionados.\n\nCQL resulta familiar para usuarios de SQL, pero su comportamiento sigue las reglas de almacenamiento y distribucion de Cassandra. Un buen diseno CQL se centra en claves de particion, columnas de ordenamiento, tablas desnormalizadas y consultas guiadas por patrones de acceso."
+          name: "Crystal",
+          description: "Un lenguaje compilado y tipado estaticamente con sintaxis inspirada en Ruby y rendimiento nativo.",
+          longDescription: "Crystal es un lenguaje de programacion de proposito general con sintaxis inspirada en Ruby, verificacion estatica de tipos, inferencia de tipos, macros, fibers, channels, bindings con C y compilacion nativa. Busca mantener el codigo expresivo mientras detecta errores de tipos en compilacion.\n\nSe usa en servicios web, herramientas de linea de comandos, automatizacion, aplicaciones nativas, backends sensibles al rendimiento y proyectos que quieren ergonomia similar a Ruby con un toolchain compilado."
         },
         it: {
-          name: "CQL",
-          description: "Linguaggio di query simile a SQL per tabelle e keyspace Apache Cassandra.",
-          longDescription: "Cassandra Query Language e l interfaccia principale per definire e interrogare dati in Apache Cassandra. Modella keyspace, tabelle, colonne, indici, viste materializzate e istruzioni per leggere e scrivere dati partizionati.\n\nCQL risulta familiare agli utenti SQL, ma il suo comportamento segue le regole di archiviazione e distribuzione di Cassandra. Un buon design CQL si concentra su chiavi di partizione, colonne di clustering, tabelle denormalizzate e query modellate sui pattern di accesso."
+          name: "Crystal",
+          description: "Un linguaggio compilato, con tipi statici, con sintassi ispirata a Ruby e prestazioni native.",
+          longDescription: "Crystal e un linguaggio di programmazione general-purpose con sintassi ispirata a Ruby, controllo dei tipi statico, inferenza dei tipi, macro, fibre, canali, binding C e compilazione nativa. Mira a mantenere il codice espressivo catturando errori di tipo a compile time.\n\nViene utilizzato per servizi web, strumenti da riga di comando, automazione, applicazioni native, sistemi backend sensibili alle prestazioni e progetti che desiderano l'ergonomia simile a Ruby con un toolchain compilato."
         },
         fr: {
-          name: "CQL",
-          description: "Langage de requete proche de SQL pour tables et keyspaces Apache Cassandra.",
-          longDescription: "Cassandra Query Language est l interface principale pour definir et interroger les donnees dans Apache Cassandra. Il modelise keyspaces, tables, colonnes, index, vues materialisees et instructions pour lire et ecrire des donnees partitionnees.\n\nCQL parait familier aux utilisateurs SQL, mais son comportement suit les regles de stockage et de distribution de Cassandra. Une bonne conception CQL se concentre sur cles de partition, colonnes de clustering, tables denormalisees et requetes guidees par les acces."
+          name: "Crystal",
+          description: "Un langage compile, de typage statique, avec une syntaxe inspiree de Ruby et des performances natives.",
+          longDescription: "Crystal est un langage de programmation general a usage, avec une syntaxe inspiree de Ruby, un controle de type statique, l'inference de type, des macros, des fibres, des canaux, des liaisons C et une compilation native. Il vise a maintenir le code expressif tout en detectant les erreurs de type au moment de la compilation. \n\nIl est utilise pour les services web, les outils en ligne de commande, l'automatisation, les applications natives, les systemes backend sensibles aux performances et les projets qui souhaitent une ergonomie similaire a Ruby avec un outil de compilation."
         },
         de: {
-          name: "CQL",
-          description: "SQL-ahnliche Abfragesprache fur Apache-Cassandra-Tabellen und Keyspaces.",
-          longDescription: "Cassandra Query Language ist die wichtigste Schnittstelle zum Definieren und Abfragen von Daten in Apache Cassandra. Sie modelliert Keyspaces, Tabellen, Spalten, Indizes, materialisierte Views und Anweisungen zum Lesen und Schreiben partitionierter Daten.\n\nCQL wirkt fur SQL-Nutzer vertraut, folgt aber den Speicher- und Verteilungsregeln von Cassandra. Gutes CQL-Design konzentriert sich auf Partitionsschlussel, Clustering-Spalten, denormalisierte Tabellen und Abfragen nach Zugriffsmustern."
+          name: "Crystal",
+          description: "Eine kompilierte, statisch typisierte Sprache mit Ruby-\xE4hnlicher Syntax und nativem Leistung.",
+          longDescription: "Crystal ist eine allgemeine Programmiersprache mit Syntax, die von Ruby inspiriert ist, statischer Typ\xFCberpr\xFCfung, Typinferenz, Makros, Fibers, Kan\xE4len, C-Bindings und nativem Kompilieren. Sie zielt darauf ab, Code ausdrucksstark zu halten und gleichzeitig Typfehler zur Kompilierzeit zu erkennen.\n\nEs wird f\xFCr Webdienste, Kommandozeilen-Tools, Automatisierung, native Anwendungen, performante Backend-Systeme und Projekte verwendet, die die Ergonomie von Ruby mit einer kompilierten Toolchain w\xFCnschen."
         },
         pt: {
-          name: "CQL",
-          description: "Linguagem de consulta parecida com SQL para tabelas e keyspaces Cassandra.",
-          longDescription: "Cassandra Query Language e a principal interface para definir e consultar dados no Apache Cassandra. Ela modela keyspaces, tabelas, colunas, indices, visoes materializadas e comandos para ler e gravar dados particionados.\n\nCQL parece familiar para usuarios de SQL, mas seu comportamento segue as regras de armazenamento e distribuicao do Cassandra. Bom design em CQL foca chaves de particao, colunas de clustering, tabelas desnormalizadas e consultas moldadas por padroes de acesso."
+          name: "Crystal",
+          description: "Linguagem compilada, estaticamente tipada com sintaxe inspirada em Ruby e desempenho nativo.",
+          longDescription: "Crystal \xE9 uma linguagem de programa\xE7\xE3o de prop\xF3sito geral com sintaxe inspirada em Ruby, verifica\xE7\xE3o est\xE1tica de tipos, infer\xEAncia de tipos, macros, fibras, canais, bindings C e compila\xE7\xE3o nativa. Seu objetivo \xE9 manter o c\xF3digo expressivo, capturando erros de tipo em tempo de compila\xE7\xE3o.\n\n\xC9 usada para servi\xE7os web, ferramentas de linha de comando, automa\xE7\xE3o, aplicativos nativos, sistemas de backend sens\xEDveis ao desempenho e projetos que desejam a ergonomia semelhante ao Ruby com uma ferramenta compilada."
         }
       }
     };
@@ -2999,6 +3009,7 @@ var init_csharp = __esm({
   "src/languages/csharp.ts"() {
     csharp = {
       slug: "csharp",
+      aliases: ["c#", "cs"],
       publishedDate: "2000-06-26",
       extensions: [".cs", ".csx"],
       author: "Anders Hejlsberg / Microsoft",
@@ -3597,7 +3608,7 @@ var init_dax = __esm({
         ]
       },
       version: "DAX 2025",
-      logo: "https://dummyimage.com/32x32/F2C811/000000.png&text=DAX",
+      logo: "https://upload.wikimedia.org/wikipedia/commons/c/cf/New_Power_BI_Logo.svg",
       color: "#F2C811",
       i18n: {
         en: {
@@ -3763,6 +3774,7 @@ var init_dockerfile = __esm({
   "src/languages/dockerfile.ts"() {
     dockerfile = {
       slug: "dockerfile",
+      aliases: ["docker"],
       publishedDate: "2013-03-20",
       extensions: ["Dockerfile", ".dockerfile"],
       author: "Docker, Inc.",
@@ -4221,6 +4233,66 @@ var init_elm = __esm({
   }
 });
 
+// src/languages/emacs-lisp.ts
+var emacs_lisp_exports = {};
+__export(emacs_lisp_exports, {
+  emacsLisp: () => emacsLisp
+});
+var emacsLisp;
+var init_emacs_lisp = __esm({
+  "src/languages/emacs-lisp.ts"() {
+    emacsLisp = {
+      slug: "emacs-lisp",
+      aliases: ["elisp"],
+      publishedDate: "1985-03-20",
+      extensions: [".el"],
+      author: "Richard Stallman / GNU Project",
+      website: "https://www.gnu.org/software/emacs/manual/elisp.html",
+      paradigms: ["functional", "imperative", "meta-programming", "scripting"],
+      tooling: {
+        runtimes: ["GNU Emacs"],
+        packageManagers: ["package.el", "ELPA", "MELPA"],
+        ecosystems: ["Text Editors", "Scripting"]
+      },
+      version: "Emacs 30.1",
+      logo: "https://cdn.simpleicons.org/gnuemacs/7F5AB6",
+      color: "#7F5AB6",
+      i18n: {
+        en: {
+          name: "Emacs Lisp",
+          description: "The Lisp dialect used to implement and extend the GNU Emacs editor.",
+          longDescription: "Emacs Lisp is a dialect of Lisp that powers most of the GNU Emacs editor. Beyond configuration, it is a complete programming language with dynamic and lexical binding, macros, and an interactive development workflow built into the editor itself.\n\nThousands of packages distributed through ELPA and MELPA are written in Emacs Lisp, covering everything from mail clients and file managers to language servers and note-taking systems such as Org mode."
+        },
+        es: {
+          name: "Emacs Lisp",
+          description: "El dialecto de Lisp usado para implementar y extender el editor GNU Emacs.",
+          longDescription: "Emacs Lisp es un dialecto de Lisp que impulsa la mayor parte del editor GNU Emacs. M\xE1s all\xE1 de la configuraci\xF3n, es un lenguaje de programaci\xF3n completo con enlace din\xE1mico y l\xE9xico, macros y un flujo de desarrollo interactivo integrado en el propio editor.\n\nMiles de paquetes distribuidos a trav\xE9s de ELPA y MELPA est\xE1n escritos en Emacs Lisp, cubriendo desde clientes de correo y gestores de archivos hasta servidores de lenguaje y sistemas de notas como Org mode."
+        },
+        it: {
+          name: "Emacs Lisp",
+          description: "Il dialetto Lisp usato per implementare ed estendere l'editor GNU Emacs.",
+          longDescription: "Emacs Lisp \xE8 un dialetto di Lisp che alimenta la maggior parte dell'editor GNU Emacs. Oltre alla configurazione, \xE8 un linguaggio di programmazione completo con binding dinamico e lessicale, macro e un flusso di sviluppo interattivo integrato nell'editor stesso.\n\nMigliaia di pacchetti distribuiti tramite ELPA e MELPA sono scritti in Emacs Lisp, coprendo di tutto: client di posta, gestori di file, language server e sistemi di appunti come Org mode."
+        },
+        fr: {
+          name: "Emacs Lisp",
+          description: "Le dialecte Lisp utilis\xE9 pour impl\xE9menter et \xE9tendre l'\xE9diteur GNU Emacs.",
+          longDescription: "Emacs Lisp est un dialecte de Lisp qui fait fonctionner la majeure partie de l'\xE9diteur GNU Emacs. Au-del\xE0 de la configuration, c'est un langage de programmation complet avec liaison dynamique et lexicale, macros et un flux de d\xE9veloppement interactif int\xE9gr\xE9 \xE0 l'\xE9diteur lui-m\xEAme.\n\nDes milliers de paquets distribu\xE9s via ELPA et MELPA sont \xE9crits en Emacs Lisp, couvrant aussi bien des clients de messagerie et des gestionnaires de fichiers que des serveurs de langage et des syst\xE8mes de prise de notes comme Org mode."
+        },
+        de: {
+          name: "Emacs Lisp",
+          description: "Der Lisp-Dialekt, mit dem der GNU-Emacs-Editor implementiert und erweitert wird.",
+          longDescription: "Emacs Lisp ist ein Lisp-Dialekt, der den gr\xF6\xDFten Teil des GNU-Emacs-Editors antreibt. \xDCber die Konfiguration hinaus ist es eine vollst\xE4ndige Programmiersprache mit dynamischer und lexikalischer Bindung, Makros und einem interaktiven Entwicklungsworkflow direkt im Editor.\n\nTausende \xFCber ELPA und MELPA verteilte Pakete sind in Emacs Lisp geschrieben und decken alles ab: von Mail-Clients und Dateimanagern bis zu Language-Servern und Notizsystemen wie Org mode."
+        },
+        pt: {
+          name: "Emacs Lisp",
+          description: "O dialeto de Lisp usado para implementar e estender o editor GNU Emacs.",
+          longDescription: "Emacs Lisp \xE9 um dialeto de Lisp que move a maior parte do editor GNU Emacs. Al\xE9m da configura\xE7\xE3o, \xE9 uma linguagem de programa\xE7\xE3o completa com liga\xE7\xE3o din\xE2mica e l\xE9xica, macros e um fluxo de desenvolvimento interativo integrado ao pr\xF3prio editor.\n\nMilhares de pacotes distribu\xEDdos via ELPA e MELPA s\xE3o escritos em Emacs Lisp, cobrindo de clientes de e-mail e gerenciadores de arquivos a servidores de linguagem e sistemas de notas como o Org mode."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/erb.ts
 var erb_exports = {};
 __export(erb_exports, {
@@ -4408,6 +4480,7 @@ var init_fe = __esm({
   "src/languages/fe.ts"() {
     fe = {
       slug: "fe",
+      status: "experimental",
       publishedDate: "2020-10-08",
       extensions: [".fe"],
       author: "Ethereum Foundation contributors",
@@ -4807,6 +4880,64 @@ var init_fortran = __esm({
   }
 });
 
+// src/languages/fql.ts
+var fql_exports = {};
+__export(fql_exports, {
+  fql: () => fql
+});
+var fql;
+var init_fql = __esm({
+  "src/languages/fql.ts"() {
+    fql = {
+      slug: "fql",
+      publishedDate: "2012-01-01",
+      extensions: [".fql"],
+      author: "Facebook",
+      website: "https://developers.facebook.com/docs/reference/fql/",
+      paradigms: ["query", "declarative"],
+      tooling: {
+        runtimes: ["Facebook Platform"],
+        ecosystems: ["Social APIs", "Legacy web APIs"]
+      },
+      version: "legacy",
+      logo: "https://cdn.simpleicons.org/facebook/1877F2",
+      color: "#1877F2",
+      i18n: {
+        en: {
+          name: "FQL",
+          description: "A legacy SQL-like query language formerly used by Facebook Platform APIs.",
+          longDescription: "Facebook Query Language was a SQL-like language for reading data from the Facebook social graph through older platform APIs. Queries selected fields from virtual tables representing users, pages, events, photos, and related objects.\n\nFQL is now mainly of historical interest, because Facebook replaced it with newer Graph API patterns. It remains useful to recognize in old integrations, archived examples, migrations, and documentation for legacy social applications."
+        },
+        es: {
+          name: "FQL",
+          description: "Lenguaje de consultas legado tipo SQL usado antes por APIs de Facebook.",
+          longDescription: "Facebook Query Language fue un lenguaje tipo SQL para leer datos del grafo social de Facebook mediante APIs antiguas de la plataforma. Las consultas seleccionaban campos de tablas virtuales que representaban usuarios, paginas, eventos, fotos y objetos relacionados.\n\nFQL hoy tiene interes sobre todo historico, porque Facebook lo reemplazo con patrones mas nuevos de Graph API. Sigue siendo util reconocerlo en integraciones viejas, ejemplos archivados, migraciones y documentacion de apps sociales legadas."
+        },
+        it: {
+          name: "FQL",
+          description: "Linguaggio di query legacy simile a SQL usato dalle vecchie API Facebook.",
+          longDescription: "Facebook Query Language era un linguaggio simile a SQL per leggere dati dal grafo sociale di Facebook tramite vecchie API della piattaforma. Le query selezionavano campi da tabelle virtuali che rappresentavano utenti, pagine, eventi, foto e oggetti correlati.\n\nFQL oggi ha soprattutto valore storico, perche Facebook lo ha sostituito con pattern piu nuovi della Graph API. Rimane utile riconoscerlo in integrazioni vecchie, esempi archiviati, migrazioni e documentazione di applicazioni social legacy."
+        },
+        fr: {
+          name: "FQL",
+          description: "Ancien langage de requete proche de SQL utilise par les API Facebook.",
+          longDescription: "Facebook Query Language etait un langage proche de SQL pour lire les donnees du graphe social Facebook via les anciennes API de la plateforme. Les requetes selectionnaient des champs dans des tables virtuelles representant utilisateurs, pages, evenements, photos et objets lies.\n\nFQL a surtout un interet historique, car Facebook l a remplace par des modeles plus recents de Graph API. Il reste utile a reconnaitre dans anciennes integrations, exemples archives, migrations et docs d applications sociales leguees."
+        },
+        de: {
+          name: "FQL",
+          description: "Alte SQL-ahnliche Abfragesprache fruherer Facebook-Platform-APIs.",
+          longDescription: "Facebook Query Language war eine SQL-ahnliche Sprache zum Lesen von Daten aus dem sozialen Graphen von Facebook uber altere Platform-APIs. Abfragen wahlten Felder aus virtuellen Tabellen fur Nutzer, Seiten, Events, Fotos und verwandte Objekte.\n\nFQL ist heute vor allem historisch relevant, weil Facebook es durch neuere Graph-API-Muster ersetzt hat. Es bleibt nutzlich in alten Integrationen, archivierten Beispielen, Migrationen und Dokumentation fur Legacy-Social-Apps."
+        },
+        pt: {
+          name: "FQL",
+          description: "Linguagem de consulta legada parecida com SQL usada por APIs do Facebook.",
+          longDescription: "Facebook Query Language foi uma linguagem parecida com SQL para ler dados do grafo social do Facebook por APIs antigas da plataforma. Consultas selecionavam campos de tabelas virtuais que representavam usuarios, paginas, eventos, fotos e objetos relacionados.\n\nFQL hoje tem valor principalmente historico, pois o Facebook o substituiu por padroes mais novos da Graph API. Ainda e util reconhece-lo em integracoes antigas, exemplos arquivados, migracoes e documentacao de apps sociais legados."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/freemarker.ts
 var freemarker_exports = {};
 __export(freemarker_exports, {
@@ -4866,64 +4997,6 @@ var init_freemarker = __esm({
   }
 });
 
-// src/languages/fql.ts
-var fql_exports = {};
-__export(fql_exports, {
-  fql: () => fql
-});
-var fql;
-var init_fql = __esm({
-  "src/languages/fql.ts"() {
-    fql = {
-      slug: "fql",
-      publishedDate: "2012-01-01",
-      extensions: [".fql"],
-      author: "Facebook",
-      website: "https://developers.facebook.com/docs/reference/fql/",
-      paradigms: ["query", "declarative"],
-      tooling: {
-        runtimes: ["Facebook Platform"],
-        ecosystems: ["Social APIs", "Legacy web APIs"]
-      },
-      version: "legacy",
-      logo: "https://cdn.simpleicons.org/facebook/1877F2",
-      color: "#1877F2",
-      i18n: {
-        en: {
-          name: "FQL",
-          description: "A legacy SQL-like query language formerly used by Facebook Platform APIs.",
-          longDescription: "Facebook Query Language was a SQL-like language for reading data from the Facebook social graph through older platform APIs. Queries selected fields from virtual tables representing users, pages, events, photos, and related objects.\n\nFQL is now mainly of historical interest, because Facebook replaced it with newer Graph API patterns. It remains useful to recognize in old integrations, archived examples, migrations, and documentation for legacy social applications."
-        },
-        es: {
-          name: "FQL",
-          description: "Lenguaje de consultas legado tipo SQL usado antes por APIs de Facebook.",
-          longDescription: "Facebook Query Language fue un lenguaje tipo SQL para leer datos del grafo social de Facebook mediante APIs antiguas de la plataforma. Las consultas seleccionaban campos de tablas virtuales que representaban usuarios, paginas, eventos, fotos y objetos relacionados.\n\nFQL hoy tiene interes sobre todo historico, porque Facebook lo reemplazo con patrones mas nuevos de Graph API. Sigue siendo util reconocerlo en integraciones viejas, ejemplos archivados, migraciones y documentacion de apps sociales legadas."
-        },
-        it: {
-          name: "FQL",
-          description: "Linguaggio di query legacy simile a SQL usato dalle vecchie API Facebook.",
-          longDescription: "Facebook Query Language era un linguaggio simile a SQL per leggere dati dal grafo sociale di Facebook tramite vecchie API della piattaforma. Le query selezionavano campi da tabelle virtuali che rappresentavano utenti, pagine, eventi, foto e oggetti correlati.\n\nFQL oggi ha soprattutto valore storico, perche Facebook lo ha sostituito con pattern piu nuovi della Graph API. Rimane utile riconoscerlo in integrazioni vecchie, esempi archiviati, migrazioni e documentazione di applicazioni social legacy."
-        },
-        fr: {
-          name: "FQL",
-          description: "Ancien langage de requete proche de SQL utilise par les API Facebook.",
-          longDescription: "Facebook Query Language etait un langage proche de SQL pour lire les donnees du graphe social Facebook via les anciennes API de la plateforme. Les requetes selectionnaient des champs dans des tables virtuelles representant utilisateurs, pages, evenements, photos et objets lies.\n\nFQL a surtout un interet historique, car Facebook l a remplace par des modeles plus recents de Graph API. Il reste utile a reconnaitre dans anciennes integrations, exemples archives, migrations et docs d applications sociales leguees."
-        },
-        de: {
-          name: "FQL",
-          description: "Alte SQL-ahnliche Abfragesprache fruherer Facebook-Platform-APIs.",
-          longDescription: "Facebook Query Language war eine SQL-ahnliche Sprache zum Lesen von Daten aus dem sozialen Graphen von Facebook uber altere Platform-APIs. Abfragen wahlten Felder aus virtuellen Tabellen fur Nutzer, Seiten, Events, Fotos und verwandte Objekte.\n\nFQL ist heute vor allem historisch relevant, weil Facebook es durch neuere Graph-API-Muster ersetzt hat. Es bleibt nutzlich in alten Integrationen, archivierten Beispielen, Migrationen und Dokumentation fur Legacy-Social-Apps."
-        },
-        pt: {
-          name: "FQL",
-          description: "Linguagem de consulta legada parecida com SQL usada por APIs do Facebook.",
-          longDescription: "Facebook Query Language foi uma linguagem parecida com SQL para ler dados do grafo social do Facebook por APIs antigas da plataforma. Consultas selecionavam campos de tabelas virtuais que representavam usuarios, paginas, eventos, fotos e objetos relacionados.\n\nFQL hoje tem valor principalmente historico, pois o Facebook o substituiu por padroes mais novos da Graph API. Ainda e util reconhece-lo em integracoes antigas, exemplos arquivados, migracoes e documentacao de apps sociais legados."
-        }
-      }
-    };
-  }
-});
-
 // src/languages/fsharp.ts
 var fsharp_exports = {};
 __export(fsharp_exports, {
@@ -4934,6 +5007,7 @@ var init_fsharp = __esm({
   "src/languages/fsharp.ts"() {
     fsharp = {
       slug: "fsharp",
+      aliases: ["f#"],
       publishedDate: "2005-05-01",
       extensions: [".fs", ".fsi", ".fsx", ".fsscript"],
       author: "Don Syme / Microsoft Research",
@@ -5042,6 +5116,64 @@ var init_fstar = __esm({
   }
 });
 
+// src/languages/gcode.ts
+var gcode_exports = {};
+__export(gcode_exports, {
+  gcode: () => gcode
+});
+var gcode;
+var init_gcode = __esm({
+  "src/languages/gcode.ts"() {
+    gcode = {
+      slug: "gcode",
+      publishedDate: "1958-01-01",
+      extensions: [".gcode", ".gco", ".nc", ".cnc", ".tap"],
+      author: "MIT Servomechanisms Laboratory",
+      website: "https://www.nist.gov/publications/nist-rs274ngc-interpreter-version-3",
+      paradigms: ["machine control", "imperative"],
+      tooling: {
+        runtimes: ["CNC controllers", "3D printer firmware"],
+        ecosystems: ["CNC machining", "Additive manufacturing"]
+      },
+      version: "RS-274",
+      logo: "https://raw.githubusercontent.com/vscode-icons/vscode-icons/master/icons/file_type_gcode.svg",
+      color: "#DC2626",
+      i18n: {
+        en: {
+          name: "G-code",
+          description: "A machine-control language for CNC tools, mills, lathes, routers, and 3D printers.",
+          longDescription: "G-code is a family of machine-control languages used to command motion, speed, coordinates, tools, temperatures, and other manufacturing operations. Programs are usually generated by CAM or slicer software, then interpreted by machine controllers.\n\nIt is common in CNC machining, laser cutting, routing, milling, turning, and additive manufacturing. Dialects vary by controller and vendor, so practical G-code often depends on a specific machine profile."
+        },
+        es: {
+          name: "G-code",
+          description: "Lenguaje de control de maquinas para CNC, fresadoras, tornos, routers e impresoras 3D.",
+          longDescription: "G-code es una familia de lenguajes de control de maquinas usada para ordenar movimiento, velocidad, coordenadas, herramientas, temperaturas y otras operaciones de fabricacion. Los programas suelen generarse con software CAM o slicers y luego los interpretan controladores de maquina.\n\nEs comun en mecanizado CNC, corte laser, routing, fresado, torneado y fabricacion aditiva. Los dialectos varian por controlador y proveedor, asi que el G-code practico suele depender de un perfil de maquina especifico."
+        },
+        it: {
+          name: "G-code",
+          description: "Linguaggio di controllo macchina per utensili CNC, frese, torni, router e stampanti 3D.",
+          longDescription: "G-code e una famiglia di linguaggi di controllo macchina usata per comandare movimento, velocita, coordinate, utensili, temperature e altre operazioni di produzione. I programmi sono di solito generati da software CAM o slicer e poi interpretati dai controller.\n\nE comune in lavorazione CNC, taglio laser, routing, fresatura, tornitura e produzione additiva. I dialetti variano per controller e fornitore, quindi il G-code pratico dipende spesso da un profilo macchina specifico."
+        },
+        fr: {
+          name: "G-code",
+          description: "Langage de controle machine pour outils CNC, fraiseuses, tours, routeurs et imprimantes 3D.",
+          longDescription: "G-code est une famille de langages de controle machine pour commander mouvement, vitesse, coordonnees, outils, temperatures et autres operations de fabrication. Les programmes sont souvent generes par logiciel CAM ou slicer, puis interpretes par des controleurs.\n\nIl est courant en usinage CNC, decoupe laser, routage, fraisage, tournage et fabrication additive. Les dialectes varient selon controleur et fournisseur, donc le G-code pratique depend souvent d un profil machine precis."
+        },
+        de: {
+          name: "G-code",
+          description: "Maschinensteuerungssprache fur CNC-Werkzeuge, Frasen, Drehbanken, Router und 3D-Drucker.",
+          longDescription: "G-code ist eine Familie von Maschinensteuerungssprachen fur Bewegung, Geschwindigkeit, Koordinaten, Werkzeuge, Temperaturen und andere Fertigungsablaufe. Programme werden meist von CAM- oder Slicer-Software erzeugt und dann von Maschinensteuerungen interpretiert.\n\nEr ist verbreitet in CNC-Bearbeitung, Laserschneiden, Routing, Frasen, Drehen und additiver Fertigung. Dialekte unterscheiden sich nach Steuerung und Anbieter, daher hangt praktischer G-code oft von einem konkreten Maschinenprofil ab."
+        },
+        pt: {
+          name: "G-code",
+          description: "Linguagem de controle de maquinas para CNC, fresadoras, tornos, routers e impressoras 3D.",
+          longDescription: "G-code e uma familia de linguagens de controle de maquinas usada para comandar movimento, velocidade, coordenadas, ferramentas, temperaturas e outras operacoes de fabricacao. Programas geralmente sao gerados por software CAM ou slicers e depois interpretados por controladores.\n\nEle e comum em usinagem CNC, corte a laser, roteamento, fresamento, torneamento e manufatura aditiva. Dialetos variam por controlador e fornecedor, entao G-code pratico costuma depender de um perfil de maquina especifico."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/gdscript.ts
 var gdscript_exports = {};
 __export(gdscript_exports, {
@@ -5101,64 +5233,6 @@ var init_gdscript = __esm({
   }
 });
 
-// src/languages/gcode.ts
-var gcode_exports = {};
-__export(gcode_exports, {
-  gcode: () => gcode
-});
-var gcode;
-var init_gcode = __esm({
-  "src/languages/gcode.ts"() {
-    gcode = {
-      slug: "gcode",
-      publishedDate: "1958-01-01",
-      extensions: [".gcode", ".gco", ".nc", ".cnc", ".tap"],
-      author: "MIT Servomechanisms Laboratory",
-      website: "https://www.nist.gov/publications/nist-rs274ngc-interpreter-version-3",
-      paradigms: ["machine control", "imperative"],
-      tooling: {
-        runtimes: ["CNC controllers", "3D printer firmware"],
-        ecosystems: ["CNC machining", "Additive manufacturing"]
-      },
-      version: "RS-274",
-      logo: "https://dummyimage.com/32x32/DC2626/ffffff.png&text=G",
-      color: "#DC2626",
-      i18n: {
-        en: {
-          name: "G-code",
-          description: "A machine-control language for CNC tools, mills, lathes, routers, and 3D printers.",
-          longDescription: "G-code is a family of machine-control languages used to command motion, speed, coordinates, tools, temperatures, and other manufacturing operations. Programs are usually generated by CAM or slicer software, then interpreted by machine controllers.\n\nIt is common in CNC machining, laser cutting, routing, milling, turning, and additive manufacturing. Dialects vary by controller and vendor, so practical G-code often depends on a specific machine profile."
-        },
-        es: {
-          name: "G-code",
-          description: "Lenguaje de control de maquinas para CNC, fresadoras, tornos, routers e impresoras 3D.",
-          longDescription: "G-code es una familia de lenguajes de control de maquinas usada para ordenar movimiento, velocidad, coordenadas, herramientas, temperaturas y otras operaciones de fabricacion. Los programas suelen generarse con software CAM o slicers y luego los interpretan controladores de maquina.\n\nEs comun en mecanizado CNC, corte laser, routing, fresado, torneado y fabricacion aditiva. Los dialectos varian por controlador y proveedor, asi que el G-code practico suele depender de un perfil de maquina especifico."
-        },
-        it: {
-          name: "G-code",
-          description: "Linguaggio di controllo macchina per utensili CNC, frese, torni, router e stampanti 3D.",
-          longDescription: "G-code e una famiglia di linguaggi di controllo macchina usata per comandare movimento, velocita, coordinate, utensili, temperature e altre operazioni di produzione. I programmi sono di solito generati da software CAM o slicer e poi interpretati dai controller.\n\nE comune in lavorazione CNC, taglio laser, routing, fresatura, tornitura e produzione additiva. I dialetti variano per controller e fornitore, quindi il G-code pratico dipende spesso da un profilo macchina specifico."
-        },
-        fr: {
-          name: "G-code",
-          description: "Langage de controle machine pour outils CNC, fraiseuses, tours, routeurs et imprimantes 3D.",
-          longDescription: "G-code est une famille de langages de controle machine pour commander mouvement, vitesse, coordonnees, outils, temperatures et autres operations de fabrication. Les programmes sont souvent generes par logiciel CAM ou slicer, puis interpretes par des controleurs.\n\nIl est courant en usinage CNC, decoupe laser, routage, fraisage, tournage et fabrication additive. Les dialectes varient selon controleur et fournisseur, donc le G-code pratique depend souvent d un profil machine precis."
-        },
-        de: {
-          name: "G-code",
-          description: "Maschinensteuerungssprache fur CNC-Werkzeuge, Frasen, Drehbanken, Router und 3D-Drucker.",
-          longDescription: "G-code ist eine Familie von Maschinensteuerungssprachen fur Bewegung, Geschwindigkeit, Koordinaten, Werkzeuge, Temperaturen und andere Fertigungsablaufe. Programme werden meist von CAM- oder Slicer-Software erzeugt und dann von Maschinensteuerungen interpretiert.\n\nEr ist verbreitet in CNC-Bearbeitung, Laserschneiden, Routing, Frasen, Drehen und additiver Fertigung. Dialekte unterscheiden sich nach Steuerung und Anbieter, daher hangt praktischer G-code oft von einem konkreten Maschinenprofil ab."
-        },
-        pt: {
-          name: "G-code",
-          description: "Linguagem de controle de maquinas para CNC, fresadoras, tornos, routers e impressoras 3D.",
-          longDescription: "G-code e uma familia de linguagens de controle de maquinas usada para comandar movimento, velocidade, coordenadas, ferramentas, temperaturas e outras operacoes de fabricacao. Programas geralmente sao gerados por software CAM ou slicers e depois interpretados por controladores.\n\nEle e comum em usinagem CNC, corte a laser, roteamento, fresamento, torneamento e manufatura aditiva. Dialetos variam por controlador e fornecedor, entao G-code pratico costuma depender de um perfil de maquina especifico."
-        }
-      }
-    };
-  }
-});
-
 // src/languages/gettext.ts
 var gettext_exports = {};
 __export(gettext_exports, {
@@ -5179,7 +5253,7 @@ var init_gettext = __esm({
         ecosystems: ["Internationalization", "Localization"]
       },
       version: "stable",
-      logo: "https://dummyimage.com/32x32/7C3AED/ffffff.png&text=PO",
+      logo: "https://cdn.simpleicons.org/gnu/A42E2B",
       color: "#7C3AED",
       i18n: {
         en: {
@@ -5334,64 +5408,6 @@ var init_gleam = __esm({
   }
 });
 
-// src/languages/gml.ts
-var gml_exports = {};
-__export(gml_exports, {
-  gml: () => gml
-});
-var gml;
-var init_gml = __esm({
-  "src/languages/gml.ts"() {
-    gml = {
-      slug: "gml",
-      publishedDate: "1999-01-01",
-      extensions: [".gml"],
-      author: "YoYo Games",
-      website: "https://gamemaker.io",
-      paradigms: ["object-oriented", "event-driven", "scripting", "procedural"],
-      tooling: {
-        runtimes: ["GameMaker"],
-        ecosystems: ["Game Development", "2D Games", "Indie Games"]
-      },
-      version: "2024.13.0",
-      logo: "https://cdn.simpleicons.org/gamemaker/000000",
-      color: "#71B33C",
-      i18n: {
-        en: {
-          name: "GML",
-          description: "GameMaker Language: a scripting language for 2D game development in GameMaker Studio.",
-          longDescription: "GML (GameMaker Language) is the scripting language used in GameMaker Studio for creating 2D games. It combines an event-driven architecture with a procedural scripting syntax inspired by C, allowing developers to control sprites, objects, rooms, and game logic through code attached to game object events.\n\nGML supports functions, arrays, structs, and lambdas, and has evolved from a simplified drag-and-drop companion into a full-featured language. It targets multiple export platforms including Windows, macOS, Linux, Android, iOS, and consoles. Its accessible design makes it a popular entry point for independent game developers."
-        },
-        es: {
-          name: "GML",
-          description: "GameMaker Language: lenguaje de scripting para desarrollo de juegos 2D en GameMaker Studio.",
-          longDescription: "GML (GameMaker Language) es el lenguaje de scripting utilizado en GameMaker Studio para crear juegos 2D. Combina una arquitectura orientada a eventos con una sintaxis procedural inspirada en C, permitiendo controlar sprites, objetos, salas y logica de juego mediante codigo adjunto a los eventos de los objetos.\n\nGML admite funciones, arrays, structs y lambdas, y ha evolucionado de un complemento simplificado de arrastrar y soltar a un lenguaje completo. Exporta a multiples plataformas como Windows, macOS, Linux, Android, iOS y consolas. Su diseno accesible lo hace popular entre desarrolladores de juegos independientes."
-        },
-        it: {
-          name: "GML",
-          description: "GameMaker Language: linguaggio di scripting per lo sviluppo di giochi 2D in GameMaker Studio.",
-          longDescription: "GML (GameMaker Language) e il linguaggio di scripting utilizzato in GameMaker Studio per creare giochi 2D. Combina un architettura event-driven con una sintassi procedurale ispirata al C, consentendo di controllare sprite, oggetti, stanze e logica di gioco tramite codice allegato agli eventi degli oggetti di gioco.\n\nGML supporta funzioni, array, struct e lambda, ed e evoluto da un semplice strumento drag-and-drop a un linguaggio completo. Supporta l esportazione su piu piattaforme tra cui Windows, macOS, Linux, Android, iOS e console. Il suo design accessibile lo rende un punto di ingresso popolare per gli sviluppatori indie."
-        },
-        fr: {
-          name: "GML",
-          description: "GameMaker Language: langage de script pour le developpement de jeux 2D dans GameMaker Studio.",
-          longDescription: "GML (GameMaker Language) est le langage de script utilise dans GameMaker Studio pour creer des jeux 2D. Il combine une architecture evenementielle avec une syntaxe procedurale inspiree du C, permettant de controler sprites, objets, salles et logique de jeu via du code attache aux evenements des objets de jeu.\n\nGML prend en charge les fonctions, tableaux, structures et lambdas, et a evolue d un simple outil glisser-deposer vers un langage complet. Il cible de nombreuses plateformes d export dont Windows, macOS, Linux, Android, iOS et consoles. Sa conception accessible en fait un point d entree populaire pour les developpeurs independants."
-        },
-        de: {
-          name: "GML",
-          description: "GameMaker Language: Skriptsprache fur 2D-Spieleentwicklung in GameMaker Studio.",
-          longDescription: "GML (GameMaker Language) ist die Skriptsprache von GameMaker Studio fur die Entwicklung von 2D-Spielen. Sie kombiniert eine ereignisgesteuerte Architektur mit einer prozeduralen, an C angelehnten Syntax und ermoglicht die Steuerung von Sprites, Objekten, Raumen und Spiellogik uber an Ereignisse gebundenen Code.\n\nGML unterstutzt Funktionen, Arrays, Structs und Lambdas und hat sich von einem einfachen Drag-and-Drop-Werkzeug zu einer vollwertigen Sprache entwickelt. Es exportiert auf mehrere Plattformen wie Windows, macOS, Linux, Android, iOS und Konsolen. Sein zugangliches Design macht es zum beliebten Einstiegspunkt fur Indie-Spieleentwickler."
-        },
-        pt: {
-          name: "GML",
-          description: "GameMaker Language: linguagem de script para desenvolvimento de jogos 2D no GameMaker Studio.",
-          longDescription: "GML (GameMaker Language) e a linguagem de script usada no GameMaker Studio para criar jogos 2D. Combina uma arquitetura orientada a eventos com uma sintaxe procedural inspirada em C, permitindo controlar sprites, objetos, salas e logica de jogo por meio de codigo vinculado aos eventos dos objetos.\n\nGML suporta funcoes, arrays, structs e lambdas, e evoluiu de um simples complemento de arrastar e soltar para uma linguagem completa. Exporta para multiplas plataformas como Windows, macOS, Linux, Android, iOS e consoles. Seu design acessivel o torna um ponto de entrada popular para desenvolvedores de jogos independentes."
-        }
-      }
-    };
-  }
-});
-
 // src/languages/glsl.ts
 var glsl_exports = {};
 __export(glsl_exports, {
@@ -5432,19 +5448,77 @@ var init_glsl = __esm({
           longDescription: "GLSL e il linguaggio di shading OpenGL utilizzato per scrivere programmi GPU per gli stadi di vertex, fragment, geometry, tessellation e compute. Fornisce una sintassi simile a C, tipi di vettori e matrici, campionamento di texture, uniformi, variabili e funzioni integrate per le pipeline grafiche.\n\nE utilizzato in motori di gioco, strumenti di visualizzazione, applicazioni WebGL, coding creativo, sistemi di rendering, simulazioni e progetti di grafica in tempo reale che richiedono un comportamento GPU programmabile."
         },
         fr: {
-          name: "GLSL",
-          description: "Le langage de programmation GLSL pour ecrire des etapes de shaders GPU programmables.",
-          longDescription: "GLSL est le langage de programmation GLSL utilise pour ecrire des programmes GPU pour les etapes de vertex, fragment, geometrie, tessellation et compute shader. Il fournit une syntaxe semblable a C, des types de vecteurs et de matrices, de l'echantillonnage de textures, des uniformes, des variables et des fonctions integrees pour les pipelines graphiques.\n\nIl est utilise dans les moteurs de jeu, les outils de visualisation, les applications WebGL, le codage creatif, les systemes de rendu, les simulations et les projets de graphiques en temps reel qui necessitent un comportement GPU programmable."
+          name: "GLSL",
+          description: "Le langage de programmation GLSL pour ecrire des etapes de shaders GPU programmables.",
+          longDescription: "GLSL est le langage de programmation GLSL utilise pour ecrire des programmes GPU pour les etapes de vertex, fragment, geometrie, tessellation et compute shader. Il fournit une syntaxe semblable a C, des types de vecteurs et de matrices, de l'echantillonnage de textures, des uniformes, des variables et des fonctions integrees pour les pipelines graphiques.\n\nIl est utilise dans les moteurs de jeu, les outils de visualisation, les applications WebGL, le codage creatif, les systemes de rendu, les simulations et les projets de graphiques en temps reel qui necessitent un comportement GPU programmable."
+        },
+        de: {
+          name: "GLSL",
+          description: "Die OpenGL Shading Language f\xFCr das Schreiben von programmierbaren GPU-Shader-Stufen.",
+          longDescription: "GLSL ist die OpenGL Shading Language, die zum Schreiben von GPU-Programmen f\xFCr Vertex-, Fragment-, Geometry-, Tessellation- und Compute-Shader-Stufen verwendet wird. Sie bietet eine C-\xE4hnliche Syntax, Vektor- und Matrixtypen, Textur-Sampling, Uniformen, Varyings und integrierte Funktionen f\xFCr Grafikpipelines.\n\nSie wird in Spiel-Engines, Visualisierungstools, WebGL-Anwendungen, kreativem Coding, Rendering-Systemen, Simulationen und Echtzeit-Grafikprojekten verwendet, die programmierbares GPU-Verhalten ben\xF6tigen."
+        },
+        pt: {
+          name: "GLSL",
+          description: "A linguagem de programa\xE7\xE3o GLSL para escrever est\xE1gios de shaders GPU program\xE1veis.",
+          longDescription: "GLSL \xE9 a linguagem de programa\xE7\xE3o GLSL usada para escrever programas GPU para est\xE1gios de vertex, fragment, geometria, tessela\xE7\xE3o e compute. Fornece uma sintaxe semelhante \xE0 C, tipos de vetores e matrizes, amostragem de texturas, uniformes, vari\xE1veis e fun\xE7\xF5es embutidas para pipelines de gr\xE1ficos.\n\n\xC9 usada em motores de jogos, ferramentas de visualiza\xE7\xE3o, aplica\xE7\xF5es WebGL, codifica\xE7\xE3o criativa, sistemas de renderiza\xE7\xE3o, simula\xE7\xF5es e projetos de gr\xE1ficos em tempo real que precisam de comportamento de GPU program\xE1vel."
+        }
+      }
+    };
+  }
+});
+
+// src/languages/gml.ts
+var gml_exports = {};
+__export(gml_exports, {
+  gml: () => gml
+});
+var gml;
+var init_gml = __esm({
+  "src/languages/gml.ts"() {
+    gml = {
+      slug: "gml",
+      publishedDate: "1999-01-01",
+      extensions: [".gml"],
+      author: "YoYo Games",
+      website: "https://gamemaker.io",
+      paradigms: ["object-oriented", "event-driven", "scripting", "procedural"],
+      tooling: {
+        runtimes: ["GameMaker"],
+        ecosystems: ["Game Development", "2D Games", "Indie Games"]
+      },
+      version: "2024.13.0",
+      logo: "https://cdn.simpleicons.org/gamemaker/000000",
+      color: "#71B33C",
+      i18n: {
+        en: {
+          name: "GML",
+          description: "GameMaker Language: a scripting language for 2D game development in GameMaker Studio.",
+          longDescription: "GML (GameMaker Language) is the scripting language used in GameMaker Studio for creating 2D games. It combines an event-driven architecture with a procedural scripting syntax inspired by C, allowing developers to control sprites, objects, rooms, and game logic through code attached to game object events.\n\nGML supports functions, arrays, structs, and lambdas, and has evolved from a simplified drag-and-drop companion into a full-featured language. It targets multiple export platforms including Windows, macOS, Linux, Android, iOS, and consoles. Its accessible design makes it a popular entry point for independent game developers."
+        },
+        es: {
+          name: "GML",
+          description: "GameMaker Language: lenguaje de scripting para desarrollo de juegos 2D en GameMaker Studio.",
+          longDescription: "GML (GameMaker Language) es el lenguaje de scripting utilizado en GameMaker Studio para crear juegos 2D. Combina una arquitectura orientada a eventos con una sintaxis procedural inspirada en C, permitiendo controlar sprites, objetos, salas y logica de juego mediante codigo adjunto a los eventos de los objetos.\n\nGML admite funciones, arrays, structs y lambdas, y ha evolucionado de un complemento simplificado de arrastrar y soltar a un lenguaje completo. Exporta a multiples plataformas como Windows, macOS, Linux, Android, iOS y consolas. Su diseno accesible lo hace popular entre desarrolladores de juegos independientes."
+        },
+        it: {
+          name: "GML",
+          description: "GameMaker Language: linguaggio di scripting per lo sviluppo di giochi 2D in GameMaker Studio.",
+          longDescription: "GML (GameMaker Language) e il linguaggio di scripting utilizzato in GameMaker Studio per creare giochi 2D. Combina un architettura event-driven con una sintassi procedurale ispirata al C, consentendo di controllare sprite, oggetti, stanze e logica di gioco tramite codice allegato agli eventi degli oggetti di gioco.\n\nGML supporta funzioni, array, struct e lambda, ed e evoluto da un semplice strumento drag-and-drop a un linguaggio completo. Supporta l esportazione su piu piattaforme tra cui Windows, macOS, Linux, Android, iOS e console. Il suo design accessibile lo rende un punto di ingresso popolare per gli sviluppatori indie."
+        },
+        fr: {
+          name: "GML",
+          description: "GameMaker Language: langage de script pour le developpement de jeux 2D dans GameMaker Studio.",
+          longDescription: "GML (GameMaker Language) est le langage de script utilise dans GameMaker Studio pour creer des jeux 2D. Il combine une architecture evenementielle avec une syntaxe procedurale inspiree du C, permettant de controler sprites, objets, salles et logique de jeu via du code attache aux evenements des objets de jeu.\n\nGML prend en charge les fonctions, tableaux, structures et lambdas, et a evolue d un simple outil glisser-deposer vers un langage complet. Il cible de nombreuses plateformes d export dont Windows, macOS, Linux, Android, iOS et consoles. Sa conception accessible en fait un point d entree populaire pour les developpeurs independants."
         },
         de: {
-          name: "GLSL",
-          description: "Die OpenGL Shading Language f\xFCr das Schreiben von programmierbaren GPU-Shader-Stufen.",
-          longDescription: "GLSL ist die OpenGL Shading Language, die zum Schreiben von GPU-Programmen f\xFCr Vertex-, Fragment-, Geometry-, Tessellation- und Compute-Shader-Stufen verwendet wird. Sie bietet eine C-\xE4hnliche Syntax, Vektor- und Matrixtypen, Textur-Sampling, Uniformen, Varyings und integrierte Funktionen f\xFCr Grafikpipelines.\n\nSie wird in Spiel-Engines, Visualisierungstools, WebGL-Anwendungen, kreativem Coding, Rendering-Systemen, Simulationen und Echtzeit-Grafikprojekten verwendet, die programmierbares GPU-Verhalten ben\xF6tigen."
+          name: "GML",
+          description: "GameMaker Language: Skriptsprache fur 2D-Spieleentwicklung in GameMaker Studio.",
+          longDescription: "GML (GameMaker Language) ist die Skriptsprache von GameMaker Studio fur die Entwicklung von 2D-Spielen. Sie kombiniert eine ereignisgesteuerte Architektur mit einer prozeduralen, an C angelehnten Syntax und ermoglicht die Steuerung von Sprites, Objekten, Raumen und Spiellogik uber an Ereignisse gebundenen Code.\n\nGML unterstutzt Funktionen, Arrays, Structs und Lambdas und hat sich von einem einfachen Drag-and-Drop-Werkzeug zu einer vollwertigen Sprache entwickelt. Es exportiert auf mehrere Plattformen wie Windows, macOS, Linux, Android, iOS und Konsolen. Sein zugangliches Design macht es zum beliebten Einstiegspunkt fur Indie-Spieleentwickler."
         },
         pt: {
-          name: "GLSL",
-          description: "A linguagem de programa\xE7\xE3o GLSL para escrever est\xE1gios de shaders GPU program\xE1veis.",
-          longDescription: "GLSL \xE9 a linguagem de programa\xE7\xE3o GLSL usada para escrever programas GPU para est\xE1gios de vertex, fragment, geometria, tessela\xE7\xE3o e compute. Fornece uma sintaxe semelhante \xE0 C, tipos de vetores e matrizes, amostragem de texturas, uniformes, vari\xE1veis e fun\xE7\xF5es embutidas para pipelines de gr\xE1ficos.\n\n\xC9 usada em motores de jogos, ferramentas de visualiza\xE7\xE3o, aplica\xE7\xF5es WebGL, codifica\xE7\xE3o criativa, sistemas de renderiza\xE7\xE3o, simula\xE7\xF5es e projetos de gr\xE1ficos em tempo real que precisam de comportamento de GPU program\xE1vel."
+          name: "GML",
+          description: "GameMaker Language: linguagem de script para desenvolvimento de jogos 2D no GameMaker Studio.",
+          longDescription: "GML (GameMaker Language) e a linguagem de script usada no GameMaker Studio para criar jogos 2D. Combina uma arquitetura orientada a eventos com uma sintaxe procedural inspirada em C, permitindo controlar sprites, objetos, salas e logica de jogo por meio de codigo vinculado aos eventos dos objetos.\n\nGML suporta funcoes, arrays, structs e lambdas, e evoluiu de um simples complemento de arrastar e soltar para uma linguagem completa. Exporta para multiplas plataformas como Windows, macOS, Linux, Android, iOS e consoles. Seu design acessivel o torna um ponto de entrada popular para desenvolvedores de jogos independentes."
         }
       }
     };
@@ -5461,6 +5535,7 @@ var init_go = __esm({
   "src/languages/go.ts"() {
     go = {
       slug: "go",
+      aliases: ["golang"],
       publishedDate: "2012-03-28",
       extensions: [".go"],
       author: "Robert Griesemer, Rob Pike, Ken Thompson / Google",
@@ -6699,7 +6774,7 @@ var init_io = __esm({
         ecosystems: ["Scripting", "Prototype Programming", "Language Exploration"]
       },
       version: "2017.09.06",
-      logo: "https://dummyimage.com/32x32/2563EB/ffffff.png&text=Io",
+      logo: "https://raw.githubusercontent.com/vscode-icons/vscode-icons/master/icons/file_type_io.svg",
       color: "#2563EB",
       i18n: {
         en: {
@@ -6923,6 +6998,7 @@ var init_javascript = __esm({
   "src/languages/javascript.ts"() {
     javascript = {
       slug: "javascript",
+      aliases: ["js", "ecmascript"],
       publishedDate: "1995-12-04",
       extensions: [".js", ".mjs", ".cjs", ".jsx"],
       author: "Brendan Eich / Netscape",
@@ -6972,6 +7048,64 @@ var init_javascript = __esm({
   }
 });
 
+// src/languages/jcl.ts
+var jcl_exports = {};
+__export(jcl_exports, {
+  jcl: () => jcl
+});
+var jcl;
+var init_jcl = __esm({
+  "src/languages/jcl.ts"() {
+    jcl = {
+      slug: "jcl",
+      publishedDate: "1964-04-07",
+      extensions: [".jcl"],
+      author: "IBM",
+      website: "https://www.ibm.com/docs/en/zos/3.1.0?topic=zos-mvs-jcl-reference",
+      paradigms: ["declarative", "batch"],
+      tooling: {
+        runtimes: ["z/OS", "MVS", "JES2", "JES3"],
+        ecosystems: ["Mainframe", "Batch Processing"]
+      },
+      version: "z/OS 3.1",
+      logo: "https://upload.wikimedia.org/wikipedia/commons/5/51/IBM_logo.svg",
+      color: "#1F70C1",
+      i18n: {
+        en: {
+          name: "JCL",
+          description: "IBM Job Control Language for describing batch jobs on z/OS mainframes.",
+          longDescription: "JCL (Job Control Language) tells IBM mainframe operating systems how to run batch work: which programs to execute, in what order, with which datasets, and how to react to failures. JOB, EXEC, and DD statements describe jobs, steps, and data allocations processed by the JES2/JES3 subsystems.\n\nIntroduced with System/360 in 1964, JCL still orchestrates nightly batch processing in banking, insurance, and government workloads on z/OS, usually alongside COBOL, PL/I, and REXX."
+        },
+        es: {
+          name: "JCL",
+          description: "El Job Control Language de IBM para describir trabajos batch en mainframes z/OS.",
+          longDescription: "JCL (Job Control Language) indica a los sistemas operativos de mainframe de IBM c\xF3mo ejecutar trabajo batch: qu\xE9 programas ejecutar, en qu\xE9 orden, con qu\xE9 datasets y c\xF3mo reaccionar ante fallos. Las sentencias JOB, EXEC y DD describen trabajos, pasos y asignaciones de datos procesados por los subsistemas JES2/JES3.\n\nIntroducido con el System/360 en 1964, JCL sigue orquestando el procesamiento batch nocturno en cargas bancarias, de seguros y gubernamentales sobre z/OS, normalmente junto a COBOL, PL/I y REXX."
+        },
+        it: {
+          name: "JCL",
+          description: "Il Job Control Language di IBM per descrivere job batch sui mainframe z/OS.",
+          longDescription: "JCL (Job Control Language) indica ai sistemi operativi mainframe di IBM come eseguire il lavoro batch: quali programmi eseguire, in quale ordine, con quali dataset e come reagire ai fallimenti. Le istruzioni JOB, EXEC e DD descrivono job, step e allocazioni di dati elaborati dai sottosistemi JES2/JES3.\n\nIntrodotto con il System/360 nel 1964, JCL orchestra ancora l'elaborazione batch notturna nei carichi bancari, assicurativi e governativi su z/OS, di solito insieme a COBOL, PL/I e REXX."
+        },
+        fr: {
+          name: "JCL",
+          description: "Le Job Control Language d'IBM pour d\xE9crire les travaux batch sur mainframes z/OS.",
+          longDescription: "JCL (Job Control Language) indique aux syst\xE8mes d'exploitation mainframe d'IBM comment ex\xE9cuter le travail batch : quels programmes lancer, dans quel ordre, avec quels datasets et comment r\xE9agir aux \xE9checs. Les instructions JOB, EXEC et DD d\xE9crivent les travaux, les \xE9tapes et les allocations de donn\xE9es trait\xE9s par les sous-syst\xE8mes JES2/JES3.\n\nIntroduit avec le System/360 en 1964, JCL orchestre encore le traitement batch nocturne des charges bancaires, d'assurance et gouvernementales sous z/OS, g\xE9n\xE9ralement aux c\xF4t\xE9s de COBOL, PL/I et REXX."
+        },
+        de: {
+          name: "JCL",
+          description: "IBMs Job Control Language zur Beschreibung von Batch-Jobs auf z/OS-Mainframes.",
+          longDescription: "JCL (Job Control Language) sagt IBM-Mainframe-Betriebssystemen, wie Batch-Arbeit auszuf\xFChren ist: welche Programme in welcher Reihenfolge laufen, mit welchen Datasets und wie auf Fehler zu reagieren ist. JOB-, EXEC- und DD-Anweisungen beschreiben Jobs, Schritte und Datenzuweisungen, die von den JES2/JES3-Subsystemen verarbeitet werden.\n\nMit dem System/360 im Jahr 1964 eingef\xFChrt, orchestriert JCL noch heute die n\xE4chtliche Batch-Verarbeitung in Bank-, Versicherungs- und Beh\xF6rden-Workloads auf z/OS, \xFCblicherweise neben COBOL, PL/I und REXX."
+        },
+        pt: {
+          name: "JCL",
+          description: "A Job Control Language da IBM para descrever jobs batch em mainframes z/OS.",
+          longDescription: "JCL (Job Control Language) diz aos sistemas operacionais de mainframe da IBM como executar trabalho batch: quais programas executar, em que ordem, com quais datasets e como reagir a falhas. As instru\xE7\xF5es JOB, EXEC e DD descrevem jobs, passos e aloca\xE7\xF5es de dados processados pelos subsistemas JES2/JES3.\n\nIntroduzida com o System/360 em 1964, a JCL ainda orquestra o processamento batch noturno em cargas banc\xE1rias, de seguros e governamentais no z/OS, geralmente ao lado de COBOL, PL/I e REXX."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/jinja.ts
 var jinja_exports = {};
 __export(jinja_exports, {
@@ -7089,6 +7223,64 @@ var init_jmespath = __esm({
   }
 });
 
+// src/languages/jq.ts
+var jq_exports = {};
+__export(jq_exports, {
+  jq: () => jq
+});
+var jq;
+var init_jq = __esm({
+  "src/languages/jq.ts"() {
+    jq = {
+      slug: "jq",
+      publishedDate: "2012-10-21",
+      extensions: [".jq"],
+      author: "Stephen Dolan",
+      website: "https://jqlang.org",
+      paradigms: ["functional", "declarative", "query"],
+      tooling: {
+        runtimes: ["jq CLI"],
+        ecosystems: ["Data Processing", "DevOps", "Scripting"]
+      },
+      version: "1.8.1",
+      logo: "https://avatars.githubusercontent.com/u/125535133?v=4",
+      color: "#C7254E",
+      i18n: {
+        en: {
+          name: "jq",
+          description: "A functional filter language for slicing, transforming, and querying JSON.",
+          longDescription: "jq is a lightweight command-line language for processing JSON. Programs are written as filter pipelines that select, reshape, and combine values, with built-in functions for iteration, reduction, string handling, and arithmetic.\n\nIt is a staple of shell scripting and DevOps workflows, used to inspect API responses, transform configuration, and glue JSON-producing tools together. Larger filters can be stored in .jq files and reused as modules."
+        },
+        es: {
+          name: "jq",
+          description: "Un lenguaje funcional de filtros para cortar, transformar y consultar JSON.",
+          longDescription: "jq es un lenguaje ligero de l\xEDnea de comandos para procesar JSON. Los programas se escriben como tuber\xEDas de filtros que seleccionan, remodelan y combinan valores, con funciones integradas para iteraci\xF3n, reducci\xF3n, manejo de cadenas y aritm\xE9tica.\n\nEs una pieza b\xE1sica del scripting de shell y de los flujos DevOps, usado para inspeccionar respuestas de API, transformar configuraci\xF3n y conectar herramientas que producen JSON. Los filtros grandes pueden guardarse en archivos .jq y reutilizarse como m\xF3dulos."
+        },
+        it: {
+          name: "jq",
+          description: "Un linguaggio funzionale di filtri per tagliare, trasformare e interrogare JSON.",
+          longDescription: "jq \xE8 un linguaggio leggero da riga di comando per elaborare JSON. I programmi si scrivono come pipeline di filtri che selezionano, rimodellano e combinano valori, con funzioni integrate per iterazione, riduzione, gestione delle stringhe e aritmetica.\n\n\xC8 un elemento fondamentale dello scripting di shell e dei flussi DevOps, usato per ispezionare risposte di API, trasformare configurazioni e collegare strumenti che producono JSON. I filtri pi\xF9 grandi possono essere salvati in file .jq e riutilizzati come moduli."
+        },
+        fr: {
+          name: "jq",
+          description: "Un langage fonctionnel de filtres pour d\xE9couper, transformer et interroger du JSON.",
+          longDescription: "jq est un langage l\xE9ger en ligne de commande pour traiter du JSON. Les programmes s'\xE9crivent comme des pipelines de filtres qui s\xE9lectionnent, remod\xE8lent et combinent des valeurs, avec des fonctions int\xE9gr\xE9es pour l'it\xE9ration, la r\xE9duction, le traitement des cha\xEEnes et l'arithm\xE9tique.\n\nC'est un incontournable des scripts shell et des workflows DevOps, utilis\xE9 pour inspecter des r\xE9ponses d'API, transformer de la configuration et relier des outils produisant du JSON. Les filtres volumineux peuvent \xEAtre stock\xE9s dans des fichiers .jq et r\xE9utilis\xE9s comme modules."
+        },
+        de: {
+          name: "jq",
+          description: "Eine funktionale Filtersprache zum Zerlegen, Transformieren und Abfragen von JSON.",
+          longDescription: "jq ist eine leichtgewichtige Kommandozeilensprache zur Verarbeitung von JSON. Programme werden als Filter-Pipelines geschrieben, die Werte ausw\xE4hlen, umformen und kombinieren, mit eingebauten Funktionen f\xFCr Iteration, Reduktion, Zeichenkettenverarbeitung und Arithmetik.\n\nSie ist ein fester Bestandteil von Shell-Skripten und DevOps-Workflows und dient dazu, API-Antworten zu untersuchen, Konfigurationen zu transformieren und JSON-erzeugende Werkzeuge zu verbinden. Gr\xF6\xDFere Filter k\xF6nnen in .jq-Dateien abgelegt und als Module wiederverwendet werden."
+        },
+        pt: {
+          name: "jq",
+          description: "Uma linguagem funcional de filtros para fatiar, transformar e consultar JSON.",
+          longDescription: "jq \xE9 uma linguagem leve de linha de comando para processar JSON. Os programas s\xE3o escritos como pipelines de filtros que selecionam, remodelam e combinam valores, com fun\xE7\xF5es embutidas para itera\xE7\xE3o, redu\xE7\xE3o, manipula\xE7\xE3o de strings e aritm\xE9tica.\n\n\xC9 um item b\xE1sico do scripting de shell e dos fluxos DevOps, usado para inspecionar respostas de API, transformar configura\xE7\xF5es e conectar ferramentas que produzem JSON. Filtros maiores podem ser guardados em arquivos .jq e reutilizados como m\xF3dulos."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/json.ts
 var json_exports = {};
 __export(json_exports, {
@@ -7740,6 +7932,7 @@ var init_kotlin = __esm({
   "src/languages/kotlin.ts"() {
     kotlin = {
       slug: "kotlin",
+      aliases: ["kt"],
       publishedDate: "2016-02-15",
       extensions: [".kt", ".kts"],
       author: "JetBrains",
@@ -7965,6 +8158,65 @@ var init_less = __esm({
   }
 });
 
+// src/languages/lex.ts
+var lex_exports = {};
+__export(lex_exports, {
+  lex: () => lex
+});
+var lex;
+var init_lex = __esm({
+  "src/languages/lex.ts"() {
+    lex = {
+      slug: "lex",
+      aliases: ["flex"],
+      publishedDate: "1975-07-01",
+      extensions: [".l", ".lex"],
+      author: "Mike Lesk / Eric Schmidt (Bell Labs)",
+      website: "https://pubs.opengroup.org/onlinepubs/9699919799/utilities/lex.html",
+      paradigms: ["declarative", "generator"],
+      tooling: {
+        runtimes: ["C toolchains"],
+        ecosystems: ["Compilers", "Language Tooling", "Unix"]
+      },
+      version: "POSIX lex / flex 2.6.4",
+      logo: "https://dummyimage.com/32x32/DBCA00/000000.png&text=Lex",
+      color: "#DBCA00",
+      i18n: {
+        en: {
+          name: "Lex",
+          description: "A lexical analyzer generator that turns regex rules into scanner code.",
+          longDescription: "Lex is a classic Unix tool that generates lexical analyzers. A .l specification pairs regular expressions with C actions; the generated scanner reads input, groups characters into tokens, and hands them to a parser, typically one produced by Yacc or Bison.\n\nThe modern open-source implementation is flex, which remains a standard part of compiler courses and production language tooling wherever hand-written lexers are not required."
+        },
+        es: {
+          name: "Lex",
+          description: "Un generador de analizadores l\xE9xicos que convierte reglas regex en c\xF3digo de escaneo.",
+          longDescription: "Lex es una herramienta cl\xE1sica de Unix que genera analizadores l\xE9xicos. Una especificaci\xF3n .l empareja expresiones regulares con acciones en C; el esc\xE1ner generado lee la entrada, agrupa caracteres en tokens y los entrega a un parser, normalmente producido por Yacc o Bison.\n\nLa implementaci\xF3n moderna de c\xF3digo abierto es flex, que sigue siendo parte est\xE1ndar de los cursos de compiladores y de las herramientas de lenguajes en producci\xF3n donde no se requieren lexers escritos a mano."
+        },
+        it: {
+          name: "Lex",
+          description: "Un generatore di analizzatori lessicali che trasforma regole regex in codice scanner.",
+          longDescription: "Lex \xE8 uno strumento classico di Unix che genera analizzatori lessicali. Una specifica .l abbina espressioni regolari ad azioni in C; lo scanner generato legge l'input, raggruppa i caratteri in token e li passa a un parser, tipicamente prodotto da Yacc o Bison.\n\nL'implementazione open source moderna \xE8 flex, che rimane una parte standard dei corsi sui compilatori e degli strumenti linguistici in produzione dove non servono lexer scritti a mano."
+        },
+        fr: {
+          name: "Lex",
+          description: "Un g\xE9n\xE9rateur d'analyseurs lexicaux qui transforme des r\xE8gles regex en code de scanner.",
+          longDescription: "Lex est un outil Unix classique qui g\xE9n\xE8re des analyseurs lexicaux. Une sp\xE9cification .l associe des expressions r\xE9guli\xE8res \xE0 des actions en C ; le scanner g\xE9n\xE9r\xE9 lit l'entr\xE9e, regroupe les caract\xE8res en jetons et les transmet \xE0 un parseur, g\xE9n\xE9ralement produit par Yacc ou Bison.\n\nL'impl\xE9mentation open source moderne est flex, qui reste un \xE9l\xE9ment standard des cours de compilation et de l'outillage de langages en production lorsque des lexers \xE9crits \xE0 la main ne sont pas n\xE9cessaires."
+        },
+        de: {
+          name: "Lex",
+          description: "Ein Generator f\xFCr lexikalische Analysatoren, der Regex-Regeln in Scanner-Code \xFCbersetzt.",
+          longDescription: "Lex ist ein klassisches Unix-Werkzeug zur Erzeugung lexikalischer Analysatoren. Eine .l-Spezifikation verkn\xFCpft regul\xE4re Ausdr\xFCcke mit C-Aktionen; der erzeugte Scanner liest die Eingabe, gruppiert Zeichen zu Tokens und \xFCbergibt sie an einen Parser, der typischerweise von Yacc oder Bison erzeugt wird.\n\nDie moderne Open-Source-Implementierung ist flex, die weiterhin fester Bestandteil von Compiler-Kursen und produktivem Sprach-Tooling ist, wo keine handgeschriebenen Lexer erforderlich sind."
+        },
+        pt: {
+          name: "Lex",
+          description: "Um gerador de analisadores l\xE9xicos que converte regras regex em c\xF3digo de scanner.",
+          longDescription: "Lex \xE9 uma ferramenta cl\xE1ssica do Unix que gera analisadores l\xE9xicos. Uma especifica\xE7\xE3o .l combina express\xF5es regulares com a\xE7\xF5es em C; o scanner gerado l\xEA a entrada, agrupa caracteres em tokens e os entrega a um parser, normalmente produzido pelo Yacc ou Bison.\n\nA implementa\xE7\xE3o moderna de c\xF3digo aberto \xE9 o flex, que continua sendo parte padr\xE3o dos cursos de compiladores e das ferramentas de linguagens em produ\xE7\xE3o onde lexers escritos \xE0 m\xE3o n\xE3o s\xE3o necess\xE1rios."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/ligo.ts
 var ligo_exports = {};
 __export(ligo_exports, {
@@ -8024,6 +8276,64 @@ var init_ligo = __esm({
   }
 });
 
+// src/languages/linkerscript.ts
+var linkerscript_exports = {};
+__export(linkerscript_exports, {
+  linkerscript: () => linkerscript
+});
+var linkerscript;
+var init_linkerscript = __esm({
+  "src/languages/linkerscript.ts"() {
+    linkerscript = {
+      slug: "linkerscript",
+      publishedDate: "1988-01-01",
+      extensions: [".ld", ".lds", ".x"],
+      author: "GNU Project",
+      website: "https://sourceware.org/binutils/docs/ld/Scripts.html",
+      paradigms: ["configuration", "systems"],
+      tooling: {
+        runtimes: ["GNU ld", "LLD"],
+        ecosystems: ["Embedded systems", "Operating systems"]
+      },
+      version: "stable",
+      logo: "https://cdn.simpleicons.org/gnu/A42E2B",
+      color: "#475569",
+      i18n: {
+        en: {
+          name: "Linker Script",
+          description: "A script language for controlling memory layout and section placement during linking.",
+          longDescription: "Linker scripts describe how object files are combined into an executable or image. They define memory regions, output sections, symbol assignments, entry points, and placement rules used by linkers.\n\nThey are especially important in embedded systems, kernels, bootloaders, firmware, and bare-metal programs where exact addresses and memory maps matter. Linker scripts connect compiler output to hardware and runtime constraints."
+        },
+        es: {
+          name: "Linker Script",
+          description: "Lenguaje de scripts para controlar layout de memoria y secciones durante el enlazado.",
+          longDescription: "Los linker scripts describen como se combinan archivos objeto en un ejecutable o imagen. Definen regiones de memoria, secciones de salida, asignaciones de simbolos, puntos de entrada y reglas de ubicacion usadas por enlazadores.\n\nSon especialmente importantes en sistemas embebidos, kernels, bootloaders, firmware y programas bare-metal donde importan direcciones exactas y mapas de memoria. Los linker scripts conectan la salida del compilador con hardware y restricciones de runtime."
+        },
+        it: {
+          name: "Linker Script",
+          description: "Linguaggio di script per controllare layout memoria e sezioni durante il linking.",
+          longDescription: "I linker script descrivono come i file oggetto vengono combinati in un eseguibile o immagine. Definiscono regioni di memoria, sezioni di output, assegnazioni di simboli, entry point e regole di posizionamento usate dai linker.\n\nSono particolarmente importanti in sistemi embedded, kernel, bootloader, firmware e programmi bare-metal dove contano indirizzi esatti e mappe di memoria. I linker script collegano l output del compilatore a vincoli hardware e runtime."
+        },
+        fr: {
+          name: "Linker Script",
+          description: "Langage de script pour controler layout memoire et placement de sections au link.",
+          longDescription: "Les linker scripts decrivent comment des fichiers objet sont combines en executable ou image. Ils definissent regions memoire, sections de sortie, affectations de symboles, points d entree et regles de placement utilisees par les linkers.\n\nIls sont particulierement importants dans les systemes embarques, noyaux, bootloaders, firmwares et programmes bare-metal ou adresses exactes et cartes memoire comptent. Les linker scripts relient la sortie du compilateur aux contraintes materiel et runtime."
+        },
+        de: {
+          name: "Linker Script",
+          description: "Skriptsprache zur Steuerung von Speicherlayout und Section-Platzierung beim Linken.",
+          longDescription: "Linker-Skripte beschreiben, wie Objektdateien zu einer ausfuhrbaren Datei oder einem Image kombiniert werden. Sie definieren Speicherbereiche, Ausgabesections, Symbolzuweisungen, Einstiegspunkte und Platzierungsregeln fur Linker.\n\nSie sind besonders wichtig in Embedded-Systemen, Kerneln, Bootloadern, Firmware und Bare-Metal-Programmen, wo genaue Adressen und Speicherkarten zahlen. Linker-Skripte verbinden Compiler-Ausgabe mit Hardware- und Laufzeitgrenzen."
+        },
+        pt: {
+          name: "Linker Script",
+          description: "Linguagem de script para controlar layout de memoria e secoes durante linkagem.",
+          longDescription: "Linker scripts descrevem como arquivos objeto sao combinados em um executavel ou imagem. Eles definem regioes de memoria, secoes de saida, atribuicoes de simbolos, pontos de entrada e regras de posicionamento usadas por linkers.\n\nSao especialmente importantes em sistemas embarcados, kernels, bootloaders, firmware e programas bare-metal, onde enderecos exatos e mapas de memoria importam. Linker scripts conectam a saida do compilador a restricoes de hardware e runtime."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/liquid.ts
 var liquid_exports = {};
 __export(liquid_exports, {
@@ -8083,64 +8393,6 @@ var init_liquid = __esm({
   }
 });
 
-// src/languages/linkerscript.ts
-var linkerscript_exports = {};
-__export(linkerscript_exports, {
-  linkerscript: () => linkerscript
-});
-var linkerscript;
-var init_linkerscript = __esm({
-  "src/languages/linkerscript.ts"() {
-    linkerscript = {
-      slug: "linkerscript",
-      publishedDate: "1988-01-01",
-      extensions: [".ld", ".lds", ".x"],
-      author: "GNU Project",
-      website: "https://sourceware.org/binutils/docs/ld/Scripts.html",
-      paradigms: ["configuration", "systems"],
-      tooling: {
-        runtimes: ["GNU ld", "LLD"],
-        ecosystems: ["Embedded systems", "Operating systems"]
-      },
-      version: "stable",
-      logo: "https://dummyimage.com/32x32/475569/ffffff.png&text=LD",
-      color: "#475569",
-      i18n: {
-        en: {
-          name: "Linker Script",
-          description: "A script language for controlling memory layout and section placement during linking.",
-          longDescription: "Linker scripts describe how object files are combined into an executable or image. They define memory regions, output sections, symbol assignments, entry points, and placement rules used by linkers.\n\nThey are especially important in embedded systems, kernels, bootloaders, firmware, and bare-metal programs where exact addresses and memory maps matter. Linker scripts connect compiler output to hardware and runtime constraints."
-        },
-        es: {
-          name: "Linker Script",
-          description: "Lenguaje de scripts para controlar layout de memoria y secciones durante el enlazado.",
-          longDescription: "Los linker scripts describen como se combinan archivos objeto en un ejecutable o imagen. Definen regiones de memoria, secciones de salida, asignaciones de simbolos, puntos de entrada y reglas de ubicacion usadas por enlazadores.\n\nSon especialmente importantes en sistemas embebidos, kernels, bootloaders, firmware y programas bare-metal donde importan direcciones exactas y mapas de memoria. Los linker scripts conectan la salida del compilador con hardware y restricciones de runtime."
-        },
-        it: {
-          name: "Linker Script",
-          description: "Linguaggio di script per controllare layout memoria e sezioni durante il linking.",
-          longDescription: "I linker script descrivono come i file oggetto vengono combinati in un eseguibile o immagine. Definiscono regioni di memoria, sezioni di output, assegnazioni di simboli, entry point e regole di posizionamento usate dai linker.\n\nSono particolarmente importanti in sistemi embedded, kernel, bootloader, firmware e programmi bare-metal dove contano indirizzi esatti e mappe di memoria. I linker script collegano l output del compilatore a vincoli hardware e runtime."
-        },
-        fr: {
-          name: "Linker Script",
-          description: "Langage de script pour controler layout memoire et placement de sections au link.",
-          longDescription: "Les linker scripts decrivent comment des fichiers objet sont combines en executable ou image. Ils definissent regions memoire, sections de sortie, affectations de symboles, points d entree et regles de placement utilisees par les linkers.\n\nIls sont particulierement importants dans les systemes embarques, noyaux, bootloaders, firmwares et programmes bare-metal ou adresses exactes et cartes memoire comptent. Les linker scripts relient la sortie du compilateur aux contraintes materiel et runtime."
-        },
-        de: {
-          name: "Linker Script",
-          description: "Skriptsprache zur Steuerung von Speicherlayout und Section-Platzierung beim Linken.",
-          longDescription: "Linker-Skripte beschreiben, wie Objektdateien zu einer ausfuhrbaren Datei oder einem Image kombiniert werden. Sie definieren Speicherbereiche, Ausgabesections, Symbolzuweisungen, Einstiegspunkte und Platzierungsregeln fur Linker.\n\nSie sind besonders wichtig in Embedded-Systemen, Kerneln, Bootloadern, Firmware und Bare-Metal-Programmen, wo genaue Adressen und Speicherkarten zahlen. Linker-Skripte verbinden Compiler-Ausgabe mit Hardware- und Laufzeitgrenzen."
-        },
-        pt: {
-          name: "Linker Script",
-          description: "Linguagem de script para controlar layout de memoria e secoes durante linkagem.",
-          longDescription: "Linker scripts descrevem como arquivos objeto sao combinados em um executavel ou imagem. Eles definem regioes de memoria, secoes de saida, atribuicoes de simbolos, pontos de entrada e regras de posicionamento usadas por linkers.\n\nSao especialmente importantes em sistemas embarcados, kernels, bootloaders, firmware e programas bare-metal, onde enderecos exatos e mapas de memoria importam. Linker scripts conectam a saida do compilador a restricoes de hardware e runtime."
-        }
-      }
-    };
-  }
-});
-
 // src/languages/lisp.ts
 var lisp_exports = {};
 __export(lisp_exports, {
@@ -8279,7 +8531,7 @@ var init_lobster = __esm({
         ecosystems: ["Games", "Interactive Graphics", "Language Experiments"]
       },
       version: "development snapshot",
-      logo: "https://dummyimage.com/32x32/DC2626/ffffff.png&text=Lo",
+      logo: "https://raw.githubusercontent.com/aardappel/lobster/master/docs/lobster.png",
       color: "#DC2626",
       i18n: {
         en: {
@@ -8620,6 +8872,7 @@ var init_markdown = __esm({
   "src/languages/markdown.ts"() {
     markdown = {
       slug: "markdown",
+      aliases: ["md"],
       publishedDate: "2004-03-19",
       extensions: [".md", ".markdown", ".mdown", ".mkd"],
       author: "John Gruber / Aaron Swartz",
@@ -8932,24 +9185,83 @@ var init_mdx = __esm({
           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."
         },
         it: {
-          name: "MDX",
-          description: "Un formato basato su Markdown che incorpora componenti JSX nei documenti di contenuto.",
-          longDescription: "MDX combina la prosa Markdown con le espressioni e i componenti JSX, consentendo ai documenti di includere esempi interattivi, importazioni, esportazioni e layout guidati dai componenti. Viene comunemente compilato in JavaScript per pipeline di rendering basate su React.\n\nViene utilizzato in siti di documentazione, sistemi di design, blog, tutorial, demo di componenti, piattaforme di contenuti e generatori di siti statici che necessitano di prosa e componenti UI nello stesso file sorgente."
+          name: "MDX",
+          description: "Un formato basato su Markdown che incorpora componenti JSX nei documenti di contenuto.",
+          longDescription: "MDX combina la prosa Markdown con le espressioni e i componenti JSX, consentendo ai documenti di includere esempi interattivi, importazioni, esportazioni e layout guidati dai componenti. Viene comunemente compilato in JavaScript per pipeline di rendering basate su React.\n\nViene utilizzato in siti di documentazione, sistemi di design, blog, tutorial, demo di componenti, piattaforme di contenuti e generatori di siti statici che necessitano di prosa e componenti UI nello stesso file sorgente."
+        },
+        fr: {
+          name: "MDX",
+          description: "Un format base sur Markdown qui integre des composants JSX dans les documents de contenu.",
+          longDescription: "MDX combine la prose Markdown avec des expressions et des composants JSX, permettant aux documents d'inclure des exemples interactifs, des importations, des exportations et des mises en page basees sur des composants. Il est couramment compile en JavaScript pour les pipelines de rendu bases sur React.\n\nIl est utilise dans les sites de documentation, les systemes de conception, les blogs, les tutoriels, les demos de composants, les plateformes de contenu et les generateurs de sites statiques qui ont besoin de prose et de composants d'interface utilisateur dans le meme fichier source."
+        },
+        de: {
+          name: "MDX",
+          description: "Ein Markdown-basierter Format, das JSX-Komponenten in Inhaltsdokumenten einbettet.",
+          longDescription: "MDX kombiniert Markdown-Text mit JSX-Ausdr\xFCcken und -Komponenten, sodass Dokumente interaktive Beispiele, Importe, Exporte und komponentengesteuerte Layouts enthalten k\xF6nnen. Es wird \xFCblicherweise in JavaScript kompiliert f\xFCr React-basierte Rendering-Pipelines.\n\nEs wird in Dokumentationsseiten, Designsystemen, Blogs, Tutorials, Komponenten-Demos, Content-Plattformen und statischen Site-Generatoren verwendet, die sowohl Text als auch UI-Komponenten in derselben Quelldatei ben\xF6tigen."
+        },
+        pt: {
+          name: "MDX",
+          description: "Formato baseado em Markdown que incorpora componentes JSX em documentos de conte\xFAdo.",
+          longDescription: "O MDX combina a escrita em Markdown com express\xF5es e componentes JSX, permitindo que os documentos incluam exemplos interativos, importa\xE7\xF5es, exporta\xE7\xF5es e layouts orientados a componentes. \xC9 comumente compilado para JavaScript para pipelines de renderiza\xE7\xE3o baseadas em React.\n\n\xC9 usado em sites de documenta\xE7\xE3o, sistemas de design, blogs, tutoriais, demonstra\xE7\xF5es de componentes, plataformas de conte\xFAdo e geradores de sites est\xE1ticos que precisam de texto e componentes de interface no mesmo arquivo."
+        }
+      }
+    };
+  }
+});
+
+// src/languages/mercury.ts
+var mercury_exports = {};
+__export(mercury_exports, {
+  mercury: () => mercury
+});
+var mercury;
+var init_mercury = __esm({
+  "src/languages/mercury.ts"() {
+    mercury = {
+      slug: "mercury",
+      publishedDate: "1995-04-08",
+      extensions: [".m"],
+      author: "University of Melbourne",
+      website: "https://www.mercurylang.org",
+      paradigms: ["logic", "functional", "declarative"],
+      tooling: {
+        runtimes: ["Melbourne Mercury Compiler"],
+        packageManagers: ["mmc build tooling"],
+        ecosystems: ["Logic Programming", "Declarative Systems", "Academic Computing"]
+      },
+      version: "22.01.8",
+      logo: "https://www.mercurylang.org/favicon.ico",
+      color: "#0891B2",
+      i18n: {
+        en: {
+          name: "Mercury",
+          description: "A pure logic and functional language with strong static typing and determinism analysis.",
+          longDescription: "Mercury is a declarative programming language that combines logic programming with functional programming, strong static typing, modes, and determinism analysis. It aims to make logic programs more reliable and efficient for larger software.\n\nMercury is used in research, compiler work, and specialized systems where Prolog-like relations benefit from compile-time checks, explicit module structure, and predictable execution behavior."
+        },
+        es: {
+          name: "Mercury",
+          description: "Lenguaje logico y funcional puro con tipado estatico fuerte y analisis de determinismo.",
+          longDescription: "Mercury es un lenguaje declarativo que combina programacion logica y funcional con tipado estatico fuerte, modos y analisis de determinismo. Busca que programas de estilo logico sean mas fiables y eficientes en software grande.\n\nSe usa en investigacion, compiladores y sistemas especializados donde relaciones estilo Prolog se benefician de chequeos en compilacion, modulos explicitos y ejecucion predecible."
+        },
+        it: {
+          name: "Mercury",
+          description: "Linguaggio puramente logico e funzionale con forte tipizzazione statica e analisi deterministica.",
+          longDescription: "Mercury \xE8 un linguaggio di programmazione dichiarativo che combina la programmazione logica con quella funzionale, una forte tipizzazione statica, modalit\xE0 ed analisi deterministica. Mira a rendere i programmi logici pi\xF9 affidabili ed efficienti per software di grandi dimensioni.\n\nMercury viene utilizzato nella ricerca, nello sviluppo di compilatori e in sistemi specializzati dove le relazioni simili a Prolog beneficiano di controlli a tempo di compilazione, una struttura modulare esplicita e un comportamento di esecuzione prevedibile."
         },
         fr: {
-          name: "MDX",
-          description: "Un format base sur Markdown qui integre des composants JSX dans les documents de contenu.",
-          longDescription: "MDX combine la prose Markdown avec des expressions et des composants JSX, permettant aux documents d'inclure des exemples interactifs, des importations, des exportations et des mises en page basees sur des composants. Il est couramment compile en JavaScript pour les pipelines de rendu bases sur React.\n\nIl est utilise dans les sites de documentation, les systemes de conception, les blogs, les tutoriels, les demos de composants, les plateformes de contenu et les generateurs de sites statiques qui ont besoin de prose et de composants d'interface utilisateur dans le meme fichier source."
+          name: "Mercury",
+          description: "Langage purement logique et fonctionnel avec typage statique fort et analyse de d\xE9terminisme.",
+          longDescription: "Mercury est un langage de programmation d\xE9claratif qui combine la programmation logique avec la programmation fonctionnelle, le typage statique fort, les modes et l'analyse de d\xE9terminisme. Il vise \xE0 rendre les programmes logiques plus fiables et efficaces pour des logiciels plus importants.\n\nMercury est utilis\xE9 dans la recherche, le d\xE9veloppement de compilateurs et les syst\xE8mes sp\xE9cialis\xE9s o\xF9 les relations semblables \xE0 Prolog b\xE9n\xE9ficient des v\xE9rifications au moment de la compilation, d'une structure modulaire explicite et d'un comportement d'ex\xE9cution pr\xE9visible."
         },
         de: {
-          name: "MDX",
-          description: "Ein Markdown-basierter Format, das JSX-Komponenten in Inhaltsdokumenten einbettet.",
-          longDescription: "MDX kombiniert Markdown-Text mit JSX-Ausdr\xFCcken und -Komponenten, sodass Dokumente interaktive Beispiele, Importe, Exporte und komponentengesteuerte Layouts enthalten k\xF6nnen. Es wird \xFCblicherweise in JavaScript kompiliert f\xFCr React-basierte Rendering-Pipelines.\n\nEs wird in Dokumentationsseiten, Designsystemen, Blogs, Tutorials, Komponenten-Demos, Content-Plattformen und statischen Site-Generatoren verwendet, die sowohl Text als auch UI-Komponenten in derselben Quelldatei ben\xF6tigen."
+          name: "Mercury",
+          description: "Eine reine Logik- und Funktionssprache mit starker statischer Typisierung und deterministischer Analyse.",
+          longDescription: "Mercury ist eine deklarative Programmiersprache, die Logikprogrammierung mit funktionaler Programmierung, starker statischer Typisierung, Modi und deterministischer Analyse kombiniert. Sie zielt darauf ab, Logikprogramme zuverl\xE4ssiger und effizienter f\xFCr gr\xF6\xDFere Software zu machen.\n\nMercury wird in Forschung, Compiler-Entwicklung und spezialisierten Systemen eingesetzt, wo Prolog-\xE4hnliche Beziehungen von Compile-Zeitpr\xFCfungen, einer expliziten Modulstruktur und einem vorhersagbaren Ausf\xFChrungsverhalten profitieren."
         },
         pt: {
-          name: "MDX",
-          description: "Formato baseado em Markdown que incorpora componentes JSX em documentos de conte\xFAdo.",
-          longDescription: "O MDX combina a escrita em Markdown com express\xF5es e componentes JSX, permitindo que os documentos incluam exemplos interativos, importa\xE7\xF5es, exporta\xE7\xF5es e layouts orientados a componentes. \xC9 comumente compilado para JavaScript para pipelines de renderiza\xE7\xE3o baseadas em React.\n\n\xC9 usado em sites de documenta\xE7\xE3o, sistemas de design, blogs, tutoriais, demonstra\xE7\xF5es de componentes, plataformas de conte\xFAdo e geradores de sites est\xE1ticos que precisam de texto e componentes de interface no mesmo arquivo."
+          name: "Mercury",
+          description: "Linguagem pura de l\xF3gica e funcional com tipagem est\xE1tica forte e an\xE1lise determin\xEDstica.",
+          longDescription: "Mercury \xE9 uma linguagem de programa\xE7\xE3o declarativa que combina a programa\xE7\xE3o l\xF3gica com a funcional, tipagem est\xE1tica forte, modos e an\xE1lise determin\xEDstica. Visa tornar os programas l\xF3gicos mais confi\xE1veis e eficientes para softwares maiores.\n\nMercury \xE9 usado em pesquisa, desenvolvimento de compiladores e sistemas especializados onde as rela\xE7\xF5es semelhantes ao Prolog se beneficiam de verifica\xE7\xF5es em tempo de compila\xE7\xE3o, estrutura modular expl\xEDcita e comportamento de execu\xE7\xE3o previs\xEDvel."
         }
       }
     };
@@ -9074,65 +9386,6 @@ var init_meson = __esm({
   }
 });
 
-// src/languages/mercury.ts
-var mercury_exports = {};
-__export(mercury_exports, {
-  mercury: () => mercury
-});
-var mercury;
-var init_mercury = __esm({
-  "src/languages/mercury.ts"() {
-    mercury = {
-      slug: "mercury",
-      publishedDate: "1995-04-08",
-      extensions: [".m"],
-      author: "University of Melbourne",
-      website: "https://www.mercurylang.org",
-      paradigms: ["logic", "functional", "declarative"],
-      tooling: {
-        runtimes: ["Melbourne Mercury Compiler"],
-        packageManagers: ["mmc build tooling"],
-        ecosystems: ["Logic Programming", "Declarative Systems", "Academic Computing"]
-      },
-      version: "22.01.8",
-      logo: "https://www.mercurylang.org/favicon.ico",
-      color: "#0891B2",
-      i18n: {
-        en: {
-          name: "Mercury",
-          description: "A pure logic and functional language with strong static typing and determinism analysis.",
-          longDescription: "Mercury is a declarative programming language that combines logic programming with functional programming, strong static typing, modes, and determinism analysis. It aims to make logic programs more reliable and efficient for larger software.\n\nMercury is used in research, compiler work, and specialized systems where Prolog-like relations benefit from compile-time checks, explicit module structure, and predictable execution behavior."
-        },
-        es: {
-          name: "Mercury",
-          description: "Lenguaje logico y funcional puro con tipado estatico fuerte y analisis de determinismo.",
-          longDescription: "Mercury es un lenguaje declarativo que combina programacion logica y funcional con tipado estatico fuerte, modos y analisis de determinismo. Busca que programas de estilo logico sean mas fiables y eficientes en software grande.\n\nSe usa en investigacion, compiladores y sistemas especializados donde relaciones estilo Prolog se benefician de chequeos en compilacion, modulos explicitos y ejecucion predecible."
-        },
-        it: {
-          name: "Mercury",
-          description: "Linguaggio puramente logico e funzionale con forte tipizzazione statica e analisi deterministica.",
-          longDescription: "Mercury \xE8 un linguaggio di programmazione dichiarativo che combina la programmazione logica con quella funzionale, una forte tipizzazione statica, modalit\xE0 ed analisi deterministica. Mira a rendere i programmi logici pi\xF9 affidabili ed efficienti per software di grandi dimensioni.\n\nMercury viene utilizzato nella ricerca, nello sviluppo di compilatori e in sistemi specializzati dove le relazioni simili a Prolog beneficiano di controlli a tempo di compilazione, una struttura modulare esplicita e un comportamento di esecuzione prevedibile."
-        },
-        fr: {
-          name: "Mercury",
-          description: "Langage purement logique et fonctionnel avec typage statique fort et analyse de d\xE9terminisme.",
-          longDescription: "Mercury est un langage de programmation d\xE9claratif qui combine la programmation logique avec la programmation fonctionnelle, le typage statique fort, les modes et l'analyse de d\xE9terminisme. Il vise \xE0 rendre les programmes logiques plus fiables et efficaces pour des logiciels plus importants.\n\nMercury est utilis\xE9 dans la recherche, le d\xE9veloppement de compilateurs et les syst\xE8mes sp\xE9cialis\xE9s o\xF9 les relations semblables \xE0 Prolog b\xE9n\xE9ficient des v\xE9rifications au moment de la compilation, d'une structure modulaire explicite et d'un comportement d'ex\xE9cution pr\xE9visible."
-        },
-        de: {
-          name: "Mercury",
-          description: "Eine reine Logik- und Funktionssprache mit starker statischer Typisierung und deterministischer Analyse.",
-          longDescription: "Mercury ist eine deklarative Programmiersprache, die Logikprogrammierung mit funktionaler Programmierung, starker statischer Typisierung, Modi und deterministischer Analyse kombiniert. Sie zielt darauf ab, Logikprogramme zuverl\xE4ssiger und effizienter f\xFCr gr\xF6\xDFere Software zu machen.\n\nMercury wird in Forschung, Compiler-Entwicklung und spezialisierten Systemen eingesetzt, wo Prolog-\xE4hnliche Beziehungen von Compile-Zeitpr\xFCfungen, einer expliziten Modulstruktur und einem vorhersagbaren Ausf\xFChrungsverhalten profitieren."
-        },
-        pt: {
-          name: "Mercury",
-          description: "Linguagem pura de l\xF3gica e funcional com tipagem est\xE1tica forte e an\xE1lise determin\xEDstica.",
-          longDescription: "Mercury \xE9 uma linguagem de programa\xE7\xE3o declarativa que combina a programa\xE7\xE3o l\xF3gica com a funcional, tipagem est\xE1tica forte, modos e an\xE1lise determin\xEDstica. Visa tornar os programas l\xF3gicos mais confi\xE1veis e eficientes para softwares maiores.\n\nMercury \xE9 usado em pesquisa, desenvolvimento de compiladores e sistemas especializados onde as rela\xE7\xF5es semelhantes ao Prolog se beneficiam de verifica\xE7\xF5es em tempo de compila\xE7\xE3o, estrutura modular expl\xEDcita e comportamento de execu\xE7\xE3o previs\xEDvel."
-        }
-      }
-    };
-  }
-});
-
 // src/languages/metal.ts
 var metal_exports = {};
 __export(metal_exports, {
@@ -9249,6 +9502,64 @@ var init_modelica = __esm({
   }
 });
 
+// src/languages/modula-2.ts
+var modula_2_exports = {};
+__export(modula_2_exports, {
+  modula2: () => modula2
+});
+var modula2;
+var init_modula_2 = __esm({
+  "src/languages/modula-2.ts"() {
+    modula2 = {
+      slug: "modula-2",
+      publishedDate: "1978-01-01",
+      extensions: [".mod", ".def"],
+      author: "Niklaus Wirth",
+      website: "https://www.modula2.org",
+      paradigms: ["imperative", "procedural", "modular"],
+      tooling: {
+        runtimes: ["GNU Modula-2", "ADW Modula-2", "Classic compilers"],
+        ecosystems: ["Systems Programming", "Education", "Language History"]
+      },
+      version: "ISO/IEC 10514-1:1996",
+      logo: "https://dummyimage.com/32x32/2563EB/ffffff.png&text=M2",
+      color: "#2563EB",
+      i18n: {
+        en: {
+          name: "Modula-2",
+          description: "A modular systems language from Niklaus Wirth with explicit interfaces and modules.",
+          longDescription: "Modula-2 was designed as a successor to Pascal for systems programming and teaching. It emphasizes separate compilation, explicit definition modules, strong typing, coroutines, and structured imperative programming.\n\nThe language influenced later modular languages and remains relevant in compiler history, embedded systems, and educational settings where clear module boundaries and small language design matter."
+        },
+        es: {
+          name: "Modula-2",
+          description: "Lenguaje modular de sistemas de Niklaus Wirth con interfaces y modulos explicitos.",
+          longDescription: "Modula-2 fue disenado como sucesor de Pascal para sistemas y ensenanza. Enfatiza compilacion separada, modulos de definicion explicitos, tipado fuerte, corrutinas y programacion imperativa estructurada.\n\nInfluyo en lenguajes modulares posteriores y sigue siendo relevante en historia de compiladores, sistemas embebidos y contextos educativos."
+        },
+        it: {
+          name: "Modula-2",
+          description: "Linguaggio modulare di Niklaus Wirth con interfacce ed moduli espliciti.",
+          longDescription: "Modula-2 \xE8 stato progettato come successore di Pascal per la programmazione a sistema e l'insegnamento. Enfatizza la compilazione separata, la definizione esplicita dei moduli, il tipaggio forte, le coroutine e la programmazione imperativa strutturata.\n\nIl linguaggio ha influenzato linguaggi modulari successivi ed \xE8 ancora rilevante nella storia dei compilatori, nei sistemi embedded e in ambienti didattici dove i confini del modulo chiari e un design di linguaggio piccolo sono importanti."
+        },
+        fr: {
+          name: "Modula-2",
+          description: "Langage modulaire de Niklaus Wirth avec interfaces et modules explicites.",
+          longDescription: "Modula-2 a \xE9t\xE9 con\xE7u comme successeur de Pascal pour la programmation syst\xE8me et l'enseignement. Il met l'accent sur la compilation s\xE9par\xE9e, les d\xE9finitions explicites des modules, le typage fort, les coroutines et la programmation imp\xE9rative structur\xE9e.\n\nLe langage a influenc\xE9 les langages modulaires ult\xE9rieurs et reste pertinent dans l'histoire des compilateurs, les syst\xE8mes embarqu\xE9s et les environnements \xE9ducatifs o\xF9 les limites de module claires et un petit langage sont importants."
+        },
+        de: {
+          name: "Modula-2",
+          description: "Ein modulare Programmiersprache von Niklaus Wirth mit expliziten Schnittstellen und Modulen.",
+          longDescription: "Modula-2 wurde als Nachfolger von Pascal f\xFCr Systemprogrammierung und Lehre entwickelt. Es betont separate Kompilierbarkeit, explizite Definition von Modulen, starke Typisierung, Koroutinen und strukturierte imperative Programmierung.\n\nDie Sprache beeinflusste sp\xE4tere modulare Sprachen und ist auch heute noch relevant in der Compiler-Geschichte, bei eingebetteten Systemen und im Bildungsbereich, wo klare Modulgrenzen und eine einfache Sprachgestaltung wichtig sind."
+        },
+        pt: {
+          name: "Modula-2",
+          description: "Linguagem de sistemas modular desenvolvida por Niklaus Wirth com interfaces e m\xF3dulos expl\xEDcitos.",
+          longDescription: "Modula-2 foi projetada como sucessora do Pascal para programa\xE7\xE3o de sistemas e ensino. Enfatiza compila\xE7\xE3o separada, defini\xE7\xE3o expl\xEDcita de m\xF3dulos, tipagem forte, corrotinas e programa\xE7\xE3o imperativa estruturada.\n\nA linguagem influenciou linguagens modulares posteriores e permanece relevante na hist\xF3ria dos compiladores, sistemas embarcados e ambientes educacionais onde limites de m\xF3dulo claros e um design de linguagem pequeno s\xE3o importantes."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/mojo.ts
 var mojo_exports = {};
 __export(mojo_exports, {
@@ -9308,64 +9619,6 @@ var init_mojo = __esm({
   }
 });
 
-// src/languages/modula-2.ts
-var modula_2_exports = {};
-__export(modula_2_exports, {
-  modula2: () => modula2
-});
-var modula2;
-var init_modula_2 = __esm({
-  "src/languages/modula-2.ts"() {
-    modula2 = {
-      slug: "modula-2",
-      publishedDate: "1978-01-01",
-      extensions: [".mod", ".def"],
-      author: "Niklaus Wirth",
-      website: "https://www.modula2.org",
-      paradigms: ["imperative", "procedural", "modular"],
-      tooling: {
-        runtimes: ["GNU Modula-2", "ADW Modula-2", "Classic compilers"],
-        ecosystems: ["Systems Programming", "Education", "Language History"]
-      },
-      version: "ISO/IEC 10514-1:1996",
-      logo: "https://dummyimage.com/32x32/2563EB/ffffff.png&text=M2",
-      color: "#2563EB",
-      i18n: {
-        en: {
-          name: "Modula-2",
-          description: "A modular systems language from Niklaus Wirth with explicit interfaces and modules.",
-          longDescription: "Modula-2 was designed as a successor to Pascal for systems programming and teaching. It emphasizes separate compilation, explicit definition modules, strong typing, coroutines, and structured imperative programming.\n\nThe language influenced later modular languages and remains relevant in compiler history, embedded systems, and educational settings where clear module boundaries and small language design matter."
-        },
-        es: {
-          name: "Modula-2",
-          description: "Lenguaje modular de sistemas de Niklaus Wirth con interfaces y modulos explicitos.",
-          longDescription: "Modula-2 fue disenado como sucesor de Pascal para sistemas y ensenanza. Enfatiza compilacion separada, modulos de definicion explicitos, tipado fuerte, corrutinas y programacion imperativa estructurada.\n\nInfluyo en lenguajes modulares posteriores y sigue siendo relevante en historia de compiladores, sistemas embebidos y contextos educativos."
-        },
-        it: {
-          name: "Modula-2",
-          description: "Linguaggio modulare di Niklaus Wirth con interfacce ed moduli espliciti.",
-          longDescription: "Modula-2 \xE8 stato progettato come successore di Pascal per la programmazione a sistema e l'insegnamento. Enfatizza la compilazione separata, la definizione esplicita dei moduli, il tipaggio forte, le coroutine e la programmazione imperativa strutturata.\n\nIl linguaggio ha influenzato linguaggi modulari successivi ed \xE8 ancora rilevante nella storia dei compilatori, nei sistemi embedded e in ambienti didattici dove i confini del modulo chiari e un design di linguaggio piccolo sono importanti."
-        },
-        fr: {
-          name: "Modula-2",
-          description: "Langage modulaire de Niklaus Wirth avec interfaces et modules explicites.",
-          longDescription: "Modula-2 a \xE9t\xE9 con\xE7u comme successeur de Pascal pour la programmation syst\xE8me et l'enseignement. Il met l'accent sur la compilation s\xE9par\xE9e, les d\xE9finitions explicites des modules, le typage fort, les coroutines et la programmation imp\xE9rative structur\xE9e.\n\nLe langage a influenc\xE9 les langages modulaires ult\xE9rieurs et reste pertinent dans l'histoire des compilateurs, les syst\xE8mes embarqu\xE9s et les environnements \xE9ducatifs o\xF9 les limites de module claires et un petit langage sont importants."
-        },
-        de: {
-          name: "Modula-2",
-          description: "Ein modulare Programmiersprache von Niklaus Wirth mit expliziten Schnittstellen und Modulen.",
-          longDescription: "Modula-2 wurde als Nachfolger von Pascal f\xFCr Systemprogrammierung und Lehre entwickelt. Es betont separate Kompilierbarkeit, explizite Definition von Modulen, starke Typisierung, Koroutinen und strukturierte imperative Programmierung.\n\nDie Sprache beeinflusste sp\xE4tere modulare Sprachen und ist auch heute noch relevant in der Compiler-Geschichte, bei eingebetteten Systemen und im Bildungsbereich, wo klare Modulgrenzen und eine einfache Sprachgestaltung wichtig sind."
-        },
-        pt: {
-          name: "Modula-2",
-          description: "Linguagem de sistemas modular desenvolvida por Niklaus Wirth com interfaces e m\xF3dulos expl\xEDcitos.",
-          longDescription: "Modula-2 foi projetada como sucessora do Pascal para programa\xE7\xE3o de sistemas e ensino. Enfatiza compila\xE7\xE3o separada, defini\xE7\xE3o expl\xEDcita de m\xF3dulos, tipagem forte, corrotinas e programa\xE7\xE3o imperativa estruturada.\n\nA linguagem influenciou linguagens modulares posteriores e permanece relevante na hist\xF3ria dos compiladores, sistemas embarcados e ambientes educacionais onde limites de m\xF3dulo claros e um design de linguagem pequeno s\xE3o importantes."
-        }
-      }
-    };
-  }
-});
-
 // src/languages/moonbit.ts
 var moonbit_exports = {};
 __export(moonbit_exports, {
@@ -10066,6 +10319,64 @@ var init_nushell = __esm({
   }
 });
 
+// src/languages/oberon.ts
+var oberon_exports = {};
+__export(oberon_exports, {
+  oberon: () => oberon
+});
+var oberon;
+var init_oberon = __esm({
+  "src/languages/oberon.ts"() {
+    oberon = {
+      slug: "oberon",
+      publishedDate: "1987-01-01",
+      extensions: [".ob", ".mod"],
+      author: "Niklaus Wirth",
+      website: "https://people.inf.ethz.ch/wirth/Oberon/",
+      paradigms: ["imperative", "procedural", "modular"],
+      tooling: {
+        runtimes: ["Oberon System", "Oxford Oberon-2 compiler", "Classic compilers"],
+        ecosystems: ["Operating Systems", "Education", "Language Design"]
+      },
+      version: "Oberon-2",
+      logo: "https://dummyimage.com/32x32/0F766E/ffffff.png&text=Ob",
+      color: "#0F766E",
+      i18n: {
+        en: {
+          name: "Oberon",
+          description: "A compact Pascal-family language with modules, type extension, and system roots.",
+          longDescription: "Oberon is a compact language and operating-system project created by Niklaus Wirth and Jurg Gutknecht. The language simplifies Modula-2 while adding type extension and a small, strongly typed module system.\n\nOberon is important in operating-system research, compiler construction, and teaching because it shows how a small language, compiler, and environment can form a coherent software system."
+        },
+        es: {
+          name: "Oberon",
+          description: "Lenguaje compacto de la familia Pascal con modulos, extension de tipos y raices de sistema.",
+          longDescription: "Oberon es un lenguaje y proyecto de sistema operativo creado por Niklaus Wirth y Jurg Gutknecht. Simplifica Modula-2 y agrega extension de tipos junto con un sistema de modulos pequeno y fuertemente tipado.\n\nEs importante en investigacion de sistemas operativos, construccion de compiladores y ensenanza porque muestra como lenguaje, compilador y entorno pueden formar un sistema coherente."
+        },
+        it: {
+          name: "Oberon",
+          description: "Un linguaggio Pascal-family compatto con moduli, estensione dei tipi e radici di sistema.",
+          longDescription: "Oberon \xE8 un linguaggio e progetto per sistemi operativi compatti creato da Niklaus Wirth e Jurg Gutknecht. Il linguaggio semplifica Modula-2 aggiungendo l'estensione dei tipi e un piccolo sistema modulare fortemente tipizzato.\n\nOberon \xE8 importante nella ricerca sui sistemi operativi, nella costruzione di compilatori e nell'insegnamento perch\xE9 dimostra come un piccolo linguaggio, un compilatore ed un ambiente possano formare un sistema software coerente."
+        },
+        fr: {
+          name: "Oberon",
+          description: "Un langage compact de la famille Pascal avec des modules, une extension de types et des racines syst\xE8me.",
+          longDescription: "Oberon est un langage et un projet de syst\xE8me d'exploitation compact cr\xE9\xE9 par Niklaus Wirth et Jurg Gutknecht. Le langage simplifie Modula-2 tout en ajoutant une extension de type et un petit syst\xE8me de modules fortement typ\xE9.\n\nOberon est important dans la recherche sur les syst\xE8mes d'exploitation, la construction de compilateurs et l'enseignement car il montre comment un petit langage, un compilateur et un environnement peuvent former un syst\xE8me logiciel coh\xE9rent."
+        },
+        de: {
+          name: "Oberon",
+          description: "Eine kompakte Pascal-\xE4hnliche Sprache mit Modulen, Typen und Systemwurzeln.",
+          longDescription: "Oberon ist eine kompakte Sprache und ein Betriebssystemprojekt von Niklaus Wirth und Jurg Gutknecht. Die Sprache vereinfacht Modula-2 und f\xFCgt Typerweiterungen sowie ein kleines, stark typisiertes Modulsystem hinzu.\n\nOberon ist wichtig f\xFCr die Forschung im Bereich Betriebssysteme, Compilerbau und Lehre, da es zeigt, wie eine kleine Sprache, ein Compiler und eine Umgebung ein koh\xE4rentes Softwaresystem bilden k\xF6nnen."
+        },
+        pt: {
+          name: "Oberon",
+          description: "Linguagem compacta da fam\xEDlia Pascal com m\xF3dulos, extens\xE3o de tipos e ra\xEDzes do sistema.",
+          longDescription: "Oberon \xE9 uma linguagem e projeto de sistema operacional compacto criado por Niklaus Wirth e Jurg Gutknecht. A linguagem simplifica o Modula-2 adicionando extens\xE3o de tipos e um pequeno sistema modular fortemente tipado.\n\nOberon \xE9 importante em pesquisa de sistemas operacionais, constru\xE7\xE3o de compiladores e ensino porque demonstra como uma pequena linguagem, compilador e ambiente podem formar um sistema de software coerente."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/objective-c.ts
 var objective_c_exports = {};
 __export(objective_c_exports, {
@@ -10076,6 +10387,7 @@ var init_objective_c = __esm({
   "src/languages/objective-c.ts"() {
     objectiveC = {
       slug: "objective-c",
+      aliases: ["objc", "objective c"],
       publishedDate: "1984-01-01",
       extensions: [".m", ".mm"],
       author: "Brad Cox / Tom Love",
@@ -10242,64 +10554,6 @@ var init_octave = __esm({
   }
 });
 
-// src/languages/oberon.ts
-var oberon_exports = {};
-__export(oberon_exports, {
-  oberon: () => oberon
-});
-var oberon;
-var init_oberon = __esm({
-  "src/languages/oberon.ts"() {
-    oberon = {
-      slug: "oberon",
-      publishedDate: "1987-01-01",
-      extensions: [".ob", ".mod"],
-      author: "Niklaus Wirth",
-      website: "https://people.inf.ethz.ch/wirth/Oberon/",
-      paradigms: ["imperative", "procedural", "modular"],
-      tooling: {
-        runtimes: ["Oberon System", "Oxford Oberon-2 compiler", "Classic compilers"],
-        ecosystems: ["Operating Systems", "Education", "Language Design"]
-      },
-      version: "Oberon-2",
-      logo: "https://dummyimage.com/32x32/0F766E/ffffff.png&text=Ob",
-      color: "#0F766E",
-      i18n: {
-        en: {
-          name: "Oberon",
-          description: "A compact Pascal-family language with modules, type extension, and system roots.",
-          longDescription: "Oberon is a compact language and operating-system project created by Niklaus Wirth and Jurg Gutknecht. The language simplifies Modula-2 while adding type extension and a small, strongly typed module system.\n\nOberon is important in operating-system research, compiler construction, and teaching because it shows how a small language, compiler, and environment can form a coherent software system."
-        },
-        es: {
-          name: "Oberon",
-          description: "Lenguaje compacto de la familia Pascal con modulos, extension de tipos y raices de sistema.",
-          longDescription: "Oberon es un lenguaje y proyecto de sistema operativo creado por Niklaus Wirth y Jurg Gutknecht. Simplifica Modula-2 y agrega extension de tipos junto con un sistema de modulos pequeno y fuertemente tipado.\n\nEs importante en investigacion de sistemas operativos, construccion de compiladores y ensenanza porque muestra como lenguaje, compilador y entorno pueden formar un sistema coherente."
-        },
-        it: {
-          name: "Oberon",
-          description: "Un linguaggio Pascal-family compatto con moduli, estensione dei tipi e radici di sistema.",
-          longDescription: "Oberon \xE8 un linguaggio e progetto per sistemi operativi compatti creato da Niklaus Wirth e Jurg Gutknecht. Il linguaggio semplifica Modula-2 aggiungendo l'estensione dei tipi e un piccolo sistema modulare fortemente tipizzato.\n\nOberon \xE8 importante nella ricerca sui sistemi operativi, nella costruzione di compilatori e nell'insegnamento perch\xE9 dimostra come un piccolo linguaggio, un compilatore ed un ambiente possano formare un sistema software coerente."
-        },
-        fr: {
-          name: "Oberon",
-          description: "Un langage compact de la famille Pascal avec des modules, une extension de types et des racines syst\xE8me.",
-          longDescription: "Oberon est un langage et un projet de syst\xE8me d'exploitation compact cr\xE9\xE9 par Niklaus Wirth et Jurg Gutknecht. Le langage simplifie Modula-2 tout en ajoutant une extension de type et un petit syst\xE8me de modules fortement typ\xE9.\n\nOberon est important dans la recherche sur les syst\xE8mes d'exploitation, la construction de compilateurs et l'enseignement car il montre comment un petit langage, un compilateur et un environnement peuvent former un syst\xE8me logiciel coh\xE9rent."
-        },
-        de: {
-          name: "Oberon",
-          description: "Eine kompakte Pascal-\xE4hnliche Sprache mit Modulen, Typen und Systemwurzeln.",
-          longDescription: "Oberon ist eine kompakte Sprache und ein Betriebssystemprojekt von Niklaus Wirth und Jurg Gutknecht. Die Sprache vereinfacht Modula-2 und f\xFCgt Typerweiterungen sowie ein kleines, stark typisiertes Modulsystem hinzu.\n\nOberon ist wichtig f\xFCr die Forschung im Bereich Betriebssysteme, Compilerbau und Lehre, da es zeigt, wie eine kleine Sprache, ein Compiler und eine Umgebung ein koh\xE4rentes Softwaresystem bilden k\xF6nnen."
-        },
-        pt: {
-          name: "Oberon",
-          description: "Linguagem compacta da fam\xEDlia Pascal com m\xF3dulos, extens\xE3o de tipos e ra\xEDzes do sistema.",
-          longDescription: "Oberon \xE9 uma linguagem e projeto de sistema operacional compacto criado por Niklaus Wirth e Jurg Gutknecht. A linguagem simplifica o Modula-2 adicionando extens\xE3o de tipos e um pequeno sistema modular fortemente tipado.\n\nOberon \xE9 importante em pesquisa de sistemas operacionais, constru\xE7\xE3o de compiladores e ensino porque demonstra como uma pequena linguagem, compilador e ambiente podem formar um sistema de software coerente."
-        }
-      }
-    };
-  }
-});
-
 // src/languages/odin.ts
 var odin_exports = {};
 __export(odin_exports, {
@@ -10826,64 +11080,6 @@ var init_pine_script = __esm({
   }
 });
 
-// src/languages/pl-i.ts
-var pl_i_exports = {};
-__export(pl_i_exports, {
-  plI: () => plI
-});
-var plI;
-var init_pl_i = __esm({
-  "src/languages/pl-i.ts"() {
-    plI = {
-      slug: "pl-i",
-      publishedDate: "1964-01-01",
-      extensions: [".pli", ".pl1"],
-      author: "IBM",
-      website: "https://www.ibm.com/products/pli-compiler-aix",
-      paradigms: ["imperative", "procedural", "structured"],
-      tooling: {
-        runtimes: ["IBM Enterprise PL/I", "Open PL/I compilers"],
-        ecosystems: ["Mainframe", "Enterprise", "Scientific Computing"]
-      },
-      version: "Enterprise PL/I 6.2",
-      logo: "https://dummyimage.com/32x32/1F2937/ffffff.png&text=PL1",
-      color: "#1F2937",
-      i18n: {
-        en: {
-          name: "PL/I",
-          description: "An IBM language combining business, scientific, and systems programming features.",
-          longDescription: "PL/I was designed by IBM to cover business data processing, scientific computing, and systems programming in one language. It combines block structure, strong data-description facilities, exceptions, concurrency features, and rich numeric support.\n\nPL/I remains associated with mainframe and enterprise systems, where long-lived applications depend on its data handling, batch processing, and compatibility with IBM tooling."
-        },
-        es: {
-          name: "PL/I",
-          description: "Lenguaje de IBM que combina rasgos de programacion empresarial, cientifica y de sistemas.",
-          longDescription: "PL/I fue disenado por IBM para cubrir procesamiento empresarial, computacion cientifica y programacion de sistemas en un solo lenguaje. Combina estructura de bloques, descripciones de datos, excepciones, concurrencia y soporte numerico amplio.\n\nSigue asociado a mainframes y sistemas empresariales donde aplicaciones de larga vida dependen de su manejo de datos, procesos batch y herramientas IBM."
-        },
-        it: {
-          name: "PL/I",
-          description: "Un linguaggio IBM che combina funzionalit\xE0 per la programmazione aziendale, scientifica e di sistemi.",
-          longDescription: "PL/I \xE8 stato progettato da IBM per coprire l'elaborazione dei dati aziendali, il calcolo scientifico e la programmazione di sistema in un unico linguaggio. Combina struttura a blocchi, potenti funzionalit\xE0 di descrizione dei dati, gestione delle eccezioni, funzionalit\xE0 di concorrenza e supporto numerico ricco.\n\nPL/I rimane associato ai sistemi mainframe ed enterprise, dove le applicazioni a lungo termine dipendono dalla sua capacit\xE0 di gestire i dati, l'elaborazione batch e la compatibilit\xE0 con gli strumenti IBM."
-        },
-        fr: {
-          name: "PL/I",
-          description: "Langage IBM combinant les fonctionnalit\xE9s de programmation m\xE9tier, scientifique et syst\xE8me.",
-          longDescription: "Con\xE7u par IBM, PL/I combine la gestion des donn\xE9es commerciales, le calcul scientifique et la programmation syst\xE8me. Il offre une structure en blocs, des capacit\xE9s de description de donn\xE9es robustes, la gestion des exceptions, des fonctionnalit\xE9s de concurrence et un support num\xE9rique riche.\n\nPL/I reste associ\xE9 aux syst\xE8mes mainframe et d'entreprise, o\xF9 les applications \xE0 long terme d\xE9pendent de ses capacit\xE9s de manipulation des donn\xE9es, de traitement par lots et de sa compatibilit\xE9 avec les outils IBM."
-        },
-        de: {
-          name: "PL/I",
-          description: "Eine von IBM entwickelte Sprache f\xFCr Gesch\xE4ftsanwendungen, wissenschaftliche Berechnungen und Systemprogrammierung.",
-          longDescription: "PL/I wurde von IBM entwickelt, um Gesch\xE4ftsdatenverarbeitung, wissenschaftliches Rechnen und Systemprogrammierung in einer einzigen Sprache zu vereinen. Es kombiniert Blockstruktur, leistungsstarke Datenbeschreibung, Ausnahmen, Nebenl\xE4ufigkeitsfunktionen und umfangreiche numerische Unterst\xFCtzung.\n\nPL/I ist weiterhin mit Mainframe- und Unternehmenssystemen verbunden, wo langlaufende Anwendungen auf seine Datenverarbeitung, Batch-Verarbeitung und Kompatibilit\xE4t mit IBM-Tools angewiesen sind."
-        },
-        pt: {
-          name: "PL/I",
-          description: "Linguagem da IBM que combina recursos de programa\xE7\xE3o empresarial, cient\xEDfica e de sistemas.",
-          longDescription: "O PL/I foi projetado pela IBM para cobrir o processamento de dados empresariais, computa\xE7\xE3o cient\xEDfica e programa\xE7\xE3o de sistemas em uma \xFAnica linguagem. Ele combina estrutura de blocos, fortes recursos de descri\xE7\xE3o de dados, tratamento de exce\xE7\xF5es, recursos de concorr\xEAncia e suporte num\xE9rico rico.\n\nO PL/I permanece associado a sistemas mainframe e corporativos, onde aplica\xE7\xF5es de longa dura\xE7\xE3o dependem do seu processamento de dados, processamento em lote e compatibilidade com as ferramentas IBM."
-        }
-      }
-    };
-  }
-});
-
 // src/languages/pkl.ts
 var pkl_exports = {};
 __export(pkl_exports, {
@@ -10943,6 +11139,64 @@ var init_pkl = __esm({
   }
 });
 
+// src/languages/pl-i.ts
+var pl_i_exports = {};
+__export(pl_i_exports, {
+  plI: () => plI
+});
+var plI;
+var init_pl_i = __esm({
+  "src/languages/pl-i.ts"() {
+    plI = {
+      slug: "pl-i",
+      publishedDate: "1964-01-01",
+      extensions: [".pli", ".pl1"],
+      author: "IBM",
+      website: "https://www.ibm.com/products/pli-compiler-aix",
+      paradigms: ["imperative", "procedural", "structured"],
+      tooling: {
+        runtimes: ["IBM Enterprise PL/I", "Open PL/I compilers"],
+        ecosystems: ["Mainframe", "Enterprise", "Scientific Computing"]
+      },
+      version: "Enterprise PL/I 6.2",
+      logo: "https://upload.wikimedia.org/wikipedia/commons/5/51/IBM_logo.svg",
+      color: "#1F2937",
+      i18n: {
+        en: {
+          name: "PL/I",
+          description: "An IBM language combining business, scientific, and systems programming features.",
+          longDescription: "PL/I was designed by IBM to cover business data processing, scientific computing, and systems programming in one language. It combines block structure, strong data-description facilities, exceptions, concurrency features, and rich numeric support.\n\nPL/I remains associated with mainframe and enterprise systems, where long-lived applications depend on its data handling, batch processing, and compatibility with IBM tooling."
+        },
+        es: {
+          name: "PL/I",
+          description: "Lenguaje de IBM que combina rasgos de programacion empresarial, cientifica y de sistemas.",
+          longDescription: "PL/I fue disenado por IBM para cubrir procesamiento empresarial, computacion cientifica y programacion de sistemas en un solo lenguaje. Combina estructura de bloques, descripciones de datos, excepciones, concurrencia y soporte numerico amplio.\n\nSigue asociado a mainframes y sistemas empresariales donde aplicaciones de larga vida dependen de su manejo de datos, procesos batch y herramientas IBM."
+        },
+        it: {
+          name: "PL/I",
+          description: "Un linguaggio IBM che combina funzionalit\xE0 per la programmazione aziendale, scientifica e di sistemi.",
+          longDescription: "PL/I \xE8 stato progettato da IBM per coprire l'elaborazione dei dati aziendali, il calcolo scientifico e la programmazione di sistema in un unico linguaggio. Combina struttura a blocchi, potenti funzionalit\xE0 di descrizione dei dati, gestione delle eccezioni, funzionalit\xE0 di concorrenza e supporto numerico ricco.\n\nPL/I rimane associato ai sistemi mainframe ed enterprise, dove le applicazioni a lungo termine dipendono dalla sua capacit\xE0 di gestire i dati, l'elaborazione batch e la compatibilit\xE0 con gli strumenti IBM."
+        },
+        fr: {
+          name: "PL/I",
+          description: "Langage IBM combinant les fonctionnalit\xE9s de programmation m\xE9tier, scientifique et syst\xE8me.",
+          longDescription: "Con\xE7u par IBM, PL/I combine la gestion des donn\xE9es commerciales, le calcul scientifique et la programmation syst\xE8me. Il offre une structure en blocs, des capacit\xE9s de description de donn\xE9es robustes, la gestion des exceptions, des fonctionnalit\xE9s de concurrence et un support num\xE9rique riche.\n\nPL/I reste associ\xE9 aux syst\xE8mes mainframe et d'entreprise, o\xF9 les applications \xE0 long terme d\xE9pendent de ses capacit\xE9s de manipulation des donn\xE9es, de traitement par lots et de sa compatibilit\xE9 avec les outils IBM."
+        },
+        de: {
+          name: "PL/I",
+          description: "Eine von IBM entwickelte Sprache f\xFCr Gesch\xE4ftsanwendungen, wissenschaftliche Berechnungen und Systemprogrammierung.",
+          longDescription: "PL/I wurde von IBM entwickelt, um Gesch\xE4ftsdatenverarbeitung, wissenschaftliches Rechnen und Systemprogrammierung in einer einzigen Sprache zu vereinen. Es kombiniert Blockstruktur, leistungsstarke Datenbeschreibung, Ausnahmen, Nebenl\xE4ufigkeitsfunktionen und umfangreiche numerische Unterst\xFCtzung.\n\nPL/I ist weiterhin mit Mainframe- und Unternehmenssystemen verbunden, wo langlaufende Anwendungen auf seine Datenverarbeitung, Batch-Verarbeitung und Kompatibilit\xE4t mit IBM-Tools angewiesen sind."
+        },
+        pt: {
+          name: "PL/I",
+          description: "Linguagem da IBM que combina recursos de programa\xE7\xE3o empresarial, cient\xEDfica e de sistemas.",
+          longDescription: "O PL/I foi projetado pela IBM para cobrir o processamento de dados empresariais, computa\xE7\xE3o cient\xEDfica e programa\xE7\xE3o de sistemas em uma \xFAnica linguagem. Ele combina estrutura de blocos, fortes recursos de descri\xE7\xE3o de dados, tratamento de exce\xE7\xF5es, recursos de concorr\xEAncia e suporte num\xE9rico rico.\n\nO PL/I permanece associado a sistemas mainframe e corporativos, onde aplica\xE7\xF5es de longa dura\xE7\xE3o dependem do seu processamento de dados, processamento em lote e compatibilidade com as ferramentas IBM."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/plantuml.ts
 var plantuml_exports = {};
 __export(plantuml_exports, {
@@ -11254,7 +11508,7 @@ var init_postscript = __esm({
         ecosystems: ["Print", "PDF"]
       },
       version: "PostScript 3",
-      logo: "https://dummyimage.com/32x32/EC1C24/ffffff.png&text=PS",
+      logo: "https://raw.githubusercontent.com/vscode-icons/vscode-icons/master/icons/file_type_postscript.svg",
       color: "#EC1C24",
       i18n: {
         en: {
@@ -11311,7 +11565,7 @@ var init_powerquery = __esm({
         ecosystems: ["Microsoft Power BI", "Excel", "Azure Data Factory", "Microsoft Fabric"]
       },
       version: "Power Query M 2025",
-      logo: "https://dummyimage.com/32x32/F2C811/000000.png&text=PQ",
+      logo: "https://upload.wikimedia.org/wikipedia/commons/c/cf/New_Power_BI_Logo.svg",
       color: "#F2C811",
       i18n: {
         en: {
@@ -11359,6 +11613,7 @@ var init_powershell = __esm({
   "src/languages/powershell.ts"() {
     powershell = {
       slug: "powershell",
+      aliases: ["pwsh"],
       publishedDate: "2006-11-14",
       extensions: [".ps1", ".psm1", ".psd1", ".ps1xml"],
       author: "Microsoft",
@@ -11583,6 +11838,65 @@ var init_promql = __esm({
   }
 });
 
+// src/languages/properties.ts
+var properties_exports = {};
+__export(properties_exports, {
+  properties: () => properties
+});
+var properties;
+var init_properties = __esm({
+  "src/languages/properties.ts"() {
+    properties = {
+      slug: "properties",
+      aliases: ["java properties"],
+      publishedDate: "1996-01-23",
+      extensions: [".properties"],
+      author: "Sun Microsystems",
+      website: "https://docs.oracle.com/javase/8/docs/api/java/util/Properties.html",
+      paradigms: ["declarative", "configuration"],
+      tooling: {
+        runtimes: ["JVM"],
+        ecosystems: ["JVM", "Configuration"]
+      },
+      version: "stable",
+      logo: "https://cdn.simpleicons.org/openjdk/437291",
+      color: "#2A6277",
+      i18n: {
+        en: {
+          name: "Java Properties",
+          description: "A simple key-value configuration format used across the Java ecosystem.",
+          longDescription: "Java Properties files store configuration as key-value pairs in plain text, with support for comments, escaping, and Unicode sequences. The format ships with the JDK through java.util.Properties and dates back to Java 1.0.\n\nIt remains the default configuration format across the JVM ecosystem: Spring application settings, Gradle project configuration, log4j setup, and resource bundles for internationalization all commonly live in .properties files."
+        },
+        es: {
+          name: "Java Properties",
+          description: "Un formato simple de configuraci\xF3n clave-valor usado en todo el ecosistema Java.",
+          longDescription: "Los archivos Java Properties almacenan configuraci\xF3n como pares clave-valor en texto plano, con soporte para comentarios, escapes y secuencias Unicode. El formato viene con el JDK a trav\xE9s de java.util.Properties y se remonta a Java 1.0.\n\nSigue siendo el formato de configuraci\xF3n por defecto en el ecosistema JVM: los ajustes de aplicaciones Spring, la configuraci\xF3n de proyectos Gradle, la configuraci\xF3n de log4j y los resource bundles de internacionalizaci\xF3n suelen vivir en archivos .properties."
+        },
+        it: {
+          name: "Java Properties",
+          description: "Un semplice formato di configurazione chiave-valore usato nell'ecosistema Java.",
+          longDescription: "I file Java Properties memorizzano la configurazione come coppie chiave-valore in testo semplice, con supporto per commenti, escape e sequenze Unicode. Il formato \xE8 incluso nel JDK tramite java.util.Properties e risale a Java 1.0.\n\nRimane il formato di configurazione predefinito nell'ecosistema JVM: le impostazioni delle applicazioni Spring, la configurazione dei progetti Gradle, la configurazione di log4j e i resource bundle per l'internazionalizzazione vivono comunemente in file .properties."
+        },
+        fr: {
+          name: "Java Properties",
+          description: "Un format simple de configuration cl\xE9-valeur utilis\xE9 dans tout l'\xE9cosyst\xE8me Java.",
+          longDescription: "Les fichiers Java Properties stockent la configuration sous forme de paires cl\xE9-valeur en texte brut, avec la prise en charge des commentaires, de l'\xE9chappement et des s\xE9quences Unicode. Le format est livr\xE9 avec le JDK via java.util.Properties et remonte \xE0 Java 1.0.\n\nIl reste le format de configuration par d\xE9faut de l'\xE9cosyst\xE8me JVM : les param\xE8tres d'applications Spring, la configuration de projets Gradle, la configuration de log4j et les resource bundles d'internationalisation vivent couramment dans des fichiers .properties."
+        },
+        de: {
+          name: "Java Properties",
+          description: "Ein einfaches Schl\xFCssel-Wert-Konfigurationsformat aus dem Java-\xD6kosystem.",
+          longDescription: "Java-Properties-Dateien speichern Konfiguration als Schl\xFCssel-Wert-Paare im Klartext, mit Unterst\xFCtzung f\xFCr Kommentare, Escaping und Unicode-Sequenzen. Das Format ist \xFCber java.util.Properties Teil des JDK und stammt aus Java 1.0.\n\nEs bleibt das Standard-Konfigurationsformat im JVM-\xD6kosystem: Spring-Anwendungseinstellungen, Gradle-Projektkonfiguration, log4j-Setup und Resource-Bundles f\xFCr Internationalisierung liegen \xFCblicherweise in .properties-Dateien."
+        },
+        pt: {
+          name: "Java Properties",
+          description: "Um formato simples de configura\xE7\xE3o chave-valor usado em todo o ecossistema Java.",
+          longDescription: "Os arquivos Java Properties armazenam configura\xE7\xE3o como pares chave-valor em texto simples, com suporte a coment\xE1rios, escapes e sequ\xEAncias Unicode. O formato acompanha o JDK por meio de java.util.Properties e remonta ao Java 1.0.\n\nContinua sendo o formato de configura\xE7\xE3o padr\xE3o do ecossistema JVM: as configura\xE7\xF5es de aplica\xE7\xF5es Spring, a configura\xE7\xE3o de projetos Gradle, a configura\xE7\xE3o do log4j e os resource bundles de internacionaliza\xE7\xE3o costumam viver em arquivos .properties."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/protobuf.ts
 var protobuf_exports = {};
 __export(protobuf_exports, {
@@ -11593,6 +11907,7 @@ var init_protobuf = __esm({
   "src/languages/protobuf.ts"() {
     protobuf = {
       slug: "protobuf",
+      aliases: ["proto", "protocol buffers"],
       publishedDate: "2008-07-07",
       extensions: [".proto"],
       author: "Google",
@@ -11829,6 +12144,7 @@ var init_python = __esm({
   "src/languages/python.ts"() {
     python = {
       slug: "python",
+      aliases: ["py"],
       publishedDate: "1991-02-20",
       extensions: [".py", ".pyw"],
       author: "Guido van Rossum",
@@ -11878,6 +12194,64 @@ var init_python = __esm({
   }
 });
 
+// src/languages/qmake.ts
+var qmake_exports = {};
+__export(qmake_exports, {
+  qmake: () => qmake
+});
+var qmake;
+var init_qmake = __esm({
+  "src/languages/qmake.ts"() {
+    qmake = {
+      slug: "qmake",
+      publishedDate: "2002-01-01",
+      extensions: [".pri", ".prf"],
+      author: "Trolltech",
+      website: "https://doc.qt.io/qt-6/qmake-manual.html",
+      paradigms: ["build configuration"],
+      tooling: {
+        runtimes: ["qmake"],
+        ecosystems: ["Qt", "C++"]
+      },
+      version: "stable",
+      logo: "https://d33sqmjvzgs8hq.cloudfront.net/wp-content/themes/oneqt/assets/images/favicon-32x32.png",
+      color: "#41CD52",
+      i18n: {
+        en: {
+          name: "qmake",
+          description: "A Qt build configuration language for generating platform-specific Makefiles and projects.",
+          longDescription: "qmake project files describe Qt and C++ builds with variables, scopes, conditions, templates, sources, headers, resources, and platform-specific settings. qmake reads these files and generates native build files for the target environment.\n\nThe language is strongly associated with Qt applications and libraries, especially older and long-lived projects. It remains useful for maintaining Qt codebases that predate or choose not to migrate to CMake."
+        },
+        es: {
+          name: "qmake",
+          description: "Lenguaje de configuracion de builds Qt para generar Makefiles y proyectos por plataforma.",
+          longDescription: "Los archivos de proyecto qmake describen builds Qt y C++ con variables, scopes, condiciones, templates, fuentes, headers, recursos y ajustes por plataforma. qmake lee estos archivos y genera archivos de build nativos para el entorno destino.\n\nEl lenguaje esta muy asociado a aplicaciones y bibliotecas Qt, sobre todo proyectos antiguos o de larga vida. Sigue siendo util para mantener bases Qt anteriores a CMake o que eligen no migrar."
+        },
+        it: {
+          name: "qmake",
+          description: "Linguaggio di configurazione build Qt per generare Makefile e progetti specifici.",
+          longDescription: "I file progetto qmake descrivono build Qt e C++ con variabili, scope, condizioni, template, sorgenti, header, risorse e impostazioni specifiche di piattaforma. qmake legge questi file e genera file di build nativi per l ambiente target.\n\nIl linguaggio e fortemente associato ad applicazioni e librerie Qt, specialmente progetti vecchi e longevi. Rimane utile per mantenere codebase Qt precedenti a CMake o che scelgono di non migrare."
+        },
+        fr: {
+          name: "qmake",
+          description: "Langage de configuration build Qt pour generer Makefiles et projets par plateforme.",
+          longDescription: "Les fichiers projet qmake decrivent des builds Qt et C++ avec variables, scopes, conditions, templates, sources, headers, ressources et reglages par plateforme. qmake lit ces fichiers et genere des fichiers de build natifs pour l environnement cible.\n\nLe langage est fortement associe aux applications et bibliotheques Qt, surtout les projets anciens ou durables. Il reste utile pour maintenir des bases Qt anterieures a CMake ou qui choisissent de ne pas migrer."
+        },
+        de: {
+          name: "qmake",
+          description: "Qt-Build-Konfigurationssprache zum Erzeugen plattformspezifischer Makefiles und Projekte.",
+          longDescription: "qmake-Projektdateien beschreiben Qt- und C++-Builds mit Variablen, Scopes, Bedingungen, Templates, Quellen, Headern, Ressourcen und plattformspezifischen Einstellungen. qmake liest diese Dateien und erzeugt native Build-Dateien fur die Zielumgebung.\n\nDie Sprache ist eng mit Qt-Anwendungen und Bibliotheken verbunden, besonders mit alteren und langlebigen Projekten. Sie bleibt nutzlich fur Qt-Codebasen, die vor CMake entstanden sind oder nicht migrieren wollen."
+        },
+        pt: {
+          name: "qmake",
+          description: "Linguagem de configuracao de build Qt para gerar Makefiles e projetos por plataforma.",
+          longDescription: "Arquivos de projeto qmake descrevem builds Qt e C++ com variaveis, escopos, condicoes, templates, fontes, headers, recursos e ajustes por plataforma. qmake le esses arquivos e gera arquivos de build nativos para o ambiente alvo.\n\nA linguagem e fortemente associada a aplicativos e bibliotecas Qt, especialmente projetos antigos e duradouros. Continua util para manter bases Qt anteriores ao CMake ou que escolhem nao migrar."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/qml.ts
 var qml_exports = {};
 __export(qml_exports, {
@@ -11937,64 +12311,6 @@ var init_qml = __esm({
   }
 });
 
-// src/languages/qmake.ts
-var qmake_exports = {};
-__export(qmake_exports, {
-  qmake: () => qmake
-});
-var qmake;
-var init_qmake = __esm({
-  "src/languages/qmake.ts"() {
-    qmake = {
-      slug: "qmake",
-      publishedDate: "2002-01-01",
-      extensions: [".pri", ".prf"],
-      author: "Trolltech",
-      website: "https://doc.qt.io/qt-6/qmake-manual.html",
-      paradigms: ["build configuration"],
-      tooling: {
-        runtimes: ["qmake"],
-        ecosystems: ["Qt", "C++"]
-      },
-      version: "stable",
-      logo: "https://d33sqmjvzgs8hq.cloudfront.net/wp-content/themes/oneqt/assets/images/favicon-32x32.png",
-      color: "#41CD52",
-      i18n: {
-        en: {
-          name: "qmake",
-          description: "A Qt build configuration language for generating platform-specific Makefiles and projects.",
-          longDescription: "qmake project files describe Qt and C++ builds with variables, scopes, conditions, templates, sources, headers, resources, and platform-specific settings. qmake reads these files and generates native build files for the target environment.\n\nThe language is strongly associated with Qt applications and libraries, especially older and long-lived projects. It remains useful for maintaining Qt codebases that predate or choose not to migrate to CMake."
-        },
-        es: {
-          name: "qmake",
-          description: "Lenguaje de configuracion de builds Qt para generar Makefiles y proyectos por plataforma.",
-          longDescription: "Los archivos de proyecto qmake describen builds Qt y C++ con variables, scopes, condiciones, templates, fuentes, headers, recursos y ajustes por plataforma. qmake lee estos archivos y genera archivos de build nativos para el entorno destino.\n\nEl lenguaje esta muy asociado a aplicaciones y bibliotecas Qt, sobre todo proyectos antiguos o de larga vida. Sigue siendo util para mantener bases Qt anteriores a CMake o que eligen no migrar."
-        },
-        it: {
-          name: "qmake",
-          description: "Linguaggio di configurazione build Qt per generare Makefile e progetti specifici.",
-          longDescription: "I file progetto qmake descrivono build Qt e C++ con variabili, scope, condizioni, template, sorgenti, header, risorse e impostazioni specifiche di piattaforma. qmake legge questi file e genera file di build nativi per l ambiente target.\n\nIl linguaggio e fortemente associato ad applicazioni e librerie Qt, specialmente progetti vecchi e longevi. Rimane utile per mantenere codebase Qt precedenti a CMake o che scelgono di non migrare."
-        },
-        fr: {
-          name: "qmake",
-          description: "Langage de configuration build Qt pour generer Makefiles et projets par plateforme.",
-          longDescription: "Les fichiers projet qmake decrivent des builds Qt et C++ avec variables, scopes, conditions, templates, sources, headers, ressources et reglages par plateforme. qmake lit ces fichiers et genere des fichiers de build natifs pour l environnement cible.\n\nLe langage est fortement associe aux applications et bibliotheques Qt, surtout les projets anciens ou durables. Il reste utile pour maintenir des bases Qt anterieures a CMake ou qui choisissent de ne pas migrer."
-        },
-        de: {
-          name: "qmake",
-          description: "Qt-Build-Konfigurationssprache zum Erzeugen plattformspezifischer Makefiles und Projekte.",
-          longDescription: "qmake-Projektdateien beschreiben Qt- und C++-Builds mit Variablen, Scopes, Bedingungen, Templates, Quellen, Headern, Ressourcen und plattformspezifischen Einstellungen. qmake liest diese Dateien und erzeugt native Build-Dateien fur die Zielumgebung.\n\nDie Sprache ist eng mit Qt-Anwendungen und Bibliotheken verbunden, besonders mit alteren und langlebigen Projekten. Sie bleibt nutzlich fur Qt-Codebasen, die vor CMake entstanden sind oder nicht migrieren wollen."
-        },
-        pt: {
-          name: "qmake",
-          description: "Linguagem de configuracao de build Qt para gerar Makefiles e projetos por plataforma.",
-          longDescription: "Arquivos de projeto qmake descrevem builds Qt e C++ com variaveis, escopos, condicoes, templates, fontes, headers, recursos e ajustes por plataforma. qmake le esses arquivos e gera arquivos de build nativos para o ambiente alvo.\n\nA linguagem e fortemente associada a aplicativos e bibliotecas Qt, especialmente projetos antigos e duradouros. Continua util para manter bases Qt anteriores ao CMake ou que escolhem nao migrar."
-        }
-      }
-    };
-  }
-});
-
 // src/languages/qsharp.ts
 var qsharp_exports = {};
 __export(qsharp_exports, {
@@ -12182,6 +12498,7 @@ var init_raku = __esm({
   "src/languages/raku.ts"() {
     raku = {
       slug: "raku",
+      aliases: ["perl6", "perl 6"],
       publishedDate: "2015-12-25",
       extensions: [".raku", ".rakumod", ".rakudoc", ".rakutest", ".p6", ".pm6"],
       author: "Raku Community",
@@ -12290,6 +12607,65 @@ var init_razor = __esm({
   }
 });
 
+// src/languages/reasonml.ts
+var reasonml_exports = {};
+__export(reasonml_exports, {
+  reasonml: () => reasonml
+});
+var reasonml;
+var init_reasonml = __esm({
+  "src/languages/reasonml.ts"() {
+    reasonml = {
+      slug: "reasonml",
+      publishedDate: "2016-05-13",
+      extensions: [".re", ".rei"],
+      author: "Jordan Walke / Reason contributors",
+      website: "https://reasonml.github.io",
+      paradigms: ["functional", "statically typed", "multi-paradigm"],
+      tooling: {
+        runtimes: ["OCaml", "JavaScript"],
+        packageManagers: ["opam", "npm"],
+        ecosystems: ["OCaml", "JavaScript", "Web"]
+      },
+      version: "3.13.0",
+      logo: "https://cdn.simpleicons.org/reason/DD4B39",
+      color: "#DD4B39",
+      i18n: {
+        en: {
+          name: "ReasonML",
+          description: "A JavaScript-like syntax for OCaml and typed functional programming.",
+          longDescription: "ReasonML is a syntax layer for OCaml that presents familiar braces and punctuation while retaining OCaml's modules, pattern matching, type inference, and functional foundations. It has been used with native OCaml and JavaScript compilation workflows.\n\nIt is used in OCaml-adjacent projects, typed UI code, libraries, and codebases that prefer Reason syntax over traditional OCaml syntax."
+        },
+        es: {
+          name: "ReasonML",
+          description: "Una sintaxis cercana a JavaScript para OCaml y programacion funcional tipada.",
+          longDescription: "ReasonML es una capa de sintaxis para OCaml que presenta llaves y puntuacion familiares conservando modulos, pattern matching, inferencia de tipos y bases funcionales de OCaml. Se ha usado con flujos nativos y de compilacion a JavaScript.\n\nSe usa en proyectos cercanos a OCaml, UI tipada, bibliotecas y codebases que prefieren la sintaxis Reason frente a la sintaxis tradicional de OCaml."
+        },
+        it: {
+          name: "ReasonML",
+          description: "Una sintassi simile a JavaScript per OCaml e la programmazione funzionale tipata.",
+          longDescription: "ReasonML e un livello di sintassi per OCaml che presenta parentesi e punteggiatura familiari, mantenendo al contempo i moduli, il pattern matching, l'inferenza dei tipi e le fondamenta funzionali di OCaml. E stato utilizzato con OCaml nativo e flussi di lavoro di compilazione in JavaScript.\n\nE utilizzato in progetti adiacenti a OCaml, codice UI tipato, librerie e codebase che preferiscono la sintassi Reason rispetto alla sintassi OCaml tradizionale."
+        },
+        fr: {
+          name: "ReasonML",
+          description: "Une syntaxe semblable a JavaScript pour OCaml et la programmation fonctionnelle typee.",
+          longDescription: "ReasonML est une couche de syntaxe pour OCaml qui presente des accolades et une ponctuation familieres tout en conservant les modules, la correspondance de motifs, l'inference de type et les fondements fonctionnels d'OCaml. Il a ete utilise avec OCaml natif et des flux de travail de compilation vers JavaScript.\n\nIl est utilise dans des projets lies a OCaml, du code d'interface utilisateur type, des bibliotheques et des bases de code qui preferent la syntaxe Reason a la syntaxe OCaml traditionnelle."
+        },
+        de: {
+          name: "ReasonML",
+          description: "Eine JavaScript-\xE4hnliche Syntax f\xFCr OCaml und typisierte funktionale Programmierung.",
+          longDescription: "ReasonML ist eine Syntaxebene f\xFCr OCaml, die vertraute Klammern und Satzzeichen verwendet, w\xE4hrend sie die Module, das Pattern Matching, die Typinferenz und die funktionalen Grundlagen von OCaml beibeh\xE4lt. Es wurde mit nativem OCaml und JavaScript-Kompilierungsabl\xE4ufen verwendet.\n\nEs wird in OCaml-nahen Projekten, typisierten UI-Code, Bibliotheken und Codebasen verwendet, die den Reason-Syntax gegen\xFCber der traditionellen OCaml-Syntax bevorzugen."
+        },
+        pt: {
+          name: "ReasonML",
+          description: "Uma sintaxe semelhante a JavaScript para OCaml e programa\xE7\xE3o funcional com tipagem.",
+          longDescription: "ReasonML \xE9 uma camada de sintaxe para OCaml que apresenta as familiaridades de chaves e pontua\xE7\xE3o, mantendo os m\xF3dulos, correspond\xEAncia de padr\xF5es, infer\xEAncia de tipo e fundamentos funcionais do OCaml. \xC9 usado com OCaml nativo e fluxos de trabalho de compila\xE7\xE3o para JavaScript.\n\n\xC9 usado em projetos relacionados ao OCaml, c\xF3digo de interface de usu\xE1rio com tipagem, bibliotecas e bases de c\xF3digo que preferem a sintaxe Reason em vez da sintaxe OCaml tradicional."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/rebol.ts
 var rebol_exports = {};
 __export(rebol_exports, {
@@ -12406,65 +12782,6 @@ var init_red = __esm({
   }
 });
 
-// src/languages/reasonml.ts
-var reasonml_exports = {};
-__export(reasonml_exports, {
-  reasonml: () => reasonml
-});
-var reasonml;
-var init_reasonml = __esm({
-  "src/languages/reasonml.ts"() {
-    reasonml = {
-      slug: "reasonml",
-      publishedDate: "2016-05-13",
-      extensions: [".re", ".rei"],
-      author: "Jordan Walke / Reason contributors",
-      website: "https://reasonml.github.io",
-      paradigms: ["functional", "statically typed", "multi-paradigm"],
-      tooling: {
-        runtimes: ["OCaml", "JavaScript"],
-        packageManagers: ["opam", "npm"],
-        ecosystems: ["OCaml", "JavaScript", "Web"]
-      },
-      version: "3.13.0",
-      logo: "https://cdn.simpleicons.org/reason/DD4B39",
-      color: "#DD4B39",
-      i18n: {
-        en: {
-          name: "ReasonML",
-          description: "A JavaScript-like syntax for OCaml and typed functional programming.",
-          longDescription: "ReasonML is a syntax layer for OCaml that presents familiar braces and punctuation while retaining OCaml's modules, pattern matching, type inference, and functional foundations. It has been used with native OCaml and JavaScript compilation workflows.\n\nIt is used in OCaml-adjacent projects, typed UI code, libraries, and codebases that prefer Reason syntax over traditional OCaml syntax."
-        },
-        es: {
-          name: "ReasonML",
-          description: "Una sintaxis cercana a JavaScript para OCaml y programacion funcional tipada.",
-          longDescription: "ReasonML es una capa de sintaxis para OCaml que presenta llaves y puntuacion familiares conservando modulos, pattern matching, inferencia de tipos y bases funcionales de OCaml. Se ha usado con flujos nativos y de compilacion a JavaScript.\n\nSe usa en proyectos cercanos a OCaml, UI tipada, bibliotecas y codebases que prefieren la sintaxis Reason frente a la sintaxis tradicional de OCaml."
-        },
-        it: {
-          name: "ReasonML",
-          description: "Una sintassi simile a JavaScript per OCaml e la programmazione funzionale tipata.",
-          longDescription: "ReasonML e un livello di sintassi per OCaml che presenta parentesi e punteggiatura familiari, mantenendo al contempo i moduli, il pattern matching, l'inferenza dei tipi e le fondamenta funzionali di OCaml. E stato utilizzato con OCaml nativo e flussi di lavoro di compilazione in JavaScript.\n\nE utilizzato in progetti adiacenti a OCaml, codice UI tipato, librerie e codebase che preferiscono la sintassi Reason rispetto alla sintassi OCaml tradizionale."
-        },
-        fr: {
-          name: "ReasonML",
-          description: "Une syntaxe semblable a JavaScript pour OCaml et la programmation fonctionnelle typee.",
-          longDescription: "ReasonML est une couche de syntaxe pour OCaml qui presente des accolades et une ponctuation familieres tout en conservant les modules, la correspondance de motifs, l'inference de type et les fondements fonctionnels d'OCaml. Il a ete utilise avec OCaml natif et des flux de travail de compilation vers JavaScript.\n\nIl est utilise dans des projets lies a OCaml, du code d'interface utilisateur type, des bibliotheques et des bases de code qui preferent la syntaxe Reason a la syntaxe OCaml traditionnelle."
-        },
-        de: {
-          name: "ReasonML",
-          description: "Eine JavaScript-\xE4hnliche Syntax f\xFCr OCaml und typisierte funktionale Programmierung.",
-          longDescription: "ReasonML ist eine Syntaxebene f\xFCr OCaml, die vertraute Klammern und Satzzeichen verwendet, w\xE4hrend sie die Module, das Pattern Matching, die Typinferenz und die funktionalen Grundlagen von OCaml beibeh\xE4lt. Es wurde mit nativem OCaml und JavaScript-Kompilierungsabl\xE4ufen verwendet.\n\nEs wird in OCaml-nahen Projekten, typisierten UI-Code, Bibliotheken und Codebasen verwendet, die den Reason-Syntax gegen\xFCber der traditionellen OCaml-Syntax bevorzugen."
-        },
-        pt: {
-          name: "ReasonML",
-          description: "Uma sintaxe semelhante a JavaScript para OCaml e programa\xE7\xE3o funcional com tipagem.",
-          longDescription: "ReasonML \xE9 uma camada de sintaxe para OCaml que apresenta as familiaridades de chaves e pontua\xE7\xE3o, mantendo os m\xF3dulos, correspond\xEAncia de padr\xF5es, infer\xEAncia de tipo e fundamentos funcionais do OCaml. \xC9 usado com OCaml nativo e fluxos de trabalho de compila\xE7\xE3o para JavaScript.\n\n\xC9 usado em projetos relacionados ao OCaml, c\xF3digo de interface de usu\xE1rio com tipagem, bibliotecas e bases de c\xF3digo que preferem a sintaxe Reason em vez da sintaxe OCaml tradicional."
-        }
-      }
-    };
-  }
-});
-
 // src/languages/rego.ts
 var rego_exports = {};
 __export(rego_exports, {
@@ -12593,6 +12910,7 @@ var init_restructuredtext = __esm({
   "src/languages/restructuredtext.ts"() {
     restructuredtext = {
       slug: "restructuredtext",
+      aliases: ["rst"],
       publishedDate: "2001-06-01",
       extensions: [".rst", ".rest"],
       author: "David Goodger / Docutils contributors",
@@ -12642,6 +12960,64 @@ var init_restructuredtext = __esm({
   }
 });
 
+// src/languages/rexx.ts
+var rexx_exports = {};
+__export(rexx_exports, {
+  rexx: () => rexx
+});
+var rexx;
+var init_rexx = __esm({
+  "src/languages/rexx.ts"() {
+    rexx = {
+      slug: "rexx",
+      publishedDate: "1979-03-20",
+      extensions: [".rexx", ".rex"],
+      author: "Mike Cowlishaw / IBM",
+      website: "https://www.rexxla.org",
+      paradigms: ["imperative", "procedural", "scripting"],
+      tooling: {
+        runtimes: ["z/OS", "ooRexx", "Regina REXX"],
+        ecosystems: ["Mainframe", "Scripting"]
+      },
+      version: "ANSI X3.274-1996",
+      logo: "https://raw.githubusercontent.com/vscode-icons/vscode-icons/master/icons/file_type_rexx.svg",
+      color: "#D90E09",
+      i18n: {
+        en: {
+          name: "REXX",
+          description: "A readable IBM scripting language for mainframe automation and system glue.",
+          longDescription: "REXX (Restructured Extended Executor) is a scripting language designed by Mike Cowlishaw at IBM with an emphasis on readability and ease of learning. It became the standard automation language on IBM mainframes, driving TSO/ISPF, batch jobs, and system utilities on z/OS.\n\nBeyond the mainframe, Open Object Rexx (ooRexx) and Regina bring the language to Linux, Windows, and macOS, and REXX remains in active production use wherever decades of mainframe automation live on."
+        },
+        es: {
+          name: "REXX",
+          description: "Un lenguaje de scripting legible de IBM para automatizaci\xF3n de mainframes.",
+          longDescription: "REXX (Restructured Extended Executor) es un lenguaje de scripting dise\xF1ado por Mike Cowlishaw en IBM con \xE9nfasis en la legibilidad y la facilidad de aprendizaje. Se convirti\xF3 en el lenguaje de automatizaci\xF3n est\xE1ndar de los mainframes de IBM, controlando TSO/ISPF, trabajos batch y utilidades del sistema en z/OS.\n\nM\xE1s all\xE1 del mainframe, Open Object Rexx (ooRexx) y Regina llevan el lenguaje a Linux, Windows y macOS, y REXX sigue en uso productivo activo dondequiera que perduren d\xE9cadas de automatizaci\xF3n de mainframe."
+        },
+        it: {
+          name: "REXX",
+          description: "Un linguaggio di scripting IBM leggibile per l'automazione dei mainframe.",
+          longDescription: "REXX (Restructured Extended Executor) \xE8 un linguaggio di scripting progettato da Mike Cowlishaw in IBM con enfasi sulla leggibilit\xE0 e sulla facilit\xE0 di apprendimento. \xC8 diventato il linguaggio di automazione standard sui mainframe IBM, guidando TSO/ISPF, job batch e utility di sistema su z/OS.\n\nOltre il mainframe, Open Object Rexx (ooRexx) e Regina portano il linguaggio su Linux, Windows e macOS, e REXX rimane in uso produttivo attivo ovunque sopravvivano decenni di automazione mainframe."
+        },
+        fr: {
+          name: "REXX",
+          description: "Un langage de script IBM lisible pour l'automatisation des mainframes.",
+          longDescription: "REXX (Restructured Extended Executor) est un langage de script con\xE7u par Mike Cowlishaw chez IBM avec un accent sur la lisibilit\xE9 et la facilit\xE9 d'apprentissage. Il est devenu le langage d'automatisation standard des mainframes IBM, pilotant TSO/ISPF, les travaux batch et les utilitaires syst\xE8me sous z/OS.\n\nAu-del\xE0 du mainframe, Open Object Rexx (ooRexx) et Regina portent le langage sur Linux, Windows et macOS, et REXX reste en usage productif actif partout o\xF9 survivent des d\xE9cennies d'automatisation mainframe."
+        },
+        de: {
+          name: "REXX",
+          description: "Eine gut lesbare IBM-Skriptsprache f\xFCr Mainframe-Automatisierung.",
+          longDescription: "REXX (Restructured Extended Executor) ist eine von Mike Cowlishaw bei IBM entworfene Skriptsprache mit Schwerpunkt auf Lesbarkeit und leichter Erlernbarkeit. Sie wurde zur Standard-Automatisierungssprache auf IBM-Mainframes und steuert TSO/ISPF, Batch-Jobs und Systemwerkzeuge unter z/OS.\n\nJenseits des Mainframes bringen Open Object Rexx (ooRexx) und Regina die Sprache auf Linux, Windows und macOS, und REXX bleibt \xFCberall dort im produktiven Einsatz, wo Jahrzehnte an Mainframe-Automatisierung weiterleben."
+        },
+        pt: {
+          name: "REXX",
+          description: "Uma linguagem de script leg\xEDvel da IBM para automa\xE7\xE3o de mainframes.",
+          longDescription: "REXX (Restructured Extended Executor) \xE9 uma linguagem de script projetada por Mike Cowlishaw na IBM com \xEAnfase em legibilidade e facilidade de aprendizado. Tornou-se a linguagem de automa\xE7\xE3o padr\xE3o nos mainframes da IBM, controlando TSO/ISPF, jobs batch e utilit\xE1rios de sistema no z/OS.\n\nAl\xE9m do mainframe, o Open Object Rexx (ooRexx) e o Regina levam a linguagem para Linux, Windows e macOS, e o REXX continua em uso produtivo ativo onde quer que d\xE9cadas de automa\xE7\xE3o de mainframe sobrevivam."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/roc.ts
 var roc_exports = {};
 __export(roc_exports, {
@@ -12768,6 +13144,7 @@ var init_ruby = __esm({
   "src/languages/ruby.ts"() {
     ruby = {
       slug: "ruby",
+      aliases: ["rb"],
       publishedDate: "1995-12-21",
       extensions: [".rb", ".rbw", ".rake", ".gemspec", "Gemfile", "Rakefile", "config.ru"],
       author: "Yukihiro Matsumoto",
@@ -13178,6 +13555,7 @@ var init_simula = __esm({
   "src/languages/simula.ts"() {
     simula = {
       slug: "simula",
+      status: "historical",
       publishedDate: "1962-01-01",
       extensions: [".sim", ".simula"],
       author: "Ole-Johan Dahl and Kristen Nygaard",
@@ -13411,6 +13789,7 @@ var init_snobol = __esm({
   "src/languages/snobol.ts"() {
     snobol = {
       slug: "snobol",
+      status: "historical",
       publishedDate: "1962-01-01",
       extensions: [".sno", ".snobol"],
       author: "David J. Farber, Ralph Griswold, and Ivan P. Polonsky",
@@ -13547,29 +13926,87 @@ var init_soql = __esm({
           longDescription: "Salesforce Object Query Language is used to retrieve records from Salesforce objects. It selects fields, filters rows, traverses relationships, orders results, aggregates data, and feeds Apex code, APIs, reports, and integrations.\n\nSOQL resembles SQL, but it is shaped by Salesforce metadata, object relationships, governor limits, sharing rules, and multi-tenant execution. It is central to custom Salesforce apps, admin automation, data migration, and CRM integrations."
         },
         es: {
-          name: "SOQL",
-          description: "Salesforce Object Query Language para leer registros de datos Salesforce.",
-          longDescription: "Salesforce Object Query Language se usa para recuperar registros de objetos Salesforce. Selecciona campos, filtra filas, recorre relaciones, ordena resultados, agrega datos y alimenta codigo Apex, APIs, reportes e integraciones.\n\nSOQL se parece a SQL, pero esta moldeado por metadatos Salesforce, relaciones entre objetos, limites de gobernador, reglas de comparticion y ejecucion multi-tenant. Es central en apps Salesforce personalizadas, automatizacion admin, migracion de datos e integraciones CRM."
+          name: "SOQL",
+          description: "Salesforce Object Query Language para leer registros de datos Salesforce.",
+          longDescription: "Salesforce Object Query Language se usa para recuperar registros de objetos Salesforce. Selecciona campos, filtra filas, recorre relaciones, ordena resultados, agrega datos y alimenta codigo Apex, APIs, reportes e integraciones.\n\nSOQL se parece a SQL, pero esta moldeado por metadatos Salesforce, relaciones entre objetos, limites de gobernador, reglas de comparticion y ejecucion multi-tenant. Es central en apps Salesforce personalizadas, automatizacion admin, migracion de datos e integraciones CRM."
+        },
+        it: {
+          name: "SOQL",
+          description: "Salesforce Object Query Language per leggere record dai dati Salesforce.",
+          longDescription: "Salesforce Object Query Language e usato per recuperare record dagli oggetti Salesforce. Seleziona campi, filtra righe, attraversa relazioni, ordina risultati, aggrega dati e alimenta codice Apex, API, report e integrazioni.\n\nSOQL assomiglia a SQL, ma e modellato da metadati Salesforce, relazioni tra oggetti, governor limit, regole di condivisione ed esecuzione multi-tenant. E centrale in app Salesforce custom, automazione admin, migrazione dati e integrazioni CRM."
+        },
+        fr: {
+          name: "SOQL",
+          description: "Salesforce Object Query Language pour lire des enregistrements Salesforce.",
+          longDescription: "Salesforce Object Query Language sert a recuperer des enregistrements depuis les objets Salesforce. Il selectionne des champs, filtre des lignes, traverse relations, trie resultats, agrege donnees et alimente code Apex, API, rapports et integrations.\n\nSOQL ressemble a SQL, mais il est modele par metadonnees Salesforce, relations d objets, governor limits, regles de partage et execution multi-tenant. Il est central dans apps Salesforce personnalisees, automatisation admin, migrations de donnees et integrations CRM."
+        },
+        de: {
+          name: "SOQL",
+          description: "Salesforce Object Query Language zum Lesen von Salesforce-Datensatzen.",
+          longDescription: "Salesforce Object Query Language wird genutzt, um Datensatze aus Salesforce-Objekten abzurufen. Sie wahlt Felder, filtert Zeilen, folgt Beziehungen, sortiert Ergebnisse, aggregiert Daten und versorgt Apex-Code, APIs, Reports und Integrationen.\n\nSOQL ahnelt SQL, wird aber durch Salesforce-Metadaten, Objektbeziehungen, Governor Limits, Sharing-Regeln und Multi-Tenant-Ausfuhrung gepragt. Es ist zentral fur angepasste Salesforce-Apps, Admin-Automation, Datenmigration und CRM-Integrationen."
+        },
+        pt: {
+          name: "SOQL",
+          description: "Salesforce Object Query Language para ler registros de dados Salesforce.",
+          longDescription: "Salesforce Object Query Language e usada para recuperar registros de objetos Salesforce. Ela seleciona campos, filtra linhas, atravessa relacionamentos, ordena resultados, agrega dados e alimenta codigo Apex, APIs, relatorios e integracoes.\n\nSOQL lembra SQL, mas e moldada por metadados Salesforce, relacionamentos entre objetos, governor limits, regras de compartilhamento e execucao multi-tenant. E central em apps Salesforce customizados, automacao admin, migracao de dados e integracoes CRM."
+        }
+      }
+    };
+  }
+});
+
+// src/languages/spark.ts
+var spark_exports = {};
+__export(spark_exports, {
+  spark: () => spark
+});
+var spark;
+var init_spark = __esm({
+  "src/languages/spark.ts"() {
+    spark = {
+      slug: "spark",
+      publishedDate: "2009-01-01",
+      extensions: [".spark", ".adb", ".ads"],
+      author: "Altran and AdaCore",
+      website: "https://www.adacore.com/about-spark",
+      paradigms: ["imperative", "object-oriented", "formal verification"],
+      tooling: {
+        runtimes: ["GNAT", "Ada runtimes"],
+        ecosystems: ["Ada", "Embedded", "Safety-critical software"]
+      },
+      version: "SPARK Community 2021",
+      logo: "https://avatars.githubusercontent.com/u/7767877?v=4",
+      color: "#DC2626",
+      i18n: {
+        en: {
+          name: "SPARK",
+          description: "A formally verifiable Ada-based language for high-integrity and safety-critical software.",
+          longDescription: "SPARK is a programming language and verification ecosystem based on Ada, designed for software where correctness, safety, and security matter. It restricts and extends Ada with contracts, proof-oriented annotations, and analyzable semantics.\n\nSPARK is used in avionics, defense, embedded systems, industrial control, and other high-integrity domains. Its tooling can prove absence of runtime errors and verify functional properties before code runs."
+        },
+        es: {
+          name: "SPARK",
+          description: "Lenguaje basado en Ada y verificable formalmente para software critico y de alta integridad.",
+          longDescription: "SPARK es un lenguaje de programacion y ecosistema de verificacion basado en Ada, disenado para software donde importan correccion, seguridad funcional y seguridad informatica. Restringe y extiende Ada con contratos, anotaciones orientadas a pruebas y semantica analizable.\n\nSPARK se usa en avionica, defensa, sistemas embebidos, control industrial y otros dominios de alta integridad. Sus herramientas pueden probar ausencia de errores en tiempo de ejecucion y verificar propiedades funcionales antes de ejecutar el codigo."
         },
         it: {
-          name: "SOQL",
-          description: "Salesforce Object Query Language per leggere record dai dati Salesforce.",
-          longDescription: "Salesforce Object Query Language e usato per recuperare record dagli oggetti Salesforce. Seleziona campi, filtra righe, attraversa relazioni, ordina risultati, aggrega dati e alimenta codice Apex, API, report e integrazioni.\n\nSOQL assomiglia a SQL, ma e modellato da metadati Salesforce, relazioni tra oggetti, governor limit, regole di condivisione ed esecuzione multi-tenant. E centrale in app Salesforce custom, automazione admin, migrazione dati e integrazioni CRM."
+          name: "SPARK",
+          description: "Linguaggio basato su Ada e verificabile formalmente per software critico e ad alta integrita.",
+          longDescription: "SPARK e un linguaggio di programmazione e un ecosistema di verifica basato su Ada, progettato per software in cui correttezza, safety e security sono fondamentali. Restringe ed estende Ada con contratti, annotazioni orientate alla prova e semantica analizzabile.\n\nSPARK e usato in avionica, difesa, sistemi embedded, controllo industriale e altri domini ad alta integrita. I suoi strumenti possono provare l assenza di errori a runtime e verificare proprieta funzionali prima dell esecuzione del codice."
         },
         fr: {
-          name: "SOQL",
-          description: "Salesforce Object Query Language pour lire des enregistrements Salesforce.",
-          longDescription: "Salesforce Object Query Language sert a recuperer des enregistrements depuis les objets Salesforce. Il selectionne des champs, filtre des lignes, traverse relations, trie resultats, agrege donnees et alimente code Apex, API, rapports et integrations.\n\nSOQL ressemble a SQL, mais il est modele par metadonnees Salesforce, relations d objets, governor limits, regles de partage et execution multi-tenant. Il est central dans apps Salesforce personnalisees, automatisation admin, migrations de donnees et integrations CRM."
+          name: "SPARK",
+          description: "Langage base sur Ada, verifiable formellement, pour logiciels critiques et haute integrite.",
+          longDescription: "SPARK est un langage de programmation et un ecosysteme de verification base sur Ada, concu pour les logiciels ou correction, surete et securite sont essentielles. Il restreint et etend Ada avec des contrats, des annotations orientees preuve et une semantique analysable.\n\nSPARK est utilise dans l avionique, la defense, les systemes embarques, le controle industriel et d autres domaines a haute integrite. Ses outils peuvent prouver l absence d erreurs a l execution et verifier des proprietes fonctionnelles avant que le code ne tourne."
         },
         de: {
-          name: "SOQL",
-          description: "Salesforce Object Query Language zum Lesen von Salesforce-Datensatzen.",
-          longDescription: "Salesforce Object Query Language wird genutzt, um Datensatze aus Salesforce-Objekten abzurufen. Sie wahlt Felder, filtert Zeilen, folgt Beziehungen, sortiert Ergebnisse, aggregiert Daten und versorgt Apex-Code, APIs, Reports und Integrationen.\n\nSOQL ahnelt SQL, wird aber durch Salesforce-Metadaten, Objektbeziehungen, Governor Limits, Sharing-Regeln und Multi-Tenant-Ausfuhrung gepragt. Es ist zentral fur angepasste Salesforce-Apps, Admin-Automation, Datenmigration und CRM-Integrationen."
+          name: "SPARK",
+          description: "Formal verifizierbare Ada-basierte Sprache fur sicherheitskritische High-Integrity-Software.",
+          longDescription: "SPARK ist eine auf Ada basierende Programmiersprache und Verifikationsumgebung fur Software, bei der Korrektheit, Safety und Security entscheidend sind. Sie beschrankt und erweitert Ada mit Vertragen, beweisorientierten Annotationen und analysierbarer Semantik.\n\nSPARK wird in Avionik, Verteidigung, eingebetteten Systemen, industrieller Steuerung und anderen High-Integrity-Domanen genutzt. Die Werkzeuge konnen Laufzeitfehlerfreiheit beweisen und funktionale Eigenschaften vor der Ausfuhrung verifizieren."
         },
         pt: {
-          name: "SOQL",
-          description: "Salesforce Object Query Language para ler registros de dados Salesforce.",
-          longDescription: "Salesforce Object Query Language e usada para recuperar registros de objetos Salesforce. Ela seleciona campos, filtra linhas, atravessa relacionamentos, ordena resultados, agrega dados e alimenta codigo Apex, APIs, relatorios e integracoes.\n\nSOQL lembra SQL, mas e moldada por metadados Salesforce, relacionamentos entre objetos, governor limits, regras de compartilhamento e execucao multi-tenant. E central em apps Salesforce customizados, automacao admin, migracao de dados e integracoes CRM."
+          name: "SPARK",
+          description: "Linguagem baseada em Ada e verificavel formalmente para software critico e de alta integridade.",
+          longDescription: "SPARK e uma linguagem de programacao e ecossistema de verificacao baseado em Ada, criado para software onde correcao, seguranca funcional e seguranca importam. Ela restringe e estende Ada com contratos, anotacoes orientadas a provas e semantica analisavel.\n\nSPARK e usada em avionica, defesa, sistemas embarcados, controle industrial e outros dominios de alta integridade. Suas ferramentas podem provar ausencia de erros em tempo de execucao e verificar propriedades funcionais antes do codigo rodar."
         }
       }
     };
@@ -13634,64 +14071,6 @@ var init_sparql = __esm({
   }
 });
 
-// src/languages/spark.ts
-var spark_exports = {};
-__export(spark_exports, {
-  spark: () => spark
-});
-var spark;
-var init_spark = __esm({
-  "src/languages/spark.ts"() {
-    spark = {
-      slug: "spark",
-      publishedDate: "2009-01-01",
-      extensions: [".spark", ".adb", ".ads"],
-      author: "Altran and AdaCore",
-      website: "https://www.adacore.com/about-spark",
-      paradigms: ["imperative", "object-oriented", "formal verification"],
-      tooling: {
-        runtimes: ["GNAT", "Ada runtimes"],
-        ecosystems: ["Ada", "Embedded", "Safety-critical software"]
-      },
-      version: "SPARK Community 2021",
-      logo: "https://dummyimage.com/32x32/DC2626/ffffff.png&text=SP",
-      color: "#DC2626",
-      i18n: {
-        en: {
-          name: "SPARK",
-          description: "A formally verifiable Ada-based language for high-integrity and safety-critical software.",
-          longDescription: "SPARK is a programming language and verification ecosystem based on Ada, designed for software where correctness, safety, and security matter. It restricts and extends Ada with contracts, proof-oriented annotations, and analyzable semantics.\n\nSPARK is used in avionics, defense, embedded systems, industrial control, and other high-integrity domains. Its tooling can prove absence of runtime errors and verify functional properties before code runs."
-        },
-        es: {
-          name: "SPARK",
-          description: "Lenguaje basado en Ada y verificable formalmente para software critico y de alta integridad.",
-          longDescription: "SPARK es un lenguaje de programacion y ecosistema de verificacion basado en Ada, disenado para software donde importan correccion, seguridad funcional y seguridad informatica. Restringe y extiende Ada con contratos, anotaciones orientadas a pruebas y semantica analizable.\n\nSPARK se usa en avionica, defensa, sistemas embebidos, control industrial y otros dominios de alta integridad. Sus herramientas pueden probar ausencia de errores en tiempo de ejecucion y verificar propiedades funcionales antes de ejecutar el codigo."
-        },
-        it: {
-          name: "SPARK",
-          description: "Linguaggio basato su Ada e verificabile formalmente per software critico e ad alta integrita.",
-          longDescription: "SPARK e un linguaggio di programmazione e un ecosistema di verifica basato su Ada, progettato per software in cui correttezza, safety e security sono fondamentali. Restringe ed estende Ada con contratti, annotazioni orientate alla prova e semantica analizzabile.\n\nSPARK e usato in avionica, difesa, sistemi embedded, controllo industriale e altri domini ad alta integrita. I suoi strumenti possono provare l assenza di errori a runtime e verificare proprieta funzionali prima dell esecuzione del codice."
-        },
-        fr: {
-          name: "SPARK",
-          description: "Langage base sur Ada, verifiable formellement, pour logiciels critiques et haute integrite.",
-          longDescription: "SPARK est un langage de programmation et un ecosysteme de verification base sur Ada, concu pour les logiciels ou correction, surete et securite sont essentielles. Il restreint et etend Ada avec des contrats, des annotations orientees preuve et une semantique analysable.\n\nSPARK est utilise dans l avionique, la defense, les systemes embarques, le controle industriel et d autres domaines a haute integrite. Ses outils peuvent prouver l absence d erreurs a l execution et verifier des proprietes fonctionnelles avant que le code ne tourne."
-        },
-        de: {
-          name: "SPARK",
-          description: "Formal verifizierbare Ada-basierte Sprache fur sicherheitskritische High-Integrity-Software.",
-          longDescription: "SPARK ist eine auf Ada basierende Programmiersprache und Verifikationsumgebung fur Software, bei der Korrektheit, Safety und Security entscheidend sind. Sie beschrankt und erweitert Ada mit Vertragen, beweisorientierten Annotationen und analysierbarer Semantik.\n\nSPARK wird in Avionik, Verteidigung, eingebetteten Systemen, industrieller Steuerung und anderen High-Integrity-Domanen genutzt. Die Werkzeuge konnen Laufzeitfehlerfreiheit beweisen und funktionale Eigenschaften vor der Ausfuhrung verifizieren."
-        },
-        pt: {
-          name: "SPARK",
-          description: "Linguagem baseada em Ada e verificavel formalmente para software critico e de alta integridade.",
-          longDescription: "SPARK e uma linguagem de programacao e ecossistema de verificacao baseado em Ada, criado para software onde correcao, seguranca funcional e seguranca importam. Ela restringe e estende Ada com contratos, anotacoes orientadas a provas e semantica analisavel.\n\nSPARK e usada em avionica, defesa, sistemas embarcados, controle industrial e outros dominios de alta integridade. Suas ferramentas podem provar ausencia de erros em tempo de execucao e verificar propriedades funcionais antes do codigo rodar."
-        }
-      }
-    };
-  }
-});
-
 // src/languages/spl.ts
 var spl_exports = {};
 __export(spl_exports, {
@@ -13770,7 +14149,7 @@ var init_spss = __esm({
         ecosystems: ["Statistics", "Data Analysis", "Social Sciences", "Business Intelligence"]
       },
       version: "29.0",
-      logo: "https://dummyimage.com/32x32/052FAD/ffffff.png&text=SPSS",
+      logo: "https://upload.wikimedia.org/wikipedia/commons/e/ea/SPSS_logo.svg",
       color: "#052FAD",
       i18n: {
         en: {
@@ -13882,7 +14261,7 @@ var init_squirrel = __esm({
         ecosystems: ["Game Development", "Embedded Scripting", "Valve Source Engine"]
       },
       version: "3.2",
-      logo: "https://dummyimage.com/32x32/CC4A00/ffffff.png&text=SQ",
+      logo: "https://raw.githubusercontent.com/vscode-icons/vscode-icons/master/icons/file_type_squirrel.svg",
       color: "#CC4A00",
       i18n: {
         en: {
@@ -14515,6 +14894,7 @@ var init_tex = __esm({
   "src/languages/tex.ts"() {
     tex = {
       slug: "tex",
+      aliases: ["latex"],
       publishedDate: "1978-01-01",
       extensions: [".tex", ".sty", ".cls", ".dtx", ".ins", ".ltx"],
       author: "Donald Knuth",
@@ -15040,6 +15420,7 @@ var init_typescript = __esm({
   "src/languages/typescript.ts"() {
     typescript = {
       slug: "typescript",
+      aliases: ["ts"],
       publishedDate: "2012-10-01",
       extensions: [".ts", ".tsx", ".mts", ".cts"],
       author: "Anders Hejlsberg / Microsoft",
@@ -15325,6 +15706,65 @@ var init_vala = __esm({
   }
 });
 
+// src/languages/vale.ts
+var vale_exports = {};
+__export(vale_exports, {
+  vale: () => vale
+});
+var vale;
+var init_vale = __esm({
+  "src/languages/vale.ts"() {
+    vale = {
+      slug: "vale",
+      status: "experimental",
+      publishedDate: "2018-01-01",
+      extensions: [".vale"],
+      author: "Evan Ovadia",
+      website: "https://vale.dev",
+      paradigms: ["systems", "imperative", "object-oriented"],
+      tooling: {
+        runtimes: ["Vale compiler"],
+        ecosystems: ["Native applications", "Systems programming"]
+      },
+      version: "experimental",
+      logo: "https://avatars.githubusercontent.com/u/67560249?v=4",
+      color: "#059669",
+      i18n: {
+        en: {
+          name: "Vale",
+          description: "A systems programming language exploring memory safety through ownership and generational references.",
+          longDescription: "Vale is a systems programming language focused on fast native code, memory safety, and ergonomic ownership. Its design explores generational references, region-like ownership, and compile-time checks that avoid conventional garbage collection.\n\nThe language targets domains where C and C++ are common, including engines, tools, and performance-sensitive services. It remains experimental, with active design work around safety, concurrency, and interoperability."
+        },
+        es: {
+          name: "Vale",
+          description: "Lenguaje de sistemas que explora seguridad de memoria con ownership y referencias generacionales.",
+          longDescription: "Vale es un lenguaje de programacion de sistemas centrado en codigo nativo rapido, seguridad de memoria y ownership ergonomico. Su diseno explora referencias generacionales, ownership parecido a regiones y comprobaciones en compilacion que evitan la recoleccion de basura convencional.\n\nEl lenguaje apunta a dominios donde C y C++ son comunes, como motores, herramientas y servicios sensibles al rendimiento. Sigue siendo experimental, con trabajo activo en seguridad, concurrencia e interoperabilidad."
+        },
+        it: {
+          name: "Vale",
+          description: "Linguaggio di sistema che esplora sicurezza della memoria con ownership e riferimenti generazionali.",
+          longDescription: "Vale e un linguaggio di programmazione di sistema focalizzato su codice nativo veloce, sicurezza della memoria e ownership ergonomica. Il design esplora riferimenti generazionali, ownership simile a regioni e controlli a tempo di compilazione che evitano la garbage collection convenzionale.\n\nIl linguaggio mira a domini dove C e C++ sono comuni, inclusi motori, strumenti e servizi sensibili alle prestazioni. Rimane sperimentale, con lavoro attivo su sicurezza, concorrenza e interoperabilita."
+        },
+        fr: {
+          name: "Vale",
+          description: "Langage systeme explorant la surete memoire par ownership et references generationnelles.",
+          longDescription: "Vale est un langage de programmation systeme centre sur le code natif rapide, la surete memoire et un ownership ergonomique. Sa conception explore les references generationnelles, un ownership proche des regions et des verifications a la compilation qui evitent le ramasse-miettes classique.\n\nLe langage vise les domaines ou C et C++ sont frequents, comme les moteurs, les outils et les services sensibles aux performances. Il reste experimental, avec un travail actif sur la surete, la concurrence et l interoperabilite."
+        },
+        de: {
+          name: "Vale",
+          description: "Systemprogrammiersprache fur Speichersicherheit durch Ownership und generationale Referenzen.",
+          longDescription: "Vale ist eine Systemprogrammiersprache mit Fokus auf schnellen nativen Code, Speichersicherheit und ergonomisches Ownership. Das Design erforscht generationale Referenzen, regionenahnliches Ownership und Kompilierzeitprufungen, die klassische Garbage Collection vermeiden.\n\nDie Sprache zielt auf Bereiche, in denen C und C++ verbreitet sind, etwa Engines, Werkzeuge und leistungsensitive Dienste. Sie bleibt experimentell, mit aktiver Arbeit an Sicherheit, Nebenlaufigkeit und Interoperabilitat."
+        },
+        pt: {
+          name: "Vale",
+          description: "Linguagem de sistemas que explora seguranca de memoria com ownership e referencias geracionais.",
+          longDescription: "Vale e uma linguagem de programacao de sistemas focada em codigo nativo rapido, seguranca de memoria e ownership ergonomico. Seu design explora referencias geracionais, ownership parecido com regioes e verificacoes em tempo de compilacao que evitam garbage collection convencional.\n\nA linguagem mira dominios onde C e C++ sao comuns, incluindo motores, ferramentas e servicos sensiveis a desempenho. Ela permanece experimental, com trabalho ativo em seguranca, concorrencia e interoperabilidade."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/vba.ts
 var vba_exports = {};
 __export(vba_exports, {
@@ -15344,7 +15784,7 @@ var init_vba = __esm({
         ecosystems: ["Microsoft Office", "Excel", "Access", "Word", "Outlook"]
       },
       version: "VBA 7.1",
-      logo: "https://dummyimage.com/32x32/217346/ffffff.png&text=VBA",
+      logo: "https://raw.githubusercontent.com/vscode-icons/vscode-icons/master/icons/file_type_vba.svg",
       color: "#217346",
       i18n: {
         en: {
@@ -15382,58 +15822,59 @@ var init_vba = __esm({
   }
 });
 
-// src/languages/vale.ts
-var vale_exports = {};
-__export(vale_exports, {
-  vale: () => vale
+// src/languages/vbscript.ts
+var vbscript_exports = {};
+__export(vbscript_exports, {
+  vbscript: () => vbscript
 });
-var vale;
-var init_vale = __esm({
-  "src/languages/vale.ts"() {
-    vale = {
-      slug: "vale",
-      publishedDate: "2018-01-01",
-      extensions: [".vale"],
-      author: "Evan Ovadia",
-      website: "https://vale.dev",
-      paradigms: ["systems", "imperative", "object-oriented"],
+var vbscript;
+var init_vbscript = __esm({
+  "src/languages/vbscript.ts"() {
+    vbscript = {
+      slug: "vbscript",
+      status: "legacy",
+      publishedDate: "1996-08-01",
+      extensions: [".vbs", ".vbe"],
+      author: "Microsoft",
+      website: "https://learn.microsoft.com/en-us/previous-versions/t0aew7h6(v=vs.85)",
+      paradigms: ["imperative", "object-based", "scripting"],
       tooling: {
-        runtimes: ["Vale compiler"],
-        ecosystems: ["Native applications", "Systems programming"]
+        runtimes: ["Windows Script Host", "Classic ASP", "Internet Explorer"],
+        ecosystems: ["Windows", "Scripting"]
       },
-      version: "experimental",
-      logo: "https://dummyimage.com/32x32/059669/ffffff.png&text=Va",
-      color: "#059669",
+      version: "5.8",
+      logo: "https://dummyimage.com/32x32/15DCDC/000000.png&text=VBS",
+      color: "#15DCDC",
       i18n: {
         en: {
-          name: "Vale",
-          description: "A systems programming language exploring memory safety through ownership and generational references.",
-          longDescription: "Vale is a systems programming language focused on fast native code, memory safety, and ergonomic ownership. Its design explores generational references, region-like ownership, and compile-time checks that avoid conventional garbage collection.\n\nThe language targets domains where C and C++ are common, including engines, tools, and performance-sensitive services. It remains experimental, with active design work around safety, concurrency, and interoperability."
+          name: "VBScript",
+          description: "A lightweight Visual Basic dialect for Windows automation and Classic ASP.",
+          longDescription: "VBScript is a scripting language modeled on Visual Basic and executed by the Windows Script Host, Classic ASP, and legacy Internet Explorer. It was widely used for Windows administration, logon scripts, and early server-side web pages.\n\nMicrosoft has deprecated VBScript and is phasing it out of Windows in favor of PowerShell and JavaScript, but large volumes of .vbs automation still run in enterprise environments."
         },
         es: {
-          name: "Vale",
-          description: "Lenguaje de sistemas que explora seguridad de memoria con ownership y referencias generacionales.",
-          longDescription: "Vale es un lenguaje de programacion de sistemas centrado en codigo nativo rapido, seguridad de memoria y ownership ergonomico. Su diseno explora referencias generacionales, ownership parecido a regiones y comprobaciones en compilacion que evitan la recoleccion de basura convencional.\n\nEl lenguaje apunta a dominios donde C y C++ son comunes, como motores, herramientas y servicios sensibles al rendimiento. Sigue siendo experimental, con trabajo activo en seguridad, concurrencia e interoperabilidad."
+          name: "VBScript",
+          description: "Un dialecto ligero de Visual Basic para automatizaci\xF3n de Windows y ASP cl\xE1sico.",
+          longDescription: "VBScript es un lenguaje de scripting inspirado en Visual Basic y ejecutado por Windows Script Host, ASP cl\xE1sico e Internet Explorer heredado. Se us\xF3 ampliamente para administraci\xF3n de Windows, scripts de inicio de sesi\xF3n y las primeras p\xE1ginas web del lado del servidor.\n\nMicrosoft ha marcado VBScript como obsoleto y lo est\xE1 retirando de Windows en favor de PowerShell y JavaScript, pero grandes vol\xFAmenes de automatizaci\xF3n .vbs siguen ejecut\xE1ndose en entornos empresariales."
         },
         it: {
-          name: "Vale",
-          description: "Linguaggio di sistema che esplora sicurezza della memoria con ownership e riferimenti generazionali.",
-          longDescription: "Vale e un linguaggio di programmazione di sistema focalizzato su codice nativo veloce, sicurezza della memoria e ownership ergonomica. Il design esplora riferimenti generazionali, ownership simile a regioni e controlli a tempo di compilazione che evitano la garbage collection convenzionale.\n\nIl linguaggio mira a domini dove C e C++ sono comuni, inclusi motori, strumenti e servizi sensibili alle prestazioni. Rimane sperimentale, con lavoro attivo su sicurezza, concorrenza e interoperabilita."
+          name: "VBScript",
+          description: "Un dialetto leggero di Visual Basic per automazione Windows e ASP classico.",
+          longDescription: "VBScript \xE8 un linguaggio di scripting modellato su Visual Basic ed eseguito da Windows Script Host, ASP classico e dal vecchio Internet Explorer. \xC8 stato ampiamente usato per l'amministrazione di Windows, gli script di accesso e le prime pagine web lato server.\n\nMicrosoft ha deprecato VBScript e lo sta rimuovendo da Windows in favore di PowerShell e JavaScript, ma grandi volumi di automazione .vbs sono ancora in esecuzione negli ambienti aziendali."
         },
         fr: {
-          name: "Vale",
-          description: "Langage systeme explorant la surete memoire par ownership et references generationnelles.",
-          longDescription: "Vale est un langage de programmation systeme centre sur le code natif rapide, la surete memoire et un ownership ergonomique. Sa conception explore les references generationnelles, un ownership proche des regions et des verifications a la compilation qui evitent le ramasse-miettes classique.\n\nLe langage vise les domaines ou C et C++ sont frequents, comme les moteurs, les outils et les services sensibles aux performances. Il reste experimental, avec un travail actif sur la surete, la concurrence et l interoperabilite."
+          name: "VBScript",
+          description: "Un dialecte l\xE9ger de Visual Basic pour l'automatisation Windows et l'ASP classique.",
+          longDescription: "VBScript est un langage de script inspir\xE9 de Visual Basic et ex\xE9cut\xE9 par Windows Script Host, l'ASP classique et l'ancien Internet Explorer. Il a \xE9t\xE9 largement utilis\xE9 pour l'administration Windows, les scripts d'ouverture de session et les premi\xE8res pages web c\xF4t\xE9 serveur.\n\nMicrosoft a d\xE9pr\xE9ci\xE9 VBScript et le retire progressivement de Windows au profit de PowerShell et de JavaScript, mais de grands volumes d'automatisation .vbs tournent encore dans les environnements d'entreprise."
         },
         de: {
-          name: "Vale",
-          description: "Systemprogrammiersprache fur Speichersicherheit durch Ownership und generationale Referenzen.",
-          longDescription: "Vale ist eine Systemprogrammiersprache mit Fokus auf schnellen nativen Code, Speichersicherheit und ergonomisches Ownership. Das Design erforscht generationale Referenzen, regionenahnliches Ownership und Kompilierzeitprufungen, die klassische Garbage Collection vermeiden.\n\nDie Sprache zielt auf Bereiche, in denen C und C++ verbreitet sind, etwa Engines, Werkzeuge und leistungsensitive Dienste. Sie bleibt experimentell, mit aktiver Arbeit an Sicherheit, Nebenlaufigkeit und Interoperabilitat."
+          name: "VBScript",
+          description: "Ein leichter Visual-Basic-Dialekt f\xFCr Windows-Automatisierung und Classic ASP.",
+          longDescription: "VBScript ist eine an Visual Basic angelehnte Skriptsprache, die vom Windows Script Host, Classic ASP und dem alten Internet Explorer ausgef\xFChrt wird. Sie wurde breit f\xFCr Windows-Administration, Anmeldeskripte und fr\xFChe serverseitige Webseiten eingesetzt.\n\nMicrosoft hat VBScript als veraltet markiert und entfernt es schrittweise aus Windows zugunsten von PowerShell und JavaScript, aber gro\xDFe Mengen an .vbs-Automatisierung laufen weiterhin in Unternehmensumgebungen."
         },
         pt: {
-          name: "Vale",
-          description: "Linguagem de sistemas que explora seguranca de memoria com ownership e referencias geracionais.",
-          longDescription: "Vale e uma linguagem de programacao de sistemas focada em codigo nativo rapido, seguranca de memoria e ownership ergonomico. Seu design explora referencias geracionais, ownership parecido com regioes e verificacoes em tempo de compilacao que evitam garbage collection convencional.\n\nA linguagem mira dominios onde C e C++ sao comuns, incluindo motores, ferramentas e servicos sensiveis a desempenho. Ela permanece experimental, com trabalho ativo em seguranca, concorrencia e interoperabilidade."
+          name: "VBScript",
+          description: "Um dialeto leve de Visual Basic para automa\xE7\xE3o do Windows e ASP cl\xE1ssico.",
+          longDescription: "VBScript \xE9 uma linguagem de script baseada no Visual Basic e executada pelo Windows Script Host, pelo ASP cl\xE1ssico e pelo antigo Internet Explorer. Foi amplamente usada para administra\xE7\xE3o do Windows, scripts de logon e as primeiras p\xE1ginas web do lado do servidor.\n\nA Microsoft descontinuou o VBScript e o est\xE1 removendo do Windows em favor do PowerShell e do JavaScript, mas grandes volumes de automa\xE7\xE3o .vbs ainda rodam em ambientes corporativos."
         }
       }
     };
@@ -15577,7 +16018,7 @@ var init_verse = __esm({
         ecosystems: ["Unreal Engine", "Fortnite Creator"]
       },
       version: "UEFN Verse",
-      logo: "https://dummyimage.com/32x32/111827/ffffff.png&text=Ve",
+      logo: "https://cdn.simpleicons.org/epicgames",
       color: "#111827",
       i18n: {
         en: {
@@ -15674,6 +16115,66 @@ var init_vhdl = __esm({
   }
 });
 
+// src/languages/vimscript.ts
+var vimscript_exports = {};
+__export(vimscript_exports, {
+  vimscript: () => vimscript
+});
+var vimscript;
+var init_vimscript = __esm({
+  "src/languages/vimscript.ts"() {
+    vimscript = {
+      slug: "vimscript",
+      aliases: ["vim", "vim script", "viml"],
+      publishedDate: "1991-11-02",
+      extensions: [".vim", ".vimrc", ".gvimrc"],
+      author: "Bram Moolenaar",
+      website: "https://www.vim.org",
+      paradigms: ["imperative", "scripting"],
+      tooling: {
+        runtimes: ["Vim", "Neovim"],
+        packageManagers: ["vim-plug", "lazy.nvim", "packer.nvim"],
+        ecosystems: ["Text Editors", "Scripting"]
+      },
+      version: "Vim 9.1",
+      logo: "https://cdn.simpleicons.org/vim/019733",
+      color: "#019733",
+      i18n: {
+        en: {
+          name: "Vim script",
+          description: "The scripting language built into the Vim editor for configuration & plugins.",
+          longDescription: "Vim script is the scripting language embedded in the Vim text editor. It drives user configuration through vimrc files and powers a large plugin ecosystem, with commands, autocommands, functions, and access to buffers, windows, and registers.\n\nVim 9 introduced Vim9 script, a faster, more structured dialect with typed variables and compiled functions, while Neovim pairs the legacy dialect with Lua as an alternative extension language."
+        },
+        es: {
+          name: "Vim script",
+          description: "El lenguaje de scripting integrado en el editor Vim para configuraci\xF3n y plugins.",
+          longDescription: "Vim script es el lenguaje de scripting integrado en el editor de texto Vim. Gestiona la configuraci\xF3n del usuario mediante archivos vimrc e impulsa un gran ecosistema de plugins, con comandos, autocomandos, funciones y acceso a buffers, ventanas y registros.\n\nVim 9 introdujo Vim9 script, un dialecto m\xE1s r\xE1pido y estructurado con variables tipadas y funciones compiladas, mientras que Neovim combina el dialecto cl\xE1sico con Lua como lenguaje de extensi\xF3n alternativo."
+        },
+        it: {
+          name: "Vim script",
+          description: "Il linguaggio di scripting integrato nell'editor Vim per configurazione e plugin.",
+          longDescription: "Vim script \xE8 il linguaggio di scripting incorporato nell'editor di testo Vim. Gestisce la configurazione dell'utente tramite i file vimrc e alimenta un vasto ecosistema di plugin, con comandi, autocomandi, funzioni e accesso a buffer, finestre e registri.\n\nVim 9 ha introdotto Vim9 script, un dialetto pi\xF9 veloce e strutturato con variabili tipate e funzioni compilate, mentre Neovim affianca al dialetto classico Lua come linguaggio di estensione alternativo."
+        },
+        fr: {
+          name: "Vim script",
+          description: "Le langage de script int\xE9gr\xE9 \xE0 l'\xE9diteur Vim pour la configuration et les plugins.",
+          longDescription: "Vim script est le langage de script int\xE9gr\xE9 \xE0 l'\xE9diteur de texte Vim. Il pilote la configuration de l'utilisateur via les fichiers vimrc et alimente un vaste \xE9cosyst\xE8me de plugins, avec des commandes, des autocommandes, des fonctions et un acc\xE8s aux tampons, fen\xEAtres et registres.\n\nVim 9 a introduit Vim9 script, un dialecte plus rapide et plus structur\xE9 avec des variables typ\xE9es et des fonctions compil\xE9es, tandis que Neovim associe le dialecte historique \xE0 Lua comme langage d'extension alternatif."
+        },
+        de: {
+          name: "Vim script",
+          description: "Die im Vim-Editor eingebaute Skriptsprache f\xFCr Konfiguration und Plugins.",
+          longDescription: "Vim script ist die in den Texteditor Vim eingebettete Skriptsprache. Sie steuert die Benutzerkonfiguration \xFCber vimrc-Dateien und treibt ein gro\xDFes Plugin-\xD6kosystem an, mit Befehlen, Autokommandos, Funktionen und Zugriff auf Puffer, Fenster und Register.\n\nVim 9 f\xFChrte Vim9 script ein, einen schnelleren, st\xE4rker strukturierten Dialekt mit typisierten Variablen und kompilierten Funktionen, w\xE4hrend Neovim den klassischen Dialekt mit Lua als alternativer Erweiterungssprache kombiniert."
+        },
+        pt: {
+          name: "Vim script",
+          description: "A linguagem de script embutida no editor Vim para configura\xE7\xE3o e plugins.",
+          longDescription: "Vim script \xE9 a linguagem de script embutida no editor de texto Vim. Ela controla a configura\xE7\xE3o do usu\xE1rio por meio de arquivos vimrc e move um grande ecossistema de plugins, com comandos, autocomandos, fun\xE7\xF5es e acesso a buffers, janelas e registradores.\n\nO Vim 9 introduziu o Vim9 script, um dialeto mais r\xE1pido e estruturado com vari\xE1veis tipadas e fun\xE7\xF5es compiladas, enquanto o Neovim combina o dialeto cl\xE1ssico com Lua como linguagem de extens\xE3o alternativa."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/visual-basic.ts
 var visual_basic_exports = {};
 __export(visual_basic_exports, {
@@ -15684,6 +16185,7 @@ var init_visual_basic = __esm({
   "src/languages/visual-basic.ts"() {
     visualBasic = {
       slug: "visual-basic",
+      aliases: ["vb", "vb.net"],
       publishedDate: "2001-02-13",
       extensions: [".vb"],
       author: "Microsoft",
@@ -15842,9 +16344,67 @@ var init_vyper = __esm({
           longDescription: "Vyper ist eine Vertragssprache f\xFCr Ethereum, die explizites Verhalten, Grenzen und Pr\xFCfbarkeit gegen\xFCber einem breiten Sprachumfang priorisiert. Ihre Syntax \xE4hnelt Python, w\xE4hrend ihr Compiler EVM-Bytecode erzeugt.\n\nSie wird f\xFCr Ethereum-Smart Contracts, Finanzprotokolle, On-Chain-Experimente und Codebasen verwendet, die eine absichtlich eingeschr\xE4nkte Vertragssprache bevorzugen."
         },
         pt: {
-          name: "Vyper",
-          description: "Linguagem de contrato Pythonic para a M\xE1quina Virtual Ethereum.",
-          longDescription: "Vyper \xE9 uma linguagem de contrato para Ethereum que favorece o comportamento expl\xEDcito, limites e auditabilidade em vez de uma ampla superf\xEDcie de linguagem. Sua sintaxe \xE9 semelhante \xE0 do Python, enquanto seu compilador emite bytecode EVM.\n\n\xC9 usada para contratos inteligentes Ethereum, protocolos financeiros, experimentos on-chain e c\xF3digo que prefere uma linguagem de contrato deliberadamente restrita."
+          name: "Vyper",
+          description: "Linguagem de contrato Pythonic para a M\xE1quina Virtual Ethereum.",
+          longDescription: "Vyper \xE9 uma linguagem de contrato para Ethereum que favorece o comportamento expl\xEDcito, limites e auditabilidade em vez de uma ampla superf\xEDcie de linguagem. Sua sintaxe \xE9 semelhante \xE0 do Python, enquanto seu compilador emite bytecode EVM.\n\n\xC9 usada para contratos inteligentes Ethereum, protocolos financeiros, experimentos on-chain e c\xF3digo que prefere uma linguagem de contrato deliberadamente restrita."
+        }
+      }
+    };
+  }
+});
+
+// src/languages/wdl.ts
+var wdl_exports = {};
+__export(wdl_exports, {
+  wdl: () => wdl
+});
+var wdl;
+var init_wdl = __esm({
+  "src/languages/wdl.ts"() {
+    wdl = {
+      slug: "wdl",
+      publishedDate: "2016-01-01",
+      extensions: [".wdl"],
+      author: "Broad Institute and OpenWDL community",
+      website: "https://openwdl.org",
+      paradigms: ["declarative", "dataflow", "pipeline"],
+      tooling: {
+        runtimes: ["Cromwell", "miniwdl", "Terra"],
+        ecosystems: ["Bioinformatics", "Scientific Workflows", "Cloud Computing", "Genomics"]
+      },
+      version: "1.2.0",
+      logo: "https://avatars.githubusercontent.com/u/23492081?v=4",
+      color: "#3C6DA6",
+      i18n: {
+        en: {
+          name: "WDL",
+          description: "A workflow definition language for describing portable and reproducible data pipelines.",
+          longDescription: "WDL (Workflow Description Language) is a human-readable specification language for defining tasks, workflows, and their dependencies in a portable and reproducible way. Each task describes a command to run with typed inputs, outputs, and runtime requirements such as CPU, memory, and container images.\n\nOriginally developed at the Broad Institute, WDL is governed by the OpenWDL community and widely used in genomics and precision medicine on platforms such as Terra, Google Life Sciences, and AWS Batch. Its declarative syntax makes pipelines easy to read, maintain, and share across research groups and cloud environments."
+        },
+        es: {
+          name: "WDL",
+          description: "Lenguaje de definicion de flujos de trabajo para describir pipelines portables y reproducibles.",
+          longDescription: "WDL (Workflow Description Language) es un lenguaje de especificacion legible para definir tareas, flujos de trabajo y sus dependencias de forma portable y reproducible. Cada tarea describe un comando a ejecutar con entradas y salidas tipadas y requisitos de ejecucion como CPU, memoria e imagenes de contenedor.\n\nDesarrollado originalmente en el Broad Institute, WDL es gobernado por la comunidad OpenWDL y ampliamente utilizado en genomica y medicina de precision en plataformas como Terra, Google Life Sciences y AWS Batch. Su sintaxis declarativa facilita la lectura, mantenimiento y comparticion de pipelines entre grupos de investigacion."
+        },
+        it: {
+          name: "WDL",
+          description: "Linguaggio di definizione dei workflow per descrivere pipeline dati portabili e riproducibili.",
+          longDescription: "WDL (Workflow Description Language) e un linguaggio di specifica leggibile per definire task, workflow e dipendenze in modo portabile e riproducibile. Ogni task descrive un comando da eseguire con input e output tipizzati e requisiti di runtime come CPU, memoria e immagini container.\n\nSviluppato originariamente al Broad Institute, WDL e gestito dalla community OpenWDL ed e ampiamente usato in genomica e medicina di precisione su piattaforme come Terra, Google Life Sciences e AWS Batch. La sua sintassi dichiarativa rende le pipeline facili da leggere, mantenere e condividere tra gruppi di ricerca."
+        },
+        fr: {
+          name: "WDL",
+          description: "Langage de definition de workflows pour decrire des pipelines de donnees portables et reproductibles.",
+          longDescription: "WDL (Workflow Description Language) est un langage de specification lisible pour definir des taches, des workflows et leurs dependances de maniere portable et reproductible. Chaque tache decrit une commande a executer avec des entrees et sorties typees et des exigences d execution telles que CPU, memoire et images conteneur.\n\nDeveloppe initialement au Broad Institute, WDL est gere par la communaute OpenWDL et largement utilise en genomique et medecine de precision sur des plateformes telles que Terra, Google Life Sciences et AWS Batch. Sa syntaxe declarative facilite la lecture, la maintenance et le partage des pipelines."
+        },
+        de: {
+          name: "WDL",
+          description: "Workflow-Definitionssprache fur portable und reproduzierbare Daten-Pipelines.",
+          longDescription: "WDL (Workflow Description Language) ist eine menschenlesbare Spezifikationssprache zur Definition von Tasks, Workflows und deren Abhangigkeiten auf portable und reproduzierbare Weise. Jeder Task beschreibt einen auszufuhrenden Befehl mit typisierten Ein- und Ausgaben sowie Laufzeitanforderungen wie CPU, Speicher und Container-Images.\n\nUrsprunglich am Broad Institute entwickelt, wird WDL von der OpenWDL-Community betreut und ist weit verbreitet in Genomik und Prazisionsmedizin auf Plattformen wie Terra, Google Life Sciences und AWS Batch. Die deklarative Syntax erleichtert das Lesen, Pflegen und Teilen von Pipelines zwischen Forschungsgruppen."
+        },
+        pt: {
+          name: "WDL",
+          description: "Linguagem de definicao de workflow para descrever pipelines de dados portaveis e reproduziveis.",
+          longDescription: "WDL (Workflow Description Language) e uma linguagem de especificacao legivel para definir tarefas, workflows e suas dependencias de forma portavel e reproduzivel. Cada tarefa descreve um comando a ser executado com entradas e saidas tipadas e requisitos de execucao como CPU, memoria e imagens de container.\n\nDesenvolvido originalmente no Broad Institute, o WDL e gerenciado pela comunidade OpenWDL e amplamente utilizado em genomica e medicina de precisao em plataformas como Terra, Google Life Sciences e AWS Batch. Sua sintaxe declarativa facilita a leitura, manutencao e compartilhamento de pipelines entre grupos de pesquisa."
         }
       }
     };
@@ -15861,6 +16421,7 @@ var init_webassembly = __esm({
   "src/languages/webassembly.ts"() {
     webassembly = {
       slug: "webassembly",
+      aliases: ["wasm", "wat"],
       publishedDate: "2017-03-07",
       extensions: [".wasm", ".wat"],
       author: "W3C WebAssembly Community Group",
@@ -15910,64 +16471,6 @@ var init_webassembly = __esm({
   }
 });
 
-// src/languages/wdl.ts
-var wdl_exports = {};
-__export(wdl_exports, {
-  wdl: () => wdl
-});
-var wdl;
-var init_wdl = __esm({
-  "src/languages/wdl.ts"() {
-    wdl = {
-      slug: "wdl",
-      publishedDate: "2016-01-01",
-      extensions: [".wdl"],
-      author: "Broad Institute and OpenWDL community",
-      website: "https://openwdl.org",
-      paradigms: ["declarative", "dataflow", "pipeline"],
-      tooling: {
-        runtimes: ["Cromwell", "miniwdl", "Terra"],
-        ecosystems: ["Bioinformatics", "Scientific Workflows", "Cloud Computing", "Genomics"]
-      },
-      version: "1.2.0",
-      logo: "https://avatars.githubusercontent.com/u/23492081?v=4",
-      color: "#3C6DA6",
-      i18n: {
-        en: {
-          name: "WDL",
-          description: "A workflow definition language for describing portable and reproducible data pipelines.",
-          longDescription: "WDL (Workflow Description Language) is a human-readable specification language for defining tasks, workflows, and their dependencies in a portable and reproducible way. Each task describes a command to run with typed inputs, outputs, and runtime requirements such as CPU, memory, and container images.\n\nOriginally developed at the Broad Institute, WDL is governed by the OpenWDL community and widely used in genomics and precision medicine on platforms such as Terra, Google Life Sciences, and AWS Batch. Its declarative syntax makes pipelines easy to read, maintain, and share across research groups and cloud environments."
-        },
-        es: {
-          name: "WDL",
-          description: "Lenguaje de definicion de flujos de trabajo para describir pipelines portables y reproducibles.",
-          longDescription: "WDL (Workflow Description Language) es un lenguaje de especificacion legible para definir tareas, flujos de trabajo y sus dependencias de forma portable y reproducible. Cada tarea describe un comando a ejecutar con entradas y salidas tipadas y requisitos de ejecucion como CPU, memoria e imagenes de contenedor.\n\nDesarrollado originalmente en el Broad Institute, WDL es gobernado por la comunidad OpenWDL y ampliamente utilizado en genomica y medicina de precision en plataformas como Terra, Google Life Sciences y AWS Batch. Su sintaxis declarativa facilita la lectura, mantenimiento y comparticion de pipelines entre grupos de investigacion."
-        },
-        it: {
-          name: "WDL",
-          description: "Linguaggio di definizione dei workflow per descrivere pipeline dati portabili e riproducibili.",
-          longDescription: "WDL (Workflow Description Language) e un linguaggio di specifica leggibile per definire task, workflow e dipendenze in modo portabile e riproducibile. Ogni task descrive un comando da eseguire con input e output tipizzati e requisiti di runtime come CPU, memoria e immagini container.\n\nSviluppato originariamente al Broad Institute, WDL e gestito dalla community OpenWDL ed e ampiamente usato in genomica e medicina di precisione su piattaforme come Terra, Google Life Sciences e AWS Batch. La sua sintassi dichiarativa rende le pipeline facili da leggere, mantenere e condividere tra gruppi di ricerca."
-        },
-        fr: {
-          name: "WDL",
-          description: "Langage de definition de workflows pour decrire des pipelines de donnees portables et reproductibles.",
-          longDescription: "WDL (Workflow Description Language) est un langage de specification lisible pour definir des taches, des workflows et leurs dependances de maniere portable et reproductible. Chaque tache decrit une commande a executer avec des entrees et sorties typees et des exigences d execution telles que CPU, memoire et images conteneur.\n\nDeveloppe initialement au Broad Institute, WDL est gere par la communaute OpenWDL et largement utilise en genomique et medecine de precision sur des plateformes telles que Terra, Google Life Sciences et AWS Batch. Sa syntaxe declarative facilite la lecture, la maintenance et le partage des pipelines."
-        },
-        de: {
-          name: "WDL",
-          description: "Workflow-Definitionssprache fur portable und reproduzierbare Daten-Pipelines.",
-          longDescription: "WDL (Workflow Description Language) ist eine menschenlesbare Spezifikationssprache zur Definition von Tasks, Workflows und deren Abhangigkeiten auf portable und reproduzierbare Weise. Jeder Task beschreibt einen auszufuhrenden Befehl mit typisierten Ein- und Ausgaben sowie Laufzeitanforderungen wie CPU, Speicher und Container-Images.\n\nUrsprunglich am Broad Institute entwickelt, wird WDL von der OpenWDL-Community betreut und ist weit verbreitet in Genomik und Prazisionsmedizin auf Plattformen wie Terra, Google Life Sciences und AWS Batch. Die deklarative Syntax erleichtert das Lesen, Pflegen und Teilen von Pipelines zwischen Forschungsgruppen."
-        },
-        pt: {
-          name: "WDL",
-          description: "Linguagem de definicao de workflow para descrever pipelines de dados portaveis e reproduziveis.",
-          longDescription: "WDL (Workflow Description Language) e uma linguagem de especificacao legivel para definir tarefas, workflows e suas dependencias de forma portavel e reproduzivel. Cada tarefa descreve um comando a ser executado com entradas e saidas tipadas e requisitos de execucao como CPU, memoria e imagens de container.\n\nDesenvolvido originalmente no Broad Institute, o WDL e gerenciado pela comunidade OpenWDL e amplamente utilizado em genomica e medicina de precisao em plataformas como Terra, Google Life Sciences e AWS Batch. Sua sintaxe declarativa facilita a leitura, manutencao e compartilhamento de pipelines entre grupos de pesquisa."
-        }
-      }
-    };
-  }
-});
-
 // src/languages/wgsl.ts
 var wgsl_exports = {};
 __export(wgsl_exports, {
@@ -16372,6 +16875,67 @@ var init_xslt = __esm({
   }
 });
 
+// src/languages/yacc.ts
+var yacc_exports = {};
+__export(yacc_exports, {
+  yacc: () => yacc
+});
+var yacc;
+var init_yacc = __esm({
+  "src/languages/yacc.ts"() {
+    yacc = {
+      slug: "yacc",
+      aliases: ["bison"],
+      publishedDate: "1973-01-01",
+      extensions: [".y", ".yacc"],
+      author: "Stephen C. Johnson (Bell Labs)",
+      website: "https://pubs.opengroup.org/onlinepubs/9699919799/utilities/yacc.html",
+      paradigms: ["declarative", "generator"],
+      tooling: {
+        runtimes: ["C toolchains"],
+        ecosystems: ["Compilers", "Language Tooling", "Unix"]
+      },
+      version: "POSIX yacc / Bison 3.8.2",
+      logo: "https://cdn.simpleicons.org/gnu/A42E2B",
+      color: "#4B6C4B",
+      i18n: {
+        en: {
+          name: "Yacc",
+          description: "A parser generator that turns context-free grammars into LALR parser code.",
+          longDescription: 'Yacc ("Yet Another Compiler-Compiler") is a classic Unix parser generator. A .y grammar file declares tokens, precedences, and production rules with embedded C actions, from which Yacc produces an LALR(1) parser that pairs naturally with a Lex-generated scanner.\n\nGNU Bison is the dominant modern implementation and remains widely used to build compilers, interpreters, configuration readers, and query languages across open-source projects.'
+        },
+        es: {
+          name: "Yacc",
+          description: "Un generador de parsers que convierte gram\xE1ticas libres de contexto en parsers LALR.",
+          longDescription: 'Yacc ("Yet Another Compiler-Compiler") es un generador de parsers cl\xE1sico de Unix. Un archivo de gram\xE1tica .y declara tokens, precedencias y reglas de producci\xF3n con acciones en C incrustadas, a partir de las cuales Yacc produce un parser LALR(1) que se combina de forma natural con un esc\xE1ner generado por Lex.\n\nGNU Bison es la implementaci\xF3n moderna dominante y sigue siendo muy usada para construir compiladores, int\xE9rpretes, lectores de configuraci\xF3n y lenguajes de consulta en proyectos de c\xF3digo abierto.'
+        },
+        it: {
+          name: "Yacc",
+          description: "Un generatore di parser che trasforma grammatiche libere dal contesto in parser LALR.",
+          longDescription: `Yacc ("Yet Another Compiler-Compiler") \xE8 un generatore di parser classico di Unix. Un file di grammatica .y dichiara token, precedenze e regole di produzione con azioni C incorporate, da cui Yacc produce un parser LALR(1) che si abbina naturalmente a uno scanner generato da Lex.
+
+GNU Bison \xE8 l'implementazione moderna dominante e rimane ampiamente usata per costruire compilatori, interpreti, lettori di configurazione e linguaggi di interrogazione nei progetti open source.`
+        },
+        fr: {
+          name: "Yacc",
+          description: "Un g\xE9n\xE9rateur de parseurs qui transforme des grammaires hors contexte en parseurs LALR.",
+          longDescription: "Yacc (\xAB Yet Another Compiler-Compiler \xBB) est un g\xE9n\xE9rateur de parseurs Unix classique. Un fichier de grammaire .y d\xE9clare des jetons, des pr\xE9c\xE9dences et des r\xE8gles de production avec des actions C int\xE9gr\xE9es, \xE0 partir desquelles Yacc produit un parseur LALR(1) qui se combine naturellement avec un scanner g\xE9n\xE9r\xE9 par Lex.\n\nGNU Bison est l'impl\xE9mentation moderne dominante et reste largement utilis\xE9e pour construire des compilateurs, des interpr\xE9teurs, des lecteurs de configuration et des langages de requ\xEAte dans les projets open source."
+        },
+        de: {
+          name: "Yacc",
+          description: "Ein Parser-Generator, der kontextfreie Grammatiken in LALR-Parser-Code \xFCbersetzt.",
+          longDescription: 'Yacc (\u201EYet Another Compiler-Compiler") ist ein klassischer Unix-Parser-Generator. Eine .y-Grammatikdatei deklariert Tokens, Pr\xE4zedenzen und Produktionsregeln mit eingebetteten C-Aktionen, aus denen Yacc einen LALR(1)-Parser erzeugt, der sich nat\xFCrlich mit einem von Lex erzeugten Scanner kombinieren l\xE4sst.\n\nGNU Bison ist die dominierende moderne Implementierung und wird weiterhin breit eingesetzt, um Compiler, Interpreter, Konfigurationsleser und Abfragesprachen in Open-Source-Projekten zu bauen.'
+        },
+        pt: {
+          name: "Yacc",
+          description: "Um gerador de parsers que converte gram\xE1ticas livres de contexto em parsers LALR.",
+          longDescription: 'Yacc ("Yet Another Compiler-Compiler") \xE9 um gerador de parsers cl\xE1ssico do Unix. Um arquivo de gram\xE1tica .y declara tokens, preced\xEAncias e regras de produ\xE7\xE3o com a\xE7\xF5es em C embutidas, a partir das quais o Yacc produz um parser LALR(1) que combina naturalmente com um scanner gerado pelo Lex.\n\nO GNU Bison \xE9 a implementa\xE7\xE3o moderna dominante e continua amplamente usado para construir compiladores, interpretadores, leitores de configura\xE7\xE3o e linguagens de consulta em projetos de c\xF3digo aberto.'
+        }
+      }
+    };
+  }
+});
+
 // src/languages/yaml.ts
 var yaml_exports = {};
 __export(yaml_exports, {
@@ -16791,6 +17355,73 @@ function matchesCategory(lang, category) {
   }
 }
 
+// src/domain/detection/match.ts
+var pathSegmentPattern = /[/\\]/;
+var indexCache = /* @__PURE__ */ new WeakMap();
+var getBasename = (filename) => {
+  const parts = filename.trim().split(pathSegmentPattern);
+  return parts.at(-1).toLowerCase();
+};
+var addIndexKey = (index, key, match) => {
+  const matches = index.get(key);
+  if (matches) {
+    matches.push(match);
+  } else {
+    index.set(key, [match]);
+  }
+};
+var buildDetectionIndex = (entries) => {
+  const index = /* @__PURE__ */ new Map();
+  entries.forEach((entry, entryIndex) => {
+    for (const extension of entry.extensions) {
+      const normalizedExtension = extension.toLowerCase();
+      const match = { entry, index: entryIndex, matchLength: extension.length };
+      if (normalizedExtension.startsWith(".")) {
+        addIndexKey(index, normalizedExtension, match);
+      } else {
+        addIndexKey(index, normalizedExtension, match);
+        addIndexKey(index, `.${normalizedExtension}`, match);
+      }
+    }
+  });
+  return index;
+};
+var getDetectionIndex = (entries) => {
+  let index = indexCache.get(entries);
+  if (!index) {
+    index = buildDetectionIndex(entries);
+    indexCache.set(entries, index);
+  }
+  return index;
+};
+var getLookupKeys = (basename) => {
+  const keys = [basename];
+  for (let position = basename.indexOf("."); position !== -1; position = basename.indexOf(".", position + 1)) {
+    const suffix = basename.slice(position);
+    if (suffix !== basename) {
+      keys.push(suffix);
+    }
+  }
+  return keys;
+};
+var detectMatchingEntries = (entries, filename) => {
+  const basename = getBasename(filename);
+  if (!basename) {
+    return [];
+  }
+  const index = getDetectionIndex(entries);
+  const bestMatches = /* @__PURE__ */ new Map();
+  for (const key of getLookupKeys(basename)) {
+    for (const match of index.get(key) ?? []) {
+      const existing = bestMatches.get(match.index);
+      if (!existing || match.matchLength > existing.matchLength) {
+        bestMatches.set(match.index, match);
+      }
+    }
+  }
+  return [...bestMatches.values()].sort((first, second) => second.matchLength - first.matchLength || first.index - second.index).map(({ entry }) => entry);
+};
+
 // src/domain/language/registry.ts
 var languageIndex = [
   { slug: "abap", extensions: [".abap"] },
@@ -16799,34 +17430,34 @@ var languageIndex = [
   { slug: "agda", extensions: [".agda", ".lagda", ".lagda.md", ".lagda.rst", ".lagda.tex"] },
   { slug: "algol", extensions: [".alg", ".algol"] },
   { slug: "ampl", extensions: [".mod", ".dat", ".run"] },
+  { slug: "angelscript", extensions: [".as", ".angelscript"] },
   { slug: "ante", extensions: [".ante"] },
   { 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: "aql", extensions: [".aql"] },
+  { slug: "arduino", extensions: [".ino", ".pde"] },
   { slug: "asciidoc", extensions: [".adoc", ".asciidoc", ".asc"] },
   { slug: "asp", extensions: [".asp", ".aspx", ".ascx", ".ashx", ".asmx", ".master"] },
   { slug: "assembly", extensions: [".asm", ".s", ".S", ".inc"] },
   { slug: "assemblyscript", extensions: [".as"] },
-  { slug: "angelscript", extensions: [".as", ".angelscript"] },
   { slug: "astro", extensions: [".astro"] },
   { slug: "austral", extensions: [".aum", ".aui"] },
   { slug: "autohotkey", extensions: [".ahk", ".ah2"] },
   { slug: "avro-idl", extensions: [".avdl"] },
   { slug: "awk", extensions: [".awk"] },
   { slug: "ballerina", extensions: [".bal"] },
-  { slug: "basic", extensions: [".bas", ".bi", ".bb"] },
   {
     slug: "bash",
     extensions: [".sh", ".bash", ".bashrc", ".bash_profile", ".bash_login", ".profile"]
   },
+  { slug: "basic", extensions: [".bas", ".bi", ".bb"] },
   { slug: "batch", extensions: [".bat", ".cmd"] },
   { slug: "bazel", extensions: ["BUILD.bazel", "WORKSPACE", "WORKSPACE.bazel", "MODULE.bazel"] },
   { slug: "bcpl", extensions: [".bcpl"] },
-  { slug: "bicep", extensions: [".bicep", ".bicepparam"] },
   { slug: "bibtex", extensions: [".bib", ".bibtex"] },
+  { slug: "bicep", extensions: [".bicep", ".bicepparam"] },
   { slug: "blade", extensions: [".blade.php"] },
   { slug: "bosque", extensions: [".bsq"] },
   { slug: "bqn", extensions: [".bqn"] },
@@ -16845,8 +17476,8 @@ var languageIndex = [
   { slug: "coldfusion", extensions: [".cfm", ".cfml", ".cfc"] },
   { slug: "coq", extensions: [".v"] },
   { slug: "cpp", extensions: [".cpp", ".cc", ".cxx", ".h", ".hpp", ".hh", ".hxx"] },
-  { slug: "crystal", extensions: [".cr"] },
   { slug: "cql", extensions: [".cql"] },
+  { slug: "crystal", extensions: [".cr"] },
   { slug: "csharp", extensions: [".cs", ".csx"] },
   { slug: "css", extensions: [".css"] },
   { slug: "cuda", extensions: [".cu", ".cuh"] },
@@ -16868,6 +17499,7 @@ var languageIndex = [
   { slug: "ejs", extensions: [".ejs"] },
   { slug: "elixir", extensions: [".ex", ".exs", ".eex", ".leex", ".heex"] },
   { slug: "elm", extensions: [".elm"] },
+  { slug: "emacs-lisp", extensions: [".el"] },
   { slug: "erb", extensions: [".erb", ".rhtml", ".html.erb"] },
   {
     slug: "erlang",
@@ -16884,20 +17516,20 @@ var languageIndex = [
     slug: "fortran",
     extensions: [".f", ".for", ".ftn", ".f90", ".f95", ".f03", ".f08", ".f18", ".f23"]
   },
-  { slug: "freemarker", extensions: [".ftl", ".ftlh", ".ftlx"] },
   { slug: "fql", extensions: [".fql"] },
+  { slug: "freemarker", extensions: [".ftl", ".ftlh", ".ftlx"] },
   { slug: "fsharp", extensions: [".fs", ".fsi", ".fsx", ".fsscript"] },
   { slug: "fstar", extensions: [".fst", ".fsti"] },
-  { slug: "gdscript", extensions: [".gd"] },
   { slug: "gcode", extensions: [".gcode", ".gco", ".nc", ".cnc", ".tap"] },
+  { slug: "gdscript", extensions: [".gd"] },
   { slug: "gettext", extensions: [".po", ".pot"] },
   { slug: "git", extensions: [".git", ".gitignore", ".gitattributes", ".gitmodules", ".gitkeep"] },
   { slug: "gleam", extensions: [".gleam"] },
-  { slug: "gml", extensions: [".gml"] },
   {
     slug: "glsl",
     extensions: [".glsl", ".vert", ".frag", ".geom", ".tesc", ".tese", ".comp", ".vs", ".fs"]
   },
+  { slug: "gml", extensions: [".gml"] },
   { slug: "go", extensions: [".go"] },
   { slug: "gradle", extensions: [".gradle", ".gradle.kts"] },
   { slug: "grain", extensions: [".gr"] },
@@ -16924,8 +17556,10 @@ var languageIndex = [
   { slug: "janet", extensions: [".janet", ".jdn"] },
   { slug: "java", extensions: [".java"] },
   { slug: "javascript", extensions: [".js", ".mjs", ".cjs", ".jsx"] },
+  { slug: "jcl", extensions: [".jcl"] },
   { slug: "jinja", extensions: [".jinja", ".jinja2", ".j2"] },
   { slug: "jmespath", extensions: [".jmespath", ".jp"] },
+  { slug: "jq", extensions: [".jq"] },
   { slug: "json", extensions: [".json"] },
   { slug: "json5", extensions: [".json5"] },
   { slug: "jsonata", extensions: [".jsonata"] },
@@ -16941,9 +17575,10 @@ var languageIndex = [
   { slug: "kql", extensions: [".kql"] },
   { slug: "lean", extensions: [".lean"] },
   { slug: "less", extensions: [".less"] },
+  { slug: "lex", extensions: [".l", ".lex"] },
   { slug: "ligo", extensions: [".ligo", ".mligo", ".religo", ".jsligo"] },
-  { slug: "liquid", extensions: [".liquid"] },
   { slug: "linkerscript", extensions: [".ld", ".lds", ".x"] },
+  { slug: "liquid", extensions: [".liquid"] },
   { slug: "lisp", extensions: [".lisp", ".lsp", ".cl", ".asd"] },
   { slug: "llvm-ir", extensions: [".ll", ".bc"] },
   { slug: "lobster", extensions: [".lobster"] },
@@ -16958,13 +17593,13 @@ var languageIndex = [
   { slug: "matlab", extensions: [".m", ".mlx"] },
   { slug: "maxima", extensions: [".mac", ".wxm"] },
   { slug: "mdx", extensions: [".mdx"] },
+  { slug: "mercury", extensions: [".m"] },
   { slug: "mermaid", extensions: [".mmd", ".mermaid"] },
   { slug: "meson", extensions: ["meson.build", "meson_options.txt", "meson.options", ".wrap"] },
-  { slug: "mercury", extensions: [".m"] },
   { slug: "metal", extensions: [".metal"] },
   { slug: "modelica", extensions: [".mo"] },
-  { slug: "mojo", extensions: [".mojo"] },
   { slug: "modula-2", extensions: [".mod", ".def"] },
+  { slug: "mojo", extensions: [".mojo"] },
   { slug: "moonbit", extensions: [".mbt"] },
   { slug: "move", extensions: [".move"] },
   { slug: "mumps", extensions: [".mac", ".int", ".ro", ".mro"] },
@@ -16977,10 +17612,10 @@ var languageIndex = [
   { slug: "nix", extensions: [".nix"] },
   { slug: "nunjucks", extensions: [".njk", ".nunjucks"] },
   { slug: "nushell", extensions: [".nu"] },
+  { slug: "oberon", extensions: [".ob", ".mod"] },
   { slug: "objective-c", extensions: [".m", ".mm"] },
   { slug: "ocaml", extensions: [".ml", ".mli", ".mll", ".mly", ".mlt", ".eliom", ".eliomi"] },
   { slug: "octave", extensions: [".m", ".octave"] },
-  { slug: "oberon", extensions: [".ob", ".mod"] },
   { slug: "odin", extensions: [".odin"] },
   { slug: "openapi", extensions: [".openapi.json", ".openapi.yaml", ".openapi.yml"] },
   { slug: "opencl", extensions: [".cl", ".clh"] },
@@ -16990,8 +17625,8 @@ var languageIndex = [
   { slug: "perl", extensions: [".pl", ".pm", ".pod", ".t", ".psgi"] },
   { slug: "php", extensions: [".php", ".phtml", ".php3", ".php4", ".php5", ".phps"] },
   { slug: "pine-script", extensions: [".pine"] },
-  { slug: "pl-i", extensions: [".pli", ".pl1"] },
   { slug: "pkl", extensions: [".pkl"] },
+  { slug: "pl-i", extensions: [".pli", ".pl1"] },
   { slug: "plantuml", extensions: [".puml", ".plantuml", ".iuml"] },
   { slug: "plpgsql", extensions: [".pgsql", ".plpgsql"] },
   { slug: "plsql", extensions: [".pls", ".pks", ".pkb", ".plsql"] },
@@ -17003,24 +17638,26 @@ var languageIndex = [
   { slug: "processing", extensions: [".pde"] },
   { slug: "prolog", extensions: [".pl", ".pro", ".prolog", ".P"] },
   { slug: "promql", extensions: [".promql"] },
+  { slug: "properties", extensions: [".properties"] },
   { slug: "protobuf", extensions: [".proto"] },
   { slug: "pug", extensions: [".pug", ".jade"] },
   { slug: "puppet", extensions: [".pp", ".epp"] },
   { slug: "purescript", extensions: [".purs"] },
   { slug: "python", extensions: [".py", ".pyw"] },
-  { slug: "qml", extensions: [".qml", ".qmltypes", ".qmlproject"] },
   { slug: "qmake", extensions: [".pri", ".prf"] },
+  { slug: "qml", extensions: [".qml", ".qmltypes", ".qmlproject"] },
   { slug: "qsharp", extensions: [".qs"] },
   { slug: "r", extensions: [".r", ".R", ".rmd", ".Rmd", ".qmd", ".Rprofile"] },
   { slug: "racket", extensions: [".rkt", ".rktd", ".rktl", ".scrbl"] },
   { slug: "raku", extensions: [".raku", ".rakumod", ".rakudoc", ".rakutest", ".p6", ".pm6"] },
   { slug: "razor", extensions: [".cshtml", ".razor"] },
+  { slug: "reasonml", extensions: [".re", ".rei"] },
   { slug: "rebol", extensions: [".r", ".reb", ".rebol"] },
   { slug: "red", extensions: [".red", ".reds"] },
-  { slug: "reasonml", extensions: [".re", ".rei"] },
   { slug: "rego", extensions: [".rego"] },
   { slug: "rescript", extensions: [".res", ".resi"] },
   { slug: "restructuredtext", extensions: [".rst", ".rest"] },
+  { slug: "rexx", extensions: [".rexx", ".rex"] },
   { slug: "roc", extensions: [".roc"] },
   { slug: "rpg", extensions: [".rpg", ".rpgle", ".sqlrpgle", ".clle", ".dspf"] },
   {
@@ -17040,8 +17677,8 @@ var languageIndex = [
   { slug: "snobol", extensions: [".sno", ".snobol"] },
   { slug: "solidity", extensions: [".sol"] },
   { slug: "soql", extensions: [".soql"] },
-  { slug: "sparql", extensions: [".sparql", ".rq"] },
   { slug: "spark", extensions: [".spark", ".adb", ".ads"] },
+  { slug: "sparql", extensions: [".sparql", ".rq"] },
   { slug: "spl", extensions: [".spl"] },
   { slug: "spss", extensions: [".sps", ".spss"] },
   { slug: "sql", extensions: [".sql"] },
@@ -17070,17 +17707,19 @@ var languageIndex = [
   { slug: "unison", extensions: [".u", ".uu"] },
   { slug: "v", extensions: [".v", ".vsh"] },
   { slug: "vala", extensions: [".vala", ".vapi"] },
-  { slug: "vba", extensions: [".bas", ".cls", ".frm", ".vba"] },
   { slug: "vale", extensions: [".vale"] },
+  { slug: "vba", extensions: [".bas", ".cls", ".frm", ".vba"] },
+  { slug: "vbscript", extensions: [".vbs", ".vbe"] },
   { slug: "velocity", extensions: [".vm", ".vtl"] },
   { slug: "verilog", extensions: [".v", ".vh", ".sv", ".svh"] },
   { slug: "verse", extensions: [".verse"] },
   { slug: "vhdl", extensions: [".vhd", ".vhdl"] },
+  { slug: "vimscript", extensions: [".vim", ".vimrc", ".gvimrc"] },
   { slug: "visual-basic", extensions: [".vb"] },
   { slug: "vue", extensions: [".vue"] },
   { slug: "vyper", extensions: [".vy"] },
-  { slug: "webassembly", extensions: [".wasm", ".wat"] },
   { slug: "wdl", extensions: [".wdl"] },
+  { slug: "webassembly", extensions: [".wasm", ".wat"] },
   { slug: "wgsl", extensions: [".wgsl"] },
   { slug: "wren", extensions: [".wren"] },
   { slug: "xaml", extensions: [".xaml", ".baml"] },
@@ -17088,6 +17727,7 @@ var languageIndex = [
   { slug: "xpath", extensions: [".xpath", ".xpth"] },
   { slug: "xquery", extensions: [".xq", ".xql", ".xqm", ".xquery", ".xqy"] },
   { slug: "xslt", extensions: [".xsl", ".xslt"] },
+  { slug: "yacc", extensions: [".y", ".yacc"] },
   { slug: "yaml", extensions: [".yaml", ".yml"] },
   { slug: "yara", extensions: [".yar", ".yara"] },
   { slug: "zeek", extensions: [".zeek", ".bro"] },
@@ -17105,31 +17745,31 @@ var languageLoaders = {
   agda: async () => (await Promise.resolve().then(() => (init_agda(), agda_exports))).agda,
   algol: async () => (await Promise.resolve().then(() => (init_algol(), algol_exports))).algol,
   ampl: async () => (await Promise.resolve().then(() => (init_ampl(), ampl_exports))).ampl,
+  angelscript: async () => (await Promise.resolve().then(() => (init_angelscript(), angelscript_exports))).angelscript,
   ante: async () => (await Promise.resolve().then(() => (init_ante(), ante_exports))).ante,
   antlr: async () => (await Promise.resolve().then(() => (init_antlr(), antlr_exports))).antlr,
   apex: async () => (await Promise.resolve().then(() => (init_apex(), apex_exports))).apex,
   apl: async () => (await Promise.resolve().then(() => (init_apl(), apl_exports))).apl,
   applescript: async () => (await Promise.resolve().then(() => (init_applescript(), applescript_exports))).applescript,
-  arduino: async () => (await Promise.resolve().then(() => (init_arduino(), arduino_exports))).arduino,
   aql: async () => (await Promise.resolve().then(() => (init_aql(), aql_exports))).aql,
+  arduino: async () => (await Promise.resolve().then(() => (init_arduino(), arduino_exports))).arduino,
   asciidoc: async () => (await Promise.resolve().then(() => (init_asciidoc(), asciidoc_exports))).asciidoc,
   asp: async () => (await Promise.resolve().then(() => (init_asp(), asp_exports))).asp,
   assembly: async () => (await Promise.resolve().then(() => (init_assembly(), assembly_exports))).assembly,
   assemblyscript: async () => (await Promise.resolve().then(() => (init_assemblyscript(), assemblyscript_exports))).assemblyscript,
-  angelscript: async () => (await Promise.resolve().then(() => (init_angelscript(), angelscript_exports))).angelscript,
   astro: async () => (await Promise.resolve().then(() => (init_astro(), astro_exports))).astro,
   austral: async () => (await Promise.resolve().then(() => (init_austral(), austral_exports))).austral,
   autohotkey: async () => (await Promise.resolve().then(() => (init_autohotkey(), autohotkey_exports))).autohotkey,
   "avro-idl": async () => (await Promise.resolve().then(() => (init_avro_idl(), avro_idl_exports))).avroIdl,
   awk: async () => (await Promise.resolve().then(() => (init_awk(), awk_exports))).awk,
   ballerina: async () => (await Promise.resolve().then(() => (init_ballerina(), ballerina_exports))).ballerina,
-  basic: async () => (await Promise.resolve().then(() => (init_basic(), basic_exports))).basic,
   bash: async () => (await Promise.resolve().then(() => (init_bash(), bash_exports))).bash,
+  basic: async () => (await Promise.resolve().then(() => (init_basic(), basic_exports))).basic,
   batch: async () => (await Promise.resolve().then(() => (init_batch(), batch_exports))).batch,
   bazel: async () => (await Promise.resolve().then(() => (init_bazel(), bazel_exports))).bazel,
   bcpl: async () => (await Promise.resolve().then(() => (init_bcpl(), bcpl_exports))).bcpl,
-  bicep: async () => (await Promise.resolve().then(() => (init_bicep(), bicep_exports))).bicep,
   bibtex: async () => (await Promise.resolve().then(() => (init_bibtex(), bibtex_exports))).bibtex,
+  bicep: async () => (await Promise.resolve().then(() => (init_bicep(), bicep_exports))).bicep,
   blade: async () => (await Promise.resolve().then(() => (init_blade(), blade_exports))).blade,
   bosque: async () => (await Promise.resolve().then(() => (init_bosque(), bosque_exports))).bosque,
   bqn: async () => (await Promise.resolve().then(() => (init_bqn(), bqn_exports))).bqn,
@@ -17148,8 +17788,8 @@ var languageLoaders = {
   coldfusion: async () => (await Promise.resolve().then(() => (init_coldfusion(), coldfusion_exports))).coldfusion,
   coq: async () => (await Promise.resolve().then(() => (init_coq(), coq_exports))).coq,
   cpp: async () => (await Promise.resolve().then(() => (init_cpp(), cpp_exports))).cpp,
-  crystal: async () => (await Promise.resolve().then(() => (init_crystal(), crystal_exports))).crystal,
   cql: async () => (await Promise.resolve().then(() => (init_cql(), cql_exports))).cql,
+  crystal: async () => (await Promise.resolve().then(() => (init_crystal(), crystal_exports))).crystal,
   csharp: async () => (await Promise.resolve().then(() => (init_csharp(), csharp_exports))).csharp,
   css: async () => (await Promise.resolve().then(() => (init_css(), css_exports))).css,
   cuda: async () => (await Promise.resolve().then(() => (init_cuda(), cuda_exports))).cuda,
@@ -17171,6 +17811,7 @@ var languageLoaders = {
   ejs: async () => (await Promise.resolve().then(() => (init_ejs(), ejs_exports))).ejs,
   elixir: async () => (await Promise.resolve().then(() => (init_elixir(), elixir_exports))).elixir,
   elm: async () => (await Promise.resolve().then(() => (init_elm(), elm_exports))).elm,
+  "emacs-lisp": async () => (await Promise.resolve().then(() => (init_emacs_lisp(), emacs_lisp_exports))).emacsLisp,
   erb: async () => (await Promise.resolve().then(() => (init_erb(), erb_exports))).erb,
   erlang: async () => (await Promise.resolve().then(() => (init_erlang(), erlang_exports))).erlang,
   factor: async () => (await Promise.resolve().then(() => (init_factor(), factor_exports))).factor,
@@ -17181,17 +17822,17 @@ var languageLoaders = {
   flux: async () => (await Promise.resolve().then(() => (init_flux(), flux_exports))).flux,
   forth: async () => (await Promise.resolve().then(() => (init_forth(), forth_exports))).forth,
   fortran: async () => (await Promise.resolve().then(() => (init_fortran(), fortran_exports))).fortran,
-  freemarker: async () => (await Promise.resolve().then(() => (init_freemarker(), freemarker_exports))).freemarker,
   fql: async () => (await Promise.resolve().then(() => (init_fql(), fql_exports))).fql,
+  freemarker: async () => (await Promise.resolve().then(() => (init_freemarker(), freemarker_exports))).freemarker,
   fsharp: async () => (await Promise.resolve().then(() => (init_fsharp(), fsharp_exports))).fsharp,
   fstar: async () => (await Promise.resolve().then(() => (init_fstar(), fstar_exports))).fstar,
-  gdscript: async () => (await Promise.resolve().then(() => (init_gdscript(), gdscript_exports))).gdscript,
   gcode: async () => (await Promise.resolve().then(() => (init_gcode(), gcode_exports))).gcode,
+  gdscript: async () => (await Promise.resolve().then(() => (init_gdscript(), gdscript_exports))).gdscript,
   gettext: async () => (await Promise.resolve().then(() => (init_gettext(), gettext_exports))).gettext,
   git: async () => (await Promise.resolve().then(() => (init_git(), git_exports))).git,
   gleam: async () => (await Promise.resolve().then(() => (init_gleam(), gleam_exports))).gleam,
-  gml: async () => (await Promise.resolve().then(() => (init_gml(), gml_exports))).gml,
   glsl: async () => (await Promise.resolve().then(() => (init_glsl(), glsl_exports))).glsl,
+  gml: async () => (await Promise.resolve().then(() => (init_gml(), gml_exports))).gml,
   go: async () => (await Promise.resolve().then(() => (init_go(), go_exports))).go,
   gradle: async () => (await Promise.resolve().then(() => (init_gradle(), gradle_exports))).gradle,
   grain: async () => (await Promise.resolve().then(() => (init_grain(), grain_exports))).grain,
@@ -17218,8 +17859,10 @@ var languageLoaders = {
   janet: async () => (await Promise.resolve().then(() => (init_janet(), janet_exports))).janet,
   java: async () => (await Promise.resolve().then(() => (init_java(), java_exports))).java,
   javascript: async () => (await Promise.resolve().then(() => (init_javascript(), javascript_exports))).javascript,
+  jcl: async () => (await Promise.resolve().then(() => (init_jcl(), jcl_exports))).jcl,
   jinja: async () => (await Promise.resolve().then(() => (init_jinja(), jinja_exports))).jinja,
   jmespath: async () => (await Promise.resolve().then(() => (init_jmespath(), jmespath_exports))).jmespath,
+  jq: async () => (await Promise.resolve().then(() => (init_jq(), jq_exports))).jq,
   json: async () => (await Promise.resolve().then(() => (init_json(), json_exports))).json,
   json5: async () => (await Promise.resolve().then(() => (init_json5(), json5_exports))).json5,
   jsonata: async () => (await Promise.resolve().then(() => (init_jsonata(), jsonata_exports))).jsonata,
@@ -17235,9 +17878,10 @@ var languageLoaders = {
   kql: async () => (await Promise.resolve().then(() => (init_kql(), kql_exports))).kql,
   lean: async () => (await Promise.resolve().then(() => (init_lean(), lean_exports))).lean,
   less: async () => (await Promise.resolve().then(() => (init_less(), less_exports))).less,
+  lex: async () => (await Promise.resolve().then(() => (init_lex(), lex_exports))).lex,
   ligo: async () => (await Promise.resolve().then(() => (init_ligo(), ligo_exports))).ligo,
-  liquid: async () => (await Promise.resolve().then(() => (init_liquid(), liquid_exports))).liquid,
   linkerscript: async () => (await Promise.resolve().then(() => (init_linkerscript(), linkerscript_exports))).linkerscript,
+  liquid: async () => (await Promise.resolve().then(() => (init_liquid(), liquid_exports))).liquid,
   lisp: async () => (await Promise.resolve().then(() => (init_lisp(), lisp_exports))).lisp,
   "llvm-ir": async () => (await Promise.resolve().then(() => (init_llvm_ir(), llvm_ir_exports))).llvmIr,
   lobster: async () => (await Promise.resolve().then(() => (init_lobster(), lobster_exports))).lobster,
@@ -17252,13 +17896,13 @@ var languageLoaders = {
   matlab: async () => (await Promise.resolve().then(() => (init_matlab(), matlab_exports))).matlab,
   maxima: async () => (await Promise.resolve().then(() => (init_maxima(), maxima_exports))).maxima,
   mdx: async () => (await Promise.resolve().then(() => (init_mdx(), mdx_exports))).mdx,
+  mercury: async () => (await Promise.resolve().then(() => (init_mercury(), mercury_exports))).mercury,
   mermaid: async () => (await Promise.resolve().then(() => (init_mermaid(), mermaid_exports))).mermaid,
   meson: async () => (await Promise.resolve().then(() => (init_meson(), meson_exports))).meson,
-  mercury: async () => (await Promise.resolve().then(() => (init_mercury(), mercury_exports))).mercury,
   metal: async () => (await Promise.resolve().then(() => (init_metal(), metal_exports))).metal,
   modelica: async () => (await Promise.resolve().then(() => (init_modelica(), modelica_exports))).modelica,
-  mojo: async () => (await Promise.resolve().then(() => (init_mojo(), mojo_exports))).mojo,
   "modula-2": async () => (await Promise.resolve().then(() => (init_modula_2(), modula_2_exports))).modula2,
+  mojo: async () => (await Promise.resolve().then(() => (init_mojo(), mojo_exports))).mojo,
   moonbit: async () => (await Promise.resolve().then(() => (init_moonbit(), moonbit_exports))).moonbit,
   move: async () => (await Promise.resolve().then(() => (init_move(), move_exports))).move,
   mumps: async () => (await Promise.resolve().then(() => (init_mumps(), mumps_exports))).mumps,
@@ -17271,10 +17915,10 @@ var languageLoaders = {
   nix: async () => (await Promise.resolve().then(() => (init_nix(), nix_exports))).nix,
   nunjucks: async () => (await Promise.resolve().then(() => (init_nunjucks(), nunjucks_exports))).nunjucks,
   nushell: async () => (await Promise.resolve().then(() => (init_nushell(), nushell_exports))).nushell,
+  oberon: async () => (await Promise.resolve().then(() => (init_oberon(), oberon_exports))).oberon,
   "objective-c": async () => (await Promise.resolve().then(() => (init_objective_c(), objective_c_exports))).objectiveC,
   ocaml: async () => (await Promise.resolve().then(() => (init_ocaml(), ocaml_exports))).ocaml,
   octave: async () => (await Promise.resolve().then(() => (init_octave(), octave_exports))).octave,
-  oberon: async () => (await Promise.resolve().then(() => (init_oberon(), oberon_exports))).oberon,
   odin: async () => (await Promise.resolve().then(() => (init_odin(), odin_exports))).odin,
   openapi: async () => (await Promise.resolve().then(() => (init_openapi(), openapi_exports))).openapi,
   opencl: async () => (await Promise.resolve().then(() => (init_opencl(), opencl_exports))).opencl,
@@ -17284,8 +17928,8 @@ var languageLoaders = {
   perl: async () => (await Promise.resolve().then(() => (init_perl(), perl_exports))).perl,
   php: async () => (await Promise.resolve().then(() => (init_php(), php_exports))).php,
   "pine-script": async () => (await Promise.resolve().then(() => (init_pine_script(), pine_script_exports))).pineScript,
-  "pl-i": async () => (await Promise.resolve().then(() => (init_pl_i(), pl_i_exports))).plI,
   pkl: async () => (await Promise.resolve().then(() => (init_pkl(), pkl_exports))).pkl,
+  "pl-i": async () => (await Promise.resolve().then(() => (init_pl_i(), pl_i_exports))).plI,
   plantuml: async () => (await Promise.resolve().then(() => (init_plantuml(), plantuml_exports))).plantuml,
   plpgsql: async () => (await Promise.resolve().then(() => (init_plpgsql(), plpgsql_exports))).plpgsql,
   plsql: async () => (await Promise.resolve().then(() => (init_plsql(), plsql_exports))).plsql,
@@ -17297,24 +17941,26 @@ var languageLoaders = {
   processing: async () => (await Promise.resolve().then(() => (init_processing(), processing_exports))).processing,
   prolog: async () => (await Promise.resolve().then(() => (init_prolog(), prolog_exports))).prolog,
   promql: async () => (await Promise.resolve().then(() => (init_promql(), promql_exports))).promql,
+  properties: async () => (await Promise.resolve().then(() => (init_properties(), properties_exports))).properties,
   protobuf: async () => (await Promise.resolve().then(() => (init_protobuf(), protobuf_exports))).protobuf,
   pug: async () => (await Promise.resolve().then(() => (init_pug(), pug_exports))).pug,
   puppet: async () => (await Promise.resolve().then(() => (init_puppet(), puppet_exports))).puppet,
   purescript: async () => (await Promise.resolve().then(() => (init_purescript(), purescript_exports))).purescript,
   python: async () => (await Promise.resolve().then(() => (init_python(), python_exports))).python,
-  qml: async () => (await Promise.resolve().then(() => (init_qml(), qml_exports))).qml,
   qmake: async () => (await Promise.resolve().then(() => (init_qmake(), qmake_exports))).qmake,
+  qml: async () => (await Promise.resolve().then(() => (init_qml(), qml_exports))).qml,
   qsharp: async () => (await Promise.resolve().then(() => (init_qsharp(), qsharp_exports))).qsharp,
   r: async () => (await Promise.resolve().then(() => (init_r(), r_exports))).r,
   racket: async () => (await Promise.resolve().then(() => (init_racket(), racket_exports))).racket,
   raku: async () => (await Promise.resolve().then(() => (init_raku(), raku_exports))).raku,
   razor: async () => (await Promise.resolve().then(() => (init_razor(), razor_exports))).razor,
+  reasonml: async () => (await Promise.resolve().then(() => (init_reasonml(), reasonml_exports))).reasonml,
   rebol: async () => (await Promise.resolve().then(() => (init_rebol(), rebol_exports))).rebol,
   red: async () => (await Promise.resolve().then(() => (init_red(), red_exports))).red,
-  reasonml: async () => (await Promise.resolve().then(() => (init_reasonml(), reasonml_exports))).reasonml,
   rego: async () => (await Promise.resolve().then(() => (init_rego(), rego_exports))).rego,
   rescript: async () => (await Promise.resolve().then(() => (init_rescript(), rescript_exports))).rescript,
   restructuredtext: async () => (await Promise.resolve().then(() => (init_restructuredtext(), restructuredtext_exports))).restructuredtext,
+  rexx: async () => (await Promise.resolve().then(() => (init_rexx(), rexx_exports))).rexx,
   roc: async () => (await Promise.resolve().then(() => (init_roc(), roc_exports))).roc,
   rpg: async () => (await Promise.resolve().then(() => (init_rpg(), rpg_exports))).rpg,
   ruby: async () => (await Promise.resolve().then(() => (init_ruby(), ruby_exports))).ruby,
@@ -17331,8 +17977,8 @@ var languageLoaders = {
   snobol: async () => (await Promise.resolve().then(() => (init_snobol(), snobol_exports))).snobol,
   solidity: async () => (await Promise.resolve().then(() => (init_solidity(), solidity_exports))).solidity,
   soql: async () => (await Promise.resolve().then(() => (init_soql(), soql_exports))).soql,
-  sparql: async () => (await Promise.resolve().then(() => (init_sparql(), sparql_exports))).sparql,
   spark: async () => (await Promise.resolve().then(() => (init_spark(), spark_exports))).spark,
+  sparql: async () => (await Promise.resolve().then(() => (init_sparql(), sparql_exports))).sparql,
   spl: async () => (await Promise.resolve().then(() => (init_spl(), spl_exports))).spl,
   spss: async () => (await Promise.resolve().then(() => (init_spss(), spss_exports))).spss,
   sql: async () => (await Promise.resolve().then(() => (init_sql(), sql_exports))).sql,
@@ -17361,17 +18007,19 @@ var languageLoaders = {
   unison: async () => (await Promise.resolve().then(() => (init_unison(), unison_exports))).unison,
   v: async () => (await Promise.resolve().then(() => (init_v(), v_exports))).v,
   vala: async () => (await Promise.resolve().then(() => (init_vala(), vala_exports))).vala,
-  vba: async () => (await Promise.resolve().then(() => (init_vba(), vba_exports))).vba,
   vale: async () => (await Promise.resolve().then(() => (init_vale(), vale_exports))).vale,
+  vba: async () => (await Promise.resolve().then(() => (init_vba(), vba_exports))).vba,
+  vbscript: async () => (await Promise.resolve().then(() => (init_vbscript(), vbscript_exports))).vbscript,
   velocity: async () => (await Promise.resolve().then(() => (init_velocity(), velocity_exports))).velocity,
   verilog: async () => (await Promise.resolve().then(() => (init_verilog(), verilog_exports))).verilog,
   verse: async () => (await Promise.resolve().then(() => (init_verse(), verse_exports))).verse,
   vhdl: async () => (await Promise.resolve().then(() => (init_vhdl(), vhdl_exports))).vhdl,
+  vimscript: async () => (await Promise.resolve().then(() => (init_vimscript(), vimscript_exports))).vimscript,
   "visual-basic": async () => (await Promise.resolve().then(() => (init_visual_basic(), visual_basic_exports))).visualBasic,
   vue: async () => (await Promise.resolve().then(() => (init_vue(), vue_exports))).vue,
   vyper: async () => (await Promise.resolve().then(() => (init_vyper(), vyper_exports))).vyper,
-  webassembly: async () => (await Promise.resolve().then(() => (init_webassembly(), webassembly_exports))).webassembly,
   wdl: async () => (await Promise.resolve().then(() => (init_wdl(), wdl_exports))).wdl,
+  webassembly: async () => (await Promise.resolve().then(() => (init_webassembly(), webassembly_exports))).webassembly,
   wgsl: async () => (await Promise.resolve().then(() => (init_wgsl(), wgsl_exports))).wgsl,
   wren: async () => (await Promise.resolve().then(() => (init_wren(), wren_exports))).wren,
   xaml: async () => (await Promise.resolve().then(() => (init_xaml(), xaml_exports))).xaml,
@@ -17379,6 +18027,7 @@ var languageLoaders = {
   xpath: async () => (await Promise.resolve().then(() => (init_xpath(), xpath_exports))).xpath,
   xquery: async () => (await Promise.resolve().then(() => (init_xquery(), xquery_exports))).xquery,
   xslt: async () => (await Promise.resolve().then(() => (init_xslt(), xslt_exports))).xslt,
+  yacc: async () => (await Promise.resolve().then(() => (init_yacc(), yacc_exports))).yacc,
   yaml: async () => (await Promise.resolve().then(() => (init_yaml(), yaml_exports))).yaml,
   yara: async () => (await Promise.resolve().then(() => (init_yara(), yara_exports))).yara,
   zeek: async () => (await Promise.resolve().then(() => (init_zeek(), zeek_exports))).zeek,
@@ -17388,33 +18037,6 @@ var languageLoaders = {
 };
 var loadLanguage = (slug) => languageLoaders[slug]?.();
 
-// src/domain/detection/match.ts
-var pathSegmentPattern = /[/\\]/;
-var getBasename = (filename) => {
-  const parts = filename.trim().split(pathSegmentPattern);
-  return parts.at(-1).toLowerCase();
-};
-var matchesExtension = (basename, extension) => {
-  const normalizedExtension = extension.toLowerCase();
-  if (normalizedExtension.startsWith(".")) {
-    return basename.endsWith(normalizedExtension);
-  }
-  return basename === normalizedExtension || basename.endsWith(`.${normalizedExtension}`);
-};
-var detectMatchingEntries = (entries, filename) => {
-  const basename = getBasename(filename);
-  if (!basename) {
-    return [];
-  }
-  return entries.map((entry, index) => ({
-    entry,
-    index,
-    matchLength: Math.max(
-      ...entry.extensions.filter((extension) => matchesExtension(basename, extension)).map((extension) => extension.length)
-    )
-  })).filter(({ matchLength }) => Number.isFinite(matchLength)).sort((first, second) => second.matchLength - first.matchLength || first.index - second.index).map(({ entry }) => entry);
-};
-
 // src/domain/detection/detect-slugs.ts
 var detectLanguageSlugs = (filename) => detectMatchingEntries(languageIndex, filename).map((entry) => entry.slug);
 var detectLanguageSlug = (filename) => detectLanguageSlugs(filename).at(0);
@@ -17800,6 +18422,7 @@ init_eiffel();
 init_ejs();
 init_elixir();
 init_elm();
+init_emacs_lisp();
 init_erb();
 init_erlang();
 init_factor();
@@ -17847,8 +18470,10 @@ init_isabelle();
 init_janet();
 init_java();
 init_javascript();
+init_jcl();
 init_jinja();
 init_jmespath();
+init_jq();
 init_json();
 init_json5();
 init_jsonata();
@@ -17864,6 +18489,7 @@ init_kotlin();
 init_kql();
 init_lean();
 init_less();
+init_lex();
 init_ligo();
 init_linkerscript();
 init_liquid();
@@ -17926,6 +18552,7 @@ init_powershell();
 init_processing();
 init_prolog();
 init_promql();
+init_properties();
 init_protobuf();
 init_pug();
 init_puppet();
@@ -17944,6 +18571,7 @@ init_red();
 init_rego();
 init_rescript();
 init_restructuredtext();
+init_rexx();
 init_roc();
 init_rpg();
 init_ruby();
@@ -17992,10 +18620,12 @@ init_v();
 init_vala();
 init_vale();
 init_vba();
+init_vbscript();
 init_velocity();
 init_verilog();
 init_verse();
 init_vhdl();
+init_vimscript();
 init_visual_basic();
 init_vue();
 init_vyper();
@@ -18008,6 +18638,7 @@ init_xml();
 init_xpath();
 init_xquery();
 init_xslt();
+init_yacc();
 init_yaml();
 init_yara();
 init_zeek();
@@ -18021,31 +18652,31 @@ var languages = [
   agda,
   algol,
   ampl,
+  angelscript,
   ante,
   antlr,
   apex,
   apl,
   applescript,
-  arduino,
   aql,
+  arduino,
   asciidoc,
   asp,
   assembly,
   assemblyscript,
-  angelscript,
   astro,
   austral,
   autohotkey,
   avroIdl,
   awk,
   ballerina,
-  basic,
   bash,
+  basic,
   batch,
   bazel,
   bcpl,
-  bicep,
   bibtex,
+  bicep,
   blade,
   bosque,
   bqn,
@@ -18064,8 +18695,8 @@ var languages = [
   coldfusion,
   coq,
   cpp,
-  crystal,
   cql,
+  crystal,
   csharp,
   css,
   cuda,
@@ -18087,6 +18718,7 @@ var languages = [
   ejs,
   elixir,
   elm,
+  emacsLisp,
   erb,
   erlang,
   factor,
@@ -18097,17 +18729,17 @@ var languages = [
   flux,
   forth,
   fortran,
-  freemarker,
   fql,
+  freemarker,
   fsharp,
   fstar,
-  gdscript,
   gcode,
+  gdscript,
   gettext,
   git,
   gleam,
-  gml,
   glsl,
+  gml,
   go,
   gradle,
   grain,
@@ -18134,8 +18766,10 @@ var languages = [
   janet,
   java,
   javascript,
+  jcl,
   jinja,
   jmespath,
+  jq,
   json,
   json5,
   jsonata,
@@ -18151,9 +18785,10 @@ var languages = [
   kql,
   lean,
   less,
+  lex,
   ligo,
-  liquid,
   linkerscript,
+  liquid,
   lisp,
   llvmIr,
   lobster,
@@ -18168,13 +18803,13 @@ var languages = [
   matlab,
   maxima,
   mdx,
+  mercury,
   mermaid,
   meson,
-  mercury,
   metal,
   modelica,
-  mojo,
   modula2,
+  mojo,
   moonbit,
   move,
   mumps,
@@ -18187,10 +18822,10 @@ var languages = [
   nix,
   nunjucks,
   nushell,
+  oberon,
   objectiveC,
   ocaml,
   octave,
-  oberon,
   odin,
   openapi,
   opencl,
@@ -18200,8 +18835,8 @@ var languages = [
   perl,
   php,
   pineScript,
-  plI,
   pkl,
+  plI,
   plantuml,
   plpgsql,
   plsql,
@@ -18213,24 +18848,26 @@ var languages = [
   processing,
   prolog,
   promql,
+  properties,
   protobuf,
   pug,
   puppet,
   purescript,
   python,
-  qml,
   qmake,
+  qml,
   qsharp,
   r,
   racket,
   raku,
   razor,
+  reasonml,
   rebol,
   red,
-  reasonml,
   rego,
   rescript,
   restructuredtext,
+  rexx,
   roc,
   rpg,
   ruby,
@@ -18247,8 +18884,8 @@ var languages = [
   snobol,
   solidity,
   soql,
-  sparql,
   spark,
+  sparql,
   spl,
   spss,
   sql,
@@ -18277,17 +18914,19 @@ var languages = [
   unison,
   v,
   vala,
-  vba,
   vale,
+  vba,
+  vbscript,
   velocity,
   verilog,
   verse,
   vhdl,
+  vimscript,
   visualBasic,
   vue,
   vyper,
-  webassembly,
   wdl,
+  webassembly,
   wgsl,
   wren,
   xaml,
@@ -18295,6 +18934,7 @@ var languages = [
   xpath,
   xquery,
   xslt,
+  yacc,
   yaml,
   yara,
   zeek,
@@ -19156,7 +19796,18 @@ function runtimesForPackageManager(targets) {
 // src/api.ts
 var defaultLocale = "en";
 var languageMap = new Map(languages.map((l) => [l.slug, l]));
+var languageAliasMap = /* @__PURE__ */ new Map();
+for (const language of languages) {
+  for (const alias of language.aliases ?? []) {
+    languageAliasMap.set(alias.toLowerCase(), language.slug);
+  }
+}
 var normalizeLanguageSlug = (slug) => slug.trim().toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+var resolveLanguageLookup = (value) => {
+  const raw = value.trim().toLowerCase();
+  const normalized = normalizeLanguageSlug(value);
+  return languageAliasMap.get(raw) ?? languageAliasMap.get(normalized) ?? normalized;
+};
 var localizeOptionalLanguage = (language, locale) => language ? localizeLanguage(language, locale) : void 0;
 var createLanguageRequest = (getLanguage, loadLanguageModule) => {
   let requestedLocale = defaultLocale;
@@ -19191,6 +19842,13 @@ var createLanguageCollectionRequest = (getLanguageList, loadLanguageList) => {
   };
   return request;
 };
+var createFilteredLanguageCollection = (predicate) => {
+  const filtered = () => languages.filter(predicate);
+  return createLanguageCollectionRequest(filtered, async () => {
+    const loaded = await Promise.all(filtered().map((language) => loadLanguage(language.slug)));
+    return loaded.filter((language) => Boolean(language));
+  });
+};
 var loadDetectedLanguages = async (filename) => {
   const detectedLanguages = await Promise.all(
     detectLanguageSlugs(filename).map((slug) => loadLanguage(slug))
@@ -19201,18 +19859,22 @@ var getLanguageBySlug = (slug) => languageMap.get(slug);
 var getDetectedLanguages = (filename) => detectLanguageSlugs(filename).map((slug) => getLanguageBySlug(slug)).filter((language) => Boolean(language));
 var api = {
   /**
-   * Selects a language by slug.
+   * Selects a language by slug or alias.
    *
-   * Input is normalized to the package slug format before lookup.
+   * Input is normalized to the package slug format before lookup, and language
+   * aliases such as `golang`, `C#`, or `wasm` resolve to their catalog slug.
+   * When the slug is a known literal, `get()` and `load()` are typed as
+   * always returning a language.
    *
    * @example
    * api.language("astro").locale("es-PE").get();
+   * api.language("golang").get()?.slug; // "go"
    */
   language(slug) {
-    const normalizedSlug = normalizeLanguageSlug(slug);
+    const resolvedSlug = resolveLanguageLookup(slug);
     return createLanguageRequest(
-      () => languageMap.get(normalizedSlug),
-      () => loadLanguage(normalizedSlug)
+      () => languageMap.get(resolvedSlug),
+      () => loadLanguage(resolvedSlug)
     );
   },
   /**
@@ -19245,6 +19907,30 @@ var api = {
       async () => (await loadDetectedLanguages(filename)).at(0)
     );
   },
+  /**
+   * Selects every language that registers the given file extension or exact filename.
+   *
+   * Accepts values with or without the leading dot: `.ts`, `ts`, or `Dockerfile`.
+   * Unlike `detect`, this matches the extension entry exactly instead of ranking
+   * suffix matches, so `api.extension('.h')` returns both C and C++.
+   *
+   * @example
+   * api.extension('.h').langs().get().map((language) => language.slug); // ["c", "cpp"]
+   * api.extension('ts').langs().locale('es').get();
+   */
+  extension(value) {
+    const normalized = value.trim().toLowerCase();
+    return {
+      langs() {
+        return createFilteredLanguageCollection(
+          (language) => language.extensions.some((extension) => {
+            const normalizedExtension = extension.toLowerCase();
+            return normalizedExtension === normalized || normalizedExtension === `.${normalized}`;
+          })
+        );
+      }
+    };
+  },
   /**
    * Selects every language that runs on or targets the given platform or runtime.
    *
@@ -19263,11 +19949,7 @@ var api = {
         return definition ? runtimeInfoFromDefinition(definition) : void 0;
       },
       langs() {
-        const filtered = () => languages.filter((lang) => matchesRuntime(lang, targets));
-        return createLanguageCollectionRequest(filtered, async () => {
-          const loaded = await Promise.all(filtered().map((lang) => loadLanguage(lang.slug)));
-          return loaded.filter((lang) => Boolean(lang));
-        });
+        return createFilteredLanguageCollection((language) => matchesRuntime(language, targets));
       }
     };
   },
@@ -19289,11 +19971,9 @@ var api = {
         return definition ? packageManagerInfoFromDefinition(definition) : void 0;
       },
       langs() {
-        const filtered = () => languages.filter((lang) => matchesPackageManager(lang, targets));
-        return createLanguageCollectionRequest(filtered, async () => {
-          const loaded = await Promise.all(filtered().map((lang) => loadLanguage(lang.slug)));
-          return loaded.filter((lang) => Boolean(lang));
-        });
+        return createFilteredLanguageCollection(
+          (language) => matchesPackageManager(language, targets)
+        );
       },
       runtimes() {
         return runtimesForPackageManager(targets);
@@ -19321,11 +20001,7 @@ var api = {
   category(value) {
     return {
       langs() {
-        const filtered = () => languages.filter((lang) => matchesCategory(lang, value));
-        return createLanguageCollectionRequest(filtered, async () => {
-          const loaded = await Promise.all(filtered().map((lang) => loadLanguage(lang.slug)));
-          return loaded.filter((lang) => Boolean(lang));
-        });
+        return createFilteredLanguageCollection((language) => matchesCategory(language, value));
       }
     };
   },
@@ -19347,11 +20023,7 @@ var api = {
         return definition ? paradigmInfoFromDefinition(definition) : void 0;
       },
       langs() {
-        const filtered = () => languages.filter((lang) => matchesParadigm(lang, targets));
-        return createLanguageCollectionRequest(filtered, async () => {
-          const loaded = await Promise.all(filtered().map((lang) => loadLanguage(lang.slug)));
-          return loaded.filter((lang) => Boolean(lang));
-        });
+        return createFilteredLanguageCollection((language) => matchesParadigm(language, targets));
       }
     };
   },
@@ -19373,11 +20045,7 @@ var api = {
         return definition ? ecosystemInfoFromDefinition(definition) : void 0;
       },
       langs() {
-        const filtered = () => languages.filter((lang) => matchesEcosystem(lang, targets));
-        return createLanguageCollectionRequest(filtered, async () => {
-          const loaded = await Promise.all(filtered().map((lang) => loadLanguage(lang.slug)));
-          return loaded.filter((lang) => Boolean(lang));
-        });
+        return createFilteredLanguageCollection((language) => matchesEcosystem(language, targets));
       }
     };
   },