code-languages 1.21.0 → 1.22.0

package/dist/index.cjs

@@ -3249,6 +3249,44 @@ var init_makefile = __esm({
   }
 });
 
+// src/languages/mako.ts
+var mako_exports = {};
+__export(mako_exports, {
+  mako: () => exports.mako
+});
+exports.mako = void 0;
+var init_mako = __esm({
+  "src/languages/mako.ts"() {
+    exports.mako = {
+      slug: "mako",
+      publishedDate: "2006-07-17",
+      extensions: [".mako", ".mao"],
+      author: "Michael Bayer / Mako contributors",
+      website: "https://www.makotemplates.org",
+      paradigms: ["templating", "declarative", "scripting"],
+      tooling: {
+        runtimes: ["Python"],
+        packageManagers: ["pip", "uv", "Poetry"],
+        ecosystems: ["Python", "Web", "Documentation"]
+      },
+      version: "1.3.10",
+      logo: "https://cdn.simpleicons.org/python/3776AB",
+      i18n: {
+        en: {
+          name: "Mako",
+          description: "A Python template language for generating text, HTML, and source artifacts.",
+          longDescription: "Mako is a Python template language that mixes text with expressions, control blocks, inheritance, includes, and reusable definitions. Templates compile to Python code, which keeps it close to the host language.\n\nIt is used for web views, documentation, code generation, configuration rendering, and projects that need expressive Python-backed templates."
+        },
+        es: {
+          name: "Mako",
+          description: "Un lenguaje de plantillas de Python para generar texto, HTML y artefactos fuente.",
+          longDescription: "Mako es un lenguaje de plantillas de Python que mezcla texto con expresiones, bloques de control, herencia, includes y definiciones reutilizables. Las plantillas compilan a codigo Python y quedan cerca del lenguaje anfitrion.\n\nSe usa en vistas web, documentacion, generacion de codigo, renderizado de configuracion y proyectos que necesitan plantillas expresivas respaldadas por Python."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/markdown.ts
 var markdown_exports = {};
 __export(markdown_exports, {
@@ -3282,6 +3320,43 @@ var init_markdown = __esm({
   }
 });
 
+// src/languages/mathematica.ts
+var mathematica_exports = {};
+__export(mathematica_exports, {
+  mathematica: () => exports.mathematica
+});
+exports.mathematica = void 0;
+var init_mathematica = __esm({
+  "src/languages/mathematica.ts"() {
+    exports.mathematica = {
+      slug: "mathematica",
+      publishedDate: "1988-06-23",
+      extensions: [".wl", ".wls", ".nb"],
+      author: "Stephen Wolfram / Wolfram Research",
+      website: "https://www.wolfram.com/language/",
+      paradigms: ["symbolic", "functional", "rule-based", "notebook"],
+      tooling: {
+        runtimes: ["Wolfram Engine", "Wolfram Cloud", "Mathematica"],
+        ecosystems: ["Scientific Computing", "Symbolic Computing", "Notebooks"]
+      },
+      version: "14.3",
+      logo: "https://cdn.simpleicons.org/wolfram/DD1100",
+      i18n: {
+        en: {
+          name: "Wolfram Language",
+          description: "A symbolic computation language used by Mathematica and Wolfram tools.",
+          longDescription: "The Wolfram Language combines symbolic expressions, functional programming, pattern rules, notebooks, visualization, and a large knowledge-oriented standard library. Mathematica is its best-known interactive environment.\n\nIt is used for mathematics, modeling, data science, research notebooks, education, automation, and computational reports that benefit from symbolic and numeric workflows."
+        },
+        es: {
+          name: "Wolfram Language",
+          description: "Un lenguaje de computacion simbolica usado por Mathematica y herramientas Wolfram.",
+          longDescription: "Wolfram Language combina expresiones simbolicas, programacion funcional, reglas por patrones, notebooks, visualizacion y una biblioteca estandar orientada al conocimiento. Mathematica es su entorno interactivo mas conocido.\n\nSe usa en matematicas, modelado, ciencia de datos, notebooks de investigacion, educacion, automatizacion y reportes computacionales con flujos simbolicos y numericos."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/matlab.ts
 var matlab_exports = {};
 __export(matlab_exports, {
@@ -3471,6 +3546,82 @@ var init_metal = __esm({
   }
 });
 
+// src/languages/mojo.ts
+var mojo_exports = {};
+__export(mojo_exports, {
+  mojo: () => exports.mojo
+});
+exports.mojo = void 0;
+var init_mojo = __esm({
+  "src/languages/mojo.ts"() {
+    exports.mojo = {
+      slug: "mojo",
+      publishedDate: "2023-05-02",
+      extensions: [".mojo"],
+      author: "Modular",
+      website: "https://www.modular.com/mojo",
+      paradigms: ["imperative", "systems", "statically typed", "data-oriented"],
+      tooling: {
+        runtimes: ["Mojo toolchain", "MAX"],
+        packageManagers: ["pixi", "pip"],
+        ecosystems: ["AI", "Accelerators", "Python"]
+      },
+      version: "0.26.1",
+      logo: "https://avatars.githubusercontent.com/u/107116314?v=4",
+      i18n: {
+        en: {
+          name: "Mojo",
+          description: "A systems-oriented language for AI and accelerator-aware programming.",
+          longDescription: "Mojo is a language from Modular that combines Python-friendly syntax with ownership, value semantics, low-level control, and compiler features aimed at performance-sensitive code. Its toolchain targets CPUs and accelerator workflows.\n\nIt is used in experiments around AI kernels, numeric code, systems programming, Python-adjacent libraries, and workloads that need explicit performance control."
+        },
+        es: {
+          name: "Mojo",
+          description: "Un lenguaje orientado a sistemas para IA y programacion con aceleradores.",
+          longDescription: "Mojo es un lenguaje de Modular que combina una sintaxis cercana a Python con ownership, semantica de valores, control de bajo nivel y funciones de compilador pensadas para codigo sensible al rendimiento. Su toolchain apunta a CPUs y flujos con aceleradores.\n\nSe usa en experimentos con kernels de IA, codigo numerico, programacion de sistemas, bibliotecas cercanas a Python y cargas que necesitan control explicito del rendimiento."
+        }
+      }
+    };
+  }
+});
+
+// src/languages/moonbit.ts
+var moonbit_exports = {};
+__export(moonbit_exports, {
+  moonbit: () => exports.moonbit
+});
+exports.moonbit = void 0;
+var init_moonbit = __esm({
+  "src/languages/moonbit.ts"() {
+    exports.moonbit = {
+      slug: "moonbit",
+      publishedDate: "2023-08-18",
+      extensions: [".mbt"],
+      author: "MoonBit Team",
+      website: "https://www.moonbitlang.com",
+      paradigms: ["functional", "statically typed", "multi-paradigm", "wasm"],
+      tooling: {
+        runtimes: ["MoonBit toolchain", "WebAssembly", "JavaScript"],
+        packageManagers: ["moon"],
+        ecosystems: ["WebAssembly", "Web", "Embedded"]
+      },
+      version: "0.9.2",
+      logo: "https://avatars.githubusercontent.com/u/124476259?v=4",
+      i18n: {
+        en: {
+          name: "MoonBit",
+          description: "A statically typed language and toolchain designed for WebAssembly output.",
+          longDescription: "MoonBit is a language and toolchain built around fast feedback, algebraic data types, pattern matching, and multiple backends including WebAssembly. Its package and test tools are designed as part of the language workflow.\n\nIt is used for WebAssembly libraries, command-line experiments, web runtimes, teaching, and projects that want compact typed code with integrated tooling."
+        },
+        es: {
+          name: "MoonBit",
+          description: "Un lenguaje tipado y toolchain disenado para generar WebAssembly.",
+          longDescription: "MoonBit es un lenguaje y toolchain construido alrededor de feedback rapido, tipos algebraicos, pattern matching y varios backends, incluido WebAssembly. Sus herramientas de paquetes y pruebas forman parte del flujo del lenguaje.\n\nSe usa en bibliotecas WebAssembly, experimentos de linea de comandos, runtimes web, ensenanza y proyectos que buscan codigo tipado compacto con tooling integrado."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/nginx.ts
 var nginx_exports = {};
 __export(nginx_exports, {
@@ -3660,6 +3811,81 @@ var init_ocaml = __esm({
   }
 });
 
+// src/languages/odin.ts
+var odin_exports = {};
+__export(odin_exports, {
+  odin: () => exports.odin
+});
+exports.odin = void 0;
+var init_odin = __esm({
+  "src/languages/odin.ts"() {
+    exports.odin = {
+      slug: "odin",
+      publishedDate: "2016-11-05",
+      extensions: [".odin"],
+      author: "Ginger Bill",
+      website: "https://odin-lang.org",
+      paradigms: ["imperative", "procedural", "systems", "data-oriented"],
+      tooling: {
+        runtimes: ["Odin compiler"],
+        packageManagers: ["odin"],
+        ecosystems: ["Systems", "Game Development", "Native"]
+      },
+      version: "dev-2026-02",
+      logo: "https://avatars.githubusercontent.com/u/12533910?v=4",
+      i18n: {
+        en: {
+          name: "Odin",
+          description: "A data-oriented systems language for native software and game tooling.",
+          longDescription: "Odin is a procedural systems programming language with explicit memory control, packages, foreign interfaces, custom allocators, and language features oriented toward data layout. It favors straightforward native code over large runtime machinery.\n\nIt is used for engines, tools, graphics programs, native utilities, and performance-sensitive applications where predictable control over data matters."
+        },
+        es: {
+          name: "Odin",
+          description: "Un lenguaje de sistemas orientado a datos para software nativo y juegos.",
+          longDescription: "Odin es un lenguaje procedural de programacion de sistemas con control explicito de memoria, paquetes, interfaces externas, allocators personalizados y funciones orientadas al layout de datos. Favorece codigo nativo directo sobre runtimes grandes.\n\nSe usa en motores, herramientas, programas graficos, utilidades nativas y aplicaciones sensibles al rendimiento donde importa el control predecible de los datos."
+        }
+      }
+    };
+  }
+});
+
+// src/languages/opencl.ts
+var opencl_exports = {};
+__export(opencl_exports, {
+  opencl: () => exports.opencl
+});
+exports.opencl = void 0;
+var init_opencl = __esm({
+  "src/languages/opencl.ts"() {
+    exports.opencl = {
+      slug: "opencl",
+      publishedDate: "2008-12-08",
+      extensions: [".cl", ".clh"],
+      author: "Khronos Group",
+      website: "https://www.khronos.org/opencl/",
+      paradigms: ["parallel", "kernel", "data-parallel", "c-family"],
+      tooling: {
+        runtimes: ["OpenCL Runtime"],
+        ecosystems: ["GPU Compute", "Heterogeneous Computing", "Khronos"]
+      },
+      version: "OpenCL C 3.0",
+      logo: "https://cdn.simpleicons.org/khronosgroup/CC3333",
+      i18n: {
+        en: {
+          name: "OpenCL C",
+          description: "The C-based kernel language for OpenCL heterogeneous compute programs.",
+          longDescription: "OpenCL C is the kernel programming language used by OpenCL to describe parallel work over devices such as CPUs, GPUs, and accelerators. It extends a C-family model with address spaces, vector types, work-items, and synchronization primitives.\n\nIt is used for compute kernels, image processing, simulations, numeric workloads, and portable heterogeneous programs that target OpenCL runtimes."
+        },
+        es: {
+          name: "OpenCL C",
+          description: "El lenguaje de kernels basado en C para programas de computo OpenCL.",
+          longDescription: "OpenCL C es el lenguaje de kernels que usa OpenCL para describir trabajo paralelo sobre dispositivos como CPUs, GPUs y aceleradores. Extiende un modelo de la familia C con espacios de direcciones, tipos vectoriales, work-items y primitivas de sincronizacion.\n\nSe usa en kernels de computo, procesamiento de imagenes, simulaciones, cargas numericas y programas heterogeneos portables dirigidos a runtimes OpenCL."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/pascal.ts
 var pascal_exports = {};
 __export(pascal_exports, {
@@ -3774,6 +4000,43 @@ var init_php = __esm({
   }
 });
 
+// src/languages/pine-script.ts
+var pine_script_exports = {};
+__export(pine_script_exports, {
+  pineScript: () => exports.pineScript
+});
+exports.pineScript = void 0;
+var init_pine_script = __esm({
+  "src/languages/pine-script.ts"() {
+    exports.pineScript = {
+      slug: "pine-script",
+      publishedDate: "2013-12-01",
+      extensions: [".pine"],
+      author: "TradingView",
+      website: "https://www.tradingview.com/pine-script-docs/",
+      paradigms: ["domain-specific", "time-series", "declarative", "scripting"],
+      tooling: {
+        runtimes: ["TradingView"],
+        ecosystems: ["Charts", "Trading", "Technical Analysis"]
+      },
+      version: "v6",
+      logo: "https://cdn.simpleicons.org/tradingview/131722",
+      i18n: {
+        en: {
+          name: "Pine Script",
+          description: "TradingView's language for indicators, strategies, and chart studies.",
+          longDescription: "Pine Script is a domain-specific language for expressing calculations over chart bars, series values, indicators, alerts, and trading strategies in TradingView. Its execution model is centered on time-series data.\n\nIt is used for custom technical indicators, backtested strategies, chart overlays, alerts, and market analysis shared through TradingView."
+        },
+        es: {
+          name: "Pine Script",
+          description: "El lenguaje de TradingView para indicadores, estrategias y estudios de graficos.",
+          longDescription: "Pine Script es un lenguaje de dominio especifico para expresar calculos sobre barras, series, indicadores, alertas y estrategias de trading en TradingView. Su modelo de ejecucion gira alrededor de datos temporales.\n\nSe usa en indicadores tecnicos personalizados, estrategias con backtesting, overlays de graficos, alertas y analisis de mercado compartido en TradingView."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/plantuml.ts
 var plantuml_exports = {};
 __export(plantuml_exports, {
@@ -3812,6 +4075,81 @@ var init_plantuml = __esm({
   }
 });
 
+// src/languages/plsql.ts
+var plsql_exports = {};
+__export(plsql_exports, {
+  plsql: () => exports.plsql
+});
+exports.plsql = void 0;
+var init_plsql = __esm({
+  "src/languages/plsql.ts"() {
+    exports.plsql = {
+      slug: "plsql",
+      publishedDate: "1992-01-01",
+      extensions: [".pls", ".pks", ".pkb", ".plsql"],
+      author: "Oracle",
+      website: "https://www.oracle.com/database/technologies/appdev/plsql.html",
+      paradigms: ["procedural", "database", "declarative", "imperative"],
+      tooling: {
+        runtimes: ["Oracle Database"],
+        ecosystems: ["Oracle", "SQL", "Enterprise Data"]
+      },
+      version: "Oracle Database 26ai",
+      logo: "https://github.com/oracle.png",
+      i18n: {
+        en: {
+          name: "Oracle PL/SQL",
+          description: "Oracle's procedural extension to SQL for database programs and packages.",
+          longDescription: "PL/SQL adds blocks, variables, exceptions, procedures, functions, packages, cursors, and triggers to Oracle SQL. It keeps database logic close to data and transactional behavior inside Oracle Database.\n\nIt is used for stored procedures, migration scripts, business rules, batch jobs, packages, and enterprise database applications built on Oracle."
+        },
+        es: {
+          name: "Oracle PL/SQL",
+          description: "La extension procedural de SQL de Oracle para programas y paquetes de base de datos.",
+          longDescription: "PL/SQL agrega bloques, variables, excepciones, procedimientos, funciones, paquetes, cursores y triggers a Oracle SQL. Mantiene logica de base de datos cerca de los datos y del comportamiento transaccional en Oracle Database.\n\nSe usa en stored procedures, scripts de migracion, reglas de negocio, trabajos batch, paquetes y aplicaciones empresariales construidas sobre Oracle."
+        }
+      }
+    };
+  }
+});
+
+// src/languages/pony.ts
+var pony_exports = {};
+__export(pony_exports, {
+  pony: () => exports.pony
+});
+exports.pony = void 0;
+var init_pony = __esm({
+  "src/languages/pony.ts"() {
+    exports.pony = {
+      slug: "pony",
+      publishedDate: "2015-04-29",
+      extensions: [".pony"],
+      author: "Sylvan Clebsch / Pony contributors",
+      website: "https://www.ponylang.io",
+      paradigms: ["actor-model", "object-oriented", "capability-secure", "concurrent"],
+      tooling: {
+        runtimes: ["Pony runtime"],
+        packageManagers: ["ponyup", "corral"],
+        ecosystems: ["Actors", "Native", "Distributed Systems"]
+      },
+      version: "0.61.1",
+      logo: "https://avatars.githubusercontent.com/u/14593805?v=4",
+      i18n: {
+        en: {
+          name: "Pony",
+          description: "An actor language with reference capabilities and data-race safety.",
+          longDescription: "Pony combines actors, object capabilities, static typing, and reference capabilities to make concurrent native programs explicit about aliasing and mutation. The language runtime schedules isolated actors that communicate by messages.\n\nIt is used for concurrent services, native experiments, actor systems, and programs that want compile-time guarantees around data races."
+        },
+        es: {
+          name: "Pony",
+          description: "Un lenguaje de actores con capacidades de referencia y seguridad ante data races.",
+          longDescription: "Pony combina actores, object capabilities, tipado estatico y capacidades de referencia para que programas nativos concurrentes sean explicitos sobre aliasing y mutacion. El runtime agenda actores aislados que se comunican por mensajes.\n\nSe usa en servicios concurrentes, experimentos nativos, sistemas de actores y programas que buscan garantias de compilacion frente a data races."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/powershell.ts
 var powershell_exports = {};
 __export(powershell_exports, {
@@ -3888,6 +4226,43 @@ var init_prolog = __esm({
   }
 });
 
+// src/languages/promql.ts
+var promql_exports = {};
+__export(promql_exports, {
+  promql: () => exports.promql
+});
+exports.promql = void 0;
+var init_promql = __esm({
+  "src/languages/promql.ts"() {
+    exports.promql = {
+      slug: "promql",
+      publishedDate: "2012-11-24",
+      extensions: [".promql"],
+      author: "Prometheus Authors",
+      website: "https://prometheus.io/docs/prometheus/latest/querying/basics/",
+      paradigms: ["query", "time-series", "declarative", "domain-specific"],
+      tooling: {
+        runtimes: ["Prometheus", "Thanos", "Mimir"],
+        ecosystems: ["Observability", "Metrics", "Monitoring"]
+      },
+      version: "Prometheus 3.x",
+      logo: "https://cdn.simpleicons.org/prometheus/E6522C",
+      i18n: {
+        en: {
+          name: "PromQL",
+          description: "The Prometheus query language for selecting and aggregating metrics.",
+          longDescription: "PromQL is the expression language used by Prometheus to select instant vectors, range vectors, scalars, and strings from time-series data. It includes label matching, arithmetic, aggregation, and functions for metric analysis.\n\nIt is used in dashboards, alerts, recording rules, troubleshooting, capacity analysis, and observability systems compatible with Prometheus queries."
+        },
+        es: {
+          name: "PromQL",
+          description: "El lenguaje de consulta de Prometheus para seleccionar y agregar metricas.",
+          longDescription: "PromQL es el lenguaje de expresiones que usa Prometheus para seleccionar vectores instantaneos, rangos, escalares y cadenas desde datos de series temporales. Incluye matching de labels, aritmetica, agregaciones y funciones para analizar metricas.\n\nSe usa en dashboards, alertas, recording rules, troubleshooting, analisis de capacidad y sistemas de observabilidad compatibles con consultas Prometheus."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/protobuf.ts
 var protobuf_exports = {};
 __export(protobuf_exports, {
@@ -3964,6 +4339,44 @@ var init_pug = __esm({
   }
 });
 
+// src/languages/purescript.ts
+var purescript_exports = {};
+__export(purescript_exports, {
+  purescript: () => exports.purescript
+});
+exports.purescript = void 0;
+var init_purescript = __esm({
+  "src/languages/purescript.ts"() {
+    exports.purescript = {
+      slug: "purescript",
+      publishedDate: "2013-09-01",
+      extensions: [".purs"],
+      author: "Phil Freeman / PureScript contributors",
+      website: "https://www.purescript.org",
+      paradigms: ["functional", "pure", "statically typed", "declarative"],
+      tooling: {
+        runtimes: ["JavaScript", "Node.js"],
+        packageManagers: ["Spago", "npm"],
+        ecosystems: ["Web", "Functional Programming", "JavaScript"]
+      },
+      version: "0.15.15",
+      logo: "https://cdn.simpleicons.org/purescript/14161A",
+      i18n: {
+        en: {
+          name: "PureScript",
+          description: "A strongly typed purely functional language that compiles to JavaScript.",
+          longDescription: "PureScript brings algebraic data types, type classes, effects, modules, row polymorphism, and a Haskell-influenced functional model to JavaScript targets. Its compiler emits readable JavaScript and works with foreign JavaScript modules.\n\nIt is used for front-end applications, libraries, typed domain models, functional architecture, and JavaScript projects that want explicit effect handling."
+        },
+        es: {
+          name: "PureScript",
+          description: "Un lenguaje funcional puro y fuertemente tipado que compila a JavaScript.",
+          longDescription: "PureScript lleva tipos algebraicos, type classes, efectos, modulos, row polymorphism y un modelo funcional influido por Haskell a objetivos JavaScript. Su compilador emite JavaScript legible e interoperable con modulos externos.\n\nSe usa en aplicaciones front-end, bibliotecas, modelos de dominio tipados, arquitectura funcional y proyectos JavaScript que buscan manejo explicito de efectos."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/python.ts
 var python_exports = {};
 __export(python_exports, {
@@ -4040,6 +4453,44 @@ var init_qml = __esm({
   }
 });
 
+// src/languages/qsharp.ts
+var qsharp_exports = {};
+__export(qsharp_exports, {
+  qsharp: () => exports.qsharp
+});
+exports.qsharp = void 0;
+var init_qsharp = __esm({
+  "src/languages/qsharp.ts"() {
+    exports.qsharp = {
+      slug: "qsharp",
+      publishedDate: "2017-12-11",
+      extensions: [".qs"],
+      author: "Microsoft",
+      website: "https://learn.microsoft.com/azure/quantum/qsharp-overview",
+      paradigms: ["quantum", "domain-specific", "functional", "imperative"],
+      tooling: {
+        runtimes: ["Azure Quantum", "Q# compiler"],
+        packageManagers: ["NuGet", "Python"],
+        ecosystems: ["Quantum Computing", "Azure"]
+      },
+      version: "Q# 1.0",
+      logo: "https://github.com/microsoft.png",
+      i18n: {
+        en: {
+          name: "Q#",
+          description: "Microsoft's language for expressing quantum programs and operations.",
+          longDescription: "Q# is a quantum programming language for declaring operations, functions, qubit use, measurement, adjoints, controlled operations, and classical control around quantum routines. It is designed to model quantum algorithms separately from hardware details.\n\nIt is used for quantum algorithm development, simulation, teaching, Azure Quantum workflows, and hybrid experiments that combine classical and quantum code."
+        },
+        es: {
+          name: "Q#",
+          description: "El lenguaje de Microsoft para expresar programas y operaciones cuanticas.",
+          longDescription: "Q# es un lenguaje de programacion cuantica para declarar operaciones, funciones, uso de qubits, mediciones, adjoints, operaciones controladas y control clasico alrededor de rutinas cuanticas. Modela algoritmos cuanticos separados de detalles de hardware.\n\nSe usa en desarrollo de algoritmos cuanticos, simulacion, ensenanza, flujos de Azure Quantum y experimentos hibridos que combinan codigo clasico y cuantico."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/r.ts
 var r_exports = {};
 __export(r_exports, {
@@ -4116,6 +4567,44 @@ var init_racket = __esm({
   }
 });
 
+// src/languages/raku.ts
+var raku_exports = {};
+__export(raku_exports, {
+  raku: () => exports.raku
+});
+exports.raku = void 0;
+var init_raku = __esm({
+  "src/languages/raku.ts"() {
+    exports.raku = {
+      slug: "raku",
+      publishedDate: "2015-12-25",
+      extensions: [".raku", ".rakumod", ".rakudoc", ".rakutest", ".p6", ".pm6"],
+      author: "Raku Community",
+      website: "https://raku.org",
+      paradigms: ["multi-paradigm", "object-oriented", "functional", "concurrent"],
+      tooling: {
+        runtimes: ["Rakudo", "MoarVM"],
+        packageManagers: ["zef"],
+        ecosystems: ["Raku", "CLI", "Text Processing"]
+      },
+      version: "6.d",
+      logo: "https://github.com/Raku.png",
+      i18n: {
+        en: {
+          name: "Raku",
+          description: "A multi-paradigm language with grammars, concurrency, and rich dispatch.",
+          longDescription: "Raku is a sibling of Perl with gradual typing, signatures, multiple dispatch, grammars, junctions, concurrency primitives, and expressive operators. It is designed for both small scripts and larger language-oriented programs.\n\nIt is used for text processing, command-line tools, parsers, automation, experimentation, and applications that benefit from built-in grammar support."
+        },
+        es: {
+          name: "Raku",
+          description: "Un lenguaje multiparadigma con grammars, concurrencia y dispatch expresivo.",
+          longDescription: "Raku es un lenguaje hermano de Perl con tipado gradual, firmas, multiple dispatch, grammars, junctions, primitivas concurrentes y operadores expresivos. Sirve tanto para scripts pequenos como para programas orientados a lenguajes.\n\nSe usa en procesamiento de texto, herramientas de linea de comandos, parsers, automatizacion, experimentacion y aplicaciones que aprovechan soporte integrado para grammars."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/razor.ts
 var razor_exports = {};
 __export(razor_exports, {
@@ -4154,6 +4643,44 @@ var init_razor = __esm({
   }
 });
 
+// src/languages/reasonml.ts
+var reasonml_exports = {};
+__export(reasonml_exports, {
+  reasonml: () => exports.reasonml
+});
+exports.reasonml = void 0;
+var init_reasonml = __esm({
+  "src/languages/reasonml.ts"() {
+    exports.reasonml = {
+      slug: "reasonml",
+      publishedDate: "2016-05-13",
+      extensions: [".re", ".rei"],
+      author: "Jordan Walke / Reason contributors",
+      website: "https://reasonml.github.io",
+      paradigms: ["functional", "statically typed", "multi-paradigm"],
+      tooling: {
+        runtimes: ["OCaml", "JavaScript"],
+        packageManagers: ["opam", "npm"],
+        ecosystems: ["OCaml", "JavaScript", "Web"]
+      },
+      version: "3.13.0",
+      logo: "https://cdn.simpleicons.org/reason/DD4B39",
+      i18n: {
+        en: {
+          name: "ReasonML",
+          description: "A JavaScript-like syntax for OCaml and typed functional programming.",
+          longDescription: "ReasonML is a syntax layer for OCaml that presents familiar braces and punctuation while retaining OCaml's modules, pattern matching, type inference, and functional foundations. It has been used with native OCaml and JavaScript compilation workflows.\n\nIt is used in OCaml-adjacent projects, typed UI code, libraries, and codebases that prefer Reason syntax over traditional OCaml syntax."
+        },
+        es: {
+          name: "ReasonML",
+          description: "Una sintaxis cercana a JavaScript para OCaml y programacion funcional tipada.",
+          longDescription: "ReasonML es una capa de sintaxis para OCaml que presenta llaves y puntuacion familiares conservando modulos, pattern matching, inferencia de tipos y bases funcionales de OCaml. Se ha usado con flujos nativos y de compilacion a JavaScript.\n\nSe usa en proyectos cercanos a OCaml, UI tipada, bibliotecas y codebases que prefieren la sintaxis Reason frente a la sintaxis tradicional de OCaml."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/rego.ts
 var rego_exports = {};
 __export(rego_exports, {
@@ -4192,6 +4719,82 @@ var init_rego = __esm({
   }
 });
 
+// src/languages/rescript.ts
+var rescript_exports = {};
+__export(rescript_exports, {
+  rescript: () => exports.rescript
+});
+exports.rescript = void 0;
+var init_rescript = __esm({
+  "src/languages/rescript.ts"() {
+    exports.rescript = {
+      slug: "rescript",
+      publishedDate: "2020-07-01",
+      extensions: [".res", ".resi"],
+      author: "ReScript Association",
+      website: "https://rescript-lang.org",
+      paradigms: ["functional", "statically typed", "multi-paradigm", "javascript-targeted"],
+      tooling: {
+        runtimes: ["JavaScript", "Node.js", "Browser"],
+        packageManagers: ["npm", "pnpm", "Yarn"],
+        ecosystems: ["Web", "React", "JavaScript"]
+      },
+      version: "12.0.0",
+      logo: "https://cdn.simpleicons.org/rescript/E6484A",
+      i18n: {
+        en: {
+          name: "ReScript",
+          description: "A typed language and compiler focused on ergonomic JavaScript output.",
+          longDescription: "ReScript is a statically typed language for JavaScript targets with pattern matching, variants, modules, records, interop annotations, and a syntax tuned for web development. Its compiler and build tools focus on predictable generated JavaScript.\n\nIt is used in front-end applications, React codebases, shared libraries, and JavaScript projects that want compact type-safe source with explicit interop."
+        },
+        es: {
+          name: "ReScript",
+          description: "Un lenguaje tipado y compilador enfocado en generar JavaScript ergonomico.",
+          longDescription: "ReScript es un lenguaje de tipado estatico para objetivos JavaScript con pattern matching, variants, modulos, records, anotaciones de interop y una sintaxis ajustada al desarrollo web. Su compilador y herramientas buscan JavaScript generado predecible.\n\nSe usa en aplicaciones front-end, codebases React, bibliotecas compartidas y proyectos JavaScript que buscan fuente compacta y segura con interop explicito."
+        }
+      }
+    };
+  }
+});
+
+// src/languages/restructuredtext.ts
+var restructuredtext_exports = {};
+__export(restructuredtext_exports, {
+  restructuredtext: () => exports.restructuredtext
+});
+exports.restructuredtext = void 0;
+var init_restructuredtext = __esm({
+  "src/languages/restructuredtext.ts"() {
+    exports.restructuredtext = {
+      slug: "restructuredtext",
+      publishedDate: "2001-06-01",
+      extensions: [".rst", ".rest"],
+      author: "David Goodger / Docutils contributors",
+      website: "https://docutils.sourceforge.io/rst.html",
+      paradigms: ["markup", "declarative", "documentation"],
+      tooling: {
+        runtimes: ["Docutils", "Sphinx"],
+        packageManagers: ["pip"],
+        ecosystems: ["Python", "Documentation", "Publishing"]
+      },
+      version: "Docutils 0.22.2",
+      logo: "https://cdn.simpleicons.org/readthedocs/8CA1AF",
+      i18n: {
+        en: {
+          name: "reStructuredText",
+          description: "A plain-text markup format used by Docutils and Sphinx documentation.",
+          longDescription: "reStructuredText is a structured plain-text markup language with sections, directives, roles, references, tables, lists, and extension points. Docutils defines the parser model and Sphinx extends it for technical documentation.\n\nIt is used for Python documentation, manuals, API references, books, project notes, and publishing workflows that need semantic markup from readable text."
+        },
+        es: {
+          name: "reStructuredText",
+          description: "Un formato de marcado en texto plano usado por Docutils y Sphinx.",
+          longDescription: "reStructuredText es un lenguaje de marcado estructurado en texto plano con secciones, directives, roles, referencias, tablas, listas y puntos de extension. Docutils define su modelo de parser y Sphinx lo extiende para documentacion tecnica.\n\nSe usa en documentacion Python, manuales, referencias API, libros, notas de proyectos y flujos de publicacion que necesitan marcado semantico desde texto legible."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/ruby.ts
 var ruby_exports = {};
 __export(ruby_exports, {
@@ -4268,6 +4871,43 @@ var init_rust = __esm({
   }
 });
 
+// src/languages/sas.ts
+var sas_exports = {};
+__export(sas_exports, {
+  sas: () => exports.sas
+});
+exports.sas = void 0;
+var init_sas = __esm({
+  "src/languages/sas.ts"() {
+    exports.sas = {
+      slug: "sas",
+      publishedDate: "1976-01-01",
+      extensions: [".sas"],
+      author: "SAS Institute",
+      website: "https://www.sas.com",
+      paradigms: ["data-step", "procedural", "statistical", "domain-specific"],
+      tooling: {
+        runtimes: ["SAS 9", "SAS Viya"],
+        ecosystems: ["Analytics", "Statistics", "Enterprise Data"]
+      },
+      version: "SAS 9.4",
+      logo: "https://upload.wikimedia.org/wikipedia/commons/1/10/SAS_logo_horiz.svg",
+      i18n: {
+        en: {
+          name: "SAS",
+          description: "A language and system for statistical analysis and data processing.",
+          longDescription: "SAS programs combine DATA steps, procedures, macros, formats, libraries, and analytics-oriented statements to transform and analyze data. The language is tightly linked to the SAS platform and its statistical tooling.\n\nIt is used in analytics, regulated reporting, clinical workflows, data preparation, forecasting, and enterprise statistical systems."
+        },
+        es: {
+          name: "SAS",
+          description: "Un lenguaje y sistema para analisis estadistico y procesamiento de datos.",
+          longDescription: "Los programas SAS combinan DATA steps, procedimientos, macros, formatos, libraries y sentencias orientadas a analitica para transformar y analizar datos. El lenguaje esta ligado a la plataforma SAS y su tooling estadistico.\n\nSe usa en analitica, reportes regulados, flujos clinicos, preparacion de datos, pronosticos y sistemas estadisticos empresariales."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/scala.ts
 var scala_exports = {};
 __export(scala_exports, {
@@ -4306,6 +4946,43 @@ var init_scala = __esm({
   }
 });
 
+// src/languages/scheme.ts
+var scheme_exports = {};
+__export(scheme_exports, {
+  scheme: () => exports.scheme
+});
+exports.scheme = void 0;
+var init_scheme = __esm({
+  "src/languages/scheme.ts"() {
+    exports.scheme = {
+      slug: "scheme",
+      publishedDate: "1975-12-01",
+      extensions: [".scm", ".ss", ".sld", ".sls"],
+      author: "Guy L. Steele Jr. / Gerald Jay Sussman",
+      website: "https://www.scheme.org",
+      paradigms: ["functional", "lisp", "minimal", "multi-paradigm"],
+      tooling: {
+        runtimes: ["Chez Scheme", "Guile", "Racket", "Chicken"],
+        ecosystems: ["Lisp", "Education", "Language Research"]
+      },
+      version: "R7RS small",
+      logo: "https://cdn.simpleicons.org/racket/9F1D20",
+      i18n: {
+        en: {
+          name: "Scheme",
+          description: "A small Lisp family language centered on lexical scope and procedures.",
+          longDescription: "Scheme is a Lisp dialect known for a compact core, lexical scoping, first-class procedures, macros, continuations, and a tradition of language experimentation. Standards define a portable base while implementations add libraries and tooling.\n\nIt is used in teaching, compilers, scripting, research, embedded extension systems, and programs that value a small expressive language core."
+        },
+        es: {
+          name: "Scheme",
+          description: "Un lenguaje de la familia Lisp centrado en alcance lexico y procedimientos.",
+          longDescription: "Scheme es un dialecto Lisp conocido por un nucleo compacto, alcance lexico, procedimientos de primera clase, macros, continuations y una tradicion de experimentacion con lenguajes. Los estandares definen una base portable mientras las implementaciones agregan bibliotecas.\n\nSe usa en ensenanza, compiladores, scripting, investigacion, sistemas de extension embebidos y programas que valoran un nucleo expresivo pequeno."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/scss.ts
 var scss_exports = {};
 __export(scss_exports, {
@@ -4344,6 +5021,81 @@ var init_scss = __esm({
   }
 });
 
+// src/languages/smalltalk.ts
+var smalltalk_exports = {};
+__export(smalltalk_exports, {
+  smalltalk: () => exports.smalltalk
+});
+exports.smalltalk = void 0;
+var init_smalltalk = __esm({
+  "src/languages/smalltalk.ts"() {
+    exports.smalltalk = {
+      slug: "smalltalk",
+      publishedDate: "1972-01-01",
+      extensions: [".st"],
+      author: "Alan Kay / Dan Ingalls / Adele Goldberg",
+      website: "https://squeak.org",
+      paradigms: ["object-oriented", "message-passing", "reflective", "dynamic"],
+      tooling: {
+        runtimes: ["Pharo", "Squeak", "GNU Smalltalk"],
+        ecosystems: ["Images", "Education", "Object Systems"]
+      },
+      version: "ANSI INCITS 319-1998",
+      logo: "https://commons.wikimedia.org/wiki/Special:FilePath/Smalltalk_Balloon.svg",
+      i18n: {
+        en: {
+          name: "Smalltalk",
+          description: "A message-oriented object language with live image-based environments.",
+          longDescription: "Smalltalk helped define object-oriented programming through message sends, classes, blocks, reflection, and interactive image environments. Many implementations pair the language with live browsers, inspectors, and debuggers.\n\nIt is used for education, research, long-lived business systems, simulations, and exploratory programming inside live object images."
+        },
+        es: {
+          name: "Smalltalk",
+          description: "Un lenguaje orientado a mensajes y objetos con entornos de imagen vivos.",
+          longDescription: "Smalltalk ayudo a definir la programacion orientada a objetos mediante mensajes, clases, bloques, reflexion y entornos interactivos basados en imagenes. Muchas implementaciones combinan el lenguaje con browsers, inspectors y debuggers vivos.\n\nSe usa en educacion, investigacion, sistemas de negocio longevos, simulaciones y programacion exploratoria dentro de imagenes de objetos."
+        }
+      }
+    };
+  }
+});
+
+// src/languages/smarty.ts
+var smarty_exports = {};
+__export(smarty_exports, {
+  smarty: () => exports.smarty
+});
+exports.smarty = void 0;
+var init_smarty = __esm({
+  "src/languages/smarty.ts"() {
+    exports.smarty = {
+      slug: "smarty",
+      publishedDate: "2001-01-01",
+      extensions: [".tpl", ".smarty"],
+      author: "Monte Ohrt / Andrei Zmievski / Smarty contributors",
+      website: "https://www.smarty.net",
+      paradigms: ["templating", "declarative", "markup"],
+      tooling: {
+        runtimes: ["PHP"],
+        packageManagers: ["Composer"],
+        ecosystems: ["PHP", "Web"]
+      },
+      version: "5.5.1",
+      logo: "https://www.smarty.net/images/logo_print.gif",
+      i18n: {
+        en: {
+          name: "Smarty",
+          description: "A PHP template language for presentation logic and reusable views.",
+          longDescription: "Smarty is a PHP templating system with tags, modifiers, functions, plugins, inheritance, and caching features for separating presentation templates from application code. Templates are compiled for execution by PHP.\n\nIt is used in PHP applications, themes, CMS views, emails, and server-rendered web projects that maintain separate template files."
+        },
+        es: {
+          name: "Smarty",
+          description: "Un lenguaje de plantillas PHP para logica de presentacion y vistas reutilizables.",
+          longDescription: "Smarty es un sistema de plantillas PHP con tags, modifiers, funciones, plugins, herencia y cache para separar plantillas de presentacion del codigo de aplicacion. Las plantillas se compilan para ejecutarse con PHP.\n\nSe usa en aplicaciones PHP, temas, vistas de CMS, emails y proyectos web renderizados en servidor que mantienen archivos de plantillas separados."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/solidity.ts
 var solidity_exports = {};
 __export(solidity_exports, {
@@ -4415,6 +5167,43 @@ var init_sql = __esm({
   }
 });
 
+// src/languages/standard-ml.ts
+var standard_ml_exports = {};
+__export(standard_ml_exports, {
+  standardMl: () => exports.standardMl
+});
+exports.standardMl = void 0;
+var init_standard_ml = __esm({
+  "src/languages/standard-ml.ts"() {
+    exports.standardMl = {
+      slug: "standard-ml",
+      publishedDate: "1990-01-01",
+      extensions: [".sml", ".sig", ".fun"],
+      author: "Robin Milner and collaborators",
+      website: "https://smlfamily.github.io",
+      paradigms: ["functional", "statically typed", "module-oriented"],
+      tooling: {
+        runtimes: ["MLton", "Standard ML of New Jersey", "Poly/ML"],
+        ecosystems: ["ML", "Compilers", "Research"]
+      },
+      version: "The Definition 1997",
+      logo: "https://avatars.githubusercontent.com/u/62883579?v=4",
+      i18n: {
+        en: {
+          name: "Standard ML",
+          description: "A statically typed ML language with modules and pattern matching.",
+          longDescription: "Standard ML defines a strict functional language with algebraic datatypes, pattern matching, type inference, exceptions, and a strong module system with signatures and functors. Its formal definition shaped much ML-family work.\n\nIt is used in compilers, theorem tools, teaching, research, and projects that need a small typed functional core with robust modules."
+        },
+        es: {
+          name: "Standard ML",
+          description: "Un lenguaje ML tipado con modulos y pattern matching.",
+          longDescription: "Standard ML define un lenguaje funcional estricto con datatypes algebraicos, pattern matching, inferencia de tipos, excepciones y un sistema fuerte de modulos con signatures y functors. Su definicion formal influyo mucho en la familia ML.\n\nSe usa en compiladores, herramientas de teoremas, ensenanza, investigacion y proyectos que necesitan un nucleo funcional tipado con modulos robustos."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/starlark.ts
 var starlark_exports = {};
 __export(starlark_exports, {
@@ -4453,6 +5242,81 @@ var init_starlark = __esm({
   }
 });
 
+// src/languages/stata.ts
+var stata_exports = {};
+__export(stata_exports, {
+  stata: () => exports.stata
+});
+exports.stata = void 0;
+var init_stata = __esm({
+  "src/languages/stata.ts"() {
+    exports.stata = {
+      slug: "stata",
+      publishedDate: "1985-01-01",
+      extensions: [".do", ".ado", ".mata"],
+      author: "StataCorp",
+      website: "https://www.stata.com",
+      paradigms: ["statistical", "scripting", "data-analysis", "domain-specific"],
+      tooling: {
+        runtimes: ["Stata"],
+        ecosystems: ["Statistics", "Econometrics", "Research"]
+      },
+      version: "19",
+      logo: "https://www.stata.com/includes/images/stata-logo-blue.svg",
+      i18n: {
+        en: {
+          name: "Stata",
+          description: "A command language for statistical analysis, data management, and graphics.",
+          longDescription: "Stata commands and do-files cover data preparation, estimation, graphics, reporting, and programmable workflows, with Mata available for matrix-oriented programming. The language is tied to the Stata statistical environment.\n\nIt is used in economics, public health, social science, policy analysis, teaching, and reproducible statistical research."
+        },
+        es: {
+          name: "Stata",
+          description: "Un lenguaje de comandos para analisis estadistico, datos y graficos.",
+          longDescription: "Los comandos y do-files de Stata cubren preparacion de datos, estimacion, graficos, reportes y flujos programables, con Mata para programacion orientada a matrices. El lenguaje esta ligado al entorno estadistico Stata.\n\nSe usa en economia, salud publica, ciencias sociales, analisis de politicas, ensenanza e investigacion estadistica reproducible."
+        }
+      }
+    };
+  }
+});
+
+// src/languages/stylus.ts
+var stylus_exports = {};
+__export(stylus_exports, {
+  stylus: () => exports.stylus
+});
+exports.stylus = void 0;
+var init_stylus = __esm({
+  "src/languages/stylus.ts"() {
+    exports.stylus = {
+      slug: "stylus",
+      publishedDate: "2010-12-01",
+      extensions: [".styl"],
+      author: "TJ Holowaychuk / Stylus contributors",
+      website: "https://stylus-lang.com",
+      paradigms: ["stylesheet", "declarative", "preprocessor"],
+      tooling: {
+        runtimes: ["Node.js"],
+        packageManagers: ["npm", "pnpm", "Yarn"],
+        ecosystems: ["CSS", "Web"]
+      },
+      version: "0.64.0",
+      logo: "https://cdn.simpleicons.org/stylus/333333",
+      i18n: {
+        en: {
+          name: "Stylus",
+          description: "A flexible CSS preprocessor with optional punctuation and indentation syntax.",
+          longDescription: "Stylus extends stylesheet authoring with variables, mixins, functions, imports, nesting, and a syntax that can omit braces, colons, and semicolons. It compiles authoring files into CSS.\n\nIt is used in web styling pipelines, design systems, legacy front-end builds, and projects that prefer concise stylesheet syntax."
+        },
+        es: {
+          name: "Stylus",
+          description: "Un preprocesador CSS flexible con puntuacion opcional y sintaxis por indentacion.",
+          longDescription: "Stylus extiende la autoria de estilos con variables, mixins, funciones, imports, nesting y una sintaxis que puede omitir llaves, dos puntos y punto y coma. Compila archivos de autoria hacia CSS.\n\nSe usa en pipelines de estilos web, sistemas de diseno, builds front-end heredados y proyectos que prefieren sintaxis de hojas de estilo concisa."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/svelte.ts
 var svelte_exports = {};
 __export(svelte_exports, {
@@ -4679,6 +5543,81 @@ var init_tex = __esm({
   }
 });
 
+// src/languages/thrift.ts
+var thrift_exports = {};
+__export(thrift_exports, {
+  thrift: () => exports.thrift
+});
+exports.thrift = void 0;
+var init_thrift = __esm({
+  "src/languages/thrift.ts"() {
+    exports.thrift = {
+      slug: "thrift",
+      publishedDate: "2007-04-01",
+      extensions: [".thrift"],
+      author: "Facebook / Apache Software Foundation",
+      website: "https://thrift.apache.org",
+      paradigms: ["interface-definition", "schema", "declarative", "rpc"],
+      tooling: {
+        runtimes: ["Apache Thrift Runtime"],
+        packageManagers: ["Maven", "npm", "PyPI", "Go modules"],
+        ecosystems: ["RPC", "APIs", "Distributed Systems"]
+      },
+      version: "0.22.0",
+      logo: "https://cdn.simpleicons.org/apache/D22128",
+      i18n: {
+        en: {
+          name: "Apache Thrift",
+          description: "An IDL for cross-language services and serializable data types.",
+          longDescription: "Thrift files define services, structs, fields, enums, exceptions, namespaces, and wire-level choices that generators turn into code for many languages. The project includes protocols and transports for RPC use.\n\nIt is used for service contracts, schema sharing, code generation, distributed systems, and cross-language APIs."
+        },
+        es: {
+          name: "Apache Thrift",
+          description: "Un IDL para servicios entre lenguajes y tipos de datos serializables.",
+          longDescription: "Los archivos Thrift definen servicios, structs, campos, enums, excepciones, namespaces y decisiones de wire que los generadores convierten en codigo para muchos lenguajes. El proyecto incluye protocolos y transports para RPC.\n\nSe usa en contratos de servicios, schemas compartidos, generacion de codigo, sistemas distribuidos y APIs entre lenguajes."
+        }
+      }
+    };
+  }
+});
+
+// src/languages/tla-plus.ts
+var tla_plus_exports = {};
+__export(tla_plus_exports, {
+  tlaPlus: () => exports.tlaPlus
+});
+exports.tlaPlus = void 0;
+var init_tla_plus = __esm({
+  "src/languages/tla-plus.ts"() {
+    exports.tlaPlus = {
+      slug: "tla-plus",
+      publishedDate: "1999-01-01",
+      extensions: [".tla"],
+      author: "Leslie Lamport",
+      website: "https://lamport.azurewebsites.net/tla/tla.html",
+      paradigms: ["specification", "formal-methods", "temporal-logic", "declarative"],
+      tooling: {
+        runtimes: ["TLC", "TLA+ Toolbox", "Apalache"],
+        ecosystems: ["Formal Methods", "Distributed Systems", "Verification"]
+      },
+      version: "TLA+ 2",
+      logo: "https://avatars.githubusercontent.com/u/315978?v=4",
+      i18n: {
+        en: {
+          name: "TLA+",
+          description: "A formal specification language for state machines and temporal properties.",
+          longDescription: "TLA+ describes systems as mathematical state transitions with actions, invariants, temporal formulas, modules, and refinement-oriented specifications. Tooling such as TLC explores behaviors to check models.\n\nIt is used to reason about distributed algorithms, protocols, concurrency, safety properties, design reviews, and systems where a precise specification catches failures early."
+        },
+        es: {
+          name: "TLA+",
+          description: "Un lenguaje de especificacion formal para estados y propiedades temporales.",
+          longDescription: "TLA+ describe sistemas como transiciones matematicas de estado con acciones, invariantes, formulas temporales, modulos y especificaciones orientadas a refinamiento. Herramientas como TLC exploran comportamientos para revisar modelos.\n\nSe usa para razonar sobre algoritmos distribuidos, protocolos, concurrencia, propiedades de seguridad, revisiones de diseno y sistemas donde una especificacion precisa detecta fallos temprano."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/toml.ts
 var toml_exports = {};
 __export(toml_exports, {
@@ -4826,6 +5765,82 @@ var init_typst = __esm({
   }
 });
 
+// src/languages/v.ts
+var v_exports = {};
+__export(v_exports, {
+  v: () => exports.v
+});
+exports.v = void 0;
+var init_v = __esm({
+  "src/languages/v.ts"() {
+    exports.v = {
+      slug: "v",
+      publishedDate: "2019-06-20",
+      extensions: [".v", ".vsh"],
+      author: "Alexander Medvednikov / V contributors",
+      website: "https://vlang.io",
+      paradigms: ["imperative", "systems", "multi-paradigm", "statically typed"],
+      tooling: {
+        runtimes: ["V compiler"],
+        packageManagers: ["vpm"],
+        ecosystems: ["Native", "Web", "Systems"]
+      },
+      version: "weekly.2025.49",
+      logo: "https://cdn.simpleicons.org/v/5D87BF",
+      i18n: {
+        en: {
+          name: "V",
+          description: "A compiled statically typed language for simple native application builds.",
+          longDescription: "V is a compiled language with modules, sum types, generics, concurrency syntax, C interop, and a toolchain that emphasizes quick compilation and small deployment workflows. It targets C and native outputs through its compiler.\n\nIt is used for command-line tools, native applications, experiments, web services, and projects that prefer an integrated lightweight toolchain."
+        },
+        es: {
+          name: "V",
+          description: "Un lenguaje compilado y tipado para construir aplicaciones nativas simples.",
+          longDescription: "V es un lenguaje compilado con modulos, sum types, generics, sintaxis concurrente, interop con C y un toolchain que enfatiza compilacion rapida y despliegues pequenos. Su compilador apunta a C y salidas nativas.\n\nSe usa en herramientas de linea de comandos, aplicaciones nativas, experimentos, servicios web y proyectos que prefieren un toolchain ligero e integrado."
+        }
+      }
+    };
+  }
+});
+
+// src/languages/vala.ts
+var vala_exports = {};
+__export(vala_exports, {
+  vala: () => exports.vala
+});
+exports.vala = void 0;
+var init_vala = __esm({
+  "src/languages/vala.ts"() {
+    exports.vala = {
+      slug: "vala",
+      publishedDate: "2006-07-15",
+      extensions: [".vala", ".vapi"],
+      author: "Jurg Billeter / GNOME contributors",
+      website: "https://vala.dev",
+      paradigms: ["object-oriented", "statically typed", "gnome", "c-targeted"],
+      tooling: {
+        runtimes: ["GLib", "GObject"],
+        packageManagers: ["Meson", "pkg-config"],
+        ecosystems: ["GNOME", "GTK", "Native"]
+      },
+      version: "0.56.18",
+      logo: "https://cdn.simpleicons.org/gnome/4A86CF",
+      i18n: {
+        en: {
+          name: "Vala",
+          description: "A GNOME-oriented language that compiles high-level syntax to C.",
+          longDescription: "Vala provides classes, interfaces, properties, generics, signals, and async syntax over GLib and GObject conventions, compiling source into C. VAPI files describe bindings to existing C libraries.\n\nIt is used for GTK applications, GNOME libraries, native tools, bindings, and projects that want high-level source while integrating with C APIs."
+        },
+        es: {
+          name: "Vala",
+          description: "Un lenguaje orientado a GNOME que compila sintaxis de alto nivel a C.",
+          longDescription: "Vala ofrece clases, interfaces, propiedades, generics, signals y sintaxis async sobre las convenciones de GLib y GObject, compilando fuente hacia C. Los archivos VAPI describen bindings a bibliotecas C existentes.\n\nSe usa en aplicaciones GTK, bibliotecas GNOME, herramientas nativas, bindings y proyectos que buscan fuente de alto nivel integrada con APIs C."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/verilog.ts
 var verilog_exports = {};
 __export(verilog_exports, {
@@ -4978,6 +5993,44 @@ var init_vue = __esm({
   }
 });
 
+// src/languages/vyper.ts
+var vyper_exports = {};
+__export(vyper_exports, {
+  vyper: () => exports.vyper
+});
+exports.vyper = void 0;
+var init_vyper = __esm({
+  "src/languages/vyper.ts"() {
+    exports.vyper = {
+      slug: "vyper",
+      publishedDate: "2017-07-19",
+      extensions: [".vy"],
+      author: "Vyper contributors",
+      website: "https://vyperlang.org",
+      paradigms: ["smart-contract", "statically typed", "domain-specific", "imperative"],
+      tooling: {
+        runtimes: ["Ethereum Virtual Machine"],
+        packageManagers: ["pip", "uv"],
+        ecosystems: ["Ethereum", "Smart Contracts", "Web3"]
+      },
+      version: "0.4.3",
+      logo: "https://avatars.githubusercontent.com/u/37288461?v=4",
+      i18n: {
+        en: {
+          name: "Vyper",
+          description: "A Pythonic smart contract language for the Ethereum Virtual Machine.",
+          longDescription: "Vyper is a contract language for Ethereum that favors explicit behavior, bounds, and auditability over broad language surface area. Its syntax is Python-like while its compiler emits EVM bytecode.\n\nIt is used for Ethereum smart contracts, financial protocols, on-chain experiments, and codebases that prefer a deliberately constrained contract language."
+        },
+        es: {
+          name: "Vyper",
+          description: "Un lenguaje de smart contracts con sintaxis Python para Ethereum.",
+          longDescription: "Vyper es un lenguaje de contratos para Ethereum que favorece comportamiento explicito, limites y auditabilidad sobre una superficie amplia del lenguaje. Su sintaxis es parecida a Python y su compilador emite bytecode EVM.\n\nSe usa en smart contracts de Ethereum, protocolos financieros, experimentos on-chain y codebases que prefieren un lenguaje de contratos deliberadamente restringido."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/webassembly.ts
 var webassembly_exports = {};
 __export(webassembly_exports, {
@@ -5054,6 +6107,43 @@ var init_wgsl = __esm({
   }
 });
 
+// src/languages/wren.ts
+var wren_exports = {};
+__export(wren_exports, {
+  wren: () => exports.wren
+});
+exports.wren = void 0;
+var init_wren = __esm({
+  "src/languages/wren.ts"() {
+    exports.wren = {
+      slug: "wren",
+      publishedDate: "2013-10-31",
+      extensions: [".wren"],
+      author: "Bob Nystrom / Wren contributors",
+      website: "https://wren.io",
+      paradigms: ["object-oriented", "scripting", "class-based", "dynamic"],
+      tooling: {
+        runtimes: ["Wren VM"],
+        ecosystems: ["Embedding", "Games", "Scripting"]
+      },
+      version: "0.4.0",
+      logo: "https://avatars.githubusercontent.com/u/8763410?v=4",
+      i18n: {
+        en: {
+          name: "Wren",
+          description: "A small class-based scripting language designed for embedding.",
+          longDescription: "Wren is a compact dynamic language with classes, fibers, modules, closures, and a VM intended to embed cleanly in host applications. Its syntax keeps scripting programs short while preserving an object-oriented model.\n\nIt is used for embedded scripting, game experiments, tools, teaching, and applications that need a small embeddable language runtime."
+        },
+        es: {
+          name: "Wren",
+          description: "Un lenguaje pequeno de scripting basado en clases y pensado para embeberse.",
+          longDescription: "Wren es un lenguaje dinamico compacto con clases, fibers, modulos, closures y una VM pensada para integrarse limpiamente en aplicaciones anfitrionas. Su sintaxis mantiene scripts breves y conserva un modelo orientado a objetos.\n\nSe usa en scripting embebido, experimentos de juegos, herramientas, ensenanza y aplicaciones que necesitan un runtime de lenguaje pequeno."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/xaml.ts
 var xaml_exports = {};
 __export(xaml_exports, {
@@ -5233,6 +6323,44 @@ var init_yaml = __esm({
   }
 });
 
+// src/languages/zeek.ts
+var zeek_exports = {};
+__export(zeek_exports, {
+  zeek: () => exports.zeek
+});
+exports.zeek = void 0;
+var init_zeek = __esm({
+  "src/languages/zeek.ts"() {
+    exports.zeek = {
+      slug: "zeek",
+      publishedDate: "1995-01-01",
+      extensions: [".zeek", ".bro"],
+      author: "Vern Paxson / Zeek Project",
+      website: "https://zeek.org",
+      paradigms: ["event-driven", "network-analysis", "domain-specific", "scripting"],
+      tooling: {
+        runtimes: ["Zeek"],
+        packageManagers: ["zkg"],
+        ecosystems: ["Network Security", "Observability", "Incident Response"]
+      },
+      version: "8.0.4",
+      logo: "https://avatars.githubusercontent.com/u/10666805?v=4",
+      i18n: {
+        en: {
+          name: "Zeek",
+          description: "An event-driven scripting language for network analysis and security policy.",
+          longDescription: "Zeek scripts describe events, records, analyzers, notices, logging, and policy logic over network traffic observed by the Zeek monitor. The language lets analysts extend protocol and detection behavior.\n\nIt is used in network security monitoring, incident response, traffic analysis, telemetry pipelines, and site-specific security policy."
+        },
+        es: {
+          name: "Zeek",
+          description: "Un lenguaje event-driven para analisis de red y politicas de seguridad.",
+          longDescription: "Los scripts Zeek describen eventos, records, analyzers, notices, logging y logica de politica sobre trafico de red observado por el monitor Zeek. El lenguaje permite extender comportamiento de protocolos y deteccion.\n\nSe usa en monitoreo de seguridad de red, respuesta a incidentes, analisis de trafico, pipelines de telemetria y politicas de seguridad especificas del sitio."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/zig.ts
 var zig_exports = {};
 __export(zig_exports, {
@@ -5271,6 +6399,43 @@ var init_zig = __esm({
   }
 });
 
+// src/languages/ziggy.ts
+var ziggy_exports = {};
+__export(ziggy_exports, {
+  ziggy: () => exports.ziggy
+});
+exports.ziggy = void 0;
+var init_ziggy = __esm({
+  "src/languages/ziggy.ts"() {
+    exports.ziggy = {
+      slug: "ziggy",
+      publishedDate: "2023-10-02",
+      extensions: [".ziggy", ".ziggy-schema"],
+      author: "Loris Cro",
+      website: "https://ziggy-lang.io",
+      paradigms: ["data-notation", "schema", "declarative", "configuration"],
+      tooling: {
+        runtimes: ["Ziggy CLI"],
+        ecosystems: ["Configuration", "Data Formats", "Zig"]
+      },
+      version: "0.1.0",
+      logo: "https://avatars.githubusercontent.com/u/1642052?v=4",
+      i18n: {
+        en: {
+          name: "Ziggy",
+          description: "A data notation and schema language for configuration-style documents.",
+          longDescription: "Ziggy is a data language for readable structured documents with a companion schema form for describing expected shapes. It targets configuration and data interchange workflows with tooling around Zig ecosystems.\n\nIt is used for configuration files, schema-checked data documents, tooling experiments, and projects that want a compact typed data notation."
+        },
+        es: {
+          name: "Ziggy",
+          description: "Una notacion de datos y schemas para documentos de configuracion.",
+          longDescription: "Ziggy es un lenguaje de datos para documentos estructurados legibles con una forma de schema complementaria para describir shapes esperados. Apunta a configuracion e intercambio de datos con tooling cercano al ecosistema Zig.\n\nSe usa en archivos de configuracion, documentos de datos validados por schemas, experimentos de tooling y proyectos que buscan una notacion de datos compacta y tipada."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/zsh.ts
 var zsh_exports = {};
 __export(zsh_exports, {
@@ -5396,60 +6561,91 @@ init_llvm_ir();
 init_lua();
 init_luau();
 init_makefile();
+init_mako();
 init_markdown();
+init_mathematica();
 init_matlab();
 init_mdx();
 init_mermaid();
 init_meson();
 init_metal();
+init_mojo();
+init_moonbit();
 init_nginx();
 init_nim();
 init_nix();
 init_objective_c();
 init_ocaml();
+init_odin();
+init_opencl();
 init_pascal();
 init_perl();
 init_php();
+init_pine_script();
 init_plantuml();
+init_plsql();
+init_pony();
 init_powershell();
 init_prolog();
+init_promql();
 init_protobuf();
 init_pug();
+init_purescript();
 init_python();
 init_qml();
+init_qsharp();
 init_r();
 init_racket();
+init_raku();
 init_razor();
+init_reasonml();
 init_rego();
+init_rescript();
+init_restructuredtext();
 init_ruby();
 init_rust();
+init_sas();
 init_scala();
+init_scheme();
 init_scss();
+init_smalltalk();
+init_smarty();
 init_solidity();
 init_sql();
+init_standard_ml();
 init_starlark();
+init_stata();
+init_stylus();
 init_svelte();
 init_svg();
 init_svn();
 init_swift();
 init_tcl();
 init_tex();
+init_thrift();
+init_tla_plus();
 init_toml();
 init_twig();
 init_typescript();
 init_typst();
+init_v();
+init_vala();
 init_verilog();
 init_vhdl();
 init_visual_basic();
 init_vue();
+init_vyper();
 init_webassembly();
 init_wgsl();
+init_wren();
 init_xaml();
 init_xml();
 init_xquery();
 init_xslt();
 init_yaml();
+init_zeek();
 init_zig();
+init_ziggy();
 init_zsh();
 var languages = [
   exports.abap,
@@ -5537,61 +6733,92 @@ var languages = [
   exports.llvmIr,
   exports.lua,
   exports.luau,
+  exports.mako,
   exports.makefile,
+  exports.mathematica,
   exports.matlab,
   exports.markdown,
   exports.mdx,
   exports.mermaid,
   exports.meson,
   exports.metal,
+  exports.mojo,
+  exports.moonbit,
   exports.svn,
   exports.nginx,
   exports.nim,
   exports.nix,
   exports.ocaml,
   exports.objectiveC,
+  exports.odin,
+  exports.opencl,
   exports.pascal,
   exports.perl,
   exports.php,
+  exports.pineScript,
   exports.plantuml,
+  exports.plsql,
+  exports.pony,
   exports.powershell,
   exports.prolog,
+  exports.promql,
   exports.protobuf,
   exports.pug,
+  exports.purescript,
   exports.python,
   exports.qml,
+  exports.qsharp,
   exports.r,
+  exports.raku,
   exports.racket,
   exports.razor,
+  exports.reasonml,
   exports.rego,
+  exports.rescript,
+  exports.restructuredtext,
   exports.ruby,
   exports.rust,
+  exports.sas,
   exports.scala,
   exports.scss,
+  exports.scheme,
+  exports.smalltalk,
+  exports.smarty,
   exports.solidity,
   exports.sql,
+  exports.standardMl,
   exports.starlark,
+  exports.stata,
+  exports.stylus,
   exports.svg,
   exports.svelte,
   exports.swift,
   exports.tcl,
   exports.tex,
+  exports.thrift,
+  exports.tlaPlus,
   exports.toml,
   exports.twig,
   exports.typescript,
   exports.typst,
+  exports.v,
+  exports.vala,
   exports.verilog,
   exports.vhdl,
   exports.visualBasic,
   exports.vue,
+  exports.vyper,
   exports.webassembly,
   exports.wgsl,
+  exports.wren,
   exports.xaml,
   exports.xml,
   exports.xquery,
   exports.xslt,
   exports.yaml,
+  exports.zeek,
   exports.zig,
+  exports.ziggy,
   exports.zsh
 ];
 
@@ -5749,64 +6976,95 @@ var languageIndex = [
   { slug: "llvm-ir", extensions: [".ll", ".bc"] },
   { slug: "lua", extensions: [".lua", ".rockspec"] },
   { slug: "luau", extensions: [".luau"] },
+  { slug: "mako", extensions: [".mako", ".mao"] },
   { slug: "makefile", extensions: ["Makefile", "makefile", "GNUmakefile", ".mk", ".mak"] },
+  { slug: "mathematica", extensions: [".wl", ".wls", ".nb"] },
   { slug: "matlab", extensions: [".m", ".mlx"] },
   { slug: "markdown", extensions: [".md", ".markdown", ".mdown", ".mkd"] },
   { slug: "mdx", extensions: [".mdx"] },
   { slug: "mermaid", extensions: [".mmd", ".mermaid"] },
   { slug: "meson", extensions: ["meson.build", "meson_options.txt", "meson.options", ".wrap"] },
   { slug: "metal", extensions: [".metal"] },
+  { slug: "mojo", extensions: [".mojo"] },
+  { slug: "moonbit", extensions: [".mbt"] },
   { 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"] },
+  { slug: "odin", extensions: [".odin"] },
+  { slug: "opencl", extensions: [".cl", ".clh"] },
   { slug: "pascal", extensions: [".pas", ".pp", ".inc", ".lpr", ".dpr", ".dfm"] },
   { slug: "perl", extensions: [".pl", ".pm", ".pod", ".t", ".psgi"] },
   { slug: "php", extensions: [".php", ".phtml", ".php3", ".php4", ".php5", ".phps"] },
+  { slug: "pine-script", extensions: [".pine"] },
   { slug: "plantuml", extensions: [".puml", ".plantuml", ".iuml"] },
+  { slug: "plsql", extensions: [".pls", ".pks", ".pkb", ".plsql"] },
+  { slug: "pony", extensions: [".pony"] },
   { slug: "powershell", extensions: [".ps1", ".psm1", ".psd1", ".ps1xml"] },
   { slug: "prolog", extensions: [".pl", ".pro", ".prolog", ".P"] },
+  { slug: "promql", extensions: [".promql"] },
   { slug: "protobuf", extensions: [".proto"] },
   { slug: "pug", extensions: [".pug", ".jade"] },
+  { slug: "purescript", extensions: [".purs"] },
   { slug: "python", extensions: [".py", ".pyw"] },
   { slug: "qml", extensions: [".qml", ".qmltypes", ".qmlproject"] },
+  { slug: "qsharp", extensions: [".qs"] },
   { slug: "r", extensions: [".r", ".R", ".rmd", ".Rmd", ".qmd", ".Rprofile"] },
+  { slug: "raku", extensions: [".raku", ".rakumod", ".rakudoc", ".rakutest", ".p6", ".pm6"] },
   { slug: "racket", extensions: [".rkt", ".rktd", ".rktl", ".scrbl"] },
   { slug: "razor", extensions: [".cshtml", ".razor"] },
+  { slug: "reasonml", extensions: [".re", ".rei"] },
   { slug: "rego", extensions: [".rego"] },
+  { slug: "rescript", extensions: [".res", ".resi"] },
+  { slug: "restructuredtext", extensions: [".rst", ".rest"] },
   {
     slug: "ruby",
     extensions: [".rb", ".rbw", ".rake", ".gemspec", "Gemfile", "Rakefile", "config.ru"]
   },
   { slug: "rust", extensions: [".rs"] },
+  { slug: "sas", extensions: [".sas"] },
   { slug: "scala", extensions: [".scala", ".sc"] },
   { slug: "scss", extensions: [".scss", ".sass"] },
+  { slug: "scheme", extensions: [".scm", ".ss", ".sld", ".sls"] },
+  { slug: "smalltalk", extensions: [".st"] },
+  { slug: "smarty", extensions: [".tpl", ".smarty"] },
   { slug: "solidity", extensions: [".sol"] },
   { slug: "sql", extensions: [".sql"] },
+  { slug: "standard-ml", extensions: [".sml", ".sig", ".fun"] },
   { slug: "starlark", extensions: [".bzl", ".star", ".sky"] },
+  { slug: "stata", extensions: [".do", ".ado", ".mata"] },
+  { slug: "stylus", extensions: [".styl"] },
   { slug: "svg", extensions: [".svg", ".svgz"] },
   { slug: "svelte", extensions: [".svelte"] },
   { slug: "swift", extensions: [".swift"] },
   { slug: "tcl", extensions: [".tcl", ".tm", ".test"] },
   { slug: "tex", extensions: [".tex", ".sty", ".cls", ".dtx", ".ins", ".ltx"] },
+  { slug: "thrift", extensions: [".thrift"] },
+  { slug: "tla-plus", extensions: [".tla"] },
   { slug: "toml", extensions: [".toml"] },
   { slug: "twig", extensions: [".twig"] },
   { slug: "typescript", extensions: [".ts", ".tsx", ".mts", ".cts"] },
   { slug: "typst", extensions: [".typ"] },
+  { slug: "v", extensions: [".v", ".vsh"] },
+  { slug: "vala", extensions: [".vala", ".vapi"] },
   { slug: "verilog", extensions: [".v", ".vh", ".sv", ".svh"] },
   { slug: "vhdl", extensions: [".vhd", ".vhdl"] },
   { slug: "visual-basic", extensions: [".vb"] },
   { slug: "vue", extensions: [".vue"] },
+  { slug: "vyper", extensions: [".vy"] },
   { slug: "webassembly", extensions: [".wasm", ".wat"] },
   { slug: "wgsl", extensions: [".wgsl"] },
+  { slug: "wren", extensions: [".wren"] },
   { slug: "xaml", extensions: [".xaml", ".baml"] },
   { slug: "xml", extensions: [".xml", ".xsd", ".xsl", ".xslt"] },
   { slug: "xquery", extensions: [".xq", ".xql", ".xqm", ".xquery", ".xqy"] },
   { slug: "xslt", extensions: [".xsl", ".xslt"] },
   { slug: "yaml", extensions: [".yaml", ".yml"] },
+  { slug: "zeek", extensions: [".zeek", ".bro"] },
   { slug: "zig", extensions: [".zig", ".zon"] },
+  { slug: "ziggy", extensions: [".ziggy", ".ziggy-schema"] },
   {
     slug: "zsh",
     extensions: [".zsh", ".zshrc", ".zshenv", ".zprofile", ".zlogin", ".zlogout", ".zsh-theme"]
@@ -5898,61 +7156,92 @@ var languageLoaders = {
   "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),
+  mako: () => Promise.resolve().then(() => (init_mako(), mako_exports)).then((module) => module.mako),
   makefile: () => Promise.resolve().then(() => (init_makefile(), makefile_exports)).then((module) => module.makefile),
+  mathematica: () => Promise.resolve().then(() => (init_mathematica(), mathematica_exports)).then((module) => module.mathematica),
   matlab: () => Promise.resolve().then(() => (init_matlab(), matlab_exports)).then((module) => module.matlab),
   markdown: () => Promise.resolve().then(() => (init_markdown(), markdown_exports)).then((module) => module.markdown),
   mdx: () => Promise.resolve().then(() => (init_mdx(), mdx_exports)).then((module) => module.mdx),
   mermaid: () => Promise.resolve().then(() => (init_mermaid(), mermaid_exports)).then((module) => module.mermaid),
   meson: () => Promise.resolve().then(() => (init_meson(), meson_exports)).then((module) => module.meson),
   metal: () => Promise.resolve().then(() => (init_metal(), metal_exports)).then((module) => module.metal),
+  mojo: () => Promise.resolve().then(() => (init_mojo(), mojo_exports)).then((module) => module.mojo),
+  moonbit: () => Promise.resolve().then(() => (init_moonbit(), moonbit_exports)).then((module) => module.moonbit),
   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),
+  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),
   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),
   plantuml: () => Promise.resolve().then(() => (init_plantuml(), plantuml_exports)).then((module) => module.plantuml),
+  plsql: () => Promise.resolve().then(() => (init_plsql(), plsql_exports)).then((module) => module.plsql),
+  pony: () => Promise.resolve().then(() => (init_pony(), pony_exports)).then((module) => module.pony),
   powershell: () => Promise.resolve().then(() => (init_powershell(), powershell_exports)).then((module) => module.powershell),
   prolog: () => Promise.resolve().then(() => (init_prolog(), prolog_exports)).then((module) => module.prolog),
+  promql: () => Promise.resolve().then(() => (init_promql(), promql_exports)).then((module) => module.promql),
   protobuf: () => Promise.resolve().then(() => (init_protobuf(), protobuf_exports)).then((module) => module.protobuf),
   pug: () => Promise.resolve().then(() => (init_pug(), pug_exports)).then((module) => module.pug),
+  purescript: () => Promise.resolve().then(() => (init_purescript(), purescript_exports)).then((module) => module.purescript),
   python: () => Promise.resolve().then(() => (init_python(), python_exports)).then((module) => module.python),
   qml: () => Promise.resolve().then(() => (init_qml(), qml_exports)).then((module) => module.qml),
+  qsharp: () => Promise.resolve().then(() => (init_qsharp(), qsharp_exports)).then((module) => module.qsharp),
   r: () => Promise.resolve().then(() => (init_r(), r_exports)).then((module) => module.r),
+  raku: () => Promise.resolve().then(() => (init_raku(), raku_exports)).then((module) => module.raku),
   racket: () => Promise.resolve().then(() => (init_racket(), racket_exports)).then((module) => module.racket),
   razor: () => Promise.resolve().then(() => (init_razor(), razor_exports)).then((module) => module.razor),
+  reasonml: () => Promise.resolve().then(() => (init_reasonml(), reasonml_exports)).then((module) => module.reasonml),
   rego: () => Promise.resolve().then(() => (init_rego(), rego_exports)).then((module) => module.rego),
+  rescript: () => Promise.resolve().then(() => (init_rescript(), rescript_exports)).then((module) => module.rescript),
+  restructuredtext: () => Promise.resolve().then(() => (init_restructuredtext(), restructuredtext_exports)).then((module) => module.restructuredtext),
   ruby: () => Promise.resolve().then(() => (init_ruby(), ruby_exports)).then((module) => module.ruby),
   rust: () => Promise.resolve().then(() => (init_rust(), rust_exports)).then((module) => module.rust),
+  sas: () => Promise.resolve().then(() => (init_sas(), sas_exports)).then((module) => module.sas),
   scala: () => Promise.resolve().then(() => (init_scala(), scala_exports)).then((module) => module.scala),
   scss: () => Promise.resolve().then(() => (init_scss(), scss_exports)).then((module) => module.scss),
+  scheme: () => Promise.resolve().then(() => (init_scheme(), scheme_exports)).then((module) => module.scheme),
+  smalltalk: () => Promise.resolve().then(() => (init_smalltalk(), smalltalk_exports)).then((module) => module.smalltalk),
+  smarty: () => Promise.resolve().then(() => (init_smarty(), smarty_exports)).then((module) => module.smarty),
   solidity: () => Promise.resolve().then(() => (init_solidity(), solidity_exports)).then((module) => module.solidity),
   sql: () => Promise.resolve().then(() => (init_sql(), sql_exports)).then((module) => module.sql),
+  "standard-ml": () => Promise.resolve().then(() => (init_standard_ml(), standard_ml_exports)).then((module) => module.standardMl),
   starlark: () => Promise.resolve().then(() => (init_starlark(), starlark_exports)).then((module) => module.starlark),
+  stata: () => Promise.resolve().then(() => (init_stata(), stata_exports)).then((module) => module.stata),
+  stylus: () => Promise.resolve().then(() => (init_stylus(), stylus_exports)).then((module) => module.stylus),
   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),
   tex: () => Promise.resolve().then(() => (init_tex(), tex_exports)).then((module) => module.tex),
+  thrift: () => Promise.resolve().then(() => (init_thrift(), thrift_exports)).then((module) => module.thrift),
+  "tla-plus": () => Promise.resolve().then(() => (init_tla_plus(), tla_plus_exports)).then((module) => module.tlaPlus),
   toml: () => Promise.resolve().then(() => (init_toml(), toml_exports)).then((module) => module.toml),
   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),
+  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),
   vhdl: () => Promise.resolve().then(() => (init_vhdl(), vhdl_exports)).then((module) => module.vhdl),
   "visual-basic": () => Promise.resolve().then(() => (init_visual_basic(), visual_basic_exports)).then((module) => module.visualBasic),
   vue: () => Promise.resolve().then(() => (init_vue(), vue_exports)).then((module) => module.vue),
+  vyper: () => Promise.resolve().then(() => (init_vyper(), vyper_exports)).then((module) => module.vyper),
   webassembly: () => Promise.resolve().then(() => (init_webassembly(), webassembly_exports)).then((module) => module.webassembly),
   wgsl: () => Promise.resolve().then(() => (init_wgsl(), wgsl_exports)).then((module) => module.wgsl),
+  wren: () => Promise.resolve().then(() => (init_wren(), wren_exports)).then((module) => module.wren),
   xaml: () => Promise.resolve().then(() => (init_xaml(), xaml_exports)).then((module) => module.xaml),
   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),
   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),
+  ziggy: () => Promise.resolve().then(() => (init_ziggy(), ziggy_exports)).then((module) => module.ziggy),
   zsh: () => Promise.resolve().then(() => (init_zsh(), zsh_exports)).then((module) => module.zsh)
 };
 var loadLanguage = (slug) => languageLoaders[slug]?.();
@@ -6135,61 +7424,92 @@ init_lisp();
 init_llvm_ir();
 init_lua();
 init_luau();
+init_mako();
 init_makefile();
+init_mathematica();
 init_matlab();
 init_markdown();
 init_mdx();
 init_mermaid();
 init_meson();
 init_metal();
+init_mojo();
+init_moonbit();
 init_nginx();
 init_nim();
 init_nix();
 init_ocaml();
 init_objective_c();
+init_odin();
+init_opencl();
 init_pascal();
 init_perl();
 init_php();
+init_pine_script();
 init_plantuml();
+init_plsql();
+init_pony();
 init_powershell();
 init_prolog();
+init_promql();
 init_protobuf();
 init_pug();
+init_purescript();
 init_python();
 init_qml();
+init_qsharp();
 init_r();
+init_raku();
 init_racket();
 init_razor();
+init_reasonml();
 init_rego();
+init_rescript();
+init_restructuredtext();
 init_ruby();
 init_rust();
+init_sas();
 init_scala();
 init_scss();
+init_scheme();
+init_smalltalk();
+init_smarty();
 init_solidity();
 init_sql();
+init_standard_ml();
 init_starlark();
+init_stata();
+init_stylus();
 init_svg();
 init_svn();
 init_svelte();
 init_swift();
 init_tcl();
 init_tex();
+init_thrift();
+init_tla_plus();
 init_toml();
 init_twig();
 init_typescript();
 init_typst();
+init_v();
+init_vala();
 init_verilog();
 init_vhdl();
 init_visual_basic();
 init_vue();
+init_vyper();
 init_webassembly();
 init_wgsl();
+init_wren();
 init_xaml();
 init_xml();
 init_xquery();
 init_xslt();
 init_yaml();
+init_zeek();
 init_zig();
+init_ziggy();
 init_zsh();
 
 exports.api = api;