code-languages 1.26.0 → 1.28.0

package/dist/api.js

@@ -888,6 +888,65 @@ var init_awk = __esm({
   }
 });
 
+// src/languages/ballerina.ts
+var ballerina_exports = {};
+__export(ballerina_exports, {
+  ballerina: () => ballerina
+});
+var ballerina;
+var init_ballerina = __esm({
+  "src/languages/ballerina.ts"() {
+    ballerina = {
+      slug: "ballerina",
+      publishedDate: "2017-02-01",
+      extensions: [".bal"],
+      author: "WSO2",
+      website: "https://ballerina.io",
+      paradigms: ["concurrent", "functional", "imperative", "object-oriented"],
+      tooling: {
+        runtimes: ["Ballerina runtime (JVM-based)"],
+        packageManagers: ["Ballerina Central"],
+        ecosystems: ["Cloud", "Microservices", "Integration", "APIs"]
+      },
+      version: "2201.12.0",
+      logo: "https://ballerina.io/images/ballerina-logo.svg",
+      color: "#20B6B0",
+      i18n: {
+        en: {
+          name: "Ballerina",
+          description: "A cloud-native programming language designed for writing network services and APIs with built-in concurrency and type safety.",
+          longDescription: "Ballerina is a statically typed, compiled language created by WSO2 specifically for cloud-native integration and network programming. It has built-in abstractions for network services, HTTP, GraphQL, gRPC, WebSockets, and data formats like JSON and XML, making service-to-service communication a first-class concern.\n\nBallerina features a sequence diagram-based visualization of code, explicit error handling, transactional support, and a strong type system with union types and structural typing. It compiles to native code via GraalVM or runs on the JVM, and its package ecosystem is hosted on Ballerina Central."
+        },
+        es: {
+          name: "Ballerina",
+          description: "Un lenguaje de programaci\xF3n nativo de la nube dise\xF1ado para escribir servicios de red y APIs con concurrencia y seguridad de tipos integradas.",
+          longDescription: "Ballerina es un lenguaje compilado de tipo est\xE1tico creado por WSO2 espec\xEDficamente para integraci\xF3n nativa de la nube y programaci\xF3n de redes. Tiene abstracciones integradas para servicios de red, HTTP, GraphQL, gRPC, WebSockets y formatos de datos como JSON y XML.\n\nBallerina presenta una visualizaci\xF3n del c\xF3digo basada en diagramas de secuencia, manejo expl\xEDcito de errores, soporte transaccional y un sistema de tipos fuerte con tipos uni\xF3n y tipado estructural. Compila a c\xF3digo nativo via GraalVM o se ejecuta en la JVM."
+        },
+        it: {
+          name: "Ballerina",
+          description: "Un linguaggio di programmazione cloud-native progettato per scrivere servizi di rete e API con concorrenza e sicurezza dei tipi integrate.",
+          longDescription: "Ballerina \xE8 un linguaggio compilato staticamente tipizzato creato da WSO2 specificamente per l'integrazione cloud-native e la programmazione di rete. Ha astrazioni integrate per servizi di rete, HTTP, GraphQL, gRPC, WebSocket e formati di dati come JSON e XML.\n\nBallerina presenta una visualizzazione del codice basata su diagrammi di sequenza, gestione esplicita degli errori, supporto transazionale e un sistema di tipi forte con tipi unione e tipizzazione strutturale. Compila in codice nativo tramite GraalVM o viene eseguito sulla JVM."
+        },
+        fr: {
+          name: "Ballerina",
+          description: "Un langage de programmation cloud-native con\xE7u pour \xE9crire des services r\xE9seau et des APIs avec concurrence et s\xE9curit\xE9 des types int\xE9gr\xE9es.",
+          longDescription: "Ballerina est un langage compil\xE9 statiquement typ\xE9 cr\xE9\xE9 par WSO2 sp\xE9cifiquement pour l'int\xE9gration cloud-native et la programmation r\xE9seau. Il dispose d'abstractions int\xE9gr\xE9es pour les services r\xE9seau, HTTP, GraphQL, gRPC, WebSockets et les formats de donn\xE9es comme JSON et XML.\n\nBallerina pr\xE9sente une visualisation du code bas\xE9e sur des diagrammes de s\xE9quence, une gestion explicite des erreurs, un support transactionnel et un syst\xE8me de types fort avec des types union et un typage structurel. Il se compile en code natif via GraalVM ou s'ex\xE9cute sur la JVM."
+        },
+        de: {
+          name: "Ballerina",
+          description: "Eine Cloud-native Programmiersprache f\xFCr Netzwerkdienste und APIs mit eingebauter Nebenl\xE4ufigkeit und Typsicherheit.",
+          longDescription: "Ballerina ist eine statisch typisierte, kompilierte Sprache, die von WSO2 speziell f\xFCr Cloud-native Integration und Netzwerkprogrammierung entwickelt wurde. Sie hat eingebaute Abstraktionen f\xFCr Netzwerkdienste, HTTP, GraphQL, gRPC, WebSockets und Datenformate wie JSON und XML.\n\nBallerina bietet eine sequenzdiagrammbasierte Visualisierung des Codes, explizites Fehlerhandling, transaktionale Unterst\xFCtzung und ein starkes Typsystem mit Union-Types und struktureller Typisierung. Es kompiliert zu nativem Code via GraalVM oder l\xE4uft auf der JVM."
+        },
+        pt: {
+          name: "Ballerina",
+          description: "Uma linguagem de programa\xE7\xE3o cloud-native projetada para escrever servi\xE7os de rede e APIs com concorr\xEAncia e seguran\xE7a de tipos integradas.",
+          longDescription: "Ballerina \xE9 uma linguagem compilada estaticamente tipada criada pela WSO2 especificamente para integra\xE7\xE3o cloud-native e programa\xE7\xE3o de rede. Possui abstra\xE7\xF5es integradas para servi\xE7os de rede, HTTP, GraphQL, gRPC, WebSockets e formatos de dados como JSON e XML.\n\nBallerina apresenta uma visualiza\xE7\xE3o do c\xF3digo baseada em diagramas de sequ\xEAncia, tratamento expl\xEDcito de erros, suporte transacional e um sistema de tipos forte com tipos union e tipagem estrutural. Compila para c\xF3digo nativo via GraalVM ou executa na JVM."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/bash.ts
 var bash_exports = {};
 __export(bash_exports, {
@@ -2119,6 +2178,64 @@ var init_cue = __esm({
   }
 });
 
+// src/languages/cypher.ts
+var cypher_exports = {};
+__export(cypher_exports, {
+  cypher: () => cypher
+});
+var cypher;
+var init_cypher = __esm({
+  "src/languages/cypher.ts"() {
+    cypher = {
+      slug: "cypher",
+      publishedDate: "2011-02-01",
+      extensions: [".cypher", ".cyp"],
+      author: "Neo Technology (Neo4j)",
+      website: "https://neo4j.com/docs/cypher-manual/current/",
+      paradigms: ["declarative", "query"],
+      tooling: {
+        runtimes: ["Neo4j", "Amazon Neptune", "Memgraph", "RedisGraph"],
+        ecosystems: ["Graph Databases", "Data"]
+      },
+      version: "25",
+      logo: "https://dist.neo4j.com/wp-content/uploads/20210423072428/neo4j-logo-2020-1.svg",
+      color: "#018BFF",
+      i18n: {
+        en: {
+          name: "Cypher",
+          description: "A declarative graph query language for Neo4j and other graph databases, designed to express graph patterns naturally.",
+          longDescription: "Cypher is a declarative query language designed specifically for querying and updating property graphs. Its ASCII-art syntax uses parentheses for nodes and arrows for relationships, making graph patterns intuitive to read and write.\n\nOriginally developed by Neo4j, Cypher has been standardized as openCypher and is supported by multiple graph database engines including Amazon Neptune and Memgraph. It is used for social networks, recommendation engines, fraud detection, and knowledge graphs."
+        },
+        es: {
+          name: "Cypher",
+          description: "Un lenguaje declarativo de consulta de grafos para Neo4j y otras bases de datos de grafos, dise\xF1ado para expresar patrones de grafos de forma natural.",
+          longDescription: "Cypher es un lenguaje de consulta declarativo dise\xF1ado para consultar y actualizar grafos de propiedades. Su sintaxis de arte ASCII usa par\xE9ntesis para nodos y flechas para relaciones, haciendo los patrones de grafo intuitivos de leer y escribir.\n\nOriginalmente desarrollado por Neo4j, Cypher ha sido estandarizado como openCypher y es compatible con m\xFAltiples motores de bases de datos de grafos. Se usa en redes sociales, motores de recomendaci\xF3n, detecci\xF3n de fraude y grafos de conocimiento."
+        },
+        it: {
+          name: "Cypher",
+          description: "Un linguaggio di interrogazione di grafi dichiarativo per Neo4j e altri database a grafo, progettato per esprimere pattern di grafi in modo naturale.",
+          longDescription: "Cypher \xE8 un linguaggio di interrogazione dichiarativo progettato per interrogare e aggiornare grafi di propriet\xE0. La sua sintassi ASCII art usa parentesi per i nodi e frecce per le relazioni, rendendo i pattern di grafo intuitivi da leggere e scrivere.\n\nOriginariamente sviluppato da Neo4j, Cypher \xE8 stato standardizzato come openCypher ed \xE8 supportato da pi\xF9 motori di database a grafo. \xC8 utilizzato per reti sociali, motori di raccomandazione, rilevamento frodi e grafi della conoscenza."
+        },
+        fr: {
+          name: "Cypher",
+          description: "Un langage de requ\xEAte de graphes d\xE9claratif pour Neo4j et d'autres bases de donn\xE9es de graphes, con\xE7u pour exprimer des motifs de graphes naturellement.",
+          longDescription: "Cypher est un langage de requ\xEAte d\xE9claratif con\xE7u pour interroger et mettre \xE0 jour des graphes de propri\xE9t\xE9s. Sa syntaxe art ASCII utilise des parenth\xE8ses pour les n\u0153uds et des fl\xE8ches pour les relations, rendant les motifs de graphes intuitifs \xE0 lire et \xE0 \xE9crire.\n\nD\xE9velopp\xE9 initialement par Neo4j, Cypher a \xE9t\xE9 standardis\xE9 en tant qu'openCypher et est support\xE9 par plusieurs moteurs de bases de donn\xE9es de graphes. Il est utilis\xE9 pour les r\xE9seaux sociaux, les moteurs de recommandation, la d\xE9tection de fraude et les graphes de connaissances."
+        },
+        de: {
+          name: "Cypher",
+          description: "Eine deklarative Graphabfragesprache f\xFCr Neo4j und andere Graphdatenbanken, die Graphmuster nat\xFCrlich ausdr\xFCckt.",
+          longDescription: "Cypher ist eine deklarative Abfragesprache, die speziell f\xFCr die Abfrage und Aktualisierung von Eigenschaftsgraphen entwickelt wurde. Ihre ASCII-Art-Syntax verwendet Klammern f\xFCr Knoten und Pfeile f\xFCr Beziehungen, was Graphmuster intuitiv lesbar und schreibbar macht.\n\nUrspr\xFCnglich von Neo4j entwickelt, wurde Cypher als openCypher standardisiert und wird von mehreren Graphdatenbank-Engines unterst\xFCtzt. Es wird f\xFCr soziale Netzwerke, Empfehlungssysteme, Betrugserkennung und Wissensgraphen eingesetzt."
+        },
+        pt: {
+          name: "Cypher",
+          description: "Uma linguagem declarativa de consulta de grafos para Neo4j e outros bancos de dados de grafos, projetada para expressar padr\xF5es de grafos de forma natural.",
+          longDescription: "Cypher \xE9 uma linguagem de consulta declarativa projetada para consultar e atualizar grafos de propriedades. Sua sintaxe de arte ASCII usa par\xEAnteses para n\xF3s e setas para relacionamentos, tornando os padr\xF5es de grafo intuitivos de ler e escrever.\n\nOriginalmente desenvolvido pela Neo4j, o Cypher foi padronizado como openCypher e \xE9 suportado por m\xFAltiplos motores de bancos de dados de grafos. \xC9 usado em redes sociais, motores de recomenda\xE7\xE3o, detec\xE7\xE3o de fraude e grafos de conhecimento."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/cython.ts
 var cython_exports = {};
 __export(cython_exports, {
@@ -2531,6 +2648,65 @@ var init_earthly = __esm({
   }
 });
 
+// src/languages/eiffel.ts
+var eiffel_exports = {};
+__export(eiffel_exports, {
+  eiffel: () => eiffel
+});
+var eiffel;
+var init_eiffel = __esm({
+  "src/languages/eiffel.ts"() {
+    eiffel = {
+      slug: "eiffel",
+      publishedDate: "1986-01-01",
+      extensions: [".e"],
+      author: "Bertrand Meyer",
+      website: "https://www.eiffel.org",
+      paradigms: ["object-oriented", "concurrent", "generic", "imperative"],
+      tooling: {
+        runtimes: ["EiffelStudio", "Native"],
+        packageManagers: ["iron"],
+        ecosystems: ["Enterprise", "Systems"]
+      },
+      version: "24.05",
+      logo: "https://www.eiffel.org/images/eiffel_logo.png",
+      color: "#4D6977",
+      i18n: {
+        en: {
+          name: "Eiffel",
+          description: "An object-oriented language by Bertrand Meyer that pioneered Design by Contract, generics, and multiple inheritance.",
+          longDescription: "Eiffel is an object-oriented programming language designed by Bertrand Meyer and first released in 1986. It introduced the concept of Design by Contract (DbC), where preconditions, postconditions, and class invariants are first-class language features that enforce correctness at runtime.\n\nEiffel supports multiple inheritance, generics, and automatic memory management. It has influenced many modern languages including Java and C#. EiffelStudio is the primary IDE and compiler, targeting native code. Eiffel is used in safety-critical, financial, and enterprise software systems."
+        },
+        es: {
+          name: "Eiffel",
+          description: "Un lenguaje orientado a objetos de Bertrand Meyer que fue pionero en el Dise\xF1o por Contrato, los gen\xE9ricos y la herencia m\xFAltiple.",
+          longDescription: "Eiffel es un lenguaje de programaci\xF3n orientado a objetos dise\xF1ado por Bertrand Meyer y lanzado por primera vez en 1986. Introdujo el concepto de Dise\xF1o por Contrato (DbC), donde las precondiciones, postcondiciones e invariantes de clase son caracter\xEDsticas del lenguaje de primera clase.\n\nEiffel soporta herencia m\xFAltiple, gen\xE9ricos y gesti\xF3n autom\xE1tica de memoria. Ha influenciado muchos lenguajes modernos incluyendo Java y C#. Se usa en sistemas de software de misi\xF3n cr\xEDtica, financieros y empresariales."
+        },
+        it: {
+          name: "Eiffel",
+          description: "Un linguaggio orientato agli oggetti di Bertrand Meyer che ha introdotto il Design by Contract, i generici e l'ereditariet\xE0 multipla.",
+          longDescription: "Eiffel \xE8 un linguaggio di programmazione orientato agli oggetti progettato da Bertrand Meyer e rilasciato per la prima volta nel 1986. Ha introdotto il concetto di Design by Contract (DbC), dove le precondizioni, le postcondizioni e gli invarianti di classe sono funzionalit\xE0 di prima classe del linguaggio.\n\nEiffel supporta l'ereditariet\xE0 multipla, i generici e la gestione automatica della memoria. Ha influenzato molti linguaggi moderni tra cui Java e C#. Viene utilizzato in sistemi software mission-critical, finanziari e aziendali."
+        },
+        fr: {
+          name: "Eiffel",
+          description: "Un langage orient\xE9 objet de Bertrand Meyer qui a introduit la Conception par Contrat, les g\xE9n\xE9riques et l'h\xE9ritage multiple.",
+          longDescription: "Eiffel est un langage de programmation orient\xE9 objet con\xE7u par Bertrand Meyer et publi\xE9 pour la premi\xE8re fois en 1986. Il a introduit le concept de Conception par Contrat (DbC), o\xF9 les pr\xE9conditions, les postconditions et les invariants de classe sont des fonctionnalit\xE9s de premi\xE8re classe du langage.\n\nEiffel supporte l'h\xE9ritage multiple, les g\xE9n\xE9riques et la gestion automatique de la m\xE9moire. Il a influenc\xE9 de nombreux langages modernes dont Java et C#. Il est utilis\xE9 dans les syst\xE8mes logiciels critiques, financiers et d'entreprise."
+        },
+        de: {
+          name: "Eiffel",
+          description: "Eine objektorientierte Sprache von Bertrand Meyer, die Design by Contract, Generics und Mehrfachvererbung eingef\xFChrt hat.",
+          longDescription: "Eiffel ist eine objektorientierte Programmiersprache, die von Bertrand Meyer entworfen und erstmals 1986 ver\xF6ffentlicht wurde. Sie f\xFChrte das Konzept des Design by Contract (DbC) ein, bei dem Vorbedingungen, Nachbedingungen und Klasseninvarianten erstklassige Sprachmerkmale sind.\n\nEiffel unterst\xFCtzt Mehrfachvererbung, Generics und automatisches Speichermanagement. Es hat viele moderne Sprachen wie Java und C# beeinflusst. EiffelStudio ist die prim\xE4re IDE und der Compiler. Eiffel wird in sicherheitskritischen, finanziellen und Unternehmenssoftwaresystemen eingesetzt."
+        },
+        pt: {
+          name: "Eiffel",
+          description: "Uma linguagem orientada a objetos de Bertrand Meyer que foi pioneira no Design by Contract, generics e heran\xE7a m\xFAltipla.",
+          longDescription: "Eiffel \xE9 uma linguagem de programa\xE7\xE3o orientada a objetos projetada por Bertrand Meyer e lan\xE7ada pela primeira vez em 1986. Introduziu o conceito de Design by Contract (DbC), onde pr\xE9-condi\xE7\xF5es, p\xF3s-condi\xE7\xF5es e invariantes de classe s\xE3o recursos de primeira classe da linguagem.\n\nEiffel suporta heran\xE7a m\xFAltipla, generics e gerenciamento autom\xE1tico de mem\xF3ria. Influenciou muitas linguagens modernas incluindo Java e C#. EiffelStudio \xE9 a IDE e compilador principal. \xC9 usado em sistemas de software de miss\xE3o cr\xEDtica, financeiros e empresariais."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/elixir.ts
 var elixir_exports = {};
 __export(elixir_exports, {
@@ -2826,6 +3002,65 @@ var init_fennel = __esm({
   }
 });
 
+// src/languages/fish.ts
+var fish_exports = {};
+__export(fish_exports, {
+  fish: () => fish
+});
+var fish;
+var init_fish = __esm({
+  "src/languages/fish.ts"() {
+    fish = {
+      slug: "fish",
+      publishedDate: "2005-10-13",
+      extensions: [".fish"],
+      author: "Axel Liljencrantz",
+      website: "https://fishshell.com",
+      paradigms: ["imperative", "scripting"],
+      tooling: {
+        runtimes: ["fish"],
+        packageManagers: ["Fisher", "Oh My Fish"],
+        ecosystems: ["Shell", "Unix", "macOS", "Linux"]
+      },
+      version: "4.0.2",
+      logo: "https://fishshell.com/assets/img/Terminal_Logo2_CRT_Flat.png",
+      color: "#4AAE21",
+      i18n: {
+        en: {
+          name: "Fish",
+          description: "A smart and user-friendly command line shell for Unix-like systems with autosuggestions and syntax highlighting.",
+          longDescription: "Fish (Friendly Interactive SHell) is a Unix shell designed to be interactive and user-friendly out of the box. It provides features like autosuggestions based on history, syntax highlighting, tab completions from man pages, and a web-based configuration interface.\n\nUnlike Bash or Zsh, Fish avoids POSIX compatibility to offer a cleaner scripting language with consistent syntax. It is popular among developers who want a productive shell experience without heavy configuration."
+        },
+        es: {
+          name: "Fish",
+          description: "Un shell de l\xEDnea de comandos amigable para sistemas Unix con autosugerencias y resaltado de sintaxis.",
+          longDescription: "Fish (Friendly Interactive SHell) es un shell Unix dise\xF1ado para ser interactivo y f\xE1cil de usar. Ofrece autosugerencias basadas en el historial, resaltado de sintaxis, completado de tabulaci\xF3n desde p\xE1ginas man y una interfaz de configuraci\xF3n web.\n\nA diferencia de Bash o Zsh, Fish evita la compatibilidad POSIX para ofrecer un lenguaje de scripting m\xE1s limpio con sintaxis consistente. Es popular entre desarrolladores que buscan productividad sin configuraci\xF3n compleja."
+        },
+        it: {
+          name: "Fish",
+          description: "Una shell a riga di comando intelligente per sistemi Unix con suggerimenti automatici e evidenziazione della sintassi.",
+          longDescription: "Fish (Friendly Interactive SHell) \xE8 una shell Unix progettata per essere interattiva e facile da usare. Offre suggerimenti automatici basati sulla cronologia, evidenziazione della sintassi, completamento con tab dalle pagine man e un'interfaccia di configurazione web.\n\nA differenza di Bash o Zsh, Fish evita la compatibilit\xE0 POSIX per offrire un linguaggio di scripting pi\xF9 pulito con sintassi coerente. \xC8 popolare tra gli sviluppatori che vogliono produttivit\xE0 senza configurazione complessa."
+        },
+        fr: {
+          name: "Fish",
+          description: "Un shell en ligne de commande convivial pour les syst\xE8mes Unix avec autocompl\xE9tion et coloration syntaxique.",
+          longDescription: "Fish (Friendly Interactive SHell) est un shell Unix con\xE7u pour \xEAtre interactif et facile \xE0 utiliser. Il offre des suggestions automatiques bas\xE9es sur l'historique, la coloration syntaxique, la compl\xE9tion par tabulation depuis les pages man et une interface de configuration web.\n\nContrairement \xE0 Bash ou Zsh, Fish \xE9vite la compatibilit\xE9 POSIX pour proposer un langage de script plus propre avec une syntaxe coh\xE9rente. Il est populaire parmi les d\xE9veloppeurs qui souhaitent une productivit\xE9 \xE9lev\xE9e sans configuration complexe."
+        },
+        de: {
+          name: "Fish",
+          description: "Eine benutzerfreundliche Kommandozeilen-Shell f\xFCr Unix-Systeme mit Autovervollst\xE4ndigung und Syntaxhervorhebung.",
+          longDescription: "Fish (Friendly Interactive SHell) ist eine Unix-Shell, die von Grund auf interaktiv und benutzerfreundlich gestaltet ist. Sie bietet verlaufsbasierte Autovervollst\xE4ndigung, Syntaxhervorhebung, Tab-Vervollst\xE4ndigung aus Man-Seiten und eine webbasierte Konfigurationsoberfl\xE4che.\n\nAnders als Bash oder Zsh verzichtet Fish auf POSIX-Kompatibilit\xE4t, um eine sauberere Skriptsprache mit konsistenter Syntax zu bieten. Sie ist bei Entwicklern beliebt, die produktiv arbeiten m\xF6chten ohne aufwendige Konfiguration."
+        },
+        pt: {
+          name: "Fish",
+          description: "Um shell de linha de comando amig\xE1vel para sistemas Unix com autosugest\xF5es e destaque de sintaxe.",
+          longDescription: "Fish (Friendly Interactive SHell) \xE9 um shell Unix projetado para ser interativo e f\xE1cil de usar. Oferece autosugest\xF5es baseadas no hist\xF3rico, destaque de sintaxe, completamento por tab a partir de p\xE1ginas man e uma interface de configura\xE7\xE3o web.\n\nAo contr\xE1rio do Bash ou Zsh, o Fish evita compatibilidade POSIX para oferecer uma linguagem de script mais limpa com sintaxe consistente. \xC9 popular entre desenvolvedores que buscam produtividade sem configura\xE7\xE3o complexa."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/forth.ts
 var forth_exports = {};
 __export(forth_exports, {
@@ -3886,6 +4121,63 @@ var init_hlsl = __esm({
   }
 });
 
+// src/languages/hocon.ts
+var hocon_exports = {};
+__export(hocon_exports, {
+  hocon: () => hocon
+});
+var hocon;
+var init_hocon = __esm({
+  "src/languages/hocon.ts"() {
+    hocon = {
+      slug: "hocon",
+      publishedDate: "2013-01-01",
+      extensions: [".hocon"],
+      author: "Typesafe (now Lightbend)",
+      website: "https://github.com/lightbend/config/blob/main/HOCON.md",
+      paradigms: ["declarative"],
+      tooling: {
+        ecosystems: ["JVM", "Scala", "Akka", "Play Framework", "Configuration"]
+      },
+      version: "1.4.3",
+      logo: "https://www.lightbend.com/assets/images/brand/lightbend-icon-reverse.svg",
+      color: "#F26822",
+      i18n: {
+        en: {
+          name: "HOCON",
+          description: "A human-optimized configuration format that is a superset of JSON, used widely in the Scala and Akka ecosystems.",
+          longDescription: "HOCON (Human-Optimized Config Object Notation) is a configuration format developed by Lightbend as a superset of JSON. It allows comments, unquoted keys, multi-line strings, variable substitution, and file inclusion, making configuration files easier to read and maintain.\n\nHOCON is the default configuration format for Akka, Play Framework, and Lagom. It is parsed by the Typesafe Config library and supports merging and overriding of configuration values, enabling environment-specific configurations through a single unified format."
+        },
+        es: {
+          name: "HOCON",
+          description: "Un formato de configuraci\xF3n optimizado para humanos que es un superconjunto de JSON, usado ampliamente en los ecosistemas Scala y Akka.",
+          longDescription: "HOCON (Human-Optimized Config Object Notation) es un formato de configuraci\xF3n desarrollado por Lightbend como superconjunto de JSON. Permite comentarios, claves sin comillas, cadenas multil\xEDnea, sustituci\xF3n de variables e inclusi\xF3n de archivos.\n\nEs el formato de configuraci\xF3n predeterminado para Akka, Play Framework y Lagom. Soporta fusi\xF3n y sobreescritura de valores de configuraci\xF3n, permitiendo configuraciones espec\xEDficas de entorno a trav\xE9s de un formato unificado."
+        },
+        it: {
+          name: "HOCON",
+          description: "Un formato di configurazione ottimizzato per l'uomo che \xE8 un superset di JSON, ampiamente utilizzato negli ecosistemi Scala e Akka.",
+          longDescription: "HOCON (Human-Optimized Config Object Notation) \xE8 un formato di configurazione sviluppato da Lightbend come superset di JSON. Consente commenti, chiavi senza virgolette, stringhe multiriga, sostituzione di variabili e inclusione di file.\n\n\xC8 il formato di configurazione predefinito per Akka, Play Framework e Lagom. Supporta la fusione e la sovrascrittura dei valori di configurazione, consentendo configurazioni specifiche per ambiente attraverso un unico formato unificato."
+        },
+        fr: {
+          name: "HOCON",
+          description: "Un format de configuration optimis\xE9 pour les humains, superset de JSON, largement utilis\xE9 dans les \xE9cosyst\xE8mes Scala et Akka.",
+          longDescription: "HOCON (Human-Optimized Config Object Notation) est un format de configuration d\xE9velopp\xE9 par Lightbend comme superset de JSON. Il permet les commentaires, les cl\xE9s sans guillemets, les cha\xEEnes multi-lignes, la substitution de variables et l'inclusion de fichiers.\n\nC'est le format de configuration par d\xE9faut pour Akka, Play Framework et Lagom. Il supporte la fusion et la substitution de valeurs de configuration, permettant des configurations sp\xE9cifiques \xE0 l'environnement via un format unifi\xE9."
+        },
+        de: {
+          name: "HOCON",
+          description: "Ein f\xFCr Menschen optimiertes Konfigurationsformat, das eine Obermenge von JSON ist und im Scala- und Akka-\xD6kosystem weit verbreitet ist.",
+          longDescription: "HOCON (Human-Optimized Config Object Notation) ist ein Konfigurationsformat, das von Lightbend als Obermenge von JSON entwickelt wurde. Es erlaubt Kommentare, Schl\xFCssel ohne Anf\xFChrungszeichen, mehrzeilige Strings, Variablensubstitution und Dateieinbindung.\n\nHOCON ist das Standardkonfigurationsformat f\xFCr Akka, Play Framework und Lagom. Es unterst\xFCtzt das Zusammenf\xFChren und \xDCberschreiben von Konfigurationswerten und erm\xF6glicht umgebungsspezifische Konfigurationen \xFCber ein einheitliches Format."
+        },
+        pt: {
+          name: "HOCON",
+          description: "Um formato de configura\xE7\xE3o otimizado para humanos que \xE9 um superconjunto de JSON, amplamente usado nos ecossistemas Scala e Akka.",
+          longDescription: "HOCON (Human-Optimized Config Object Notation) \xE9 um formato de configura\xE7\xE3o desenvolvido pela Lightbend como superconjunto de JSON. Permite coment\xE1rios, chaves sem aspas, strings multilinhas, substitui\xE7\xE3o de vari\xE1veis e inclus\xE3o de arquivos.\n\n\xC9 o formato de configura\xE7\xE3o padr\xE3o para Akka, Play Framework e Lagom. Suporta mesclagem e substitui\xE7\xE3o de valores de configura\xE7\xE3o, permitindo configura\xE7\xF5es espec\xEDficas de ambiente atrav\xE9s de um formato unificado."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/html.ts
 var html_exports = {};
 __export(html_exports, {
@@ -4346,6 +4638,65 @@ var init_json = __esm({
   }
 });
 
+// src/languages/json5.ts
+var json5_exports = {};
+__export(json5_exports, {
+  json5: () => json5
+});
+var json5;
+var init_json5 = __esm({
+  "src/languages/json5.ts"() {
+    json5 = {
+      slug: "json5",
+      publishedDate: "2012-01-01",
+      extensions: [".json5"],
+      author: "Aseem Kishore",
+      website: "https://json5.org",
+      paradigms: ["declarative"],
+      tooling: {
+        runtimes: ["Node.js", "Browser"],
+        packageManagers: ["npm", "pnpm", "Yarn"],
+        ecosystems: ["Configuration", "Web", "Node.js"]
+      },
+      version: "2.2.3",
+      logo: "https://json5.org/assets/logo.svg",
+      color: "#267CB9",
+      i18n: {
+        en: {
+          name: "JSON5",
+          description: "An extension of JSON that allows comments, trailing commas, and unquoted keys to make configuration files more human-readable.",
+          longDescription: "JSON5 is a superset of JSON that adds syntax conveniences inspired by ES5 JavaScript, including single-line and multi-line comments, trailing commas in objects and arrays, unquoted object keys, single-quoted strings, and hexadecimal numbers.\n\nIt is commonly used for configuration files where readability and maintainability matter but the strict JSON format is too limiting. JSON5 parsers are available in JavaScript, Python, Go, Rust, and other languages."
+        },
+        es: {
+          name: "JSON5",
+          description: "Una extensi\xF3n de JSON que permite comentarios, comas finales y claves sin comillas para hacer los archivos de configuraci\xF3n m\xE1s legibles.",
+          longDescription: "JSON5 es un superconjunto de JSON que a\xF1ade conveniencias de sintaxis inspiradas en ES5 JavaScript, incluyendo comentarios de una y varias l\xEDneas, comas finales en objetos y arreglos, claves de objeto sin comillas, cadenas con comillas simples y n\xFAmeros hexadecimales.\n\nSe usa habitualmente en archivos de configuraci\xF3n donde la legibilidad importa pero el formato JSON estricto es demasiado limitante. Hay parsers de JSON5 disponibles en JavaScript, Python, Go, Rust y otros lenguajes."
+        },
+        it: {
+          name: "JSON5",
+          description: "Un'estensione di JSON che consente commenti, virgole finali e chiavi senza virgolette per rendere i file di configurazione pi\xF9 leggibili.",
+          longDescription: "JSON5 \xE8 un superset di JSON che aggiunge comodit\xE0 sintattiche ispirate a ES5 JavaScript, tra cui commenti su una o pi\xF9 righe, virgole finali in oggetti e array, chiavi oggetto senza virgolette, stringhe con virgolette singole e numeri esadecimali.\n\n\xC8 comunemente utilizzato per file di configurazione dove la leggibilit\xE0 \xE8 importante ma il formato JSON stretto \xE8 troppo limitante. I parser JSON5 sono disponibili in JavaScript, Python, Go, Rust e altri linguaggi."
+        },
+        fr: {
+          name: "JSON5",
+          description: "Une extension de JSON qui autorise les commentaires, les virgules finales et les cl\xE9s non cit\xE9es pour rendre les fichiers de configuration plus lisibles.",
+          longDescription: "JSON5 est un superset de JSON qui ajoute des commodit\xE9s syntaxiques inspir\xE9es de ES5 JavaScript, notamment les commentaires sur une ou plusieurs lignes, les virgules finales dans les objets et tableaux, les cl\xE9s d'objet sans guillemets, les cha\xEEnes entre guillemets simples et les nombres hexad\xE9cimaux.\n\nIl est couramment utilis\xE9 pour les fichiers de configuration o\xF9 la lisibilit\xE9 est importante mais o\xF9 le format JSON strict est trop contraignant. Des parseurs JSON5 sont disponibles en JavaScript, Python, Go, Rust et d'autres langages."
+        },
+        de: {
+          name: "JSON5",
+          description: "Eine Erweiterung von JSON, die Kommentare, abschlie\xDFende Kommas und Schl\xFCssel ohne Anf\xFChrungszeichen erlaubt, um Konfigurationsdateien lesbarer zu machen.",
+          longDescription: "JSON5 ist eine Obermenge von JSON, die durch ES5-JavaScript inspirierte Syntaxerleichterungen hinzuf\xFCgt, darunter einzeilige und mehrzeilige Kommentare, abschlie\xDFende Kommas in Objekten und Arrays, Objektschl\xFCssel ohne Anf\xFChrungszeichen, Strings in einfachen Anf\xFChrungszeichen und Hexadezimalzahlen.\n\nEs wird h\xE4ufig f\xFCr Konfigurationsdateien verwendet, bei denen Lesbarkeit und Wartbarkeit wichtig sind, das strenge JSON-Format aber zu einschr\xE4nkend ist. JSON5-Parser sind in JavaScript, Python, Go, Rust und anderen Sprachen verf\xFCgbar."
+        },
+        pt: {
+          name: "JSON5",
+          description: "Uma extens\xE3o do JSON que permite coment\xE1rios, v\xEDrgulas finais e chaves sem aspas para tornar os arquivos de configura\xE7\xE3o mais leg\xEDveis.",
+          longDescription: "JSON5 \xE9 um superconjunto de JSON que adiciona conveni\xEAncias de sintaxe inspiradas no ES5 JavaScript, incluindo coment\xE1rios de uma e v\xE1rias linhas, v\xEDrgulas finais em objetos e arrays, chaves de objeto sem aspas, strings com aspas simples e n\xFAmeros hexadecimais.\n\n\xC9 comumente usado em arquivos de configura\xE7\xE3o onde legibilidade e manutenibilidade importam, mas o formato JSON estrito \xE9 muito limitante. Parsers de JSON5 est\xE3o dispon\xEDveis em JavaScript, Python, Go, Rust e outras linguagens."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/jsonnet.ts
 var jsonnet_exports = {};
 __export(jsonnet_exports, {
@@ -5636,6 +5987,63 @@ var init_moonbit = __esm({
   }
 });
 
+// src/languages/mustache.ts
+var mustache_exports = {};
+__export(mustache_exports, {
+  mustache: () => mustache
+});
+var mustache;
+var init_mustache = __esm({
+  "src/languages/mustache.ts"() {
+    mustache = {
+      slug: "mustache",
+      publishedDate: "2009-06-01",
+      extensions: [".mustache", ".mst"],
+      author: "Chris Wanstrath",
+      website: "https://mustache.github.io",
+      paradigms: ["declarative", "templating"],
+      tooling: {
+        ecosystems: ["Web", "Node.js", "Ruby", "Python", "Java", "Go"]
+      },
+      version: "1.0",
+      logo: "https://mustache.github.io/images/mustache.png",
+      color: "#974A01",
+      i18n: {
+        en: {
+          name: "Mustache",
+          description: "A logic-less template language with implementations in many programming languages, using double-brace delimiters.",
+          longDescription: "Mustache is a lightweight, logic-less template language that uses double curly braces ({{ }}) as delimiters for variable interpolation, sections, and partials. By avoiding conditionals and loops in the template itself, Mustache enforces a clean separation between logic and presentation.\n\nIt has official and community implementations in over 40 programming languages including JavaScript, Ruby, Python, Java, Go, and PHP. Mustache is used for generating HTML, configuration files, email bodies, and any text-based output where a simple substitution model suffices."
+        },
+        es: {
+          name: "Mustache",
+          description: "Un lenguaje de plantillas sin l\xF3gica con implementaciones en muchos lenguajes de programaci\xF3n, usando delimitadores de llaves dobles.",
+          longDescription: "Mustache es un lenguaje de plantillas ligero y sin l\xF3gica que usa llaves dobles ({{ }}) como delimitadores para interpolaci\xF3n de variables, secciones y parciales. Al evitar condicionales y bucles en la propia plantilla, Mustache impone una separaci\xF3n clara entre l\xF3gica y presentaci\xF3n.\n\nTiene implementaciones oficiales y de la comunidad en m\xE1s de 40 lenguajes de programaci\xF3n. Se usa para generar HTML, archivos de configuraci\xF3n, cuerpos de correos electr\xF3nicos y cualquier salida basada en texto."
+        },
+        it: {
+          name: "Mustache",
+          description: "Un linguaggio di template senza logica con implementazioni in molti linguaggi di programmazione, che usa delimitatori a doppie graffe.",
+          longDescription: "Mustache \xE8 un linguaggio di template leggero e senza logica che usa doppie graffe ({{ }}) come delimitatori per l'interpolazione di variabili, sezioni e parziali. Evitando condizionali e cicli nel template stesso, Mustache impone una netta separazione tra logica e presentazione.\n\nHa implementazioni ufficiali e della comunit\xE0 in oltre 40 linguaggi di programmazione. \xC8 utilizzato per generare HTML, file di configurazione, corpi di email e qualsiasi output basato su testo."
+        },
+        fr: {
+          name: "Mustache",
+          description: "Un langage de template sans logique avec des impl\xE9mentations dans de nombreux langages de programmation, utilisant des d\xE9limiteurs \xE0 doubles accolades.",
+          longDescription: "Mustache est un langage de template l\xE9ger et sans logique qui utilise des doubles accolades ({{ }}) comme d\xE9limiteurs pour l'interpolation de variables, les sections et les partiels. En \xE9vitant les conditionnelles et les boucles dans le template lui-m\xEAme, Mustache impose une s\xE9paration nette entre la logique et la pr\xE9sentation.\n\nIl dispose d'impl\xE9mentations officielles et communautaires dans plus de 40 langages de programmation. Mustache est utilis\xE9 pour g\xE9n\xE9rer du HTML, des fichiers de configuration, des corps d'emails et tout output textuel."
+        },
+        de: {
+          name: "Mustache",
+          description: "Eine logiklose Template-Sprache mit Implementierungen in vielen Programmiersprachen, die doppelte geschweifte Klammern als Begrenzer verwendet.",
+          longDescription: "Mustache ist eine leichtgewichtige, logiklose Template-Sprache, die doppelte geschweifte Klammern ({{ }}) als Begrenzer f\xFCr Variableninterpolation, Abschnitte und Partials verwendet. Durch das Vermeiden von Bedingungen und Schleifen im Template selbst erzwingt Mustache eine saubere Trennung zwischen Logik und Darstellung.\n\nEs gibt offizielle und Community-Implementierungen in \xFCber 40 Programmiersprachen. Mustache wird zur Generierung von HTML, Konfigurationsdateien, E-Mail-Texten und beliebigen textbasierten Ausgaben verwendet."
+        },
+        pt: {
+          name: "Mustache",
+          description: "Uma linguagem de template sem l\xF3gica com implementa\xE7\xF5es em muitas linguagens de programa\xE7\xE3o, usando delimitadores de chaves duplas.",
+          longDescription: "Mustache \xE9 uma linguagem de template leve e sem l\xF3gica que usa chaves duplas ({{ }}) como delimitadores para interpola\xE7\xE3o de vari\xE1veis, se\xE7\xF5es e parciais. Ao evitar condicionais e loops no pr\xF3prio template, o Mustache imp\xF5e uma separa\xE7\xE3o limpa entre l\xF3gica e apresenta\xE7\xE3o.\n\nTem implementa\xE7\xF5es oficiais e da comunidade em mais de 40 linguagens de programa\xE7\xE3o. \xC9 usado para gerar HTML, arquivos de configura\xE7\xE3o, corpos de e-mail e qualquer sa\xEDda baseada em texto."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/nginx.ts
 var nginx_exports = {};
 __export(nginx_exports, {
@@ -5812,6 +6220,124 @@ var init_nix = __esm({
   }
 });
 
+// src/languages/nunjucks.ts
+var nunjucks_exports = {};
+__export(nunjucks_exports, {
+  nunjucks: () => nunjucks
+});
+var nunjucks;
+var init_nunjucks = __esm({
+  "src/languages/nunjucks.ts"() {
+    nunjucks = {
+      slug: "nunjucks",
+      publishedDate: "2013-07-01",
+      extensions: [".njk", ".nunjucks"],
+      author: "James Long / Mozilla",
+      website: "https://mozilla.github.io/nunjucks/",
+      paradigms: ["declarative", "templating"],
+      tooling: {
+        runtimes: ["Node.js", "Browser"],
+        packageManagers: ["npm", "pnpm", "Yarn"],
+        ecosystems: ["Web", "Node.js", "Static Sites"]
+      },
+      version: "3.2.4",
+      logo: "https://mozilla.github.io/nunjucks/img/nunjucks-logo.png",
+      color: "#1C4A1C",
+      i18n: {
+        en: {
+          name: "Nunjucks",
+          description: "A rich and powerful templating language for JavaScript inspired by Jinja2, with template inheritance and macros.",
+          longDescription: "Nunjucks is a full-featured template language for JavaScript, created by Mozilla and heavily inspired by Python's Jinja2. It supports template inheritance, macros, include, custom filters, and asynchronous rendering, making it well-suited for building complex HTML-based applications.\n\nNunjucks runs both in Node.js and in the browser and is commonly used with static site generators like Eleventy. Its expressive syntax and rich feature set make it a popular choice for server-rendered web applications and documentation sites."
+        },
+        es: {
+          name: "Nunjucks",
+          description: "Un potente lenguaje de plantillas para JavaScript inspirado en Jinja2, con herencia de plantillas y macros.",
+          longDescription: "Nunjucks es un lenguaje de plantillas completo para JavaScript, creado por Mozilla e inspirado en Jinja2 de Python. Soporta herencia de plantillas, macros, includes, filtros personalizados y renderizado as\xEDncrono.\n\nFunciona tanto en Node.js como en el navegador y se usa habitualmente con generadores de sitios est\xE1ticos como Eleventy. Su sintaxis expresiva lo convierte en una opci\xF3n popular para aplicaciones web renderizadas en servidor."
+        },
+        it: {
+          name: "Nunjucks",
+          description: "Un potente linguaggio di template per JavaScript ispirato a Jinja2, con ereditariet\xE0 dei template e macro.",
+          longDescription: "Nunjucks \xE8 un linguaggio di template completo per JavaScript, creato da Mozilla e fortemente ispirato a Jinja2 di Python. Supporta l'ereditariet\xE0 dei template, macro, include, filtri personalizzati e rendering asincrono.\n\nFunziona sia in Node.js che nel browser ed \xE8 comunemente usato con generatori di siti statici come Eleventy. La sua sintassi espressiva lo rende una scelta popolare per applicazioni web renderizzate lato server."
+        },
+        fr: {
+          name: "Nunjucks",
+          description: "Un langage de template riche et puissant pour JavaScript inspir\xE9 de Jinja2, avec h\xE9ritage de templates et macros.",
+          longDescription: "Nunjucks est un langage de template complet pour JavaScript, cr\xE9\xE9 par Mozilla et fortement inspir\xE9 de Jinja2 de Python. Il supporte l'h\xE9ritage de templates, les macros, l'inclusion, les filtres personnalis\xE9s et le rendu asynchrone.\n\nNunjucks fonctionne \xE0 la fois dans Node.js et dans le navigateur et est couramment utilis\xE9 avec des g\xE9n\xE9rateurs de sites statiques comme Eleventy. Sa syntaxe expressive en fait un choix populaire pour les applications web rendues c\xF4t\xE9 serveur."
+        },
+        de: {
+          name: "Nunjucks",
+          description: "Eine reichhaltige und leistungsstarke Template-Sprache f\xFCr JavaScript, inspiriert von Jinja2, mit Template-Vererbung und Makros.",
+          longDescription: "Nunjucks ist eine vollst\xE4ndige Template-Sprache f\xFCr JavaScript, von Mozilla entwickelt und stark von Pythons Jinja2 inspiriert. Es unterst\xFCtzt Template-Vererbung, Makros, Includes, benutzerdefinierte Filter und asynchrones Rendering.\n\nNunjucks l\xE4uft sowohl in Node.js als auch im Browser und wird h\xE4ufig mit Static-Site-Generatoren wie Eleventy verwendet. Seine ausdrucksstarke Syntax macht es zu einer beliebten Wahl f\xFCr serverseitig gerenderte Webanwendungen."
+        },
+        pt: {
+          name: "Nunjucks",
+          description: "Uma linguagem de template rica e poderosa para JavaScript inspirada no Jinja2, com heran\xE7a de templates e macros.",
+          longDescription: "Nunjucks \xE9 uma linguagem de template completa para JavaScript, criada pela Mozilla e fortemente inspirada no Jinja2 do Python. Suporta heran\xE7a de templates, macros, include, filtros personalizados e renderiza\xE7\xE3o ass\xEDncrona.\n\nFunciona tanto no Node.js quanto no navegador e \xE9 comumente usado com geradores de sites est\xE1ticos como o Eleventy. Sua sintaxe expressiva o torna uma escolha popular para aplica\xE7\xF5es web renderizadas no servidor."
+        }
+      }
+    };
+  }
+});
+
+// src/languages/nushell.ts
+var nushell_exports = {};
+__export(nushell_exports, {
+  nushell: () => nushell
+});
+var nushell;
+var init_nushell = __esm({
+  "src/languages/nushell.ts"() {
+    nushell = {
+      slug: "nushell",
+      publishedDate: "2019-08-23",
+      extensions: [".nu"],
+      author: "Jonathan Turner / Nushell contributors",
+      website: "https://www.nushell.sh",
+      paradigms: ["functional", "imperative", "scripting"],
+      tooling: {
+        runtimes: ["nu"],
+        packageManagers: ["nupm"],
+        ecosystems: ["Shell", "Unix", "Windows", "macOS"]
+      },
+      version: "0.103.0",
+      logo: "https://www.nushell.sh/icons/android-chrome-512x512.png",
+      color: "#3AA675",
+      i18n: {
+        en: {
+          name: "Nushell",
+          description: "A modern shell that treats data as structured tables, enabling pipeline-based data manipulation across platforms.",
+          longDescription: "Nushell is a cross-platform shell that brings a structured, typed approach to command-line data processing. Instead of treating everything as plain text, Nushell pipelines produce and consume structured data like tables, lists, and records, making it easy to filter, sort, and transform output.\n\nIt supports plugins, custom completions, and a rich standard library. Nushell is written in Rust and runs on Linux, macOS, and Windows, combining the interactivity of a shell with expressive data manipulation capabilities."
+        },
+        es: {
+          name: "Nushell",
+          description: "Un shell moderno que trata los datos como tablas estructuradas, permitiendo manipulaci\xF3n de datos en pipelines multiplataforma.",
+          longDescription: "Nushell es un shell multiplataforma que aplica un enfoque estructurado y tipado al procesamiento de datos en l\xEDnea de comandos. En lugar de tratar todo como texto plano, sus pipelines producen y consumen datos estructurados como tablas, listas y registros.\n\nAdmite plugins, completados personalizados y una rica biblioteca est\xE1ndar. Est\xE1 escrito en Rust y funciona en Linux, macOS y Windows, combinando la interactividad de un shell con capacidades expresivas de manipulaci\xF3n de datos."
+        },
+        it: {
+          name: "Nushell",
+          description: "Una shell moderna che tratta i dati come tabelle strutturate, abilitando la manipolazione dei dati in pipeline su pi\xF9 piattaforme.",
+          longDescription: "Nushell \xE8 una shell multipiattaforma che porta un approccio strutturato e tipizzato all'elaborazione dei dati dalla riga di comando. Invece di trattare tutto come testo normale, le pipeline di Nushell producono e consumano dati strutturati come tabelle, liste e record.\n\nSupporta plugin, completamenti personalizzati e una ricca libreria standard. \xC8 scritto in Rust e funziona su Linux, macOS e Windows, combinando l'interattivit\xE0 di una shell con capacit\xE0 espressive di manipolazione dei dati."
+        },
+        fr: {
+          name: "Nushell",
+          description: "Un shell moderne qui traite les donn\xE9es comme des tables structur\xE9es, permettant la manipulation de donn\xE9es en pipeline sur toutes les plateformes.",
+          longDescription: "Nushell est un shell multiplateforme qui apporte une approche structur\xE9e et typ\xE9e au traitement des donn\xE9es en ligne de commande. Au lieu de tout traiter comme du texte brut, les pipelines Nushell produisent et consomment des donn\xE9es structur\xE9es comme des tables, des listes et des enregistrements.\n\nIl prend en charge les plugins, les compl\xE9tions personnalis\xE9es et une riche biblioth\xE8que standard. \xC9crit en Rust, il fonctionne sur Linux, macOS et Windows, combinant l'interactivit\xE9 d'un shell avec des capacit\xE9s expressives de manipulation de donn\xE9es."
+        },
+        de: {
+          name: "Nushell",
+          description: "Eine moderne Shell, die Daten als strukturierte Tabellen behandelt und plattform\xFCbergreifende Pipeline-Datenverarbeitung erm\xF6glicht.",
+          longDescription: "Nushell ist eine plattform\xFCbergreifende Shell, die einen strukturierten, typisierten Ansatz f\xFCr die Befehlszeilen-Datenverarbeitung bringt. Anstatt alles als Klartext zu behandeln, erzeugen und verarbeiten Nushell-Pipelines strukturierte Daten wie Tabellen, Listen und Datens\xE4tze.\n\nEs unterst\xFCtzt Plugins, benutzerdefinierte Vervollst\xE4ndigungen und eine umfangreiche Standardbibliothek. In Rust geschrieben, l\xE4uft es unter Linux, macOS und Windows und kombiniert die Interaktivit\xE4t einer Shell mit ausdrucksstarken Datenverarbeitungsf\xE4higkeiten."
+        },
+        pt: {
+          name: "Nushell",
+          description: "Um shell moderno que trata dados como tabelas estruturadas, permitindo manipula\xE7\xE3o de dados em pipelines multiplataforma.",
+          longDescription: "Nushell \xE9 um shell multiplataforma que traz uma abordagem estruturada e tipada ao processamento de dados na linha de comando. Em vez de tratar tudo como texto simples, os pipelines do Nushell produzem e consomem dados estruturados como tabelas, listas e registros.\n\nSuporta plugins, completamentos personalizados e uma rica biblioteca padr\xE3o. Escrito em Rust, funciona no Linux, macOS e Windows, combinando a interatividade de um shell com capacidades expressivas de manipula\xE7\xE3o de dados."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/objective-c.ts
 var objective_c_exports = {};
 __export(objective_c_exports, {
@@ -7988,6 +8514,64 @@ var init_solidity = __esm({
   }
 });
 
+// src/languages/sparql.ts
+var sparql_exports = {};
+__export(sparql_exports, {
+  sparql: () => sparql
+});
+var sparql;
+var init_sparql = __esm({
+  "src/languages/sparql.ts"() {
+    sparql = {
+      slug: "sparql",
+      publishedDate: "2008-01-15",
+      extensions: [".sparql", ".rq"],
+      author: "W3C DAWG (Data Access Working Group)",
+      website: "https://www.w3.org/TR/sparql11-overview/",
+      paradigms: ["declarative", "query"],
+      tooling: {
+        runtimes: ["Apache Jena", "Virtuoso", "GraphDB", "Blazegraph", "RDF4J"],
+        ecosystems: ["Semantic Web", "Linked Data", "Knowledge Graphs"]
+      },
+      version: "1.1",
+      logo: "https://www.w3.org/RDF/icons/rdf_flyer.svg",
+      color: "#0E75B6",
+      i18n: {
+        en: {
+          name: "SPARQL",
+          description: "A W3C standard query language and protocol for RDF data, enabling queries across the Semantic Web and knowledge graphs.",
+          longDescription: "SPARQL (SPARQL Protocol and RDF Query Language) is the standard query language for RDF (Resource Description Framework) data. It allows querying and manipulating data stored in triplestores and linked data endpoints using graph pattern matching.\n\nSPARQL supports SELECT, CONSTRUCT, ASK, and DESCRIBE query forms, as well as UPDATE operations. It is widely used in semantic web applications, open government data portals, biomedical databases like UniProt and Wikidata, and knowledge graph systems."
+        },
+        es: {
+          name: "SPARQL",
+          description: "Un lenguaje de consulta est\xE1ndar W3C para datos RDF que permite consultas en la Web Sem\xE1ntica y grafos de conocimiento.",
+          longDescription: "SPARQL es el lenguaje de consulta est\xE1ndar para datos RDF (Resource Description Framework). Permite consultar y manipular datos almacenados en triplestores y endpoints de datos enlazados usando coincidencia de patrones de grafo.\n\nSPARQL soporta formas de consulta SELECT, CONSTRUCT, ASK y DESCRIBE, as\xED como operaciones UPDATE. Es ampliamente usado en aplicaciones de web sem\xE1ntica, portales de datos abiertos, bases de datos biom\xE9dicas como UniProt y Wikidata, y sistemas de grafos de conocimiento."
+        },
+        it: {
+          name: "SPARQL",
+          description: "Un linguaggio di interrogazione standard W3C per i dati RDF che abilita le query sul Web Semantico e sui grafi della conoscenza.",
+          longDescription: "SPARQL \xE8 il linguaggio di interrogazione standard per i dati RDF (Resource Description Framework). Permette di interrogare e manipolare dati memorizzati in triplestore ed endpoint di linked data usando la corrispondenza di pattern di grafo.\n\nSPARQL supporta le forme di query SELECT, CONSTRUCT, ASK e DESCRIBE, nonch\xE9 le operazioni UPDATE. \xC8 ampiamente utilizzato in applicazioni di web semantico, portali di dati aperti, database biomedici come UniProt e Wikidata, e sistemi di grafi della conoscenza."
+        },
+        fr: {
+          name: "SPARQL",
+          description: "Un langage de requ\xEAte standard W3C pour les donn\xE9es RDF permettant des requ\xEAtes sur le Web S\xE9mantique et les graphes de connaissances.",
+          longDescription: "SPARQL est le langage de requ\xEAte standard pour les donn\xE9es RDF (Resource Description Framework). Il permet d'interroger et de manipuler des donn\xE9es stock\xE9es dans des triplestores et des points de terminaison de donn\xE9es li\xE9es en utilisant la correspondance de motifs de graphe.\n\nSPARQL prend en charge les formes de requ\xEAte SELECT, CONSTRUCT, ASK et DESCRIBE, ainsi que les op\xE9rations UPDATE. Il est largement utilis\xE9 dans les applications de web s\xE9mantique, les portails de donn\xE9es ouvertes, les bases de donn\xE9es biom\xE9dicales comme UniProt et Wikidata, et les syst\xE8mes de graphes de connaissances."
+        },
+        de: {
+          name: "SPARQL",
+          description: "Eine W3C-Standard-Abfragesprache f\xFCr RDF-Daten, die Abfragen \xFCber das Semantic Web und Wissensgraphen erm\xF6glicht.",
+          longDescription: "SPARQL ist die Standard-Abfragesprache f\xFCr RDF-Daten (Resource Description Framework). Sie erm\xF6glicht die Abfrage und Manipulation von Daten in Triplestores und Linked-Data-Endpunkten mittels Graphmuster-Matching.\n\nSPARQL unterst\xFCtzt die Abfrageformen SELECT, CONSTRUCT, ASK und DESCRIBE sowie UPDATE-Operationen. Es wird in semantischen Web-Anwendungen, Open-Government-Datenportalen, biomedizinischen Datenbanken wie UniProt und Wikidata sowie Wissensgraph-Systemen eingesetzt."
+        },
+        pt: {
+          name: "SPARQL",
+          description: "Uma linguagem de consulta padr\xE3o W3C para dados RDF que permite consultas na Web Sem\xE2ntica e grafos de conhecimento.",
+          longDescription: "SPARQL \xE9 a linguagem de consulta padr\xE3o para dados RDF (Resource Description Framework). Permite consultar e manipular dados armazenados em triplestores e endpoints de linked data usando correspond\xEAncia de padr\xF5es de grafo.\n\nSPARQL suporta formas de consulta SELECT, CONSTRUCT, ASK e DESCRIBE, bem como opera\xE7\xF5es UPDATE. \xC9 amplamente usado em aplica\xE7\xF5es de web sem\xE2ntica, portais de dados abertos, bancos de dados biom\xE9dicos como UniProt e Wikidata, e sistemas de grafos de conhecimento."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/sql.ts
 var sql_exports = {};
 __export(sql_exports, {
@@ -10100,6 +10684,7 @@ init_assembly();
 init_astro();
 init_autohotkey();
 init_awk();
+init_ballerina();
 init_bash();
 init_batch();
 init_bazel();
@@ -10121,6 +10706,7 @@ init_csharp();
 init_css();
 init_cuda();
 init_cue();
+init_cypher();
 init_cython();
 init_d();
 init_dart();
@@ -10128,11 +10714,13 @@ init_dhall();
 init_dita();
 init_dockerfile();
 init_earthly();
+init_eiffel();
 init_elixir();
 init_elm();
 init_erb();
 init_erlang();
 init_fennel();
+init_fish();
 init_forth();
 init_fortran();
 init_fsharp();
@@ -10151,6 +10739,7 @@ init_haskell();
 init_haxe();
 init_hcl();
 init_hlsl();
+init_hocon();
 init_html();
 init_idris();
 init_ini();
@@ -10159,6 +10748,7 @@ init_java();
 init_javascript();
 init_jinja();
 init_json();
+init_json5();
 init_jsonnet();
 init_julia();
 init_jupyter_notebook();
@@ -10181,9 +10771,12 @@ init_meson();
 init_metal();
 init_mojo();
 init_moonbit();
+init_mustache();
 init_nginx();
 init_nim();
 init_nix();
+init_nunjucks();
+init_nushell();
 init_objective_c();
 init_ocaml();
 init_odin();
@@ -10221,6 +10814,7 @@ init_scss();
 init_smalltalk();
 init_smarty();
 init_solidity();
+init_sparql();
 init_sql();
 init_standard_ml();
 init_starlark();
@@ -10273,6 +10867,7 @@ var languages = [
   assembly,
   awk,
   autohotkey,
+  ballerina,
   bash,
   batch,
   bazel,
@@ -10289,6 +10884,7 @@ var languages = [
   cobol,
   coq,
   cpp,
+  cypher,
   csharp,
   crystal,
   css,
@@ -10300,11 +10896,13 @@ var languages = [
   dhall,
   dita,
   dockerfile,
+  eiffel,
   earthly,
   elixir,
   elm,
   erb,
   erlang,
+  fish,
   fennel,
   fortran,
   forth,
@@ -10320,6 +10918,7 @@ var languages = [
   handlebars,
   hack,
   haml,
+  hocon,
   haskell,
   haxe,
   hcl,
@@ -10332,6 +10931,7 @@ var languages = [
   janet,
   jinja,
   json,
+  json5,
   jsonnet,
   jupyterNotebook,
   julia,
@@ -10352,10 +10952,13 @@ var languages = [
   mermaid,
   meson,
   metal,
+  mustache,
   mojo,
   moonbit,
   svn,
   nginx,
+  nunjucks,
+  nushell,
   nim,
   nix,
   ocaml,
@@ -10395,6 +10998,7 @@ var languages = [
   smalltalk,
   smarty,
   solidity,
+  sparql,
   sql,
   standardMl,
   starlark,
@@ -10432,58 +11036,6 @@ var languages = [
   zsh
 ];
 
-// src/match.ts
-var pathSegmentPattern = /[/\\]/;
-var getBasename = (filename) => filename.trim().split(pathSegmentPattern).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.filter(
-    (entry) => entry.extensions.some((extension) => matchesExtension(basename, extension))
-  );
-};
-
-// src/detect.ts
-var detectLanguages = (filename) => {
-  return detectMatchingEntries(languages, filename);
-};
-var detectLanguage = (filename) => detectLanguages(filename).at(0);
-
-// src/i18n.ts
-var localizeLanguage = (language, locale = "en") => {
-  const { i18n, ...metadata } = language;
-  const resolvedLocale = resolveLocale(i18n, locale);
-  const content = i18n[resolvedLocale] ?? i18n.en;
-  return {
-    ...metadata,
-    ...content,
-    locale,
-    resolvedLocale,
-    availableLocales: Object.keys(i18n)
-  };
-};
-var resolveLocale = (translations, locale) => {
-  const normalizedLocale = locale.toLowerCase();
-  const exactLocale = normalizedLocale;
-  if (translations[exactLocale]) {
-    return exactLocale;
-  }
-  const baseLocale = normalizedLocale.split("-")[0];
-  if (translations[baseLocale]) {
-    return baseLocale;
-  }
-  return "en";
-};
-
 // src/language-registry.ts
 var languageIndex = [
   { slug: "abap", extensions: [".abap"] },
@@ -10501,6 +11053,7 @@ var languageIndex = [
   { slug: "assembly", extensions: [".asm", ".s", ".S", ".inc"] },
   { slug: "awk", extensions: [".awk"] },
   { slug: "autohotkey", extensions: [".ahk", ".ah2"] },
+  { slug: "ballerina", extensions: [".bal"] },
   {
     slug: "bash",
     extensions: [".sh", ".bash", ".bashrc", ".bash_profile", ".bash_login", ".profile"]
@@ -10523,6 +11076,7 @@ var languageIndex = [
   { slug: "cobol", extensions: [".cob", ".cbl", ".cobol", ".cpy"] },
   { slug: "coq", extensions: [".v"] },
   { slug: "cpp", extensions: [".cpp", ".cc", ".cxx", ".h", ".hpp", ".hh", ".hxx"] },
+  { slug: "cypher", extensions: [".cypher", ".cyp"] },
   { slug: "csharp", extensions: [".cs", ".csx"] },
   { slug: "crystal", extensions: [".cr"] },
   { slug: "css", extensions: [".css"] },
@@ -10534,6 +11088,7 @@ var languageIndex = [
   { slug: "dhall", extensions: [".dhall"] },
   { slug: "dita", extensions: [".dita", ".ditamap", ".ditaval"] },
   { slug: "dockerfile", extensions: ["Dockerfile", ".dockerfile"] },
+  { slug: "eiffel", extensions: [".e"] },
   { slug: "earthly", extensions: ["Earthfile"] },
   { slug: "elixir", extensions: [".ex", ".exs", ".eex", ".leex", ".heex"] },
   { slug: "elm", extensions: [".elm"] },
@@ -10542,6 +11097,7 @@ var languageIndex = [
     slug: "erlang",
     extensions: [".erl", ".hrl", ".app.src", ".escript", ".xrl", ".yrl", "rebar.config"]
   },
+  { slug: "fish", extensions: [".fish"] },
   { slug: "fennel", extensions: [".fnl"] },
   {
     slug: "fortran",
@@ -10563,6 +11119,7 @@ var languageIndex = [
   { slug: "handlebars", extensions: [".hbs", ".handlebars"] },
   { slug: "hack", extensions: [".hack", ".hh", ".hhi"] },
   { slug: "haml", extensions: [".haml"] },
+  { slug: "hocon", extensions: [".hocon"] },
   { slug: "haskell", extensions: [".hs", ".lhs", ".hsc", ".hs-boot", ".hsig", ".cabal"] },
   { slug: "haxe", extensions: [".hx", ".hxml"] },
   { slug: "hcl", extensions: [".hcl", ".tf", ".tfvars", ".pkr.hcl", ".nomad"] },
@@ -10575,6 +11132,7 @@ var languageIndex = [
   { slug: "janet", extensions: [".janet", ".jdn"] },
   { slug: "jinja", extensions: [".jinja", ".jinja2", ".j2"] },
   { slug: "json", extensions: [".json"] },
+  { slug: "json5", extensions: [".json5"] },
   { slug: "jsonnet", extensions: [".jsonnet", ".libsonnet"] },
   { slug: "jupyter-notebook", extensions: [".ipynb"] },
   { slug: "julia", extensions: [".jl"] },
@@ -10595,10 +11153,13 @@ var languageIndex = [
   { slug: "mermaid", extensions: [".mmd", ".mermaid"] },
   { slug: "meson", extensions: ["meson.build", "meson_options.txt", "meson.options", ".wrap"] },
   { slug: "metal", extensions: [".metal"] },
+  { slug: "mustache", extensions: [".mustache", ".mst"] },
   { slug: "mojo", extensions: [".mojo"] },
   { slug: "moonbit", extensions: [".mbt"] },
   { slug: "svn", extensions: [".svn", "svnserve.conf"] },
   { slug: "nginx", extensions: ["nginx.conf", ".nginx", ".conf"] },
+  { slug: "nunjucks", extensions: [".njk", ".nunjucks"] },
+  { slug: "nushell", extensions: [".nu"] },
   { slug: "nim", extensions: [".nim", ".nims", ".nimble"] },
   { slug: "nix", extensions: [".nix"] },
   { slug: "ocaml", extensions: [".ml", ".mli", ".mll", ".mly", ".mlt", ".eliom", ".eliomi"] },
@@ -10641,6 +11202,7 @@ var languageIndex = [
   { slug: "smalltalk", extensions: [".st"] },
   { slug: "smarty", extensions: [".tpl", ".smarty"] },
   { slug: "solidity", extensions: [".sol"] },
+  { slug: "sparql", extensions: [".sparql", ".rq"] },
   { slug: "sql", extensions: [".sql"] },
   { slug: "standard-ml", extensions: [".sml", ".sig", ".fun"] },
   { slug: "starlark", extensions: [".bzl", ".star", ".sky"] },
@@ -10696,6 +11258,7 @@ var languageLoaders = {
   astro: () => Promise.resolve().then(() => (init_astro(), astro_exports)).then((module) => module.astro),
   autohotkey: () => Promise.resolve().then(() => (init_autohotkey(), autohotkey_exports)).then((module) => module.autohotkey),
   awk: () => Promise.resolve().then(() => (init_awk(), awk_exports)).then((module) => module.awk),
+  ballerina: () => Promise.resolve().then(() => (init_ballerina(), ballerina_exports)).then((module) => module.ballerina),
   bash: () => Promise.resolve().then(() => (init_bash(), bash_exports)).then((module) => module.bash),
   batch: () => Promise.resolve().then(() => (init_batch(), batch_exports)).then((module) => module.batch),
   bazel: () => Promise.resolve().then(() => (init_bazel(), bazel_exports)).then((module) => module.bazel),
@@ -10713,6 +11276,7 @@ var languageLoaders = {
   coq: () => Promise.resolve().then(() => (init_coq(), coq_exports)).then((module) => module.coq),
   cpp: () => Promise.resolve().then(() => (init_cpp(), cpp_exports)).then((module) => module.cpp),
   csharp: () => Promise.resolve().then(() => (init_csharp(), csharp_exports)).then((module) => module.csharp),
+  cypher: () => Promise.resolve().then(() => (init_cypher(), cypher_exports)).then((module) => module.cypher),
   crystal: () => Promise.resolve().then(() => (init_crystal(), crystal_exports)).then((module) => module.crystal),
   css: () => Promise.resolve().then(() => (init_css(), css_exports)).then((module) => module.css),
   cue: () => Promise.resolve().then(() => (init_cue(), cue_exports)).then((module) => module.cue),
@@ -10723,11 +11287,13 @@ var languageLoaders = {
   dhall: () => Promise.resolve().then(() => (init_dhall(), dhall_exports)).then((module) => module.dhall),
   dita: () => Promise.resolve().then(() => (init_dita(), dita_exports)).then((module) => module.dita),
   dockerfile: () => Promise.resolve().then(() => (init_dockerfile(), dockerfile_exports)).then((module) => module.dockerfile),
+  eiffel: () => Promise.resolve().then(() => (init_eiffel(), eiffel_exports)).then((module) => module.eiffel),
   earthly: () => Promise.resolve().then(() => (init_earthly(), earthly_exports)).then((module) => module.earthly),
   elixir: () => Promise.resolve().then(() => (init_elixir(), elixir_exports)).then((module) => module.elixir),
   elm: () => Promise.resolve().then(() => (init_elm(), elm_exports)).then((module) => module.elm),
   erb: () => Promise.resolve().then(() => (init_erb(), erb_exports)).then((module) => module.erb),
   erlang: () => Promise.resolve().then(() => (init_erlang(), erlang_exports)).then((module) => module.erlang),
+  fish: () => Promise.resolve().then(() => (init_fish(), fish_exports)).then((module) => module.fish),
   fennel: () => Promise.resolve().then(() => (init_fennel(), fennel_exports)).then((module) => module.fennel),
   fortran: () => Promise.resolve().then(() => (init_fortran(), fortran_exports)).then((module) => module.fortran),
   forth: () => Promise.resolve().then(() => (init_forth(), forth_exports)).then((module) => module.forth),
@@ -10743,6 +11309,7 @@ var languageLoaders = {
   handlebars: () => Promise.resolve().then(() => (init_handlebars(), handlebars_exports)).then((module) => module.handlebars),
   hack: () => Promise.resolve().then(() => (init_hack(), hack_exports)).then((module) => module.hack),
   haml: () => Promise.resolve().then(() => (init_haml(), haml_exports)).then((module) => module.haml),
+  hocon: () => Promise.resolve().then(() => (init_hocon(), hocon_exports)).then((module) => module.hocon),
   haskell: () => Promise.resolve().then(() => (init_haskell(), haskell_exports)).then((module) => module.haskell),
   haxe: () => Promise.resolve().then(() => (init_haxe(), haxe_exports)).then((module) => module.haxe),
   hcl: () => Promise.resolve().then(() => (init_hcl(), hcl_exports)).then((module) => module.hcl),
@@ -10755,6 +11322,7 @@ var languageLoaders = {
   janet: () => Promise.resolve().then(() => (init_janet(), janet_exports)).then((module) => module.janet),
   jinja: () => Promise.resolve().then(() => (init_jinja(), jinja_exports)).then((module) => module.jinja),
   json: () => Promise.resolve().then(() => (init_json(), json_exports)).then((module) => module.json),
+  json5: () => Promise.resolve().then(() => (init_json5(), json5_exports)).then((module) => module.json5),
   jsonnet: () => Promise.resolve().then(() => (init_jsonnet(), jsonnet_exports)).then((module) => module.jsonnet),
   "jupyter-notebook": () => Promise.resolve().then(() => (init_jupyter_notebook(), jupyter_notebook_exports)).then((module) => module.jupyterNotebook),
   julia: () => Promise.resolve().then(() => (init_julia(), julia_exports)).then((module) => module.julia),
@@ -10775,10 +11343,13 @@ var languageLoaders = {
   mermaid: () => Promise.resolve().then(() => (init_mermaid(), mermaid_exports)).then((module) => module.mermaid),
   meson: () => Promise.resolve().then(() => (init_meson(), meson_exports)).then((module) => module.meson),
   metal: () => Promise.resolve().then(() => (init_metal(), metal_exports)).then((module) => module.metal),
+  mustache: () => Promise.resolve().then(() => (init_mustache(), mustache_exports)).then((module) => module.mustache),
   mojo: () => Promise.resolve().then(() => (init_mojo(), mojo_exports)).then((module) => module.mojo),
   moonbit: () => Promise.resolve().then(() => (init_moonbit(), moonbit_exports)).then((module) => module.moonbit),
   svn: () => Promise.resolve().then(() => (init_svn(), svn_exports)).then((module) => module.svn),
   nginx: () => Promise.resolve().then(() => (init_nginx(), nginx_exports)).then((module) => module.nginx),
+  nunjucks: () => Promise.resolve().then(() => (init_nunjucks(), nunjucks_exports)).then((module) => module.nunjucks),
+  nushell: () => Promise.resolve().then(() => (init_nushell(), nushell_exports)).then((module) => module.nushell),
   nim: () => Promise.resolve().then(() => (init_nim(), nim_exports)).then((module) => module.nim),
   nix: () => Promise.resolve().then(() => (init_nix(), nix_exports)).then((module) => module.nix),
   ocaml: () => Promise.resolve().then(() => (init_ocaml(), ocaml_exports)).then((module) => module.ocaml),
@@ -10818,6 +11389,7 @@ var languageLoaders = {
   smalltalk: () => Promise.resolve().then(() => (init_smalltalk(), smalltalk_exports)).then((module) => module.smalltalk),
   smarty: () => Promise.resolve().then(() => (init_smarty(), smarty_exports)).then((module) => module.smarty),
   solidity: () => Promise.resolve().then(() => (init_solidity(), solidity_exports)).then((module) => module.solidity),
+  sparql: () => Promise.resolve().then(() => (init_sparql(), sparql_exports)).then((module) => module.sparql),
   sql: () => Promise.resolve().then(() => (init_sql(), sql_exports)).then((module) => module.sql),
   "standard-ml": () => Promise.resolve().then(() => (init_standard_ml(), standard_ml_exports)).then((module) => module.standardMl),
   starlark: () => Promise.resolve().then(() => (init_starlark(), starlark_exports)).then((module) => module.starlark),
@@ -10856,6 +11428,56 @@ var languageLoaders = {
 };
 var loadLanguage = (slug) => languageLoaders[slug]?.();
 
+// src/match.ts
+var pathSegmentPattern = /[/\\]/;
+var getBasename = (filename) => filename.trim().split(pathSegmentPattern).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.filter(
+    (entry) => entry.extensions.some((extension) => matchesExtension(basename, extension))
+  );
+};
+
+// src/detect-slugs.ts
+var detectLanguageSlugs = (filename) => detectMatchingEntries(languageIndex, filename).map((entry) => entry.slug);
+var detectLanguageSlug = (filename) => detectLanguageSlugs(filename).at(0);
+
+// src/i18n.ts
+var localizeLanguage = (language, locale = "en") => {
+  const { i18n, ...metadata } = language;
+  const resolvedLocale = resolveLocale(i18n, locale);
+  const content = i18n[resolvedLocale] ?? i18n.en;
+  return {
+    ...metadata,
+    ...content,
+    locale,
+    resolvedLocale,
+    availableLocales: Object.keys(i18n)
+  };
+};
+var resolveLocale = (translations, locale) => {
+  const normalizedLocale = locale.toLowerCase();
+  const exactLocale = normalizedLocale;
+  if (translations[exactLocale]) {
+    return exactLocale;
+  }
+  const baseLocale = normalizedLocale.split("-")[0];
+  if (translations[baseLocale]) {
+    return baseLocale;
+  }
+  return "en";
+};
+
 // src/api.ts
 var defaultLocale = "en";
 var normalizeLanguageSlug = (slug) => slug.trim().toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
@@ -10893,11 +11515,11 @@ var createLanguageCollectionRequest = (getLanguageList, loadLanguageList) => {
   };
   return request;
 };
-var loadDetectedLanguages = (filename) => Promise.all(
-  detectMatchingEntries(languageIndex, filename).map((entry) => loadLanguage(entry.slug))
-).then(
+var loadDetectedLanguages = (filename) => Promise.all(detectLanguageSlugs(filename).map((slug) => loadLanguage(slug))).then(
   (detectedLanguages) => detectedLanguages.filter((language) => Boolean(language))
 );
+var getLanguageBySlug = (slug) => languages.find((language) => language.slug === slug);
+var getDetectedLanguages = (filename) => detectLanguageSlugs(filename).map((slug) => getLanguageBySlug(slug)).filter((language) => Boolean(language));
 var api = {
   /**
    * Selects a language by slug.
@@ -10936,7 +11558,10 @@ var api = {
    */
   detect(filename) {
     return createLanguageRequest(
-      () => detectLanguage(filename),
+      () => {
+        const slug = detectLanguageSlug(filename);
+        return slug ? getLanguageBySlug(slug) : void 0;
+      },
       async () => (await loadDetectedLanguages(filename)).at(0)
     );
   },
@@ -10947,12 +11572,10 @@ var api = {
    */
   detectAll(filename) {
     return createLanguageCollectionRequest(
-      () => detectLanguages(filename),
+      () => getDetectedLanguages(filename),
       () => loadDetectedLanguages(filename)
     );
   }
 };
 
 export { api };
-//# sourceMappingURL=api.js.map
-//# sourceMappingURL=api.js.map