code-languages 1.14.0 → 1.16.0

package/dist/api.cjs

@@ -84,6 +84,82 @@ var init_actionscript = __esm({
   }
 });
 
+// src/languages/ada.ts
+var ada_exports = {};
+__export(ada_exports, {
+  ada: () => ada
+});
+var ada;
+var init_ada = __esm({
+  "src/languages/ada.ts"() {
+    ada = {
+      slug: "ada",
+      publishedDate: "1980-01-01",
+      extensions: [".adb", ".ads", ".ada"],
+      author: "Jean Ichbiah / CII Honeywell Bull",
+      website: "https://www.adaic.org",
+      paradigms: ["imperative", "object-oriented", "concurrent", "real-time", "modular"],
+      tooling: {
+        runtimes: ["Native", "GNAT Runtime", "Ravenscar"],
+        packageManagers: ["Alire"],
+        ecosystems: ["Embedded", "Aerospace", "Defense", "Safety-critical Systems"]
+      },
+      version: "Ada 2022",
+      logo: "https://cdn.simpleicons.org/ada/02F88C",
+      i18n: {
+        en: {
+          name: "Ada",
+          description: "A strongly typed language for reliable, maintainable, and safety-critical software.",
+          longDescription: "Ada is a general-purpose programming language designed for reliability, readability, strong typing, modularity, concurrency, and real-time systems. Modern Ada includes packages, generics, tasking, protected objects, contracts, object-oriented features, and precise control over representation.\n\nIt is used in aerospace, defense, transportation, embedded systems, high-integrity applications, industrial control, and software where long-term maintainability and correctness are central requirements."
+        },
+        es: {
+          name: "Ada",
+          description: "Un lenguaje de tipado fuerte para software confiable, mantenible y critico para la seguridad.",
+          longDescription: "Ada es un lenguaje de programacion de proposito general disenado para confiabilidad, legibilidad, tipado fuerte, modularidad, concurrencia y sistemas de tiempo real. Ada moderno incluye paquetes, genericos, tareas, objetos protegidos, contratos, caracteristicas orientadas a objetos y control preciso de representacion.\n\nSe usa en aeroespacial, defensa, transporte, sistemas embebidos, aplicaciones de alta integridad, control industrial y software donde la mantenibilidad a largo plazo y la correccion son requisitos centrales."
+        }
+      }
+    };
+  }
+});
+
+// src/languages/apex.ts
+var apex_exports = {};
+__export(apex_exports, {
+  apex: () => apex
+});
+var apex;
+var init_apex = __esm({
+  "src/languages/apex.ts"() {
+    apex = {
+      slug: "apex",
+      publishedDate: "2007-01-01",
+      extensions: [".cls", ".trigger"],
+      author: "Salesforce",
+      website: "https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/",
+      paradigms: ["object-oriented", "cloud", "database-oriented", "event-driven"],
+      tooling: {
+        runtimes: ["Salesforce Platform"],
+        packageManagers: ["Salesforce CLI", "Unlocked Packages", "Managed Packages"],
+        ecosystems: ["Salesforce", "CRM", "Enterprise Applications", "Platform Automation"]
+      },
+      version: "API 66.0",
+      logo: "https://commons.wikimedia.org/wiki/Special:FilePath/Salesforce.com_logo.svg",
+      i18n: {
+        en: {
+          name: "Apex",
+          description: "Salesforce's strongly typed, object-oriented language for platform business logic.",
+          longDescription: "Apex is a strongly typed, object-oriented programming language that runs on the Salesforce Platform. It combines Java-like syntax with platform-specific database operations, triggers, asynchronous jobs, governor limits, sharing rules, and integrations with Salesforce metadata and APIs.\n\nIt is used for CRM customizations, business automation, custom controllers, data validation, integrations, batch processing, platform events, and enterprise applications built inside Salesforce."
+        },
+        es: {
+          name: "Apex",
+          description: "El lenguaje fuertemente tipado y orientado a objetos de Salesforce para logica de negocio en la plataforma.",
+          longDescription: "Apex es un lenguaje de programacion fuertemente tipado y orientado a objetos que corre en Salesforce Platform. Combina sintaxis similar a Java con operaciones de base de datos propias de la plataforma, triggers, trabajos asincronos, governor limits, reglas de sharing e integraciones con metadata y APIs de Salesforce.\n\nSe usa para personalizaciones de CRM, automatizacion de negocio, controladores personalizados, validacion de datos, integraciones, procesamiento batch, platform events y aplicaciones empresariales construidas dentro de Salesforce."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/asp.ts
 var asp_exports = {};
 __export(asp_exports, {
@@ -198,6 +274,44 @@ var init_astro = __esm({
   }
 });
 
+// src/languages/awk.ts
+var awk_exports = {};
+__export(awk_exports, {
+  awk: () => awk
+});
+var awk;
+var init_awk = __esm({
+  "src/languages/awk.ts"() {
+    awk = {
+      slug: "awk",
+      publishedDate: "1977-01-01",
+      extensions: [".awk"],
+      author: "Alfred Aho, Peter Weinberger, Brian Kernighan",
+      website: "https://www.gnu.org/software/gawk/",
+      paradigms: ["text-processing", "scripting", "pattern-action", "data-driven"],
+      tooling: {
+        runtimes: ["awk", "gawk", "mawk", "nawk"],
+        packageManagers: ["APT", "DNF", "Pacman", "Homebrew"],
+        ecosystems: ["Unix", "Text Processing", "Shell", "Data Extraction"]
+      },
+      version: "GNU Awk 5.4.0",
+      logo: "https://www.gnu.org/graphics/heckert_gnu.small.png",
+      i18n: {
+        en: {
+          name: "awk",
+          description: "A pattern-action language for scanning, transforming, and reporting on text data.",
+          longDescription: "awk is a compact text-processing language built around pattern-action rules, records, fields, associative arrays, regular expressions, and streaming input. It is commonly available on Unix-like systems, with GNU Awk adding many extensions and tooling conveniences.\n\nIt is used for command-line data extraction, log processing, report generation, one-off transformations, shell pipelines, lightweight ETL tasks, and scripts that need concise processing of structured or semi-structured text."
+        },
+        es: {
+          name: "awk",
+          description: "Un lenguaje de patron-accion para analizar, transformar y reportar datos de texto.",
+          longDescription: "awk es un lenguaje compacto de procesamiento de texto basado en reglas patron-accion, registros, campos, arreglos asociativos, expresiones regulares y entrada en streaming. Esta disponible comunmente en sistemas tipo Unix, con GNU Awk agregando muchas extensiones y comodidades de tooling.\n\nSe usa para extraccion de datos en linea de comandos, procesamiento de logs, generacion de reportes, transformaciones puntuales, pipelines de shell, tareas ETL ligeras y scripts que necesitan procesar texto estructurado o semiestructurado de forma concisa."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/bash.ts
 var bash_exports = {};
 __export(bash_exports, {
@@ -311,6 +425,44 @@ var init_c = __esm({
   }
 });
 
+// src/languages/clojure.ts
+var clojure_exports = {};
+__export(clojure_exports, {
+  clojure: () => clojure
+});
+var clojure;
+var init_clojure = __esm({
+  "src/languages/clojure.ts"() {
+    clojure = {
+      slug: "clojure",
+      publishedDate: "2007-10-16",
+      extensions: [".clj", ".cljs", ".cljc", ".edn", ".bb"],
+      author: "Rich Hickey",
+      website: "https://clojure.org",
+      paradigms: ["functional", "lisp", "concurrent", "dynamic", "immutable-data"],
+      tooling: {
+        runtimes: ["JVM", "ClojureScript", "Babashka", "ClojureCLR"],
+        packageManagers: ["Clojure CLI", "Leiningen", "Boot", "Maven"],
+        ecosystems: ["JVM", "JavaScript", "Data Processing", "Web", "REPL-driven Development"]
+      },
+      version: "1.12.5",
+      logo: "https://cdn.simpleicons.org/clojure/5881D8",
+      i18n: {
+        en: {
+          name: "Clojure",
+          description: "A modern Lisp for the JVM and JavaScript ecosystems with immutable data and interactive development.",
+          longDescription: "Clojure is a dynamic functional Lisp dialect designed for practical software development on hosted runtimes. It emphasizes immutable persistent data structures, first-class functions, macros, namespaces, protocols, software transactional memory, and REPL-driven workflows.\n\nIt is used for backend services, data pipelines, interactive systems, scripting with Babashka, web applications, distributed systems, and projects that benefit from a small language core with strong data-oriented programming practices."
+        },
+        es: {
+          name: "Clojure",
+          description: "Un Lisp moderno para los ecosistemas JVM y JavaScript con datos inmutables y desarrollo interactivo.",
+          longDescription: "Clojure es un dialecto Lisp funcional y dinamico disenado para desarrollo practico de software sobre runtimes hospedados. Enfatiza estructuras de datos persistentes e inmutables, funciones de primera clase, macros, namespaces, protocolos, memoria transaccional de software y flujos guiados por REPL.\n\nSe usa en servicios backend, pipelines de datos, sistemas interactivos, scripting con Babashka, aplicaciones web, sistemas distribuidos y proyectos que se benefician de un nucleo pequeno de lenguaje con practicas fuertes de programacion orientada a datos."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/cmake.ts
 var cmake_exports = {};
 __export(cmake_exports, {
@@ -608,6 +760,44 @@ var init_cuda = __esm({
   }
 });
 
+// src/languages/d.ts
+var d_exports = {};
+__export(d_exports, {
+  d: () => d
+});
+var d;
+var init_d = __esm({
+  "src/languages/d.ts"() {
+    d = {
+      slug: "d",
+      publishedDate: "2001-12-08",
+      extensions: [".d", ".di"],
+      author: "Walter Bright / D Language Foundation",
+      website: "https://dlang.org",
+      paradigms: ["systems", "imperative", "object-oriented", "generic", "functional"],
+      tooling: {
+        runtimes: ["Native", "D Runtime"],
+        packageManagers: ["DUB"],
+        ecosystems: ["Systems Programming", "Native Applications", "Tooling", "Game Development"]
+      },
+      version: "2.112.0",
+      logo: "https://cdn.simpleicons.org/d/BA595E",
+      i18n: {
+        en: {
+          name: "D",
+          description: "A systems programming language combining native performance with high-level abstractions.",
+          longDescription: "D is a general-purpose systems programming language with C-like syntax, native compilation, garbage collection, manual memory options, templates, compile-time function execution, ranges, contracts, and interoperability with C.\n\nIt is used for command-line tools, systems software, native services, high-performance applications, game tooling, compilers, and projects that want low-level control alongside expressive metaprogramming and modern language features."
+        },
+        es: {
+          name: "D",
+          description: "Un lenguaje de sistemas que combina rendimiento nativo con abstracciones de alto nivel.",
+          longDescription: "D es un lenguaje de programacion de sistemas de proposito general con sintaxis similar a C, compilacion nativa, garbage collection, opciones de memoria manual, templates, ejecucion de funciones en tiempo de compilacion, ranges, contratos e interoperabilidad con C.\n\nSe usa en herramientas de linea de comandos, software de sistemas, servicios nativos, aplicaciones de alto rendimiento, tooling para juegos, compiladores y proyectos que buscan control de bajo nivel junto con metaprogramacion expresiva y caracteristicas modernas de lenguaje."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/dart.ts
 var dart_exports = {};
 __export(dart_exports, {
@@ -797,6 +987,44 @@ var init_erlang = __esm({
   }
 });
 
+// src/languages/fennel.ts
+var fennel_exports = {};
+__export(fennel_exports, {
+  fennel: () => fennel
+});
+var fennel;
+var init_fennel = __esm({
+  "src/languages/fennel.ts"() {
+    fennel = {
+      slug: "fennel",
+      publishedDate: "2016-10-01",
+      extensions: [".fnl"],
+      author: "Calvin Rose, Phil Hagelberg",
+      website: "https://fennel-lang.org",
+      paradigms: ["functional", "lisp", "scripting", "metaprogramming"],
+      tooling: {
+        runtimes: ["Lua", "LuaJIT"],
+        packageManagers: ["LuaRocks"],
+        ecosystems: ["Lua", "Neovim", "Game Development", "Embedded Scripting"]
+      },
+      version: "1.6.1",
+      logo: "https://fennel-lang.org/logo.svg",
+      i18n: {
+        en: {
+          name: "Fennel",
+          description: "A Lisp that compiles to Lua while preserving access to the Lua ecosystem.",
+          longDescription: "Fennel is a Lisp dialect that compiles to Lua, offering parentheses, macros, pattern matching, destructuring, functional style, and interactive development while keeping compatibility with Lua runtimes and libraries.\n\nIt is used for Lua applications, Neovim configuration, game scripting, embedded extension languages, tools, and projects that want Lisp-style syntax and macros with Lua's portability and small runtime footprint."
+        },
+        es: {
+          name: "Fennel",
+          description: "Un Lisp que compila a Lua y conserva acceso al ecosistema Lua.",
+          longDescription: "Fennel es un dialecto Lisp que compila a Lua, ofreciendo parentesis, macros, pattern matching, destructuring, estilo funcional y desarrollo interactivo mientras mantiene compatibilidad con runtimes y bibliotecas de Lua.\n\nSe usa en aplicaciones Lua, configuracion de Neovim, scripting para juegos, lenguajes embebidos de extension, herramientas y proyectos que quieren sintaxis y macros de estilo Lisp con la portabilidad y huella pequena de runtime de Lua."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/fortran.ts
 var fortran_exports = {};
 __export(fortran_exports, {
@@ -910,6 +1138,44 @@ var init_git = __esm({
   }
 });
 
+// src/languages/gleam.ts
+var gleam_exports = {};
+__export(gleam_exports, {
+  gleam: () => gleam
+});
+var gleam;
+var init_gleam = __esm({
+  "src/languages/gleam.ts"() {
+    gleam = {
+      slug: "gleam",
+      publishedDate: "2019-04-15",
+      extensions: [".gleam"],
+      author: "Louis Pilfold",
+      website: "https://gleam.run",
+      paradigms: ["functional", "statically typed", "concurrent", "actor-model"],
+      tooling: {
+        runtimes: ["Erlang/OTP", "BEAM", "JavaScript"],
+        packageManagers: ["gleam", "Hex"],
+        ecosystems: ["BEAM", "Erlang", "Elixir", "JavaScript", "Web"]
+      },
+      version: "1.16.0",
+      logo: "https://cdn.simpleicons.org/gleam/FFAFF3",
+      i18n: {
+        en: {
+          name: "Gleam",
+          description: "A friendly statically typed functional language for the BEAM and JavaScript.",
+          longDescription: "Gleam is a statically typed functional programming language that compiles to Erlang and JavaScript. It provides algebraic data types, pattern matching, immutable data, a small syntax, helpful compiler errors, and interoperability with Erlang and Elixir libraries on the BEAM.\n\nIt is used for web services, concurrent systems, command-line tools, full-stack applications, and projects that want BEAM reliability with a lightweight type system and approachable functional programming model."
+        },
+        es: {
+          name: "Gleam",
+          description: "Un lenguaje funcional amigable y de tipado estatico para BEAM y JavaScript.",
+          longDescription: "Gleam es un lenguaje de programacion funcional con tipado estatico que compila a Erlang y JavaScript. Ofrece tipos algebraicos, pattern matching, datos inmutables, una sintaxis pequena, errores de compilador utiles e interoperabilidad con bibliotecas Erlang y Elixir sobre BEAM.\n\nSe usa en servicios web, sistemas concurrentes, herramientas de linea de comandos, aplicaciones full-stack y proyectos que buscan la confiabilidad de BEAM con un sistema de tipos ligero y un modelo funcional accesible."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/glsl.ts
 var glsl_exports = {};
 __export(glsl_exports, {
@@ -1138,6 +1404,44 @@ var init_haskell = __esm({
   }
 });
 
+// src/languages/haxe.ts
+var haxe_exports = {};
+__export(haxe_exports, {
+  haxe: () => haxe
+});
+var haxe;
+var init_haxe = __esm({
+  "src/languages/haxe.ts"() {
+    haxe = {
+      slug: "haxe",
+      publishedDate: "2005-10-01",
+      extensions: [".hx", ".hxml"],
+      author: "Nicolas Cannasse / Haxe Foundation",
+      website: "https://haxe.org",
+      paradigms: ["object-oriented", "functional", "cross-platform", "statically typed"],
+      tooling: {
+        runtimes: ["JavaScript", "HashLink", "JVM", "C++", "C#", "PHP", "Lua", "Python"],
+        packageManagers: ["haxelib"],
+        ecosystems: ["Games", "Web", "Cross-platform Applications", "OpenFL", "Heaps"]
+      },
+      version: "4.3.7",
+      logo: "https://cdn.simpleicons.org/haxe/EA8220",
+      i18n: {
+        en: {
+          name: "Haxe",
+          description: "A cross-platform typed language that compiles to many runtimes and targets.",
+          longDescription: "Haxe is a high-level, statically typed programming language and compiler toolkit that targets JavaScript, C++, C#, Java, JVM bytecode, PHP, Lua, Python, HashLink, and other platforms. It includes type inference, macros, abstracts, generics, pattern matching, and a shared standard library.\n\nIt is used for games, web applications, creative coding, cross-platform tools, multimedia frameworks, and codebases that need to share typed business or engine logic across many targets."
+        },
+        es: {
+          name: "Haxe",
+          description: "Un lenguaje tipado multiplataforma que compila a muchos runtimes y destinos.",
+          longDescription: "Haxe es un lenguaje de programacion de alto nivel con tipado estatico y un toolkit de compilador que apunta a JavaScript, C++, C#, Java, bytecode JVM, PHP, Lua, Python, HashLink y otras plataformas. Incluye inferencia de tipos, macros, abstracts, genericos, pattern matching y una biblioteca estandar compartida.\n\nSe usa en juegos, aplicaciones web, creative coding, herramientas multiplataforma, frameworks multimedia y codebases que necesitan compartir logica tipada de negocio o motor entre muchos destinos."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/hcl.ts
 var hcl_exports = {};
 __export(hcl_exports, {
@@ -1802,6 +2106,44 @@ var init_nginx = __esm({
   }
 });
 
+// src/languages/nim.ts
+var nim_exports = {};
+__export(nim_exports, {
+  nim: () => nim
+});
+var nim;
+var init_nim = __esm({
+  "src/languages/nim.ts"() {
+    nim = {
+      slug: "nim",
+      publishedDate: "2008-08-20",
+      extensions: [".nim", ".nims", ".nimble"],
+      author: "Andreas Rumpf",
+      website: "https://nim-lang.org",
+      paradigms: ["systems", "imperative", "functional", "metaprogramming", "statically typed"],
+      tooling: {
+        runtimes: ["Native", "JavaScript"],
+        packageManagers: ["Nimble"],
+        ecosystems: ["Systems Programming", "CLI", "Web", "Embedded", "Native Applications"]
+      },
+      version: "2.2.10",
+      logo: "https://cdn.simpleicons.org/nim/FFE953",
+      i18n: {
+        en: {
+          name: "Nim",
+          description: "A compiled systems language with Python-like syntax, macros, and efficient native output.",
+          longDescription: "Nim is a statically typed compiled language designed for efficiency, expressiveness, and flexibility. It offers indentation-based syntax, generics, macros, templates, multiple memory-management strategies, C/C++/Objective-C interoperability, and compilation to C, C++, Objective-C, or JavaScript.\n\nIt is used for command-line tools, systems programming, embedded software, web services, scripting-like automation, native applications, and projects that want low overhead with powerful metaprogramming."
+        },
+        es: {
+          name: "Nim",
+          description: "Un lenguaje compilado de sistemas con sintaxis similar a Python, macros y salida nativa eficiente.",
+          longDescription: "Nim es un lenguaje compilado con tipado estatico disenado para eficiencia, expresividad y flexibilidad. Ofrece sintaxis basada en indentacion, genericos, macros, templates, varias estrategias de gestion de memoria, interoperabilidad con C/C++/Objective-C y compilacion a C, C++, Objective-C o JavaScript.\n\nSe usa en herramientas de linea de comandos, programacion de sistemas, software embebido, servicios web, automatizacion con estilo de scripting, aplicaciones nativas y proyectos que buscan bajo overhead con metaprogramacion potente."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/nix.ts
 var nix_exports = {};
 __export(nix_exports, {
@@ -2068,6 +2410,44 @@ var init_powershell = __esm({
   }
 });
 
+// src/languages/protobuf.ts
+var protobuf_exports = {};
+__export(protobuf_exports, {
+  protobuf: () => protobuf
+});
+var protobuf;
+var init_protobuf = __esm({
+  "src/languages/protobuf.ts"() {
+    protobuf = {
+      slug: "protobuf",
+      publishedDate: "2008-07-07",
+      extensions: [".proto"],
+      author: "Google",
+      website: "https://protobuf.dev",
+      paradigms: ["interface-definition", "schema", "declarative", "data-serialization"],
+      tooling: {
+        runtimes: ["Protocol Buffers Runtime", "gRPC"],
+        packageManagers: ["Buf", "npm", "Maven", "Go modules", "NuGet", "PyPI"],
+        ecosystems: ["gRPC", "APIs", "Microservices", "Data Serialization"]
+      },
+      version: "34.1",
+      logo: "https://cdn.simpleicons.org/google/4285F4",
+      i18n: {
+        en: {
+          name: "Protocol Buffers",
+          description: "Google's language-neutral schema format for structured data serialization and service APIs.",
+          longDescription: "Protocol Buffers is a language-neutral, platform-neutral mechanism for defining structured data schemas and generating strongly typed code in many programming languages. `.proto` files describe messages, fields, enums, services, packages, imports, options, and RPC contracts.\n\nIt is widely used with gRPC, microservices, distributed systems, APIs, telemetry, configuration, event streams, and storage formats that need compact binary serialization and stable cross-language contracts."
+        },
+        es: {
+          name: "Protocol Buffers",
+          description: "El formato de schemas neutral de Google para serializacion de datos estructurados y APIs de servicios.",
+          longDescription: "Protocol Buffers es un mecanismo neutral en lenguaje y plataforma para definir schemas de datos estructurados y generar codigo tipado en muchos lenguajes de programacion. Los archivos `.proto` describen mensajes, campos, enums, servicios, paquetes, imports, opciones y contratos RPC.\n\nSe usa ampliamente con gRPC, microservicios, sistemas distribuidos, APIs, telemetria, configuracion, flujos de eventos y formatos de almacenamiento que necesitan serializacion binaria compacta y contratos estables entre lenguajes."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/pug.ts
 var pug_exports = {};
 __export(pug_exports, {
@@ -2182,6 +2562,44 @@ var init_r = __esm({
   }
 });
 
+// src/languages/racket.ts
+var racket_exports = {};
+__export(racket_exports, {
+  racket: () => racket
+});
+var racket;
+var init_racket = __esm({
+  "src/languages/racket.ts"() {
+    racket = {
+      slug: "racket",
+      publishedDate: "1995-01-01",
+      extensions: [".rkt", ".rktd", ".rktl", ".scrbl"],
+      author: "Matthias Felleisen, Robert Bruce Findler, Matthew Flatt, Shriram Krishnamurthi",
+      website: "https://racket-lang.org",
+      paradigms: ["functional", "multi-paradigm", "language-oriented", "metaprogramming"],
+      tooling: {
+        runtimes: ["Racket CS", "Racket BC", "DrRacket"],
+        packageManagers: ["raco pkg"],
+        ecosystems: ["Education", "Language Design", "DSLs", "Research", "Scripting"]
+      },
+      version: "9.1",
+      logo: "https://commons.wikimedia.org/wiki/Special:FilePath/Racket-logo.svg",
+      i18n: {
+        en: {
+          name: "Racket",
+          description: "A Scheme-family language and platform for functional, educational, and language-oriented programming.",
+          longDescription: "Racket is a general-purpose programming language in the Scheme and Lisp family, designed as a platform for creating languages as well as applications. It includes modules, macros, contracts, pattern matching, a rich standard library, DrRacket, and tools for building domain-specific languages.\n\nIt is used in programming education, language design research, DSLs, compilers, scripting, web applications, documentation with Scribble, and projects that benefit from programmable syntax and interactive development."
+        },
+        es: {
+          name: "Racket",
+          description: "Un lenguaje de la familia Scheme y una plataforma para programacion funcional, educativa y orientada a lenguajes.",
+          longDescription: "Racket es un lenguaje de programacion de proposito general de la familia Scheme y Lisp, disenado como plataforma para crear lenguajes ademas de aplicaciones. Incluye modulos, macros, contratos, pattern matching, una biblioteca estandar amplia, DrRacket y herramientas para construir lenguajes especificos de dominio.\n\nSe usa en educacion en programacion, investigacion en diseno de lenguajes, DSLs, compiladores, scripting, aplicaciones web, documentacion con Scribble y proyectos que se benefician de sintaxis programable y desarrollo interactivo."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/razor.ts
 var razor_exports = {};
 __export(razor_exports, {
@@ -2593,6 +3011,44 @@ var init_swift = __esm({
   }
 });
 
+// src/languages/tcl.ts
+var tcl_exports = {};
+__export(tcl_exports, {
+  tcl: () => tcl
+});
+var tcl;
+var init_tcl = __esm({
+  "src/languages/tcl.ts"() {
+    tcl = {
+      slug: "tcl",
+      publishedDate: "1988-01-01",
+      extensions: [".tcl", ".tm", ".test"],
+      author: "John Ousterhout",
+      website: "https://www.tcl-lang.org",
+      paradigms: ["scripting", "command", "event-driven", "embeddable"],
+      tooling: {
+        runtimes: ["Tcl", "Tk", "tclsh", "wish"],
+        packageManagers: ["Teapot", "Tcl Modules"],
+        ecosystems: ["GUI Applications", "EDA", "Automation", "Embedded Scripting"]
+      },
+      version: "9.0.3",
+      logo: "https://www.tcl-lang.org/images/tcl-logo.png",
+      i18n: {
+        en: {
+          name: "Tcl/Tk",
+          description: "An embeddable command language and GUI toolkit for automation, tools, and applications.",
+          longDescription: "Tcl is a dynamic command language designed for embedding, scripting, automation, and extension. Tk is its cross-platform GUI toolkit. Together they provide a simple command syntax, event loop, strings-as-data model, embeddability, and portable user interface components.\n\nTcl/Tk is used for desktop tools, EDA and CAD automation, test harnesses, embedded scripting, build and deployment scripts, rapid prototypes, and applications that need a small extensible command language."
+        },
+        es: {
+          name: "Tcl/Tk",
+          description: "Un lenguaje de comandos embebible y toolkit GUI para automatizacion, herramientas y aplicaciones.",
+          longDescription: "Tcl es un lenguaje dinamico de comandos disenado para embedding, scripting, automatizacion y extension. Tk es su toolkit GUI multiplataforma. Juntos ofrecen una sintaxis simple de comandos, event loop, modelo de strings como datos, capacidad de embedding y componentes de interfaz portables.\n\nTcl/Tk se usa en herramientas de escritorio, automatizacion EDA y CAD, bancos de prueba, scripting embebido, scripts de build y despliegue, prototipos rapidos y aplicaciones que necesitan un lenguaje de comandos pequeno y extensible."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/toml.ts
 var toml_exports = {};
 __export(toml_exports, {
@@ -2960,12 +3416,16 @@ var init_zsh = __esm({
 // src/catalog.ts
 init_abap();
 init_actionscript();
+init_ada();
+init_apex();
 init_asp();
 init_assembly();
 init_astro();
+init_awk();
 init_bash();
 init_batch();
 init_c();
+init_clojure();
 init_cmake();
 init_cobol();
 init_coffeescript();
@@ -2974,20 +3434,24 @@ init_crystal();
 init_csharp();
 init_css();
 init_cuda();
+init_d();
 init_dart();
 init_dockerfile();
 init_elixir();
 init_elm();
 init_erlang();
+init_fennel();
 init_fortran();
 init_fsharp();
 init_git();
+init_gleam();
 init_glsl();
 init_go();
 init_gradle();
 init_graphql();
 init_groovy();
 init_haskell();
+init_haxe();
 init_hcl();
 init_html();
 init_ini();
@@ -3006,6 +3470,7 @@ init_matlab();
 init_meson();
 init_metal();
 init_nginx();
+init_nim();
 init_nix();
 init_objective_c();
 init_ocaml();
@@ -3013,9 +3478,11 @@ init_pascal();
 init_perl();
 init_php();
 init_powershell();
+init_protobuf();
 init_pug();
 init_python();
 init_r();
+init_racket();
 init_razor();
 init_ruby();
 init_rust();
@@ -3027,6 +3494,7 @@ init_svelte();
 init_svg();
 init_svn();
 init_swift();
+init_tcl();
 init_toml();
 init_typescript();
 init_visual_basic();
@@ -3040,13 +3508,17 @@ init_zsh();
 var languages = [
   abap,
   actionscript,
+  ada,
+  apex,
   asp,
   astro,
   assembly,
+  awk,
   bash,
   batch,
   c,
   cmake,
+  clojure,
   coffeescript,
   cobol,
   cpp,
@@ -3054,20 +3526,24 @@ var languages = [
   crystal,
   css,
   cuda,
+  d,
   dart,
   dockerfile,
   elixir,
   elm,
   erlang,
+  fennel,
   fortran,
   fsharp,
   git,
+  gleam,
   go,
   gradle,
   glsl,
   graphql,
   groovy,
   haskell,
+  haxe,
   hcl,
   html,
   ini,
@@ -3087,6 +3563,7 @@ var languages = [
   metal,
   svn,
   nginx,
+  nim,
   nix,
   ocaml,
   objectiveC,
@@ -3094,9 +3571,11 @@ var languages = [
   perl,
   php,
   powershell,
+  protobuf,
   pug,
   python,
   r,
+  racket,
   razor,
   ruby,
   rust,
@@ -3107,6 +3586,7 @@ var languages = [
   svg,
   svelte,
   swift,
+  tcl,
   toml,
   typescript,
   visualBasic,
@@ -3175,9 +3655,12 @@ var resolveLocale = (translations, locale) => {
 var languageIndex = [
   { slug: "abap", extensions: [".abap"] },
   { slug: "actionscript", extensions: [".as"] },
+  { slug: "ada", extensions: [".adb", ".ads", ".ada"] },
+  { slug: "apex", extensions: [".cls", ".trigger"] },
   { slug: "asp", extensions: [".asp", ".aspx", ".ascx", ".ashx", ".asmx", ".master"] },
   { slug: "astro", extensions: [".astro"] },
   { slug: "assembly", extensions: [".asm", ".s", ".S", ".inc"] },
+  { slug: "awk", extensions: [".awk"] },
   {
     slug: "bash",
     extensions: [".sh", ".bash", ".bashrc", ".bash_profile", ".bash_login", ".profile"]
@@ -3185,6 +3668,7 @@ var languageIndex = [
   { slug: "batch", extensions: [".bat", ".cmd"] },
   { slug: "c", extensions: [".c", ".h"] },
   { slug: "cmake", extensions: ["CMakeLists.txt", ".cmake"] },
+  { slug: "clojure", extensions: [".clj", ".cljs", ".cljc", ".edn", ".bb"] },
   { slug: "coffeescript", extensions: [".coffee", ".litcoffee", ".cson"] },
   { slug: "cobol", extensions: [".cob", ".cbl", ".cobol", ".cpy"] },
   { slug: "cpp", extensions: [".cpp", ".cc", ".cxx", ".h", ".hpp", ".hh", ".hxx"] },
@@ -3192,6 +3676,7 @@ var languageIndex = [
   { slug: "crystal", extensions: [".cr"] },
   { slug: "css", extensions: [".css"] },
   { slug: "cuda", extensions: [".cu", ".cuh"] },
+  { slug: "d", extensions: [".d", ".di"] },
   { slug: "dart", extensions: [".dart"] },
   { slug: "dockerfile", extensions: ["Dockerfile", ".dockerfile"] },
   { slug: "elixir", extensions: [".ex", ".exs", ".eex", ".leex", ".heex"] },
@@ -3200,12 +3685,14 @@ var languageIndex = [
     slug: "erlang",
     extensions: [".erl", ".hrl", ".app.src", ".escript", ".xrl", ".yrl", "rebar.config"]
   },
+  { slug: "fennel", extensions: [".fnl"] },
   {
     slug: "fortran",
     extensions: [".f", ".for", ".ftn", ".f90", ".f95", ".f03", ".f08", ".f18", ".f23"]
   },
   { slug: "fsharp", extensions: [".fs", ".fsi", ".fsx", ".fsscript"] },
   { slug: "git", extensions: [".git", ".gitignore", ".gitattributes", ".gitmodules", ".gitkeep"] },
+  { slug: "gleam", extensions: [".gleam"] },
   { slug: "go", extensions: [".go"] },
   { slug: "gradle", extensions: [".gradle", ".gradle.kts"] },
   {
@@ -3215,6 +3702,7 @@ var languageIndex = [
   { slug: "graphql", extensions: [".graphql", ".gql", ".graphqls"] },
   { slug: "groovy", extensions: [".groovy", ".gvy", ".gy", ".gsh"] },
   { 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: "html", extensions: [".html", ".htm"] },
   { slug: "ini", extensions: [".ini"] },
@@ -3234,6 +3722,7 @@ var languageIndex = [
   { slug: "metal", extensions: [".metal"] },
   { slug: "svn", extensions: [".svn", "svnserve.conf"] },
   { slug: "nginx", extensions: ["nginx.conf", ".nginx", ".conf"] },
+  { slug: "nim", extensions: [".nim", ".nims", ".nimble"] },
   { slug: "nix", extensions: [".nix"] },
   { slug: "ocaml", extensions: [".ml", ".mli", ".mll", ".mly", ".mlt", ".eliom", ".eliomi"] },
   { slug: "objective-c", extensions: [".m", ".mm"] },
@@ -3241,9 +3730,11 @@ var languageIndex = [
   { slug: "perl", extensions: [".pl", ".pm", ".pod", ".t", ".psgi"] },
   { slug: "php", extensions: [".php", ".phtml", ".php3", ".php4", ".php5", ".phps"] },
   { slug: "powershell", extensions: [".ps1", ".psm1", ".psd1", ".ps1xml"] },
+  { slug: "protobuf", extensions: [".proto"] },
   { slug: "pug", extensions: [".pug", ".jade"] },
   { slug: "python", extensions: [".py", ".pyw"] },
   { slug: "r", extensions: [".r", ".R", ".rmd", ".Rmd", ".qmd", ".Rprofile"] },
+  { slug: "racket", extensions: [".rkt", ".rktd", ".rktl", ".scrbl"] },
   { slug: "razor", extensions: [".cshtml", ".razor"] },
   {
     slug: "ruby",
@@ -3257,6 +3748,7 @@ var languageIndex = [
   { slug: "svg", extensions: [".svg", ".svgz"] },
   { slug: "svelte", extensions: [".svelte"] },
   { slug: "swift", extensions: [".swift"] },
+  { slug: "tcl", extensions: [".tcl", ".tm", ".test"] },
   { slug: "toml", extensions: [".toml"] },
   { slug: "typescript", extensions: [".ts", ".tsx", ".mts", ".cts"] },
   { slug: "visual-basic", extensions: [".vb"] },
@@ -3274,13 +3766,17 @@ var languageIndex = [
 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),
+  apex: () => Promise.resolve().then(() => (init_apex(), apex_exports)).then((module) => module.apex),
   asp: () => Promise.resolve().then(() => (init_asp(), asp_exports)).then((module) => module.asp),
   assembly: () => Promise.resolve().then(() => (init_assembly(), assembly_exports)).then((module) => module.assembly),
   astro: () => Promise.resolve().then(() => (init_astro(), astro_exports)).then((module) => module.astro),
+  awk: () => Promise.resolve().then(() => (init_awk(), awk_exports)).then((module) => module.awk),
   bash: () => Promise.resolve().then(() => (init_bash(), bash_exports)).then((module) => module.bash),
   batch: () => Promise.resolve().then(() => (init_batch(), batch_exports)).then((module) => module.batch),
   c: () => Promise.resolve().then(() => (init_c(), c_exports)).then((module) => module.c),
   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),
   cpp: () => Promise.resolve().then(() => (init_cpp(), cpp_exports)).then((module) => module.cpp),
@@ -3288,20 +3784,24 @@ var languageLoaders = {
   crystal: () => Promise.resolve().then(() => (init_crystal(), crystal_exports)).then((module) => module.crystal),
   css: () => Promise.resolve().then(() => (init_css(), css_exports)).then((module) => module.css),
   cuda: () => Promise.resolve().then(() => (init_cuda(), cuda_exports)).then((module) => module.cuda),
+  d: () => Promise.resolve().then(() => (init_d(), d_exports)).then((module) => module.d),
   dart: () => Promise.resolve().then(() => (init_dart(), dart_exports)).then((module) => module.dart),
   dockerfile: () => Promise.resolve().then(() => (init_dockerfile(), dockerfile_exports)).then((module) => module.dockerfile),
   elixir: () => Promise.resolve().then(() => (init_elixir(), elixir_exports)).then((module) => module.elixir),
   elm: () => Promise.resolve().then(() => (init_elm(), elm_exports)).then((module) => module.elm),
   erlang: () => Promise.resolve().then(() => (init_erlang(), erlang_exports)).then((module) => module.erlang),
+  fennel: () => Promise.resolve().then(() => (init_fennel(), fennel_exports)).then((module) => module.fennel),
   fortran: () => Promise.resolve().then(() => (init_fortran(), fortran_exports)).then((module) => module.fortran),
   fsharp: () => Promise.resolve().then(() => (init_fsharp(), fsharp_exports)).then((module) => module.fsharp),
   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),
   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),
   groovy: () => Promise.resolve().then(() => (init_groovy(), groovy_exports)).then((module) => module.groovy),
   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),
   html: () => Promise.resolve().then(() => (init_html(), html_exports)).then((module) => module.html),
   ini: () => Promise.resolve().then(() => (init_ini(), ini_exports)).then((module) => module.ini),
@@ -3321,6 +3821,7 @@ var languageLoaders = {
   metal: () => Promise.resolve().then(() => (init_metal(), metal_exports)).then((module) => module.metal),
   svn: () => Promise.resolve().then(() => (init_svn(), svn_exports)).then((module) => module.svn),
   nginx: () => Promise.resolve().then(() => (init_nginx(), nginx_exports)).then((module) => module.nginx),
+  nim: () => Promise.resolve().then(() => (init_nim(), nim_exports)).then((module) => module.nim),
   nix: () => Promise.resolve().then(() => (init_nix(), nix_exports)).then((module) => module.nix),
   ocaml: () => Promise.resolve().then(() => (init_ocaml(), ocaml_exports)).then((module) => module.ocaml),
   "objective-c": () => Promise.resolve().then(() => (init_objective_c(), objective_c_exports)).then((module) => module.objectiveC),
@@ -3328,9 +3829,11 @@ var languageLoaders = {
   perl: () => Promise.resolve().then(() => (init_perl(), perl_exports)).then((module) => module.perl),
   php: () => Promise.resolve().then(() => (init_php(), php_exports)).then((module) => module.php),
   powershell: () => Promise.resolve().then(() => (init_powershell(), powershell_exports)).then((module) => module.powershell),
+  protobuf: () => Promise.resolve().then(() => (init_protobuf(), protobuf_exports)).then((module) => module.protobuf),
   pug: () => Promise.resolve().then(() => (init_pug(), pug_exports)).then((module) => module.pug),
   python: () => Promise.resolve().then(() => (init_python(), python_exports)).then((module) => module.python),
   r: () => Promise.resolve().then(() => (init_r(), r_exports)).then((module) => module.r),
+  racket: () => Promise.resolve().then(() => (init_racket(), racket_exports)).then((module) => module.racket),
   razor: () => Promise.resolve().then(() => (init_razor(), razor_exports)).then((module) => module.razor),
   ruby: () => Promise.resolve().then(() => (init_ruby(), ruby_exports)).then((module) => module.ruby),
   rust: () => Promise.resolve().then(() => (init_rust(), rust_exports)).then((module) => module.rust),
@@ -3341,6 +3844,7 @@ var languageLoaders = {
   svelte: () => Promise.resolve().then(() => (init_svelte(), svelte_exports)).then((module) => module.svelte),
   svg: () => Promise.resolve().then(() => (init_svg(), svg_exports)).then((module) => module.svg),
   swift: () => Promise.resolve().then(() => (init_swift(), swift_exports)).then((module) => module.swift),
+  tcl: () => Promise.resolve().then(() => (init_tcl(), tcl_exports)).then((module) => module.tcl),
   toml: () => Promise.resolve().then(() => (init_toml(), toml_exports)).then((module) => module.toml),
   typescript: () => Promise.resolve().then(() => (init_typescript(), typescript_exports)).then((module) => module.typescript),
   "visual-basic": () => Promise.resolve().then(() => (init_visual_basic(), visual_basic_exports)).then((module) => module.visualBasic),