code-languages 1.33.1 → 1.34.0

package/dist/api.js

@@ -593,6 +593,64 @@ var init_applescript = __esm({
   }
 });
 
+// src/languages/aql.ts
+var aql_exports = {};
+__export(aql_exports, {
+  aql: () => aql
+});
+var aql;
+var init_aql = __esm({
+  "src/languages/aql.ts"() {
+    aql = {
+      slug: "aql",
+      publishedDate: "2012-05-01",
+      extensions: [".aql"],
+      author: "ArangoDB GmbH",
+      website: "https://docs.arangodb.com/stable/aql/",
+      paradigms: ["query", "declarative"],
+      tooling: {
+        runtimes: ["ArangoDB"],
+        ecosystems: ["Graph databases", "Document databases"]
+      },
+      version: "ArangoDB AQL",
+      logo: "https://dummyimage.com/32x32/16A34A/ffffff.png&text=AQ",
+      color: "#16A34A",
+      i18n: {
+        en: {
+          name: "AQL",
+          description: "ArangoDB Query Language, a declarative query language for multi-model graph and document data.",
+          longDescription: "AQL is the ArangoDB Query Language used to query documents, graphs, key-value data, and search views in ArangoDB. It has SQL-like declarative structure while supporting graph traversal, document operations, aggregation, and expression-oriented data shaping.\n\nAQL is used in applications that need one query language across multiple data models. It is closely tied to ArangoDB server versions and the database features available in each release."
+        },
+        es: {
+          name: "AQL",
+          description: "Lenguaje declarativo de consultas de ArangoDB para datos de grafos, documentos y multiples modelos.",
+          longDescription: "AQL es el lenguaje de consultas de ArangoDB para consultar documentos, grafos, datos clave-valor y vistas de busqueda. Tiene una estructura declarativa parecida a SQL, con soporte para recorridos de grafos, operaciones sobre documentos, agregaciones y transformacion de datos mediante expresiones.\n\nAQL se usa en aplicaciones que necesitan un solo lenguaje de consulta para varios modelos de datos. Esta estrechamente ligado a las versiones del servidor ArangoDB y a las capacidades disponibles en cada lanzamiento."
+        },
+        it: {
+          name: "AQL",
+          description: "Linguaggio dichiarativo di query di ArangoDB per dati a grafo, documenti e modelli multipli.",
+          longDescription: "AQL e il linguaggio di query di ArangoDB usato per interrogare documenti, grafi, dati chiave-valore e viste di ricerca. Ha una struttura dichiarativa simile a SQL, con supporto per attraversamenti di grafi, operazioni sui documenti, aggregazioni e trasformazione dei dati tramite espressioni.\n\nAQL viene usato in applicazioni che richiedono un unico linguaggio di query per piu modelli di dati. E strettamente legato alle versioni del server ArangoDB e alle funzionalita disponibili in ogni rilascio."
+        },
+        fr: {
+          name: "AQL",
+          description: "Langage de requete declaratif d ArangoDB pour graphes, documents et donnees multi-modeles.",
+          longDescription: "AQL est le langage de requete d ArangoDB utilise pour interroger des documents, des graphes, des donnees cle-valeur et des vues de recherche. Il possede une structure declarative proche de SQL et prend en charge les parcours de graphes, les operations sur documents, les agregations et la mise en forme des donnees par expressions.\n\nAQL est utilise dans les applications qui ont besoin d un seul langage de requete pour plusieurs modeles de donnees. Il est etroitement lie aux versions du serveur ArangoDB et aux fonctionnalites disponibles dans chaque version."
+        },
+        de: {
+          name: "AQL",
+          description: "Deklarative Abfragesprache von ArangoDB fur Graph-, Dokument- und Multi-Model-Daten.",
+          longDescription: "AQL ist die ArangoDB Query Language zum Abfragen von Dokumenten, Graphen, Key-Value-Daten und Suchansichten in ArangoDB. Sie hat eine SQL-ahnliche deklarative Struktur und unterstutzt Graph-Traversierungen, Dokumentoperationen, Aggregationen und ausdrucksbasierte Datenformung.\n\nAQL wird in Anwendungen eingesetzt, die eine Abfragesprache fur mehrere Datenmodelle benotigen. Die Sprache ist eng an ArangoDB-Serverversionen und die darin verfugbaren Funktionen gebunden."
+        },
+        pt: {
+          name: "AQL",
+          description: "Linguagem declarativa de consulta do ArangoDB para grafos, documentos e dados multimodelo.",
+          longDescription: "AQL e a linguagem de consulta do ArangoDB usada para consultar documentos, grafos, dados chave-valor e visoes de busca. Ela tem uma estrutura declarativa semelhante a SQL, com suporte a percursos de grafos, operacoes em documentos, agregacoes e modelagem de dados baseada em expressoes.\n\nAQL e usada em aplicacoes que precisam de uma unica linguagem de consulta para varios modelos de dados. Ela esta ligada as versoes do servidor ArangoDB e aos recursos disponiveis em cada lancamento."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/arduino.ts
 var arduino_exports = {};
 __export(arduino_exports, {
@@ -849,7 +907,7 @@ var init_astro = __esm({
         packageManagers: ["npm", "pnpm", "Yarn", "Bun"],
         ecosystems: ["Web", "Static Sites", "Content"]
       },
-      version: "6.4.5",
+      version: "6.4.6",
       logo: "https://astro.build/assets/press/astro-icon-light.svg",
       color: "#FF5D01",
       i18n: {
@@ -1376,7 +1434,7 @@ var init_bicep = __esm({
         packageManagers: ["Azure Verified Modules", "Bicep Registry"],
         ecosystems: ["Azure", "Cloud", "DevOps", "Infrastructure as Code"]
       },
-      version: "0.43.8",
+      version: "0.44.1",
       logo: "https://cdn.jsdelivr.net/gh/homarr-labs/dashboard-icons/svg/azure-bicep.svg",
       color: "#0078D4",
       i18n: {
@@ -3587,6 +3645,64 @@ var init_factor = __esm({
   }
 });
 
+// src/languages/fe.ts
+var fe_exports = {};
+__export(fe_exports, {
+  fe: () => fe
+});
+var fe;
+var init_fe = __esm({
+  "src/languages/fe.ts"() {
+    fe = {
+      slug: "fe",
+      publishedDate: "2020-10-08",
+      extensions: [".fe"],
+      author: "Ethereum Foundation contributors",
+      website: "https://fe-lang.org",
+      paradigms: ["smart contract", "imperative", "object-oriented"],
+      tooling: {
+        runtimes: ["Ethereum Virtual Machine"],
+        ecosystems: ["Ethereum", "EVM"]
+      },
+      version: "experimental",
+      logo: "https://dummyimage.com/32x32/4F46E5/ffffff.png&text=Fe",
+      color: "#4F46E5",
+      i18n: {
+        en: {
+          name: "Fe",
+          description: "A statically typed smart contract language for the Ethereum Virtual Machine.",
+          longDescription: "Fe is a smart contract language for Ethereum and other EVM-compatible chains. It aims to provide a Python-inspired syntax, static typing, explicitness, and safer defaults for contract development.\n\nThe language compiles to EVM bytecode and is designed for tooling-driven workflows around contracts, tests, and audits. Its ecosystem is experimental compared with Solidity, but useful for exploring alternative smart contract design."
+        },
+        es: {
+          name: "Fe",
+          description: "Lenguaje de contratos inteligentes con tipado estatico para la Maquina Virtual de Ethereum.",
+          longDescription: "Fe es un lenguaje de contratos inteligentes para Ethereum y otras cadenas compatibles con EVM. Busca ofrecer una sintaxis inspirada en Python, tipado estatico, explicitud y valores predeterminados mas seguros para desarrollar contratos.\n\nEl lenguaje compila a bytecode EVM y esta pensado para flujos de trabajo guiados por herramientas alrededor de contratos, pruebas y auditorias. Su ecosistema es experimental frente a Solidity, pero sirve para explorar disenos alternativos de contratos inteligentes."
+        },
+        it: {
+          name: "Fe",
+          description: "Linguaggio per smart contract con tipizzazione statica per Ethereum Virtual Machine.",
+          longDescription: "Fe e un linguaggio per smart contract destinato a Ethereum e ad altre chain compatibili con EVM. Punta a offrire una sintassi ispirata a Python, tipizzazione statica, esplicitezza e impostazioni predefinite piu sicure per lo sviluppo di contratti.\n\nIl linguaggio compila in bytecode EVM ed e pensato per flussi di lavoro basati su strumenti per contratti, test e audit. Il suo ecosistema e sperimentale rispetto a Solidity, ma utile per esplorare design alternativi di smart contract."
+        },
+        fr: {
+          name: "Fe",
+          description: "Langage de contrats intelligents a typage statique pour la machine virtuelle Ethereum.",
+          longDescription: "Fe est un langage de contrats intelligents pour Ethereum et les autres chaines compatibles EVM. Il vise une syntaxe inspiree de Python, un typage statique, une grande explicitation et des valeurs par defaut plus sures pour le developpement de contrats.\n\nLe langage compile vers le bytecode EVM et s integre a des flux de travail outilles pour les contrats, les tests et les audits. Son ecosysteme reste experimental face a Solidity, mais il est utile pour explorer d autres conceptions de contrats intelligents."
+        },
+        de: {
+          name: "Fe",
+          description: "Statisch typisierte Smart-Contract-Sprache fur die Ethereum Virtual Machine.",
+          longDescription: "Fe ist eine Smart-Contract-Sprache fur Ethereum und andere EVM-kompatible Chains. Sie zielt auf eine von Python inspirierte Syntax, statische Typisierung, Explizitheit und sicherere Voreinstellungen fur die Vertragsentwicklung.\n\nDie Sprache kompiliert zu EVM-Bytecode und ist fur toolgestutzte Workflows rund um Vertrage, Tests und Audits gedacht. Ihr Okosystem ist im Vergleich zu Solidity experimentell, eignet sich aber zum Erkunden alternativer Smart-Contract-Designs."
+        },
+        pt: {
+          name: "Fe",
+          description: "Linguagem de contratos inteligentes com tipagem estatica para a Maquina Virtual Ethereum.",
+          longDescription: "Fe e uma linguagem de contratos inteligentes para Ethereum e outras cadeias compativeis com EVM. Ela busca oferecer sintaxe inspirada em Python, tipagem estatica, explicitude e padroes mais seguros para o desenvolvimento de contratos.\n\nA linguagem compila para bytecode EVM e foi criada para fluxos de trabalho guiados por ferramentas em contratos, testes e auditorias. Seu ecossistema e experimental em comparacao com Solidity, mas util para explorar designs alternativos de contratos inteligentes."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/fennel.ts
 var fennel_exports = {};
 __export(fennel_exports, {
@@ -5345,6 +5461,65 @@ var init_ini = __esm({
   }
 });
 
+// src/languages/ink.ts
+var ink_exports = {};
+__export(ink_exports, {
+  ink: () => ink
+});
+var ink;
+var init_ink = __esm({
+  "src/languages/ink.ts"() {
+    ink = {
+      slug: "ink",
+      publishedDate: "2018-01-01",
+      extensions: [".ink"],
+      author: "Parity Technologies",
+      website: "https://use.ink",
+      paradigms: ["smart contract", "embedded DSL", "systems"],
+      tooling: {
+        runtimes: ["WebAssembly", "Substrate contracts pallet"],
+        packageManagers: ["Cargo"],
+        ecosystems: ["Polkadot", "Substrate", "Rust"]
+      },
+      version: "Ink! 6",
+      logo: "https://dummyimage.com/32x32/EC4899/ffffff.png&text=In",
+      color: "#EC4899",
+      i18n: {
+        en: {
+          name: "Ink!",
+          description: "A Rust-based embedded domain-specific language for writing WebAssembly smart contracts.",
+          longDescription: "Ink! is a smart contract language and framework built on Rust for Substrate-compatible blockchains. Contracts are written as Rust code using Ink! attributes and compile to WebAssembly for execution by compatible contract pallets.\n\nIt gives smart contract authors access to Rust tooling, types, testing, and package workflows while targeting blockchain runtimes. Ink! is common in Polkadot, Substrate, and related ecosystems."
+        },
+        es: {
+          name: "Ink!",
+          description: "DSL embebido basado en Rust para escribir contratos inteligentes WebAssembly.",
+          longDescription: "Ink! es un lenguaje y framework de contratos inteligentes construido sobre Rust para blockchains compatibles con Substrate. Los contratos se escriben como codigo Rust usando atributos de Ink! y compilan a WebAssembly para ejecutarse en pallets de contratos compatibles.\n\nDa a los autores de contratos acceso a herramientas, tipos, pruebas y flujos de paquetes de Rust mientras apunta a runtimes blockchain. Ink! es comun en Polkadot, Substrate y ecosistemas relacionados."
+        },
+        it: {
+          name: "Ink!",
+          description: "DSL incorporato basato su Rust per smart contract WebAssembly.",
+          longDescription: "Ink! e un linguaggio e framework per smart contract costruito su Rust per blockchain compatibili con Substrate. I contratti sono scritti come codice Rust usando attributi Ink! e compilano in WebAssembly per l esecuzione da parte di pallet di contratti compatibili.\n\nOffre agli autori di smart contract accesso a strumenti, tipi, test e workflow di pacchetti Rust mentre punta a runtime blockchain. Ink! e comune in Polkadot, Substrate ed ecosistemi correlati."
+        },
+        fr: {
+          name: "Ink!",
+          description: "DSL integre base sur Rust pour ecrire des contrats intelligents WebAssembly.",
+          longDescription: "Ink! est un langage et framework de contrats intelligents construit sur Rust pour les blockchains compatibles Substrate. Les contrats sont ecrits comme du code Rust avec des attributs Ink! et compiles vers WebAssembly pour etre executes par des pallets de contrats compatibles.\n\nIl donne aux auteurs de contrats l acces aux outils, types, tests et flux de paquets Rust tout en ciblant des runtimes blockchain. Ink! est courant dans Polkadot, Substrate et les ecosystemes associes."
+        },
+        de: {
+          name: "Ink!",
+          description: "Rust-basierte eingebettete DSL zum Schreiben von WebAssembly-Smart-Contracts.",
+          longDescription: "Ink! ist eine Smart-Contract-Sprache und ein Framework auf Basis von Rust fur Substrate-kompatible Blockchains. Vertrage werden als Rust-Code mit Ink!-Attributen geschrieben und zu WebAssembly kompiliert, damit kompatible Contract-Pallets sie ausfuhren konnen.\n\nAutorinnen und Autoren erhalten Zugriff auf Rust-Werkzeuge, Typen, Tests und Paket-Workflows, wahrend Blockchain-Runtimes adressiert werden. Ink! ist in Polkadot, Substrate und verwandten Okosystemen verbreitet."
+        },
+        pt: {
+          name: "Ink!",
+          description: "DSL embutida baseada em Rust para escrever contratos inteligentes WebAssembly.",
+          longDescription: "Ink! e uma linguagem e framework de contratos inteligentes criada sobre Rust para blockchains compativeis com Substrate. Os contratos sao escritos como codigo Rust usando atributos Ink! e compilam para WebAssembly para execucao por pallets de contratos compativeis.\n\nEla da a autores de contratos acesso a ferramentas, tipos, testes e fluxos de pacotes de Rust enquanto mira runtimes blockchain. Ink! e comum em Polkadot, Substrate e ecossistemas relacionados."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/io.ts
 var io_exports = {};
 __export(io_exports, {
@@ -6457,6 +6632,65 @@ var init_less = __esm({
   }
 });
 
+// src/languages/ligo.ts
+var ligo_exports = {};
+__export(ligo_exports, {
+  ligo: () => ligo
+});
+var ligo;
+var init_ligo = __esm({
+  "src/languages/ligo.ts"() {
+    ligo = {
+      slug: "ligo",
+      publishedDate: "2019-01-01",
+      extensions: [".ligo", ".mligo", ".religo", ".jsligo"],
+      author: "TriliTech and Ligo contributors",
+      website: "https://ligolang.org",
+      paradigms: ["smart contract", "functional", "imperative"],
+      tooling: {
+        runtimes: ["Tezos Michelson"],
+        packageManagers: ["ligo registry"],
+        ecosystems: ["Tezos"]
+      },
+      version: "1.x",
+      logo: "https://dummyimage.com/32x32/0D9488/ffffff.png&text=Li",
+      color: "#0D9488",
+      i18n: {
+        en: {
+          name: "Ligo",
+          description: "A smart contract language family for Tezos with multiple syntaxes and static typing.",
+          longDescription: "Ligo is a smart contract language for Tezos that offers several syntaxes, including CameLIGO, JsLIGO, and older Pascal-style variants. It compiles to Michelson, the low-level language executed by the Tezos protocol.\n\nThe language emphasizes static typing, predictable contract behavior, and tooling for compilation, testing, and deployment. It is used by Tezos developers who want higher-level contract syntax than raw Michelson."
+        },
+        es: {
+          name: "Ligo",
+          description: "Familia de lenguajes de contratos inteligentes para Tezos con varias sintaxis y tipado estatico.",
+          longDescription: "Ligo es un lenguaje de contratos inteligentes para Tezos que ofrece varias sintaxis, incluyendo CameLIGO, JsLIGO y variantes antiguas de estilo Pascal. Compila a Michelson, el lenguaje de bajo nivel ejecutado por el protocolo Tezos.\n\nEl lenguaje enfatiza tipado estatico, comportamiento predecible de contratos y herramientas para compilar, probar y desplegar. Lo usan desarrolladores de Tezos que quieren una sintaxis de contratos de mas alto nivel que Michelson puro."
+        },
+        it: {
+          name: "Ligo",
+          description: "Famiglia di linguaggi per smart contract Tezos con piu sintassi e tipizzazione statica.",
+          longDescription: "Ligo e un linguaggio per smart contract su Tezos che offre diverse sintassi, tra cui CameLIGO, JsLIGO e varianti piu vecchie in stile Pascal. Compila in Michelson, il linguaggio di basso livello eseguito dal protocollo Tezos.\n\nIl linguaggio enfatizza tipizzazione statica, comportamento prevedibile dei contratti e strumenti per compilazione, test e distribuzione. Viene usato da sviluppatori Tezos che vogliono una sintassi di contratto piu ad alto livello rispetto a Michelson puro."
+        },
+        fr: {
+          name: "Ligo",
+          description: "Famille de langages de contrats intelligents pour Tezos avec plusieurs syntaxes et typage statique.",
+          longDescription: "Ligo est un langage de contrats intelligents pour Tezos qui propose plusieurs syntaxes, dont CameLIGO, JsLIGO et d anciennes variantes de style Pascal. Il compile vers Michelson, le langage bas niveau execute par le protocole Tezos.\n\nLe langage met l accent sur le typage statique, le comportement previsible des contrats et les outils de compilation, de test et de deploiement. Il est utilise par les developpeurs Tezos qui veulent une syntaxe plus haut niveau que Michelson brut."
+        },
+        de: {
+          name: "Ligo",
+          description: "Smart-Contract-Sprachfamilie fur Tezos mit mehreren Syntaxen und statischer Typisierung.",
+          longDescription: "Ligo ist eine Smart-Contract-Sprache fur Tezos mit mehreren Syntaxen, darunter CameLIGO, JsLIGO und altere Pascal-artige Varianten. Sie kompiliert zu Michelson, der Low-Level-Sprache, die vom Tezos-Protokoll ausgefuhrt wird.\n\nDie Sprache betont statische Typisierung, vorhersagbares Vertragsverhalten und Werkzeuge fur Kompilierung, Tests und Deployment. Sie wird von Tezos-Entwicklern genutzt, die eine hohere Vertragssyntax als reines Michelson wollen."
+        },
+        pt: {
+          name: "Ligo",
+          description: "Familia de linguagens de contratos inteligentes para Tezos com varias sintaxes e tipagem estatica.",
+          longDescription: "Ligo e uma linguagem de contratos inteligentes para Tezos que oferece varias sintaxes, incluindo CameLIGO, JsLIGO e variantes antigas no estilo Pascal. Ela compila para Michelson, a linguagem de baixo nivel executada pelo protocolo Tezos.\n\nA linguagem enfatiza tipagem estatica, comportamento previsivel de contratos e ferramentas para compilacao, testes e implantacao. E usada por desenvolvedores Tezos que querem sintaxe de contrato mais alto nivel que Michelson puro."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/liquid.ts
 var liquid_exports = {};
 __export(liquid_exports, {
@@ -7039,6 +7273,64 @@ var init_markdown = __esm({
   }
 });
 
+// src/languages/marlowe.ts
+var marlowe_exports = {};
+__export(marlowe_exports, {
+  marlowe: () => marlowe
+});
+var marlowe;
+var init_marlowe = __esm({
+  "src/languages/marlowe.ts"() {
+    marlowe = {
+      slug: "marlowe",
+      publishedDate: "2018-01-01",
+      extensions: [".marlowe"],
+      author: "IOG",
+      website: "https://marlowe.iohk.io",
+      paradigms: ["smart contract", "domain-specific", "functional"],
+      tooling: {
+        runtimes: ["Cardano"],
+        ecosystems: ["Cardano", "Financial contracts"]
+      },
+      version: "Marlowe Runtime",
+      logo: "https://dummyimage.com/32x32/6D28D9/ffffff.png&text=Ma",
+      color: "#6D28D9",
+      i18n: {
+        en: {
+          name: "Marlowe",
+          description: "A domain-specific language for financial smart contracts on Cardano.",
+          longDescription: "Marlowe is a domain-specific language for describing financial contracts, originally designed for Cardano. It models roles, choices, payments, deposits, timeouts, and contract continuations in a constrained language intended to be easier to analyze than general-purpose smart contract code.\n\nMarlowe is used for financial agreement prototypes, education, and contract workflows where explicit lifecycle modeling matters. Its tooling includes visual and textual authoring paths plus execution infrastructure in the Cardano ecosystem."
+        },
+        es: {
+          name: "Marlowe",
+          description: "Lenguaje especifico de dominio para contratos financieros inteligentes en Cardano.",
+          longDescription: "Marlowe es un lenguaje especifico de dominio para describir contratos financieros, disenado originalmente para Cardano. Modela roles, elecciones, pagos, depositos, vencimientos y continuaciones de contratos en un lenguaje restringido pensado para ser mas facil de analizar que codigo general de contratos inteligentes.\n\nMarlowe se usa para prototipos de acuerdos financieros, educacion y flujos de contratos donde importa modelar explicitamente el ciclo de vida. Sus herramientas incluyen autoria visual y textual, ademas de infraestructura de ejecucion en el ecosistema Cardano."
+        },
+        it: {
+          name: "Marlowe",
+          description: "DSL per smart contract finanziari su Cardano.",
+          longDescription: "Marlowe e un linguaggio specifico di dominio per descrivere contratti finanziari, progettato originariamente per Cardano. Modella ruoli, scelte, pagamenti, depositi, timeout e continuazioni dei contratti in un linguaggio limitato pensato per essere piu facile da analizzare rispetto al codice generale per smart contract.\n\nMarlowe viene usato per prototipi di accordi finanziari, formazione e workflow contrattuali in cui conta modellare esplicitamente il ciclo di vita. Gli strumenti includono authoring visuale e testuale, oltre a infrastruttura di esecuzione nell ecosistema Cardano."
+        },
+        fr: {
+          name: "Marlowe",
+          description: "DSL pour contrats financiers intelligents sur Cardano.",
+          longDescription: "Marlowe est un langage specifique au domaine pour decrire des contrats financiers, concu a l origine pour Cardano. Il modelise les roles, choix, paiements, depots, delais et continuations de contrats dans un langage contraint plus facile a analyser que du code general de contrats intelligents.\n\nMarlowe est utilise pour des prototypes d accords financiers, l education et des flux de contrats ou la modelisation explicite du cycle de vie est importante. Ses outils incluent des modes d auteur visuels et textuels ainsi qu une infrastructure d execution dans l ecosysteme Cardano."
+        },
+        de: {
+          name: "Marlowe",
+          description: "Domanenspezifische Sprache fur finanzielle Smart Contracts auf Cardano.",
+          longDescription: "Marlowe ist eine domanenspezifische Sprache zum Beschreiben finanzieller Vertrage und wurde ursprunglich fur Cardano entworfen. Sie modelliert Rollen, Entscheidungen, Zahlungen, Einzahlungen, Timeouts und Vertragsfortsetzungen in einer eingeschrankten Sprache, die leichter analysierbar sein soll als allgemeiner Smart-Contract-Code.\n\nMarlowe wird fur Prototypen finanzieller Vereinbarungen, Lehre und Vertrags-Workflows genutzt, bei denen explizite Lebenszyklusmodellierung wichtig ist. Die Werkzeuge umfassen visuelle und textuelle Autorenschaft sowie Ausfuhrungsinfrastruktur im Cardano-Okosystem."
+        },
+        pt: {
+          name: "Marlowe",
+          description: "Linguagem especifica de dominio para contratos financeiros inteligentes no Cardano.",
+          longDescription: "Marlowe e uma linguagem especifica de dominio para descrever contratos financeiros, criada originalmente para Cardano. Ela modela papeis, escolhas, pagamentos, depositos, prazos e continuacoes de contrato em uma linguagem restrita, pensada para ser mais facil de analisar que codigo geral de contratos inteligentes.\n\nMarlowe e usada em prototipos de acordos financeiros, educacao e fluxos de contratos onde a modelagem explicita do ciclo de vida importa. Suas ferramentas incluem autoria visual e textual, alem de infraestrutura de execucao no ecossistema Cardano."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/mathematica.ts
 var mathematica_exports = {};
 __export(mathematica_exports, {
@@ -9170,7 +9462,7 @@ var init_protobuf = __esm({
         packageManagers: ["Buf", "npm", "Maven", "Go modules", "NuGet", "PyPI"],
         ecosystems: ["gRPC", "APIs", "Microservices", "Data Serialization"]
       },
-      version: "35.0",
+      version: "35.1",
       logo: "https://cdn.simpleicons.org/google/4285F4",
       color: "#4285F4",
       i18n: {
@@ -9406,7 +9698,7 @@ var init_python = __esm({
         packageManagers: ["pip", "Poetry", "uv", "conda"],
         ecosystems: ["Web", "Data Science", "Machine Learning", "Automation"]
       },
-      version: "3.14.5",
+      version: "3.14.6",
       logo: "https://commons.wikimedia.org/wiki/Special:FilePath/Python-logo-notext.svg",
       color: "#3776AB",
       i18n: {
@@ -10523,7 +10815,7 @@ var init_scss = __esm({
         packageManagers: ["npm", "pnpm", "Yarn", "Bun"],
         ecosystems: ["Web", "Design Systems"]
       },
-      version: "1.100.0",
+      version: "1.101.0",
       logo: "https://sass-lang.com/assets/img/logos/logo.svg",
       color: "#CC6699",
       i18n: {
@@ -10620,6 +10912,64 @@ var init_self = __esm({
   }
 });
 
+// src/languages/simula.ts
+var simula_exports = {};
+__export(simula_exports, {
+  simula: () => simula
+});
+var simula;
+var init_simula = __esm({
+  "src/languages/simula.ts"() {
+    simula = {
+      slug: "simula",
+      publishedDate: "1962-01-01",
+      extensions: [".sim", ".simula"],
+      author: "Ole-Johan Dahl and Kristen Nygaard",
+      website: "https://www.simula67.info",
+      paradigms: ["object-oriented", "imperative", "procedural"],
+      tooling: {
+        runtimes: ["Simula compilers"],
+        ecosystems: ["Simulation", "Language history"]
+      },
+      version: "Simula 67",
+      logo: "https://dummyimage.com/32x32/2563EB/ffffff.png&text=Si",
+      color: "#2563EB",
+      i18n: {
+        en: {
+          name: "Simula",
+          description: "A pioneering simulation and object-oriented programming language descended from ALGOL.",
+          longDescription: "Simula is a programming language family created for discrete-event simulation and later recognized as the first object-oriented language. Simula 67 introduced classes, objects, inheritance-like specialization, and coroutines in a form that shaped later object-oriented systems.\n\nIt is historically important in language design, education, simulation modeling, and the evolution of object-oriented programming. Modern use is mostly archival, academic, and through maintained compilers and historical implementations."
+        },
+        es: {
+          name: "Simula",
+          description: "Lenguaje pionero de simulacion y programacion orientada a objetos derivado de ALGOL.",
+          longDescription: "Simula es una familia de lenguajes creada para simulacion de eventos discretos y luego reconocida como el primer lenguaje orientado a objetos. Simula 67 introdujo clases, objetos, especializacion similar a herencia y corrutinas en una forma que influyo en sistemas orientados a objetos posteriores.\n\nTiene importancia historica en diseno de lenguajes, educacion, modelado de simulacion y evolucion de la programacion orientada a objetos. Su uso moderno es principalmente archivistico, academico y mediante compiladores mantenidos e implementaciones historicas."
+        },
+        it: {
+          name: "Simula",
+          description: "Linguaggio pionieristico di simulazione e programmazione orientata agli oggetti derivato da ALGOL.",
+          longDescription: "Simula e una famiglia di linguaggi creata per la simulazione a eventi discreti e poi riconosciuta come il primo linguaggio orientato agli oggetti. Simula 67 introdusse classi, oggetti, specializzazione simile all ereditarieta e coroutine in una forma che influenzo i sistemi orientati agli oggetti successivi.\n\nE storicamente importante per il design dei linguaggi, la didattica, la modellazione di simulazioni e l evoluzione della programmazione orientata agli oggetti. L uso moderno e soprattutto archivistico, accademico e tramite compilatori mantenuti o implementazioni storiche."
+        },
+        fr: {
+          name: "Simula",
+          description: "Langage pionnier de simulation et de programmation orientee objet issu d ALGOL.",
+          longDescription: "Simula est une famille de langages creee pour la simulation a evenements discrets, puis reconnue comme le premier langage oriente objet. Simula 67 a introduit classes, objets, specialisation proche de l heritage et coroutines sous une forme qui a marque les systemes objets ulterieurs.\n\nIl est historiquement important pour la conception des langages, l enseignement, la modelisation de simulations et l evolution de la programmation orientee objet. Son usage moderne est surtout archivistique, academique et lie a des compilateurs maintenus ou des implementations historiques."
+        },
+        de: {
+          name: "Simula",
+          description: "Pioniersprache fur Simulation und objektorientierte Programmierung aus der ALGOL-Familie.",
+          longDescription: "Simula ist eine Sprachfamilie, die fur diskrete Ereignissimulation entwickelt wurde und spater als erste objektorientierte Sprache anerkannt wurde. Simula 67 fuhrte Klassen, Objekte, vererbungsahnliche Spezialisierung und Koroutinen in einer Form ein, die spatere objektorientierte Systeme pragte.\n\nDie Sprache ist historisch wichtig fur Sprachdesign, Lehre, Simulationsmodellierung und die Entwicklung objektorientierter Programmierung. Moderne Nutzung ist vor allem archivalisch, akademisch und uber gepflegte Compiler oder historische Implementierungen."
+        },
+        pt: {
+          name: "Simula",
+          description: "Linguagem pioneira de simulacao e programacao orientada a objetos derivada de ALGOL.",
+          longDescription: "Simula e uma familia de linguagens criada para simulacao de eventos discretos e depois reconhecida como a primeira linguagem orientada a objetos. Simula 67 introduziu classes, objetos, especializacao parecida com heranca e corrotinas em uma forma que influenciou sistemas orientados a objetos posteriores.\n\nEla e historicamente importante no design de linguagens, educacao, modelagem de simulacao e evolucao da programacao orientada a objetos. O uso moderno e principalmente arquivistico, academico e por compiladores mantidos ou implementacoes historicas."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/smalltalk.ts
 var smalltalk_exports = {};
 __export(smalltalk_exports, {
@@ -10737,6 +11087,64 @@ var init_smarty = __esm({
   }
 });
 
+// src/languages/snobol.ts
+var snobol_exports = {};
+__export(snobol_exports, {
+  snobol: () => snobol
+});
+var snobol;
+var init_snobol = __esm({
+  "src/languages/snobol.ts"() {
+    snobol = {
+      slug: "snobol",
+      publishedDate: "1962-01-01",
+      extensions: [".sno", ".snobol"],
+      author: "David J. Farber, Ralph Griswold, and Ivan P. Polonsky",
+      website: "https://www.regressive.org/snobol4/",
+      paradigms: ["imperative", "procedural", "text-processing"],
+      tooling: {
+        runtimes: ["SNOBOL4 implementations", "SPITBOL"],
+        ecosystems: ["Text processing", "Language history"]
+      },
+      version: "SNOBOL4",
+      logo: "https://dummyimage.com/32x32/7C2D12/ffffff.png&text=SN",
+      color: "#7C2D12",
+      i18n: {
+        en: {
+          name: "SNOBOL",
+          description: "A text-processing language known for pattern matching, symbolic programming, and string manipulation.",
+          longDescription: "SNOBOL is a family of programming languages from Bell Labs focused on string processing, symbolic computation, and pattern matching. SNOBOL4 became the best-known version, with patterns as first-class values and expressive operators for text transformation.\n\nIt influenced later text-processing and scripting languages, especially through its treatment of patterns and dynamic data. Today it is mainly used for historical study, preservation, and specialized legacy programs."
+        },
+        es: {
+          name: "SNOBOL",
+          description: "Lenguaje de procesamiento de texto conocido por patrones, simbolos y manipulacion de cadenas.",
+          longDescription: "SNOBOL es una familia de lenguajes de Bell Labs centrada en procesamiento de cadenas, computacion simbolica y coincidencia de patrones. SNOBOL4 se convirtio en la version mas conocida, con patrones como valores de primera clase y operadores expresivos para transformar texto.\n\nInfluyo en lenguajes posteriores de procesamiento de texto y scripting, especialmente por su tratamiento de patrones y datos dinamicos. Hoy se usa principalmente para estudio historico, preservacion y programas legacy especializados."
+        },
+        it: {
+          name: "SNOBOL",
+          description: "Linguaggio per elaborazione del testo noto per pattern matching, simboli e stringhe.",
+          longDescription: "SNOBOL e una famiglia di linguaggi di Bell Labs focalizzata su elaborazione di stringhe, computazione simbolica e pattern matching. SNOBOL4 divenne la versione piu nota, con pattern come valori di prima classe e operatori espressivi per trasformare testo.\n\nInfluenzo linguaggi successivi di elaborazione del testo e scripting, soprattutto per il trattamento di pattern e dati dinamici. Oggi e usato principalmente per studio storico, conservazione e programmi legacy specializzati."
+        },
+        fr: {
+          name: "SNOBOL",
+          description: "Langage de traitement de texte connu pour les motifs, la programmation symbolique et les chaines.",
+          longDescription: "SNOBOL est une famille de langages de Bell Labs centree sur le traitement des chaines, le calcul symbolique et la reconnaissance de motifs. SNOBOL4 est devenu la version la plus connue, avec des motifs comme valeurs de premiere classe et des operateurs expressifs pour transformer le texte.\n\nIl a influence des langages ulterieurs de traitement de texte et de script, surtout par son traitement des motifs et des donnees dynamiques. Aujourd hui, il sert surtout a l etude historique, a la preservation et a des programmes legacy specialises."
+        },
+        de: {
+          name: "SNOBOL",
+          description: "Textverarbeitungssprache fur Musterabgleich, symbolische Programmierung und Zeichenketten.",
+          longDescription: "SNOBOL ist eine Sprachfamilie aus den Bell Labs mit Fokus auf Zeichenkettenverarbeitung, symbolische Berechnung und Musterabgleich. SNOBOL4 wurde zur bekanntesten Version, mit Mustern als First-Class-Werten und ausdrucksstarken Operatoren zur Texttransformation.\n\nDie Sprache beeinflusste spatere Textverarbeitungs- und Skriptsprachen, besonders durch den Umgang mit Mustern und dynamischen Daten. Heute wird sie vor allem fur historische Studien, Bewahrung und spezialisierte Legacy-Programme genutzt."
+        },
+        pt: {
+          name: "SNOBOL",
+          description: "Linguagem de processamento de texto conhecida por padroes, simbolos e manipulacao de strings.",
+          longDescription: "SNOBOL e uma familia de linguagens da Bell Labs focada em processamento de strings, computacao simbolica e correspondencia de padroes. SNOBOL4 tornou-se a versao mais conhecida, com padroes como valores de primeira classe e operadores expressivos para transformar texto.\n\nEla influenciou linguagens posteriores de processamento de texto e scripting, especialmente pelo tratamento de padroes e dados dinamicos. Hoje e usada principalmente para estudo historico, preservacao e programas legados especializados."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/solidity.ts
 var solidity_exports = {};
 __export(solidity_exports, {
@@ -10796,6 +11204,64 @@ var init_solidity = __esm({
   }
 });
 
+// src/languages/spark.ts
+var spark_exports = {};
+__export(spark_exports, {
+  spark: () => spark
+});
+var spark;
+var init_spark = __esm({
+  "src/languages/spark.ts"() {
+    spark = {
+      slug: "spark",
+      publishedDate: "2009-01-01",
+      extensions: [".spark", ".adb", ".ads"],
+      author: "Altran and AdaCore",
+      website: "https://www.adacore.com/about-spark",
+      paradigms: ["imperative", "object-oriented", "formal verification"],
+      tooling: {
+        runtimes: ["GNAT", "Ada runtimes"],
+        ecosystems: ["Ada", "Embedded", "Safety-critical software"]
+      },
+      version: "SPARK Community 2021",
+      logo: "https://dummyimage.com/32x32/DC2626/ffffff.png&text=SP",
+      color: "#DC2626",
+      i18n: {
+        en: {
+          name: "SPARK",
+          description: "A formally verifiable Ada-based language for high-integrity and safety-critical software.",
+          longDescription: "SPARK is a programming language and verification ecosystem based on Ada, designed for software where correctness, safety, and security matter. It restricts and extends Ada with contracts, proof-oriented annotations, and analyzable semantics.\n\nSPARK is used in avionics, defense, embedded systems, industrial control, and other high-integrity domains. Its tooling can prove absence of runtime errors and verify functional properties before code runs."
+        },
+        es: {
+          name: "SPARK",
+          description: "Lenguaje basado en Ada y verificable formalmente para software critico y de alta integridad.",
+          longDescription: "SPARK es un lenguaje de programacion y ecosistema de verificacion basado en Ada, disenado para software donde importan correccion, seguridad funcional y seguridad informatica. Restringe y extiende Ada con contratos, anotaciones orientadas a pruebas y semantica analizable.\n\nSPARK se usa en avionica, defensa, sistemas embebidos, control industrial y otros dominios de alta integridad. Sus herramientas pueden probar ausencia de errores en tiempo de ejecucion y verificar propiedades funcionales antes de ejecutar el codigo."
+        },
+        it: {
+          name: "SPARK",
+          description: "Linguaggio basato su Ada e verificabile formalmente per software critico e ad alta integrita.",
+          longDescription: "SPARK e un linguaggio di programmazione e un ecosistema di verifica basato su Ada, progettato per software in cui correttezza, safety e security sono fondamentali. Restringe ed estende Ada con contratti, annotazioni orientate alla prova e semantica analizzabile.\n\nSPARK e usato in avionica, difesa, sistemi embedded, controllo industriale e altri domini ad alta integrita. I suoi strumenti possono provare l assenza di errori a runtime e verificare proprieta funzionali prima dell esecuzione del codice."
+        },
+        fr: {
+          name: "SPARK",
+          description: "Langage base sur Ada, verifiable formellement, pour logiciels critiques et haute integrite.",
+          longDescription: "SPARK est un langage de programmation et un ecosysteme de verification base sur Ada, concu pour les logiciels ou correction, surete et securite sont essentielles. Il restreint et etend Ada avec des contrats, des annotations orientees preuve et une semantique analysable.\n\nSPARK est utilise dans l avionique, la defense, les systemes embarques, le controle industriel et d autres domaines a haute integrite. Ses outils peuvent prouver l absence d erreurs a l execution et verifier des proprietes fonctionnelles avant que le code ne tourne."
+        },
+        de: {
+          name: "SPARK",
+          description: "Formal verifizierbare Ada-basierte Sprache fur sicherheitskritische High-Integrity-Software.",
+          longDescription: "SPARK ist eine auf Ada basierende Programmiersprache und Verifikationsumgebung fur Software, bei der Korrektheit, Safety und Security entscheidend sind. Sie beschrankt und erweitert Ada mit Vertragen, beweisorientierten Annotationen und analysierbarer Semantik.\n\nSPARK wird in Avionik, Verteidigung, eingebetteten Systemen, industrieller Steuerung und anderen High-Integrity-Domanen genutzt. Die Werkzeuge konnen Laufzeitfehlerfreiheit beweisen und funktionale Eigenschaften vor der Ausfuhrung verifizieren."
+        },
+        pt: {
+          name: "SPARK",
+          description: "Linguagem baseada em Ada e verificavel formalmente para software critico e de alta integridade.",
+          longDescription: "SPARK e uma linguagem de programacao e ecossistema de verificacao baseado em Ada, criado para software onde correcao, seguranca funcional e seguranca importam. Ela restringe e estende Ada com contratos, anotacoes orientadas a provas e semantica analisavel.\n\nSPARK e usada em avionica, defesa, sistemas embarcados, controle industrial e outros dominios de alta integridade. Suas ferramentas podem provar ausencia de erros em tempo de execucao e verificar propriedades funcionais antes do codigo rodar."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/sparql.ts
 var sparql_exports = {};
 __export(sparql_exports, {
@@ -12082,6 +12548,64 @@ var init_vala = __esm({
   }
 });
 
+// src/languages/vale.ts
+var vale_exports = {};
+__export(vale_exports, {
+  vale: () => vale
+});
+var vale;
+var init_vale = __esm({
+  "src/languages/vale.ts"() {
+    vale = {
+      slug: "vale",
+      publishedDate: "2018-01-01",
+      extensions: [".vale"],
+      author: "Evan Ovadia",
+      website: "https://vale.dev",
+      paradigms: ["systems", "imperative", "object-oriented"],
+      tooling: {
+        runtimes: ["Vale compiler"],
+        ecosystems: ["Native applications", "Systems programming"]
+      },
+      version: "experimental",
+      logo: "https://dummyimage.com/32x32/059669/ffffff.png&text=Va",
+      color: "#059669",
+      i18n: {
+        en: {
+          name: "Vale",
+          description: "A systems programming language exploring memory safety through ownership and generational references.",
+          longDescription: "Vale is a systems programming language focused on fast native code, memory safety, and ergonomic ownership. Its design explores generational references, region-like ownership, and compile-time checks that avoid conventional garbage collection.\n\nThe language targets domains where C and C++ are common, including engines, tools, and performance-sensitive services. It remains experimental, with active design work around safety, concurrency, and interoperability."
+        },
+        es: {
+          name: "Vale",
+          description: "Lenguaje de sistemas que explora seguridad de memoria con ownership y referencias generacionales.",
+          longDescription: "Vale es un lenguaje de programacion de sistemas centrado en codigo nativo rapido, seguridad de memoria y ownership ergonomico. Su diseno explora referencias generacionales, ownership parecido a regiones y comprobaciones en compilacion que evitan la recoleccion de basura convencional.\n\nEl lenguaje apunta a dominios donde C y C++ son comunes, como motores, herramientas y servicios sensibles al rendimiento. Sigue siendo experimental, con trabajo activo en seguridad, concurrencia e interoperabilidad."
+        },
+        it: {
+          name: "Vale",
+          description: "Linguaggio di sistema che esplora sicurezza della memoria con ownership e riferimenti generazionali.",
+          longDescription: "Vale e un linguaggio di programmazione di sistema focalizzato su codice nativo veloce, sicurezza della memoria e ownership ergonomica. Il design esplora riferimenti generazionali, ownership simile a regioni e controlli a tempo di compilazione che evitano la garbage collection convenzionale.\n\nIl linguaggio mira a domini dove C e C++ sono comuni, inclusi motori, strumenti e servizi sensibili alle prestazioni. Rimane sperimentale, con lavoro attivo su sicurezza, concorrenza e interoperabilita."
+        },
+        fr: {
+          name: "Vale",
+          description: "Langage systeme explorant la surete memoire par ownership et references generationnelles.",
+          longDescription: "Vale est un langage de programmation systeme centre sur le code natif rapide, la surete memoire et un ownership ergonomique. Sa conception explore les references generationnelles, un ownership proche des regions et des verifications a la compilation qui evitent le ramasse-miettes classique.\n\nLe langage vise les domaines ou C et C++ sont frequents, comme les moteurs, les outils et les services sensibles aux performances. Il reste experimental, avec un travail actif sur la surete, la concurrence et l interoperabilite."
+        },
+        de: {
+          name: "Vale",
+          description: "Systemprogrammiersprache fur Speichersicherheit durch Ownership und generationale Referenzen.",
+          longDescription: "Vale ist eine Systemprogrammiersprache mit Fokus auf schnellen nativen Code, Speichersicherheit und ergonomisches Ownership. Das Design erforscht generationale Referenzen, regionenahnliches Ownership und Kompilierzeitprufungen, die klassische Garbage Collection vermeiden.\n\nDie Sprache zielt auf Bereiche, in denen C und C++ verbreitet sind, etwa Engines, Werkzeuge und leistungsensitive Dienste. Sie bleibt experimentell, mit aktiver Arbeit an Sicherheit, Nebenlaufigkeit und Interoperabilitat."
+        },
+        pt: {
+          name: "Vale",
+          description: "Linguagem de sistemas que explora seguranca de memoria com ownership e referencias geracionais.",
+          longDescription: "Vale e uma linguagem de programacao de sistemas focada em codigo nativo rapido, seguranca de memoria e ownership ergonomico. Seu design explora referencias geracionais, ownership parecido com regioes e verificacoes em tempo de compilacao que evitam garbage collection convencional.\n\nA linguagem mira dominios onde C e C++ sao comuns, incluindo motores, ferramentas e servicos sensiveis a desempenho. Ela permanece experimental, com trabalho ativo em seguranca, concorrencia e interoperabilidade."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/verilog.ts
 var verilog_exports = {};
 __export(verilog_exports, {
@@ -12141,6 +12665,64 @@ var init_verilog = __esm({
   }
 });
 
+// src/languages/verse.ts
+var verse_exports = {};
+__export(verse_exports, {
+  verse: () => verse
+});
+var verse;
+var init_verse = __esm({
+  "src/languages/verse.ts"() {
+    verse = {
+      slug: "verse",
+      publishedDate: "2023-03-23",
+      extensions: [".verse"],
+      author: "Epic Games",
+      website: "https://dev.epicgames.com/documentation/en-us/uefn/verse-language-reference",
+      paradigms: ["functional", "logic", "scripting"],
+      tooling: {
+        runtimes: ["Unreal Editor for Fortnite"],
+        ecosystems: ["Unreal Engine", "Fortnite Creator"]
+      },
+      version: "UEFN Verse",
+      logo: "https://dummyimage.com/32x32/111827/ffffff.png&text=Ve",
+      color: "#111827",
+      i18n: {
+        en: {
+          name: "Verse",
+          description: "A functional-logic scripting language from Epic Games for UEFN and future Unreal workflows.",
+          longDescription: "Verse is a programming language developed by Epic Games for Unreal Editor for Fortnite and related game-creation workflows. It combines scripting for interactive experiences with ideas from functional and logic programming.\n\nVerse is used to define gameplay behavior, devices, rules, and systems in UEFN projects. Its public ecosystem is tied to Fortnite Creator tooling and Unreal Engine documentation."
+        },
+        es: {
+          name: "Verse",
+          description: "Lenguaje de scripting funcional-logico de Epic Games para UEFN y flujos Unreal.",
+          longDescription: "Verse es un lenguaje de programacion desarrollado por Epic Games para Unreal Editor for Fortnite y flujos relacionados de creacion de juegos. Combina scripting para experiencias interactivas con ideas de programacion funcional y logica.\n\nVerse se usa para definir comportamiento de juego, dispositivos, reglas y sistemas en proyectos UEFN. Su ecosistema publico esta ligado a las herramientas de Fortnite Creator y a la documentacion de Unreal Engine."
+        },
+        it: {
+          name: "Verse",
+          description: "Linguaggio di scripting funzionale-logico di Epic Games per UEFN e workflow Unreal.",
+          longDescription: "Verse e un linguaggio di programmazione sviluppato da Epic Games per Unreal Editor for Fortnite e workflow correlati di creazione di giochi. Combina scripting per esperienze interattive con idee di programmazione funzionale e logica.\n\nVerse viene usato per definire comportamento di gioco, dispositivi, regole e sistemi nei progetti UEFN. Il suo ecosistema pubblico e legato agli strumenti Fortnite Creator e alla documentazione Unreal Engine."
+        },
+        fr: {
+          name: "Verse",
+          description: "Langage de script fonctionnel-logique d Epic Games pour UEFN et les flux Unreal.",
+          longDescription: "Verse est un langage de programmation developpe par Epic Games pour Unreal Editor for Fortnite et les flux associes de creation de jeux. Il combine le script d experiences interactives avec des idees issues de la programmation fonctionnelle et logique.\n\nVerse sert a definir comportements de gameplay, appareils, regles et systemes dans les projets UEFN. Son ecosysteme public est lie aux outils Fortnite Creator et a la documentation Unreal Engine."
+        },
+        de: {
+          name: "Verse",
+          description: "Funktional-logische Skriptsprache von Epic Games fur UEFN und Unreal-Workflows.",
+          longDescription: "Verse ist eine von Epic Games entwickelte Programmiersprache fur Unreal Editor for Fortnite und verwandte Workflows zur Spieleerstellung. Sie kombiniert Skripting fur interaktive Erlebnisse mit Ideen aus funktionaler und logischer Programmierung.\n\nVerse wird genutzt, um Gameplay-Verhalten, Gerate, Regeln und Systeme in UEFN-Projekten zu definieren. Das offentliche Okosystem ist an Fortnite-Creator-Werkzeuge und Unreal-Engine-Dokumentation gebunden."
+        },
+        pt: {
+          name: "Verse",
+          description: "Linguagem de scripting funcional-logica da Epic Games para UEFN e fluxos Unreal.",
+          longDescription: "Verse e uma linguagem de programacao desenvolvida pela Epic Games para Unreal Editor for Fortnite e fluxos relacionados de criacao de jogos. Ela combina scripting para experiencias interativas com ideias de programacao funcional e logica.\n\nVerse e usada para definir comportamento de gameplay, dispositivos, regras e sistemas em projetos UEFN. Seu ecossistema publico esta ligado as ferramentas Fortnite Creator e a documentacao do Unreal Engine."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/vhdl.ts
 var vhdl_exports = {};
 __export(vhdl_exports, {
@@ -12279,7 +12861,7 @@ var init_vue = __esm({
         packageManagers: ["npm", "pnpm", "Yarn", "Bun"],
         ecosystems: ["Web", "Vue", "Vite", "Nuxt"]
       },
-      version: "3.5.35",
+      version: "3.5.38",
       logo: "https://upload.wikimedia.org/wikipedia/commons/9/95/Vue.js_Logo_2.svg",
       color: "#4FC08D",
       i18n: {
@@ -13142,6 +13724,7 @@ init_antlr();
 init_apex();
 init_apl();
 init_applescript();
+init_aql();
 init_arduino();
 init_asciidoc();
 init_asp();
@@ -13193,6 +13776,7 @@ init_elm();
 init_erb();
 init_erlang();
 init_factor();
+init_fe();
 init_fennel();
 init_fish();
 init_flux();
@@ -13223,6 +13807,7 @@ init_html();
 init_hy();
 init_idris();
 init_ini();
+init_ink();
 init_io();
 init_isabelle();
 init_janet();
@@ -13242,6 +13827,7 @@ init_koka();
 init_kotlin();
 init_lean();
 init_less();
+init_ligo();
 init_liquid();
 init_lisp();
 init_llvm_ir();
@@ -13252,6 +13838,7 @@ init_luau();
 init_makefile();
 init_mako();
 init_markdown();
+init_marlowe();
 init_mathematica();
 init_matlab();
 init_mdx();
@@ -13313,9 +13900,12 @@ init_scala();
 init_scheme();
 init_scss();
 init_self();
+init_simula();
 init_smalltalk();
 init_smarty();
+init_snobol();
 init_solidity();
+init_spark();
 init_sparql();
 init_sql();
 init_standard_ml();
@@ -13338,7 +13928,9 @@ init_typst();
 init_unison();
 init_v();
 init_vala();
+init_vale();
 init_verilog();
+init_verse();
 init_vhdl();
 init_visual_basic();
 init_vue();
@@ -13368,6 +13960,7 @@ var languages = [
   apl,
   applescript,
   arduino,
+  aql,
   asciidoc,
   asp,
   assembly,
@@ -13418,6 +14011,7 @@ var languages = [
   erb,
   erlang,
   factor,
+  fe,
   fennel,
   fish,
   flux,
@@ -13448,6 +14042,7 @@ var languages = [
   hy,
   idris,
   ini,
+  ink,
   io,
   isabelle,
   janet,
@@ -13467,6 +14062,7 @@ var languages = [
   kotlin,
   lean,
   less,
+  ligo,
   liquid,
   lisp,
   llvmIr,
@@ -13477,6 +14073,7 @@ var languages = [
   makefile,
   mako,
   markdown,
+  marlowe,
   mathematica,
   matlab,
   mdx,
@@ -13538,10 +14135,13 @@ var languages = [
   scheme,
   scss,
   self,
+  simula,
   smalltalk,
   smarty,
+  snobol,
   solidity,
   sparql,
+  spark,
   sql,
   standardMl,
   starlark,
@@ -13563,7 +14163,9 @@ var languages = [
   unison,
   v,
   vala,
+  vale,
   verilog,
+  verse,
   vhdl,
   visualBasic,
   vue,
@@ -13596,6 +14198,7 @@ var languageIndex = [
   { slug: "apl", extensions: [".apl", ".dyalog"] },
   { slug: "applescript", extensions: [".applescript", ".scpt", ".scptd"] },
   { slug: "arduino", extensions: [".ino", ".pde"] },
+  { slug: "aql", extensions: [".aql"] },
   { slug: "asciidoc", extensions: [".adoc", ".asciidoc", ".asc"] },
   { slug: "asp", extensions: [".asp", ".aspx", ".ascx", ".ashx", ".asmx", ".master"] },
   { slug: "assembly", extensions: [".asm", ".s", ".S", ".inc"] },
@@ -13652,6 +14255,7 @@ var languageIndex = [
     extensions: [".erl", ".hrl", ".app.src", ".escript", ".xrl", ".yrl", "rebar.config"]
   },
   { slug: "factor", extensions: [".factor"] },
+  { slug: "fe", extensions: [".fe"] },
   { slug: "fennel", extensions: [".fnl"] },
   { slug: "fish", extensions: [".fish"] },
   { slug: "flux", extensions: [".flux"] },
@@ -13688,6 +14292,7 @@ var languageIndex = [
   { slug: "hy", extensions: [".hy"] },
   { slug: "idris", extensions: [".idr", ".lidr", ".ipkg"] },
   { slug: "ini", extensions: [".ini"] },
+  { slug: "ink", extensions: [".ink"] },
   { slug: "io", extensions: [".io"] },
   { slug: "isabelle", extensions: [".thy"] },
   { slug: "janet", extensions: [".janet", ".jdn"] },
@@ -13707,6 +14312,7 @@ var languageIndex = [
   { slug: "kotlin", extensions: [".kt", ".kts"] },
   { slug: "lean", extensions: [".lean"] },
   { slug: "less", extensions: [".less"] },
+  { slug: "ligo", extensions: [".ligo", ".mligo", ".religo", ".jsligo"] },
   { slug: "liquid", extensions: [".liquid"] },
   { slug: "lisp", extensions: [".lisp", ".lsp", ".cl", ".asd"] },
   { slug: "llvm-ir", extensions: [".ll", ".bc"] },
@@ -13717,6 +14323,7 @@ var languageIndex = [
   { slug: "makefile", extensions: ["Makefile", "makefile", "GNUmakefile", ".mk", ".mak"] },
   { slug: "mako", extensions: [".mako", ".mao"] },
   { slug: "markdown", extensions: [".md", ".markdown", ".mdown", ".mkd"] },
+  { slug: "marlowe", extensions: [".marlowe"] },
   { slug: "mathematica", extensions: [".wl", ".wls", ".nb"] },
   { slug: "matlab", extensions: [".m", ".mlx"] },
   { slug: "mdx", extensions: [".mdx"] },
@@ -13781,10 +14388,13 @@ var languageIndex = [
   { slug: "scheme", extensions: [".scm", ".ss", ".sld", ".sls"] },
   { slug: "scss", extensions: [".scss", ".sass"] },
   { slug: "self", extensions: [".self"] },
+  { slug: "simula", extensions: [".sim", ".simula"] },
   { slug: "smalltalk", extensions: [".st"] },
   { slug: "smarty", extensions: [".tpl", ".smarty"] },
+  { slug: "snobol", extensions: [".sno", ".snobol"] },
   { slug: "solidity", extensions: [".sol"] },
   { slug: "sparql", extensions: [".sparql", ".rq"] },
+  { slug: "spark", extensions: [".spark", ".adb", ".ads"] },
   { slug: "sql", extensions: [".sql"] },
   { slug: "standard-ml", extensions: [".sml", ".sig", ".fun"] },
   { slug: "starlark", extensions: [".bzl", ".star", ".sky"] },
@@ -13806,7 +14416,9 @@ var languageIndex = [
   { slug: "unison", extensions: [".u", ".uu"] },
   { slug: "v", extensions: [".v", ".vsh"] },
   { slug: "vala", extensions: [".vala", ".vapi"] },
+  { slug: "vale", extensions: [".vale"] },
   { slug: "verilog", extensions: [".v", ".vh", ".sv", ".svh"] },
+  { slug: "verse", extensions: [".verse"] },
   { slug: "vhdl", extensions: [".vhd", ".vhdl"] },
   { slug: "visual-basic", extensions: [".vb"] },
   { slug: "vue", extensions: [".vue"] },
@@ -13840,6 +14452,7 @@ var languageLoaders = {
   apl: () => Promise.resolve().then(() => (init_apl(), apl_exports)).then((module) => module.apl),
   applescript: () => Promise.resolve().then(() => (init_applescript(), applescript_exports)).then((module) => module.applescript),
   arduino: () => Promise.resolve().then(() => (init_arduino(), arduino_exports)).then((module) => module.arduino),
+  aql: () => Promise.resolve().then(() => (init_aql(), aql_exports)).then((module) => module.aql),
   asciidoc: () => Promise.resolve().then(() => (init_asciidoc(), asciidoc_exports)).then((module) => module.asciidoc),
   asp: () => Promise.resolve().then(() => (init_asp(), asp_exports)).then((module) => module.asp),
   assembly: () => Promise.resolve().then(() => (init_assembly(), assembly_exports)).then((module) => module.assembly),
@@ -13890,6 +14503,7 @@ var languageLoaders = {
   erb: () => Promise.resolve().then(() => (init_erb(), erb_exports)).then((module) => module.erb),
   erlang: () => Promise.resolve().then(() => (init_erlang(), erlang_exports)).then((module) => module.erlang),
   factor: () => Promise.resolve().then(() => (init_factor(), factor_exports)).then((module) => module.factor),
+  fe: () => Promise.resolve().then(() => (init_fe(), fe_exports)).then((module) => module.fe),
   fennel: () => Promise.resolve().then(() => (init_fennel(), fennel_exports)).then((module) => module.fennel),
   fish: () => Promise.resolve().then(() => (init_fish(), fish_exports)).then((module) => module.fish),
   flux: () => Promise.resolve().then(() => (init_flux(), flux_exports)).then((module) => module.flux),
@@ -13920,6 +14534,7 @@ var languageLoaders = {
   hy: () => Promise.resolve().then(() => (init_hy(), hy_exports)).then((module) => module.hy),
   idris: () => Promise.resolve().then(() => (init_idris(), idris_exports)).then((module) => module.idris),
   ini: () => Promise.resolve().then(() => (init_ini(), ini_exports)).then((module) => module.ini),
+  ink: () => Promise.resolve().then(() => (init_ink(), ink_exports)).then((module) => module.ink),
   io: () => Promise.resolve().then(() => (init_io(), io_exports)).then((module) => module.io),
   isabelle: () => Promise.resolve().then(() => (init_isabelle(), isabelle_exports)).then((module) => module.isabelle),
   janet: () => Promise.resolve().then(() => (init_janet(), janet_exports)).then((module) => module.janet),
@@ -13939,6 +14554,7 @@ var languageLoaders = {
   kotlin: () => Promise.resolve().then(() => (init_kotlin(), kotlin_exports)).then((module) => module.kotlin),
   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),
   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),
@@ -13949,6 +14565,7 @@ var languageLoaders = {
   makefile: () => Promise.resolve().then(() => (init_makefile(), makefile_exports)).then((module) => module.makefile),
   mako: () => Promise.resolve().then(() => (init_mako(), mako_exports)).then((module) => module.mako),
   markdown: () => Promise.resolve().then(() => (init_markdown(), markdown_exports)).then((module) => module.markdown),
+  marlowe: () => Promise.resolve().then(() => (init_marlowe(), marlowe_exports)).then((module) => module.marlowe),
   mathematica: () => Promise.resolve().then(() => (init_mathematica(), mathematica_exports)).then((module) => module.mathematica),
   matlab: () => Promise.resolve().then(() => (init_matlab(), matlab_exports)).then((module) => module.matlab),
   mdx: () => Promise.resolve().then(() => (init_mdx(), mdx_exports)).then((module) => module.mdx),
@@ -14010,10 +14627,13 @@ var languageLoaders = {
   scheme: () => Promise.resolve().then(() => (init_scheme(), scheme_exports)).then((module) => module.scheme),
   scss: () => Promise.resolve().then(() => (init_scss(), scss_exports)).then((module) => module.scss),
   self: () => Promise.resolve().then(() => (init_self(), self_exports)).then((module) => module.self),
+  simula: () => Promise.resolve().then(() => (init_simula(), simula_exports)).then((module) => module.simula),
   smalltalk: () => Promise.resolve().then(() => (init_smalltalk(), smalltalk_exports)).then((module) => module.smalltalk),
   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),
   sparql: () => Promise.resolve().then(() => (init_sparql(), sparql_exports)).then((module) => module.sparql),
+  spark: () => Promise.resolve().then(() => (init_spark(), spark_exports)).then((module) => module.spark),
   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),
@@ -14035,7 +14655,9 @@ var languageLoaders = {
   unison: () => Promise.resolve().then(() => (init_unison(), unison_exports)).then((module) => module.unison),
   v: () => Promise.resolve().then(() => (init_v(), v_exports)).then((module) => module.v),
   vala: () => Promise.resolve().then(() => (init_vala(), vala_exports)).then((module) => module.vala),
+  vale: () => Promise.resolve().then(() => (init_vale(), vale_exports)).then((module) => module.vale),
   verilog: () => Promise.resolve().then(() => (init_verilog(), verilog_exports)).then((module) => module.verilog),
+  verse: () => Promise.resolve().then(() => (init_verse(), verse_exports)).then((module) => module.verse),
   vhdl: () => Promise.resolve().then(() => (init_vhdl(), vhdl_exports)).then((module) => module.vhdl),
   "visual-basic": () => Promise.resolve().then(() => (init_visual_basic(), visual_basic_exports)).then((module) => module.visualBasic),
   vue: () => Promise.resolve().then(() => (init_vue(), vue_exports)).then((module) => module.vue),