code-languages 1.34.1 → 1.35.0

package/dist/api.js

@@ -300,6 +300,64 @@ var init_algol = __esm({
   }
 });
 
+// src/languages/ampl.ts
+var ampl_exports = {};
+__export(ampl_exports, {
+  ampl: () => ampl
+});
+var ampl;
+var init_ampl = __esm({
+  "src/languages/ampl.ts"() {
+    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://dummyimage.com/32x32/1D4ED8/ffffff.png&text=AM",
+      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, {
@@ -1414,6 +1472,64 @@ var init_bcpl = __esm({
   }
 });
 
+// src/languages/bibtex.ts
+var bibtex_exports = {};
+__export(bibtex_exports, {
+  bibtex: () => bibtex
+});
+var bibtex;
+var init_bibtex = __esm({
+  "src/languages/bibtex.ts"() {
+    bibtex = {
+      slug: "bibtex",
+      publishedDate: "1985-01-01",
+      extensions: [".bib", ".bibtex"],
+      author: "Oren Patashnik and Leslie Lamport",
+      website: "https://ctan.org/pkg/bibtex",
+      paradigms: ["data", "bibliography"],
+      tooling: {
+        runtimes: ["BibTeX", "Biber"],
+        ecosystems: ["TeX", "LaTeX", "Academic publishing"]
+      },
+      version: "stable",
+      logo: "https://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, {
@@ -1648,6 +1764,64 @@ var init_bqn = __esm({
   }
 });
 
+// src/languages/brainfuck.ts
+var brainfuck_exports = {};
+__export(brainfuck_exports, {
+  brainfuck: () => brainfuck
+});
+var brainfuck;
+var init_brainfuck = __esm({
+  "src/languages/brainfuck.ts"() {
+    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, {
@@ -1766,6 +1940,64 @@ var init_cairo = __esm({
   }
 });
 
+// src/languages/capnproto.ts
+var capnproto_exports = {};
+__export(capnproto_exports, {
+  capnproto: () => capnproto
+});
+var capnproto;
+var init_capnproto = __esm({
+  "src/languages/capnproto.ts"() {
+    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://dummyimage.com/32x32/F97316/ffffff.png&text=CP",
+      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, {
@@ -2354,6 +2586,64 @@ var init_cpp = __esm({
   }
 });
 
+// src/languages/cql.ts
+var cql_exports = {};
+__export(cql_exports, {
+  cql: () => cql
+});
+var cql;
+var init_cql = __esm({
+  "src/languages/cql.ts"() {
+    cql = {
+      slug: "cql",
+      publishedDate: "2008-01-01",
+      extensions: [".cql"],
+      author: "Apache Cassandra project",
+      website: "https://cassandra.apache.org/doc/latest/cassandra/developing/cql/index.html",
+      paradigms: ["query", "declarative"],
+      tooling: {
+        runtimes: ["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, {
@@ -3173,6 +3463,64 @@ var init_dockerfile = __esm({
   }
 });
 
+// src/languages/dot.ts
+var dot_exports = {};
+__export(dot_exports, {
+  dot: () => dot
+});
+var dot;
+var init_dot = __esm({
+  "src/languages/dot.ts"() {
+    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://dummyimage.com/32x32/16A34A/ffffff.png&text=GV",
+      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, {
@@ -3232,6 +3580,63 @@ var init_earthly = __esm({
   }
 });
 
+// src/languages/editorconfig.ts
+var editorconfig_exports = {};
+__export(editorconfig_exports, {
+  editorconfig: () => editorconfig
+});
+var editorconfig;
+var init_editorconfig = __esm({
+  "src/languages/editorconfig.ts"() {
+    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://dummyimage.com/32x32/0F766E/ffffff.png&text=EC",
+      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, {
@@ -3996,6 +4401,64 @@ var init_fortran = __esm({
   }
 });
 
+// src/languages/fql.ts
+var fql_exports = {};
+__export(fql_exports, {
+  fql: () => fql
+});
+var fql;
+var init_fql = __esm({
+  "src/languages/fql.ts"() {
+    fql = {
+      slug: "fql",
+      publishedDate: "2012-01-01",
+      extensions: [".fql"],
+      author: "Facebook",
+      website: "https://developers.facebook.com/docs/reference/fql/",
+      paradigms: ["query", "declarative"],
+      tooling: {
+        runtimes: ["Facebook Platform"],
+        ecosystems: ["Social APIs", "Legacy web APIs"]
+      },
+      version: "legacy",
+      logo: "https://cdn.simpleicons.org/facebook/1877F2",
+      color: "#1877F2",
+      i18n: {
+        en: {
+          name: "FQL",
+          description: "A legacy SQL-like query language formerly used by Facebook Platform APIs.",
+          longDescription: "Facebook Query Language was a SQL-like language for reading data from the Facebook social graph through older platform APIs. Queries selected fields from virtual tables representing users, pages, events, photos, and related objects.\n\nFQL is now mainly of historical interest, because Facebook replaced it with newer Graph API patterns. It remains useful to recognize in old integrations, archived examples, migrations, and documentation for legacy social applications."
+        },
+        es: {
+          name: "FQL",
+          description: "Lenguaje de consultas legado tipo SQL usado antes por APIs de Facebook.",
+          longDescription: "Facebook Query Language fue un lenguaje tipo SQL para leer datos del grafo social de Facebook mediante APIs antiguas de la plataforma. Las consultas seleccionaban campos de tablas virtuales que representaban usuarios, paginas, eventos, fotos y objetos relacionados.\n\nFQL hoy tiene interes sobre todo historico, porque Facebook lo reemplazo con patrones mas nuevos de Graph API. Sigue siendo util reconocerlo en integraciones viejas, ejemplos archivados, migraciones y documentacion de apps sociales legadas."
+        },
+        it: {
+          name: "FQL",
+          description: "Linguaggio di query legacy simile a SQL usato dalle vecchie API Facebook.",
+          longDescription: "Facebook Query Language era un linguaggio simile a SQL per leggere dati dal grafo sociale di Facebook tramite vecchie API della piattaforma. Le query selezionavano campi da tabelle virtuali che rappresentavano utenti, pagine, eventi, foto e oggetti correlati.\n\nFQL oggi ha soprattutto valore storico, perche Facebook lo ha sostituito con pattern piu nuovi della Graph API. Rimane utile riconoscerlo in integrazioni vecchie, esempi archiviati, migrazioni e documentazione di applicazioni social legacy."
+        },
+        fr: {
+          name: "FQL",
+          description: "Ancien langage de requete proche de SQL utilise par les API Facebook.",
+          longDescription: "Facebook Query Language etait un langage proche de SQL pour lire les donnees du graphe social Facebook via les anciennes API de la plateforme. Les requetes selectionnaient des champs dans des tables virtuelles representant utilisateurs, pages, evenements, photos et objets lies.\n\nFQL a surtout un interet historique, car Facebook l a remplace par des modeles plus recents de Graph API. Il reste utile a reconnaitre dans anciennes integrations, exemples archives, migrations et docs d applications sociales leguees."
+        },
+        de: {
+          name: "FQL",
+          description: "Alte SQL-ahnliche Abfragesprache fruherer Facebook-Platform-APIs.",
+          longDescription: "Facebook Query Language war eine SQL-ahnliche Sprache zum Lesen von Daten aus dem sozialen Graphen von Facebook uber altere Platform-APIs. Abfragen wahlten Felder aus virtuellen Tabellen fur Nutzer, Seiten, Events, Fotos und verwandte Objekte.\n\nFQL ist heute vor allem historisch relevant, weil Facebook es durch neuere Graph-API-Muster ersetzt hat. Es bleibt nutzlich in alten Integrationen, archivierten Beispielen, Migrationen und Dokumentation fur Legacy-Social-Apps."
+        },
+        pt: {
+          name: "FQL",
+          description: "Linguagem de consulta legada parecida com SQL usada por APIs do Facebook.",
+          longDescription: "Facebook Query Language foi uma linguagem parecida com SQL para ler dados do grafo social do Facebook por APIs antigas da plataforma. Consultas selecionavam campos de tabelas virtuais que representavam usuarios, paginas, eventos, fotos e objetos relacionados.\n\nFQL hoje tem valor principalmente historico, pois o Facebook o substituiu por padroes mais novos da Graph API. Ainda e util reconhece-lo em integracoes antigas, exemplos arquivados, migracoes e documentacao de apps sociais legados."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/freemarker.ts
 var freemarker_exports = {};
 __export(freemarker_exports, {
@@ -4173,6 +4636,64 @@ var init_fstar = __esm({
   }
 });
 
+// src/languages/gcode.ts
+var gcode_exports = {};
+__export(gcode_exports, {
+  gcode: () => gcode
+});
+var gcode;
+var init_gcode = __esm({
+  "src/languages/gcode.ts"() {
+    gcode = {
+      slug: "gcode",
+      publishedDate: "1958-01-01",
+      extensions: [".gcode", ".gco", ".nc", ".cnc", ".tap"],
+      author: "MIT Servomechanisms Laboratory",
+      website: "https://www.nist.gov/publications/nist-rs274ngc-interpreter-version-3",
+      paradigms: ["machine control", "imperative"],
+      tooling: {
+        runtimes: ["CNC controllers", "3D printer firmware"],
+        ecosystems: ["CNC machining", "Additive manufacturing"]
+      },
+      version: "RS-274",
+      logo: "https://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, {
@@ -4232,6 +4753,64 @@ var init_gdscript = __esm({
   }
 });
 
+// src/languages/gettext.ts
+var gettext_exports = {};
+__export(gettext_exports, {
+  gettext: () => gettext
+});
+var gettext;
+var init_gettext = __esm({
+  "src/languages/gettext.ts"() {
+    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, {
@@ -4644,6 +5223,64 @@ var init_graphql = __esm({
   }
 });
 
+// src/languages/gremlin.ts
+var gremlin_exports = {};
+__export(gremlin_exports, {
+  gremlin: () => gremlin
+});
+var gremlin;
+var init_gremlin = __esm({
+  "src/languages/gremlin.ts"() {
+    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, {
@@ -5872,6 +6509,64 @@ var init_jinja = __esm({
   }
 });
 
+// src/languages/jmespath.ts
+var jmespath_exports = {};
+__export(jmespath_exports, {
+  jmespath: () => jmespath
+});
+var jmespath;
+var init_jmespath = __esm({
+  "src/languages/jmespath.ts"() {
+    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://dummyimage.com/32x32/2F80ED/ffffff.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, {
@@ -5985,6 +6680,64 @@ var init_json5 = __esm({
   }
 });
 
+// src/languages/jsonata.ts
+var jsonata_exports = {};
+__export(jsonata_exports, {
+  jsonata: () => jsonata
+});
+var jsonata;
+var init_jsonata = __esm({
+  "src/languages/jsonata.ts"() {
+    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, {
@@ -6514,6 +7267,64 @@ var init_kotlin = __esm({
   }
 });
 
+// src/languages/kql.ts
+var kql_exports = {};
+__export(kql_exports, {
+  kql: () => kql
+});
+var kql;
+var init_kql = __esm({
+  "src/languages/kql.ts"() {
+    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, {
@@ -6691,6 +7502,64 @@ var init_ligo = __esm({
   }
 });
 
+// src/languages/linkerscript.ts
+var linkerscript_exports = {};
+__export(linkerscript_exports, {
+  linkerscript: () => linkerscript
+});
+var linkerscript;
+var init_linkerscript = __esm({
+  "src/languages/linkerscript.ts"() {
+    linkerscript = {
+      slug: "linkerscript",
+      publishedDate: "1988-01-01",
+      extensions: [".ld", ".lds", ".x"],
+      author: "GNU Project",
+      website: "https://sourceware.org/binutils/docs/ld/Scripts.html",
+      paradigms: ["configuration", "systems"],
+      tooling: {
+        runtimes: ["GNU ld", "LLD"],
+        ecosystems: ["Embedded systems", "Operating systems"]
+      },
+      version: "stable",
+      logo: "https://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, {
@@ -8034,6 +8903,64 @@ var init_mustache = __esm({
   }
 });
 
+// src/languages/n1ql.ts
+var n1ql_exports = {};
+__export(n1ql_exports, {
+  n1ql: () => n1ql
+});
+var n1ql;
+var init_n1ql = __esm({
+  "src/languages/n1ql.ts"() {
+    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, {
@@ -9149,6 +10076,64 @@ var init_plantuml = __esm({
   }
 });
 
+// src/languages/plpgsql.ts
+var plpgsql_exports = {};
+__export(plpgsql_exports, {
+  plpgsql: () => plpgsql
+});
+var plpgsql;
+var init_plpgsql = __esm({
+  "src/languages/plpgsql.ts"() {
+    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, {
@@ -9737,6 +10722,64 @@ var init_python = __esm({
   }
 });
 
+// src/languages/qmake.ts
+var qmake_exports = {};
+__export(qmake_exports, {
+  qmake: () => qmake
+});
+var qmake;
+var init_qmake = __esm({
+  "src/languages/qmake.ts"() {
+    qmake = {
+      slug: "qmake",
+      publishedDate: "2002-01-01",
+      extensions: [".pri", ".prf"],
+      author: "Trolltech",
+      website: "https://doc.qt.io/qt-6/qmake-manual.html",
+      paradigms: ["build configuration"],
+      tooling: {
+        runtimes: ["qmake"],
+        ecosystems: ["Qt", "C++"]
+      },
+      version: "stable",
+      logo: "https://dummyimage.com/32x32/41CD52/ffffff.png&text=Qt",
+      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, {
@@ -11204,6 +12247,64 @@ var init_solidity = __esm({
   }
 });
 
+// src/languages/soql.ts
+var soql_exports = {};
+__export(soql_exports, {
+  soql: () => soql
+});
+var soql;
+var init_soql = __esm({
+  "src/languages/soql.ts"() {
+    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, {
@@ -11320,6 +12421,64 @@ var init_sparql = __esm({
   }
 });
 
+// src/languages/spl.ts
+var spl_exports = {};
+__export(spl_exports, {
+  spl: () => spl
+});
+var spl;
+var init_spl = __esm({
+  "src/languages/spl.ts"() {
+    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, {
@@ -13719,6 +14878,7 @@ init_actionscript();
 init_ada();
 init_agda();
 init_algol();
+init_ampl();
 init_ante();
 init_antlr();
 init_apex();
@@ -13738,12 +14898,15 @@ 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_chapel();
 init_circom();
@@ -13754,6 +14917,7 @@ init_coffeescript();
 init_coldfusion();
 init_coq();
 init_cpp();
+init_cql();
 init_crystal();
 init_csharp();
 init_css();
@@ -13768,7 +14932,9 @@ init_dart();
 init_dhall();
 init_dita();
 init_dockerfile();
+init_dot();
 init_earthly();
+init_editorconfig();
 init_eiffel();
 init_ejs();
 init_elixir();
@@ -13782,10 +14948,13 @@ init_fish();
 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();
@@ -13793,6 +14962,7 @@ init_go();
 init_gradle();
 init_grain();
 init_graphql();
+init_gremlin();
 init_groovy();
 init_hack();
 init_haml();
@@ -13814,8 +14984,10 @@ init_janet();
 init_java();
 init_javascript();
 init_jinja();
+init_jmespath();
 init_json();
 init_json5();
+init_jsonata();
 init_jsonc();
 init_jsonnet();
 init_julia();
@@ -13825,9 +14997,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();
@@ -13851,6 +15025,7 @@ init_mojo();
 init_moonbit();
 init_move();
 init_mustache();
+init_n1ql();
 init_nginx();
 init_nickel();
 init_nim();
@@ -13870,6 +15045,7 @@ init_pine_script();
 init_pkl();
 init_pl_i();
 init_plantuml();
+init_plpgsql();
 init_plsql();
 init_pony();
 init_powershell();
@@ -13880,6 +15056,7 @@ init_pug();
 init_puppet();
 init_purescript();
 init_python();
+init_qmake();
 init_qml();
 init_qsharp();
 init_r();
@@ -13905,8 +15082,10 @@ init_smalltalk();
 init_smarty();
 init_snobol();
 init_solidity();
+init_soql();
 init_spark();
 init_sparql();
+init_spl();
 init_sql();
 init_standard_ml();
 init_starlark();
@@ -13954,6 +15133,7 @@ var languages = [
   ada,
   agda,
   algol,
+  ampl,
   ante,
   antlr,
   apex,
@@ -13974,11 +15154,14 @@ var languages = [
   bazel,
   bcpl,
   bicep,
+  bibtex,
   blade,
   bosque,
   bqn,
+  brainfuck,
   c,
   cairo,
+  capnproto,
   carbon,
   chapel,
   circom,
@@ -13990,6 +15173,7 @@ var languages = [
   coq,
   cpp,
   crystal,
+  cql,
   csharp,
   css,
   cuda,
@@ -14003,7 +15187,9 @@ var languages = [
   dhall,
   dita,
   dockerfile,
+  dot,
   earthly,
+  editorconfig,
   eiffel,
   ejs,
   elixir,
@@ -14018,9 +15204,12 @@ var languages = [
   forth,
   fortran,
   freemarker,
+  fql,
   fsharp,
   fstar,
   gdscript,
+  gcode,
+  gettext,
   git,
   gleam,
   glsl,
@@ -14028,6 +15217,7 @@ var languages = [
   gradle,
   grain,
   graphql,
+  gremlin,
   groovy,
   hack,
   haml,
@@ -14049,8 +15239,10 @@ var languages = [
   java,
   javascript,
   jinja,
+  jmespath,
   json,
   json5,
+  jsonata,
   jsonc,
   jsonnet,
   julia,
@@ -14060,10 +15252,12 @@ var languages = [
   kdl,
   koka,
   kotlin,
+  kql,
   lean,
   less,
   ligo,
   liquid,
+  linkerscript,
   lisp,
   llvmIr,
   lobster,
@@ -14086,6 +15280,7 @@ var languages = [
   moonbit,
   move,
   mustache,
+  n1ql,
   nginx,
   nickel,
   nim,
@@ -14105,6 +15300,7 @@ var languages = [
   plI,
   pkl,
   plantuml,
+  plpgsql,
   plsql,
   pony,
   powershell,
@@ -14116,6 +15312,7 @@ var languages = [
   purescript,
   python,
   qml,
+  qmake,
   qsharp,
   r,
   racket,
@@ -14140,8 +15337,10 @@ var languages = [
   smarty,
   snobol,
   solidity,
+  soql,
   sparql,
   spark,
+  spl,
   sql,
   standardMl,
   starlark,
@@ -14192,6 +15391,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"] },
@@ -14215,11 +15415,14 @@ 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: "chapel", extensions: [".chpl"] },
   { slug: "circom", extensions: [".circom"] },
@@ -14231,6 +15434,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"] },
@@ -14244,7 +15448,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"] },
@@ -14265,9 +15471,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"] },
   {
@@ -14278,6 +15487,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"] },
@@ -14299,8 +15509,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"] },
@@ -14310,10 +15522,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"] },
@@ -14336,6 +15550,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"] },
@@ -14355,6 +15570,7 @@ 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: "pony", extensions: [".pony"] },
   { slug: "powershell", extensions: [".ps1", ".psm1", ".psd1", ".ps1xml"] },
@@ -14366,6 +15582,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"] },
@@ -14393,8 +15610,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"] },
@@ -14446,6 +15665,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),
@@ -14466,11 +15686,14 @@ 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),
   chapel: () => Promise.resolve().then(() => (init_chapel(), chapel_exports)).then((module) => module.chapel),
   circom: () => Promise.resolve().then(() => (init_circom(), circom_exports)).then((module) => module.circom),
@@ -14482,6 +15705,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),
@@ -14495,7 +15719,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),
@@ -14510,9 +15736,12 @@ var languageLoaders = {
   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),
@@ -14520,6 +15749,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),
@@ -14541,8 +15771,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),
@@ -14552,10 +15784,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),
@@ -14578,6 +15812,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),
@@ -14597,6 +15832,7 @@ 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),
   pony: () => Promise.resolve().then(() => (init_pony(), pony_exports)).then((module) => module.pony),
   powershell: () => Promise.resolve().then(() => (init_powershell(), powershell_exports)).then((module) => module.powershell),
@@ -14608,6 +15844,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),
@@ -14632,8 +15869,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),