code-languages 1.20.6 → 1.21.0

package/dist/api.js

@@ -120,6 +120,44 @@ var init_ada = __esm({
   }
 });
 
+// src/languages/agda.ts
+var agda_exports = {};
+__export(agda_exports, {
+  agda: () => agda
+});
+var agda;
+var init_agda = __esm({
+  "src/languages/agda.ts"() {
+    agda = {
+      slug: "agda",
+      publishedDate: "2007-01-01",
+      extensions: [".agda", ".lagda", ".lagda.md", ".lagda.rst", ".lagda.tex"],
+      author: "Ulf Norell / Chalmers University of Technology",
+      website: "https://wiki.portal.chalmers.se/agda/",
+      paradigms: ["functional", "dependently typed", "total", "proof-oriented"],
+      tooling: {
+        runtimes: ["GHC", "JavaScript"],
+        packageManagers: ["Cabal", "Stack"],
+        ecosystems: ["Haskell", "Formal methods", "Proof assistants"]
+      },
+      version: "2.8.0",
+      logo: "https://cdn.jsdelivr.net/gh/vscode-icons/vscode-icons@master/icons/file_type_agda.svg",
+      i18n: {
+        en: {
+          name: "Agda",
+          description: "A dependently typed functional language and proof assistant.",
+          longDescription: "Agda is a dependently typed functional programming language and interactive proof assistant. It supports inductive families, pattern matching, modules, mixfix operators, Unicode syntax, and a type system expressive enough to encode mathematical proofs as programs.\n\nIt is used in programming language research, constructive mathematics, certified algorithms, and education where precise specifications and machine-checked proofs matter as much as executable code."
+        },
+        es: {
+          name: "Agda",
+          description: "Un lenguaje funcional con tipos dependientes y asistente de pruebas.",
+          longDescription: "Agda es un lenguaje de programacion funcional con tipos dependientes y un asistente interactivo de pruebas. Soporta familias inductivas, pattern matching, modulos, operadores mixfix, sintaxis Unicode y un sistema de tipos expresivo para codificar pruebas matematicas como programas.\n\nSe usa en investigacion de lenguajes, matematica constructiva, algoritmos certificados y educacion cuando las especificaciones precisas y las pruebas verificadas por maquina importan tanto como el codigo ejecutable."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/antlr.ts
 var antlr_exports = {};
 __export(antlr_exports, {
@@ -762,6 +800,120 @@ var init_c = __esm({
   }
 });
 
+// src/languages/carbon.ts
+var carbon_exports = {};
+__export(carbon_exports, {
+  carbon: () => carbon
+});
+var carbon;
+var init_carbon = __esm({
+  "src/languages/carbon.ts"() {
+    carbon = {
+      slug: "carbon",
+      publishedDate: "2022-07-19",
+      extensions: [".carbon"],
+      author: "Carbon Language Project",
+      website: "https://docs.carbon-lang.dev",
+      paradigms: ["imperative", "object-oriented", "generic", "statically typed"],
+      tooling: {
+        runtimes: ["LLVM"],
+        packageManagers: ["Bazel"],
+        ecosystems: ["C++", "Systems programming"]
+      },
+      version: "0.0.0 nightly",
+      logo: "https://upload.wikimedia.org/wikipedia/commons/e/e1/Carbon_logo.png",
+      i18n: {
+        en: {
+          name: "Carbon",
+          description: "An experimental successor language for C++ interoperability and migration.",
+          longDescription: "Carbon is an experimental systems programming language designed as a possible successor to C++. It focuses on readable syntax, strong generics, modern tooling, and incremental migration paths for large C++ codebases.\n\nThe project is still pre-stable, so real-world use is centered on experiments, design evaluation, compiler development, and discussions about long-term interoperability with existing C++ ecosystems."
+        },
+        es: {
+          name: "Carbon",
+          description: "Un lenguaje experimental sucesor para interoperabilidad y migracion desde C++.",
+          longDescription: "Carbon es un lenguaje experimental de programacion de sistemas disenado como posible sucesor de C++. Se enfoca en sintaxis legible, genericos fuertes, herramientas modernas y rutas de migracion incremental para bases de codigo grandes en C++.\n\nEl proyecto aun no es estable, asi que su uso real se centra en experimentos, evaluacion de diseno, desarrollo del compilador y debates sobre interoperabilidad a largo plazo con ecosistemas C++ existentes."
+        }
+      }
+    };
+  }
+});
+
+// src/languages/chapel.ts
+var chapel_exports = {};
+__export(chapel_exports, {
+  chapel: () => chapel
+});
+var chapel;
+var init_chapel = __esm({
+  "src/languages/chapel.ts"() {
+    chapel = {
+      slug: "chapel",
+      publishedDate: "2009-04-01",
+      extensions: [".chpl"],
+      author: "Cray Inc. / Hewlett Packard Enterprise",
+      website: "https://chapel-lang.org",
+      paradigms: ["parallel", "imperative", "object-oriented", "generic"],
+      tooling: {
+        runtimes: ["Chapel runtime"],
+        packageManagers: ["Mason"],
+        ecosystems: ["High-performance computing", "Parallel computing"]
+      },
+      version: "2.6.0",
+      logo: "https://chapel-lang.org/images/chapel-logo.png",
+      i18n: {
+        en: {
+          name: "Chapel",
+          description: "A productive parallel programming language for scalable systems.",
+          longDescription: "Chapel is a parallel programming language created to make high-performance and distributed computing more approachable. It provides domains, arrays, task parallelism, data parallelism, locality control, and abstractions for writing scalable programs without dropping into low-level message passing everywhere.\n\nIt is used for research, numerical computing, data analytics, simulations, and high-performance applications that need to express parallel algorithms clearly across laptops, clusters, and supercomputers."
+        },
+        es: {
+          name: "Chapel",
+          description: "Un lenguaje de programacion paralela productivo para sistemas escalables.",
+          longDescription: "Chapel es un lenguaje de programacion paralela creado para hacer mas accesible la computacion de alto rendimiento y distribuida. Ofrece dominios, arreglos, paralelismo de tareas, paralelismo de datos, control de localidad y abstracciones para escribir programas escalables sin depender siempre de paso de mensajes de bajo nivel.\n\nSe usa en investigacion, computacion numerica, analitica de datos, simulaciones y aplicaciones de alto rendimiento que necesitan expresar algoritmos paralelos con claridad en laptops, clusters y supercomputadoras."
+        }
+      }
+    };
+  }
+});
+
+// src/languages/circom.ts
+var circom_exports = {};
+__export(circom_exports, {
+  circom: () => circom
+});
+var circom;
+var init_circom = __esm({
+  "src/languages/circom.ts"() {
+    circom = {
+      slug: "circom",
+      publishedDate: "2018-01-01",
+      extensions: [".circom"],
+      author: "iden3",
+      website: "https://docs.circom.io",
+      paradigms: ["declarative", "constraint-based", "domain-specific"],
+      tooling: {
+        runtimes: ["circom compiler", "WebAssembly", "C++"],
+        packageManagers: ["npm", "Cargo"],
+        ecosystems: ["Zero-knowledge proofs", "Ethereum", "zkSNARKs"]
+      },
+      version: "2.2.3",
+      logo: "https://cdn.jsdelivr.net/gh/vscode-icons/vscode-icons@master/icons/file_type_circom.svg",
+      i18n: {
+        en: {
+          name: "Circom",
+          description: "A DSL for writing arithmetic circuits used in zero-knowledge proofs.",
+          longDescription: "Circom is a domain-specific language for defining arithmetic circuits used by zkSNARK proving systems. Its compiler can generate constraint systems together with witness-generation code for C++ or WebAssembly.\n\nIt is common in privacy-preserving protocols, identity systems, blockchain applications, and cryptographic projects that need reusable circuits for zero-knowledge proofs."
+        },
+        es: {
+          name: "Circom",
+          description: "Un DSL para escribir circuitos aritmeticos usados en pruebas de conocimiento cero.",
+          longDescription: "Circom es un lenguaje especifico de dominio para definir circuitos aritmeticos usados por sistemas de prueba zkSNARK. Su compilador puede generar sistemas de restricciones junto con codigo de generacion de testigos para C++ o WebAssembly.\n\nEs comun en protocolos de privacidad, sistemas de identidad, aplicaciones blockchain y proyectos criptograficos que necesitan circuitos reutilizables para pruebas de conocimiento cero."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/clojure.ts
 var clojure_exports = {};
 __export(clojure_exports, {
@@ -950,6 +1102,44 @@ var init_coldfusion = __esm({
   }
 });
 
+// src/languages/coq.ts
+var coq_exports = {};
+__export(coq_exports, {
+  coq: () => coq
+});
+var coq;
+var init_coq = __esm({
+  "src/languages/coq.ts"() {
+    coq = {
+      slug: "coq",
+      publishedDate: "1989-01-01",
+      extensions: [".v"],
+      author: "INRIA / Rocq Prover Development Team",
+      website: "https://rocq-prover.org",
+      paradigms: ["functional", "dependently typed", "proof-oriented", "tactic-based"],
+      tooling: {
+        runtimes: ["Rocq Prover", "OCaml"],
+        packageManagers: ["opam", "Rocq Platform"],
+        ecosystems: ["Formal methods", "Proof assistants", "OCaml"]
+      },
+      version: "9.2.0",
+      logo: "https://avatars.githubusercontent.com/u/621198?v=4",
+      i18n: {
+        en: {
+          name: "Coq / Rocq",
+          description: "A proof assistant and dependently typed language for certified mathematics and software.",
+          longDescription: "Coq, now released under the Rocq Prover name, is an interactive theorem prover and dependently typed language. It lets users write definitions, executable programs, theorems, and machine-checked proofs in one environment.\n\nIt is widely used in formal verification, programming language metatheory, certified compilers, mathematics, cryptography, and projects where correctness arguments need to be checked with high confidence."
+        },
+        es: {
+          name: "Coq / Rocq",
+          description: "Un asistente de pruebas y lenguaje con tipos dependientes para software certificado.",
+          longDescription: "Coq, publicado ahora bajo el nombre Rocq Prover, es un demostrador interactivo de teoremas y un lenguaje con tipos dependientes. Permite escribir definiciones, programas ejecutables, teoremas y pruebas verificadas por maquina en un mismo entorno.\n\nSe usa ampliamente en verificacion formal, metateoria de lenguajes, compiladores certificados, matematica, criptografia y proyectos donde los argumentos de correccion deben comprobarse con alta confianza."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/cpp.ts
 var cpp_exports = {};
 __export(cpp_exports, {
@@ -1287,6 +1477,82 @@ var init_dart = __esm({
   }
 });
 
+// src/languages/dhall.ts
+var dhall_exports = {};
+__export(dhall_exports, {
+  dhall: () => dhall
+});
+var dhall;
+var init_dhall = __esm({
+  "src/languages/dhall.ts"() {
+    dhall = {
+      slug: "dhall",
+      publishedDate: "2016-12-22",
+      extensions: [".dhall"],
+      author: "Gabriel Gonzalez",
+      website: "https://dhall-lang.org",
+      paradigms: ["functional", "declarative", "statically typed", "configuration"],
+      tooling: {
+        runtimes: ["dhall"],
+        packageManagers: ["Cabal", "Stack", "Nix"],
+        ecosystems: ["Configuration", "Haskell", "DevOps"]
+      },
+      version: "23.1.0",
+      logo: "https://cdn.jsdelivr.net/gh/vscode-icons/vscode-icons@master/icons/file_type_dhall.svg",
+      i18n: {
+        en: {
+          name: "Dhall",
+          description: "A programmable, typed configuration language that normalizes safely.",
+          longDescription: "Dhall is a programmable configuration language with a strong static type system, imports, functions, records, and guaranteed normalization. It is designed to replace repetitive JSON, YAML, and similar configuration formats with reusable typed expressions.\n\nIt is used for infrastructure configuration, application settings, generated YAML or JSON, and systems that need shared configuration without arbitrary code execution."
+        },
+        es: {
+          name: "Dhall",
+          description: "Un lenguaje de configuracion programable, tipado y de normalizacion segura.",
+          longDescription: "Dhall es un lenguaje de configuracion programable con un sistema de tipos estatico fuerte, imports, funciones, registros y normalizacion garantizada. Esta disenado para reemplazar JSON, YAML y formatos similares repetitivos con expresiones tipadas reutilizables.\n\nSe usa en configuracion de infraestructura, ajustes de aplicaciones, generacion de YAML o JSON y sistemas que necesitan configuracion compartida sin ejecucion arbitraria de codigo."
+        }
+      }
+    };
+  }
+});
+
+// src/languages/dita.ts
+var dita_exports = {};
+__export(dita_exports, {
+  dita: () => dita
+});
+var dita;
+var init_dita = __esm({
+  "src/languages/dita.ts"() {
+    dita = {
+      slug: "dita",
+      publishedDate: "2005-05-03",
+      extensions: [".dita", ".ditamap", ".ditaval"],
+      author: "OASIS",
+      website: "https://www.oasis-open.org/standard/dita/",
+      paradigms: ["markup", "structured authoring", "XML-based", "documentation"],
+      tooling: {
+        runtimes: ["DITA Open Toolkit"],
+        packageManagers: ["npm", "Maven"],
+        ecosystems: ["Technical writing", "XML", "Publishing"]
+      },
+      version: "1.3",
+      logo: "https://avatars.githubusercontent.com/u/20116735?v=4",
+      i18n: {
+        en: {
+          name: "DITA",
+          description: "An XML-based architecture for structured technical documentation.",
+          longDescription: "DITA is the Darwin Information Typing Architecture, an XML-based standard for topic-oriented authoring. It defines topic types, maps, specialization, reuse mechanisms, and publishing-oriented metadata for large documentation sets.\n\nIt is used in technical writing, product documentation, regulated content, localization workflows, and publishing pipelines that need structured reusable topics rather than page-by-page documents."
+        },
+        es: {
+          name: "DITA",
+          description: "Una arquitectura basada en XML para documentacion tecnica estructurada.",
+          longDescription: "DITA es Darwin Information Typing Architecture, un estandar basado en XML para autoria orientada a topicos. Define tipos de topico, mapas, especializacion, mecanismos de reutilizacion y metadatos de publicacion para grandes conjuntos de documentacion.\n\nSe usa en redaccion tecnica, documentacion de productos, contenido regulado, flujos de localizacion y pipelines de publicacion que necesitan topicos estructurados y reutilizables en vez de documentos pagina por pagina."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/dockerfile.ts
 var dockerfile_exports = {};
 __export(dockerfile_exports, {
@@ -1324,6 +1590,44 @@ var init_dockerfile = __esm({
   }
 });
 
+// src/languages/earthly.ts
+var earthly_exports = {};
+__export(earthly_exports, {
+  earthly: () => earthly
+});
+var earthly;
+var init_earthly = __esm({
+  "src/languages/earthly.ts"() {
+    earthly = {
+      slug: "earthly",
+      publishedDate: "2020-04-15",
+      extensions: ["Earthfile"],
+      author: "Earthly Technologies",
+      website: "https://earthly.dev",
+      paradigms: ["declarative", "build automation", "container-based"],
+      tooling: {
+        runtimes: ["Earthly", "BuildKit", "Docker"],
+        packageManagers: ["Docker"],
+        ecosystems: ["CI/CD", "Containers", "DevOps"]
+      },
+      version: "0.8.16",
+      logo: "https://avatars.githubusercontent.com/u/63060917?v=4",
+      i18n: {
+        en: {
+          name: "Earthly",
+          description: "A container-oriented build language for repeatable CI/CD pipelines.",
+          longDescription: "Earthly is a build automation language and tool centered on Earthfiles. Its syntax combines ideas from Dockerfiles and Makefiles to define repeatable builds, targets, artifacts, images, and CI-friendly workflows.\n\nIt is used by teams that want local and CI builds to behave consistently, especially in container-heavy projects where caching, reproducibility, and readable build steps matter."
+        },
+        es: {
+          name: "Earthly",
+          description: "Un lenguaje de builds orientado a contenedores para pipelines CI/CD repetibles.",
+          longDescription: "Earthly es un lenguaje y herramienta de automatizacion de builds centrado en Earthfiles. Su sintaxis combina ideas de Dockerfiles y Makefiles para definir builds repetibles, targets, artefactos, imagenes y flujos adecuados para CI.\n\nLo usan equipos que quieren que los builds locales y de CI se comporten de forma consistente, especialmente en proyectos con muchos contenedores donde importan cache, reproducibilidad y pasos de build legibles."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/elixir.ts
 var elixir_exports = {};
 __export(elixir_exports, {
@@ -1930,6 +2234,82 @@ var init_groovy = __esm({
   }
 });
 
+// src/languages/hack.ts
+var hack_exports = {};
+__export(hack_exports, {
+  hack: () => hack
+});
+var hack;
+var init_hack = __esm({
+  "src/languages/hack.ts"() {
+    hack = {
+      slug: "hack",
+      publishedDate: "2014-03-20",
+      extensions: [".hack", ".hh", ".hhi"],
+      author: "Meta",
+      website: "https://docs.hhvm.com/hack/",
+      paradigms: ["object-oriented", "functional", "gradually typed", "imperative"],
+      tooling: {
+        runtimes: ["HHVM"],
+        packageManagers: ["Composer"],
+        ecosystems: ["HHVM", "Web", "PHP"]
+      },
+      version: "HHVM 4.x",
+      logo: "https://upload.wikimedia.org/wikipedia/commons/a/a7/Hack_%28programming_language%29_logo.svg",
+      i18n: {
+        en: {
+          name: "Hack",
+          description: "A gradually typed language for HHVM with PHP heritage.",
+          longDescription: "Hack is a programming language for HHVM that evolved from PHP and adds static typing, generics, async features, shapes, collections, and tooling built around the Hack typechecker. It is designed for large web codebases that need gradual typing and fast feedback.\n\nIt is used mainly in HHVM deployments and large server-side applications where PHP-like ergonomics are paired with stronger static analysis and modern language constructs."
+        },
+        es: {
+          name: "Hack",
+          description: "Un lenguaje con tipado gradual para HHVM con herencia de PHP.",
+          longDescription: "Hack es un lenguaje de programacion para HHVM que evoluciono desde PHP y agrega tipado estatico, genericos, funciones async, shapes, colecciones y herramientas basadas en el typechecker de Hack. Esta disenado para grandes bases de codigo web que necesitan tipado gradual y feedback rapido.\n\nSe usa principalmente en despliegues HHVM y aplicaciones grandes del lado servidor donde la ergonomia similar a PHP se combina con analisis estatico mas fuerte y construcciones modernas del lenguaje."
+        }
+      }
+    };
+  }
+});
+
+// src/languages/haml.ts
+var haml_exports = {};
+__export(haml_exports, {
+  haml: () => haml
+});
+var haml;
+var init_haml = __esm({
+  "src/languages/haml.ts"() {
+    haml = {
+      slug: "haml",
+      publishedDate: "2006-10-01",
+      extensions: [".haml"],
+      author: "Hampton Catlin",
+      website: "https://haml.info",
+      paradigms: ["template", "markup", "declarative"],
+      tooling: {
+        runtimes: ["Ruby"],
+        packageManagers: ["RubyGems", "Bundler"],
+        ecosystems: ["Ruby", "Ruby on Rails", "Web"]
+      },
+      version: "7.2.0",
+      logo: "https://cdn.jsdelivr.net/gh/vscode-icons/vscode-icons@master/icons/file_type_haml.svg",
+      i18n: {
+        en: {
+          name: "Haml",
+          description: "A whitespace-sensitive template language for writing HTML tersely.",
+          longDescription: "Haml is a markup and template language for generating HTML with indentation-based structure. It removes closing tags, reduces boilerplate, and integrates with Ruby frameworks such as Ruby on Rails.\n\nIt is used in web applications and static rendering pipelines that prefer concise templates, readable nesting, and Ruby-powered interpolation over explicit HTML syntax."
+        },
+        es: {
+          name: "Haml",
+          description: "Un lenguaje de templates sensible a espacios para escribir HTML de forma concisa.",
+          longDescription: "Haml es un lenguaje de marcado y templates para generar HTML con estructura basada en indentacion. Elimina etiquetas de cierre, reduce repeticion e integra con frameworks Ruby como Ruby on Rails.\n\nSe usa en aplicaciones web y pipelines de renderizado estatico que prefieren templates concisos, anidacion legible e interpolacion con Ruby en vez de sintaxis HTML explicita."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/handlebars.ts
 var handlebars_exports = {};
 __export(handlebars_exports, {
@@ -2153,6 +2533,44 @@ var init_html = __esm({
   }
 });
 
+// src/languages/idris.ts
+var idris_exports = {};
+__export(idris_exports, {
+  idris: () => idris
+});
+var idris;
+var init_idris = __esm({
+  "src/languages/idris.ts"() {
+    idris = {
+      slug: "idris",
+      publishedDate: "2009-01-01",
+      extensions: [".idr", ".lidr", ".ipkg"],
+      author: "Edwin Brady",
+      website: "https://www.idris-lang.org",
+      paradigms: ["functional", "dependently typed", "total", "statically typed"],
+      tooling: {
+        runtimes: ["Chez Scheme", "Racket", "JavaScript", "Node.js"],
+        packageManagers: ["pack", "idris2"],
+        ecosystems: ["Formal methods", "Functional programming"]
+      },
+      version: "0.8.0",
+      logo: "https://cdn.jsdelivr.net/gh/vscode-icons/vscode-icons@master/icons/file_type_idris.svg",
+      i18n: {
+        en: {
+          name: "Idris",
+          description: "A dependently typed functional language focused on practical programs.",
+          longDescription: "Idris is a dependently typed functional programming language that brings theorem-proving ideas into general-purpose software development. Idris 2 adds a quantitative type system, totality checking, elaborator reflection, and multiple code generation backends.\n\nIt is used for type-driven development, language research, certified programming, education, and experiments where rich types help describe program behavior precisely."
+        },
+        es: {
+          name: "Idris",
+          description: "Un lenguaje funcional con tipos dependientes enfocado en programas practicos.",
+          longDescription: "Idris es un lenguaje de programacion funcional con tipos dependientes que lleva ideas de demostracion de teoremas al desarrollo general. Idris 2 agrega un sistema de tipos cuantitativo, chequeo de totalidad, reflexion de elaborador y multiples backends de generacion de codigo.\n\nSe usa en desarrollo guiado por tipos, investigacion de lenguajes, programacion certificada, educacion y experimentos donde tipos ricos ayudan a describir con precision el comportamiento de los programas."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/ini.ts
 var ini_exports = {};
 __export(ini_exports, {
@@ -2189,6 +2607,44 @@ var init_ini = __esm({
   }
 });
 
+// src/languages/janet.ts
+var janet_exports = {};
+__export(janet_exports, {
+  janet: () => janet
+});
+var janet;
+var init_janet = __esm({
+  "src/languages/janet.ts"() {
+    janet = {
+      slug: "janet",
+      publishedDate: "2017-09-01",
+      extensions: [".janet", ".jdn"],
+      author: "Calvin Rose",
+      website: "https://janet-lang.org",
+      paradigms: ["functional", "imperative", "lisp", "embedded"],
+      tooling: {
+        runtimes: ["Janet VM"],
+        packageManagers: ["jpm"],
+        ecosystems: ["Scripting", "Embedded systems", "Command-line tools"]
+      },
+      version: "1.39.1",
+      logo: "https://cdn.jsdelivr.net/gh/vscode-icons/vscode-icons@master/icons/file_type_janet.svg",
+      i18n: {
+        en: {
+          name: "Janet",
+          description: "A small Lisp-like language and embeddable runtime for scripting.",
+          longDescription: "Janet is a small Lisp-like programming language with a compact C implementation, fibers, tables, pattern matching, macros, and an embeddable runtime. It is designed for scripting, tools, and applications that need a lightweight extension language.\n\nIt is used for command-line programs, configuration, automation, embedding in native applications, and experiments that benefit from Lisp-style metaprogramming without a large runtime."
+        },
+        es: {
+          name: "Janet",
+          description: "Un lenguaje pequeno tipo Lisp y runtime embebible para scripting.",
+          longDescription: "Janet es un lenguaje de programacion pequeno tipo Lisp con una implementacion compacta en C, fibras, tablas, pattern matching, macros y un runtime embebible. Esta disenado para scripting, herramientas y aplicaciones que necesitan un lenguaje de extension liviano.\n\nSe usa en programas de linea de comandos, configuracion, automatizacion, embedding en aplicaciones nativas y experimentos que aprovechan metaprogramacion tipo Lisp sin un runtime grande."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/java.ts
 var java_exports = {};
 __export(java_exports, {
@@ -2488,6 +2944,44 @@ var init_kotlin = __esm({
   }
 });
 
+// src/languages/lean.ts
+var lean_exports = {};
+__export(lean_exports, {
+  lean: () => lean
+});
+var lean;
+var init_lean = __esm({
+  "src/languages/lean.ts"() {
+    lean = {
+      slug: "lean",
+      publishedDate: "2013-06-16",
+      extensions: [".lean"],
+      author: "Leonardo de Moura / Microsoft Research",
+      website: "https://lean-lang.org",
+      paradigms: ["functional", "dependently typed", "proof-oriented", "metaprogramming"],
+      tooling: {
+        runtimes: ["Lean"],
+        packageManagers: ["Lake", "elan"],
+        ecosystems: ["Formal methods", "Mathematics", "Proof assistants"]
+      },
+      version: "4.29.1",
+      logo: "https://cdn.simpleicons.org/leanpub/262425",
+      i18n: {
+        en: {
+          name: "Lean",
+          description: "A theorem prover and functional language for formalized mathematics and software.",
+          longDescription: "Lean is a theorem prover and dependently typed functional programming language. Lean 4 includes an efficient compiler, extensible syntax, metaprogramming facilities, tactics, and tooling for large formalization projects.\n\nIt is used in formalized mathematics, program verification, theorem proving research, educational games, and software projects where proofs and executable definitions can evolve together."
+        },
+        es: {
+          name: "Lean",
+          description: "Un demostrador de teoremas y lenguaje funcional para matematica y software formalizados.",
+          longDescription: "Lean es un demostrador de teoremas y lenguaje funcional con tipos dependientes. Lean 4 incluye un compilador eficiente, sintaxis extensible, metaprogramacion, tacticas y herramientas para grandes proyectos de formalizacion.\n\nSe usa en matematica formalizada, verificacion de programas, investigacion en demostracion de teoremas, juegos educativos y proyectos donde pruebas y definiciones ejecutables pueden evolucionar juntas."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/less.ts
 var less_exports = {};
 __export(less_exports, {
@@ -2602,6 +3096,44 @@ var init_lisp = __esm({
   }
 });
 
+// src/languages/llvm-ir.ts
+var llvm_ir_exports = {};
+__export(llvm_ir_exports, {
+  llvmIr: () => llvmIr
+});
+var llvmIr;
+var init_llvm_ir = __esm({
+  "src/languages/llvm-ir.ts"() {
+    llvmIr = {
+      slug: "llvm-ir",
+      publishedDate: "2003-10-01",
+      extensions: [".ll", ".bc"],
+      author: "LLVM Project",
+      website: "https://llvm.org/docs/LangRef.html",
+      paradigms: ["intermediate representation", "static single assignment", "compiler"],
+      tooling: {
+        runtimes: ["LLVM"],
+        packageManagers: ["LLVM releases"],
+        ecosystems: ["Compilers", "Systems programming", "Toolchains"]
+      },
+      version: "22.1.5",
+      logo: "https://cdn.simpleicons.org/llvm/262D3A",
+      i18n: {
+        en: {
+          name: "LLVM IR",
+          description: "The typed intermediate representation used by the LLVM compiler infrastructure.",
+          longDescription: "LLVM IR is the typed, low-level intermediate representation used by the LLVM compiler infrastructure. It has a textual form, bitcode form, SSA-based values, explicit control flow, and a language reference that defines instructions, types, attributes, and metadata.\n\nIt is used by compilers, optimizers, static analyzers, JIT systems, language implementations, and tools that need a portable representation between source languages and machine code."
+        },
+        es: {
+          name: "LLVM IR",
+          description: "La representacion intermedia tipada usada por la infraestructura de compiladores LLVM.",
+          longDescription: "LLVM IR es la representacion intermedia tipada y de bajo nivel usada por la infraestructura de compiladores LLVM. Tiene forma textual, forma bitcode, valores basados en SSA, flujo de control explicito y una referencia que define instrucciones, tipos, atributos y metadatos.\n\nSe usa en compiladores, optimizadores, analizadores estaticos, sistemas JIT, implementaciones de lenguajes y herramientas que necesitan una representacion portable entre lenguajes fuente y codigo maquina."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/lua.ts
 var lua_exports = {};
 __export(lua_exports, {
@@ -2640,6 +3172,44 @@ var init_lua = __esm({
   }
 });
 
+// src/languages/luau.ts
+var luau_exports = {};
+__export(luau_exports, {
+  luau: () => luau
+});
+var luau;
+var init_luau = __esm({
+  "src/languages/luau.ts"() {
+    luau = {
+      slug: "luau",
+      publishedDate: "2021-11-03",
+      extensions: [".luau"],
+      author: "Roblox",
+      website: "https://luau.org",
+      paradigms: ["imperative", "scripting", "gradually typed", "embeddable"],
+      tooling: {
+        runtimes: ["Luau VM", "Roblox"],
+        packageManagers: ["Wally", "Pesde"],
+        ecosystems: ["Roblox", "Games", "Embedded scripting"]
+      },
+      version: "0.719",
+      logo: "https://cdn.simpleicons.org/roblox/000000",
+      i18n: {
+        en: {
+          name: "Luau",
+          description: "A fast Lua-derived scripting language with gradual typing.",
+          longDescription: "Luau is a scripting language derived from Lua 5.1 and developed by Roblox. It adds gradual typing, performance-focused compiler and VM work, linting, type inference, and features aimed at large game codebases.\n\nIt is used in Roblox experiences, game tooling, embedded scripting, and projects that want Lua-like ergonomics with stronger static analysis and modern runtime performance."
+        },
+        es: {
+          name: "Luau",
+          description: "Un lenguaje de scripting derivado de Lua, rapido y con tipado gradual.",
+          longDescription: "Luau es un lenguaje de scripting derivado de Lua 5.1 y desarrollado por Roblox. Agrega tipado gradual, trabajo de compilador y VM orientado al rendimiento, linting, inferencia de tipos y caracteristicas para grandes bases de codigo de juegos.\n\nSe usa en experiencias de Roblox, herramientas de juegos, scripting embebido y proyectos que quieren ergonomia similar a Lua con analisis estatico mas fuerte y rendimiento moderno."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/makefile.ts
 var makefile_exports = {};
 __export(makefile_exports, {
@@ -4741,6 +5311,7 @@ var init_zsh = __esm({
 init_abap();
 init_actionscript();
 init_ada();
+init_agda();
 init_antlr();
 init_apex();
 init_apl();
@@ -4758,11 +5329,15 @@ init_bazel();
 init_bicep();
 init_blade();
 init_c();
+init_carbon();
+init_chapel();
+init_circom();
 init_clojure();
 init_cmake();
 init_cobol();
 init_coffeescript();
 init_coldfusion();
+init_coq();
 init_cpp();
 init_crystal();
 init_csharp();
@@ -4772,7 +5347,10 @@ init_cue();
 init_cython();
 init_d();
 init_dart();
+init_dhall();
+init_dita();
 init_dockerfile();
+init_earthly();
 init_elixir();
 init_elm();
 init_erb();
@@ -4789,13 +5367,17 @@ init_go();
 init_gradle();
 init_graphql();
 init_groovy();
+init_hack();
+init_haml();
 init_handlebars();
 init_haskell();
 init_haxe();
 init_hcl();
 init_hlsl();
 init_html();
+init_idris();
 init_ini();
+init_janet();
 init_java();
 init_javascript();
 init_jinja();
@@ -4804,10 +5386,13 @@ init_jsonnet();
 init_julia();
 init_jupyter_notebook();
 init_kotlin();
+init_lean();
 init_less();
 init_liquid();
 init_lisp();
+init_llvm_ir();
 init_lua();
+init_luau();
 init_makefile();
 init_markdown();
 init_matlab();
@@ -4868,6 +5453,7 @@ var languages = [
   abap,
   actionscript,
   ada,
+  agda,
   antlr,
   apex,
   apl,
@@ -4885,11 +5471,15 @@ var languages = [
   bicep,
   blade,
   c,
+  carbon,
+  chapel,
+  circom,
   cmake,
   clojure,
   coffeescript,
   coldfusion,
   cobol,
+  coq,
   cpp,
   csharp,
   crystal,
@@ -4899,7 +5489,10 @@ var languages = [
   cython,
   d,
   dart,
+  dhall,
+  dita,
   dockerfile,
+  earthly,
   elixir,
   elm,
   erb,
@@ -4917,24 +5510,31 @@ var languages = [
   graphql,
   groovy,
   handlebars,
+  hack,
+  haml,
   haskell,
   haxe,
   hcl,
   hlsl,
   html,
+  idris,
   ini,
   java,
   javascript,
+  janet,
   jinja,
   json,
   jsonnet,
   jupyterNotebook,
   julia,
   kotlin,
+  lean,
   less,
   liquid,
   lisp,
+  llvmIr,
   lua,
+  luau,
   makefile,
   matlab,
   markdown,
@@ -5050,6 +5650,7 @@ var languageIndex = [
   { slug: "abap", extensions: [".abap"] },
   { slug: "actionscript", extensions: [".as"] },
   { slug: "ada", extensions: [".adb", ".ads", ".ada"] },
+  { slug: "agda", extensions: [".agda", ".lagda", ".lagda.md", ".lagda.rst", ".lagda.tex"] },
   { slug: "antlr", extensions: [".g4"] },
   { slug: "apex", extensions: [".cls", ".trigger"] },
   { slug: "apl", extensions: [".apl", ".dyalog"] },
@@ -5073,11 +5674,15 @@ var languageIndex = [
   { slug: "bicep", extensions: [".bicep", ".bicepparam"] },
   { slug: "blade", extensions: [".blade.php"] },
   { slug: "c", extensions: [".c", ".h"] },
+  { slug: "carbon", extensions: [".carbon"] },
+  { slug: "chapel", extensions: [".chpl"] },
+  { slug: "circom", extensions: [".circom"] },
   { slug: "cmake", extensions: ["CMakeLists.txt", ".cmake"] },
   { slug: "clojure", extensions: [".clj", ".cljs", ".cljc", ".edn", ".bb"] },
   { slug: "coffeescript", extensions: [".coffee", ".litcoffee", ".cson"] },
   { slug: "coldfusion", extensions: [".cfm", ".cfml", ".cfc"] },
   { slug: "cobol", extensions: [".cob", ".cbl", ".cobol", ".cpy"] },
+  { slug: "coq", extensions: [".v"] },
   { slug: "cpp", extensions: [".cpp", ".cc", ".cxx", ".h", ".hpp", ".hh", ".hxx"] },
   { slug: "csharp", extensions: [".cs", ".csx"] },
   { slug: "crystal", extensions: [".cr"] },
@@ -5087,7 +5692,10 @@ var languageIndex = [
   { slug: "cython", extensions: [".pyx", ".pxd", ".pxi"] },
   { slug: "d", extensions: [".d", ".di"] },
   { slug: "dart", extensions: [".dart"] },
+  { slug: "dhall", extensions: [".dhall"] },
+  { slug: "dita", extensions: [".dita", ".ditamap", ".ditaval"] },
   { slug: "dockerfile", extensions: ["Dockerfile", ".dockerfile"] },
+  { slug: "earthly", extensions: ["Earthfile"] },
   { slug: "elixir", extensions: [".ex", ".exs", ".eex", ".leex", ".heex"] },
   { slug: "elm", extensions: [".elm"] },
   { slug: "erb", extensions: [".erb", ".rhtml", ".html.erb"] },
@@ -5114,24 +5722,31 @@ var languageIndex = [
   { slug: "graphql", extensions: [".graphql", ".gql", ".graphqls"] },
   { slug: "groovy", extensions: [".groovy", ".gvy", ".gy", ".gsh"] },
   { slug: "handlebars", extensions: [".hbs", ".handlebars"] },
+  { slug: "hack", extensions: [".hack", ".hh", ".hhi"] },
+  { slug: "haml", extensions: [".haml"] },
   { 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: "idris", extensions: [".idr", ".lidr", ".ipkg"] },
   { slug: "ini", extensions: [".ini"] },
   { slug: "java", extensions: [".java"] },
   { slug: "javascript", extensions: [".js", ".mjs", ".cjs", ".jsx"] },
+  { slug: "janet", extensions: [".janet", ".jdn"] },
   { slug: "jinja", extensions: [".jinja", ".jinja2", ".j2"] },
   { slug: "json", extensions: [".json"] },
   { slug: "jsonnet", extensions: [".jsonnet", ".libsonnet"] },
   { slug: "jupyter-notebook", extensions: [".ipynb"] },
   { slug: "julia", extensions: [".jl"] },
   { slug: "kotlin", extensions: [".kt", ".kts"] },
+  { slug: "lean", extensions: [".lean"] },
   { slug: "less", extensions: [".less"] },
   { slug: "liquid", extensions: [".liquid"] },
   { slug: "lisp", extensions: [".lisp", ".lsp", ".cl", ".asd"] },
+  { slug: "llvm-ir", extensions: [".ll", ".bc"] },
   { slug: "lua", extensions: [".lua", ".rockspec"] },
+  { slug: "luau", extensions: [".luau"] },
   { slug: "makefile", extensions: ["Makefile", "makefile", "GNUmakefile", ".mk", ".mak"] },
   { slug: "matlab", extensions: [".m", ".mlx"] },
   { slug: "markdown", extensions: [".md", ".markdown", ".mdown", ".mkd"] },
@@ -5199,6 +5814,7 @@ var languageLoaders = {
   abap: () => Promise.resolve().then(() => (init_abap(), abap_exports)).then((module) => module.abap),
   actionscript: () => Promise.resolve().then(() => (init_actionscript(), actionscript_exports)).then((module) => module.actionscript),
   ada: () => Promise.resolve().then(() => (init_ada(), ada_exports)).then((module) => module.ada),
+  agda: () => Promise.resolve().then(() => (init_agda(), agda_exports)).then((module) => module.agda),
   antlr: () => Promise.resolve().then(() => (init_antlr(), antlr_exports)).then((module) => module.antlr),
   apex: () => Promise.resolve().then(() => (init_apex(), apex_exports)).then((module) => module.apex),
   apl: () => Promise.resolve().then(() => (init_apl(), apl_exports)).then((module) => module.apl),
@@ -5216,11 +5832,15 @@ 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),
+  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),
   cmake: () => Promise.resolve().then(() => (init_cmake(), cmake_exports)).then((module) => module.cmake),
   clojure: () => Promise.resolve().then(() => (init_clojure(), clojure_exports)).then((module) => module.clojure),
   cobol: () => Promise.resolve().then(() => (init_cobol(), cobol_exports)).then((module) => module.cobol),
   coffeescript: () => Promise.resolve().then(() => (init_coffeescript(), coffeescript_exports)).then((module) => module.coffeescript),
   coldfusion: () => Promise.resolve().then(() => (init_coldfusion(), coldfusion_exports)).then((module) => module.coldfusion),
+  coq: () => Promise.resolve().then(() => (init_coq(), coq_exports)).then((module) => module.coq),
   cpp: () => Promise.resolve().then(() => (init_cpp(), cpp_exports)).then((module) => module.cpp),
   csharp: () => Promise.resolve().then(() => (init_csharp(), csharp_exports)).then((module) => module.csharp),
   crystal: () => Promise.resolve().then(() => (init_crystal(), crystal_exports)).then((module) => module.crystal),
@@ -5230,7 +5850,10 @@ var languageLoaders = {
   cython: () => Promise.resolve().then(() => (init_cython(), cython_exports)).then((module) => module.cython),
   d: () => Promise.resolve().then(() => (init_d(), d_exports)).then((module) => module.d),
   dart: () => Promise.resolve().then(() => (init_dart(), dart_exports)).then((module) => module.dart),
+  dhall: () => Promise.resolve().then(() => (init_dhall(), dhall_exports)).then((module) => module.dhall),
+  dita: () => Promise.resolve().then(() => (init_dita(), dita_exports)).then((module) => module.dita),
   dockerfile: () => Promise.resolve().then(() => (init_dockerfile(), dockerfile_exports)).then((module) => module.dockerfile),
+  earthly: () => Promise.resolve().then(() => (init_earthly(), earthly_exports)).then((module) => module.earthly),
   elixir: () => Promise.resolve().then(() => (init_elixir(), elixir_exports)).then((module) => module.elixir),
   elm: () => Promise.resolve().then(() => (init_elm(), elm_exports)).then((module) => module.elm),
   erb: () => Promise.resolve().then(() => (init_erb(), erb_exports)).then((module) => module.erb),
@@ -5248,24 +5871,31 @@ var languageLoaders = {
   graphql: () => Promise.resolve().then(() => (init_graphql(), graphql_exports)).then((module) => module.graphql),
   groovy: () => Promise.resolve().then(() => (init_groovy(), groovy_exports)).then((module) => module.groovy),
   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),
   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),
+  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),
   javascript: () => Promise.resolve().then(() => (init_javascript(), javascript_exports)).then((module) => module.javascript),
+  janet: () => Promise.resolve().then(() => (init_janet(), janet_exports)).then((module) => module.janet),
   jinja: () => Promise.resolve().then(() => (init_jinja(), jinja_exports)).then((module) => module.jinja),
   json: () => Promise.resolve().then(() => (init_json(), json_exports)).then((module) => module.json),
   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),
   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),
   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),
   lua: () => Promise.resolve().then(() => (init_lua(), lua_exports)).then((module) => module.lua),
+  luau: () => Promise.resolve().then(() => (init_luau(), luau_exports)).then((module) => module.luau),
   makefile: () => Promise.resolve().then(() => (init_makefile(), makefile_exports)).then((module) => module.makefile),
   matlab: () => Promise.resolve().then(() => (init_matlab(), matlab_exports)).then((module) => module.matlab),
   markdown: () => Promise.resolve().then(() => (init_markdown(), markdown_exports)).then((module) => module.markdown),