code-languages 1.9.2 → 1.11.0

package/dist/api.cjs

@@ -47,6 +47,43 @@ var init_abap = __esm({
   }
 });
 
+// src/languages/actionscript.ts
+var actionscript_exports = {};
+__export(actionscript_exports, {
+  actionscript: () => actionscript
+});
+var actionscript;
+var init_actionscript = __esm({
+  "src/languages/actionscript.ts"() {
+    actionscript = {
+      slug: "actionscript",
+      publishedDate: "1998-01-01",
+      extensions: [".as"],
+      author: "Gary Grossman / Macromedia",
+      website: "https://airsdk.dev/docs/development/actionscript-3.0",
+      paradigms: ["event-driven", "imperative", "object-oriented", "scripting"],
+      tooling: {
+        runtimes: ["Adobe Flash Player", "Adobe AIR", "Apache Royale"],
+        ecosystems: ["Flash", "AIR", "Flex", "Legacy Web"]
+      },
+      version: "3.0",
+      logo: "https://icons.iconarchive.com/icons/fatcow/farm-fresh/32/page-white-actionscript-icon.png",
+      i18n: {
+        en: {
+          name: "ActionScript",
+          description: "An ECMAScript-based language used for Flash, AIR, Flex, and interactive media applications.",
+          longDescription: "ActionScript is an ECMAScript-based scripting language created for interactive content, animation, rich internet applications, and application logic in the Flash platform. ActionScript 3.0 introduced a stronger type system, classes, packages, events, namespaces, and a virtual machine designed for larger applications.\n\nIt is mostly relevant today for maintaining legacy Flash, AIR, and Flex projects, migrating older interactive content, and understanding codebases built around Adobe runtime technologies."
+        },
+        es: {
+          name: "ActionScript",
+          description: "Un lenguaje basado en ECMAScript usado para Flash, AIR, Flex y aplicaciones multimedia interactivas.",
+          longDescription: "ActionScript es un lenguaje de scripting basado en ECMAScript creado para contenido interactivo, animacion, aplicaciones rich internet y logica de aplicaciones en la plataforma Flash. ActionScript 3.0 introdujo un sistema de tipos mas fuerte, clases, paquetes, eventos, namespaces y una maquina virtual disenada para aplicaciones mas grandes.\n\nHoy es relevante principalmente para mantener proyectos legacy de Flash, AIR y Flex, migrar contenido interactivo antiguo y entender codebases construidas alrededor de tecnologias runtime de Adobe."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/asp.ts
 var asp_exports = {};
 __export(asp_exports, {
@@ -424,6 +461,44 @@ var init_cpp = __esm({
   }
 });
 
+// src/languages/crystal.ts
+var crystal_exports = {};
+__export(crystal_exports, {
+  crystal: () => crystal
+});
+var crystal;
+var init_crystal = __esm({
+  "src/languages/crystal.ts"() {
+    crystal = {
+      slug: "crystal",
+      publishedDate: "2014-06-18",
+      extensions: [".cr"],
+      author: "Ary Borenszweig, Juan Wajnerman, Brian Cardiff / Crystal contributors",
+      website: "https://crystal-lang.org",
+      paradigms: ["object-oriented", "functional", "imperative", "concurrent"],
+      tooling: {
+        runtimes: ["Crystal"],
+        packageManagers: ["Shards"],
+        ecosystems: ["Web", "CLI", "Systems", "Native Applications"]
+      },
+      version: "1.20.1",
+      logo: "https://cdn.simpleicons.org/crystal/000000",
+      i18n: {
+        en: {
+          name: "Crystal",
+          description: "A compiled, statically typed language with Ruby-inspired syntax and native performance.",
+          longDescription: "Crystal is a general-purpose programming language with syntax inspired by Ruby, static type checking, type inference, macros, fibers, channels, C bindings, and native compilation. It aims to keep code expressive while catching type errors at compile time.\n\nIt is used for web services, command-line tools, automation, native applications, performance-sensitive backend systems, and projects that want Ruby-like ergonomics with a compiled toolchain."
+        },
+        es: {
+          name: "Crystal",
+          description: "Un lenguaje compilado y tipado estaticamente con sintaxis inspirada en Ruby y rendimiento nativo.",
+          longDescription: "Crystal es un lenguaje de programacion de proposito general con sintaxis inspirada en Ruby, verificacion estatica de tipos, inferencia de tipos, macros, fibers, channels, bindings con C y compilacion nativa. Busca mantener el codigo expresivo mientras detecta errores de tipos en compilacion.\n\nSe usa en servicios web, herramientas de linea de comandos, automatizacion, aplicaciones nativas, backends sensibles al rendimiento y proyectos que quieren ergonomia similar a Ruby con un toolchain compilado."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/csharp.ts
 var csharp_exports = {};
 __export(csharp_exports, {
@@ -608,6 +683,120 @@ var init_dockerfile = __esm({
   }
 });
 
+// src/languages/elm.ts
+var elm_exports = {};
+__export(elm_exports, {
+  elm: () => elm
+});
+var elm;
+var init_elm = __esm({
+  "src/languages/elm.ts"() {
+    elm = {
+      slug: "elm",
+      publishedDate: "2012-03-30",
+      extensions: [".elm"],
+      author: "Evan Czaplicki",
+      website: "https://elm-lang.org",
+      paradigms: ["functional", "declarative", "reactive", "statically typed"],
+      tooling: {
+        runtimes: ["Browser", "JavaScript"],
+        packageManagers: ["elm", "npm", "pnpm", "Yarn"],
+        ecosystems: ["Web", "Frontend", "Functional Programming"]
+      },
+      version: "0.19.1",
+      logo: "https://upload.wikimedia.org/wikipedia/commons/f/f3/Elm_logo.svg",
+      i18n: {
+        en: {
+          name: "Elm",
+          description: "A functional language for reliable web applications that compiles to JavaScript.",
+          longDescription: "Elm is a functional programming language designed for building browser applications with strong static types, immutable data, pure functions, pattern matching, and a friendly compiler that emphasizes clear error messages.\n\nIt is used for frontend applications, interactive web interfaces, learning functional programming, and projects that want predictable state updates through The Elm Architecture while compiling to JavaScript."
+        },
+        es: {
+          name: "Elm",
+          description: "Un lenguaje funcional para aplicaciones web confiables que compila a JavaScript.",
+          longDescription: "Elm es un lenguaje de programacion funcional disenado para crear aplicaciones de navegador con tipado estatico fuerte, datos inmutables, funciones puras, pattern matching y un compilador amigable que prioriza mensajes de error claros.\n\nSe usa en aplicaciones frontend, interfaces web interactivas, aprendizaje de programacion funcional y proyectos que buscan actualizaciones de estado predecibles mediante The Elm Architecture mientras compilan a JavaScript."
+        }
+      }
+    };
+  }
+});
+
+// src/languages/erlang.ts
+var erlang_exports = {};
+__export(erlang_exports, {
+  erlang: () => erlang
+});
+var erlang;
+var init_erlang = __esm({
+  "src/languages/erlang.ts"() {
+    erlang = {
+      slug: "erlang",
+      publishedDate: "1986-01-01",
+      extensions: [".erl", ".hrl", ".app.src", ".escript", ".xrl", ".yrl", "rebar.config"],
+      author: "Joe Armstrong, Robert Virding, Mike Williams / Ericsson",
+      website: "https://www.erlang.org",
+      paradigms: ["concurrent", "distributed", "functional", "message-passing"],
+      tooling: {
+        runtimes: ["BEAM", "Erlang/OTP"],
+        packageManagers: ["rebar3", "Hex"],
+        ecosystems: ["BEAM", "Telecom", "Distributed Systems", "Fault-tolerant Systems"]
+      },
+      version: "OTP 29.0",
+      logo: "https://cdn.simpleicons.org/erlang/A90533",
+      i18n: {
+        en: {
+          name: "Erlang",
+          description: "A concurrent functional language for fault-tolerant, distributed, and highly available systems.",
+          longDescription: "Erlang is a functional programming language and runtime system designed for concurrent, distributed, fault-tolerant applications. Erlang/OTP includes the BEAM virtual machine, lightweight processes, message passing, supervisors, applications, releases, and libraries for building resilient systems.\n\nIt is widely used in telecom platforms, messaging systems, databases, real-time services, network infrastructure, IoT, and systems where uptime, hot code upgrades, and fault isolation are central requirements."
+        },
+        es: {
+          name: "Erlang",
+          description: "Un lenguaje funcional concurrente para sistemas tolerantes a fallos, distribuidos y altamente disponibles.",
+          longDescription: "Erlang es un lenguaje de programacion funcional y sistema runtime disenado para aplicaciones concurrentes, distribuidas y tolerantes a fallos. Erlang/OTP incluye la maquina virtual BEAM, procesos ligeros, paso de mensajes, supervisores, aplicaciones, releases y librerias para construir sistemas resilientes.\n\nSe usa ampliamente en plataformas de telecomunicaciones, sistemas de mensajeria, bases de datos, servicios en tiempo real, infraestructura de red, IoT y sistemas donde uptime, hot code upgrades y aislamiento de fallos son requisitos centrales."
+        }
+      }
+    };
+  }
+});
+
+// src/languages/fortran.ts
+var fortran_exports = {};
+__export(fortran_exports, {
+  fortran: () => fortran
+});
+var fortran;
+var init_fortran = __esm({
+  "src/languages/fortran.ts"() {
+    fortran = {
+      slug: "fortran",
+      publishedDate: "1957-10-15",
+      extensions: [".f", ".for", ".ftn", ".f90", ".f95", ".f03", ".f08", ".f18", ".f23"],
+      author: "John Backus / IBM",
+      website: "https://fortran-lang.org",
+      paradigms: ["array", "imperative", "procedural", "structured"],
+      tooling: {
+        runtimes: ["Native", "HPC clusters"],
+        packageManagers: ["fpm", "Spack"],
+        ecosystems: ["Scientific Computing", "HPC", "Numerical Computing", "Engineering"]
+      },
+      version: "Fortran 2023",
+      logo: "https://upload.wikimedia.org/wikipedia/commons/b/b8/Fortran_logo.svg",
+      i18n: {
+        en: {
+          name: "Fortran",
+          description: "A compiled language for numerical computing, scientific software, and high-performance systems.",
+          longDescription: "Fortran is one of the earliest high-level programming languages and remains important for numerical computing, scientific simulation, engineering software, and high-performance computing. Modern Fortran includes modules, array programming, generic interfaces, derived types, coarrays, and interoperability with C.\n\nIt is widely used in climate models, physics simulations, computational chemistry, aerospace, numerical libraries, weather forecasting, and long-lived scientific codebases where performance and stable language standards matter."
+        },
+        es: {
+          name: "Fortran",
+          description: "Un lenguaje compilado para computacion numerica, software cientifico y sistemas de alto rendimiento.",
+          longDescription: "Fortran es uno de los primeros lenguajes de programacion de alto nivel y sigue siendo importante para computacion numerica, simulacion cientifica, software de ingenieria y high-performance computing. Fortran moderno incluye modulos, programacion con arrays, interfaces genericas, tipos derivados, coarrays e interoperabilidad con C.\n\nSe usa ampliamente en modelos climaticos, simulaciones fisicas, quimica computacional, aeroespacial, librerias numericas, prediccion meteorologica y codebases cientificas de larga vida donde importan el rendimiento y estandares estables del lenguaje."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/fsharp.ts
 var fsharp_exports = {};
 __export(fsharp_exports, {
@@ -868,6 +1057,42 @@ var init_html = __esm({
   }
 });
 
+// src/languages/ini.ts
+var ini_exports = {};
+__export(ini_exports, {
+  ini: () => ini
+});
+var ini;
+var init_ini = __esm({
+  "src/languages/ini.ts"() {
+    ini = {
+      slug: "ini",
+      publishedDate: "1985-01-01",
+      extensions: [".ini"],
+      author: "Microsoft / community conventions",
+      website: "https://en.wikipedia.org/wiki/INI_file",
+      paradigms: ["configuration", "declarative", "key-value"],
+      tooling: {
+        ecosystems: ["Windows", "Configuration", "Desktop Applications", "Legacy Systems"]
+      },
+      version: "Informal format",
+      logo: "https://commons.wikimedia.org/wiki/Special:FilePath/Configure.svg",
+      i18n: {
+        en: {
+          name: "INI",
+          description: "A simple section-based configuration format built around keys, values, and comments.",
+          longDescription: "INI files store configuration as sections with key-value pairs, usually with comments and implementation-specific parsing rules. The format is intentionally simple and has no single formal standard, so behavior can vary across parsers.\n\nINI-style files are common in Windows applications, legacy desktop software, game configuration, developer tools, and small projects that need readable configuration without a heavier serialization format."
+        },
+        es: {
+          name: "INI",
+          description: "Un formato simple de configuracion por secciones basado en claves, valores y comentarios.",
+          longDescription: "Los archivos INI guardan configuracion como secciones con pares clave-valor, normalmente con comentarios y reglas de parseo especificas de cada implementacion. El formato es intencionalmente simple y no tiene un estandar formal unico, por lo que el comportamiento puede variar entre parsers.\n\nLos archivos estilo INI son comunes en aplicaciones Windows, software de escritorio legacy, configuracion de juegos, herramientas de desarrollo y proyectos pequenos que necesitan configuracion legible sin un formato de serializacion mas pesado."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/java.ts
 var java_exports = {};
 __export(java_exports, {
@@ -1091,6 +1316,44 @@ var init_less = __esm({
   }
 });
 
+// src/languages/lisp.ts
+var lisp_exports = {};
+__export(lisp_exports, {
+  lisp: () => lisp
+});
+var lisp;
+var init_lisp = __esm({
+  "src/languages/lisp.ts"() {
+    lisp = {
+      slug: "lisp",
+      publishedDate: "1958-01-01",
+      extensions: [".lisp", ".lsp", ".cl", ".asd"],
+      author: "John McCarthy / ANSI X3J13",
+      website: "https://common-lisp.net",
+      paradigms: ["functional", "symbolic", "object-oriented", "metaprogramming", "dynamic"],
+      tooling: {
+        runtimes: ["SBCL", "CCL", "ECL", "CLISP", "LispWorks", "Allegro CL"],
+        packageManagers: ["Quicklisp", "ASDF"],
+        ecosystems: ["Common Lisp", "AI", "Symbolic Computing", "Research", "CLI"]
+      },
+      version: "ANSI INCITS 226-1994",
+      logo: "https://commons.wikimedia.org/wiki/Special:FilePath/Lisp_logo.svg",
+      i18n: {
+        en: {
+          name: "Lisp",
+          description: "A family of programmable, expression-oriented languages best known through Common Lisp.",
+          longDescription: "Lisp is one of the oldest high-level programming language families, built around symbolic expressions, lists, macros, interactive development, dynamic typing, and programmable language syntax. This entry focuses on Common Lisp source files and systems.\n\nCommon Lisp is used for symbolic computation, AI research, compilers, DSLs, expert systems, automation, long-lived server applications, developer tools, and exploratory programming where macros and interactive workflows are central."
+        },
+        es: {
+          name: "Lisp",
+          description: "Una familia de lenguajes expresivos y programables, conocida especialmente por Common Lisp.",
+          longDescription: "Lisp es una de las familias de lenguajes de alto nivel mas antiguas, basada en expresiones simbolicas, listas, macros, desarrollo interactivo, tipado dinamico y sintaxis programable. Esta entrada se enfoca en archivos fuente y sistemas de Common Lisp.\n\nCommon Lisp se usa en computacion simbolica, investigacion de IA, compiladores, DSLs, sistemas expertos, automatizacion, aplicaciones de servidor longevas, herramientas de desarrollo y programacion exploratoria donde las macros y los flujos interactivos son centrales."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/lua.ts
 var lua_exports = {};
 __export(lua_exports, {
@@ -1237,6 +1500,81 @@ var init_matlab = __esm({
   }
 });
 
+// src/languages/meson.ts
+var meson_exports = {};
+__export(meson_exports, {
+  meson: () => meson
+});
+var meson;
+var init_meson = __esm({
+  "src/languages/meson.ts"() {
+    meson = {
+      slug: "meson",
+      publishedDate: "2013-01-01",
+      extensions: ["meson.build", "meson_options.txt", "meson.options", ".wrap"],
+      author: "Jussi Pakkanen / Meson contributors",
+      website: "https://mesonbuild.com",
+      paradigms: ["build-automation", "declarative", "configuration", "domain-specific"],
+      tooling: {
+        runtimes: ["Meson"],
+        packageManagers: ["WrapDB"],
+        ecosystems: ["C", "C++", "GNOME", "Linux", "Cross-platform Builds"]
+      },
+      version: "1.11.1",
+      logo: "https://raw.githubusercontent.com/mesonbuild/meson/master/graphics/meson_logo.svg",
+      i18n: {
+        en: {
+          name: "Meson",
+          description: "A fast, user-friendly build system DSL used to describe cross-platform native builds.",
+          longDescription: "Meson build files describe projects, targets, dependencies, compiler options, tests, install rules, subprojects, and cross-compilation settings using a readable non-Turing-complete DSL.\n\nIt is commonly used with Ninja for C, C++, C#, D, Fortran, Java, Rust, GNOME, Linux desktop, system software, native libraries, and projects that need fast incremental builds with clear build definitions."
+        },
+        es: {
+          name: "Meson",
+          description: "Un DSL de build rapido y amigable usado para describir builds nativos multiplataforma.",
+          longDescription: "Los archivos Meson describen proyectos, targets, dependencias, opciones de compilador, tests, reglas de instalacion, subproyectos y configuracion de cross-compilation usando un DSL legible y no Turing-completo.\n\nSe usa comunmente con Ninja para C, C++, C#, D, Fortran, Java, Rust, GNOME, escritorio Linux, software de sistema, librerias nativas y proyectos que necesitan builds incrementales rapidos con definiciones claras."
+        }
+      }
+    };
+  }
+});
+
+// src/languages/metal.ts
+var metal_exports = {};
+__export(metal_exports, {
+  metal: () => metal
+});
+var metal;
+var init_metal = __esm({
+  "src/languages/metal.ts"() {
+    metal = {
+      slug: "metal",
+      publishedDate: "2014-06-02",
+      extensions: [".metal"],
+      author: "Apple Inc.",
+      website: "https://developer.apple.com/metal/",
+      paradigms: ["gpu-programming", "graphics", "compute", "shading"],
+      tooling: {
+        runtimes: ["Metal"],
+        ecosystems: ["Apple Platforms", "iOS", "iPadOS", "macOS", "visionOS", "tvOS"]
+      },
+      version: "Metal 4",
+      logo: "https://developer.apple.com/assets/elements/icons/metal/metal-256x256_2x.png",
+      i18n: {
+        en: {
+          name: "Metal",
+          description: "Apple's graphics and compute shading language for high-performance GPU programming.",
+          longDescription: "Metal is Apple's low-level graphics and compute technology, paired with the Metal Shading Language for writing GPU kernels, vertex functions, fragment functions, mesh shaders, ray tracing workloads, and machine learning or media processing pipelines.\n\nIt is used across Apple platforms for games, rendering engines, compute-heavy apps, real-time graphics, image processing, video tools, scientific workloads, and performance-sensitive native applications that need direct access to Apple GPU capabilities."
+        },
+        es: {
+          name: "Metal",
+          description: "El lenguaje y API de Apple para graficos y computo de alto rendimiento en GPU.",
+          longDescription: "Metal es la tecnologia de bajo nivel de Apple para graficos y computo, junto con Metal Shading Language para escribir kernels de GPU, funciones de vertices, funciones de fragmentos, mesh shaders, cargas de ray tracing y pipelines de machine learning o procesamiento multimedia.\n\nSe usa en plataformas Apple para juegos, motores de render, apps con computo intensivo, graficos en tiempo real, procesamiento de imagen, herramientas de video, cargas cientificas y aplicaciones nativas sensibles al rendimiento que necesitan acceso directo a capacidades de GPU de Apple."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/nginx.ts
 var nginx_exports = {};
 __export(nginx_exports, {
@@ -1350,6 +1688,44 @@ var init_pascal = __esm({
   }
 });
 
+// src/languages/perl.ts
+var perl_exports = {};
+__export(perl_exports, {
+  perl: () => perl
+});
+var perl;
+var init_perl = __esm({
+  "src/languages/perl.ts"() {
+    perl = {
+      slug: "perl",
+      publishedDate: "1987-12-18",
+      extensions: [".pl", ".pm", ".pod", ".t", ".psgi"],
+      author: "Larry Wall",
+      website: "https://www.perl.org",
+      paradigms: ["functional", "imperative", "object-oriented", "procedural", "scripting"],
+      tooling: {
+        runtimes: ["Perl interpreter", "mod_perl", "PSGI/Plack"],
+        packageManagers: ["CPAN", "cpanm", "Carton"],
+        ecosystems: ["Unix", "Web", "Text Processing", "System Administration", "Bioinformatics"]
+      },
+      version: "5.42.2",
+      logo: "https://cdn.simpleicons.org/perl/39457E",
+      i18n: {
+        en: {
+          name: "Perl",
+          description: "A flexible scripting language for text processing, automation, web systems, and CPAN modules.",
+          longDescription: "Perl is a high-level scripting language created by Larry Wall, known for practical text processing, regular expressions, system scripting, dynamic typing, CPAN, and a strong culture of reusable modules. Perl 5 remains the main production language in the Perl family.\n\nIt is used for Unix automation, log processing, legacy web applications, bioinformatics, data munging, release tooling, network services, and long-lived operational scripts where expressive text handling and mature libraries matter."
+        },
+        es: {
+          name: "Perl",
+          description: "Un lenguaje de scripting flexible para procesamiento de texto, automatizacion, web y modulos CPAN.",
+          longDescription: "Perl es un lenguaje de scripting de alto nivel creado por Larry Wall, conocido por el procesamiento practico de texto, expresiones regulares, scripting de sistemas, tipado dinamico, CPAN y una cultura fuerte de modulos reutilizables. Perl 5 sigue siendo el lenguaje principal de produccion dentro de la familia Perl.\n\nSe usa en automatizacion Unix, procesamiento de logs, aplicaciones web legacy, bioinformatica, transformacion de datos, tooling de releases, servicios de red y scripts operacionales de larga vida donde importan el manejo expresivo de texto y librerias maduras."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/php.ts
 var php_exports = {};
 __export(php_exports, {
@@ -1800,6 +2176,43 @@ var init_svg = __esm({
   }
 });
 
+// src/languages/svn.ts
+var svn_exports = {};
+__export(svn_exports, {
+  svn: () => svn
+});
+var svn;
+var init_svn = __esm({
+  "src/languages/svn.ts"() {
+    svn = {
+      slug: "svn",
+      publishedDate: "2000-10-20",
+      extensions: [".svn", "svnserve.conf"],
+      author: "CollabNet / Apache Software Foundation",
+      website: "https://subversion.apache.org",
+      paradigms: ["configuration", "version-control", "centralized-version-control"],
+      tooling: {
+        runtimes: ["Apache Subversion", "svnserve", "Apache HTTP Server"],
+        ecosystems: ["Version Control", "Source Control", "DevOps", "Enterprise"]
+      },
+      version: "1.14.5",
+      logo: "https://cdn.simpleicons.org/subversion/809CC9",
+      i18n: {
+        en: {
+          name: "SVN",
+          description: "Metadata and configuration files used by Apache Subversion repositories and clients.",
+          longDescription: "SVN, Apache Subversion, is a centralized version control system with repository metadata, working-copy directories, ignore properties, server configuration, hooks, branches, tags, and revision history managed through Subversion tooling.\n\nIt is used in legacy and enterprise codebases, centralized source-control workflows, release management, document repositories, and projects that rely on Apache Subversion servers or clients."
+        },
+        es: {
+          name: "SVN",
+          description: "Archivos de metadata y configuracion usados por repositorios y clientes Apache Subversion.",
+          longDescription: "SVN, Apache Subversion, es un sistema de control de versiones centralizado con metadata de repositorio, directorios de working copy, propiedades de ignore, configuracion de servidor, hooks, branches, tags e historial de revisiones gestionados mediante herramientas Subversion.\n\nSe usa en codebases legacy y empresariales, flujos centralizados de control de codigo, gestion de releases, repositorios de documentos y proyectos que dependen de servidores o clientes Apache Subversion."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/swift.ts
 var swift_exports = {};
 __export(swift_exports, {
@@ -2023,6 +2436,43 @@ var init_webassembly = __esm({
   }
 });
 
+// src/languages/xaml.ts
+var xaml_exports = {};
+__export(xaml_exports, {
+  xaml: () => xaml
+});
+var xaml;
+var init_xaml = __esm({
+  "src/languages/xaml.ts"() {
+    xaml = {
+      slug: "xaml",
+      publishedDate: "2006-11-21",
+      extensions: [".xaml", ".baml"],
+      author: "Microsoft",
+      website: "https://learn.microsoft.com/en-us/windows/uwp/xaml-platform/xaml-overview",
+      paradigms: ["declarative", "markup", "object-graph", "ui"],
+      tooling: {
+        runtimes: ["WPF", "WinUI", "UWP XAML", ".NET MAUI", "Avalonia"],
+        ecosystems: ["Windows", ".NET", "Desktop Applications", "Mobile Applications", "UI"]
+      },
+      version: "Platform-specific",
+      logo: "https://cdn.simpleicons.org/dotnet/512BD4",
+      i18n: {
+        en: {
+          name: "XAML",
+          description: "A declarative XML-based language for defining object graphs and application user interfaces.",
+          longDescription: "XAML, Extensible Application Markup Language, is a declarative XML-based language used to instantiate objects, set properties, declare resources, bind data, and compose user interfaces.\n\nIt is used across Microsoft and .NET UI stacks such as WPF, UWP, WinUI, and .NET MAUI, as well as XAML-inspired frameworks like Avalonia. XAML files commonly define pages, windows, controls, styles, templates, animations, resources, and visual states."
+        },
+        es: {
+          name: "XAML",
+          description: "Un lenguaje declarativo basado en XML para definir grafos de objetos e interfaces de usuario.",
+          longDescription: "XAML, Extensible Application Markup Language, es un lenguaje declarativo basado en XML usado para instanciar objetos, definir propiedades, declarar recursos, enlazar datos y componer interfaces de usuario.\n\nSe usa en stacks de UI de Microsoft y .NET como WPF, UWP, WinUI y .NET MAUI, ademas de frameworks inspirados en XAML como Avalonia. Los archivos XAML suelen definir paginas, ventanas, controles, estilos, templates, animaciones, recursos y estados visuales."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/xml.ts
 var xml_exports = {};
 __export(xml_exports, {
@@ -2167,6 +2617,7 @@ var init_zsh = __esm({
 
 // src/catalog.ts
 init_abap();
+init_actionscript();
 init_asp();
 init_assembly();
 init_astro();
@@ -2177,11 +2628,15 @@ init_cmake();
 init_cobol();
 init_coffeescript();
 init_cpp();
+init_crystal();
 init_csharp();
 init_css();
 init_cuda();
 init_dart();
 init_dockerfile();
+init_elm();
+init_erlang();
+init_fortran();
 init_fsharp();
 init_git();
 init_go();
@@ -2189,19 +2644,24 @@ init_gradle();
 init_graphql();
 init_groovy();
 init_html();
+init_ini();
 init_java();
 init_javascript();
 init_json();
 init_julia();
 init_kotlin();
 init_less();
+init_lisp();
 init_lua();
 init_makefile();
 init_markdown();
 init_matlab();
+init_meson();
+init_metal();
 init_nginx();
 init_objective_c();
 init_pascal();
+init_perl();
 init_php();
 init_powershell();
 init_pug();
@@ -2214,18 +2674,21 @@ init_scss();
 init_sql();
 init_svelte();
 init_svg();
+init_svn();
 init_swift();
 init_toml();
 init_typescript();
 init_visual_basic();
 init_vue();
 init_webassembly();
+init_xaml();
 init_xml();
 init_yaml();
 init_zig();
 init_zsh();
 var languages = [
   abap,
+  actionscript,
   asp,
   astro,
   assembly,
@@ -2237,10 +2700,14 @@ var languages = [
   cobol,
   cpp,
   csharp,
+  crystal,
   css,
   cuda,
   dart,
   dockerfile,
+  elm,
+  erlang,
+  fortran,
   fsharp,
   git,
   go,
@@ -2248,19 +2715,25 @@ var languages = [
   graphql,
   groovy,
   html,
+  ini,
   java,
   javascript,
   json,
   julia,
   kotlin,
   less,
+  lisp,
   lua,
   makefile,
   matlab,
   markdown,
+  meson,
+  metal,
+  svn,
   nginx,
   objectiveC,
   pascal,
+  perl,
   php,
   powershell,
   pug,
@@ -2279,6 +2752,7 @@ var languages = [
   visualBasic,
   vue,
   webassembly,
+  xaml,
   xml,
   yaml,
   zig,
@@ -2340,6 +2814,7 @@ var resolveLocale = (translations, locale) => {
 // src/language-registry.ts
 var languageIndex = [
   { slug: "abap", extensions: [".abap"] },
+  { slug: "actionscript", extensions: [".as"] },
   { slug: "asp", extensions: [".asp", ".aspx", ".ascx", ".ashx", ".asmx", ".master"] },
   { slug: "astro", extensions: [".astro"] },
   { slug: "assembly", extensions: [".asm", ".s", ".S", ".inc"] },
@@ -2354,10 +2829,20 @@ var languageIndex = [
   { slug: "cobol", extensions: [".cob", ".cbl", ".cobol", ".cpy"] },
   { slug: "cpp", extensions: [".cpp", ".cc", ".cxx", ".h", ".hpp", ".hh", ".hxx"] },
   { slug: "csharp", extensions: [".cs", ".csx"] },
+  { slug: "crystal", extensions: [".cr"] },
   { slug: "css", extensions: [".css"] },
   { slug: "cuda", extensions: [".cu", ".cuh"] },
   { slug: "dart", extensions: [".dart"] },
   { slug: "dockerfile", extensions: ["Dockerfile", ".dockerfile"] },
+  { slug: "elm", extensions: [".elm"] },
+  {
+    slug: "erlang",
+    extensions: [".erl", ".hrl", ".app.src", ".escript", ".xrl", ".yrl", "rebar.config"]
+  },
+  {
+    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: "go", extensions: [".go"] },
@@ -2365,19 +2850,25 @@ var languageIndex = [
   { slug: "graphql", extensions: [".graphql", ".gql", ".graphqls"] },
   { slug: "groovy", extensions: [".groovy", ".gvy", ".gy", ".gsh"] },
   { slug: "html", extensions: [".html", ".htm"] },
+  { slug: "ini", extensions: [".ini"] },
   { slug: "java", extensions: [".java"] },
   { slug: "javascript", extensions: [".js", ".mjs", ".cjs", ".jsx"] },
   { slug: "json", extensions: [".json"] },
   { slug: "julia", extensions: [".jl"] },
   { slug: "kotlin", extensions: [".kt", ".kts"] },
   { slug: "less", extensions: [".less"] },
+  { slug: "lisp", extensions: [".lisp", ".lsp", ".cl", ".asd"] },
   { slug: "lua", extensions: [".lua", ".rockspec"] },
   { slug: "makefile", extensions: ["Makefile", "makefile", "GNUmakefile", ".mk", ".mak"] },
   { slug: "matlab", extensions: [".m", ".mlx"] },
   { slug: "markdown", extensions: [".md", ".markdown", ".mdown", ".mkd"] },
+  { slug: "meson", extensions: ["meson.build", "meson_options.txt", "meson.options", ".wrap"] },
+  { slug: "metal", extensions: [".metal"] },
+  { slug: "svn", extensions: [".svn", "svnserve.conf"] },
   { slug: "nginx", extensions: ["nginx.conf", ".nginx", ".conf"] },
   { slug: "objective-c", extensions: [".m", ".mm"] },
   { 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: "powershell", extensions: [".ps1", ".psm1", ".psd1", ".ps1xml"] },
   { slug: "pug", extensions: [".pug", ".jade"] },
@@ -2399,6 +2890,7 @@ var languageIndex = [
   { slug: "visual-basic", extensions: [".vb"] },
   { slug: "vue", extensions: [".vue"] },
   { slug: "webassembly", extensions: [".wasm", ".wat"] },
+  { slug: "xaml", extensions: [".xaml", ".baml"] },
   { slug: "xml", extensions: [".xml", ".xsd", ".xsl", ".xslt"] },
   { slug: "yaml", extensions: [".yaml", ".yml"] },
   { slug: "zig", extensions: [".zig", ".zon"] },
@@ -2409,6 +2901,7 @@ 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),
   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),
@@ -2420,10 +2913,14 @@ var languageLoaders = {
   coffeescript: () => Promise.resolve().then(() => (init_coffeescript(), coffeescript_exports)).then((module) => module.coffeescript),
   cpp: () => Promise.resolve().then(() => (init_cpp(), cpp_exports)).then((module) => module.cpp),
   csharp: () => Promise.resolve().then(() => (init_csharp(), csharp_exports)).then((module) => module.csharp),
+  crystal: () => Promise.resolve().then(() => (init_crystal(), crystal_exports)).then((module) => module.crystal),
   css: () => Promise.resolve().then(() => (init_css(), css_exports)).then((module) => module.css),
   cuda: () => Promise.resolve().then(() => (init_cuda(), cuda_exports)).then((module) => module.cuda),
   dart: () => Promise.resolve().then(() => (init_dart(), dart_exports)).then((module) => module.dart),
   dockerfile: () => Promise.resolve().then(() => (init_dockerfile(), dockerfile_exports)).then((module) => module.dockerfile),
+  elm: () => Promise.resolve().then(() => (init_elm(), elm_exports)).then((module) => module.elm),
+  erlang: () => Promise.resolve().then(() => (init_erlang(), erlang_exports)).then((module) => module.erlang),
+  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),
   go: () => Promise.resolve().then(() => (init_go(), go_exports)).then((module) => module.go),
@@ -2431,19 +2928,25 @@ var languageLoaders = {
   graphql: () => Promise.resolve().then(() => (init_graphql(), graphql_exports)).then((module) => module.graphql),
   groovy: () => Promise.resolve().then(() => (init_groovy(), groovy_exports)).then((module) => module.groovy),
   html: () => Promise.resolve().then(() => (init_html(), html_exports)).then((module) => module.html),
+  ini: () => Promise.resolve().then(() => (init_ini(), ini_exports)).then((module) => module.ini),
   java: () => Promise.resolve().then(() => (init_java(), java_exports)).then((module) => module.java),
   javascript: () => Promise.resolve().then(() => (init_javascript(), javascript_exports)).then((module) => module.javascript),
   json: () => Promise.resolve().then(() => (init_json(), json_exports)).then((module) => module.json),
   julia: () => Promise.resolve().then(() => (init_julia(), julia_exports)).then((module) => module.julia),
   kotlin: () => Promise.resolve().then(() => (init_kotlin(), kotlin_exports)).then((module) => module.kotlin),
   less: () => Promise.resolve().then(() => (init_less(), less_exports)).then((module) => module.less),
+  lisp: () => Promise.resolve().then(() => (init_lisp(), lisp_exports)).then((module) => module.lisp),
   lua: () => Promise.resolve().then(() => (init_lua(), lua_exports)).then((module) => module.lua),
   makefile: () => Promise.resolve().then(() => (init_makefile(), makefile_exports)).then((module) => module.makefile),
   matlab: () => Promise.resolve().then(() => (init_matlab(), matlab_exports)).then((module) => module.matlab),
   markdown: () => Promise.resolve().then(() => (init_markdown(), markdown_exports)).then((module) => module.markdown),
+  meson: () => Promise.resolve().then(() => (init_meson(), meson_exports)).then((module) => module.meson),
+  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),
   "objective-c": () => Promise.resolve().then(() => (init_objective_c(), objective_c_exports)).then((module) => module.objectiveC),
   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),
   powershell: () => Promise.resolve().then(() => (init_powershell(), powershell_exports)).then((module) => module.powershell),
   pug: () => Promise.resolve().then(() => (init_pug(), pug_exports)).then((module) => module.pug),
@@ -2462,6 +2965,7 @@ var languageLoaders = {
   "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),
   webassembly: () => Promise.resolve().then(() => (init_webassembly(), webassembly_exports)).then((module) => module.webassembly),
+  xaml: () => Promise.resolve().then(() => (init_xaml(), xaml_exports)).then((module) => module.xaml),
   xml: () => Promise.resolve().then(() => (init_xml(), xml_exports)).then((module) => module.xml),
   yaml: () => Promise.resolve().then(() => (init_yaml(), yaml_exports)).then((module) => module.yaml),
   zig: () => Promise.resolve().then(() => (init_zig(), zig_exports)).then((module) => module.zig),