code-languages 1.34.1 → 1.36.0

package/dist/index.cjs

@@ -302,6 +302,64 @@ var init_algol = __esm({
   }
 });
 
+// src/languages/ampl.ts
+var ampl_exports = {};
+__export(ampl_exports, {
+  ampl: () => exports.ampl
+});
+exports.ampl = void 0;
+var init_ampl = __esm({
+  "src/languages/ampl.ts"() {
+    exports.ampl = {
+      slug: "ampl",
+      publishedDate: "1985-01-01",
+      extensions: [".mod", ".dat", ".run"],
+      author: "Robert Fourer, David Gay, and Brian Kernighan",
+      website: "https://ampl.com",
+      paradigms: ["declarative", "mathematical modeling"],
+      tooling: {
+        runtimes: ["AMPL"],
+        ecosystems: ["Optimization", "Operations research"]
+      },
+      version: "stable",
+      logo: "https://ampl.com/wp-content/uploads/AMPL-favicon-36x29-1.svg",
+      color: "#1D4ED8",
+      i18n: {
+        en: {
+          name: "AMPL",
+          description: "A declarative language for describing optimization models and data for mathematical solvers.",
+          longDescription: "AMPL is a modeling language for linear, nonlinear, integer, and constraint optimization. It lets modelers express sets, parameters, variables, objectives, and constraints close to mathematical notation.\n\nThe language is widely used in operations research, logistics, energy planning, finance, and industrial scheduling. AMPL separates model structure from data and connects to many commercial and open source solvers."
+        },
+        es: {
+          name: "AMPL",
+          description: "Lenguaje declarativo para describir modelos y datos de optimizacion para solvers matematicos.",
+          longDescription: "AMPL es un lenguaje de modelado para optimizacion lineal, no lineal, entera y con restricciones. Permite expresar conjuntos, parametros, variables, objetivos y restricciones cerca de la notacion matematica.\n\nEl lenguaje se usa en investigacion de operaciones, logistica, planificacion energetica, finanzas y programacion industrial. AMPL separa la estructura del modelo de los datos y se conecta con muchos solvers comerciales y abiertos."
+        },
+        it: {
+          name: "AMPL",
+          description: "Linguaggio dichiarativo per descrivere modelli e dati di ottimizzazione per solver matematici.",
+          longDescription: "AMPL e un linguaggio di modellazione per ottimizzazione lineare, non lineare, intera e vincolata. Permette di esprimere insiemi, parametri, variabili, obiettivi e vincoli vicino alla notazione matematica.\n\nIl linguaggio e usato in ricerca operativa, logistica, pianificazione energetica, finanza e schedulazione industriale. AMPL separa la struttura del modello dai dati e si collega a molti solver commerciali e open source."
+        },
+        fr: {
+          name: "AMPL",
+          description: "Langage declaratif pour decrire modeles et donnees d optimisation pour solveurs mathematiques.",
+          longDescription: "AMPL est un langage de modelisation pour l optimisation lineaire, non lineaire, entiere et sous contraintes. Il permet d exprimer ensembles, parametres, variables, objectifs et contraintes pres de la notation mathematique.\n\nLe langage est utilise en recherche operationnelle, logistique, planification energetique, finance et ordonnancement industriel. AMPL separe la structure du modele des donnees et se connecte a de nombreux solveurs commerciaux et ouverts."
+        },
+        de: {
+          name: "AMPL",
+          description: "Deklarative Sprache fur Optimierungsmodelle und Daten fur mathematische Solver.",
+          longDescription: "AMPL ist eine Modellierungssprache fur lineare, nichtlineare, ganzzahlige und eingeschrankte Optimierung. Sie beschreibt Mengen, Parameter, Variablen, Ziele und Nebenbedingungen nahe an mathematischer Notation.\n\nDie Sprache wird in Operations Research, Logistik, Energieplanung, Finanzwesen und industrieller Planung genutzt. AMPL trennt Modellstruktur von Daten und bindet viele kommerzielle und offene Solver an."
+        },
+        pt: {
+          name: "AMPL",
+          description: "Linguagem declarativa para descrever modelos e dados de otimizacao para solvers matematicos.",
+          longDescription: "AMPL e uma linguagem de modelagem para otimizacao linear, nao linear, inteira e com restricoes. Ela permite expressar conjuntos, parametros, variaveis, objetivos e restricoes perto da notacao matematica.\n\nA linguagem e usada em pesquisa operacional, logistica, planejamento energetico, financas e escalonamento industrial. AMPL separa a estrutura do modelo dos dados e se conecta a muitos solvers comerciais e abertos."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/ante.ts
 var ante_exports = {};
 __export(ante_exports, {
@@ -323,7 +381,7 @@ var init_ante = __esm({
         ecosystems: ["Systems Programming", "Research", "Compiler Development"]
       },
       version: "experimental",
-      logo: "https://dummyimage.com/32x32/4F46E5/ffffff.png&text=A",
+      logo: "https://antelang.org/img/apple-touch-icon.png",
       color: "#4F46E5",
       i18n: {
         en: {
@@ -615,7 +673,7 @@ var init_aql = __esm({
         ecosystems: ["Graph databases", "Document databases"]
       },
       version: "ArangoDB AQL",
-      logo: "https://dummyimage.com/32x32/16A34A/ffffff.png&text=AQ",
+      logo: "https://cdn.simpleicons.org/arangodb/DDE072",
       color: "#16A34A",
       i18n: {
         en: {
@@ -1064,6 +1122,64 @@ var init_autohotkey = __esm({
   }
 });
 
+// src/languages/avro-idl.ts
+var avro_idl_exports = {};
+__export(avro_idl_exports, {
+  avroIdl: () => exports.avroIdl
+});
+exports.avroIdl = void 0;
+var init_avro_idl = __esm({
+  "src/languages/avro-idl.ts"() {
+    exports.avroIdl = {
+      slug: "avro-idl",
+      publishedDate: "2009-11-02",
+      extensions: [".avdl"],
+      author: "Apache Software Foundation",
+      website: "https://avro.apache.org/docs/current/idl-language/",
+      paradigms: ["schema", "interface definition"],
+      tooling: {
+        runtimes: ["Apache Avro compiler"],
+        ecosystems: ["Serialization", "RPC", "Data Engineering"]
+      },
+      version: "1.12.1",
+      logo: "https://commons.wikimedia.org/wiki/Special:FilePath/Apache_Avro_Logo.svg",
+      color: "#1E88E5",
+      i18n: {
+        en: {
+          name: "Avro IDL",
+          description: "A human-readable interface definition language for Apache Avro schemas and protocols.",
+          longDescription: "Avro IDL defines records, enums, fixed values, errors, messages, namespaces, and imports using a syntax designed for human authors. The Avro compiler converts .avdl files into JSON protocol and schema representations.\n\nIt is used to describe serialized data and RPC interfaces shared by services and data pipelines. Generated schemas participate in Avro compatibility rules and support code generation across multiple programming languages."
+        },
+        es: {
+          name: "Avro IDL",
+          description: "Lenguaje legible de definicion de interfaces para esquemas y protocolos Apache Avro.",
+          longDescription: "Avro IDL define registros, enums, valores fijos, errores, mensajes, espacios de nombres e imports con una sintaxis pensada para personas. El compilador Avro convierte archivos .avdl en protocolos y esquemas JSON.\n\nSe usa para describir datos serializados e interfaces RPC compartidas por servicios y pipelines. Los esquemas generados siguen reglas de compatibilidad Avro y permiten generar codigo en varios lenguajes."
+        },
+        it: {
+          name: "Avro IDL",
+          description: "Linguaggio leggibile di definizione interfacce per schemi e protocolli Apache Avro.",
+          longDescription: "Avro IDL definisce record, enum, valori fissi, errori, messaggi, namespace e import con una sintassi pensata per gli autori. Il compilatore Avro converte i file .avdl in protocolli e schemi JSON.\n\nViene usato per descrivere dati serializzati e interfacce RPC condivise da servizi e pipeline. Gli schemi generati seguono le regole di compatibilita Avro e supportano generazione di codice in diversi linguaggi."
+        },
+        fr: {
+          name: "Avro IDL",
+          description: "Langage lisible de definition d interfaces pour schemas et protocoles Apache Avro.",
+          longDescription: "Avro IDL definit enregistrements, enums, valeurs fixes, erreurs, messages, espaces de noms et imports avec une syntaxe destinee aux auteurs humains. Le compilateur Avro convertit les fichiers .avdl en protocoles et schemas JSON.\n\nIl sert a decrire donnees serialisees et interfaces RPC partagees par services et pipelines. Les schemas generes suivent les regles de compatibilite Avro et permettent la generation de code dans plusieurs langages."
+        },
+        de: {
+          name: "Avro IDL",
+          description: "Menschenlesbare Schnittstellensprache fur Apache-Avro-Schemas und Protokolle.",
+          longDescription: "Avro IDL definiert Records, Enums, feste Werte, Fehler, Nachrichten, Namensraume und Importe mit einer fur Menschen entworfenen Syntax. Der Avro-Compiler wandelt .avdl-Dateien in JSON-Protokolle und Schemas um.\n\nDie Sprache beschreibt serialisierte Daten und RPC-Schnittstellen fur Dienste und Datenpipelines. Erzeugte Schemas folgen Avro-Kompatibilitatsregeln und unterstutzen Codegenerierung fur mehrere Programmiersprachen."
+        },
+        pt: {
+          name: "Avro IDL",
+          description: "Linguagem legivel de definicao de interfaces para esquemas e protocolos Apache Avro.",
+          longDescription: "Avro IDL define registros, enums, valores fixos, erros, mensagens, namespaces e imports com sintaxe voltada a autores humanos. O compilador Avro converte arquivos .avdl em protocolos e esquemas JSON.\n\nE usada para descrever dados serializados e interfaces RPC compartilhadas por servicos e pipelines. Esquemas gerados seguem regras de compatibilidade Avro e permitem geracao de codigo em varias linguagens."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/awk.ts
 var awk_exports = {};
 __export(awk_exports, {
@@ -1085,7 +1201,7 @@ var init_awk = __esm({
         ecosystems: ["Unix", "Text Processing", "Shell", "Data Extraction"]
       },
       version: "GNU Awk 5.4.0",
-      logo: "https://www.gnu.org/graphics/heckert_gnu.small.png",
+      logo: "https://cdn.simpleicons.org/gnu/A42E2B",
       color: "#4E9A06",
       i18n: {
         en: {
@@ -1416,6 +1532,64 @@ var init_bcpl = __esm({
   }
 });
 
+// src/languages/bibtex.ts
+var bibtex_exports = {};
+__export(bibtex_exports, {
+  bibtex: () => exports.bibtex
+});
+exports.bibtex = void 0;
+var init_bibtex = __esm({
+  "src/languages/bibtex.ts"() {
+    exports.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/bicep.ts
 var bicep_exports = {};
 __export(bicep_exports, {
@@ -1612,7 +1786,7 @@ var init_bqn = __esm({
         ecosystems: ["Array Programming", "Data Transformation", "Recreational Computing"]
       },
       version: "BQN specification",
-      logo: "https://dummyimage.com/32x32/7C3AED/ffffff.png&text=BQN",
+      logo: "https://mlochbaum.github.io/BQN/favicon.ico",
       color: "#7C3AED",
       i18n: {
         en: {
@@ -1650,6 +1824,64 @@ var init_bqn = __esm({
   }
 });
 
+// src/languages/brainfuck.ts
+var brainfuck_exports = {};
+__export(brainfuck_exports, {
+  brainfuck: () => exports.brainfuck
+});
+exports.brainfuck = void 0;
+var init_brainfuck = __esm({
+  "src/languages/brainfuck.ts"() {
+    exports.brainfuck = {
+      slug: "brainfuck",
+      publishedDate: "1993-01-01",
+      extensions: [".bf", ".b"],
+      author: "Urban Muller",
+      website: "https://esolangs.org/wiki/Brainfuck",
+      paradigms: ["esoteric", "imperative"],
+      tooling: {
+        runtimes: ["Interpreters", "Compilers"],
+        ecosystems: ["Esoteric programming"]
+      },
+      version: "stable",
+      logo: "https://dummyimage.com/32x32/111827/ffffff.png&text=BF",
+      color: "#111827",
+      i18n: {
+        en: {
+          name: "Brainfuck",
+          description: "An esoteric minimal language built around a tape, a pointer, and eight commands.",
+          longDescription: "Brainfuck is an intentionally tiny esoteric programming language with only eight commands. Programs move a pointer across a memory tape, mutate cells, read or write bytes, and use bracketed loops for control flow.\n\nThe language is rarely used for practical software, but it is influential as a teaching, golfing, interpreter, and compiler exercise. Its extreme simplicity makes it a compact test case for parsers, virtual machines, and code generation."
+        },
+        es: {
+          name: "Brainfuck",
+          description: "Lenguaje esoterico minimo basado en una cinta, un puntero y ocho comandos.",
+          longDescription: "Brainfuck es un lenguaje de programacion esoterico deliberadamente pequeno con solo ocho comandos. Los programas mueven un puntero sobre una cinta de memoria, mutan celdas, leen o escriben bytes y usan bucles con corchetes para control de flujo.\n\nEl lenguaje casi nunca se usa para software practico, pero influye como ejercicio de ensenanza, code golf, interpretes y compiladores. Su simplicidad extrema lo vuelve un caso de prueba compacto para parsers, maquinas virtuales y generacion de codigo."
+        },
+        it: {
+          name: "Brainfuck",
+          description: "Linguaggio esoterico minimo basato su nastro, puntatore e otto comandi.",
+          longDescription: "Brainfuck e un linguaggio di programmazione esoterico volutamente minuscolo con solo otto comandi. I programmi muovono un puntatore su un nastro di memoria, modificano celle, leggono o scrivono byte e usano cicli tra parentesi quadre per il flusso di controllo.\n\nIl linguaggio e usato raramente per software pratico, ma e influente come esercizio didattico, di code golf, interpreti e compilatori. La sua estrema semplicita lo rende un caso di prova compatto per parser, macchine virtuali e generazione di codice."
+        },
+        fr: {
+          name: "Brainfuck",
+          description: "Langage esoterique minimal fonde sur un ruban, un pointeur et huit commandes.",
+          longDescription: "Brainfuck est un langage de programmation esoterique volontairement minuscule avec seulement huit commandes. Les programmes deplacent un pointeur sur un ruban memoire, modifient des cellules, lisent ou ecrivent des octets et utilisent des boucles entre crochets.\n\nLe langage est rarement utilise pour du logiciel pratique, mais il est influent comme exercice d enseignement, de code golf, d interpreteur et de compilateur. Sa simplicite extreme en fait un cas de test compact pour parseurs, machines virtuelles et generation de code."
+        },
+        de: {
+          name: "Brainfuck",
+          description: "Esoterische minimale Sprache mit Speicherband, Zeiger und acht Befehlen.",
+          longDescription: "Brainfuck ist eine absichtlich winzige esoterische Programmiersprache mit nur acht Befehlen. Programme bewegen einen Zeiger uber ein Speicherband, verandern Zellen, lesen oder schreiben Bytes und nutzen geklammerte Schleifen fur Kontrollfluss.\n\nDie Sprache wird selten fur praktische Software genutzt, ist aber einflussreich als Ubung fur Lehre, Code Golf, Interpreter und Compiler. Ihre extreme Einfachheit macht sie zu einem kompakten Testfall fur Parser, virtuelle Maschinen und Codegenerierung."
+        },
+        pt: {
+          name: "Brainfuck",
+          description: "Linguagem esoterica minima baseada em fita, ponteiro e oito comandos.",
+          longDescription: "Brainfuck e uma linguagem de programacao esoterica intencionalmente pequena com apenas oito comandos. Programas movem um ponteiro por uma fita de memoria, alteram celulas, leem ou escrevem bytes e usam loops entre colchetes para fluxo de controle.\n\nA linguagem raramente e usada para software pratico, mas e influente como exercicio de ensino, code golf, interpretadores e compiladores. Sua simplicidade extrema a torna um caso de teste compacto para parsers, maquinas virtuais e geracao de codigo."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/c.ts
 var c_exports = {};
 __export(c_exports, {
@@ -1768,6 +2000,64 @@ var init_cairo = __esm({
   }
 });
 
+// src/languages/capnproto.ts
+var capnproto_exports = {};
+__export(capnproto_exports, {
+  capnproto: () => exports.capnproto
+});
+exports.capnproto = void 0;
+var init_capnproto = __esm({
+  "src/languages/capnproto.ts"() {
+    exports.capnproto = {
+      slug: "capnproto",
+      publishedDate: "2013-01-01",
+      extensions: [".capnp"],
+      author: "Kenton Varda",
+      website: "https://capnproto.org",
+      paradigms: ["schema", "interface definition"],
+      tooling: {
+        runtimes: ["Capn Proto compiler"],
+        ecosystems: ["RPC", "Serialization"]
+      },
+      version: "stable",
+      logo: "https://capnproto.org/images/logo.png",
+      color: "#F97316",
+      i18n: {
+        en: {
+          name: "Cap'n Proto",
+          description: "A schema language for fast serialization and capability-oriented RPC interfaces.",
+          longDescription: "Capn Proto schemas define structured messages, enums, interfaces, and constants for a zero-copy serialization system. The format is designed so data can often be used directly from its encoded representation.\n\nThe language supports code generation for multiple host languages and is paired with an RPC system built around capabilities. It is used when low latency, cross-language contracts, and efficient binary interchange matter."
+        },
+        es: {
+          name: "Cap'n Proto",
+          description: "Lenguaje de esquemas para serializacion rapida e interfaces RPC orientadas a capacidades.",
+          longDescription: "Los esquemas Capn Proto definen mensajes estructurados, enums, interfaces y constantes para un sistema de serializacion zero-copy. El formato esta disenado para que los datos puedan usarse a menudo desde su representacion codificada.\n\nEl lenguaje soporta generacion de codigo para multiples lenguajes anfitriones y se combina con un sistema RPC basado en capacidades. Se usa cuando importan baja latencia, contratos entre lenguajes e intercambio binario eficiente."
+        },
+        it: {
+          name: "Cap'n Proto",
+          description: "Linguaggio di schema per serializzazione veloce e interfacce RPC orientate a capability.",
+          longDescription: "Gli schemi Capn Proto definiscono messaggi strutturati, enum, interfacce e costanti per un sistema di serializzazione zero-copy. Il formato e progettato per usare spesso i dati direttamente dalla rappresentazione codificata.\n\nIl linguaggio supporta generazione di codice per molti linguaggi host ed e abbinato a un sistema RPC basato su capability. E usato quando contano bassa latenza, contratti cross-language e scambio binario efficiente."
+        },
+        fr: {
+          name: "Cap'n Proto",
+          description: "Langage de schema pour serialisation rapide et interfaces RPC orientees capacites.",
+          longDescription: "Les schemas Capn Proto definissent messages structures, enums, interfaces et constantes pour un systeme de serialisation zero-copy. Le format est concu pour permettre souvent l usage direct des donnees depuis leur representation encodee.\n\nLe langage prend en charge la generation de code pour plusieurs langages hotes et s accompagne d un systeme RPC fonde sur les capacites. Il est utilise quand faible latence, contrats inter-langages et echange binaire efficace comptent."
+        },
+        de: {
+          name: "Cap'n Proto",
+          description: "Schemasprache fur schnelle Serialisierung und capability-orientierte RPC-Schnittstellen.",
+          longDescription: "Capn Proto-Schemas definieren strukturierte Nachrichten, Enums, Schnittstellen und Konstanten fur ein Zero-Copy-Serialisierungssystem. Das Format ist so entworfen, dass Daten oft direkt aus ihrer kodierten Darstellung nutzbar sind.\n\nDie Sprache unterstutzt Codegenerierung fur mehrere Hostsprachen und ist mit einem RPC-System rund um Capabilities gekoppelt. Sie wird genutzt, wenn niedrige Latenz, sprachubergreifende Vertrage und effizienter Binar-Austausch wichtig sind."
+        },
+        pt: {
+          name: "Cap'n Proto",
+          description: "Linguagem de esquema para serializacao rapida e interfaces RPC orientadas a capacidades.",
+          longDescription: "Esquemas Capn Proto definem mensagens estruturadas, enums, interfaces e constantes para um sistema de serializacao zero-copy. O formato e projetado para que dados muitas vezes possam ser usados diretamente da representacao codificada.\n\nA linguagem suporta geracao de codigo para varias linguagens hospedeiras e vem junto de um sistema RPC baseado em capacidades. Ela e usada quando baixa latencia, contratos entre linguagens e intercambio binario eficiente importam."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/carbon.ts
 var carbon_exports = {};
 __export(carbon_exports, {
@@ -1827,6 +2117,64 @@ var init_carbon = __esm({
   }
 });
 
+// src/languages/cel.ts
+var cel_exports = {};
+__export(cel_exports, {
+  cel: () => exports.cel
+});
+exports.cel = void 0;
+var init_cel = __esm({
+  "src/languages/cel.ts"() {
+    exports.cel = {
+      slug: "cel",
+      publishedDate: "2018-01-01",
+      extensions: [".cel"],
+      author: "Google / CEL community",
+      website: "https://cel.dev",
+      paradigms: ["expression", "declarative", "configuration"],
+      tooling: {
+        runtimes: ["cel-go", "cel-java", "cel-cpp"],
+        ecosystems: ["Cloud Native", "Policy", "Configuration"]
+      },
+      version: "0.25.2",
+      logo: "https://www.gstatic.com/devrel-devsite/prod/v20cdb2337f656fc22df509b6d5402b3836a1b55334a8eea3301423a87970c4d5/cel/images/touchicon-180.png",
+      color: "#4285F4",
+      i18n: {
+        en: {
+          name: "Common Expression Language",
+          description: "A portable, non-Turing-complete language for fast and safe expression evaluation.",
+          longDescription: "Common Expression Language provides a compact syntax for evaluating conditions, transformations, and policy rules inside host applications. Its non-Turing-complete design keeps evaluation predictable and suitable for untrusted expressions.\n\nCEL is embedded in cloud APIs, validation systems, authorization policies, and configuration tools. A shared specification and conformance tests support compatible implementations across several host languages."
+        },
+        es: {
+          name: "Lenguaje Comun de Expresiones",
+          description: "Lenguaje portable y no Turing-completo para evaluar expresiones de forma rapida y segura.",
+          longDescription: "Common Expression Language ofrece una sintaxis compacta para evaluar condiciones, transformaciones y reglas de politica dentro de aplicaciones anfitrionas. Su diseno no Turing-completo mantiene la evaluacion predecible y apta para expresiones no confiables.\n\nCEL se integra en API de nube, sistemas de validacion, politicas de autorizacion y herramientas de configuracion. Una especificacion comun y pruebas de conformidad permiten implementaciones compatibles en varios lenguajes."
+        },
+        it: {
+          name: "Common Expression Language",
+          description: "Linguaggio portabile e non Turing-completo per valutare espressioni in modo rapido e sicuro.",
+          longDescription: "Common Expression Language offre una sintassi compatta per valutare condizioni, trasformazioni e regole di policy nelle applicazioni host. Il design non Turing-completo rende la valutazione prevedibile e adatta a espressioni non attendibili.\n\nCEL viene incorporato in API cloud, sistemi di validazione, policy di autorizzazione e strumenti di configurazione. Una specifica comune e test di conformita supportano implementazioni compatibili in diversi linguaggi."
+        },
+        fr: {
+          name: "Common Expression Language",
+          description: "Langage portable et non Turing-complet pour evaluer des expressions rapidement et surement.",
+          longDescription: "Common Expression Language fournit une syntaxe compacte pour evaluer conditions, transformations et regles de politique dans des applications hotes. Sa conception non Turing-complete rend l evaluation previsible et adaptee aux expressions non fiables.\n\nCEL est integre aux API cloud, systemes de validation, politiques d autorisation et outils de configuration. Une specification commune et des tests de conformite assurent des implementations compatibles dans plusieurs langages."
+        },
+        de: {
+          name: "Common Expression Language",
+          description: "Portable, nicht Turing-vollstandige Sprache zur schnellen und sicheren Ausdrucksauswertung.",
+          longDescription: "Common Expression Language bietet eine kompakte Syntax zur Auswertung von Bedingungen, Transformationen und Richtlinien in Host-Anwendungen. Das nicht Turing-vollstandige Design macht die Auswertung vorhersehbar und fur nicht vertrauenswurdige Ausdrucke geeignet.\n\nCEL wird in Cloud-APIs, Validierungssysteme, Autorisierungsrichtlinien und Konfigurationswerkzeuge eingebettet. Eine gemeinsame Spezifikation und Konformitatstests ermoglichen kompatible Implementierungen in mehreren Sprachen."
+        },
+        pt: {
+          name: "Common Expression Language",
+          description: "Linguagem portavel e nao Turing-completa para avaliar expressoes com rapidez e seguranca.",
+          longDescription: "Common Expression Language oferece sintaxe compacta para avaliar condicoes, transformacoes e regras de politica em aplicacoes hospedeiras. Seu design nao Turing-completo torna a avaliacao previsivel e adequada para expressoes nao confiaveis.\n\nCEL e incorporada em APIs de nuvem, sistemas de validacao, politicas de autorizacao e ferramentas de configuracao. Uma especificacao comum e testes de conformidade sustentam implementacoes compativeis em varias linguagens."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/chapel.ts
 var chapel_exports = {};
 __export(chapel_exports, {
@@ -2356,6 +2704,64 @@ var init_cpp = __esm({
   }
 });
 
+// src/languages/cql.ts
+var cql_exports = {};
+__export(cql_exports, {
+  cql: () => exports.cql
+});
+exports.cql = void 0;
+var init_cql = __esm({
+  "src/languages/cql.ts"() {
+    exports.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: ["Apache Cassandra"],
+        ecosystems: ["NoSQL", "Distributed databases"]
+      },
+      version: "CQL 3",
+      logo: "https://cdn.simpleicons.org/apachecassandra/1287B1",
+      color: "#1287B1",
+      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."
+        },
+        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."
+        },
+        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: "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: "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: "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/crystal.ts
 var crystal_exports = {};
 __export(crystal_exports, {
@@ -2667,7 +3073,7 @@ var init_curry = __esm({
         ecosystems: ["Functional Logic Programming", "Constraint Solving", "Research"]
       },
       version: "Curry 0.9.0",
-      logo: "https://dummyimage.com/32x32/BE123C/ffffff.png&text=Cu",
+      logo: "https://www.curry-language.org/assets/img/curry-32x32.png",
       color: "#BE123C",
       i18n: {
         en: {
@@ -2902,7 +3308,7 @@ var init_dafny = __esm({
         ecosystems: ["Formal Methods", ".NET", "Verification"]
       },
       version: "4.11.0",
-      logo: "https://dummyimage.com/32x32/0B6D91/ffffff.png&text=D",
+      logo: "https://dafny.org/images/dafny-favicon.svg",
       color: "#0B6D91",
       i18n: {
         en: {
@@ -3175,6 +3581,64 @@ var init_dockerfile = __esm({
   }
 });
 
+// src/languages/dot.ts
+var dot_exports = {};
+__export(dot_exports, {
+  dot: () => exports.dot
+});
+exports.dot = void 0;
+var init_dot = __esm({
+  "src/languages/dot.ts"() {
+    exports.dot = {
+      slug: "dot",
+      publishedDate: "1991-01-01",
+      extensions: [".dot", ".gv"],
+      author: "AT&T Bell Laboratories",
+      website: "https://graphviz.org/doc/info/lang.html",
+      paradigms: ["declarative", "graph description"],
+      tooling: {
+        runtimes: ["Graphviz"],
+        ecosystems: ["Visualization", "Documentation"]
+      },
+      version: "stable",
+      logo: "https://graphviz.org/Resources/favicon.png",
+      color: "#16A34A",
+      i18n: {
+        en: {
+          name: "DOT",
+          description: "A declarative graph description language used by Graphviz for diagrams and layouts.",
+          longDescription: "DOT is a text language for describing directed and undirected graphs. It defines nodes, edges, subgraphs, attributes, labels, and layout hints that Graphviz tools render into diagrams.\n\nThe language is common in documentation, architecture diagrams, compiler output, dependency graphs, state machines, and generated reports. Its compact syntax makes graphs easy to version, review, and produce from programs."
+        },
+        es: {
+          name: "DOT",
+          description: "Lenguaje declarativo de grafos usado por Graphviz para diagramas y layouts.",
+          longDescription: "DOT es un lenguaje de texto para describir grafos dirigidos y no dirigidos. Define nodos, aristas, subgrafos, atributos, etiquetas y pistas de layout que las herramientas Graphviz renderizan como diagramas.\n\nEl lenguaje es comun en documentacion, diagramas de arquitectura, salida de compiladores, grafos de dependencias, maquinas de estado e informes generados. Su sintaxis compacta facilita versionar, revisar y producir grafos desde programas."
+        },
+        it: {
+          name: "DOT",
+          description: "Linguaggio dichiarativo per grafi usato da Graphviz per diagrammi e layout.",
+          longDescription: "DOT e un linguaggio testuale per descrivere grafi diretti e non diretti. Definisce nodi, archi, sottografi, attributi, etichette e suggerimenti di layout che gli strumenti Graphviz rendono come diagrammi.\n\nIl linguaggio e comune in documentazione, diagrammi architetturali, output di compilatori, grafi di dipendenze, macchine a stati e report generati. La sua sintassi compatta rende i grafi facili da versionare, revisionare e produrre da programmi."
+        },
+        fr: {
+          name: "DOT",
+          description: "Langage declaratif de graphes utilise par Graphviz pour diagrammes et mises en page.",
+          longDescription: "DOT est un langage texte pour decrire des graphes orientes et non orientes. Il definit noeuds, aretes, sous-graphes, attributs, libelles et indications de mise en page que les outils Graphviz rendent en diagrammes.\n\nLe langage est courant dans la documentation, les diagrammes d architecture, les sorties de compilateurs, les graphes de dependances, les machines a etats et les rapports generes. Sa syntaxe compacte facilite le versionnement, la revue et la production de graphes depuis des programmes."
+        },
+        de: {
+          name: "DOT",
+          description: "Deklarative Graphbeschreibungssprache von Graphviz fur Diagramme und Layouts.",
+          longDescription: "DOT ist eine Textsprache zum Beschreiben gerichteter und ungerichteter Graphen. Sie definiert Knoten, Kanten, Teilgraphen, Attribute, Beschriftungen und Layout-Hinweise, die Graphviz-Werkzeuge als Diagramme rendern.\n\nDie Sprache ist verbreitet in Dokumentation, Architekturdiagrammen, Compiler-Ausgaben, Abhangigkeitsgraphen, Zustandsmaschinen und generierten Berichten. Ihre kompakte Syntax macht Graphen leicht versionierbar, reviewbar und aus Programmen erzeugbar."
+        },
+        pt: {
+          name: "DOT",
+          description: "Linguagem declarativa de grafos usada pelo Graphviz para diagramas e layouts.",
+          longDescription: "DOT e uma linguagem de texto para descrever grafos dirigidos e nao dirigidos. Ela define nos, arestas, subgrafos, atributos, rotulos e dicas de layout que ferramentas Graphviz renderizam como diagramas.\n\nA linguagem e comum em documentacao, diagramas de arquitetura, saida de compiladores, grafos de dependencias, maquinas de estado e relatorios gerados. Sua sintaxe compacta facilita versionar, revisar e produzir grafos a partir de programas."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/earthly.ts
 var earthly_exports = {};
 __export(earthly_exports, {
@@ -3234,6 +3698,63 @@ var init_earthly = __esm({
   }
 });
 
+// src/languages/editorconfig.ts
+var editorconfig_exports = {};
+__export(editorconfig_exports, {
+  editorconfig: () => exports.editorconfig
+});
+exports.editorconfig = void 0;
+var init_editorconfig = __esm({
+  "src/languages/editorconfig.ts"() {
+    exports.editorconfig = {
+      slug: "editorconfig",
+      publishedDate: "2011-01-01",
+      extensions: [".editorconfig"],
+      author: "EditorConfig project",
+      website: "https://editorconfig.org",
+      paradigms: ["configuration"],
+      tooling: {
+        ecosystems: ["Editors", "Code formatting"]
+      },
+      version: "stable",
+      logo: "https://editorconfig.org/logo.png",
+      color: "#0F766E",
+      i18n: {
+        en: {
+          name: "EditorConfig",
+          description: "A configuration format for sharing indentation, newline, and charset rules across editors.",
+          longDescription: "EditorConfig files define coding style settings that editors and IDEs can apply consistently. Sections target filename globs and assign properties such as indentation style, indent size, end-of-line mode, charset, and trailing whitespace handling.\n\nThe format helps projects keep basic formatting stable across teams and tools. It is often committed at repository roots so contributors get consistent editor behavior without manual setup."
+        },
+        es: {
+          name: "EditorConfig",
+          description: "Formato de configuracion para compartir indentacion, saltos de linea y charset entre editores.",
+          longDescription: "Los archivos EditorConfig definen ajustes de estilo que editores e IDEs pueden aplicar de forma consistente. Las secciones apuntan a globs de nombres de archivo y asignan propiedades como estilo de indentacion, tamano, modo de fin de linea, charset y manejo de espacios finales.\n\nEl formato ayuda a mantener estable el formato basico entre equipos y herramientas. Suele versionarse en la raiz del repositorio para que colaboradores obtengan comportamiento consistente sin configuracion manual."
+        },
+        it: {
+          name: "EditorConfig",
+          description: "Formato di configurazione per condividere indentazione, newline e charset tra editor.",
+          longDescription: "I file EditorConfig definiscono impostazioni di stile che editor e IDE possono applicare in modo coerente. Le sezioni puntano a glob di nomi file e assegnano proprieta come stile e dimensione di indentazione, fine riga, charset e gestione degli spazi finali.\n\nIl formato aiuta i progetti a mantenere stabile la formattazione di base tra team e strumenti. Spesso viene committato alla radice del repository per dare ai contributori un comportamento editor coerente senza setup manuale."
+        },
+        fr: {
+          name: "EditorConfig",
+          description: "Format de configuration pour partager indentation, fins de ligne et charset entre editeurs.",
+          longDescription: "Les fichiers EditorConfig definissent des reglages de style que les editeurs et IDE peuvent appliquer de facon coherente. Les sections ciblent des globs de fichiers et assignent des proprietes comme style d indentation, taille, fin de ligne, charset et gestion des espaces finaux.\n\nLe format aide les projets a garder un formatage de base stable entre equipes et outils. Il est souvent versionne a la racine du depot pour offrir un comportement editeur coherent sans configuration manuelle."
+        },
+        de: {
+          name: "EditorConfig",
+          description: "Konfigurationsformat fur Einruckung, Zeilenenden und Zeichensatze uber Editoren hinweg.",
+          longDescription: "EditorConfig-Dateien definieren Stilvorgaben, die Editoren und IDEs konsistent anwenden konnen. Abschnitte zielen auf Dateinamen-Globs und setzen Eigenschaften wie Einruckungsstil, Einruckungsbreite, Zeilenende, Zeichensatz und Behandlung nachgestellter Leerzeichen.\n\nDas Format hilft Projekten, grundlegende Formatierung uber Teams und Werkzeuge stabil zu halten. Es liegt oft im Repository-Wurzelverzeichnis, damit Beitragende ohne manuelles Setup konsistentes Editorverhalten erhalten."
+        },
+        pt: {
+          name: "EditorConfig",
+          description: "Formato de configuracao para compartilhar indentacao, quebras de linha e charset entre editores.",
+          longDescription: "Arquivos EditorConfig definem ajustes de estilo que editores e IDEs podem aplicar de forma consistente. Secoes miram globs de nomes de arquivo e atribuem propriedades como estilo de indentacao, tamanho, modo de fim de linha, charset e tratamento de espacos finais.\n\nO formato ajuda projetos a manter a formatacao basica estavel entre equipes e ferramentas. Ele costuma ser versionado na raiz do repositorio para que colaboradores tenham comportamento consistente no editor sem setup manual."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/eiffel.ts
 var eiffel_exports = {};
 __export(eiffel_exports, {
@@ -3609,7 +4130,7 @@ var init_factor = __esm({
         ecosystems: ["Interactive Development", "Language Research", "Desktop Tools"]
       },
       version: "0.101",
-      logo: "https://dummyimage.com/32x32/F97316/ffffff.png&text=F",
+      logo: "https://factorcode.org/favicon-96x96.png",
       color: "#F97316",
       i18n: {
         en: {
@@ -3667,7 +4188,7 @@ var init_fe = __esm({
         ecosystems: ["Ethereum", "EVM"]
       },
       version: "experimental",
-      logo: "https://dummyimage.com/32x32/4F46E5/ffffff.png&text=Fe",
+      logo: "https://fe-lang.org/favicon.png",
       color: "#4F46E5",
       i18n: {
         en: {
@@ -3823,6 +4344,64 @@ var init_fish = __esm({
   }
 });
 
+// src/languages/flatbuffers.ts
+var flatbuffers_exports = {};
+__export(flatbuffers_exports, {
+  flatbuffers: () => exports.flatbuffers
+});
+exports.flatbuffers = void 0;
+var init_flatbuffers = __esm({
+  "src/languages/flatbuffers.ts"() {
+    exports.flatbuffers = {
+      slug: "flatbuffers",
+      publishedDate: "2014-06-17",
+      extensions: [".fbs"],
+      author: "Wouter van Oortmerssen / Google",
+      website: "https://flatbuffers.dev",
+      paradigms: ["schema", "interface definition"],
+      tooling: {
+        runtimes: ["flatc"],
+        ecosystems: ["Serialization", "Games", "Mobile"]
+      },
+      version: "25.12.19",
+      logo: "https://flatbuffers.dev/assets/images/favicon.png",
+      color: "#0F9D58",
+      i18n: {
+        en: {
+          name: "FlatBuffers",
+          description: "A schema language for memory-efficient, cross-platform serialization without unpacking.",
+          longDescription: "FlatBuffers schemas define tables, structs, enums, unions, services, and namespaces for compact binary data. The flatc compiler generates strongly typed access code for many host languages.\n\nIts format lets applications read serialized data without a separate parsing or unpacking step. It is used in games, mobile applications, embedded systems, and performance-sensitive services where allocation and latency matter."
+        },
+        es: {
+          name: "FlatBuffers",
+          description: "Lenguaje de esquemas para serializacion eficiente y multiplataforma sin desempaquetado.",
+          longDescription: "Los esquemas FlatBuffers definen tablas, structs, enums, uniones, servicios y espacios de nombres para datos binarios compactos. El compilador flatc genera acceso tipado para muchos lenguajes anfitriones.\n\nEl formato permite leer datos serializados sin una fase separada de parseo o desempaquetado. Se usa en juegos, aplicaciones moviles, sistemas embebidos y servicios sensibles a asignaciones y latencia."
+        },
+        it: {
+          name: "FlatBuffers",
+          description: "Linguaggio di schema per serializzazione efficiente e multipiattaforma senza unpacking.",
+          longDescription: "Gli schemi FlatBuffers definiscono tabelle, struct, enum, unioni, servizi e namespace per dati binari compatti. Il compilatore flatc genera accesso fortemente tipizzato per molti linguaggi host.\n\nIl formato consente di leggere dati serializzati senza una fase separata di parsing o unpacking. E usato in giochi, applicazioni mobili, sistemi embedded e servizi sensibili ad allocazioni e latenza."
+        },
+        fr: {
+          name: "FlatBuffers",
+          description: "Langage de schema pour serialisation efficace et multiplateforme sans depaquetage.",
+          longDescription: "Les schemas FlatBuffers definissent tables, structures, enums, unions, services et espaces de noms pour des donnees binaires compactes. Le compilateur flatc genere un acces fortement type pour de nombreux langages hotes.\n\nLe format permet de lire les donnees serialisees sans phase distincte d analyse ou de depaquetage. Il est utilise dans jeux, applications mobiles, systemes embarques et services sensibles aux allocations et a la latence."
+        },
+        de: {
+          name: "FlatBuffers",
+          description: "Schemasprache fur speichereffiziente, plattformubergreifende Serialisierung ohne Entpacken.",
+          longDescription: "FlatBuffers-Schemas definieren Tabellen, Structs, Enums, Unions, Dienste und Namensraume fur kompakte Binardaten. Der flatc-Compiler erzeugt stark typisierten Zugriffscode fur viele Hostsprachen.\n\nDas Format erlaubt direkten Zugriff auf serialisierte Daten ohne separaten Parsing- oder Entpackschritt. Es wird in Spielen, mobilen Anwendungen, eingebetteten Systemen und latenzkritischen Diensten eingesetzt."
+        },
+        pt: {
+          name: "FlatBuffers",
+          description: "Linguagem de esquema para serializacao eficiente e multiplataforma sem desempacotar.",
+          longDescription: "Esquemas FlatBuffers definem tabelas, structs, enums, unioes, servicos e namespaces para dados binarios compactos. O compilador flatc gera acesso fortemente tipado para varias linguagens hospedeiras.\n\nO formato permite ler dados serializados sem etapa separada de parsing ou desempacotamento. E usado em jogos, apps moveis, sistemas embarcados e servicos sensiveis a alocacao e latencia."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/flux.ts
 var flux_exports = {};
 __export(flux_exports, {
@@ -3998,6 +4577,64 @@ var init_fortran = __esm({
   }
 });
 
+// src/languages/fql.ts
+var fql_exports = {};
+__export(fql_exports, {
+  fql: () => exports.fql
+});
+exports.fql = void 0;
+var init_fql = __esm({
+  "src/languages/fql.ts"() {
+    exports.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, {
@@ -4019,7 +4656,7 @@ var init_freemarker = __esm({
         ecosystems: ["Java", "Web", "Apache"]
       },
       version: "2.3.34",
-      logo: "https://dummyimage.com/32x32/326CE5/ffffff.png&text=FM",
+      logo: "https://freemarker.apache.org/favicon.png",
       color: "#326CE5",
       i18n: {
         en: {
@@ -4137,7 +4774,7 @@ var init_fstar = __esm({
         ecosystems: ["Formal Methods", "ML", "Low-level Verification"]
       },
       version: "2026.04.17",
-      logo: "https://dummyimage.com/32x32/572E91/ffffff.png&text=F%2A",
+      logo: "https://fstar-lang.org/favicon.ico",
       color: "#572E91",
       i18n: {
         en: {
@@ -4175,6 +4812,64 @@ var init_fstar = __esm({
   }
 });
 
+// src/languages/gcode.ts
+var gcode_exports = {};
+__export(gcode_exports, {
+  gcode: () => exports.gcode
+});
+exports.gcode = void 0;
+var init_gcode = __esm({
+  "src/languages/gcode.ts"() {
+    exports.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/gdscript.ts
 var gdscript_exports = {};
 __export(gdscript_exports, {
@@ -4234,6 +4929,64 @@ var init_gdscript = __esm({
   }
 });
 
+// src/languages/gettext.ts
+var gettext_exports = {};
+__export(gettext_exports, {
+  gettext: () => exports.gettext
+});
+exports.gettext = void 0;
+var init_gettext = __esm({
+  "src/languages/gettext.ts"() {
+    exports.gettext = {
+      slug: "gettext",
+      publishedDate: "1995-01-01",
+      extensions: [".po", ".pot"],
+      author: "GNU Project",
+      website: "https://www.gnu.org/software/gettext",
+      paradigms: ["localization", "data"],
+      tooling: {
+        runtimes: ["GNU gettext"],
+        ecosystems: ["Internationalization", "Localization"]
+      },
+      version: "stable",
+      logo: "https://dummyimage.com/32x32/7C3AED/ffffff.png&text=PO",
+      color: "#7C3AED",
+      i18n: {
+        en: {
+          name: "Gettext",
+          description: "A localization message catalog format for translating software strings.",
+          longDescription: "Gettext PO and POT files store translatable messages, translations, contexts, plural forms, comments, and source references. The format is line-oriented text, designed for extraction tools and translation workflows.\n\nIt is widely used in free software, desktop applications, command-line tools, web frameworks, and content systems. Gettext catalogs let source strings stay in code while translators work in separate message files."
+        },
+        es: {
+          name: "Gettext",
+          description: "Formato de catalogo de mensajes de localizacion para traducir cadenas de software.",
+          longDescription: "Los archivos PO y POT de Gettext almacenan mensajes traducibles, traducciones, contextos, formas plurales, comentarios y referencias de origen. El formato es texto orientado a lineas, disenado para herramientas de extraccion y flujos de traduccion.\n\nSe usa ampliamente en software libre, aplicaciones de escritorio, herramientas de linea de comandos, frameworks web y sistemas de contenido. Los catalogos Gettext permiten mantener cadenas fuente en codigo mientras traductores trabajan en archivos separados."
+        },
+        it: {
+          name: "Gettext",
+          description: "Formato di catalogo messaggi per localizzazione e traduzione di stringhe software.",
+          longDescription: "I file PO e POT di Gettext memorizzano messaggi traducibili, traduzioni, contesti, forme plurali, commenti e riferimenti sorgente. Il formato e testo orientato alle righe, progettato per strumenti di estrazione e flussi di traduzione.\n\nE molto usato in software libero, applicazioni desktop, strumenti a riga di comando, framework web e sistemi di contenuto. I cataloghi Gettext permettono di tenere le stringhe sorgente nel codice mentre i traduttori lavorano in file separati."
+        },
+        fr: {
+          name: "Gettext",
+          description: "Format de catalogue de messages de localisation pour traduire les chaines logicielles.",
+          longDescription: "Les fichiers PO et POT de Gettext stockent messages traduisibles, traductions, contextes, formes plurielles, commentaires et references source. Le format est un texte oriente lignes, concu pour les outils d extraction et les flux de traduction.\n\nIl est tres utilise dans le logiciel libre, les applications de bureau, les outils en ligne de commande, les frameworks web et les systemes de contenu. Les catalogues Gettext gardent les chaines source dans le code tandis que les traducteurs travaillent dans des fichiers separes."
+        },
+        de: {
+          name: "Gettext",
+          description: "Lokalisierungs-Katalogformat zum Ubersetzen von Software-Zeichenketten.",
+          longDescription: "Gettext-PO- und POT-Dateien speichern ubersetzbare Meldungen, Ubersetzungen, Kontexte, Pluralformen, Kommentare und Quellreferenzen. Das Format ist zeilenorientierter Text fur Extraktionswerkzeuge und Ubersetzungsablaufe.\n\nEs wird breit in freier Software, Desktop-Anwendungen, Kommandozeilenwerkzeugen, Webframeworks und Content-Systemen genutzt. Gettext-Kataloge lassen Quellstrings im Code, wahrend Ubersetzer in separaten Meldungsdateien arbeiten."
+        },
+        pt: {
+          name: "Gettext",
+          description: "Formato de catalogo de mensagens de localizacao para traduzir strings de software.",
+          longDescription: "Arquivos PO e POT de Gettext armazenam mensagens traduziveis, traducoes, contextos, formas plurais, comentarios e referencias de origem. O formato e texto orientado a linhas, feito para ferramentas de extracao e fluxos de traducao.\n\nEle e muito usado em software livre, aplicativos desktop, ferramentas de linha de comando, frameworks web e sistemas de conteudo. Catalogos Gettext deixam strings fonte no codigo enquanto tradutores trabalham em arquivos separados."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/git.ts
 var git_exports = {};
 __export(git_exports, {
@@ -4646,6 +5399,64 @@ var init_graphql = __esm({
   }
 });
 
+// src/languages/gremlin.ts
+var gremlin_exports = {};
+__export(gremlin_exports, {
+  gremlin: () => exports.gremlin
+});
+exports.gremlin = void 0;
+var init_gremlin = __esm({
+  "src/languages/gremlin.ts"() {
+    exports.gremlin = {
+      slug: "gremlin",
+      publishedDate: "2009-10-01",
+      extensions: [".gremlin", ".grem"],
+      author: "Apache TinkerPop project",
+      website: "https://tinkerpop.apache.org/gremlin.html",
+      paradigms: ["graph query", "traversal"],
+      tooling: {
+        runtimes: ["Apache TinkerPop", "Gremlin Console"],
+        ecosystems: ["Graph databases", "Knowledge graphs"]
+      },
+      version: "stable",
+      logo: "https://cdn.simpleicons.org/apache/6B7280",
+      color: "#6B7280",
+      i18n: {
+        en: {
+          name: "Gremlin",
+          description: "A graph traversal language for Apache TinkerPop-compatible graph systems.",
+          longDescription: "Gremlin is a graph traversal language from Apache TinkerPop. It describes walks through vertices and edges using steps for filtering, mapping, branching, aggregation, mutation, and path analysis.\n\nThe language is used across graph databases and services that implement the TinkerPop stack. It fits recommendation systems, network analysis, fraud detection, identity graphs, and applications where relationships are queried as first-class structure."
+        },
+        es: {
+          name: "Gremlin",
+          description: "Lenguaje de recorrido de grafos para sistemas compatibles con TinkerPop.",
+          longDescription: "Gremlin es un lenguaje de recorrido de grafos de Apache TinkerPop. Describe caminos por vertices y aristas usando pasos para filtrar, mapear, ramificar, agregar, mutar y analizar rutas.\n\nEl lenguaje se usa en bases de datos y servicios de grafos que implementan el stack TinkerPop. Encaja en recomendadores, analisis de redes, deteccion de fraude, grafos de identidad y apps donde las relaciones se consultan como estructura principal."
+        },
+        it: {
+          name: "Gremlin",
+          description: "Linguaggio di attraversamento grafi per sistemi compatibili con TinkerPop.",
+          longDescription: "Gremlin e un linguaggio di attraversamento grafi di Apache TinkerPop. Descrive cammini tra vertici e archi usando step per filtrare, mappare, ramificare, aggregare, modificare e analizzare percorsi.\n\nIl linguaggio e usato in database e servizi graph che implementano lo stack TinkerPop. Si adatta a raccomandazioni, analisi di reti, rilevamento frodi, grafi di identita e app dove le relazioni sono interrogate come struttura primaria."
+        },
+        fr: {
+          name: "Gremlin",
+          description: "Langage de parcours de graphes pour systemes compatibles TinkerPop.",
+          longDescription: "Gremlin est un langage de parcours de graphes issu d Apache TinkerPop. Il decrit des trajets dans sommets et aretes avec des etapes de filtrage, projection, branchement, agregation, mutation et analyse de chemins.\n\nLe langage est utilise dans bases et services de graphes qui implementent TinkerPop. Il convient aux recommandations, analyses de reseaux, detection de fraude, graphes d identite et apps ou les relations sont une structure de requete centrale."
+        },
+        de: {
+          name: "Gremlin",
+          description: "Graph-Traversal-Sprache fur Apache-TinkerPop-kompatible Systeme.",
+          longDescription: "Gremlin ist eine Graph-Traversal-Sprache aus Apache TinkerPop. Sie beschreibt Wege durch Vertices und Edges mit Schritten fur Filtern, Mapping, Verzweigung, Aggregation, Mutation und Pfadanalyse.\n\nDie Sprache wird in Graphdatenbanken und Diensten genutzt, die den TinkerPop-Stack implementieren. Sie passt zu Empfehlungen, Netzwerkanalyse, Betrugserkennung, Identitatsgraphen und Anwendungen, in denen Beziehungen als zentrale Struktur abgefragt werden."
+        },
+        pt: {
+          name: "Gremlin",
+          description: "Linguagem de travessia de grafos para sistemas compativeis com TinkerPop.",
+          longDescription: "Gremlin e uma linguagem de travessia de grafos do Apache TinkerPop. Ela descreve caminhadas por vertices e arestas usando passos para filtrar, mapear, ramificar, agregar, alterar e analisar caminhos.\n\nA linguagem e usada em bancos e servicos de grafos que implementam o stack TinkerPop. Ela serve para recomendacao, analise de redes, deteccao de fraude, grafos de identidade e apps onde relacoes sao consultadas como estrutura principal."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/groovy.ts
 var groovy_exports = {};
 __export(groovy_exports, {
@@ -5484,7 +6295,7 @@ var init_ink = __esm({
         ecosystems: ["Polkadot", "Substrate", "Rust"]
       },
       version: "Ink! 6",
-      logo: "https://dummyimage.com/32x32/EC4899/ffffff.png&text=In",
+      logo: "https://use.ink/img/favicon.png",
       color: "#EC4899",
       i18n: {
         en: {
@@ -5600,7 +6411,7 @@ var init_isabelle = __esm({
         ecosystems: ["Formal Methods", "Proof Assistants", "Higher-order Logic"]
       },
       version: "Isabelle2025-2",
-      logo: "https://dummyimage.com/32x32/6A5ACD/ffffff.png&text=Is",
+      logo: "https://isabelle.in.tum.de/img/favicon.ico",
       color: "#6A5ACD",
       i18n: {
         en: {
@@ -5874,6 +6685,64 @@ var init_jinja = __esm({
   }
 });
 
+// src/languages/jmespath.ts
+var jmespath_exports = {};
+__export(jmespath_exports, {
+  jmespath: () => exports.jmespath
+});
+exports.jmespath = void 0;
+var init_jmespath = __esm({
+  "src/languages/jmespath.ts"() {
+    exports.jmespath = {
+      slug: "jmespath",
+      publishedDate: "2013-01-01",
+      extensions: [".jmespath", ".jp"],
+      author: "James Saryerwinnie",
+      website: "https://jmespath.org",
+      paradigms: ["query", "functional"],
+      tooling: {
+        runtimes: ["JMESPath libraries", "AWS CLI"],
+        ecosystems: ["JSON", "Cloud tooling"]
+      },
+      version: "stable",
+      logo: "https://jmespath.org/_static/img/logo.png",
+      color: "#2F80ED",
+      i18n: {
+        en: {
+          name: "JMESPath",
+          description: "A declarative query language for extracting and transforming JSON data.",
+          longDescription: "JMESPath is a query language for selecting, projecting, filtering, and reshaping JSON documents. Expressions navigate objects and arrays, apply functions, flatten nested data, and produce JSON-compatible results.\n\nIt is embedded in command-line tools, SDKs, and automation systems, notably cloud workflows that need stable client-side JSON extraction. Its portable spec lets the same expression run across implementations in many host languages."
+        },
+        es: {
+          name: "JMESPath",
+          description: "Lenguaje declarativo para extraer y transformar datos JSON.",
+          longDescription: "JMESPath es un lenguaje de consultas para seleccionar, proyectar, filtrar y remodelar documentos JSON. Las expresiones navegan objetos y arreglos, aplican funciones, aplanan datos anidados y producen resultados compatibles con JSON.\n\nSe integra en herramientas de linea de comandos, SDKs y sistemas de automatizacion, especialmente flujos cloud que necesitan extraccion JSON estable del lado cliente. Su especificacion portable permite usar la misma expresion en implementaciones de muchos lenguajes anfitriones."
+        },
+        it: {
+          name: "JMESPath",
+          description: "Linguaggio dichiarativo per estrarre e trasformare dati JSON.",
+          longDescription: "JMESPath e un linguaggio di query per selezionare, proiettare, filtrare e rimodellare documenti JSON. Le espressioni navigano oggetti e array, applicano funzioni, appiattiscono dati annidati e producono risultati compatibili con JSON.\n\nE integrato in strumenti CLI, SDK e sistemi di automazione, soprattutto workflow cloud che richiedono estrazione JSON stabile lato client. La sua specifica portabile permette alla stessa espressione di girare in implementazioni per molti linguaggi host."
+        },
+        fr: {
+          name: "JMESPath",
+          description: "Langage declaratif pour extraire et transformer des donnees JSON.",
+          longDescription: "JMESPath est un langage de requete pour selectionner, projeter, filtrer et remodeler des documents JSON. Les expressions parcourent objets et tableaux, appliquent des fonctions, aplatissent des donnees imbriquees et produisent des resultats compatibles JSON.\n\nIl est integre dans outils en ligne de commande, SDK et systemes d automatisation, notamment les flux cloud qui ont besoin d extraction JSON stable cote client. Sa specification portable permet la meme expression dans beaucoup de langages hotes."
+        },
+        de: {
+          name: "JMESPath",
+          description: "Deklarative Abfragesprache zum Extrahieren und Transformieren von JSON.",
+          longDescription: "JMESPath ist eine Abfragesprache zum Auswahlen, Projizieren, Filtern und Umformen von JSON-Dokumenten. Ausdruecke navigieren Objekte und Arrays, wenden Funktionen an, flachen verschachtelte Daten ab und erzeugen JSON-kompatible Ergebnisse.\n\nSie ist in Kommandozeilenwerkzeuge, SDKs und Automationssysteme eingebettet, besonders in Cloud-Ablaufe mit stabiler clientseitiger JSON-Extraktion. Die portable Spezifikation lasst denselben Ausdruck in vielen Hostsprachen laufen."
+        },
+        pt: {
+          name: "JMESPath",
+          description: "Linguagem declarativa para extrair e transformar dados JSON.",
+          longDescription: "JMESPath e uma linguagem de consulta para selecionar, projetar, filtrar e remodelar documentos JSON. Expressoes navegam objetos e arrays, aplicam funcoes, achatam dados aninhados e produzem resultados compativeis com JSON.\n\nEla aparece em ferramentas de linha de comando, SDKs e sistemas de automacao, especialmente fluxos cloud que precisam de extracao JSON estavel no cliente. Sua especificacao portavel permite usar a mesma expressao em implementacoes de muitas linguagens hospedeiras."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/json.ts
 var json_exports = {};
 __export(json_exports, {
@@ -5949,7 +6818,7 @@ var init_json5 = __esm({
         ecosystems: ["Configuration", "Web", "Node.js"]
       },
       version: "2.2.3",
-      logo: "https://dummyimage.com/32x32/267CB9/ffffff.png&text=J5",
+      logo: "https://json5.dev/favicon.svg",
       color: "#267CB9",
       i18n: {
         en: {
@@ -5987,6 +6856,64 @@ var init_json5 = __esm({
   }
 });
 
+// src/languages/jsonata.ts
+var jsonata_exports = {};
+__export(jsonata_exports, {
+  jsonata: () => exports.jsonata
+});
+exports.jsonata = void 0;
+var init_jsonata = __esm({
+  "src/languages/jsonata.ts"() {
+    exports.jsonata = {
+      slug: "jsonata",
+      publishedDate: "2016-01-01",
+      extensions: [".jsonata"],
+      author: "IBM",
+      website: "https://jsonata.org",
+      paradigms: ["query", "functional"],
+      tooling: {
+        runtimes: ["JSONata engine"],
+        ecosystems: ["JSON", "Low-code automation"]
+      },
+      version: "stable",
+      logo: "https://jsonata.org/images/jsonata-button.png",
+      color: "#D23669",
+      i18n: {
+        en: {
+          name: "JSONata",
+          description: "A functional query and transformation language for JSON documents.",
+          longDescription: "JSONata is a compact expression language for querying and transforming JSON data. It combines path navigation, predicates, operators, variables, functions, object construction, grouping, and aggregation.\n\nThe language is used in integration tools, message processing, automation platforms, and applications that need declarative JSON reshaping. Its functional features make complex transformations possible without writing a full host-language program."
+        },
+        es: {
+          name: "JSONata",
+          description: "Lenguaje funcional de consulta y transformacion para documentos JSON.",
+          longDescription: "JSONata es un lenguaje compacto de expresiones para consultar y transformar datos JSON. Combina navegacion por rutas, predicados, operadores, variables, funciones, construccion de objetos, agrupacion y agregacion.\n\nEl lenguaje se usa en herramientas de integracion, procesamiento de mensajes, plataformas de automatizacion y apps que necesitan remodelar JSON de forma declarativa. Sus rasgos funcionales permiten transformaciones complejas sin escribir un programa completo en el lenguaje anfitrion."
+        },
+        it: {
+          name: "JSONata",
+          description: "Linguaggio funzionale di query e trasformazione per documenti JSON.",
+          longDescription: "JSONata e un linguaggio compatto di espressioni per interrogare e trasformare dati JSON. Combina navigazione per percorsi, predicati, operatori, variabili, funzioni, costruzione di oggetti, raggruppamento e aggregazione.\n\nIl linguaggio e usato in strumenti di integrazione, elaborazione messaggi, piattaforme di automazione e app che richiedono rimodellamento JSON dichiarativo. Le sue funzioni rendono possibili trasformazioni complesse senza scrivere un programma completo nel linguaggio host."
+        },
+        fr: {
+          name: "JSONata",
+          description: "Langage fonctionnel de requete et transformation pour documents JSON.",
+          longDescription: "JSONata est un langage d expressions compact pour interroger et transformer des donnees JSON. Il combine navigation par chemins, predicats, operateurs, variables, fonctions, construction d objets, groupement et agregation.\n\nLe langage est utilise dans outils d integration, traitement de messages, plateformes d automatisation et apps qui doivent remodeler JSON declarativement. Ses fonctions permettent des transformations complexes sans ecrire un programme complet dans le langage hote."
+        },
+        de: {
+          name: "JSONata",
+          description: "Funktionale Abfrage- und Transformationssprache fur JSON-Dokumente.",
+          longDescription: "JSONata ist eine kompakte Ausdruckssprache zum Abfragen und Transformieren von JSON-Daten. Sie kombiniert Pfadnavigation, Pradikate, Operatoren, Variablen, Funktionen, Objektaufbau, Gruppierung und Aggregation.\n\nDie Sprache wird in Integrationswerkzeugen, Nachrichtenverarbeitung, Automationsplattformen und Anwendungen genutzt, die JSON deklarativ umformen mussen. Ihre funktionalen Eigenschaften ermoglichen komplexe Transformationen ohne ein vollstandiges Hostsprachen-Programm."
+        },
+        pt: {
+          name: "JSONata",
+          description: "Linguagem funcional de consulta e transformacao para documentos JSON.",
+          longDescription: "JSONata e uma linguagem compacta de expressoes para consultar e transformar dados JSON. Ela combina navegacao por caminhos, predicados, operadores, variaveis, funcoes, construcao de objetos, agrupamento e agregacao.\n\nA linguagem e usada em ferramentas de integracao, processamento de mensagens, plataformas de automacao e apps que precisam remodelar JSON de forma declarativa. Seus recursos funcionais permitem transformacoes complexas sem escrever um programa completo na linguagem hospedeira."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/jsonc.ts
 var jsonc_exports = {};
 __export(jsonc_exports, {
@@ -6360,7 +7287,7 @@ var init_kdl = __esm({
         ecosystems: ["Configuration", "Rust", "Structured Documents"]
       },
       version: "2.0.0",
-      logo: "https://dummyimage.com/32x32/6B4E9B/ffffff.png&text=KDL",
+      logo: "https://kdl.dev/assets/apple-touch-icon-DYakp7eY.png",
       color: "#6B4E9B",
       i18n: {
         en: {
@@ -6419,7 +7346,7 @@ var init_koka = __esm({
         ecosystems: ["Effect Systems", "Functional Programming", "Research"]
       },
       version: "3.2.2",
-      logo: "https://dummyimage.com/32x32/0891B2/ffffff.png&text=K",
+      logo: "https://koka-lang.github.io/koka/doc/images/koka-logo-filled.png",
       color: "#0891B2",
       i18n: {
         en: {
@@ -6516,6 +7443,64 @@ var init_kotlin = __esm({
   }
 });
 
+// src/languages/kql.ts
+var kql_exports = {};
+__export(kql_exports, {
+  kql: () => exports.kql
+});
+exports.kql = void 0;
+var init_kql = __esm({
+  "src/languages/kql.ts"() {
+    exports.kql = {
+      slug: "kql",
+      publishedDate: "2014-01-01",
+      extensions: [".kql"],
+      author: "Microsoft",
+      website: "https://learn.microsoft.com/en-us/kusto/query/",
+      paradigms: ["query", "data analysis"],
+      tooling: {
+        runtimes: ["Azure Data Explorer", "Microsoft Sentinel", "Azure Monitor"],
+        ecosystems: ["Observability", "Security analytics"]
+      },
+      version: "stable",
+      logo: "https://learn.microsoft.com/favicon.ico",
+      color: "#0078D4",
+      i18n: {
+        en: {
+          name: "KQL",
+          description: "A query language for Kusto, logs, telemetry, and security analytics.",
+          longDescription: "Kusto Query Language is used to explore, filter, aggregate, and visualize large volumes of structured and semi-structured data. Queries flow through tabular operators for projection, summarization, joins, time windows, parsing, and rendering.\n\nKQL is central to Azure Data Explorer, Azure Monitor, Microsoft Sentinel, and related telemetry platforms. It is common in observability, incident response, threat hunting, performance analysis, and operational dashboards."
+        },
+        es: {
+          name: "KQL",
+          description: "Lenguaje de consultas para Kusto, logs, telemetria y analitica de seguridad.",
+          longDescription: "Kusto Query Language se usa para explorar, filtrar, agregar y visualizar grandes volumenes de datos estructurados y semiestructurados. Las consultas fluyen por operadores tabulares para proyectar, resumir, unir, analizar ventanas de tiempo, parsear y renderizar.\n\nKQL es central en Azure Data Explorer, Azure Monitor, Microsoft Sentinel y plataformas de telemetria relacionadas. Es comun en observabilidad, respuesta a incidentes, threat hunting, analisis de rendimiento y dashboards operativos."
+        },
+        it: {
+          name: "KQL",
+          description: "Linguaggio di query per Kusto, log, telemetria e security analytics.",
+          longDescription: "Kusto Query Language e usato per esplorare, filtrare, aggregare e visualizzare grandi volumi di dati strutturati e semistrutturati. Le query scorrono attraverso operatori tabellari per proiezione, riepilogo, join, finestre temporali, parsing e rendering.\n\nKQL e centrale in Azure Data Explorer, Azure Monitor, Microsoft Sentinel e piattaforme di telemetria collegate. E comune in osservabilita, risposta agli incidenti, threat hunting, analisi performance e dashboard operative."
+        },
+        fr: {
+          name: "KQL",
+          description: "Langage de requete pour Kusto, logs, telemetrie et analyse securite.",
+          longDescription: "Kusto Query Language sert a explorer, filtrer, agreger et visualiser de grands volumes de donnees structurees ou semi-structurees. Les requetes passent par des operateurs tabulaires pour projection, synthese, jointures, fenetres temporelles, parsing et rendu.\n\nKQL est central dans Azure Data Explorer, Azure Monitor, Microsoft Sentinel et plateformes de telemetrie liees. Il est courant en observabilite, reponse a incident, threat hunting, analyse performance et tableaux de bord operationnels."
+        },
+        de: {
+          name: "KQL",
+          description: "Abfragesprache fur Kusto, Logs, Telemetrie und Sicherheitsanalyse.",
+          longDescription: "Kusto Query Language wird genutzt, um grosse Mengen strukturierter und halbstrukturierter Daten zu untersuchen, filtern, aggregieren und visualisieren. Abfragen laufen durch tabellarische Operatoren fur Projektion, Zusammenfassung, Joins, Zeitfenster, Parsing und Darstellung.\n\nKQL ist zentral in Azure Data Explorer, Azure Monitor, Microsoft Sentinel und verwandten Telemetrieplattformen. Es ist verbreitet in Observability, Incident Response, Threat Hunting, Performanceanalyse und operativen Dashboards."
+        },
+        pt: {
+          name: "KQL",
+          description: "Linguagem de consulta para Kusto, logs, telemetria e analise de seguranca.",
+          longDescription: "Kusto Query Language e usada para explorar, filtrar, agregar e visualizar grandes volumes de dados estruturados e semiestruturados. Consultas passam por operadores tabulares para projecao, resumo, joins, janelas de tempo, parsing e renderizacao.\n\nKQL e central no Azure Data Explorer, Azure Monitor, Microsoft Sentinel e plataformas de telemetria relacionadas. E comum em observabilidade, resposta a incidentes, threat hunting, analise de desempenho e dashboards operacionais."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/lean.ts
 var lean_exports = {};
 __export(lean_exports, {
@@ -6655,7 +7640,7 @@ var init_ligo = __esm({
         ecosystems: ["Tezos"]
       },
       version: "1.x",
-      logo: "https://dummyimage.com/32x32/0D9488/ffffff.png&text=Li",
+      logo: "https://ligolang.org/img/logo/logo.png",
       color: "#0D9488",
       i18n: {
         en: {
@@ -6693,6 +7678,64 @@ var init_ligo = __esm({
   }
 });
 
+// src/languages/linkerscript.ts
+var linkerscript_exports = {};
+__export(linkerscript_exports, {
+  linkerscript: () => exports.linkerscript
+});
+exports.linkerscript = void 0;
+var init_linkerscript = __esm({
+  "src/languages/linkerscript.ts"() {
+    exports.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/liquid.ts
 var liquid_exports = {};
 __export(liquid_exports, {
@@ -6948,7 +7991,7 @@ var init_logo = __esm({
         ecosystems: ["Education", "Turtle Graphics", "Creative Coding"]
       },
       version: "UCBLogo 6.2",
-      logo: "https://dummyimage.com/32x32/16A34A/ffffff.png&text=Lg",
+      logo: "https://people.eecs.berkeley.edu/~bh/ucblogo.png",
       color: "#16A34A",
       i18n: {
         en: {
@@ -7295,7 +8338,7 @@ var init_marlowe = __esm({
         ecosystems: ["Cardano", "Financial contracts"]
       },
       version: "Marlowe Runtime",
-      logo: "https://dummyimage.com/32x32/6D28D9/ffffff.png&text=Ma",
+      logo: "https://marlowe.iohk.io/marlowe-footer-logo-large-dark-mode.svg",
       color: "#6D28D9",
       i18n: {
         en: {
@@ -7416,34 +8459,92 @@ var init_matlab = __esm({
       color: "#E16737",
       i18n: {
         en: {
-          name: "MATLAB",
-          description: "A matrix-oriented language and environment for engineering, science, data, and simulation.",
-          longDescription: "MATLAB is a programming language and numerical computing environment from MathWorks. It is centered on matrix and array operations, interactive analysis, visualization, algorithm development, and workflows for engineers and scientists.\n\nIt is commonly used for signal processing, control systems, robotics, data analysis, optimization, simulation, education, and model-based design alongside Simulink and MathWorks toolboxes."
+          name: "MATLAB",
+          description: "A matrix-oriented language and environment for engineering, science, data, and simulation.",
+          longDescription: "MATLAB is a programming language and numerical computing environment from MathWorks. It is centered on matrix and array operations, interactive analysis, visualization, algorithm development, and workflows for engineers and scientists.\n\nIt is commonly used for signal processing, control systems, robotics, data analysis, optimization, simulation, education, and model-based design alongside Simulink and MathWorks toolboxes."
+        },
+        es: {
+          name: "MATLAB",
+          description: "Un lenguaje y entorno orientado a matrices para ingenieria, ciencia, datos y simulacion.",
+          longDescription: "MATLAB es un lenguaje de programacion y entorno de computacion numerica de MathWorks. Esta centrado en operaciones con matrices y arreglos, analisis interactivo, visualizacion, desarrollo de algoritmos y flujos de trabajo para ingenieros y cientificos.\n\nSe usa comunmente en procesamiento de senales, sistemas de control, robotica, analisis de datos, optimizacion, simulacion, educacion y diseno basado en modelos junto con Simulink y las toolboxes de MathWorks."
+        },
+        it: {
+          name: "MATLAB",
+          description: "Un linguaggio e un ambiente orientato alle matrici per l'ingegneria, la scienza, i dati e la simulazione.",
+          longDescription: "MATLAB e un linguaggio di programmazione e un ambiente di calcolo numerico di MathWorks. E incentrato sulle operazioni di matrici e array, sull'analisi interattiva, sulla visualizzazione, sullo sviluppo di algoritmi e sui flussi di lavoro per ingegneri e scienziati.\n\nE comunemente utilizzato per l'elaborazione del segnale, i sistemi di controllo, la robotica, l'analisi dei dati, l'ottimizzazione, la simulazione, l'istruzione e la progettazione basata su modelli insieme a Simulink e alle toolbox di MathWorks."
+        },
+        fr: {
+          name: "MATLAB",
+          description: "Un langage et un environnement orientes sur les matrices pour l'ingenierie, la science, les donnees et la simulation.",
+          longDescription: "MATLAB est un langage de programmation et un environnement de calcul numerique de MathWorks. Il est centre sur les operations matricielles et sur les tableaux, l'analyse interactive, la visualisation, le developpement d'algorithmes et les flux de travail pour les ingenieurs et les scientifiques.\n\nIl est couramment utilise pour le traitement du signal, les systemes de controle, la robotique, l'analyse de donnees, l'optimisation, la simulation, l'education et la conception basee sur des modeles, ainsi que Simulink et les boites a outils MathWorks."
+        },
+        de: {
+          name: "MATLAB",
+          description: "Eine matrixorientierte Sprache und Umgebung f\xFCr Ingenieurwesen, Wissenschaft, Daten und Simulation.",
+          longDescription: "MATLAB ist eine Programmiersprache und numerische Rechenumgebung von MathWorks. Sie basiert auf Matrix- und Array-Operationen, interaktiver Analyse, Visualisierung, Algorithmusentwicklung und Arbeitsabl\xE4ufen f\xFCr Ingenieure und Wissenschaftler.\n\nSie wird h\xE4ufig f\xFCr Signalverarbeitung, Steuerungssysteme, Robotik, Datenanalyse, Optimierung, Simulation, Ausbildung und modellbasierte Entwicklung zusammen mit Simulink und MathWorks-Toolboxen verwendet."
+        },
+        pt: {
+          name: "MATLAB",
+          description: "Linguagem e ambiente orientados a matrizes para engenharia, ci\xEAncia, dados e simula\xE7\xE3o.",
+          longDescription: "MATLAB \xE9 uma linguagem de programa\xE7\xE3o e ambiente de computa\xE7\xE3o num\xE9rica da MathWorks. \xC9 centrado em opera\xE7\xF5es de matrizes e arrays, an\xE1lise interativa, visualiza\xE7\xE3o, desenvolvimento de algoritmos e fluxos de trabalho para engenheiros e cientistas.\n\n\xC9 comumente usado para processamento de sinais, sistemas de controle, rob\xF3tica, an\xE1lise de dados, otimiza\xE7\xE3o, simula\xE7\xE3o, educa\xE7\xE3o e design baseado em modelos, juntamente com Simulink e toolboxes da MathWorks."
+        }
+      }
+    };
+  }
+});
+
+// src/languages/maxima.ts
+var maxima_exports = {};
+__export(maxima_exports, {
+  maxima: () => exports.maxima
+});
+exports.maxima = void 0;
+var init_maxima = __esm({
+  "src/languages/maxima.ts"() {
+    exports.maxima = {
+      slug: "maxima",
+      publishedDate: "1982-01-01",
+      extensions: [".mac", ".wxm"],
+      author: "MIT Project MAC and the Maxima community",
+      website: "https://maxima.sourceforge.io",
+      paradigms: ["symbolic", "functional", "scientific"],
+      tooling: {
+        runtimes: ["Maxima"],
+        ecosystems: ["Computer Algebra", "Mathematics", "Scientific Computing"]
+      },
+      version: "5.49.0",
+      logo: "https://maxima.sourceforge.io/img/maxima.svg",
+      color: "#92278F",
+      i18n: {
+        en: {
+          name: "Maxima",
+          description: "A symbolic computation language and computer algebra system descended from Macsyma.",
+          longDescription: "Maxima evaluates symbolic and numeric expressions for algebra, calculus, differential equations, linear algebra, number theory, and plotting. Its interactive language supports functions, rules, pattern matching, lists, matrices, and reusable packages.\n\nThe system descends from Macsyma and is implemented primarily in Common Lisp. It is used in education, research, engineering, and automated mathematical workflows through command-line and graphical interfaces."
         },
         es: {
-          name: "MATLAB",
-          description: "Un lenguaje y entorno orientado a matrices para ingenieria, ciencia, datos y simulacion.",
-          longDescription: "MATLAB es un lenguaje de programacion y entorno de computacion numerica de MathWorks. Esta centrado en operaciones con matrices y arreglos, analisis interactivo, visualizacion, desarrollo de algoritmos y flujos de trabajo para ingenieros y cientificos.\n\nSe usa comunmente en procesamiento de senales, sistemas de control, robotica, analisis de datos, optimizacion, simulacion, educacion y diseno basado en modelos junto con Simulink y las toolboxes de MathWorks."
+          name: "Maxima",
+          description: "Lenguaje de computacion simbolica y sistema algebraico descendiente de Macsyma.",
+          longDescription: "Maxima evalua expresiones simbolicas y numericas para algebra, calculo, ecuaciones diferenciales, algebra lineal, teoria de numeros y graficos. Su lenguaje interactivo incluye funciones, reglas, patrones, listas, matrices y paquetes reutilizables.\n\nEl sistema desciende de Macsyma y esta implementado principalmente en Common Lisp. Se usa en educacion, investigacion, ingenieria y flujos matematicos automatizados mediante interfaces de terminal y graficas."
         },
         it: {
-          name: "MATLAB",
-          description: "Un linguaggio e un ambiente orientato alle matrici per l'ingegneria, la scienza, i dati e la simulazione.",
-          longDescription: "MATLAB e un linguaggio di programmazione e un ambiente di calcolo numerico di MathWorks. E incentrato sulle operazioni di matrici e array, sull'analisi interattiva, sulla visualizzazione, sullo sviluppo di algoritmi e sui flussi di lavoro per ingegneri e scienziati.\n\nE comunemente utilizzato per l'elaborazione del segnale, i sistemi di controllo, la robotica, l'analisi dei dati, l'ottimizzazione, la simulazione, l'istruzione e la progettazione basata su modelli insieme a Simulink e alle toolbox di MathWorks."
+          name: "Maxima",
+          description: "Linguaggio di calcolo simbolico e sistema di algebra derivato da Macsyma.",
+          longDescription: "Maxima valuta espressioni simboliche e numeriche per algebra, analisi, equazioni differenziali, algebra lineare, teoria dei numeri e grafici. Il linguaggio interattivo supporta funzioni, regole, pattern, liste, matrici e pacchetti riutilizzabili.\n\nIl sistema discende da Macsyma ed e implementato soprattutto in Common Lisp. Viene usato in didattica, ricerca, ingegneria e workflow matematici automatizzati tramite interfacce testuali e grafiche."
         },
         fr: {
-          name: "MATLAB",
-          description: "Un langage et un environnement orientes sur les matrices pour l'ingenierie, la science, les donnees et la simulation.",
-          longDescription: "MATLAB est un langage de programmation et un environnement de calcul numerique de MathWorks. Il est centre sur les operations matricielles et sur les tableaux, l'analyse interactive, la visualisation, le developpement d'algorithmes et les flux de travail pour les ingenieurs et les scientifiques.\n\nIl est couramment utilise pour le traitement du signal, les systemes de controle, la robotique, l'analyse de donnees, l'optimisation, la simulation, l'education et la conception basee sur des modeles, ainsi que Simulink et les boites a outils MathWorks."
+          name: "Maxima",
+          description: "Langage de calcul symbolique et systeme d algebre descendant de Macsyma.",
+          longDescription: "Maxima evalue des expressions symboliques et numeriques pour algebre, calcul, equations differentielles, algebre lineaire, theorie des nombres et graphiques. Son langage interactif prend en charge fonctions, regles, motifs, listes, matrices et paquets reutilisables.\n\nLe systeme descend de Macsyma et est principalement implemente en Common Lisp. Il sert en enseignement, recherche, ingenierie et automatisation mathematique via interfaces texte et graphiques."
         },
         de: {
-          name: "MATLAB",
-          description: "Eine matrixorientierte Sprache und Umgebung f\xFCr Ingenieurwesen, Wissenschaft, Daten und Simulation.",
-          longDescription: "MATLAB ist eine Programmiersprache und numerische Rechenumgebung von MathWorks. Sie basiert auf Matrix- und Array-Operationen, interaktiver Analyse, Visualisierung, Algorithmusentwicklung und Arbeitsabl\xE4ufen f\xFCr Ingenieure und Wissenschaftler.\n\nSie wird h\xE4ufig f\xFCr Signalverarbeitung, Steuerungssysteme, Robotik, Datenanalyse, Optimierung, Simulation, Ausbildung und modellbasierte Entwicklung zusammen mit Simulink und MathWorks-Toolboxen verwendet."
+          name: "Maxima",
+          description: "Sprache fur symbolisches Rechnen und Computeralgebrasystem auf Basis von Macsyma.",
+          longDescription: "Maxima wertet symbolische und numerische Ausdrucke fur Algebra, Analysis, Differentialgleichungen, lineare Algebra, Zahlentheorie und Diagramme aus. Die interaktive Sprache unterstutzt Funktionen, Regeln, Muster, Listen, Matrizen und wiederverwendbare Pakete.\n\nDas System stammt von Macsyma ab und ist hauptsachlich in Common Lisp implementiert. Es wird in Lehre, Forschung, Technik und automatisierten Mathematik-Workflows uber Text- und Grafikoberflachen eingesetzt."
         },
         pt: {
-          name: "MATLAB",
-          description: "Linguagem e ambiente orientados a matrizes para engenharia, ci\xEAncia, dados e simula\xE7\xE3o.",
-          longDescription: "MATLAB \xE9 uma linguagem de programa\xE7\xE3o e ambiente de computa\xE7\xE3o num\xE9rica da MathWorks. \xC9 centrado em opera\xE7\xF5es de matrizes e arrays, an\xE1lise interativa, visualiza\xE7\xE3o, desenvolvimento de algoritmos e fluxos de trabalho para engenheiros e cientistas.\n\n\xC9 comumente usado para processamento de sinais, sistemas de controle, rob\xF3tica, an\xE1lise de dados, otimiza\xE7\xE3o, simula\xE7\xE3o, educa\xE7\xE3o e design baseado em modelos, juntamente com Simulink e toolboxes da MathWorks."
+          name: "Maxima",
+          description: "Linguagem de computacao simbolica e sistema de algebra descendente do Macsyma.",
+          longDescription: "Maxima avalia expressoes simbolicas e numericas para algebra, calculo, equacoes diferenciais, algebra linear, teoria dos numeros e graficos. Sua linguagem interativa suporta funcoes, regras, padroes, listas, matrizes e pacotes reutilizaveis.\n\nO sistema descende do Macsyma e e implementado principalmente em Common Lisp. E usado em ensino, pesquisa, engenharia e fluxos matematicos automatizados por interfaces de terminal e graficas."
         }
       }
     };
@@ -7530,7 +8631,7 @@ var init_mercury = __esm({
         ecosystems: ["Logic Programming", "Declarative Systems", "Academic Computing"]
       },
       version: "22.01.8",
-      logo: "https://dummyimage.com/32x32/0891B2/ffffff.png&text=Me",
+      logo: "https://www.mercurylang.org/favicon.ico",
       color: "#0891B2",
       i18n: {
         en: {
@@ -8036,6 +9137,64 @@ var init_mustache = __esm({
   }
 });
 
+// src/languages/n1ql.ts
+var n1ql_exports = {};
+__export(n1ql_exports, {
+  n1ql: () => exports.n1ql
+});
+exports.n1ql = void 0;
+var init_n1ql = __esm({
+  "src/languages/n1ql.ts"() {
+    exports.n1ql = {
+      slug: "n1ql",
+      publishedDate: "2015-01-01",
+      extensions: [".n1ql"],
+      author: "Couchbase",
+      website: "https://docs.couchbase.com/server/current/n1ql/n1ql-language-reference/index.html",
+      paradigms: ["query", "declarative"],
+      tooling: {
+        runtimes: ["Couchbase Server"],
+        ecosystems: ["NoSQL", "JSON databases"]
+      },
+      version: "stable",
+      logo: "https://cdn.simpleicons.org/couchbase/EA2328",
+      color: "#EA2328",
+      i18n: {
+        en: {
+          name: "N1QL",
+          description: "A SQL-like query language for JSON documents stored in Couchbase.",
+          longDescription: "N1QL is a declarative query language for Couchbase that brings SQL-style selection, filtering, joins, grouping, indexing, and mutation to JSON documents. It treats buckets, scopes, collections, and document fields as queryable data structures.\n\nThe language is used by Couchbase applications that need familiar relational-style queries over flexible document data. It supports operational queries, analytics-style exploration, and migrations from SQL-shaped data access patterns."
+        },
+        es: {
+          name: "N1QL",
+          description: "Lenguaje de consultas tipo SQL para documentos JSON almacenados en Couchbase.",
+          longDescription: "N1QL es un lenguaje declarativo de consultas para Couchbase que lleva seleccion, filtrado, joins, agrupacion, indexado y mutacion al estilo SQL sobre documentos JSON. Trata buckets, scopes, colecciones y campos de documentos como estructuras consultables.\n\nEl lenguaje se usa en apps Couchbase que necesitan consultas familiares tipo relacional sobre datos documentales flexibles. Soporta consultas operativas, exploracion analitica y migraciones desde patrones de acceso con forma SQL."
+        },
+        it: {
+          name: "N1QL",
+          description: "Linguaggio di query simile a SQL per documenti JSON in Couchbase.",
+          longDescription: "N1QL e un linguaggio dichiarativo di query per Couchbase che porta selezione, filtri, join, raggruppamento, indicizzazione e mutazione in stile SQL sui documenti JSON. Tratta bucket, scope, collection e campi documento come strutture interrogabili.\n\nIl linguaggio e usato da applicazioni Couchbase che richiedono query familiari di stile relazionale su dati documentali flessibili. Supporta query operative, esplorazione analitica e migrazioni da pattern di accesso simili a SQL."
+        },
+        fr: {
+          name: "N1QL",
+          description: "Langage de requete proche de SQL pour documents JSON dans Couchbase.",
+          longDescription: "N1QL est un langage de requete declaratif pour Couchbase qui apporte selection, filtrage, jointures, groupement, indexation et mutation de style SQL aux documents JSON. Il traite buckets, scopes, collections et champs de documents comme structures interrogeables.\n\nLe langage est utilise par les applications Couchbase qui veulent des requetes relationnelles familieres sur donnees documentaires flexibles. Il prend en charge requetes operationnelles, exploration analytique et migrations depuis des acces proches de SQL."
+        },
+        de: {
+          name: "N1QL",
+          description: "SQL-ahnliche Abfragesprache fur JSON-Dokumente in Couchbase.",
+          longDescription: "N1QL ist eine deklarative Abfragesprache fur Couchbase, die SQL-artige Auswahl, Filter, Joins, Gruppierung, Indexierung und Mutation auf JSON-Dokumente bringt. Buckets, Scopes, Collections und Dokumentfelder werden als abfragbare Datenstrukturen behandelt.\n\nDie Sprache wird von Couchbase-Anwendungen genutzt, die vertraute relationale Abfragen auf flexible Dokumentdaten brauchen. Sie unterstutzt operative Abfragen, analytische Exploration und Migrationen von SQL-gepragten Zugriffsmustern."
+        },
+        pt: {
+          name: "N1QL",
+          description: "Linguagem de consulta parecida com SQL para documentos JSON no Couchbase.",
+          longDescription: "N1QL e uma linguagem declarativa de consulta para Couchbase que leva selecao, filtros, joins, agrupamento, indexacao e mutacao em estilo SQL para documentos JSON. Ela trata buckets, scopes, colecoes e campos de documentos como estruturas consultaveis.\n\nA linguagem e usada por apps Couchbase que precisam de consultas familiares de estilo relacional sobre dados documentais flexiveis. Ela suporta consultas operacionais, exploracao analitica e migracoes de padroes de acesso parecidos com SQL."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/nginx.ts
 var nginx_exports = {};
 __export(nginx_exports, {
@@ -8740,6 +9899,64 @@ var init_opencl = __esm({
   }
 });
 
+// src/languages/org.ts
+var org_exports = {};
+__export(org_exports, {
+  org: () => exports.org
+});
+exports.org = void 0;
+var init_org = __esm({
+  "src/languages/org.ts"() {
+    exports.org = {
+      slug: "org",
+      publishedDate: "2003-01-01",
+      extensions: [".org"],
+      author: "Carsten Dominik and Org mode contributors",
+      website: "https://orgmode.org",
+      paradigms: ["markup", "outlining", "literate programming"],
+      tooling: {
+        runtimes: ["GNU Emacs"],
+        ecosystems: ["Documentation", "Knowledge Management", "Reproducible Research"]
+      },
+      version: "9.8",
+      logo: "https://orgmode.org/resources/img/org-mode-unicorn.svg",
+      color: "#77AA99",
+      i18n: {
+        en: {
+          name: "Org-mode",
+          description: "A plain-text markup format for outlines, notes, planning, and literate programming.",
+          longDescription: "Org syntax structures plain-text documents with headings, lists, links, tables, properties, timestamps, tasks, and source blocks. Files remain readable without specialized software while GNU Emacs provides rich editing and agenda features.\n\nOrg-mode supports note-taking, project planning, publishing, spreadsheets, code execution, and reproducible research. Exporters convert documents to formats such as HTML, LaTeX, Markdown, and OpenDocument."
+        },
+        es: {
+          name: "Org-mode",
+          description: "Formato de texto plano para esquemas, notas, planificacion y programacion literaria.",
+          longDescription: "La sintaxis Org estructura documentos de texto con encabezados, listas, enlaces, tablas, propiedades, fechas, tareas y bloques de codigo. Los archivos siguen siendo legibles sin software especial, mientras GNU Emacs aporta edicion y agendas avanzadas.\n\nOrg-mode permite tomar notas, planificar proyectos, publicar, usar hojas de calculo, ejecutar codigo y crear investigacion reproducible. Sus exportadores generan HTML, LaTeX, Markdown y OpenDocument."
+        },
+        it: {
+          name: "Org-mode",
+          description: "Formato di testo semplice per outline, note, pianificazione e programmazione letterata.",
+          longDescription: "La sintassi Org struttura documenti di testo con titoli, liste, link, tabelle, proprieta, timestamp, attivita e blocchi di codice. I file restano leggibili senza software speciale, mentre GNU Emacs offre modifica e agenda avanzate.\n\nOrg-mode supporta note, pianificazione, pubblicazione, fogli di calcolo, esecuzione di codice e ricerca riproducibile. Gli esportatori convertono i documenti in HTML, LaTeX, Markdown e OpenDocument."
+        },
+        fr: {
+          name: "Org-mode",
+          description: "Format texte pour plans, notes, planification et programmation litteraire.",
+          longDescription: "La syntaxe Org structure les documents texte avec titres, listes, liens, tableaux, proprietes, horodatages, taches et blocs de code. Les fichiers restent lisibles sans logiciel specialise, tandis que GNU Emacs fournit edition et agendas avances.\n\nOrg-mode prend en charge notes, gestion de projets, publication, feuilles de calcul, execution de code et recherche reproductible. Ses exportateurs produisent HTML, LaTeX, Markdown et OpenDocument."
+        },
+        de: {
+          name: "Org-mode",
+          description: "Klartext-Markupformat fur Gliederungen, Notizen, Planung und literarisches Programmieren.",
+          longDescription: "Org-Syntax strukturiert Klartextdokumente mit Uberschriften, Listen, Links, Tabellen, Eigenschaften, Zeitangaben, Aufgaben und Codeblocken. Dateien bleiben ohne Spezialsoftware lesbar, wahrend GNU Emacs umfangreiche Bearbeitungs- und Agenda-Funktionen bietet.\n\nOrg-mode unterstutzt Notizen, Projektplanung, Publikation, Tabellenkalkulation, Codeausfuhrung und reproduzierbare Forschung. Exporter erzeugen HTML, LaTeX, Markdown und OpenDocument."
+        },
+        pt: {
+          name: "Org-mode",
+          description: "Formato de texto simples para estruturas, notas, planejamento e programacao literaria.",
+          longDescription: "A sintaxe Org estrutura documentos de texto com titulos, listas, links, tabelas, propriedades, datas, tarefas e blocos de codigo. Arquivos continuam legiveis sem software especial, enquanto GNU Emacs oferece edicao e agendas avancadas.\n\nOrg-mode suporta notas, planejamento de projetos, publicacao, planilhas, execucao de codigo e pesquisa reproduzivel. Exportadores convertem documentos para HTML, LaTeX, Markdown e OpenDocument."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/pascal.ts
 var pascal_exports = {};
 __export(pascal_exports, {
@@ -9151,6 +10368,64 @@ var init_plantuml = __esm({
   }
 });
 
+// src/languages/plpgsql.ts
+var plpgsql_exports = {};
+__export(plpgsql_exports, {
+  plpgsql: () => exports.plpgsql
+});
+exports.plpgsql = void 0;
+var init_plpgsql = __esm({
+  "src/languages/plpgsql.ts"() {
+    exports.plpgsql = {
+      slug: "plpgsql",
+      publishedDate: "1997-01-01",
+      extensions: [".pgsql", ".plpgsql"],
+      author: "PostgreSQL Global Development Group",
+      website: "https://www.postgresql.org/docs/current/plpgsql.html",
+      paradigms: ["procedural", "database"],
+      tooling: {
+        runtimes: ["PostgreSQL"],
+        ecosystems: ["Relational databases", "Stored procedures"]
+      },
+      version: "stable",
+      logo: "https://cdn.simpleicons.org/postgresql/4169E1",
+      color: "#4169E1",
+      i18n: {
+        en: {
+          name: "PL/pgSQL",
+          description: "PostgreSQL procedural language for functions, triggers, and stored logic.",
+          longDescription: "PL/pgSQL is PostgreSQLs procedural language for writing functions, trigger procedures, and server-side business logic. It combines SQL statements with variables, control flow, cursors, error handling, records, and dynamic execution.\n\nThe language is used when logic should run close to relational data, inside transactions, or behind database APIs. It supports validation, auditing, data transformation, maintenance jobs, and performance-sensitive routines that benefit from avoiding client round trips."
+        },
+        es: {
+          name: "PL/pgSQL",
+          description: "Lenguaje procedural de PostgreSQL para funciones, triggers y logica almacenada.",
+          longDescription: "PL/pgSQL es el lenguaje procedural de PostgreSQL para escribir funciones, procedimientos de trigger y logica de negocio del lado servidor. Combina sentencias SQL con variables, control de flujo, cursores, manejo de errores, registros y ejecucion dinamica.\n\nEl lenguaje se usa cuando la logica debe correr cerca de datos relacionales, dentro de transacciones o detras de APIs de base de datos. Soporta validacion, auditoria, transformacion de datos, tareas de mantenimiento y rutinas sensibles a rendimiento que evitan viajes al cliente."
+        },
+        it: {
+          name: "PL/pgSQL",
+          description: "Linguaggio procedurale PostgreSQL per funzioni, trigger e logica salvata.",
+          longDescription: "PL/pgSQL e il linguaggio procedurale di PostgreSQL per scrivere funzioni, procedure trigger e logica business lato server. Combina istruzioni SQL con variabili, controllo di flusso, cursori, gestione errori, record ed esecuzione dinamica.\n\nIl linguaggio e usato quando la logica deve girare vicino ai dati relazionali, dentro transazioni o dietro API database. Supporta validazione, auditing, trasformazione dati, job di manutenzione e routine sensibili alle prestazioni che evitano round trip al client."
+        },
+        fr: {
+          name: "PL/pgSQL",
+          description: "Langage procedural PostgreSQL pour fonctions, triggers et logique stockee.",
+          longDescription: "PL/pgSQL est le langage procedural de PostgreSQL pour ecrire fonctions, procedures de trigger et logique metier cote serveur. Il combine instructions SQL avec variables, controle de flux, curseurs, gestion d erreurs, enregistrements et execution dynamique.\n\nLe langage est utilise quand la logique doit tourner pres des donnees relationnelles, dans des transactions ou derriere des API de base de donnees. Il sert a validation, audit, transformation de donnees, maintenance et routines sensibles aux performances."
+        },
+        de: {
+          name: "PL/pgSQL",
+          description: "Prozedurale PostgreSQL-Sprache fur Funktionen, Trigger und gespeicherte Logik.",
+          longDescription: "PL/pgSQL ist die prozedurale Sprache von PostgreSQL fur Funktionen, Trigger-Prozeduren und serverseitige Geschaftslogik. Sie kombiniert SQL-Anweisungen mit Variablen, Kontrollfluss, Cursorn, Fehlerbehandlung, Records und dynamischer Ausfuhrung.\n\nDie Sprache wird genutzt, wenn Logik nahe an relationalen Daten, innerhalb von Transaktionen oder hinter Datenbank-APIs laufen soll. Sie unterstutzt Validierung, Auditing, Datentransformation, Wartungsjobs und performanzkritische Routinen mit weniger Client-Roundtrips."
+        },
+        pt: {
+          name: "PL/pgSQL",
+          description: "Linguagem procedural do PostgreSQL para funcoes, triggers e logica armazenada.",
+          longDescription: "PL/pgSQL e a linguagem procedural do PostgreSQL para escrever funcoes, procedimentos de trigger e logica de negocio no servidor. Ela combina comandos SQL com variaveis, controle de fluxo, cursores, tratamento de erros, registros e execucao dinamica.\n\nA linguagem e usada quando a logica deve rodar perto dos dados relacionais, dentro de transacoes ou atras de APIs de banco. Suporta validacao, auditoria, transformacao de dados, tarefas de manutencao e rotinas sensiveis a desempenho que evitam idas ao cliente."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/plsql.ts
 var plsql_exports = {};
 __export(plsql_exports, {
@@ -9209,6 +10484,64 @@ var init_plsql = __esm({
   }
 });
 
+// src/languages/pod.ts
+var pod_exports = {};
+__export(pod_exports, {
+  pod: () => exports.pod
+});
+exports.pod = void 0;
+var init_pod = __esm({
+  "src/languages/pod.ts"() {
+    exports.pod = {
+      slug: "pod",
+      publishedDate: "1994-01-01",
+      extensions: [".pod"],
+      author: "Larry Wall and the Perl community",
+      website: "https://perldoc.perl.org/perlpod",
+      paradigms: ["markup", "documentation"],
+      tooling: {
+        runtimes: ["perldoc", "Pod::Simple"],
+        ecosystems: ["Perl", "Documentation"]
+      },
+      version: "Perl 5.42.2",
+      logo: "https://cdn.simpleicons.org/perl/39457E",
+      color: "#39457E",
+      i18n: {
+        en: {
+          name: "Plain Old Documentation",
+          description: "A lightweight documentation markup format distributed with Perl.",
+          longDescription: "Plain Old Documentation uses paragraph-oriented directives for headings, lists, links, code, formatting, and embedded metadata. POD can live in standalone .pod files or alongside Perl source code after the interpreter has finished reading executable statements.\n\nPerl tooling converts POD into terminal help, manual pages, HTML, and other formats. It is the standard documentation source for Perl modules, commands, language manuals, and CPAN distributions."
+        },
+        es: {
+          name: "Plain Old Documentation",
+          description: "Formato ligero de documentacion distribuido con Perl.",
+          longDescription: "Plain Old Documentation usa directivas orientadas a parrafos para encabezados, listas, enlaces, codigo, formato y metadatos. POD puede vivir en archivos .pod independientes o junto al codigo Perl despues de las sentencias ejecutables.\n\nLas herramientas Perl convierten POD en ayuda de terminal, paginas man, HTML y otros formatos. Es la fuente estandar de documentacion para modulos, comandos, manuales y distribuciones CPAN."
+        },
+        it: {
+          name: "Plain Old Documentation",
+          description: "Formato leggero di documentazione distribuito con Perl.",
+          longDescription: "Plain Old Documentation usa direttive orientate ai paragrafi per titoli, liste, link, codice, formattazione e metadati. POD puo vivere in file .pod autonomi o insieme al codice Perl dopo le istruzioni eseguibili.\n\nGli strumenti Perl convertono POD in aiuto da terminale, pagine man, HTML e altri formati. E la fonte standard di documentazione per moduli, comandi, manuali e distribuzioni CPAN."
+        },
+        fr: {
+          name: "Plain Old Documentation",
+          description: "Format leger de documentation distribue avec Perl.",
+          longDescription: "Plain Old Documentation utilise des directives par paragraphes pour titres, listes, liens, code, mise en forme et metadonnees. POD peut vivre dans des fichiers .pod autonomes ou avec le code Perl apres les instructions executables.\n\nLes outils Perl convertissent POD en aide terminal, pages man, HTML et autres formats. Il constitue la source standard de documentation pour modules, commandes, manuels et distributions CPAN."
+        },
+        de: {
+          name: "Plain Old Documentation",
+          description: "Leichtgewichtiges Dokumentationsformat, das mit Perl ausgeliefert wird.",
+          longDescription: "Plain Old Documentation verwendet absatzorientierte Direktiven fur Uberschriften, Listen, Links, Code, Formatierung und Metadaten. POD kann in eigenstandigen .pod-Dateien oder nach ausfuhrbaren Anweisungen direkt im Perl-Quellcode stehen.\n\nPerl-Werkzeuge wandeln POD in Terminalhilfe, Handbuchseiten, HTML und weitere Formate um. Es ist die Standardquelle fur Dokumentation von Modulen, Befehlen, Sprachhandbuchern und CPAN-Distributionen."
+        },
+        pt: {
+          name: "Plain Old Documentation",
+          description: "Formato leve de documentacao distribuido com Perl.",
+          longDescription: "Plain Old Documentation usa diretivas orientadas a paragrafos para titulos, listas, links, codigo, formatacao e metadados. POD pode existir em arquivos .pod independentes ou junto ao codigo Perl apos instrucoes executaveis.\n\nFerramentas Perl convertem POD em ajuda de terminal, paginas man, HTML e outros formatos. E a fonte padrao de documentacao para modulos, comandos, manuais e distribuicoes CPAN."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/pony.ts
 var pony_exports = {};
 __export(pony_exports, {
@@ -9739,6 +11072,64 @@ var init_python = __esm({
   }
 });
 
+// src/languages/qmake.ts
+var qmake_exports = {};
+__export(qmake_exports, {
+  qmake: () => exports.qmake
+});
+exports.qmake = void 0;
+var init_qmake = __esm({
+  "src/languages/qmake.ts"() {
+    exports.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, {
@@ -10172,7 +11563,7 @@ var init_rebol = __esm({
         ecosystems: ["Scripting", "DSLs", "Network Tools"]
       },
       version: "Rebol 3",
-      logo: "https://dummyimage.com/32x32/7C2D12/ffffff.png&text=Re",
+      logo: "https://www.rebol.com/graphics/reb-logo.gif",
       color: "#7C2D12",
       i18n: {
         en: {
@@ -10876,7 +12267,7 @@ var init_self = __esm({
         ecosystems: ["Language Research", "Interactive Environments", "Prototype OO"]
       },
       version: "2024.1",
-      logo: "https://dummyimage.com/32x32/EA580C/ffffff.png&text=Se",
+      logo: "https://selflanguage.org/img/self-logo.png",
       color: "#EA580C",
       i18n: {
         en: {
@@ -11206,6 +12597,64 @@ var init_solidity = __esm({
   }
 });
 
+// src/languages/soql.ts
+var soql_exports = {};
+__export(soql_exports, {
+  soql: () => exports.soql
+});
+exports.soql = void 0;
+var init_soql = __esm({
+  "src/languages/soql.ts"() {
+    exports.soql = {
+      slug: "soql",
+      publishedDate: "2005-01-01",
+      extensions: [".soql"],
+      author: "Salesforce",
+      website: "https://developer.salesforce.com/docs/atlas.en-us.soql_sosl.meta/soql_sosl/",
+      paradigms: ["query", "declarative"],
+      tooling: {
+        runtimes: ["Salesforce Platform"],
+        ecosystems: ["CRM", "Apex"]
+      },
+      version: "stable",
+      logo: "https://commons.wikimedia.org/wiki/Special:FilePath/Salesforce.com_logo.svg",
+      color: "#00A1E0",
+      i18n: {
+        en: {
+          name: "SOQL",
+          description: "Salesforce Object Query Language for reading records from Salesforce data.",
+          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."
+        },
+        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, {
@@ -11322,6 +12771,64 @@ var init_sparql = __esm({
   }
 });
 
+// src/languages/spl.ts
+var spl_exports = {};
+__export(spl_exports, {
+  spl: () => exports.spl
+});
+exports.spl = void 0;
+var init_spl = __esm({
+  "src/languages/spl.ts"() {
+    exports.spl = {
+      slug: "spl",
+      publishedDate: "2006-01-01",
+      extensions: [".spl"],
+      author: "Splunk",
+      website: "https://docs.splunk.com/Documentation/Splunk/latest/SearchReference/WhatsInThisManual",
+      paradigms: ["query", "pipeline"],
+      tooling: {
+        runtimes: ["Splunk Enterprise", "Splunk Cloud Platform"],
+        ecosystems: ["Observability", "Security analytics"]
+      },
+      version: "stable",
+      logo: "https://cdn.simpleicons.org/splunk/000000",
+      color: "#000000",
+      i18n: {
+        en: {
+          name: "SPL",
+          description: "Splunk Search Processing Language for searching and analyzing machine data.",
+          longDescription: "Splunk Search Processing Language is a pipeline language for searching, transforming, correlating, and visualizing machine data. Commands filter events, extract fields, calculate statistics, join streams, build time series, and produce dashboard-ready results.\n\nSPL is used in log analytics, observability, security operations, incident response, compliance, and operational intelligence. Its command pipeline lets analysts move from raw events to metrics, alerts, reports, and investigations."
+        },
+        es: {
+          name: "SPL",
+          description: "Splunk Search Processing Language para buscar y analizar datos de maquinas.",
+          longDescription: "Splunk Search Processing Language es un lenguaje de pipelines para buscar, transformar, correlacionar y visualizar datos de maquinas. Los comandos filtran eventos, extraen campos, calculan estadisticas, unen flujos, crean series temporales y producen resultados listos para dashboards.\n\nSPL se usa en analitica de logs, observabilidad, operaciones de seguridad, respuesta a incidentes, cumplimiento e inteligencia operativa. Su pipeline permite pasar de eventos crudos a metricas, alertas, reportes e investigaciones."
+        },
+        it: {
+          name: "SPL",
+          description: "Splunk Search Processing Language per cercare e analizzare dati macchina.",
+          longDescription: "Splunk Search Processing Language e un linguaggio a pipeline per cercare, trasformare, correlare e visualizzare dati macchina. I comandi filtrano eventi, estraggono campi, calcolano statistiche, uniscono flussi, creano serie temporali e producono risultati pronti per dashboard.\n\nSPL e usato in log analytics, osservabilita, security operations, risposta incidenti, compliance e intelligence operativa. La sua pipeline permette agli analisti di passare da eventi grezzi a metriche, alert, report e indagini."
+        },
+        fr: {
+          name: "SPL",
+          description: "Splunk Search Processing Language pour chercher et analyser donnees machine.",
+          longDescription: "Splunk Search Processing Language est un langage en pipeline pour chercher, transformer, correler et visualiser des donnees machine. Les commandes filtrent evenements, extraient champs, calculent statistiques, joignent flux, construisent series temporelles et produisent des resultats pour tableaux de bord.\n\nSPL est utilise en analyse de logs, observabilite, operations securite, reponse a incident, conformite et intelligence operationnelle. Son pipeline aide a passer des evenements bruts aux metriques, alertes, rapports et enquetes."
+        },
+        de: {
+          name: "SPL",
+          description: "Splunk Search Processing Language zum Suchen und Analysieren von Maschinendaten.",
+          longDescription: "Splunk Search Processing Language ist eine Pipeline-Sprache zum Suchen, Transformieren, Korrelieren und Visualisieren von Maschinendaten. Befehle filtern Events, extrahieren Felder, berechnen Statistiken, verbinden Streams, bauen Zeitreihen und erzeugen Dashboard-Ergebnisse.\n\nSPL wird in Log Analytics, Observability, Security Operations, Incident Response, Compliance und operativer Intelligenz genutzt. Die Befehlspipeline fuhrt von Rohereignissen zu Metriken, Alerts, Reports und Untersuchungen."
+        },
+        pt: {
+          name: "SPL",
+          description: "Splunk Search Processing Language para buscar e analisar dados de maquinas.",
+          longDescription: "Splunk Search Processing Language e uma linguagem de pipeline para buscar, transformar, correlacionar e visualizar dados de maquinas. Comandos filtram eventos, extraem campos, calculam estatisticas, juntam fluxos, criam series temporais e produzem resultados para dashboards.\n\nSPL e usada em analise de logs, observabilidade, operacoes de seguranca, resposta a incidentes, conformidade e inteligencia operacional. Seu pipeline leva analistas de eventos brutos a metricas, alertas, relatorios e investigacoes."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/sql.ts
 var sql_exports = {};
 __export(sql_exports, {
@@ -11903,6 +13410,64 @@ var init_tcl = __esm({
   }
 });
 
+// src/languages/tcsh.ts
+var tcsh_exports = {};
+__export(tcsh_exports, {
+  tcsh: () => exports.tcsh
+});
+exports.tcsh = void 0;
+var init_tcsh = __esm({
+  "src/languages/tcsh.ts"() {
+    exports.tcsh = {
+      slug: "tcsh",
+      publishedDate: "1981-01-01",
+      extensions: [".tcsh", ".csh", ".tcshrc", ".cshrc"],
+      author: "Ken Greer, Paul Placeway, Christos Zoulas, and contributors",
+      website: "https://www.tcsh.org",
+      paradigms: ["shell", "scripting", "imperative"],
+      tooling: {
+        runtimes: ["tcsh"],
+        ecosystems: ["Unix", "BSD"]
+      },
+      version: "6.24.16",
+      logo: "https://dummyimage.com/32x32/2563EB/ffffff.png&text=TC",
+      color: "#2563EB",
+      i18n: {
+        en: {
+          name: "Tcsh",
+          description: "A C shell-compatible Unix command interpreter with editing and programmable completion.",
+          longDescription: "Tcsh extends the C shell with command-line editing, history, aliases, job control, and programmable completion. It remains largely compatible with csh scripts while providing a more interactive command environment.\n\nThe shell is available across Unix-like systems and has longstanding use in BSD environments, engineering workstations, and legacy automation. Scripts typically use csh-style control flow and variable syntax."
+        },
+        es: {
+          name: "Tcsh",
+          description: "Interprete Unix compatible con C shell, con edicion y completado programable.",
+          longDescription: "Tcsh amplia C shell con edicion de linea, historial, alias, control de trabajos y completado programable. Mantiene amplia compatibilidad con scripts csh y ofrece un entorno de comandos mas interactivo.\n\nEl shell esta disponible en sistemas tipo Unix y tiene una larga presencia en entornos BSD, estaciones de ingenieria y automatizacion heredada. Sus scripts usan control de flujo y variables al estilo csh."
+        },
+        it: {
+          name: "Tcsh",
+          description: "Interprete Unix compatibile con C shell, con modifica e completamento programmabile.",
+          longDescription: "Tcsh estende C shell con modifica della riga di comando, cronologia, alias, controllo dei job e completamento programmabile. Mantiene ampia compatibilita con gli script csh offrendo un ambiente interattivo piu ricco.\n\nLa shell e disponibile sui sistemi Unix-like ed e usata da tempo in ambienti BSD, workstation tecniche e automazione legacy. Gli script adottano flusso di controllo e sintassi delle variabili in stile csh."
+        },
+        fr: {
+          name: "Tcsh",
+          description: "Interpreteur Unix compatible C shell avec edition et completion programmable.",
+          longDescription: "Tcsh etend C shell avec edition de ligne, historique, alias, controle des taches et completion programmable. Il conserve une large compatibilite avec les scripts csh tout en offrant un environnement interactif plus riche.\n\nLe shell est disponible sur les systemes de type Unix et reste utilise dans les environnements BSD, les stations techniques et l automatisation historique. Les scripts emploient le controle de flux et les variables de style csh."
+        },
+        de: {
+          name: "Tcsh",
+          description: "C-Shell-kompatibler Unix-Interpreter mit Bearbeitung und programmierbarer Erganzung.",
+          longDescription: "Tcsh erweitert die C Shell um Kommandozeilenbearbeitung, Verlauf, Aliase, Job-Steuerung und programmierbare Vervollstandigung. Die Sprache bleibt weitgehend mit csh-Skripten kompatibel und bietet eine reichere interaktive Umgebung.\n\nDie Shell ist auf Unix-artigen Systemen verfugbar und wird seit langem in BSD-Umgebungen, technischen Workstations und alterer Automatisierung eingesetzt. Skripte verwenden Kontrollfluss und Variablensyntax im csh-Stil."
+        },
+        pt: {
+          name: "Tcsh",
+          description: "Interpretador Unix compativel com C shell, com edicao e conclusao programavel.",
+          longDescription: "Tcsh estende C shell com edicao de linha, historico, aliases, controle de tarefas e conclusao programavel. Mantem ampla compatibilidade com scripts csh e oferece um ambiente interativo mais rico.\n\nO shell esta disponivel em sistemas semelhantes ao Unix e tem uso historico em ambientes BSD, estacoes tecnicas e automacao legada. Scripts usam fluxo de controle e sintaxe de variaveis no estilo csh."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/tex.ts
 var tex_exports = {};
 __export(tex_exports, {
@@ -11962,6 +13527,63 @@ var init_tex = __esm({
   }
 });
 
+// src/languages/textile.ts
+var textile_exports = {};
+__export(textile_exports, {
+  textile: () => exports.textile
+});
+exports.textile = void 0;
+var init_textile = __esm({
+  "src/languages/textile.ts"() {
+    exports.textile = {
+      slug: "textile",
+      publishedDate: "2002-12-26",
+      extensions: [".textile"],
+      author: "Dean Allen",
+      website: "https://textile-lang.com",
+      paradigms: ["markup", "documentation"],
+      tooling: {
+        ecosystems: ["Web", "CMS", "Documentation"]
+      },
+      version: "4.1.4",
+      logo: "https://textile-lang.com/icon.svg",
+      color: "#CC0000",
+      i18n: {
+        en: {
+          name: "Textile",
+          description: "A lightweight markup language that converts readable plain text into structured HTML.",
+          longDescription: "Textile provides concise syntax for headings, emphasis, links, images, lists, tables, code, and typographic substitutions. Processors transform the source into HTML while preserving readable authoring text.\n\nThe format has been used by content management systems, issue trackers, forums, and publishing tools. Multiple implementations exist, with PHP Textile serving as a maintained reference in the current ecosystem."
+        },
+        es: {
+          name: "Textile",
+          description: "Lenguaje de marcado ligero que convierte texto legible en HTML estructurado.",
+          longDescription: "Textile ofrece sintaxis concisa para encabezados, enfasis, enlaces, imagenes, listas, tablas, codigo y sustituciones tipograficas. Sus procesadores convierten la fuente en HTML manteniendo un texto facil de escribir y leer.\n\nEl formato se ha usado en gestores de contenido, trackers, foros y herramientas de publicacion. Existen varias implementaciones; PHP Textile funciona como referencia mantenida del ecosistema actual."
+        },
+        it: {
+          name: "Textile",
+          description: "Linguaggio di markup leggero che converte testo leggibile in HTML strutturato.",
+          longDescription: "Textile offre una sintassi concisa per titoli, enfasi, link, immagini, liste, tabelle, codice e sostituzioni tipografiche. I processori trasformano il sorgente in HTML mantenendo il testo facile da scrivere e leggere.\n\nIl formato e stato usato in CMS, issue tracker, forum e strumenti di pubblicazione. Esistono diverse implementazioni; PHP Textile funge da riferimento mantenuto nell ecosistema attuale."
+        },
+        fr: {
+          name: "Textile",
+          description: "Langage de balisage leger convertissant un texte lisible en HTML structure.",
+          longDescription: "Textile fournit une syntaxe concise pour titres, emphase, liens, images, listes, tableaux, code et substitutions typographiques. Les processeurs transforment la source en HTML tout en gardant un texte facile a ecrire et lire.\n\nLe format a servi dans gestionnaires de contenu, suivis de problemes, forums et outils de publication. Plusieurs implementations existent; PHP Textile reste une reference maintenue de l ecosysteme actuel."
+        },
+        de: {
+          name: "Textile",
+          description: "Leichtgewichtige Markup-Sprache, die lesbaren Klartext in strukturiertes HTML umwandelt.",
+          longDescription: "Textile bietet kompakte Syntax fur Uberschriften, Hervorhebung, Links, Bilder, Listen, Tabellen, Code und typografische Ersetzungen. Prozessoren wandeln den Quelltext in HTML um, wahrend der Autorentext lesbar bleibt.\n\nDas Format wurde in Content-Management-Systemen, Issue-Trackern, Foren und Publikationswerkzeugen eingesetzt. Mehrere Implementierungen existieren; PHP Textile dient als gepflegte Referenz."
+        },
+        pt: {
+          name: "Textile",
+          description: "Linguagem de marcacao leve que converte texto legivel em HTML estruturado.",
+          longDescription: "Textile oferece sintaxe concisa para titulos, enfase, links, imagens, listas, tabelas, codigo e substituicoes tipograficas. Processadores transformam a fonte em HTML mantendo texto facil de escrever e ler.\n\nO formato foi usado em gestores de conteudo, rastreadores, foruns e ferramentas de publicacao. Existem varias implementacoes; PHP Textile funciona como referencia mantida no ecossistema atual."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/thrift.ts
 var thrift_exports = {};
 __export(thrift_exports, {
@@ -12133,6 +13755,64 @@ var init_toml = __esm({
   }
 });
 
+// src/languages/troff.ts
+var troff_exports = {};
+__export(troff_exports, {
+  troff: () => exports.troff
+});
+exports.troff = void 0;
+var init_troff = __esm({
+  "src/languages/troff.ts"() {
+    exports.troff = {
+      slug: "troff",
+      publishedDate: "1973-01-01",
+      extensions: [".roff", ".troff", ".man", ".me", ".ms"],
+      author: "Joe Ossanna, Brian Kernighan, and GNU contributors",
+      website: "https://www.gnu.org/software/groff/",
+      paradigms: ["markup", "typesetting"],
+      tooling: {
+        runtimes: ["GNU groff", "troff", "nroff"],
+        ecosystems: ["Unix", "Documentation", "Typesetting"]
+      },
+      version: "GNU groff 1.24.1",
+      logo: "https://cdn.simpleicons.org/gnu/A42E2B",
+      color: "#8F5902",
+      i18n: {
+        en: {
+          name: "Troff/Groff",
+          description: "A typesetting markup language and GNU implementation used for Unix documents and man pages.",
+          longDescription: "Troff source combines text with requests, escapes, registers, strings, and macros that control layout and typography. Macro packages such as man, mdoc, ms, me, and mom provide higher-level document conventions.\n\nGNU groff is the maintained free implementation of the historical Unix troff system. It formats manual pages, technical papers, books, and other documents for terminals, PostScript, PDF, HTML, and additional output devices."
+        },
+        es: {
+          name: "Troff/Groff",
+          description: "Lenguaje tipografico e implementacion GNU usado para documentos Unix y paginas man.",
+          longDescription: "La fuente Troff combina texto con peticiones, escapes, registros, cadenas y macros que controlan maquetacion y tipografia. Paquetes como man, mdoc, ms, me y mom ofrecen convenciones documentales de mayor nivel.\n\nGNU groff es la implementacion libre mantenida del sistema troff historico de Unix. Formatea paginas man, articulos tecnicos, libros y otros documentos para terminal, PostScript, PDF, HTML y mas destinos."
+        },
+        it: {
+          name: "Troff/Groff",
+          description: "Linguaggio tipografico e implementazione GNU per documenti Unix e pagine man.",
+          longDescription: "Il sorgente Troff combina testo con richieste, escape, registri, stringhe e macro che controllano impaginazione e tipografia. Pacchetti come man, mdoc, ms, me e mom offrono convenzioni documentali di livello superiore.\n\nGNU groff e l implementazione libera mantenuta dello storico sistema troff Unix. Formatta pagine man, articoli tecnici, libri e altri documenti per terminale, PostScript, PDF, HTML e ulteriori dispositivi."
+        },
+        fr: {
+          name: "Troff/Groff",
+          description: "Langage de composition et implementation GNU pour documents Unix et pages man.",
+          longDescription: "Une source Troff combine texte, requetes, echappements, registres, chaines et macros qui controlent mise en page et typographie. Les paquets man, mdoc, ms, me et mom fournissent des conventions documentaires de plus haut niveau.\n\nGNU groff est l implementation libre maintenue du systeme troff historique d Unix. Il formate pages man, articles techniques, livres et autres documents pour terminal, PostScript, PDF, HTML et autres sorties."
+        },
+        de: {
+          name: "Troff/Groff",
+          description: "Satz-Markup-Sprache und GNU-Implementierung fur Unix-Dokumente und Handbuchseiten.",
+          longDescription: "Troff-Quelltext kombiniert Text mit Befehlen, Escape-Sequenzen, Registern, Zeichenketten und Makros zur Steuerung von Layout und Typografie. Pakete wie man, mdoc, ms, me und mom bieten hohere Dokumentkonventionen.\n\nGNU groff ist die gepflegte freie Implementierung des historischen Unix-troff-Systems. Es formatiert Handbuchseiten, technische Artikel, Bucher und andere Dokumente fur Terminal, PostScript, PDF, HTML und weitere Ausgaben."
+        },
+        pt: {
+          name: "Troff/Groff",
+          description: "Linguagem tipografica e implementacao GNU usada em documentos Unix e paginas man.",
+          longDescription: "Fontes Troff combinam texto com requisicoes, escapes, registradores, strings e macros que controlam layout e tipografia. Pacotes como man, mdoc, ms, me e mom oferecem convencoes documentais de nivel mais alto.\n\nGNU groff e a implementacao livre mantida do sistema troff historico do Unix. Formata paginas man, artigos tecnicos, livros e outros documentos para terminal, PostScript, PDF, HTML e outras saidas."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/tsql.ts
 var tsql_exports = {};
 __export(tsql_exports, {
@@ -12608,6 +14288,64 @@ var init_vale = __esm({
   }
 });
 
+// src/languages/velocity.ts
+var velocity_exports = {};
+__export(velocity_exports, {
+  velocity: () => exports.velocity
+});
+exports.velocity = void 0;
+var init_velocity = __esm({
+  "src/languages/velocity.ts"() {
+    exports.velocity = {
+      slug: "velocity",
+      publishedDate: "2001-01-01",
+      extensions: [".vm", ".vtl"],
+      author: "Apache Software Foundation",
+      website: "https://velocity.apache.org",
+      paradigms: ["template", "declarative"],
+      tooling: {
+        runtimes: ["Apache Velocity Engine"],
+        ecosystems: ["Java", "Web", "Code Generation"]
+      },
+      version: "2.4.1",
+      logo: "https://velocity.apache.org/engine/devel/images/velocity-logo.png",
+      color: "#2D3E50",
+      i18n: {
+        en: {
+          name: "Apache Velocity",
+          description: "A Java template language for generating text from application data and objects.",
+          longDescription: "Apache Velocity Template Language combines references, directives, loops, conditions, and macros to render text from Java objects. Templates remain separate from application code and can target HTML, email, source code, or configuration files.\n\nVelocity is commonly embedded in Java applications, build tools, generators, and web frameworks. Its engine supplies the context that templates read while controlling resource loading, escaping, and execution behavior."
+        },
+        es: {
+          name: "Apache Velocity",
+          description: "Lenguaje de plantillas Java para generar texto desde datos y objetos de aplicaciones.",
+          longDescription: "Apache Velocity Template Language combina referencias, directivas, bucles, condiciones y macros para renderizar texto desde objetos Java. Las plantillas permanecen separadas del codigo y pueden producir HTML, correos, codigo fuente o configuracion.\n\nVelocity suele integrarse en aplicaciones Java, herramientas de construccion, generadores y frameworks web. Su motor aporta el contexto que leen las plantillas y controla carga de recursos, escape y ejecucion."
+        },
+        it: {
+          name: "Apache Velocity",
+          description: "Linguaggio di template Java per generare testo da dati e oggetti applicativi.",
+          longDescription: "Apache Velocity Template Language combina riferimenti, direttive, cicli, condizioni e macro per produrre testo da oggetti Java. I template restano separati dal codice e possono generare HTML, email, codice sorgente o configurazioni.\n\nVelocity viene incorporato in applicazioni Java, strumenti di build, generatori e framework web. Il motore fornisce il contesto letto dai template e controlla caricamento delle risorse, escaping ed esecuzione."
+        },
+        fr: {
+          name: "Apache Velocity",
+          description: "Langage de templates Java pour generer du texte depuis les donnees et objets applicatifs.",
+          longDescription: "Apache Velocity Template Language combine references, directives, boucles, conditions et macros pour produire du texte a partir d objets Java. Les templates restent separes du code et peuvent generer HTML, courriels, code source ou configuration.\n\nVelocity est integre aux applications Java, outils de build, generateurs et frameworks web. Son moteur fournit le contexte lu par les templates et controle chargement des ressources, echappement et execution."
+        },
+        de: {
+          name: "Apache Velocity",
+          description: "Java-Templatesprache zur Texterzeugung aus Anwendungsdaten und Objekten.",
+          longDescription: "Apache Velocity Template Language kombiniert Referenzen, Direktiven, Schleifen, Bedingungen und Makros, um Text aus Java-Objekten zu erzeugen. Templates bleiben vom Anwendungscode getrennt und konnen HTML, E-Mails, Quellcode oder Konfiguration ausgeben.\n\nVelocity wird in Java-Anwendungen, Build-Werkzeuge, Generatoren und Web-Frameworks eingebettet. Die Engine liefert den Template-Kontext und steuert Ressourcenladen, Escaping und Ausfuhrung."
+        },
+        pt: {
+          name: "Apache Velocity",
+          description: "Linguagem de templates Java para gerar texto a partir de dados e objetos da aplicacao.",
+          longDescription: "Apache Velocity Template Language combina referencias, diretivas, lacos, condicoes e macros para produzir texto a partir de objetos Java. Templates ficam separados do codigo e podem gerar HTML, emails, codigo-fonte ou configuracao.\n\nVelocity e incorporado em aplicacoes Java, ferramentas de build, geradores e frameworks web. Seu motor fornece o contexto lido pelos templates e controla carregamento de recursos, escape e execucao."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/verilog.ts
 var verilog_exports = {};
 __export(verilog_exports, {
@@ -13721,6 +15459,7 @@ init_actionscript();
 init_ada();
 init_agda();
 init_algol();
+init_ampl();
 init_ante();
 init_antlr();
 init_apex();
@@ -13734,19 +15473,24 @@ init_assembly();
 init_astro();
 init_austral();
 init_autohotkey();
+init_avro_idl();
 init_awk();
 init_ballerina();
 init_bash();
 init_batch();
 init_bazel();
 init_bcpl();
+init_bibtex();
 init_bicep();
 init_blade();
 init_bosque();
 init_bqn();
+init_brainfuck();
 init_c();
 init_cairo();
+init_capnproto();
 init_carbon();
+init_cel();
 init_chapel();
 init_circom();
 init_clojure();
@@ -13756,6 +15500,7 @@ init_coffeescript();
 init_coldfusion();
 init_coq();
 init_cpp();
+init_cql();
 init_crystal();
 init_csharp();
 init_css();
@@ -13770,7 +15515,9 @@ init_dart();
 init_dhall();
 init_dita();
 init_dockerfile();
+init_dot();
 init_earthly();
+init_editorconfig();
 init_eiffel();
 init_ejs();
 init_elixir();
@@ -13781,13 +15528,17 @@ init_factor();
 init_fe();
 init_fennel();
 init_fish();
+init_flatbuffers();
 init_flux();
 init_forth();
 init_fortran();
+init_fql();
 init_freemarker();
 init_fsharp();
 init_fstar();
+init_gcode();
 init_gdscript();
+init_gettext();
 init_git();
 init_gleam();
 init_glsl();
@@ -13795,6 +15546,7 @@ init_go();
 init_gradle();
 init_grain();
 init_graphql();
+init_gremlin();
 init_groovy();
 init_hack();
 init_haml();
@@ -13816,8 +15568,10 @@ init_janet();
 init_java();
 init_javascript();
 init_jinja();
+init_jmespath();
 init_json();
 init_json5();
+init_jsonata();
 init_jsonc();
 init_jsonnet();
 init_julia();
@@ -13827,9 +15581,11 @@ init_kcl();
 init_kdl();
 init_koka();
 init_kotlin();
+init_kql();
 init_lean();
 init_less();
 init_ligo();
+init_linkerscript();
 init_liquid();
 init_lisp();
 init_llvm_ir();
@@ -13843,6 +15599,7 @@ init_markdown();
 init_marlowe();
 init_mathematica();
 init_matlab();
+init_maxima();
 init_mdx();
 init_mercury();
 init_mermaid();
@@ -13853,6 +15610,7 @@ init_mojo();
 init_moonbit();
 init_move();
 init_mustache();
+init_n1ql();
 init_nginx();
 init_nickel();
 init_nim();
@@ -13865,6 +15623,7 @@ init_ocaml();
 init_odin();
 init_openapi();
 init_opencl();
+init_org();
 init_pascal();
 init_perl();
 init_php();
@@ -13872,7 +15631,9 @@ init_pine_script();
 init_pkl();
 init_pl_i();
 init_plantuml();
+init_plpgsql();
 init_plsql();
+init_pod();
 init_pony();
 init_powershell();
 init_prolog();
@@ -13882,6 +15643,7 @@ init_pug();
 init_puppet();
 init_purescript();
 init_python();
+init_qmake();
 init_qml();
 init_qsharp();
 init_r();
@@ -13907,8 +15669,10 @@ init_smalltalk();
 init_smarty();
 init_snobol();
 init_solidity();
+init_soql();
 init_spark();
 init_sparql();
+init_spl();
 init_sql();
 init_standard_ml();
 init_starlark();
@@ -13919,10 +15683,13 @@ init_svg();
 init_svn();
 init_swift();
 init_tcl();
+init_tcsh();
 init_tex();
+init_textile();
 init_thrift();
 init_tla_plus();
 init_toml();
+init_troff();
 init_tsql();
 init_twig();
 init_typescript();
@@ -13931,6 +15698,7 @@ init_unison();
 init_v();
 init_vala();
 init_vale();
+init_velocity();
 init_verilog();
 init_verse();
 init_vhdl();
@@ -13956,6 +15724,7 @@ var languages = [
   exports.ada,
   exports.agda,
   exports.algol,
+  exports.ampl,
   exports.ante,
   exports.antlr,
   exports.apex,
@@ -13969,6 +15738,7 @@ var languages = [
   exports.astro,
   exports.austral,
   exports.autohotkey,
+  exports.avroIdl,
   exports.awk,
   exports.ballerina,
   exports.bash,
@@ -13976,12 +15746,16 @@ var languages = [
   exports.bazel,
   exports.bcpl,
   exports.bicep,
+  exports.bibtex,
   exports.blade,
   exports.bosque,
   exports.bqn,
+  exports.brainfuck,
   exports.c,
   exports.cairo,
+  exports.capnproto,
   exports.carbon,
+  exports.cel,
   exports.chapel,
   exports.circom,
   exports.clojure,
@@ -13992,6 +15766,7 @@ var languages = [
   exports.coq,
   exports.cpp,
   exports.crystal,
+  exports.cql,
   exports.csharp,
   exports.css,
   exports.cuda,
@@ -14005,7 +15780,9 @@ var languages = [
   exports.dhall,
   exports.dita,
   exports.dockerfile,
+  exports.dot,
   exports.earthly,
+  exports.editorconfig,
   exports.eiffel,
   exports.ejs,
   exports.elixir,
@@ -14016,13 +15793,17 @@ var languages = [
   exports.fe,
   exports.fennel,
   exports.fish,
+  exports.flatbuffers,
   exports.flux,
   exports.forth,
   exports.fortran,
   exports.freemarker,
+  exports.fql,
   exports.fsharp,
   exports.fstar,
   exports.gdscript,
+  exports.gcode,
+  exports.gettext,
   exports.git,
   exports.gleam,
   exports.glsl,
@@ -14030,6 +15811,7 @@ var languages = [
   exports.gradle,
   exports.grain,
   exports.graphql,
+  exports.gremlin,
   exports.groovy,
   exports.hack,
   exports.haml,
@@ -14051,8 +15833,10 @@ var languages = [
   exports.java,
   exports.javascript,
   exports.jinja,
+  exports.jmespath,
   exports.json,
   exports.json5,
+  exports.jsonata,
   exports.jsonc,
   exports.jsonnet,
   exports.julia,
@@ -14062,10 +15846,12 @@ var languages = [
   exports.kdl,
   exports.koka,
   exports.kotlin,
+  exports.kql,
   exports.lean,
   exports.less,
   exports.ligo,
   exports.liquid,
+  exports.linkerscript,
   exports.lisp,
   exports.llvmIr,
   exports.lobster,
@@ -14078,6 +15864,7 @@ var languages = [
   exports.marlowe,
   exports.mathematica,
   exports.matlab,
+  exports.maxima,
   exports.mdx,
   exports.mermaid,
   exports.meson,
@@ -14088,6 +15875,7 @@ var languages = [
   exports.moonbit,
   exports.move,
   exports.mustache,
+  exports.n1ql,
   exports.nginx,
   exports.nickel,
   exports.nim,
@@ -14100,6 +15888,7 @@ var languages = [
   exports.odin,
   exports.openapi,
   exports.opencl,
+  exports.org,
   exports.pascal,
   exports.perl,
   exports.php,
@@ -14107,7 +15896,9 @@ var languages = [
   exports.plI,
   exports.pkl,
   exports.plantuml,
+  exports.plpgsql,
   exports.plsql,
+  exports.pod,
   exports.pony,
   exports.powershell,
   exports.prolog,
@@ -14118,6 +15909,7 @@ var languages = [
   exports.purescript,
   exports.python,
   exports.qml,
+  exports.qmake,
   exports.qsharp,
   exports.r,
   exports.racket,
@@ -14142,8 +15934,10 @@ var languages = [
   exports.smarty,
   exports.snobol,
   exports.solidity,
+  exports.soql,
   exports.sparql,
   exports.spark,
+  exports.spl,
   exports.sql,
   exports.standardMl,
   exports.starlark,
@@ -14154,10 +15948,13 @@ var languages = [
   exports.svn,
   exports.swift,
   exports.tcl,
+  exports.tcsh,
   exports.tex,
+  exports.textile,
   exports.thrift,
   exports.tlaPlus,
   exports.toml,
+  exports.troff,
   exports.tsql,
   exports.twig,
   exports.typescript,
@@ -14166,6 +15963,7 @@ var languages = [
   exports.v,
   exports.vala,
   exports.vale,
+  exports.velocity,
   exports.verilog,
   exports.verse,
   exports.vhdl,
@@ -14194,6 +15992,7 @@ var languageIndex = [
   { slug: "ada", extensions: [".adb", ".ads", ".ada"] },
   { slug: "agda", extensions: [".agda", ".lagda", ".lagda.md", ".lagda.rst", ".lagda.tex"] },
   { slug: "algol", extensions: [".alg", ".algol"] },
+  { slug: "ampl", extensions: [".mod", ".dat", ".run"] },
   { slug: "ante", extensions: [".ante"] },
   { slug: "antlr", extensions: [".g4"] },
   { slug: "apex", extensions: [".cls", ".trigger"] },
@@ -14207,6 +16006,7 @@ var languageIndex = [
   { 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"] },
   {
@@ -14217,12 +16017,16 @@ var languageIndex = [
   { 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: "blade", extensions: [".blade.php"] },
   { slug: "bosque", extensions: [".bsq"] },
   { slug: "bqn", extensions: [".bqn"] },
+  { slug: "brainfuck", extensions: [".bf", ".b"] },
   { slug: "c", extensions: [".c", ".h"] },
   { slug: "cairo", extensions: [".cairo"] },
+  { slug: "capnproto", extensions: [".capnp"] },
   { slug: "carbon", extensions: [".carbon"] },
+  { slug: "cel", extensions: [".cel"] },
   { slug: "chapel", extensions: [".chpl"] },
   { slug: "circom", extensions: [".circom"] },
   { slug: "clojure", extensions: [".clj", ".cljs", ".cljc", ".edn", ".bb"] },
@@ -14233,6 +16037,7 @@ var languageIndex = [
   { slug: "coq", extensions: [".v"] },
   { slug: "cpp", extensions: [".cpp", ".cc", ".cxx", ".h", ".hpp", ".hh", ".hxx"] },
   { slug: "crystal", extensions: [".cr"] },
+  { slug: "cql", extensions: [".cql"] },
   { slug: "csharp", extensions: [".cs", ".csx"] },
   { slug: "css", extensions: [".css"] },
   { slug: "cuda", extensions: [".cu", ".cuh"] },
@@ -14246,7 +16051,9 @@ var languageIndex = [
   { slug: "dhall", extensions: [".dhall"] },
   { slug: "dita", extensions: [".dita", ".ditamap", ".ditaval"] },
   { slug: "dockerfile", extensions: ["Dockerfile", ".dockerfile"] },
+  { slug: "dot", extensions: [".dot", ".gv"] },
   { slug: "earthly", extensions: ["Earthfile"] },
+  { slug: "editorconfig", extensions: [".editorconfig"] },
   { slug: "eiffel", extensions: [".e"] },
   { slug: "ejs", extensions: [".ejs"] },
   { slug: "elixir", extensions: [".ex", ".exs", ".eex", ".leex", ".heex"] },
@@ -14260,6 +16067,7 @@ var languageIndex = [
   { slug: "fe", extensions: [".fe"] },
   { slug: "fennel", extensions: [".fnl"] },
   { slug: "fish", extensions: [".fish"] },
+  { slug: "flatbuffers", extensions: [".fbs"] },
   { slug: "flux", extensions: [".flux"] },
   { slug: "forth", extensions: [".fs", ".fth", ".forth", ".4th"] },
   {
@@ -14267,9 +16075,12 @@ var languageIndex = [
     extensions: [".f", ".for", ".ftn", ".f90", ".f95", ".f03", ".f08", ".f18", ".f23"]
   },
   { slug: "freemarker", extensions: [".ftl", ".ftlh", ".ftlx"] },
+  { slug: "fql", extensions: [".fql"] },
   { 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: "gettext", extensions: [".po", ".pot"] },
   { slug: "git", extensions: [".git", ".gitignore", ".gitattributes", ".gitmodules", ".gitkeep"] },
   { slug: "gleam", extensions: [".gleam"] },
   {
@@ -14280,6 +16091,7 @@ var languageIndex = [
   { slug: "gradle", extensions: [".gradle", ".gradle.kts"] },
   { slug: "grain", extensions: [".gr"] },
   { slug: "graphql", extensions: [".graphql", ".gql", ".graphqls"] },
+  { slug: "gremlin", extensions: [".gremlin", ".grem"] },
   { slug: "groovy", extensions: [".groovy", ".gvy", ".gy", ".gsh"] },
   { slug: "hack", extensions: [".hack", ".hh", ".hhi"] },
   { slug: "haml", extensions: [".haml"] },
@@ -14301,8 +16113,10 @@ var languageIndex = [
   { slug: "java", extensions: [".java"] },
   { slug: "javascript", extensions: [".js", ".mjs", ".cjs", ".jsx"] },
   { slug: "jinja", extensions: [".jinja", ".jinja2", ".j2"] },
+  { slug: "jmespath", extensions: [".jmespath", ".jp"] },
   { slug: "json", extensions: [".json"] },
   { slug: "json5", extensions: [".json5"] },
+  { slug: "jsonata", extensions: [".jsonata"] },
   { slug: "jsonc", extensions: [".jsonc", ".code-workspace"] },
   { slug: "jsonnet", extensions: [".jsonnet", ".libsonnet"] },
   { slug: "julia", extensions: [".jl"] },
@@ -14312,10 +16126,12 @@ var languageIndex = [
   { slug: "kdl", extensions: [".kdl"] },
   { slug: "koka", extensions: [".kk"] },
   { slug: "kotlin", extensions: [".kt", ".kts"] },
+  { slug: "kql", extensions: [".kql"] },
   { slug: "lean", extensions: [".lean"] },
   { slug: "less", extensions: [".less"] },
   { slug: "ligo", extensions: [".ligo", ".mligo", ".religo", ".jsligo"] },
   { slug: "liquid", extensions: [".liquid"] },
+  { slug: "linkerscript", extensions: [".ld", ".lds", ".x"] },
   { slug: "lisp", extensions: [".lisp", ".lsp", ".cl", ".asd"] },
   { slug: "llvm-ir", extensions: [".ll", ".bc"] },
   { slug: "lobster", extensions: [".lobster"] },
@@ -14328,6 +16144,7 @@ var languageIndex = [
   { slug: "marlowe", extensions: [".marlowe"] },
   { slug: "mathematica", extensions: [".wl", ".wls", ".nb"] },
   { slug: "matlab", extensions: [".m", ".mlx"] },
+  { slug: "maxima", extensions: [".mac", ".wxm"] },
   { slug: "mdx", extensions: [".mdx"] },
   { slug: "mermaid", extensions: [".mmd", ".mermaid"] },
   { slug: "meson", extensions: ["meson.build", "meson_options.txt", "meson.options", ".wrap"] },
@@ -14338,6 +16155,7 @@ var languageIndex = [
   { slug: "moonbit", extensions: [".mbt"] },
   { slug: "move", extensions: [".move"] },
   { slug: "mustache", extensions: [".mustache", ".mst"] },
+  { slug: "n1ql", extensions: [".n1ql"] },
   { slug: "nginx", extensions: ["nginx.conf", ".nginx", ".conf"] },
   { slug: "nickel", extensions: [".ncl"] },
   { slug: "nim", extensions: [".nim", ".nims", ".nimble"] },
@@ -14350,6 +16168,7 @@ var languageIndex = [
   { slug: "odin", extensions: [".odin"] },
   { slug: "openapi", extensions: [".openapi.json", ".openapi.yaml", ".openapi.yml"] },
   { slug: "opencl", extensions: [".cl", ".clh"] },
+  { slug: "org", extensions: [".org"] },
   { slug: "pascal", extensions: [".pas", ".pp", ".inc", ".lpr", ".dpr", ".dfm"] },
   { slug: "perl", extensions: [".pl", ".pm", ".pod", ".t", ".psgi"] },
   { slug: "php", extensions: [".php", ".phtml", ".php3", ".php4", ".php5", ".phps"] },
@@ -14357,7 +16176,9 @@ var languageIndex = [
   { slug: "pl-i", extensions: [".pli", ".pl1"] },
   { slug: "pkl", extensions: [".pkl"] },
   { slug: "plantuml", extensions: [".puml", ".plantuml", ".iuml"] },
+  { slug: "plpgsql", extensions: [".pgsql", ".plpgsql"] },
   { slug: "plsql", extensions: [".pls", ".pks", ".pkb", ".plsql"] },
+  { slug: "pod", extensions: [".pod"] },
   { slug: "pony", extensions: [".pony"] },
   { slug: "powershell", extensions: [".ps1", ".psm1", ".psd1", ".ps1xml"] },
   { slug: "prolog", extensions: [".pl", ".pro", ".prolog", ".P"] },
@@ -14368,6 +16189,7 @@ var languageIndex = [
   { slug: "purescript", extensions: [".purs"] },
   { slug: "python", extensions: [".py", ".pyw"] },
   { slug: "qml", extensions: [".qml", ".qmltypes", ".qmlproject"] },
+  { slug: "qmake", extensions: [".pri", ".prf"] },
   { slug: "qsharp", extensions: [".qs"] },
   { slug: "r", extensions: [".r", ".R", ".rmd", ".Rmd", ".qmd", ".Rprofile"] },
   { slug: "racket", extensions: [".rkt", ".rktd", ".rktl", ".scrbl"] },
@@ -14395,8 +16217,10 @@ var languageIndex = [
   { slug: "smarty", extensions: [".tpl", ".smarty"] },
   { 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: "spl", extensions: [".spl"] },
   { slug: "sql", extensions: [".sql"] },
   { slug: "standard-ml", extensions: [".sml", ".sig", ".fun"] },
   { slug: "starlark", extensions: [".bzl", ".star", ".sky"] },
@@ -14407,10 +16231,13 @@ var languageIndex = [
   { slug: "svn", extensions: [".svn", "svnserve.conf"] },
   { slug: "swift", extensions: [".swift"] },
   { slug: "tcl", extensions: [".tcl", ".tm", ".test"] },
+  { slug: "tcsh", extensions: [".tcsh", ".csh", ".tcshrc", ".cshrc"] },
   { slug: "tex", extensions: [".tex", ".sty", ".cls", ".dtx", ".ins", ".ltx"] },
+  { slug: "textile", extensions: [".textile"] },
   { slug: "thrift", extensions: [".thrift"] },
   { slug: "tla-plus", extensions: [".tla"] },
   { slug: "toml", extensions: [".toml"] },
+  { slug: "troff", extensions: [".roff", ".troff", ".man", ".me", ".ms"] },
   { slug: "tsql", extensions: [".sql", ".tsql"] },
   { slug: "twig", extensions: [".twig"] },
   { slug: "typescript", extensions: [".ts", ".tsx", ".mts", ".cts"] },
@@ -14419,6 +16246,7 @@ var languageIndex = [
   { slug: "v", extensions: [".v", ".vsh"] },
   { slug: "vala", extensions: [".vala", ".vapi"] },
   { slug: "vale", extensions: [".vale"] },
+  { slug: "velocity", extensions: [".vm", ".vtl"] },
   { slug: "verilog", extensions: [".v", ".vh", ".sv", ".svh"] },
   { slug: "verse", extensions: [".verse"] },
   { slug: "vhdl", extensions: [".vhd", ".vhdl"] },
@@ -14448,6 +16276,7 @@ var languageLoaders = {
   ada: () => Promise.resolve().then(() => (init_ada(), ada_exports)).then((module) => module.ada),
   agda: () => Promise.resolve().then(() => (init_agda(), agda_exports)).then((module) => module.agda),
   algol: () => Promise.resolve().then(() => (init_algol(), algol_exports)).then((module) => module.algol),
+  ampl: () => Promise.resolve().then(() => (init_ampl(), ampl_exports)).then((module) => module.ampl),
   ante: () => Promise.resolve().then(() => (init_ante(), ante_exports)).then((module) => module.ante),
   antlr: () => Promise.resolve().then(() => (init_antlr(), antlr_exports)).then((module) => module.antlr),
   apex: () => Promise.resolve().then(() => (init_apex(), apex_exports)).then((module) => module.apex),
@@ -14461,6 +16290,7 @@ var languageLoaders = {
   astro: () => Promise.resolve().then(() => (init_astro(), astro_exports)).then((module) => module.astro),
   austral: () => Promise.resolve().then(() => (init_austral(), austral_exports)).then((module) => module.austral),
   autohotkey: () => Promise.resolve().then(() => (init_autohotkey(), autohotkey_exports)).then((module) => module.autohotkey),
+  "avro-idl": () => Promise.resolve().then(() => (init_avro_idl(), avro_idl_exports)).then((module) => module.avroIdl),
   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),
@@ -14468,12 +16298,16 @@ var languageLoaders = {
   bazel: () => Promise.resolve().then(() => (init_bazel(), bazel_exports)).then((module) => module.bazel),
   bcpl: () => Promise.resolve().then(() => (init_bcpl(), bcpl_exports)).then((module) => module.bcpl),
   bicep: () => Promise.resolve().then(() => (init_bicep(), bicep_exports)).then((module) => module.bicep),
+  bibtex: () => Promise.resolve().then(() => (init_bibtex(), bibtex_exports)).then((module) => module.bibtex),
   blade: () => Promise.resolve().then(() => (init_blade(), blade_exports)).then((module) => module.blade),
   bosque: () => Promise.resolve().then(() => (init_bosque(), bosque_exports)).then((module) => module.bosque),
   bqn: () => Promise.resolve().then(() => (init_bqn(), bqn_exports)).then((module) => module.bqn),
+  brainfuck: () => Promise.resolve().then(() => (init_brainfuck(), brainfuck_exports)).then((module) => module.brainfuck),
   c: () => Promise.resolve().then(() => (init_c(), c_exports)).then((module) => module.c),
   cairo: () => Promise.resolve().then(() => (init_cairo(), cairo_exports)).then((module) => module.cairo),
+  capnproto: () => Promise.resolve().then(() => (init_capnproto(), capnproto_exports)).then((module) => module.capnproto),
   carbon: () => Promise.resolve().then(() => (init_carbon(), carbon_exports)).then((module) => module.carbon),
+  cel: () => Promise.resolve().then(() => (init_cel(), cel_exports)).then((module) => module.cel),
   chapel: () => Promise.resolve().then(() => (init_chapel(), chapel_exports)).then((module) => module.chapel),
   circom: () => Promise.resolve().then(() => (init_circom(), circom_exports)).then((module) => module.circom),
   clojure: () => Promise.resolve().then(() => (init_clojure(), clojure_exports)).then((module) => module.clojure),
@@ -14484,6 +16318,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),
   crystal: () => Promise.resolve().then(() => (init_crystal(), crystal_exports)).then((module) => module.crystal),
+  cql: () => Promise.resolve().then(() => (init_cql(), cql_exports)).then((module) => module.cql),
   csharp: () => Promise.resolve().then(() => (init_csharp(), csharp_exports)).then((module) => module.csharp),
   css: () => Promise.resolve().then(() => (init_css(), css_exports)).then((module) => module.css),
   cuda: () => Promise.resolve().then(() => (init_cuda(), cuda_exports)).then((module) => module.cuda),
@@ -14497,7 +16332,9 @@ 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),
+  dot: () => Promise.resolve().then(() => (init_dot(), dot_exports)).then((module) => module.dot),
   earthly: () => Promise.resolve().then(() => (init_earthly(), earthly_exports)).then((module) => module.earthly),
+  editorconfig: () => Promise.resolve().then(() => (init_editorconfig(), editorconfig_exports)).then((module) => module.editorconfig),
   eiffel: () => Promise.resolve().then(() => (init_eiffel(), eiffel_exports)).then((module) => module.eiffel),
   ejs: () => Promise.resolve().then(() => (init_ejs(), ejs_exports)).then((module) => module.ejs),
   elixir: () => Promise.resolve().then(() => (init_elixir(), elixir_exports)).then((module) => module.elixir),
@@ -14508,13 +16345,17 @@ var languageLoaders = {
   fe: () => Promise.resolve().then(() => (init_fe(), fe_exports)).then((module) => module.fe),
   fennel: () => Promise.resolve().then(() => (init_fennel(), fennel_exports)).then((module) => module.fennel),
   fish: () => Promise.resolve().then(() => (init_fish(), fish_exports)).then((module) => module.fish),
+  flatbuffers: () => Promise.resolve().then(() => (init_flatbuffers(), flatbuffers_exports)).then((module) => module.flatbuffers),
   flux: () => Promise.resolve().then(() => (init_flux(), flux_exports)).then((module) => module.flux),
   forth: () => Promise.resolve().then(() => (init_forth(), forth_exports)).then((module) => module.forth),
   fortran: () => Promise.resolve().then(() => (init_fortran(), fortran_exports)).then((module) => module.fortran),
   freemarker: () => Promise.resolve().then(() => (init_freemarker(), freemarker_exports)).then((module) => module.freemarker),
+  fql: () => Promise.resolve().then(() => (init_fql(), fql_exports)).then((module) => module.fql),
   fsharp: () => Promise.resolve().then(() => (init_fsharp(), fsharp_exports)).then((module) => module.fsharp),
   fstar: () => Promise.resolve().then(() => (init_fstar(), fstar_exports)).then((module) => module.fstar),
   gdscript: () => Promise.resolve().then(() => (init_gdscript(), gdscript_exports)).then((module) => module.gdscript),
+  gcode: () => Promise.resolve().then(() => (init_gcode(), gcode_exports)).then((module) => module.gcode),
+  gettext: () => Promise.resolve().then(() => (init_gettext(), gettext_exports)).then((module) => module.gettext),
   git: () => Promise.resolve().then(() => (init_git(), git_exports)).then((module) => module.git),
   gleam: () => Promise.resolve().then(() => (init_gleam(), gleam_exports)).then((module) => module.gleam),
   glsl: () => Promise.resolve().then(() => (init_glsl(), glsl_exports)).then((module) => module.glsl),
@@ -14522,6 +16363,7 @@ var languageLoaders = {
   gradle: () => Promise.resolve().then(() => (init_gradle(), gradle_exports)).then((module) => module.gradle),
   grain: () => Promise.resolve().then(() => (init_grain(), grain_exports)).then((module) => module.grain),
   graphql: () => Promise.resolve().then(() => (init_graphql(), graphql_exports)).then((module) => module.graphql),
+  gremlin: () => Promise.resolve().then(() => (init_gremlin(), gremlin_exports)).then((module) => module.gremlin),
   groovy: () => Promise.resolve().then(() => (init_groovy(), groovy_exports)).then((module) => module.groovy),
   hack: () => Promise.resolve().then(() => (init_hack(), hack_exports)).then((module) => module.hack),
   haml: () => Promise.resolve().then(() => (init_haml(), haml_exports)).then((module) => module.haml),
@@ -14543,8 +16385,10 @@ var languageLoaders = {
   java: () => Promise.resolve().then(() => (init_java(), java_exports)).then((module) => module.java),
   javascript: () => Promise.resolve().then(() => (init_javascript(), javascript_exports)).then((module) => module.javascript),
   jinja: () => Promise.resolve().then(() => (init_jinja(), jinja_exports)).then((module) => module.jinja),
+  jmespath: () => Promise.resolve().then(() => (init_jmespath(), jmespath_exports)).then((module) => module.jmespath),
   json: () => Promise.resolve().then(() => (init_json(), json_exports)).then((module) => module.json),
   json5: () => Promise.resolve().then(() => (init_json5(), json5_exports)).then((module) => module.json5),
+  jsonata: () => Promise.resolve().then(() => (init_jsonata(), jsonata_exports)).then((module) => module.jsonata),
   jsonc: () => Promise.resolve().then(() => (init_jsonc(), jsonc_exports)).then((module) => module.jsonc),
   jsonnet: () => Promise.resolve().then(() => (init_jsonnet(), jsonnet_exports)).then((module) => module.jsonnet),
   julia: () => Promise.resolve().then(() => (init_julia(), julia_exports)).then((module) => module.julia),
@@ -14554,10 +16398,12 @@ var languageLoaders = {
   kdl: () => Promise.resolve().then(() => (init_kdl(), kdl_exports)).then((module) => module.kdl),
   koka: () => Promise.resolve().then(() => (init_koka(), koka_exports)).then((module) => module.koka),
   kotlin: () => Promise.resolve().then(() => (init_kotlin(), kotlin_exports)).then((module) => module.kotlin),
+  kql: () => Promise.resolve().then(() => (init_kql(), kql_exports)).then((module) => module.kql),
   lean: () => Promise.resolve().then(() => (init_lean(), lean_exports)).then((module) => module.lean),
   less: () => Promise.resolve().then(() => (init_less(), less_exports)).then((module) => module.less),
   ligo: () => Promise.resolve().then(() => (init_ligo(), ligo_exports)).then((module) => module.ligo),
   liquid: () => Promise.resolve().then(() => (init_liquid(), liquid_exports)).then((module) => module.liquid),
+  linkerscript: () => Promise.resolve().then(() => (init_linkerscript(), linkerscript_exports)).then((module) => module.linkerscript),
   lisp: () => Promise.resolve().then(() => (init_lisp(), lisp_exports)).then((module) => module.lisp),
   "llvm-ir": () => Promise.resolve().then(() => (init_llvm_ir(), llvm_ir_exports)).then((module) => module.llvmIr),
   lobster: () => Promise.resolve().then(() => (init_lobster(), lobster_exports)).then((module) => module.lobster),
@@ -14570,6 +16416,7 @@ var languageLoaders = {
   marlowe: () => Promise.resolve().then(() => (init_marlowe(), marlowe_exports)).then((module) => module.marlowe),
   mathematica: () => Promise.resolve().then(() => (init_mathematica(), mathematica_exports)).then((module) => module.mathematica),
   matlab: () => Promise.resolve().then(() => (init_matlab(), matlab_exports)).then((module) => module.matlab),
+  maxima: () => Promise.resolve().then(() => (init_maxima(), maxima_exports)).then((module) => module.maxima),
   mdx: () => Promise.resolve().then(() => (init_mdx(), mdx_exports)).then((module) => module.mdx),
   mermaid: () => Promise.resolve().then(() => (init_mermaid(), mermaid_exports)).then((module) => module.mermaid),
   meson: () => Promise.resolve().then(() => (init_meson(), meson_exports)).then((module) => module.meson),
@@ -14580,6 +16427,7 @@ var languageLoaders = {
   moonbit: () => Promise.resolve().then(() => (init_moonbit(), moonbit_exports)).then((module) => module.moonbit),
   move: () => Promise.resolve().then(() => (init_move(), move_exports)).then((module) => module.move),
   mustache: () => Promise.resolve().then(() => (init_mustache(), mustache_exports)).then((module) => module.mustache),
+  n1ql: () => Promise.resolve().then(() => (init_n1ql(), n1ql_exports)).then((module) => module.n1ql),
   nginx: () => Promise.resolve().then(() => (init_nginx(), nginx_exports)).then((module) => module.nginx),
   nickel: () => Promise.resolve().then(() => (init_nickel(), nickel_exports)).then((module) => module.nickel),
   nim: () => Promise.resolve().then(() => (init_nim(), nim_exports)).then((module) => module.nim),
@@ -14592,6 +16440,7 @@ var languageLoaders = {
   odin: () => Promise.resolve().then(() => (init_odin(), odin_exports)).then((module) => module.odin),
   openapi: () => Promise.resolve().then(() => (init_openapi(), openapi_exports)).then((module) => module.openapi),
   opencl: () => Promise.resolve().then(() => (init_opencl(), opencl_exports)).then((module) => module.opencl),
+  org: () => Promise.resolve().then(() => (init_org(), org_exports)).then((module) => module.org),
   pascal: () => Promise.resolve().then(() => (init_pascal(), pascal_exports)).then((module) => module.pascal),
   perl: () => Promise.resolve().then(() => (init_perl(), perl_exports)).then((module) => module.perl),
   php: () => Promise.resolve().then(() => (init_php(), php_exports)).then((module) => module.php),
@@ -14599,7 +16448,9 @@ var languageLoaders = {
   "pl-i": () => Promise.resolve().then(() => (init_pl_i(), pl_i_exports)).then((module) => module.plI),
   pkl: () => Promise.resolve().then(() => (init_pkl(), pkl_exports)).then((module) => module.pkl),
   plantuml: () => Promise.resolve().then(() => (init_plantuml(), plantuml_exports)).then((module) => module.plantuml),
+  plpgsql: () => Promise.resolve().then(() => (init_plpgsql(), plpgsql_exports)).then((module) => module.plpgsql),
   plsql: () => Promise.resolve().then(() => (init_plsql(), plsql_exports)).then((module) => module.plsql),
+  pod: () => Promise.resolve().then(() => (init_pod(), pod_exports)).then((module) => module.pod),
   pony: () => Promise.resolve().then(() => (init_pony(), pony_exports)).then((module) => module.pony),
   powershell: () => Promise.resolve().then(() => (init_powershell(), powershell_exports)).then((module) => module.powershell),
   prolog: () => Promise.resolve().then(() => (init_prolog(), prolog_exports)).then((module) => module.prolog),
@@ -14610,6 +16461,7 @@ var languageLoaders = {
   purescript: () => Promise.resolve().then(() => (init_purescript(), purescript_exports)).then((module) => module.purescript),
   python: () => Promise.resolve().then(() => (init_python(), python_exports)).then((module) => module.python),
   qml: () => Promise.resolve().then(() => (init_qml(), qml_exports)).then((module) => module.qml),
+  qmake: () => Promise.resolve().then(() => (init_qmake(), qmake_exports)).then((module) => module.qmake),
   qsharp: () => Promise.resolve().then(() => (init_qsharp(), qsharp_exports)).then((module) => module.qsharp),
   r: () => Promise.resolve().then(() => (init_r(), r_exports)).then((module) => module.r),
   racket: () => Promise.resolve().then(() => (init_racket(), racket_exports)).then((module) => module.racket),
@@ -14634,8 +16486,10 @@ var languageLoaders = {
   smarty: () => Promise.resolve().then(() => (init_smarty(), smarty_exports)).then((module) => module.smarty),
   snobol: () => Promise.resolve().then(() => (init_snobol(), snobol_exports)).then((module) => module.snobol),
   solidity: () => Promise.resolve().then(() => (init_solidity(), solidity_exports)).then((module) => module.solidity),
+  soql: () => Promise.resolve().then(() => (init_soql(), soql_exports)).then((module) => module.soql),
   sparql: () => Promise.resolve().then(() => (init_sparql(), sparql_exports)).then((module) => module.sparql),
   spark: () => Promise.resolve().then(() => (init_spark(), spark_exports)).then((module) => module.spark),
+  spl: () => Promise.resolve().then(() => (init_spl(), spl_exports)).then((module) => module.spl),
   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),
@@ -14646,10 +16500,13 @@ var languageLoaders = {
   svn: () => Promise.resolve().then(() => (init_svn(), svn_exports)).then((module) => module.svn),
   swift: () => Promise.resolve().then(() => (init_swift(), swift_exports)).then((module) => module.swift),
   tcl: () => Promise.resolve().then(() => (init_tcl(), tcl_exports)).then((module) => module.tcl),
+  tcsh: () => Promise.resolve().then(() => (init_tcsh(), tcsh_exports)).then((module) => module.tcsh),
   tex: () => Promise.resolve().then(() => (init_tex(), tex_exports)).then((module) => module.tex),
+  textile: () => Promise.resolve().then(() => (init_textile(), textile_exports)).then((module) => module.textile),
   thrift: () => Promise.resolve().then(() => (init_thrift(), thrift_exports)).then((module) => module.thrift),
   "tla-plus": () => Promise.resolve().then(() => (init_tla_plus(), tla_plus_exports)).then((module) => module.tlaPlus),
   toml: () => Promise.resolve().then(() => (init_toml(), toml_exports)).then((module) => module.toml),
+  troff: () => Promise.resolve().then(() => (init_troff(), troff_exports)).then((module) => module.troff),
   tsql: () => Promise.resolve().then(() => (init_tsql(), tsql_exports)).then((module) => module.tsql),
   twig: () => Promise.resolve().then(() => (init_twig(), twig_exports)).then((module) => module.twig),
   typescript: () => Promise.resolve().then(() => (init_typescript(), typescript_exports)).then((module) => module.typescript),
@@ -14658,6 +16515,7 @@ var languageLoaders = {
   v: () => Promise.resolve().then(() => (init_v(), v_exports)).then((module) => module.v),
   vala: () => Promise.resolve().then(() => (init_vala(), vala_exports)).then((module) => module.vala),
   vale: () => Promise.resolve().then(() => (init_vale(), vale_exports)).then((module) => module.vale),
+  velocity: () => Promise.resolve().then(() => (init_velocity(), velocity_exports)).then((module) => module.velocity),
   verilog: () => Promise.resolve().then(() => (init_verilog(), verilog_exports)).then((module) => module.verilog),
   verse: () => Promise.resolve().then(() => (init_verse(), verse_exports)).then((module) => module.verse),
   vhdl: () => Promise.resolve().then(() => (init_vhdl(), vhdl_exports)).then((module) => module.vhdl),
@@ -14857,6 +16715,7 @@ init_actionscript();
 init_ada();
 init_agda();
 init_algol();
+init_ampl();
 init_ante();
 init_antlr();
 init_apex();
@@ -14870,19 +16729,24 @@ init_assembly();
 init_astro();
 init_austral();
 init_autohotkey();
+init_avro_idl();
 init_awk();
 init_ballerina();
 init_bash();
 init_batch();
 init_bazel();
 init_bcpl();
+init_bibtex();
 init_bicep();
 init_blade();
 init_bosque();
 init_bqn();
+init_brainfuck();
 init_c();
 init_cairo();
+init_capnproto();
 init_carbon();
+init_cel();
 init_chapel();
 init_circom();
 init_clojure();
@@ -14892,6 +16756,7 @@ init_coffeescript();
 init_coldfusion();
 init_coq();
 init_cpp();
+init_cql();
 init_crystal();
 init_csharp();
 init_css();
@@ -14906,7 +16771,9 @@ init_dart();
 init_dhall();
 init_dita();
 init_dockerfile();
+init_dot();
 init_earthly();
+init_editorconfig();
 init_eiffel();
 init_ejs();
 init_elixir();
@@ -14917,13 +16784,17 @@ init_factor();
 init_fe();
 init_fennel();
 init_fish();
+init_flatbuffers();
 init_flux();
 init_forth();
 init_fortran();
+init_fql();
 init_freemarker();
 init_fsharp();
 init_fstar();
+init_gcode();
 init_gdscript();
+init_gettext();
 init_git();
 init_gleam();
 init_glsl();
@@ -14931,6 +16802,7 @@ init_go();
 init_gradle();
 init_grain();
 init_graphql();
+init_gremlin();
 init_groovy();
 init_hack();
 init_haml();
@@ -14952,8 +16824,10 @@ init_janet();
 init_java();
 init_javascript();
 init_jinja();
+init_jmespath();
 init_json();
 init_json5();
+init_jsonata();
 init_jsonc();
 init_jsonnet();
 init_julia();
@@ -14963,9 +16837,11 @@ init_kcl();
 init_kdl();
 init_koka();
 init_kotlin();
+init_kql();
 init_lean();
 init_less();
 init_ligo();
+init_linkerscript();
 init_liquid();
 init_lisp();
 init_llvm_ir();
@@ -14979,6 +16855,7 @@ init_markdown();
 init_marlowe();
 init_mathematica();
 init_matlab();
+init_maxima();
 init_mdx();
 init_mercury();
 init_mermaid();
@@ -14989,6 +16866,7 @@ init_mojo();
 init_moonbit();
 init_move();
 init_mustache();
+init_n1ql();
 init_nginx();
 init_nickel();
 init_nim();
@@ -15001,6 +16879,7 @@ init_ocaml();
 init_odin();
 init_openapi();
 init_opencl();
+init_org();
 init_pascal();
 init_perl();
 init_php();
@@ -15008,7 +16887,9 @@ init_pine_script();
 init_pkl();
 init_pl_i();
 init_plantuml();
+init_plpgsql();
 init_plsql();
+init_pod();
 init_pony();
 init_powershell();
 init_prolog();
@@ -15018,6 +16899,7 @@ init_pug();
 init_puppet();
 init_purescript();
 init_python();
+init_qmake();
 init_qml();
 init_qsharp();
 init_r();
@@ -15043,8 +16925,10 @@ init_smalltalk();
 init_smarty();
 init_snobol();
 init_solidity();
+init_soql();
 init_spark();
 init_sparql();
+init_spl();
 init_sql();
 init_standard_ml();
 init_starlark();
@@ -15055,10 +16939,13 @@ init_svg();
 init_svn();
 init_swift();
 init_tcl();
+init_tcsh();
 init_tex();
+init_textile();
 init_thrift();
 init_tla_plus();
 init_toml();
+init_troff();
 init_tsql();
 init_twig();
 init_typescript();
@@ -15067,6 +16954,7 @@ init_unison();
 init_v();
 init_vala();
 init_vale();
+init_velocity();
 init_verilog();
 init_verse();
 init_vhdl();