code-languages 1.27.0 → 1.29.0

package/dist/api.cjs

@@ -1302,6 +1302,65 @@ var init_c = __esm({
   }
 });
 
+// src/languages/cairo.ts
+var cairo_exports = {};
+__export(cairo_exports, {
+  cairo: () => cairo
+});
+var cairo;
+var init_cairo = __esm({
+  "src/languages/cairo.ts"() {
+    cairo = {
+      slug: "cairo",
+      publishedDate: "2020-07-01",
+      extensions: [".cairo"],
+      author: "StarkWare Industries",
+      website: "https://www.cairo-lang.org",
+      paradigms: ["functional", "imperative"],
+      tooling: {
+        runtimes: ["Cairo VM", "CASM"],
+        packageManagers: ["Scarb"],
+        ecosystems: ["Blockchain", "Smart Contracts", "StarkNet", "ZK Proofs"]
+      },
+      version: "2.11.4",
+      logo: "https://avatars.githubusercontent.com/u/65030650?v=4",
+      color: "#FF6B35",
+      i18n: {
+        en: {
+          name: "Cairo",
+          description: "A Rust-inspired programming language for writing provable programs and smart contracts on StarkNet using zero-knowledge proofs.",
+          longDescription: "Cairo is a programming language designed by StarkWare Industries for writing provable programs \u2014 computations whose correctness can be verified using STARK zero-knowledge proofs. It powers the StarkNet Layer-2 network on Ethereum and enables smart contracts that can scale throughput while preserving cryptographic verifiability.\n\nCairo 1.0 (released 2023) introduced a Rust-inspired syntax with a strong ownership system, algebraic data types, pattern matching, and traits. It compiles to Sierra (Safe Intermediate Representation), which is then compiled to Cairo Assembly (CASM) for execution in the Cairo VM. The Scarb build tool manages packages from the on-chain registry."
+        },
+        es: {
+          name: "Cairo",
+          description: "Un lenguaje de programaci\xF3n inspirado en Rust para escribir programas demostrables y contratos inteligentes en StarkNet usando pruebas de conocimiento cero.",
+          longDescription: "Cairo es un lenguaje dise\xF1ado por StarkWare Industries para escribir programas demostrables cuya correcci\xF3n puede verificarse con pruebas STARK de conocimiento cero. Impulsa la red StarkNet (Layer-2 sobre Ethereum) y permite contratos inteligentes escalables con verificabilidad criptogr\xE1fica.\n\nCairo 1.0 introdujo una sintaxis inspirada en Rust con sistema de propiedad, tipos de datos algebraicos, coincidencia de patrones y traits. Compila a Sierra, que luego se compila a CASM para ejecutarse en la Cairo VM. Scarb gestiona los paquetes."
+        },
+        it: {
+          name: "Cairo",
+          description: "Un linguaggio di programmazione ispirato a Rust per scrivere programmi dimostrabili e smart contract su StarkNet usando prove a conoscenza zero.",
+          longDescription: "Cairo \xE8 un linguaggio progettato da StarkWare Industries per scrivere programmi dimostrabili la cui correttezza pu\xF2 essere verificata con prove STARK a conoscenza zero. Alimenta la rete StarkNet (Layer-2 su Ethereum) e consente smart contract scalabili con verificabilit\xE0 crittografica.\n\nCairo 1.0 ha introdotto una sintassi ispirata a Rust con sistema di ownership, tipi di dati algebrici, pattern matching e traits. Compila in Sierra, poi in CASM per l'esecuzione nella Cairo VM. Scarb gestisce i pacchetti."
+        },
+        fr: {
+          name: "Cairo",
+          description: "Langage Rust-inspir\xE9 pour \xE9crire des programmes d\xE9montrables et des contrats intelligents sur StarkNet avec des preuves \xE0 connaissance nulle.",
+          longDescription: "Cairo est un langage con\xE7u par StarkWare Industries pour \xE9crire des programmes d\xE9montrables dont la correction peut \xEAtre v\xE9rifi\xE9e par des preuves STARK \xE0 connaissance nulle. Il alimente le r\xE9seau StarkNet (Layer-2 sur Ethereum) et permet des contrats intelligents \xE9volutifs avec v\xE9rifiabilit\xE9 cryptographique.\n\nCairo 1.0 a introduit une syntaxe inspir\xE9e de Rust avec un syst\xE8me d'ownership, des types de donn\xE9es alg\xE9briques, du pattern matching et des traits. Il compile en Sierra, puis en CASM pour l'ex\xE9cution dans la Cairo VM. Scarb g\xE8re les paquets."
+        },
+        de: {
+          name: "Cairo",
+          description: "Eine Rust-inspirierte Programmiersprache f\xFCr beweisbare Programme und Smart Contracts auf StarkNet mit Zero-Knowledge-Beweisen.",
+          longDescription: "Cairo ist eine von StarkWare Industries entwickelte Sprache zum Schreiben beweisbarer Programme, deren Korrektheit mit STARK-Zero-Knowledge-Beweisen verifiziert werden kann. Sie treibt das StarkNet Layer-2-Netzwerk auf Ethereum an und erm\xF6glicht skalierbare Smart Contracts mit kryptographischer \xDCberpr\xFCfbarkeit.\n\nCairo 1.0 f\xFChrte eine Rust-inspirierte Syntax mit Ownership-System, algebraischen Datentypen, Pattern Matching und Traits ein. Es kompiliert zu Sierra und dann zu CASM f\xFCr die Ausf\xFChrung in der Cairo VM. Scarb verwaltet die Pakete."
+        },
+        pt: {
+          name: "Cairo",
+          description: "Uma linguagem de programa\xE7\xE3o inspirada em Rust para escrever programas comprov\xE1veis e contratos inteligentes na StarkNet usando provas de conhecimento zero.",
+          longDescription: "Cairo \xE9 uma linguagem projetada pela StarkWare Industries para escrever programas comprov\xE1veis cuja corre\xE7\xE3o pode ser verificada com provas STARK de conhecimento zero. Alimenta a rede StarkNet (Layer-2 no Ethereum) e permite contratos inteligentes escal\xE1veis com verificabilidade criptogr\xE1fica.\n\nCairo 1.0 introduziu uma sintaxe inspirada em Rust com sistema de ownership, tipos de dados alg\xE9bricos, correspond\xEAncia de padr\xF5es e traits. Compila para Sierra, depois para CASM para execu\xE7\xE3o na Cairo VM. O Scarb gerencia os pacotes."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/carbon.ts
 var carbon_exports = {};
 __export(carbon_exports, {
@@ -3063,6 +3122,64 @@ var init_fish = __esm({
   }
 });
 
+// src/languages/flux.ts
+var flux_exports = {};
+__export(flux_exports, {
+  flux: () => flux
+});
+var flux;
+var init_flux = __esm({
+  "src/languages/flux.ts"() {
+    flux = {
+      slug: "flux",
+      publishedDate: "2018-09-01",
+      extensions: [".flux"],
+      author: "InfluxData",
+      website: "https://www.influxdata.com/products/flux/",
+      paradigms: ["functional", "declarative"],
+      tooling: {
+        runtimes: ["InfluxDB", "Flux CLI"],
+        ecosystems: ["Time Series", "Monitoring", "Observability", "InfluxDB"]
+      },
+      version: "0.197.0",
+      logo: "https://avatars.githubusercontent.com/u/5713248?v=4",
+      color: "#22ADF6",
+      i18n: {
+        en: {
+          name: "Flux",
+          description: "A functional data scripting language by InfluxData for querying, analyzing, and transforming time-series data in InfluxDB.",
+          longDescription: "Flux is a functional data scripting and query language designed by InfluxData for working with time-series data. It replaced InfluxQL as the primary query language for InfluxDB 2.0 and provides a more expressive and composable approach to data transformation.\n\nFlux uses a pipe-forward operator (|>) to chain data transformations in a readable pipeline style. It supports filtering, grouping, windowing, aggregations, joins, and mathematical operations on time-series data. Flux is also capable of querying non-InfluxDB data sources and writing results back to databases, making it useful as a general ETL scripting language for monitoring and observability pipelines."
+        },
+        es: {
+          name: "Flux",
+          description: "Un lenguaje funcional de scripting de datos de InfluxData para consultar, analizar y transformar datos de series temporales en InfluxDB.",
+          longDescription: "Flux es un lenguaje funcional de scripting y consultas dise\xF1ado por InfluxData para trabajar con datos de series temporales. Reemplaz\xF3 a InfluxQL como lenguaje de consultas principal para InfluxDB 2.0 y proporciona un enfoque m\xE1s expresivo y composable para la transformaci\xF3n de datos.\n\nFlux usa el operador pipe-forward (|>) para encadenar transformaciones de datos en un estilo de pipeline legible. Soporta filtrado, agrupaci\xF3n, ventanas temporales, agregaciones, joins y operaciones matem\xE1ticas sobre datos de series temporales."
+        },
+        it: {
+          name: "Flux",
+          description: "Un linguaggio funzionale di scripting dati di InfluxData per interrogare, analizzare e trasformare dati di serie temporali in InfluxDB.",
+          longDescription: "Flux \xE8 un linguaggio funzionale di scripting e query progettato da InfluxData per lavorare con dati di serie temporali. Ha sostituito InfluxQL come linguaggio di query principale per InfluxDB 2.0 e fornisce un approccio pi\xF9 espressivo e componibile alla trasformazione dei dati.\n\nFlux usa l'operatore pipe-forward (|>) per concatenare trasformazioni di dati in uno stile di pipeline leggibile. Supporta filtraggio, raggruppamento, windowing, aggregazioni, join e operazioni matematiche su dati di serie temporali."
+        },
+        fr: {
+          name: "Flux",
+          description: "Un langage de script de donn\xE9es fonctionnel d'InfluxData pour interroger, analyser et transformer des donn\xE9es de s\xE9ries temporelles dans InfluxDB.",
+          longDescription: "Flux est un langage fonctionnel de script et de requ\xEAte con\xE7u par InfluxData pour travailler avec des donn\xE9es de s\xE9ries temporelles. Il a remplac\xE9 InfluxQL comme langage de requ\xEAte principal pour InfluxDB 2.0 et offre une approche plus expressive et composable de la transformation des donn\xE9es.\n\nFlux utilise l'op\xE9rateur pipe-forward (|>) pour cha\xEEner les transformations de donn\xE9es dans un style de pipeline lisible. Il prend en charge le filtrage, le regroupement, le fen\xEAtrage, les agr\xE9gations, les jointures et les op\xE9rations math\xE9matiques sur les donn\xE9es de s\xE9ries temporelles."
+        },
+        de: {
+          name: "Flux",
+          description: "Eine funktionale Datenskriptsprache von InfluxData zum Abfragen, Analysieren und Transformieren von Zeitreihendaten in InfluxDB.",
+          longDescription: "Flux ist eine funktionale Datenskript- und Abfragesprache, die von InfluxData f\xFCr die Arbeit mit Zeitreihendaten entwickelt wurde. Sie ersetzte InfluxQL als prim\xE4re Abfragesprache f\xFCr InfluxDB 2.0 und bietet einen ausdrucksst\xE4rkeren und kompositionsf\xE4higeren Ansatz zur Datentransformation.\n\nFlux verwendet den Pipe-Forward-Operator (|>), um Datentransformationen in einem lesbaren Pipeline-Stil zu verketten. Es unterst\xFCtzt Filterung, Gruppierung, Fenstering, Aggregationen, Joins und mathematische Operationen auf Zeitreihendaten."
+        },
+        pt: {
+          name: "Flux",
+          description: "Uma linguagem funcional de script de dados da InfluxData para consultar, analisar e transformar dados de s\xE9ries temporais no InfluxDB.",
+          longDescription: "Flux \xE9 uma linguagem funcional de script e consulta projetada pela InfluxData para trabalhar com dados de s\xE9ries temporais. Substituiu o InfluxQL como linguagem de consulta principal para o InfluxDB 2.0 e fornece uma abordagem mais expressiva e compos\xEDvel para transforma\xE7\xE3o de dados.\n\nFlux usa o operador pipe-forward (|>) para encadear transforma\xE7\xF5es de dados em um estilo de pipeline leg\xEDvel. Suporta filtragem, agrupamento, janelamento, agrega\xE7\xF5es, joins e opera\xE7\xF5es matem\xE1ticas em dados de s\xE9ries temporais."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/forth.ts
 var forth_exports = {};
 __export(forth_exports, {
@@ -3592,6 +3709,65 @@ var init_gradle = __esm({
   }
 });
 
+// src/languages/grain.ts
+var grain_exports = {};
+__export(grain_exports, {
+  grain: () => grain
+});
+var grain;
+var init_grain = __esm({
+  "src/languages/grain.ts"() {
+    grain = {
+      slug: "grain",
+      publishedDate: "2020-08-04",
+      extensions: [".gr"],
+      author: "Oscar Spencer",
+      website: "https://grain-lang.org",
+      paradigms: ["functional", "imperative"],
+      tooling: {
+        runtimes: ["grain CLI", "WebAssembly"],
+        packageManagers: ["grain (built-in)"],
+        ecosystems: ["WebAssembly", "Web", "Server"]
+      },
+      version: "0.6.5",
+      logo: "https://avatars.githubusercontent.com/u/54953488?v=4",
+      color: "#7C4DFF",
+      i18n: {
+        en: {
+          name: "Grain",
+          description: "A functional programming language that compiles to WebAssembly first, featuring a strong type system and memory safety without garbage collection pauses.",
+          longDescription: "Grain is a strongly typed, functional programming language that targets WebAssembly as its primary compilation target. Designed from the ground up with WebAssembly in mind, it produces compact and efficient WASM modules that run in browsers, Node.js, and any WASI-compliant runtime.\n\nGrain features algebraic data types, pattern matching, type inference, closures, and a module system. Its memory model avoids garbage collection pauses through reference counting with cycle detection. The standard library covers strings, numbers, lists, maps, file I/O, and more, making Grain suitable for building both web frontend and server-side WebAssembly applications."
+        },
+        es: {
+          name: "Grain",
+          description: "Lenguaje funcional que compila a WebAssembly, con un sistema de tipos fuerte y seguridad de memoria sin pausas de recolecci\xF3n de basura.",
+          longDescription: "Grain es un lenguaje funcional de tipado fuerte que tiene WebAssembly como destino principal de compilaci\xF3n. Dise\xF1ado desde cero pensando en WebAssembly, produce m\xF3dulos WASM compactos y eficientes que se ejecutan en navegadores, Node.js y cualquier runtime compatible con WASI.\n\nGrain incluye tipos de datos algebraicos, coincidencia de patrones, inferencia de tipos, closures y un sistema de m\xF3dulos. Su modelo de memoria evita pausas de GC mediante conteo de referencias con detecci\xF3n de ciclos."
+        },
+        it: {
+          name: "Grain",
+          description: "Linguaggio funzionale che compila in WebAssembly, con un sistema di tipi forte e sicurezza della memoria senza pause di garbage collection.",
+          longDescription: "Grain \xE8 un linguaggio funzionale fortemente tipizzato che ha WebAssembly come target di compilazione principale. Progettato da zero pensando a WebAssembly, produce moduli WASM compatti ed efficienti che girano nei browser, Node.js e qualsiasi runtime compatibile con WASI.\n\nGrain include tipi di dati algebrici, pattern matching, inferenza di tipi, closure e un sistema di moduli. Il suo modello di memoria evita le pause GC tramite reference counting con rilevamento dei cicli."
+        },
+        fr: {
+          name: "Grain",
+          description: "Langage fonctionnel qui compile vers WebAssembly, avec un syst\xE8me de types fort et une s\xE9curit\xE9 m\xE9moire sans pauses de garbage collection.",
+          longDescription: "Grain est un langage fonctionnel fortement typ\xE9 qui cible WebAssembly comme destination de compilation principale. Con\xE7u d\xE8s le d\xE9part en pensant \xE0 WebAssembly, il produit des modules WASM compacts et efficaces qui s'ex\xE9cutent dans les navigateurs, Node.js et tout runtime compatible WASI.\n\nGrain inclut des types de donn\xE9es alg\xE9briques, le pattern matching, l'inf\xE9rence de types, les closures et un syst\xE8me de modules. Son mod\xE8le m\xE9moire \xE9vite les pauses GC gr\xE2ce au comptage de r\xE9f\xE9rences avec d\xE9tection de cycles."
+        },
+        de: {
+          name: "Grain",
+          description: "Eine funktionale Programmiersprache, die prim\xE4r nach WebAssembly kompiliert, mit einem starken Typsystem und Speichersicherheit ohne Garbage-Collection-Pausen.",
+          longDescription: "Grain ist eine stark typisierte, funktionale Programmiersprache, die WebAssembly als prim\xE4res Kompilierungsziel verwendet. Von Grund auf mit WebAssembly im Sinn entwickelt, erzeugt sie kompakte und effiziente WASM-Module, die in Browsern, Node.js und jeder WASI-kompatiblen Laufzeitumgebung ausgef\xFChrt werden k\xF6nnen.\n\nGrain bietet algebraische Datentypen, Pattern Matching, Typinferenz, Closures und ein Modulsystem. Das Speichermodell vermeidet GC-Pausen durch Referenzz\xE4hlung mit Zyklenerkennung."
+        },
+        pt: {
+          name: "Grain",
+          description: "Linguagem funcional que compila para WebAssembly, com um sistema de tipos forte e seguran\xE7a de mem\xF3ria sem pausas de garbage collection.",
+          longDescription: "Grain \xE9 uma linguagem funcional fortemente tipada que tem WebAssembly como principal alvo de compila\xE7\xE3o. Projetada do zero pensando em WebAssembly, produz m\xF3dulos WASM compactos e eficientes que rodam em navegadores, Node.js e qualquer runtime compat\xEDvel com WASI.\n\nGrain inclui tipos de dados alg\xE9bricos, correspond\xEAncia de padr\xF5es, infer\xEAncia de tipos, closures e um sistema de m\xF3dulos. Seu modelo de mem\xF3ria evita pausas de GC por meio de contagem de refer\xEAncias com detec\xE7\xE3o de ciclos."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/graphql.ts
 var graphql_exports = {};
 __export(graphql_exports, {
@@ -3887,6 +4063,65 @@ var init_handlebars = __esm({
   }
 });
 
+// src/languages/hare.ts
+var hare_exports = {};
+__export(hare_exports, {
+  hare: () => hare
+});
+var hare;
+var init_hare = __esm({
+  "src/languages/hare.ts"() {
+    hare = {
+      slug: "hare",
+      publishedDate: "2022-04-25",
+      extensions: [".ha"],
+      author: "Drew DeVault",
+      website: "https://harelang.org",
+      paradigms: ["imperative", "systems"],
+      tooling: {
+        runtimes: ["hare"],
+        packageManagers: ["hare (built-in modules)"],
+        ecosystems: ["Systems", "Embedded", "Unix", "Linux"]
+      },
+      version: "0.25.1",
+      logo: "https://harelang.org/mascot.png",
+      color: "#5D4E37",
+      i18n: {
+        en: {
+          name: "Hare",
+          description: "A systems programming language designed to be simple, stable, and robust, with explicit memory management and no hidden control flow.",
+          longDescription: "Hare is a systems programming language designed by Drew DeVault with an emphasis on simplicity, stability, and long-term maintainability. It targets Unix-like operating systems and bare-metal environments, serving as a modern alternative to C.\n\nHare has no runtime, no garbage collector, and no hidden control flow. Memory management is manual and explicit. The language includes tagged unions, slices, deferred function calls, and a standard library that covers I/O, networking, cryptography, and datetime handling. Hare uses a reproducible build system and aims for a stable specification that does not change, making it suitable for long-lived systems software."
+        },
+        es: {
+          name: "Hare",
+          description: "Un lenguaje de programaci\xF3n de sistemas dise\xF1ado para ser simple, estable y robusto, con gesti\xF3n de memoria expl\xEDcita y sin flujo de control oculto.",
+          longDescription: "Hare es un lenguaje de programaci\xF3n de sistemas dise\xF1ado por Drew DeVault con \xE9nfasis en la simplicidad, estabilidad y mantenibilidad a largo plazo. Est\xE1 dirigido a sistemas operativos Unix-like y entornos bare-metal, como alternativa moderna a C.\n\nHare no tiene runtime ni recolector de basura, y no tiene flujo de control oculto. La gesti\xF3n de memoria es manual y expl\xEDcita. El lenguaje incluye uniones etiquetadas, slices, llamadas diferidas y una biblioteca est\xE1ndar que cubre E/S, redes, criptograf\xEDa y fechas."
+        },
+        it: {
+          name: "Hare",
+          description: "Linguaggio di sistema semplice e stabile con gestione esplicita della memoria e senza flusso di controllo nascosto.",
+          longDescription: "Hare \xE8 un linguaggio di programmazione di sistema progettato da Drew DeVault con enfasi su semplicit\xE0, stabilit\xE0 e manutenibilit\xE0 a lungo termine. \xC8 destinato a sistemi operativi Unix-like e ambienti bare-metal, come alternativa moderna a C.\n\nHare non ha runtime n\xE9 garbage collector, e non ha flusso di controllo nascosto. La gestione della memoria \xE8 manuale ed esplicita. Il linguaggio include union taggate, slice, chiamate differite e una libreria standard che copre I/O, rete, crittografia e gestione delle date."
+        },
+        fr: {
+          name: "Hare",
+          description: "Un langage de programmation syst\xE8me con\xE7u pour \xEAtre simple, stable et robuste, avec une gestion de m\xE9moire explicite et sans flux de contr\xF4le cach\xE9.",
+          longDescription: "Hare est un langage de programmation syst\xE8me con\xE7u par Drew DeVault avec un accent sur la simplicit\xE9, la stabilit\xE9 et la maintenabilit\xE9 \xE0 long terme. Il cible les syst\xE8mes d'exploitation de type Unix et les environnements bare-metal, comme alternative moderne \xE0 C.\n\nHare n'a pas de runtime ni de garbage collector, et pas de flux de contr\xF4le cach\xE9. La gestion de la m\xE9moire est manuelle et explicite. Le langage inclut des unions \xE9tiquet\xE9es, des slices, des appels diff\xE9r\xE9s et une biblioth\xE8que standard couvrant l'I/O, le r\xE9seau, la cryptographie et la gestion des dates."
+        },
+        de: {
+          name: "Hare",
+          description: "Systemprogrammiersprache f\xFCr Einfachheit, Stabilit\xE4t und Robustheit, mit expliziter Speicherverwaltung und ohne verborgenen Kontrollfluss.",
+          longDescription: "Hare ist eine von Drew DeVault entwickelte Systemprogrammiersprache mit Schwerpunkt auf Einfachheit, Stabilit\xE4t und langfristiger Wartbarkeit. Sie zielt auf Unix-\xE4hnliche Betriebssysteme und Bare-Metal-Umgebungen als moderne Alternative zu C.\n\nHare hat keine Laufzeitumgebung, keinen Garbage Collector und keinen verborgenen Kontrollfluss. Die Speicherverwaltung ist manuell und explizit. Die Sprache umfasst Tagged Unions, Slices, verz\xF6gerte Funktionsaufrufe und eine Standardbibliothek f\xFCr I/O, Netzwerk, Kryptographie und Datumsverwaltung."
+        },
+        pt: {
+          name: "Hare",
+          description: "Uma linguagem de programa\xE7\xE3o de sistemas projetada para ser simples, est\xE1vel e robusta, com gerenciamento de mem\xF3ria expl\xEDcito e sem fluxo de controle oculto.",
+          longDescription: "Hare \xE9 uma linguagem de programa\xE7\xE3o de sistemas projetada por Drew DeVault com \xEAnfase em simplicidade, estabilidade e manutenibilidade a longo prazo. Destina-se a sistemas operacionais Unix-like e ambientes bare-metal, como alternativa moderna ao C.\n\nHare n\xE3o tem runtime nem coletor de lixo, e n\xE3o tem fluxo de controle oculto. O gerenciamento de mem\xF3ria \xE9 manual e expl\xEDcito. A linguagem inclui uni\xF5es marcadas, slices, chamadas diferidas e uma biblioteca padr\xE3o que cobre I/O, rede, criptografia e manipula\xE7\xE3o de datas."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/haskell.ts
 var haskell_exports = {};
 __export(haskell_exports, {
@@ -4234,6 +4469,65 @@ var init_html = __esm({
   }
 });
 
+// src/languages/hy.ts
+var hy_exports = {};
+__export(hy_exports, {
+  hy: () => hy
+});
+var hy;
+var init_hy = __esm({
+  "src/languages/hy.ts"() {
+    hy = {
+      slug: "hy",
+      publishedDate: "2013-04-03",
+      extensions: [".hy"],
+      author: "Paul Tagliamonte",
+      website: "https://hylang.org",
+      paradigms: ["functional", "meta-programming", "object-oriented"],
+      tooling: {
+        runtimes: ["hy (Python-based)"],
+        packageManagers: ["pip"],
+        ecosystems: ["Python", "Machine Learning", "Data Science", "Scripting"]
+      },
+      version: "1.0.0",
+      logo: "https://avatars.githubusercontent.com/u/10551643?v=4",
+      color: "#35B9E9",
+      i18n: {
+        en: {
+          name: "Hy",
+          description: "A Lisp dialect embedded in Python that compiles to Python AST, giving full access to the Python ecosystem with a macro-capable Lisp syntax.",
+          longDescription: "Hy is a Lisp dialect that is embedded directly in Python. Hy code is compiled to Python's abstract syntax tree (AST) and therefore has complete, bidirectional interoperability with Python: Python can import Hy modules and Hy can import Python modules.\n\nHy brings Lisp's powerful macro system to Python, enabling code generation and domain-specific languages. It supports all Python data types and features, including classes, decorators, generators, and async/await. The entire Python standard library and third-party ecosystem \u2014 NumPy, Pandas, TensorFlow \u2014 are available natively. Hy is particularly popular for Python developers who want to explore Lisp without leaving their familiar ecosystem."
+        },
+        es: {
+          name: "Hy",
+          description: "Un dialecto Lisp integrado en Python que compila a AST de Python, dando acceso completo al ecosistema de Python con una sintaxis Lisp con macros.",
+          longDescription: "Hy es un dialecto Lisp integrado directamente en Python. El c\xF3digo Hy se compila al \xE1rbol de sintaxis abstracta (AST) de Python, por lo que tiene interoperabilidad completa y bidireccional con Python.\n\nHy trae el potente sistema de macros de Lisp a Python, permitiendo la generaci\xF3n de c\xF3digo y lenguajes espec\xEDficos de dominio. Soporta todos los tipos de datos y caracter\xEDsticas de Python, incluidos clases, decoradores, generadores y async/await. Todo el ecosistema Python \u2014 NumPy, Pandas, TensorFlow \u2014 est\xE1 disponible de forma nativa."
+        },
+        it: {
+          name: "Hy",
+          description: "Un dialetto Lisp integrato in Python che compila in AST Python, offrendo accesso completo all'ecosistema Python con una sintassi Lisp con macro.",
+          longDescription: "Hy \xE8 un dialetto Lisp integrato direttamente in Python. Il codice Hy viene compilato nell'albero di sintassi astratta (AST) di Python e ha quindi una completa interoperabilit\xE0 bidirezionale con Python.\n\nHy porta il potente sistema di macro di Lisp in Python, abilitando la generazione di codice e i linguaggi specifici di dominio. Supporta tutti i tipi di dati e le funzionalit\xE0 di Python, incluse classi, decoratori, generatori e async/await. L'intero ecosistema Python \u2014 NumPy, Pandas, TensorFlow \u2014 \xE8 disponibile nativamente."
+        },
+        fr: {
+          name: "Hy",
+          description: "Un dialecte Lisp int\xE9gr\xE9 dans Python qui compile vers l'AST Python, donnant un acc\xE8s complet \xE0 l'\xE9cosyst\xE8me Python avec une syntaxe Lisp capable de macros.",
+          longDescription: "Hy est un dialecte Lisp int\xE9gr\xE9 directement dans Python. Le code Hy est compil\xE9 vers l'arbre de syntaxe abstraite (AST) de Python et dispose donc d'une interop\xE9rabilit\xE9 compl\xE8te et bidirectionnelle avec Python.\n\nHy apporte le puissant syst\xE8me de macros de Lisp \xE0 Python, permettant la g\xE9n\xE9ration de code et les langages sp\xE9cifiques \xE0 un domaine. Il prend en charge tous les types de donn\xE9es et fonctionnalit\xE9s Python, y compris les classes, d\xE9corateurs, g\xE9n\xE9rateurs et async/await. Tout l'\xE9cosyst\xE8me Python est disponible nativement."
+        },
+        de: {
+          name: "Hy",
+          description: "Ein in Python eingebetteter Lisp-Dialekt, der zu Python-AST kompiliert und vollen Zugang zum Python-\xD6kosystem mit einer makrof\xE4higen Lisp-Syntax bietet.",
+          longDescription: "Hy ist ein Lisp-Dialekt, der direkt in Python eingebettet ist. Hy-Code wird zu Pythons abstrakter Syntaxbaumdarstellung (AST) kompiliert und hat daher vollst\xE4ndige, bidirektionale Interoperabilit\xE4t mit Python.\n\nHy bringt Lisps leistungsstarkes Makrosystem nach Python und erm\xF6glicht Code-Generierung und dom\xE4nenspezifische Sprachen. Es unterst\xFCtzt alle Python-Datentypen und -Funktionen, einschlie\xDFlich Klassen, Dekoratoren, Generatoren und async/await. Das gesamte Python-\xD6kosystem \u2014 NumPy, Pandas, TensorFlow \u2014 ist nativ verf\xFCgbar."
+        },
+        pt: {
+          name: "Hy",
+          description: "Um dialeto Lisp embutido no Python que compila para a AST do Python, dando acesso completo ao ecossistema Python com uma sintaxe Lisp com suporte a macros.",
+          longDescription: "Hy \xE9 um dialeto Lisp integrado diretamente no Python. O c\xF3digo Hy \xE9 compilado para a \xE1rvore de sintaxe abstrata (AST) do Python e, portanto, tem interoperabilidade completa e bidirecional com Python.\n\nHy traz o poderoso sistema de macros do Lisp para o Python, permitindo gera\xE7\xE3o de c\xF3digo e linguagens espec\xEDficas de dom\xEDnio. Suporta todos os tipos de dados e recursos do Python, incluindo classes, decoradores, geradores e async/await. Todo o ecossistema Python \u2014 NumPy, Pandas, TensorFlow \u2014 est\xE1 dispon\xEDvel nativamente."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/idris.ts
 var idris_exports = {};
 __export(idris_exports, {
@@ -4876,6 +5170,65 @@ var init_jupyter_notebook = __esm({
   }
 });
 
+// src/languages/kcl.ts
+var kcl_exports = {};
+__export(kcl_exports, {
+  kcl: () => kcl
+});
+var kcl;
+var init_kcl = __esm({
+  "src/languages/kcl.ts"() {
+    kcl = {
+      slug: "kcl",
+      publishedDate: "2022-10-01",
+      extensions: [".k", ".kcl"],
+      author: "KusionStack Team (Ant Group)",
+      website: "https://kcl-lang.io",
+      paradigms: ["declarative", "functional"],
+      tooling: {
+        runtimes: ["kcl CLI"],
+        packageManagers: ["kcl mod"],
+        ecosystems: ["Configuration", "Kubernetes", "Cloud Native", "Infrastructure as Code"]
+      },
+      version: "0.11.0",
+      logo: "https://avatars.githubusercontent.com/u/121281745?v=4",
+      color: "#4A90D9",
+      i18n: {
+        en: {
+          name: "KCL",
+          description: "An open-source constraint-based configuration and policy language for cloud-native applications, with a Python-like syntax and built-in validation.",
+          longDescription: "KCL (Kusion Configuration Language) is an open-source declarative configuration and policy language developed by Ant Group's KusionStack team. It is designed to improve the writing of complex configurations, particularly for Kubernetes and cloud-native infrastructure.\n\nKCL features a Python-like syntax with strong typing, schema definitions, lambda functions, and built-in validation through constraint expressions. It supports config composition and override operations, allowing teams to manage large-scale configurations with clear inheritance and merging semantics. KCL integrates with Helm, Kustomize, and Crossplane, and can generate Kubernetes manifests, Terraform configurations, and other infrastructure-as-code outputs."
+        },
+        es: {
+          name: "KCL",
+          description: "Un lenguaje de configuraci\xF3n y pol\xEDticas declarativo de c\xF3digo abierto para aplicaciones cloud-native, con sintaxis similar a Python y validaci\xF3n incorporada.",
+          longDescription: "KCL (Kusion Configuration Language) es un lenguaje declarativo de c\xF3digo abierto desarrollado por el equipo KusionStack de Ant Group. Est\xE1 dise\xF1ado para mejorar la escritura de configuraciones complejas, especialmente para Kubernetes e infraestructura cloud-native.\n\nKCL tiene una sintaxis similar a Python con tipado fuerte, definiciones de schema, funciones lambda y validaci\xF3n integrada mediante expresiones de restricciones. Soporta composici\xF3n y anulaci\xF3n de configuraciones, y se integra con Helm, Kustomize y Crossplane."
+        },
+        it: {
+          name: "KCL",
+          description: "Un linguaggio dichiarativo open-source per configurazione e policy di applicazioni cloud-native, con sintassi simile a Python e validazione integrata.",
+          longDescription: "KCL (Kusion Configuration Language) \xE8 un linguaggio dichiarativo open source sviluppato dal team KusionStack di Ant Group. \xC8 progettato per migliorare la scrittura di configurazioni complesse, in particolare per Kubernetes e l'infrastruttura cloud-native.\n\nKCL ha una sintassi simile a Python con tipizzazione forte, definizioni di schema, funzioni lambda e validazione integrata tramite espressioni di vincolo. Supporta la composizione e l'override delle configurazioni, e si integra con Helm, Kustomize e Crossplane."
+        },
+        fr: {
+          name: "KCL",
+          description: "Langage d\xE9claratif open-source pour configurer les applications cloud-native, avec une syntaxe proche de Python et une validation int\xE9gr\xE9e.",
+          longDescription: "KCL (Kusion Configuration Language) est un langage d\xE9claratif open source d\xE9velopp\xE9 par l'\xE9quipe KusionStack d'Ant Group. Il est con\xE7u pour am\xE9liorer l'\xE9criture de configurations complexes, notamment pour Kubernetes et l'infrastructure cloud-native.\n\nKCL poss\xE8de une syntaxe proche de Python avec un typage fort, des d\xE9finitions de sch\xE9mas, des fonctions lambda et une validation int\xE9gr\xE9e via des expressions de contraintes. Il supporte la composition et la substitution de configurations, et s'int\xE8gre avec Helm, Kustomize et Crossplane."
+        },
+        de: {
+          name: "KCL",
+          description: "Eine deklarative Open-Source-Konfigurations- und Richtliniensprache f\xFCr Cloud-native Anwendungen mit Python-\xE4hnlicher Syntax und integrierter Validierung.",
+          longDescription: "KCL (Kusion Configuration Language) ist eine deklarative Open-Source-Sprache, die vom KusionStack-Team bei Ant Group entwickelt wurde. Sie ist darauf ausgelegt, das Schreiben komplexer Konfigurationen zu verbessern, insbesondere f\xFCr Kubernetes und Cloud-native Infrastruktur.\n\nKCL bietet eine Python-\xE4hnliche Syntax mit starkem Typsystem, Schema-Definitionen, Lambda-Funktionen und eingebauter Validierung durch Constraint-Ausdr\xFCcke. Es unterst\xFCtzt Konfigurationskomposition und -\xFCberschreibung und integriert sich mit Helm, Kustomize und Crossplane."
+        },
+        pt: {
+          name: "KCL",
+          description: "Uma linguagem declarativa open-source de configura\xE7\xE3o e pol\xEDticas para aplica\xE7\xF5es cloud-native, com sintaxe similar ao Python e valida\xE7\xE3o integrada.",
+          longDescription: "KCL (Kusion Configuration Language) \xE9 uma linguagem declarativa open source desenvolvida pela equipe KusionStack do Ant Group. \xC9 projetada para melhorar a escrita de configura\xE7\xF5es complexas, especialmente para Kubernetes e infraestrutura cloud-native.\n\nKCL possui uma sintaxe similar ao Python com tipagem forte, defini\xE7\xF5es de schema, fun\xE7\xF5es lambda e valida\xE7\xE3o integrada por meio de express\xF5es de restri\xE7\xE3o. Suporta composi\xE7\xE3o e substitui\xE7\xE3o de configura\xE7\xF5es, e se integra com Helm, Kustomize e Crossplane."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/kotlin.ts
 var kotlin_exports = {};
 __export(kotlin_exports, {
@@ -5989,6 +6342,65 @@ var init_moonbit = __esm({
   }
 });
 
+// src/languages/move.ts
+var move_exports = {};
+__export(move_exports, {
+  move: () => move
+});
+var move;
+var init_move = __esm({
+  "src/languages/move.ts"() {
+    move = {
+      slug: "move",
+      publishedDate: "2019-10-01",
+      extensions: [".move"],
+      author: "Diem (Meta) Research",
+      website: "https://move-language.github.io/move/",
+      paradigms: ["functional", "imperative"],
+      tooling: {
+        runtimes: ["Move VM", "Aptos CLI", "Sui CLI"],
+        packageManagers: ["Move package manager"],
+        ecosystems: ["Blockchain", "Smart Contracts", "Aptos", "Sui"]
+      },
+      version: "2.0.0",
+      logo: "https://avatars.githubusercontent.com/u/108696678?v=4",
+      color: "#1C8F9C",
+      i18n: {
+        en: {
+          name: "Move",
+          description: "A safe and flexible programming language for the Aptos and Sui blockchains, designed to express ownership of digital assets with first-class resource types.",
+          longDescription: "Move is a programming language originally created at Meta (formerly Facebook) for the Diem (formerly Libra) blockchain and later adopted as the primary language for the Aptos and Sui networks. It is designed around the concept of resources \u2014 types that can never be copied or implicitly discarded, only moved, which maps naturally to the semantics of digital assets and tokens.\n\nMove's type system enforces ownership and access control at compile time, preventing common smart contract vulnerabilities like reentrancy, double-spending, and unauthorized mutations. The language features modules, structs, generics, and formal verification support. Aptos Move and Sui Move are the two main variants, with Sui extending the model with an object-centric ownership system."
+        },
+        es: {
+          name: "Move",
+          description: "Lenguaje seguro y flexible para las blockchains Aptos y Sui, dise\xF1ado para expresar la propiedad de activos digitales mediante tipos de recursos.",
+          longDescription: "Move es un lenguaje de programaci\xF3n creado originalmente en Meta para la blockchain Diem y adoptado despu\xE9s como lenguaje principal de las redes Aptos y Sui. Est\xE1 dise\xF1ado alrededor del concepto de recursos \u2014 tipos que nunca pueden copiarse ni descartarse impl\xEDcitamente, solo moverse \u2014 lo que mapea naturalmente la sem\xE1ntica de activos digitales.\n\nEl sistema de tipos de Move aplica la propiedad y el control de acceso en tiempo de compilaci\xF3n, previniendo vulnerabilidades comunes de contratos inteligentes. El lenguaje incluye m\xF3dulos, structs, gen\xE9ricos y soporte para verificaci\xF3n formal."
+        },
+        it: {
+          name: "Move",
+          description: "Linguaggio sicuro e flessibile per le blockchain Aptos e Sui, per esprimere la propriet\xE0 di asset digitali con tipi di risorse di prima classe.",
+          longDescription: "Move \xE8 un linguaggio di programmazione creato originariamente da Meta per la blockchain Diem e successivamente adottato come linguaggio principale per le reti Aptos e Sui. \xC8 progettato attorno al concetto di risorse \u2014 tipi che non possono mai essere copiati o scartati implicitamente, solo spostati \u2014 che mappa naturalmente la semantica degli asset digitali.\n\nIl sistema di tipi di Move applica ownership e controllo degli accessi a compile time, prevenendo vulnerabilit\xE0 comuni degli smart contract. Il linguaggio include moduli, struct, generici e supporto per la verifica formale."
+        },
+        fr: {
+          name: "Move",
+          description: "Langage s\xFBr pour les blockchains Aptos et Sui, exprimant la propri\xE9t\xE9 d'actifs num\xE9riques via des types de ressources de premi\xE8re classe.",
+          longDescription: "Move est un langage de programmation cr\xE9\xE9 \xE0 l'origine par Meta pour la blockchain Diem et adopt\xE9 ult\xE9rieurement comme langage principal pour les r\xE9seaux Aptos et Sui. Il est con\xE7u autour du concept de ressources \u2014 des types qui ne peuvent jamais \xEAtre copi\xE9s ou implicitement abandonn\xE9s, seulement d\xE9plac\xE9s \u2014 ce qui correspond naturellement \xE0 la s\xE9mantique des actifs num\xE9riques.\n\nLe syst\xE8me de types de Move applique l'ownership et le contr\xF4le d'acc\xE8s \xE0 la compilation, pr\xE9venant les vuln\xE9rabilit\xE9s courantes des smart contracts. Le langage inclut des modules, des structs, des g\xE9n\xE9riques et un support pour la v\xE9rification formelle."
+        },
+        de: {
+          name: "Move",
+          description: "Sichere Programmiersprache f\xFCr Aptos und Sui, die Eigentum an digitalen Assets \xFCber erstklassige Ressourcentypen ausdr\xFCckt.",
+          longDescription: "Move ist eine Programmiersprache, die urspr\xFCnglich bei Meta f\xFCr die Diem-Blockchain entwickelt und sp\xE4ter als Hauptsprache f\xFCr die Aptos- und Sui-Netzwerke \xFCbernommen wurde. Sie ist um das Konzept von Ressourcen herum aufgebaut \u2014 Typen, die niemals kopiert oder implizit verworfen werden k\xF6nnen, sondern nur verschoben werden \u2014 was nat\xFCrlich der Semantik digitaler Assets entspricht.\n\nMoves Typsystem erzwingt Ownership und Zugriffskontrolle zur Kompilierzeit und verhindert g\xE4ngige Smart-Contract-Schwachstellen. Die Sprache umfasst Module, Structs, Generics und formale Verifikationsunterst\xFCtzung."
+        },
+        pt: {
+          name: "Move",
+          description: "Linguagem segura e flex\xEDvel para as blockchains Aptos e Sui, para expressar propriedade de ativos digitais com tipos de recursos.",
+          longDescription: "Move \xE9 uma linguagem de programa\xE7\xE3o criada originalmente na Meta para a blockchain Diem e posteriormente adotada como linguagem principal para as redes Aptos e Sui. \xC9 projetada em torno do conceito de recursos \u2014 tipos que nunca podem ser copiados ou descartados implicitamente, apenas movidos \u2014 o que mapeia naturalmente a sem\xE2ntica de ativos digitais.\n\nO sistema de tipos do Move aplica ownership e controle de acesso em tempo de compila\xE7\xE3o, prevenindo vulnerabilidades comuns de contratos inteligentes. A linguagem inclui m\xF3dulos, structs, gen\xE9ricos e suporte para verifica\xE7\xE3o formal."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/mustache.ts
 var mustache_exports = {};
 __export(mustache_exports, {
@@ -6104,6 +6516,64 @@ var init_nginx = __esm({
   }
 });
 
+// src/languages/nickel.ts
+var nickel_exports = {};
+__export(nickel_exports, {
+  nickel: () => nickel
+});
+var nickel;
+var init_nickel = __esm({
+  "src/languages/nickel.ts"() {
+    nickel = {
+      slug: "nickel",
+      publishedDate: "2022-03-09",
+      extensions: [".ncl"],
+      author: "Tweag I/O",
+      website: "https://nickel-lang.org",
+      paradigms: ["declarative", "functional"],
+      tooling: {
+        runtimes: ["nickel CLI"],
+        ecosystems: ["Configuration", "Infrastructure", "Nix", "DevOps"]
+      },
+      version: "1.9.1",
+      logo: "https://avatars.githubusercontent.com/u/83021462?v=4",
+      color: "#3C6EB4",
+      i18n: {
+        en: {
+          name: "Nickel",
+          description: "A safe, gradually-typed configuration language with gradual contracts and blame tracking, designed as an evolution of Nix expressions.",
+          longDescription: "Nickel is a configuration language developed by Tweag I/O to address the shortcomings of ad-hoc YAML/JSON and the complexity of the Nix language. It is designed to be simple enough for configuration authors while being expressive enough for library authors building reusable abstractions.\n\nNickel features gradual typing with contracts \u2014 runtime-checked refinement types that can express invariants like 'a port number between 0 and 65535'. When a contract is violated, Nickel provides precise blame tracking to identify the source of the error. It supports lazy evaluation, a record merge operator for composing configurations, and can export to JSON, YAML, and TOML."
+        },
+        es: {
+          name: "Nickel",
+          description: "Un lenguaje de configuraci\xF3n seguro y gradualmente tipado con contratos y rastreo de culpa, dise\xF1ado como una evoluci\xF3n de las expresiones Nix.",
+          longDescription: "Nickel es un lenguaje de configuraci\xF3n desarrollado por Tweag I/O para resolver las deficiencias de YAML/JSON ad-hoc y la complejidad del lenguaje Nix. Est\xE1 dise\xF1ado para ser suficientemente simple para autores de configuraci\xF3n y suficientemente expresivo para autores de bibliotecas.\n\nNickel incluye tipado gradual con contratos \u2014 tipos de refinamiento verificados en tiempo de ejecuci\xF3n que pueden expresar invariantes. Cuando se viola un contrato, Nickel proporciona rastreo preciso de culpa. Soporta evaluaci\xF3n perezosa y un operador de fusi\xF3n de registros para componer configuraciones."
+        },
+        it: {
+          name: "Nickel",
+          description: "Un linguaggio di configurazione sicuro e gradualmente tipizzato con contratti graduali e blame tracking, progettato come evoluzione delle espressioni Nix.",
+          longDescription: "Nickel \xE8 un linguaggio di configurazione sviluppato da Tweag I/O per risolvere i limiti di YAML/JSON ad-hoc e la complessit\xE0 del linguaggio Nix. \xC8 progettato per essere abbastanza semplice per gli autori di configurazioni e abbastanza espressivo per gli autori di librerie.\n\nNickel include tipizzazione graduale con contratti \u2014 tipi di raffinamento verificati a runtime che possono esprimere invarianti. Quando un contratto viene violato, Nickel fornisce un blame tracking preciso. Supporta la valutazione lazy e un operatore di fusione di record."
+        },
+        fr: {
+          name: "Nickel",
+          description: "Un langage de configuration s\xFBr et graduellement typ\xE9 avec des contrats graduels et un suivi de responsabilit\xE9, con\xE7u comme une \xE9volution des expressions Nix.",
+          longDescription: "Nickel est un langage de configuration d\xE9velopp\xE9 par Tweag I/O pour rem\xE9dier aux lacunes de YAML/JSON ad-hoc et \xE0 la complexit\xE9 du langage Nix. Il est con\xE7u pour \xEAtre suffisamment simple pour les auteurs de configurations et suffisamment expressif pour les auteurs de biblioth\xE8ques.\n\nNickel propose un typage graduel avec des contrats \u2014 des types de raffinement v\xE9rifi\xE9s \xE0 l'ex\xE9cution. En cas de violation de contrat, Nickel fournit un suivi pr\xE9cis de la responsabilit\xE9. Il supporte l'\xE9valuation paresseuse et un op\xE9rateur de fusion de records."
+        },
+        de: {
+          name: "Nickel",
+          description: "Eine sichere, graduell typisierte Konfigurationssprache mit graduellen Contracts und Blame-Tracking, entwickelt als Weiterentwicklung von Nix-Ausdr\xFCcken.",
+          longDescription: "Nickel ist eine von Tweag I/O entwickelte Konfigurationssprache, um die Schw\xE4chen von ad-hoc YAML/JSON und die Komplexit\xE4t der Nix-Sprache zu beheben. Sie ist einfach genug f\xFCr Konfigurationsautoren und ausdrucksstark genug f\xFCr Bibliotheksautoren.\n\nNickel bietet graduelles Typsystem mit Contracts \u2014 laufzeitgepr\xFCfte Verfeinerungstypen, die Invarianten ausdr\xFCcken k\xF6nnen. Bei einem Contract-Versto\xDF liefert Nickel pr\xE4zises Blame-Tracking. Es unterst\xFCtzt Lazy Evaluation und einen Record-Merge-Operator."
+        },
+        pt: {
+          name: "Nickel",
+          description: "Linguagem de configura\xE7\xE3o segura e gradualmente tipada com contratos e rastreamento de responsabilidade, projetada como evolu\xE7\xE3o das express\xF5es Nix.",
+          longDescription: "Nickel \xE9 uma linguagem de configura\xE7\xE3o desenvolvida pela Tweag I/O para resolver as defici\xEAncias de YAML/JSON ad-hoc e a complexidade da linguagem Nix. \xC9 projetada para ser simples o suficiente para autores de configura\xE7\xE3o e expressiva o suficiente para autores de bibliotecas.\n\nNickel inclui tipagem gradual com contratos \u2014 tipos de refinamento verificados em tempo de execu\xE7\xE3o que podem expressar invariantes. Quando um contrato \xE9 violado, o Nickel fornece rastreamento preciso de responsabilidade. Suporta avalia\xE7\xE3o pregui\xE7osa e um operador de mesclagem de registros."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/nim.ts
 var nim_exports = {};
 __export(nim_exports, {
@@ -6810,6 +7280,65 @@ var init_pine_script = __esm({
   }
 });
 
+// src/languages/pkl.ts
+var pkl_exports = {};
+__export(pkl_exports, {
+  pkl: () => pkl
+});
+var pkl;
+var init_pkl = __esm({
+  "src/languages/pkl.ts"() {
+    pkl = {
+      slug: "pkl",
+      publishedDate: "2024-02-01",
+      extensions: [".pkl"],
+      author: "Apple",
+      website: "https://pkl-lang.org",
+      paradigms: ["declarative", "functional"],
+      tooling: {
+        runtimes: ["pkl CLI", "GraalVM native image"],
+        packageManagers: ["pkl package"],
+        ecosystems: ["Configuration", "Infrastructure", "Cloud", "Kubernetes"]
+      },
+      version: "0.28.2",
+      logo: "https://avatars.githubusercontent.com/u/10639145?v=4",
+      color: "#72AE44",
+      i18n: {
+        en: {
+          name: "Pkl",
+          description: "Apple's programmable configuration language that brings type safety, validation, and code generation to structured configuration files.",
+          longDescription: "Pkl (pronounced 'Pickle') is a configuration language created by Apple and open-sourced in 2024. It is designed to replace ad-hoc YAML, JSON, and TOML configurations with a language that provides type safety, validation, reuse through inheritance, and multi-format output.\n\nPkl files can be evaluated to generate JSON, YAML, TOML, or Java properties output. It features a class-based module system, expressive templates, first-class functions, and built-in support for rendering configuration for Kubernetes, Terraform, and other cloud infrastructure tools. The CLI tool and native libraries are available for multiple languages."
+        },
+        es: {
+          name: "Pkl",
+          description: "El lenguaje de configuraci\xF3n programable de Apple que aporta seguridad de tipos, validaci\xF3n y generaci\xF3n de c\xF3digo a los archivos de configuraci\xF3n.",
+          longDescription: "Pkl (pronunciado 'Pickle') es un lenguaje de configuraci\xF3n creado por Apple y publicado como c\xF3digo abierto en 2024. Est\xE1 dise\xF1ado para reemplazar configuraciones ad-hoc de YAML, JSON y TOML con un lenguaje que ofrece seguridad de tipos, validaci\xF3n, reutilizaci\xF3n por herencia y salida en m\xFAltiples formatos.\n\nLos archivos Pkl pueden evaluarse para generar JSON, YAML, TOML o propiedades Java. Incluye un sistema de m\xF3dulos basado en clases, plantillas expresivas y soporte para Kubernetes, Terraform y otras herramientas de infraestructura."
+        },
+        it: {
+          name: "Pkl",
+          description: "Il linguaggio di configurazione programmabile di Apple che porta type safety, validazione e generazione di codice ai file di configurazione strutturati.",
+          longDescription: "Pkl (pronunciato 'Pickle') \xE8 un linguaggio di configurazione creato da Apple e reso open source nel 2024. \xC8 progettato per sostituire le configurazioni ad-hoc di YAML, JSON e TOML con un linguaggio che offre type safety, validazione, riutilizzo tramite ereditariet\xE0 e output in pi\xF9 formati.\n\nI file Pkl possono essere valutati per generare JSON, YAML, TOML o propriet\xE0 Java. Include un sistema di moduli basato su classi, template espressivi e supporto per Kubernetes, Terraform e altri strumenti di infrastruttura cloud."
+        },
+        fr: {
+          name: "Pkl",
+          description: "Le langage de configuration programmable d'Apple qui apporte la s\xFBret\xE9 de type, la validation et la g\xE9n\xE9ration de code aux fichiers de configuration structur\xE9s.",
+          longDescription: "Pkl (prononc\xE9 'Pickle') est un langage de configuration cr\xE9\xE9 par Apple et publi\xE9 en open source en 2024. Il est con\xE7u pour remplacer les configurations YAML, JSON et TOML ad-hoc par un langage offrant la s\xFBret\xE9 de type, la validation, la r\xE9utilisation par h\xE9ritage et la sortie en plusieurs formats.\n\nLes fichiers Pkl peuvent \xEAtre \xE9valu\xE9s pour g\xE9n\xE9rer du JSON, YAML, TOML ou des propri\xE9t\xE9s Java. Il comprend un syst\xE8me de modules bas\xE9 sur des classes, des templates expressifs et un support pour Kubernetes, Terraform et d'autres outils d'infrastructure cloud."
+        },
+        de: {
+          name: "Pkl",
+          description: "Apples programmierbare Konfigurationssprache, die Typsicherheit, Validierung und Code-Generierung in strukturierte Konfigurationsdateien bringt.",
+          longDescription: "Pkl (ausgesprochen 'Pickle') ist eine von Apple entwickelte Konfigurationssprache, die 2024 als Open Source ver\xF6ffentlicht wurde. Sie soll ad-hoc YAML-, JSON- und TOML-Konfigurationen durch eine Sprache ersetzen, die Typsicherheit, Validierung, Wiederverwendung durch Vererbung und Ausgabe in mehreren Formaten bietet.\n\nPkl-Dateien k\xF6nnen ausgewertet werden, um JSON, YAML, TOML oder Java-Properties zu generieren. Es umfasst ein klassenbasiertes Modulsystem, ausdrucksstarke Templates und Unterst\xFCtzung f\xFCr Kubernetes, Terraform und andere Cloud-Infrastruktur-Tools."
+        },
+        pt: {
+          name: "Pkl",
+          description: "A linguagem de configura\xE7\xE3o program\xE1vel da Apple que traz seguran\xE7a de tipos, valida\xE7\xE3o e gera\xE7\xE3o de c\xF3digo para arquivos de configura\xE7\xE3o estruturados.",
+          longDescription: "Pkl (pronunciado 'Pickle') \xE9 uma linguagem de configura\xE7\xE3o criada pela Apple e publicada como c\xF3digo aberto em 2024. Foi projetada para substituir configura\xE7\xF5es ad-hoc de YAML, JSON e TOML por uma linguagem que oferece seguran\xE7a de tipos, valida\xE7\xE3o, reutiliza\xE7\xE3o por heran\xE7a e sa\xEDda em m\xFAltiplos formatos.\n\nArquivos Pkl podem ser avaliados para gerar JSON, YAML, TOML ou propriedades Java. Inclui um sistema de m\xF3dulos baseado em classes, templates expressivos e suporte para Kubernetes, Terraform e outras ferramentas de infraestrutura cloud."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/plantuml.ts
 var plantuml_exports = {};
 __export(plantuml_exports, {
@@ -9562,6 +10091,65 @@ var init_typst = __esm({
   }
 });
 
+// src/languages/unison.ts
+var unison_exports = {};
+__export(unison_exports, {
+  unison: () => unison
+});
+var unison;
+var init_unison = __esm({
+  "src/languages/unison.ts"() {
+    unison = {
+      slug: "unison",
+      publishedDate: "2019-10-04",
+      extensions: [".u", ".uu"],
+      author: "Paul Chiusano, R\xFAnar Bjarnason",
+      website: "https://www.unison-lang.org",
+      paradigms: ["functional", "distributed"],
+      tooling: {
+        runtimes: ["Unison runtime (UCM)"],
+        packageManagers: ["Unison Share"],
+        ecosystems: ["Distributed Systems", "Cloud", "Functional"]
+      },
+      version: "0.5.28",
+      logo: "https://avatars.githubusercontent.com/u/18563978?v=4",
+      color: "#F37B1F",
+      i18n: {
+        en: {
+          name: "Unison",
+          description: "A functional programming language where code is content-addressed by hash, eliminating dependency conflicts and enabling seamless distributed computing.",
+          longDescription: "Unison is a programming language with a radically different approach to code storage and distribution. Instead of storing code as text files, Unison stores definitions by their content hash \u2014 a definition's identity is its content, not its name or location. This eliminates package versioning conflicts and enables a novel form of distributed programming.\n\nUnison's distributed abilities are built into the type system: functions can be serialized and sent to remote nodes where they execute with their full closure. The language is purely functional with algebraic effects, a strong type system with type inference, and first-class abilities (algebraic effects). Code is managed through the Unison Codebase Manager (UCM), and libraries are shared via Unison Share."
+        },
+        es: {
+          name: "Unison",
+          description: "Lenguaje funcional donde el c\xF3digo se almacena por hash de contenido, eliminando conflictos de dependencias y habilitando computaci\xF3n distribuida.",
+          longDescription: "Unison es un lenguaje de programaci\xF3n con un enfoque radicalmente diferente al almacenamiento y distribuci\xF3n de c\xF3digo. En lugar de archivos de texto, Unison almacena definiciones por su hash de contenido. Esto elimina los conflictos de versiones de paquetes y habilita una nueva forma de programaci\xF3n distribuida.\n\nLas capacidades distribuidas de Unison est\xE1n integradas en el sistema de tipos: las funciones pueden serializarse y enviarse a nodos remotos donde se ejecutan con todo su closure. El lenguaje es puramente funcional con efectos algebraicos y un sistema de tipos fuerte con inferencia de tipos."
+        },
+        it: {
+          name: "Unison",
+          description: "Linguaggio funzionale dove il codice \xE8 indirizzato per contenuto tramite hash, eliminando i conflitti di dipendenze e abilitando il calcolo distribuito.",
+          longDescription: "Unison \xE8 un linguaggio di programmazione con un approccio radicalmente diverso all'archiviazione e distribuzione del codice. Invece di file di testo, Unison archivia le definizioni tramite il loro hash di contenuto. Questo elimina i conflitti di versioni dei pacchetti e abilita una nuova forma di programmazione distribuita.\n\nLe capacit\xE0 distribuite di Unison sono integrate nel sistema di tipi: le funzioni possono essere serializzate e inviate a nodi remoti dove vengono eseguite con la loro closure completa. Il linguaggio \xE8 puramente funzionale con effetti algebrici e un sistema di tipi forte."
+        },
+        fr: {
+          name: "Unison",
+          description: "Un langage de programmation fonctionnel o\xF9 le code est adress\xE9 par contenu via un hash, \xE9liminant les conflits de d\xE9pendances et permettant le calcul distribu\xE9.",
+          longDescription: "Unison est un langage de programmation avec une approche radicalement diff\xE9rente du stockage et de la distribution du code. Au lieu de fichiers texte, Unison stocke les d\xE9finitions par leur hash de contenu. Cela \xE9limine les conflits de versions de paquets et permet une nouvelle forme de programmation distribu\xE9e.\n\nLes capacit\xE9s distribu\xE9es d'Unison sont int\xE9gr\xE9es dans le syst\xE8me de types: les fonctions peuvent \xEAtre s\xE9rialis\xE9es et envoy\xE9es \xE0 des n\u0153uds distants o\xF9 elles s'ex\xE9cutent avec leur closure compl\xE8te. Le langage est purement fonctionnel avec des effets alg\xE9briques."
+        },
+        de: {
+          name: "Unison",
+          description: "Funktionale Programmiersprache, bei der Code per Hash inhaltsadressiert ist, Abh\xE4ngigkeitskonflikte eliminiert und verteilte Berechnung erm\xF6glicht.",
+          longDescription: "Unison ist eine Programmiersprache mit einem radikal anderen Ansatz zur Code-Speicherung und -Verteilung. Statt Textdateien speichert Unison Definitionen durch ihren Inhalts-Hash. Dies eliminiert Paketversionskonflikte und erm\xF6glicht eine neue Form des verteilten Programmierens.\n\nUnisons verteilte F\xE4higkeiten sind in das Typsystem integriert: Funktionen k\xF6nnen serialisiert und an entfernte Knoten gesendet werden, wo sie mit ihrer vollst\xE4ndigen Closure ausgef\xFChrt werden. Die Sprache ist rein funktional mit algebraischen Effekten."
+        },
+        pt: {
+          name: "Unison",
+          description: "Linguagem funcional onde o c\xF3digo \xE9 endere\xE7ado por hash de conte\xFAdo, eliminando conflitos de depend\xEAncias e permitindo computa\xE7\xE3o distribu\xEDda.",
+          longDescription: "Unison \xE9 uma linguagem de programa\xE7\xE3o com uma abordagem radicalmente diferente para armazenamento e distribui\xE7\xE3o de c\xF3digo. Em vez de arquivos de texto, o Unison armazena defini\xE7\xF5es pelo seu hash de conte\xFAdo. Isso elimina conflitos de vers\xE3o de pacotes e permite uma nova forma de programa\xE7\xE3o distribu\xEDda.\n\nAs capacidades distribu\xEDdas do Unison est\xE3o integradas no sistema de tipos: fun\xE7\xF5es podem ser serializadas e enviadas para n\xF3s remotos onde s\xE3o executadas com todo o seu closure. A linguagem \xE9 puramente funcional com efeitos alg\xE9bricos e um sistema de tipos forte."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/v.ts
 var v_exports = {};
 __export(v_exports, {
@@ -10435,6 +11023,65 @@ var init_yaml = __esm({
   }
 });
 
+// src/languages/yara.ts
+var yara_exports = {};
+__export(yara_exports, {
+  yara: () => yara
+});
+var yara;
+var init_yara = __esm({
+  "src/languages/yara.ts"() {
+    yara = {
+      slug: "yara",
+      publishedDate: "2008-05-01",
+      extensions: [".yar", ".yara"],
+      author: "Victor M. Alvarez",
+      website: "https://virustotal.github.io/yara/",
+      paradigms: ["declarative", "pattern-matching"],
+      tooling: {
+        runtimes: ["yara", "yara-python", "libyara"],
+        packageManagers: ["pip (yara-python)"],
+        ecosystems: ["Security", "Malware Analysis", "Threat Intelligence", "Forensics"]
+      },
+      version: "4.5.2",
+      logo: "https://avatars.githubusercontent.com/u/6306898?v=4",
+      color: "#C62D42",
+      i18n: {
+        en: {
+          name: "YARA",
+          description: "A pattern-matching language for identifying and classifying malware samples based on textual and binary patterns, widely used in threat intelligence.",
+          longDescription: "YARA (Yet Another Recursive Acronym) is a tool and rule language designed by Victor M. Alvarez at VirusTotal for identifying and classifying malware based on patterns found in files and processes. A YARA rule combines textual strings, byte patterns, and Boolean logic to describe families of malware.\n\nYARA rules are used extensively in antivirus products, security operations centers, incident response, and threat hunting. Each rule has a set of strings \u2014 hexadecimal sequences, text strings, or regular expressions \u2014 and a condition that must be satisfied for the rule to match. YARA runs as a standalone tool, as a Python library (yara-python), and is integrated into platforms like VirusTotal, MISP, Cuckoo Sandbox, and many SIEM systems."
+        },
+        es: {
+          name: "YARA",
+          description: "Lenguaje de coincidencia de patrones para identificar muestras de malware por patrones textuales y binarios, ampliamente usado en inteligencia de amenazas.",
+          longDescription: "YARA es una herramienta y lenguaje de reglas dise\xF1ado por Victor M. Alvarez en VirusTotal para identificar y clasificar malware bas\xE1ndose en patrones encontrados en archivos y procesos. Una regla YARA combina cadenas de texto, patrones de bytes y l\xF3gica booleana para describir familias de malware.\n\nLas reglas YARA se usan ampliamente en antivirus, centros de operaciones de seguridad, respuesta a incidentes y b\xFAsqueda de amenazas. Cada regla tiene un conjunto de cadenas \u2014 secuencias hexadecimales, texto o expresiones regulares \u2014 y una condici\xF3n que debe cumplirse."
+        },
+        it: {
+          name: "YARA",
+          description: "Linguaggio di pattern matching per identificare campioni di malware su pattern testuali e binari, ampiamente usato nell'intelligence sulle minacce.",
+          longDescription: "YARA \xE8 uno strumento e un linguaggio di regole progettato da Victor M. Alvarez presso VirusTotal per identificare e classificare malware basandosi su pattern trovati in file e processi. Una regola YARA combina stringhe testuali, pattern di byte e logica booleana per descrivere famiglie di malware.\n\nLe regole YARA sono ampiamente utilizzate in antivirus, SOC, risposta agli incidenti e threat hunting. Ogni regola ha un insieme di stringhe \u2014 sequenze esadecimali, testo o espressioni regolari \u2014 e una condizione che deve essere soddisfatta."
+        },
+        fr: {
+          name: "YARA",
+          description: "Langage de correspondance de motifs pour identifier des \xE9chantillons de malware par motifs textuels et binaires, utilis\xE9 en renseignement sur les menaces.",
+          longDescription: "YARA est un outil et un langage de r\xE8gles con\xE7u par Victor M. Alvarez chez VirusTotal pour identifier et classifier les malwares en fonction de motifs trouv\xE9s dans des fichiers et des processus. Une r\xE8gle YARA combine des cha\xEEnes textuelles, des motifs d'octets et une logique bool\xE9enne pour d\xE9crire des familles de malwares.\n\nLes r\xE8gles YARA sont largement utilis\xE9es dans les antivirus, les SOC, la r\xE9ponse aux incidents et la chasse aux menaces. Chaque r\xE8gle contient un ensemble de cha\xEEnes et une condition qui doit \xEAtre satisfaite."
+        },
+        de: {
+          name: "YARA",
+          description: "Pattern-Matching-Sprache zur Identifizierung von Malware-Proben anhand textueller und bin\xE4rer Muster, weit verbreitet in der Bedrohungsanalyse.",
+          longDescription: "YARA ist ein Tool und eine Regelsprache, die von Victor M. Alvarez bei VirusTotal entwickelt wurde, um Malware anhand von Mustern in Dateien und Prozessen zu identifizieren und zu klassifizieren. Eine YARA-Regel kombiniert Textstrings, Byte-Muster und boolesche Logik, um Malware-Familien zu beschreiben.\n\nYARA-Regeln werden in Antivirenprodukten, Security Operations Centers, Incident Response und Threat Hunting eingesetzt. Jede Regel hat Strings \u2014 hexadezimale Sequenzen, Textstrings oder regul\xE4re Ausdr\xFCcke \u2014 und eine Bedingung."
+        },
+        pt: {
+          name: "YARA",
+          description: "Linguagem de correspond\xEAncia de padr\xF5es para identificar amostras de malware por padr\xF5es textuais e bin\xE1rios, amplamente usada em intelig\xEAncia de amea\xE7as.",
+          longDescription: "YARA \xE9 uma ferramenta e linguagem de regras projetada por Victor M. Alvarez na VirusTotal para identificar e classificar malware com base em padr\xF5es encontrados em arquivos e processos. Uma regra YARA combina strings de texto, padr\xF5es de bytes e l\xF3gica booleana para descrever fam\xEDlias de malware.\n\nAs regras YARA s\xE3o amplamente usadas em antiv\xEDrus, centros de opera\xE7\xF5es de seguran\xE7a, resposta a incidentes e ca\xE7a a amea\xE7as. Cada regra tem um conjunto de strings \u2014 sequ\xEAncias hexadecimais, texto ou express\xF5es regulares \u2014 e uma condi\xE7\xE3o que deve ser satisfeita."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/zeek.ts
 var zeek_exports = {};
 __export(zeek_exports, {
@@ -10693,6 +11340,7 @@ init_bazel();
 init_bicep();
 init_blade();
 init_c();
+init_cairo();
 init_carbon();
 init_chapel();
 init_circom();
@@ -10723,6 +11371,7 @@ init_erb();
 init_erlang();
 init_fennel();
 init_fish();
+init_flux();
 init_forth();
 init_fortran();
 init_fsharp();
@@ -10732,17 +11381,20 @@ init_gleam();
 init_glsl();
 init_go();
 init_gradle();
+init_grain();
 init_graphql();
 init_groovy();
 init_hack();
 init_haml();
 init_handlebars();
+init_hare();
 init_haskell();
 init_haxe();
 init_hcl();
 init_hlsl();
 init_hocon();
 init_html();
+init_hy();
 init_idris();
 init_ini();
 init_janet();
@@ -10754,6 +11406,7 @@ init_json5();
 init_jsonnet();
 init_julia();
 init_jupyter_notebook();
+init_kcl();
 init_kotlin();
 init_lean();
 init_less();
@@ -10773,8 +11426,10 @@ init_meson();
 init_metal();
 init_mojo();
 init_moonbit();
+init_move();
 init_mustache();
 init_nginx();
+init_nickel();
 init_nim();
 init_nix();
 init_nunjucks();
@@ -10787,6 +11442,7 @@ init_pascal();
 init_perl();
 init_php();
 init_pine_script();
+init_pkl();
 init_plantuml();
 init_plsql();
 init_pony();
@@ -10834,6 +11490,7 @@ init_toml();
 init_twig();
 init_typescript();
 init_typst();
+init_unison();
 init_v();
 init_vala();
 init_verilog();
@@ -10849,6 +11506,7 @@ init_xml();
 init_xquery();
 init_xslt();
 init_yaml();
+init_yara();
 init_zeek();
 init_zig();
 init_ziggy();
@@ -10876,6 +11534,7 @@ var languages = [
   bicep,
   blade,
   c,
+  cairo,
   carbon,
   chapel,
   circom,
@@ -10906,6 +11565,7 @@ var languages = [
   erlang,
   fish,
   fennel,
+  flux,
   fortran,
   forth,
   fsharp,
@@ -10913,6 +11573,7 @@ var languages = [
   git,
   gleam,
   go,
+  grain,
   gradle,
   glsl,
   graphql,
@@ -10920,12 +11581,14 @@ var languages = [
   handlebars,
   hack,
   haml,
+  hare,
   hocon,
   haskell,
   haxe,
   hcl,
   hlsl,
   html,
+  hy,
   idris,
   ini,
   java,
@@ -10937,6 +11600,7 @@ var languages = [
   jsonnet,
   jupyterNotebook,
   julia,
+  kcl,
   kotlin,
   lean,
   less,
@@ -10955,10 +11619,12 @@ var languages = [
   meson,
   metal,
   mustache,
+  move,
   mojo,
   moonbit,
   svn,
   nginx,
+  nickel,
   nunjucks,
   nushell,
   nim,
@@ -10968,6 +11634,7 @@ var languages = [
   odin,
   opencl,
   pascal,
+  pkl,
   perl,
   php,
   pineScript,
@@ -11017,6 +11684,7 @@ var languages = [
   twig,
   typescript,
   typst,
+  unison,
   v,
   vala,
   verilog,
@@ -11032,64 +11700,13 @@ var languages = [
   xquery,
   xslt,
   yaml,
+  yara,
   zeek,
   zig,
   ziggy,
   zsh
 ];
 
-// src/match.ts
-var pathSegmentPattern = /[/\\]/;
-var getBasename = (filename) => filename.trim().split(pathSegmentPattern).at(-1)?.toLowerCase() ?? "";
-var matchesExtension = (basename, extension) => {
-  const normalizedExtension = extension.toLowerCase();
-  if (normalizedExtension.startsWith(".")) {
-    return basename.endsWith(normalizedExtension);
-  }
-  return basename === normalizedExtension || basename.endsWith(`.${normalizedExtension}`);
-};
-var detectMatchingEntries = (entries, filename) => {
-  const basename = getBasename(filename);
-  if (!basename) {
-    return [];
-  }
-  return entries.filter(
-    (entry) => entry.extensions.some((extension) => matchesExtension(basename, extension))
-  );
-};
-
-// src/detect.ts
-var detectLanguages = (filename) => {
-  return detectMatchingEntries(languages, filename);
-};
-var detectLanguage = (filename) => detectLanguages(filename).at(0);
-
-// src/i18n.ts
-var localizeLanguage = (language, locale = "en") => {
-  const { i18n, ...metadata } = language;
-  const resolvedLocale = resolveLocale(i18n, locale);
-  const content = i18n[resolvedLocale] ?? i18n.en;
-  return {
-    ...metadata,
-    ...content,
-    locale,
-    resolvedLocale,
-    availableLocales: Object.keys(i18n)
-  };
-};
-var resolveLocale = (translations, locale) => {
-  const normalizedLocale = locale.toLowerCase();
-  const exactLocale = normalizedLocale;
-  if (translations[exactLocale]) {
-    return exactLocale;
-  }
-  const baseLocale = normalizedLocale.split("-")[0];
-  if (translations[baseLocale]) {
-    return baseLocale;
-  }
-  return "en";
-};
-
 // src/language-registry.ts
 var languageIndex = [
   { slug: "abap", extensions: [".abap"] },
@@ -11120,6 +11737,7 @@ var languageIndex = [
   { slug: "bicep", extensions: [".bicep", ".bicepparam"] },
   { slug: "blade", extensions: [".blade.php"] },
   { slug: "c", extensions: [".c", ".h"] },
+  { slug: "cairo", extensions: [".cairo"] },
   { slug: "carbon", extensions: [".carbon"] },
   { slug: "chapel", extensions: [".chpl"] },
   { slug: "circom", extensions: [".circom"] },
@@ -11153,6 +11771,7 @@ var languageIndex = [
   },
   { slug: "fish", extensions: [".fish"] },
   { slug: "fennel", extensions: [".fnl"] },
+  { slug: "flux", extensions: [".flux"] },
   {
     slug: "fortran",
     extensions: [".f", ".for", ".ftn", ".f90", ".f95", ".f03", ".f08", ".f18", ".f23"]
@@ -11163,6 +11782,7 @@ var languageIndex = [
   { slug: "git", extensions: [".git", ".gitignore", ".gitattributes", ".gitmodules", ".gitkeep"] },
   { slug: "gleam", extensions: [".gleam"] },
   { slug: "go", extensions: [".go"] },
+  { slug: "grain", extensions: [".gr"] },
   { slug: "gradle", extensions: [".gradle", ".gradle.kts"] },
   {
     slug: "glsl",
@@ -11173,12 +11793,14 @@ var languageIndex = [
   { slug: "handlebars", extensions: [".hbs", ".handlebars"] },
   { slug: "hack", extensions: [".hack", ".hh", ".hhi"] },
   { slug: "haml", extensions: [".haml"] },
+  { slug: "hare", extensions: [".ha"] },
   { slug: "hocon", extensions: [".hocon"] },
   { slug: "haskell", extensions: [".hs", ".lhs", ".hsc", ".hs-boot", ".hsig", ".cabal"] },
   { slug: "haxe", extensions: [".hx", ".hxml"] },
   { slug: "hcl", extensions: [".hcl", ".tf", ".tfvars", ".pkr.hcl", ".nomad"] },
   { slug: "hlsl", extensions: [".hlsl", ".fx", ".fxh", ".hlsli"] },
   { slug: "html", extensions: [".html", ".htm"] },
+  { slug: "hy", extensions: [".hy"] },
   { slug: "idris", extensions: [".idr", ".lidr", ".ipkg"] },
   { slug: "ini", extensions: [".ini"] },
   { slug: "java", extensions: [".java"] },
@@ -11190,6 +11812,7 @@ var languageIndex = [
   { slug: "jsonnet", extensions: [".jsonnet", ".libsonnet"] },
   { slug: "jupyter-notebook", extensions: [".ipynb"] },
   { slug: "julia", extensions: [".jl"] },
+  { slug: "kcl", extensions: [".k", ".kcl"] },
   { slug: "kotlin", extensions: [".kt", ".kts"] },
   { slug: "lean", extensions: [".lean"] },
   { slug: "less", extensions: [".less"] },
@@ -11208,10 +11831,12 @@ var languageIndex = [
   { slug: "meson", extensions: ["meson.build", "meson_options.txt", "meson.options", ".wrap"] },
   { slug: "metal", extensions: [".metal"] },
   { slug: "mustache", extensions: [".mustache", ".mst"] },
+  { slug: "move", extensions: [".move"] },
   { slug: "mojo", extensions: [".mojo"] },
   { slug: "moonbit", extensions: [".mbt"] },
   { slug: "svn", extensions: [".svn", "svnserve.conf"] },
   { slug: "nginx", extensions: ["nginx.conf", ".nginx", ".conf"] },
+  { slug: "nickel", extensions: [".ncl"] },
   { slug: "nunjucks", extensions: [".njk", ".nunjucks"] },
   { slug: "nushell", extensions: [".nu"] },
   { slug: "nim", extensions: [".nim", ".nims", ".nimble"] },
@@ -11221,6 +11846,7 @@ var languageIndex = [
   { slug: "odin", extensions: [".odin"] },
   { slug: "opencl", extensions: [".cl", ".clh"] },
   { slug: "pascal", extensions: [".pas", ".pp", ".inc", ".lpr", ".dpr", ".dfm"] },
+  { slug: "pkl", extensions: [".pkl"] },
   { slug: "perl", extensions: [".pl", ".pm", ".pod", ".t", ".psgi"] },
   { slug: "php", extensions: [".php", ".phtml", ".php3", ".php4", ".php5", ".phps"] },
   { slug: "pine-script", extensions: [".pine"] },
@@ -11273,6 +11899,7 @@ var languageIndex = [
   { slug: "twig", extensions: [".twig"] },
   { slug: "typescript", extensions: [".ts", ".tsx", ".mts", ".cts"] },
   { slug: "typst", extensions: [".typ"] },
+  { slug: "unison", extensions: [".u", ".uu"] },
   { slug: "v", extensions: [".v", ".vsh"] },
   { slug: "vala", extensions: [".vala", ".vapi"] },
   { slug: "verilog", extensions: [".v", ".vh", ".sv", ".svh"] },
@@ -11288,6 +11915,7 @@ var languageIndex = [
   { slug: "xquery", extensions: [".xq", ".xql", ".xqm", ".xquery", ".xqy"] },
   { slug: "xslt", extensions: [".xsl", ".xslt"] },
   { slug: "yaml", extensions: [".yaml", ".yml"] },
+  { slug: "yara", extensions: [".yar", ".yara"] },
   { slug: "zeek", extensions: [".zeek", ".bro"] },
   { slug: "zig", extensions: [".zig", ".zon"] },
   { slug: "ziggy", extensions: [".ziggy", ".ziggy-schema"] },
@@ -11319,6 +11947,7 @@ var languageLoaders = {
   bicep: () => Promise.resolve().then(() => (init_bicep(), bicep_exports)).then((module) => module.bicep),
   blade: () => Promise.resolve().then(() => (init_blade(), blade_exports)).then((module) => module.blade),
   c: () => Promise.resolve().then(() => (init_c(), c_exports)).then((module) => module.c),
+  cairo: () => Promise.resolve().then(() => (init_cairo(), cairo_exports)).then((module) => module.cairo),
   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),
@@ -11348,6 +11977,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),
   fish: () => Promise.resolve().then(() => (init_fish(), fish_exports)).then((module) => module.fish),
+  flux: () => Promise.resolve().then(() => (init_flux(), flux_exports)).then((module) => module.flux),
   fennel: () => Promise.resolve().then(() => (init_fennel(), fennel_exports)).then((module) => module.fennel),
   fortran: () => Promise.resolve().then(() => (init_fortran(), fortran_exports)).then((module) => module.fortran),
   forth: () => Promise.resolve().then(() => (init_forth(), forth_exports)).then((module) => module.forth),
@@ -11356,6 +11986,7 @@ var languageLoaders = {
   git: () => Promise.resolve().then(() => (init_git(), git_exports)).then((module) => module.git),
   gleam: () => Promise.resolve().then(() => (init_gleam(), gleam_exports)).then((module) => module.gleam),
   go: () => Promise.resolve().then(() => (init_go(), go_exports)).then((module) => module.go),
+  grain: () => Promise.resolve().then(() => (init_grain(), grain_exports)).then((module) => module.grain),
   gradle: () => Promise.resolve().then(() => (init_gradle(), gradle_exports)).then((module) => module.gradle),
   glsl: () => Promise.resolve().then(() => (init_glsl(), glsl_exports)).then((module) => module.glsl),
   graphql: () => Promise.resolve().then(() => (init_graphql(), graphql_exports)).then((module) => module.graphql),
@@ -11363,12 +11994,14 @@ var languageLoaders = {
   handlebars: () => Promise.resolve().then(() => (init_handlebars(), handlebars_exports)).then((module) => module.handlebars),
   hack: () => Promise.resolve().then(() => (init_hack(), hack_exports)).then((module) => module.hack),
   haml: () => Promise.resolve().then(() => (init_haml(), haml_exports)).then((module) => module.haml),
+  hare: () => Promise.resolve().then(() => (init_hare(), hare_exports)).then((module) => module.hare),
   hocon: () => Promise.resolve().then(() => (init_hocon(), hocon_exports)).then((module) => module.hocon),
   haskell: () => Promise.resolve().then(() => (init_haskell(), haskell_exports)).then((module) => module.haskell),
   haxe: () => Promise.resolve().then(() => (init_haxe(), haxe_exports)).then((module) => module.haxe),
   hcl: () => Promise.resolve().then(() => (init_hcl(), hcl_exports)).then((module) => module.hcl),
   hlsl: () => Promise.resolve().then(() => (init_hlsl(), hlsl_exports)).then((module) => module.hlsl),
   html: () => Promise.resolve().then(() => (init_html(), html_exports)).then((module) => module.html),
+  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),
   java: () => Promise.resolve().then(() => (init_java(), java_exports)).then((module) => module.java),
@@ -11380,6 +12013,7 @@ var languageLoaders = {
   jsonnet: () => Promise.resolve().then(() => (init_jsonnet(), jsonnet_exports)).then((module) => module.jsonnet),
   "jupyter-notebook": () => Promise.resolve().then(() => (init_jupyter_notebook(), jupyter_notebook_exports)).then((module) => module.jupyterNotebook),
   julia: () => Promise.resolve().then(() => (init_julia(), julia_exports)).then((module) => module.julia),
+  kcl: () => Promise.resolve().then(() => (init_kcl(), kcl_exports)).then((module) => module.kcl),
   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),
@@ -11400,8 +12034,10 @@ var languageLoaders = {
   mustache: () => Promise.resolve().then(() => (init_mustache(), mustache_exports)).then((module) => module.mustache),
   mojo: () => Promise.resolve().then(() => (init_mojo(), mojo_exports)).then((module) => module.mojo),
   moonbit: () => Promise.resolve().then(() => (init_moonbit(), moonbit_exports)).then((module) => module.moonbit),
+  move: () => Promise.resolve().then(() => (init_move(), move_exports)).then((module) => module.move),
   svn: () => Promise.resolve().then(() => (init_svn(), svn_exports)).then((module) => module.svn),
   nginx: () => Promise.resolve().then(() => (init_nginx(), nginx_exports)).then((module) => module.nginx),
+  nickel: () => Promise.resolve().then(() => (init_nickel(), nickel_exports)).then((module) => module.nickel),
   nunjucks: () => Promise.resolve().then(() => (init_nunjucks(), nunjucks_exports)).then((module) => module.nunjucks),
   nushell: () => Promise.resolve().then(() => (init_nushell(), nushell_exports)).then((module) => module.nushell),
   nim: () => Promise.resolve().then(() => (init_nim(), nim_exports)).then((module) => module.nim),
@@ -11411,6 +12047,7 @@ var languageLoaders = {
   odin: () => Promise.resolve().then(() => (init_odin(), odin_exports)).then((module) => module.odin),
   opencl: () => Promise.resolve().then(() => (init_opencl(), opencl_exports)).then((module) => module.opencl),
   pascal: () => Promise.resolve().then(() => (init_pascal(), pascal_exports)).then((module) => module.pascal),
+  pkl: () => Promise.resolve().then(() => (init_pkl(), pkl_exports)).then((module) => module.pkl),
   perl: () => Promise.resolve().then(() => (init_perl(), perl_exports)).then((module) => module.perl),
   php: () => Promise.resolve().then(() => (init_php(), php_exports)).then((module) => module.php),
   "pine-script": () => Promise.resolve().then(() => (init_pine_script(), pine_script_exports)).then((module) => module.pineScript),
@@ -11460,6 +12097,7 @@ var languageLoaders = {
   twig: () => Promise.resolve().then(() => (init_twig(), twig_exports)).then((module) => module.twig),
   typescript: () => Promise.resolve().then(() => (init_typescript(), typescript_exports)).then((module) => module.typescript),
   typst: () => Promise.resolve().then(() => (init_typst(), typst_exports)).then((module) => module.typst),
+  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),
   verilog: () => Promise.resolve().then(() => (init_verilog(), verilog_exports)).then((module) => module.verilog),
@@ -11474,6 +12112,7 @@ var languageLoaders = {
   xml: () => Promise.resolve().then(() => (init_xml(), xml_exports)).then((module) => module.xml),
   xquery: () => Promise.resolve().then(() => (init_xquery(), xquery_exports)).then((module) => module.xquery),
   xslt: () => Promise.resolve().then(() => (init_xslt(), xslt_exports)).then((module) => module.xslt),
+  yara: () => Promise.resolve().then(() => (init_yara(), yara_exports)).then((module) => module.yara),
   yaml: () => Promise.resolve().then(() => (init_yaml(), yaml_exports)).then((module) => module.yaml),
   zeek: () => Promise.resolve().then(() => (init_zeek(), zeek_exports)).then((module) => module.zeek),
   zig: () => Promise.resolve().then(() => (init_zig(), zig_exports)).then((module) => module.zig),
@@ -11482,6 +12121,56 @@ var languageLoaders = {
 };
 var loadLanguage = (slug) => languageLoaders[slug]?.();
 
+// src/match.ts
+var pathSegmentPattern = /[/\\]/;
+var getBasename = (filename) => filename.trim().split(pathSegmentPattern).at(-1)?.toLowerCase() ?? "";
+var matchesExtension = (basename, extension) => {
+  const normalizedExtension = extension.toLowerCase();
+  if (normalizedExtension.startsWith(".")) {
+    return basename.endsWith(normalizedExtension);
+  }
+  return basename === normalizedExtension || basename.endsWith(`.${normalizedExtension}`);
+};
+var detectMatchingEntries = (entries, filename) => {
+  const basename = getBasename(filename);
+  if (!basename) {
+    return [];
+  }
+  return entries.filter(
+    (entry) => entry.extensions.some((extension) => matchesExtension(basename, extension))
+  );
+};
+
+// src/detect-slugs.ts
+var detectLanguageSlugs = (filename) => detectMatchingEntries(languageIndex, filename).map((entry) => entry.slug);
+var detectLanguageSlug = (filename) => detectLanguageSlugs(filename).at(0);
+
+// src/i18n.ts
+var localizeLanguage = (language, locale = "en") => {
+  const { i18n, ...metadata } = language;
+  const resolvedLocale = resolveLocale(i18n, locale);
+  const content = i18n[resolvedLocale] ?? i18n.en;
+  return {
+    ...metadata,
+    ...content,
+    locale,
+    resolvedLocale,
+    availableLocales: Object.keys(i18n)
+  };
+};
+var resolveLocale = (translations, locale) => {
+  const normalizedLocale = locale.toLowerCase();
+  const exactLocale = normalizedLocale;
+  if (translations[exactLocale]) {
+    return exactLocale;
+  }
+  const baseLocale = normalizedLocale.split("-")[0];
+  if (translations[baseLocale]) {
+    return baseLocale;
+  }
+  return "en";
+};
+
 // src/api.ts
 var defaultLocale = "en";
 var normalizeLanguageSlug = (slug) => slug.trim().toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
@@ -11519,11 +12208,11 @@ var createLanguageCollectionRequest = (getLanguageList, loadLanguageList) => {
   };
   return request;
 };
-var loadDetectedLanguages = (filename) => Promise.all(
-  detectMatchingEntries(languageIndex, filename).map((entry) => loadLanguage(entry.slug))
-).then(
+var loadDetectedLanguages = (filename) => Promise.all(detectLanguageSlugs(filename).map((slug) => loadLanguage(slug))).then(
   (detectedLanguages) => detectedLanguages.filter((language) => Boolean(language))
 );
+var getLanguageBySlug = (slug) => languages.find((language) => language.slug === slug);
+var getDetectedLanguages = (filename) => detectLanguageSlugs(filename).map((slug) => getLanguageBySlug(slug)).filter((language) => Boolean(language));
 var api = {
   /**
    * Selects a language by slug.
@@ -11562,7 +12251,10 @@ var api = {
    */
   detect(filename) {
     return createLanguageRequest(
-      () => detectLanguage(filename),
+      () => {
+        const slug = detectLanguageSlug(filename);
+        return slug ? getLanguageBySlug(slug) : void 0;
+      },
       async () => (await loadDetectedLanguages(filename)).at(0)
     );
   },
@@ -11573,12 +12265,10 @@ var api = {
    */
   detectAll(filename) {
     return createLanguageCollectionRequest(
-      () => detectLanguages(filename),
+      () => getDetectedLanguages(filename),
       () => loadDetectedLanguages(filename)
     );
   }
 };
 
 exports.api = api;
-//# sourceMappingURL=api.cjs.map
-//# sourceMappingURL=api.cjs.map