code-languages 1.6.0 → 1.8.0

package/dist/detect.cjs

@@ -1,5 +1,62 @@
 'use strict';
 
+// src/languages/abap.ts
+var abap = {
+  slug: "abap",
+  publishedDate: "1983-01-01",
+  extensions: [".abap"],
+  author: "SAP SE",
+  website: "https://pages.community.sap.com/topics/abap",
+  paradigms: ["object-oriented", "procedural", "imperative", "event-driven", "database-oriented"],
+  tooling: {
+    runtimes: ["ABAP Platform", "SAP NetWeaver AS ABAP", "SAP BTP ABAP Environment"],
+    ecosystems: ["SAP S/4HANA", "SAP BTP", "Enterprise Applications"]
+  },
+  version: "ABAP Platform 2025 FPS01",
+  logo: "https://upload.wikimedia.org/wikipedia/commons/5/59/SAP_2011_logo.svg",
+  i18n: {
+    en: {
+      name: "ABAP",
+      description: "SAP's enterprise application programming language for business systems and extensions.",
+      longDescription: "ABAP is SAP's programming language for implementing business logic, reports, data models, services, enhancements, and extensions in ABAP-based SAP systems.\n\nIt is widely used across SAP S/4HANA, SAP BTP ABAP Environment, classic SAP ERP systems, custom enterprise applications, RAP services, CDS models, batch processing, and integration workflows."
+    },
+    es: {
+      name: "ABAP",
+      description: "El lenguaje empresarial de SAP para sistemas de negocio y extensiones.",
+      longDescription: "ABAP es el lenguaje de programacion de SAP para implementar logica de negocio, reportes, modelos de datos, servicios, mejoras y extensiones en sistemas SAP basados en ABAP.\n\nSe usa ampliamente en SAP S/4HANA, SAP BTP ABAP Environment, sistemas SAP ERP clasicos, aplicaciones empresariales personalizadas, servicios RAP, modelos CDS, procesamiento batch y flujos de integracion."
+    }
+  }
+};
+
+// src/languages/asp.ts
+var asp = {
+  slug: "asp",
+  publishedDate: "1996-12-01",
+  extensions: [".asp", ".aspx", ".ascx", ".ashx", ".asmx", ".master"],
+  author: "Microsoft",
+  website: "https://learn.microsoft.com/en-us/aspnet/web-forms/",
+  paradigms: ["server-side", "templating", "object-oriented", "event-driven"],
+  tooling: {
+    runtimes: ["IIS", ".NET Framework"],
+    packageManagers: ["NuGet"],
+    ecosystems: ["Windows", ".NET", "Web"]
+  },
+  version: "4.8.1",
+  logo: "https://cdn.simpleicons.org/dotnet/512BD4",
+  i18n: {
+    en: {
+      name: "ASP/ASPX",
+      description: "Microsoft server-side web templates and pages for Classic ASP and ASP.NET Web Forms.",
+      longDescription: "ASP and ASPX files represent Microsoft server-side web page technologies. Classic ASP uses `.asp` files with script blocks, while ASP.NET Web Forms uses `.aspx`, user controls, handlers, services, and master pages on top of the .NET Framework.\n\nThey are commonly found in legacy and long-lived Windows web applications hosted on IIS, often alongside C#, Visual Basic, HTML, CSS, JavaScript, and NuGet-based .NET Framework dependencies."
+    },
+    es: {
+      name: "ASP/ASPX",
+      description: "Plantillas y paginas web server-side de Microsoft para Classic ASP y ASP.NET Web Forms.",
+      longDescription: "Los archivos ASP y ASPX representan tecnologias de paginas web server-side de Microsoft. Classic ASP usa archivos `.asp` con bloques de script, mientras ASP.NET Web Forms usa `.aspx`, controles de usuario, handlers, servicios y paginas maestras sobre .NET Framework.\n\nAparecen comunmente en aplicaciones web Windows legacy o de larga vida alojadas en IIS, a menudo junto con C#, Visual Basic, HTML, CSS, JavaScript y dependencias .NET Framework basadas en NuGet."
+    }
+  }
+};
+
 // src/languages/assembly.ts
 var assembly = {
   slug: "assembly",
@@ -116,6 +173,34 @@ var c = {
   }
 };
 
+// src/languages/cmake.ts
+var cmake = {
+  slug: "cmake",
+  publishedDate: "2000-01-01",
+  extensions: ["CMakeLists.txt", ".cmake"],
+  author: "Kitware",
+  website: "https://cmake.org",
+  paradigms: ["build-automation", "declarative", "imperative", "configuration"],
+  tooling: {
+    runtimes: ["CMake"],
+    ecosystems: ["C", "C++", "Fortran", "Cross-platform Builds", "Embedded Systems"]
+  },
+  version: "4.3.2",
+  logo: "https://cmake.org/wp-content/uploads/2023/08/CMake-Logo.svg",
+  i18n: {
+    en: {
+      name: "CMake",
+      description: "A cross-platform build system language used to configure, generate, and manage builds.",
+      longDescription: "CMake files describe projects, targets, dependencies, compiler options, install rules, tests, and platform-specific build behavior using a command-based scripting language.\n\nThey are widely used to generate native build files for tools such as Ninja, Make, Visual Studio, and Xcode, especially in C, C++, Fortran, embedded, scientific, and cross-platform software projects."
+    },
+    es: {
+      name: "CMake",
+      description: "Un lenguaje de build multiplataforma usado para configurar, generar y gestionar builds.",
+      longDescription: "Los archivos CMake describen proyectos, targets, dependencias, opciones de compilador, reglas de instalacion, tests y comportamiento de build por plataforma usando un lenguaje de scripting basado en comandos.\n\nSe usan ampliamente para generar archivos de build nativos para herramientas como Ninja, Make, Visual Studio y Xcode, especialmente en proyectos C, C++, Fortran, embebidos, cientificos y multiplataforma."
+    }
+  }
+};
+
 // src/languages/cobol.ts
 var cobol = {
   slug: "cobol",
@@ -255,6 +340,35 @@ var css = {
   }
 };
 
+// src/languages/cuda.ts
+var cuda = {
+  slug: "cuda",
+  publishedDate: "2007-02-15",
+  extensions: [".cu", ".cuh"],
+  author: "NVIDIA",
+  website: "https://developer.nvidia.com/cuda-toolkit",
+  paradigms: ["parallel", "data-parallel", "systems", "heterogeneous-computing"],
+  tooling: {
+    runtimes: ["CUDA Runtime", "CUDA Driver API"],
+    packageManagers: ["CUDA Toolkit", "conda"],
+    ecosystems: ["GPU Computing", "HPC", "Machine Learning", "Scientific Computing"]
+  },
+  version: "13.2.1",
+  logo: "https://cdn.simpleicons.org/nvidia/76B900",
+  i18n: {
+    en: {
+      name: "CUDA",
+      description: "NVIDIA's GPU programming platform and C/C++ extensions for parallel computing.",
+      longDescription: "CUDA is NVIDIA's parallel computing platform and programming model for GPU-accelerated applications. CUDA C/C++ source files use extensions for kernels, device functions, memory spaces, grids, blocks, and threads that execute on NVIDIA GPUs.\n\nIt is used in machine learning, scientific computing, simulations, image processing, rendering, high-performance computing, and applications that need to offload massively parallel workloads to GPU hardware."
+    },
+    es: {
+      name: "CUDA",
+      description: "La plataforma GPU de NVIDIA y extensiones C/C++ para computacion paralela.",
+      longDescription: "CUDA es la plataforma de computacion paralela y modelo de programacion de NVIDIA para aplicaciones aceleradas por GPU. Los archivos CUDA C/C++ usan extensiones para kernels, funciones de dispositivo, espacios de memoria, grids, blocks y threads que se ejecutan en GPUs NVIDIA.\n\nSe usa en machine learning, computacion cientifica, simulaciones, procesamiento de imagenes, rendering, computacion de alto rendimiento y aplicaciones que necesitan descargar cargas masivamente paralelas al hardware GPU."
+    }
+  }
+};
+
 // src/languages/dart.ts
 var dart = {
   slug: "dart",
@@ -312,6 +426,35 @@ var dockerfile = {
   }
 };
 
+// src/languages/fsharp.ts
+var fsharp = {
+  slug: "fsharp",
+  publishedDate: "2005-05-01",
+  extensions: [".fs", ".fsi", ".fsx", ".fsscript"],
+  author: "Don Syme / Microsoft Research",
+  website: "https://dotnet.microsoft.com/en-us/languages/fsharp",
+  paradigms: ["functional", "object-oriented", "imperative", "scripting"],
+  tooling: {
+    runtimes: [".NET", "F# Interactive"],
+    packageManagers: ["NuGet"],
+    ecosystems: [".NET", "Data Science", "Web", "Cloud"]
+  },
+  version: "10",
+  logo: "https://cdn.simpleicons.org/fsharp/378BBA",
+  i18n: {
+    en: {
+      name: "F#",
+      description: "A succinct, functional-first .NET language for robust applications, scripts, and data workflows.",
+      longDescription: "F# is a functional-first programming language in the .NET ecosystem. It combines type inference, immutable data by default, pattern matching, discriminated unions, computation expressions, and interoperability with C# and other .NET languages.\n\nIt is used for backend services, data processing, scripting, domain modeling, financial systems, cloud applications, and teams that want concise code with strong static typing and access to the broader .NET platform."
+    },
+    es: {
+      name: "F#",
+      description: "Un lenguaje .NET conciso y funcional para aplicaciones robustas, scripts y flujos de datos.",
+      longDescription: "F# es un lenguaje de programacion funcional-first dentro del ecosistema .NET. Combina inferencia de tipos, datos inmutables por defecto, pattern matching, uniones discriminadas, computation expressions e interoperabilidad con C# y otros lenguajes .NET.\n\nSe usa en servicios backend, procesamiento de datos, scripting, modelado de dominios, sistemas financieros, aplicaciones cloud y equipos que quieren codigo conciso con tipado estatico fuerte y acceso a la plataforma .NET."
+    }
+  }
+};
+
 // src/languages/go.ts
 var go = {
   slug: "go",
@@ -505,6 +648,35 @@ var json = {
   }
 };
 
+// src/languages/julia.ts
+var julia = {
+  slug: "julia",
+  publishedDate: "2012-02-14",
+  extensions: [".jl"],
+  author: "Jeff Bezanson, Stefan Karpinski, Viral B. Shah, Alan Edelman",
+  website: "https://julialang.org",
+  paradigms: ["multiple-dispatch", "functional", "imperative", "metaprogramming"],
+  tooling: {
+    runtimes: ["Julia"],
+    packageManagers: ["Pkg"],
+    ecosystems: ["Scientific Computing", "Data Science", "Machine Learning", "HPC"]
+  },
+  version: "1.12.6",
+  logo: "https://cdn.simpleicons.org/julia/9558B2",
+  i18n: {
+    en: {
+      name: "Julia",
+      description: "A high-performance language for technical computing, data science, and numerical work.",
+      longDescription: "Julia is a high-level, high-performance programming language designed for numerical and scientific computing. It combines dynamic interactivity with just-in-time compilation, multiple dispatch, metaprogramming, and a package ecosystem focused on technical work.\n\nIt is widely used for scientific computing, data analysis, machine learning, optimization, simulations, high-performance computing, and workflows where teams want expressive code that can run close to native speed."
+    },
+    es: {
+      name: "Julia",
+      description: "Un lenguaje de alto rendimiento para computacion tecnica, ciencia de datos y trabajo numerico.",
+      longDescription: "Julia es un lenguaje de programacion de alto nivel y alto rendimiento disenado para computacion numerica y cientifica. Combina interactividad dinamica con compilacion just-in-time, multiple dispatch, metaprogramacion y un ecosistema de paquetes enfocado en trabajo tecnico.\n\nSe usa ampliamente en computacion cientifica, analisis de datos, machine learning, optimizacion, simulaciones, computacion de alto rendimiento y flujos donde los equipos quieren codigo expresivo que pueda ejecutarse cerca de velocidad nativa."
+    }
+  }
+};
+
 // src/languages/kotlin.ts
 var kotlin = {
   slug: "kotlin",
@@ -563,6 +735,35 @@ var less = {
   }
 };
 
+// src/languages/lua.ts
+var lua = {
+  slug: "lua",
+  publishedDate: "1994-07-08",
+  extensions: [".lua", ".rockspec"],
+  author: "Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes",
+  website: "https://www.lua.org",
+  paradigms: ["procedural", "functional", "object-oriented", "scripting", "embeddable"],
+  tooling: {
+    runtimes: ["Lua", "LuaJIT"],
+    packageManagers: ["LuaRocks"],
+    ecosystems: ["Game Development", "Embedded Systems", "Scripting", "Configuration"]
+  },
+  version: "5.5.0",
+  logo: "https://www.lua.org/images/lua-logo.gif",
+  i18n: {
+    en: {
+      name: "Lua",
+      description: "A lightweight, embeddable scripting language designed for extension and portability.",
+      longDescription: "Lua is a small, fast scripting language with tables, first-class functions, closures, coroutines, metatables, dynamic typing, and a compact C API for embedding and extension.\n\nIt is widely used in game engines, embedded systems, application scripting, configuration files, plugins, network tools, Redis scripts, Neovim configuration, and products that need a portable extension language."
+    },
+    es: {
+      name: "Lua",
+      description: "Un lenguaje de scripting liviano y embebible disenado para extension y portabilidad.",
+      longDescription: "Lua es un lenguaje de scripting pequeno y rapido con tablas, funciones de primera clase, closures, corutinas, metatables, tipado dinamico y una API C compacta para embedding y extension.\n\nSe usa ampliamente en motores de videojuegos, sistemas embebidos, scripting de aplicaciones, archivos de configuracion, plugins, herramientas de red, scripts de Redis, configuracion de Neovim y productos que necesitan un lenguaje de extension portable."
+    }
+  }
+};
+
 // src/languages/makefile.ts
 var makefile = {
   slug: "makefile",
@@ -615,6 +816,35 @@ var markdown = {
   }
 };
 
+// src/languages/matlab.ts
+var matlab = {
+  slug: "matlab",
+  publishedDate: "1984-01-01",
+  extensions: [".m", ".mlx"],
+  author: "MathWorks",
+  website: "https://www.mathworks.com/products/matlab.html",
+  paradigms: ["array-oriented", "imperative", "object-oriented", "procedural"],
+  tooling: {
+    runtimes: ["MATLAB"],
+    packageManagers: ["MATLAB Add-On Explorer"],
+    ecosystems: ["Scientific Computing", "Numerical Computing", "Engineering", "Simulink"]
+  },
+  version: "R2026a",
+  logo: "https://commons.wikimedia.org/wiki/Special:FilePath/Matlab_Logo.png",
+  i18n: {
+    en: {
+      name: "MATLAB",
+      description: "A matrix-oriented language and environment for engineering, science, data, and simulation.",
+      longDescription: "MATLAB is a programming language and numerical computing environment from MathWorks. It is centered on matrix and array operations, interactive analysis, visualization, algorithm development, and workflows for engineers and scientists.\n\nIt is commonly used for signal processing, control systems, robotics, data analysis, optimization, simulation, education, and model-based design alongside Simulink and MathWorks toolboxes."
+    },
+    es: {
+      name: "MATLAB",
+      description: "Un lenguaje y entorno orientado a matrices para ingenieria, ciencia, datos y simulacion.",
+      longDescription: "MATLAB es un lenguaje de programacion y entorno de computacion numerica de MathWorks. Esta centrado en operaciones con matrices y arreglos, analisis interactivo, visualizacion, desarrollo de algoritmos y flujos de trabajo para ingenieros y cientificos.\n\nSe usa comunmente en procesamiento de senales, sistemas de control, robotica, analisis de datos, optimizacion, simulacion, educacion y diseno basado en modelos junto con Simulink y las toolboxes de MathWorks."
+    }
+  }
+};
+
 // src/languages/nginx.ts
 var nginx = {
   slug: "nginx",
@@ -672,6 +902,35 @@ var objectiveC = {
   }
 };
 
+// src/languages/pascal.ts
+var pascal = {
+  slug: "pascal",
+  publishedDate: "1970-01-01",
+  extensions: [".pas", ".pp", ".inc", ".lpr", ".dpr", ".dfm"],
+  author: "Niklaus Wirth",
+  website: "https://www.freepascal.org",
+  paradigms: ["structured", "imperative", "procedural", "object-oriented"],
+  tooling: {
+    runtimes: ["Free Pascal", "Delphi Runtime"],
+    packageManagers: ["fppkg", "OPM"],
+    ecosystems: ["Desktop", "Education", "Embedded", "Cross-platform Native"]
+  },
+  version: "3.2.2",
+  logo: "https://cdn.simpleicons.org/lazarus/000000",
+  i18n: {
+    en: {
+      name: "Pascal",
+      description: "A structured programming language and Object Pascal family used for native applications.",
+      longDescription: "Pascal is a structured programming language created by Niklaus Wirth and later expanded through Object Pascal dialects such as Delphi and Free Pascal. It emphasizes readable syntax, clear program structure, strong typing, procedures, records, units, and native compilation.\n\nIt is used in education, desktop software, cross-platform native applications, embedded systems, legacy business tools, and Lazarus or Delphi projects that rely on Pascal and Object Pascal source files."
+    },
+    es: {
+      name: "Pascal",
+      description: "Un lenguaje estructurado y familia Object Pascal usado para aplicaciones nativas.",
+      longDescription: "Pascal es un lenguaje de programacion estructurada creado por Niklaus Wirth y luego expandido mediante dialectos Object Pascal como Delphi y Free Pascal. Enfatiza sintaxis legible, estructura clara, tipado fuerte, procedimientos, records, units y compilacion nativa.\n\nSe usa en educacion, software de escritorio, aplicaciones nativas multiplataforma, sistemas embebidos, herramientas legacy de negocio y proyectos Lazarus o Delphi basados en archivos fuente Pascal y Object Pascal."
+    }
+  }
+};
+
 // src/languages/php.ts
 var php = {
   slug: "php",
@@ -730,6 +989,35 @@ var powershell = {
   }
 };
 
+// src/languages/pug.ts
+var pug = {
+  slug: "pug",
+  publishedDate: "2010-06-01",
+  extensions: [".pug", ".jade"],
+  author: "TJ Holowaychuk / Pug contributors",
+  website: "https://pugjs.org",
+  paradigms: ["declarative", "templating", "markup"],
+  tooling: {
+    runtimes: ["Node.js", "Browser"],
+    packageManagers: ["npm", "pnpm", "Yarn"],
+    ecosystems: ["Web", "Node.js"]
+  },
+  version: "3.0.3",
+  logo: "https://cdn.simpleicons.org/pug/A86454",
+  i18n: {
+    en: {
+      name: "Pug",
+      description: "A whitespace-sensitive template language for generating HTML in Node.js and browsers.",
+      longDescription: "Pug is a high-performance template language for writing HTML with concise, indentation-based syntax. It was formerly known as Jade and is commonly used to generate HTML from reusable templates, layouts, includes, mixins, and JavaScript expressions.\n\nIt is used in Node.js web applications, static site workflows, component prototypes, email templates, and build pipelines where teams want compact templates that compile to HTML."
+    },
+    es: {
+      name: "Pug",
+      description: "Un lenguaje de plantillas sensible a espacios para generar HTML en Node.js y navegadores.",
+      longDescription: "Pug es un lenguaje de plantillas de alto rendimiento para escribir HTML con una sintaxis concisa basada en indentacion. Antes se llamaba Jade y se usa comunmente para generar HTML desde plantillas reutilizables, layouts, includes, mixins y expresiones JavaScript.\n\nSe usa en aplicaciones web con Node.js, flujos de sitios estaticos, prototipos de componentes, plantillas de email y pipelines de build donde los equipos quieren plantillas compactas que compilan a HTML."
+    }
+  }
+};
+
 // src/languages/python.ts
 var python = {
   slug: "python",
@@ -759,6 +1047,64 @@ var python = {
   }
 };
 
+// src/languages/r.ts
+var r = {
+  slug: "r",
+  publishedDate: "1993-08-01",
+  extensions: [".r", ".R", ".rmd", ".Rmd", ".qmd", ".Rprofile"],
+  author: "Ross Ihaka, Robert Gentleman / R Core Team",
+  website: "https://www.r-project.org",
+  paradigms: ["functional", "array-oriented", "object-oriented", "statistical"],
+  tooling: {
+    runtimes: ["R"],
+    packageManagers: ["CRAN", "renv", "pak"],
+    ecosystems: ["Statistics", "Data Science", "Visualization", "Scientific Computing"]
+  },
+  version: "4.6.0",
+  logo: "https://www.r-project.org/logo/Rlogo.svg",
+  i18n: {
+    en: {
+      name: "R",
+      description: "A statistical computing language and environment for data analysis, graphics, and research.",
+      longDescription: "R is a programming language and software environment for statistical computing, data analysis, graphics, and reproducible research. It provides vectorized operations, data frames, formulas, packages, interactive workflows, and a large ecosystem centered around CRAN.\n\nIt is widely used in statistics, bioinformatics, data science, academic research, visualization, reporting, modeling, and analytical workflows that combine code, data, plots, and narrative documents."
+    },
+    es: {
+      name: "R",
+      description: "Un lenguaje y entorno de computacion estadistica para analisis de datos, graficos e investigacion.",
+      longDescription: "R es un lenguaje de programacion y entorno de software para computacion estadistica, analisis de datos, graficos e investigacion reproducible. Ofrece operaciones vectorizadas, data frames, formulas, paquetes, flujos interactivos y un ecosistema amplio centrado en CRAN.\n\nSe usa ampliamente en estadistica, bioinformatica, ciencia de datos, investigacion academica, visualizacion, reportes, modelado y flujos analiticos que combinan codigo, datos, graficos y documentos narrativos."
+    }
+  }
+};
+
+// src/languages/ruby.ts
+var ruby = {
+  slug: "ruby",
+  publishedDate: "1995-12-21",
+  extensions: [".rb", ".rbw", ".rake", ".gemspec", "Gemfile", "Rakefile", "config.ru"],
+  author: "Yukihiro Matsumoto",
+  website: "https://www.ruby-lang.org",
+  paradigms: ["object-oriented", "imperative", "functional", "reflective", "scripting"],
+  tooling: {
+    runtimes: ["Ruby MRI", "JRuby", "TruffleRuby"],
+    packageManagers: ["RubyGems", "Bundler"],
+    ecosystems: ["Web", "Rails", "DevOps", "Automation"]
+  },
+  version: "4.0.3",
+  logo: "https://www.ruby-lang.org/images/header-ruby-logo.png",
+  i18n: {
+    en: {
+      name: "Ruby",
+      description: "A dynamic, object-oriented scripting language focused on productivity and developer happiness.",
+      longDescription: "Ruby is a dynamic language with expressive syntax, open classes, blocks, mixins, metaprogramming, exceptions, modules, and a strong object-oriented model where nearly everything is an object.\n\nIt is widely used for web applications with Ruby on Rails, command-line tools, automation scripts, infrastructure tooling, static site generation, testing frameworks, and developer productivity workflows."
+    },
+    es: {
+      name: "Ruby",
+      description: "Un lenguaje dinamico y orientado a objetos enfocado en productividad y felicidad del desarrollador.",
+      longDescription: "Ruby es un lenguaje dinamico con sintaxis expresiva, clases abiertas, bloques, mixins, metaprogramacion, excepciones, modulos y un modelo orientado a objetos donde casi todo es un objeto.\n\nSe usa ampliamente para aplicaciones web con Ruby on Rails, herramientas de linea de comandos, scripts de automatizacion, tooling de infraestructura, generadores de sitios estaticos, frameworks de testing y flujos de productividad para desarrolladores."
+    }
+  }
+};
+
 // src/languages/rust.ts
 var rust = {
   slug: "rust",
@@ -788,6 +1134,35 @@ var rust = {
   }
 };
 
+// src/languages/scala.ts
+var scala = {
+  slug: "scala",
+  publishedDate: "2004-01-20",
+  extensions: [".scala", ".sc"],
+  author: "Martin Odersky / EPFL",
+  website: "https://www.scala-lang.org",
+  paradigms: ["object-oriented", "functional", "statically-typed", "concurrent"],
+  tooling: {
+    runtimes: ["JVM", "Scala.js", "Scala Native"],
+    packageManagers: ["sbt", "Maven", "Gradle", "Scala CLI"],
+    ecosystems: ["JVM", "Web", "Data Engineering", "Distributed Systems"]
+  },
+  version: "3.7.4",
+  logo: "https://cdn.simpleicons.org/scala/DC322F",
+  i18n: {
+    en: {
+      name: "Scala",
+      description: "A JVM language that blends object-oriented and functional programming with strong static typing.",
+      longDescription: "Scala is a general-purpose programming language that combines object-oriented and functional programming on the JVM. It includes strong static typing, type inference, pattern matching, higher-order functions, traits, implicits or givens, and interoperability with Java libraries.\n\nIt is used for backend services, data engineering, distributed systems, streaming pipelines, domain modeling, and applications that benefit from expressive abstractions while staying connected to the JVM ecosystem."
+    },
+    es: {
+      name: "Scala",
+      description: "Un lenguaje JVM que combina programacion orientada a objetos y funcional con tipado estatico fuerte.",
+      longDescription: "Scala es un lenguaje de programacion de proposito general que combina programacion orientada a objetos y funcional sobre la JVM. Incluye tipado estatico fuerte, inferencia de tipos, pattern matching, funciones de orden superior, traits, implicits o givens e interoperabilidad con bibliotecas Java.\n\nSe usa en servicios backend, ingenieria de datos, sistemas distribuidos, pipelines de streaming, modelado de dominios y aplicaciones que aprovechan abstracciones expresivas sin salir del ecosistema JVM."
+    }
+  }
+};
+
 // src/languages/scss.ts
 var scss = {
   slug: "scss",
@@ -841,6 +1216,35 @@ var sql = {
   }
 };
 
+// src/languages/svelte.ts
+var svelte = {
+  slug: "svelte",
+  publishedDate: "2016-11-26",
+  extensions: [".svelte"],
+  author: "Rich Harris / Svelte contributors",
+  website: "https://svelte.dev",
+  paradigms: ["component-based", "declarative", "reactive", "compiled"],
+  tooling: {
+    runtimes: ["Browser", "Node.js"],
+    packageManagers: ["npm", "pnpm", "Yarn", "Bun"],
+    ecosystems: ["Web", "SvelteKit", "Vite"]
+  },
+  version: "5.55.5",
+  logo: "https://upload.wikimedia.org/wikipedia/commons/1/1b/Svelte_Logo.svg",
+  i18n: {
+    en: {
+      name: "Svelte",
+      description: "A compiled component framework for building reactive web user interfaces.",
+      longDescription: "Svelte components combine markup, styles, and script logic in single-file components that are compiled into efficient JavaScript for updating the DOM.\n\nIt is widely used for web applications, interactive interfaces, static sites, design systems, dashboards, and SvelteKit projects where developers want a reactive component model with minimal runtime overhead."
+    },
+    es: {
+      name: "Svelte",
+      description: "Un framework de componentes compilado para crear interfaces web reactivas.",
+      longDescription: "Los componentes Svelte combinan marcado, estilos y logica de script en componentes de archivo unico que se compilan a JavaScript eficiente para actualizar el DOM.\n\nSe usa ampliamente en aplicaciones web, interfaces interactivas, sitios estaticos, sistemas de diseno, dashboards y proyectos SvelteKit donde se busca un modelo de componentes reactivo con poca sobrecarga en runtime."
+    }
+  }
+};
+
 // src/languages/svg.ts
 var svg = {
   slug: "svg",
@@ -898,6 +1302,30 @@ var swift = {
   }
 };
 
+// src/languages/toml.ts
+var toml = {
+  slug: "toml",
+  publishedDate: "2013-02-23",
+  extensions: [".toml"],
+  author: "Tom Preston-Werner / TOML contributors",
+  website: "https://toml.io",
+  paradigms: ["configuration", "declarative", "data-serialization"],
+  version: "1.0.0",
+  logo: "https://cdn.simpleicons.org/toml/9C4221",
+  i18n: {
+    en: {
+      name: "TOML",
+      description: "A minimal, human-readable configuration format that maps clearly to data structures.",
+      longDescription: "TOML is a configuration file format designed to be easy for humans to read and write while mapping unambiguously to data structures such as hash tables. It supports key-value pairs, tables, arrays, strings, numbers, booleans, and date-time values.\n\nIt is used for project configuration, package manifests, build settings, tool configuration, infrastructure metadata, and applications that need concise structured data without the visual noise of more verbose formats."
+    },
+    es: {
+      name: "TOML",
+      description: "Un formato de configuracion minimo y legible que mapea claramente a estructuras de datos.",
+      longDescription: "TOML es un formato de archivos de configuracion disenado para ser facil de leer y escribir por humanos mientras mapea sin ambiguedad a estructuras de datos como tablas hash. Soporta pares clave-valor, tablas, arreglos, strings, numeros, booleanos y valores de fecha y hora.\n\nSe usa en configuracion de proyectos, manifiestos de paquetes, ajustes de build, configuracion de herramientas, metadata de infraestructura y aplicaciones que necesitan datos estructurados concisos sin el ruido visual de formatos mas verbosos."
+    }
+  }
+};
+
 // src/languages/typescript.ts
 var typescript = {
   slug: "typescript",
@@ -1062,6 +1490,35 @@ var yaml = {
   }
 };
 
+// src/languages/zig.ts
+var zig = {
+  slug: "zig",
+  publishedDate: "2016-02-08",
+  extensions: [".zig", ".zon"],
+  author: "Andrew Kelley / Zig Software Foundation",
+  website: "https://ziglang.org",
+  paradigms: ["imperative", "procedural", "systems", "compile-time metaprogramming"],
+  tooling: {
+    runtimes: ["Native"],
+    packageManagers: ["Zig Package Manager"],
+    ecosystems: ["Systems Programming", "Embedded", "Game Development", "Cross-compilation"]
+  },
+  version: "0.16.0",
+  logo: "https://cdn.simpleicons.org/zig/F7A41D",
+  i18n: {
+    en: {
+      name: "Zig",
+      description: "A systems programming language and toolchain focused on robustness, control, and cross-compilation.",
+      longDescription: "Zig is a general-purpose systems programming language and toolchain designed for explicit control, predictable performance, cross-compilation, and maintaining robust software. It provides manual memory management, comptime execution, error unions, integrated build tooling, and C interoperability.\n\nIt is used for systems software, embedded targets, command-line tools, game engines, low-level libraries, cross-platform native applications, and projects that need a compact language with strong compile-time capabilities."
+    },
+    es: {
+      name: "Zig",
+      description: "Un lenguaje y toolchain de sistemas enfocado en robustez, control y cross-compilation.",
+      longDescription: "Zig es un lenguaje de programacion de sistemas y toolchain de proposito general disenado para control explicito, rendimiento predecible, cross-compilation y mantenimiento de software robusto. Ofrece gestion manual de memoria, ejecucion comptime, uniones de error, tooling de build integrado e interoperabilidad con C.\n\nSe usa en software de sistemas, targets embebidos, herramientas de linea de comandos, motores de juegos, bibliotecas de bajo nivel, aplicaciones nativas multiplataforma y proyectos que necesitan un lenguaje compacto con capacidades fuertes de compilacion en tiempo de build."
+    }
+  }
+};
+
 // src/languages/zsh.ts
 var zsh = {
   slug: "zsh",
@@ -1093,17 +1550,22 @@ var zsh = {
 
 // src/catalog.ts
 var languages = [
+  abap,
+  asp,
   astro,
   assembly,
   bash,
   c,
+  cmake,
   coffeescript,
   cobol,
   cpp,
   csharp,
   css,
+  cuda,
   dart,
   dockerfile,
+  fsharp,
   go,
   graphql,
   groovy,
@@ -1111,42 +1573,43 @@ var languages = [
   java,
   javascript,
   json,
+  julia,
   kotlin,
   less,
+  lua,
   makefile,
+  matlab,
   markdown,
   nginx,
   objectiveC,
+  pascal,
   php,
   powershell,
+  pug,
   python,
+  r,
+  ruby,
   rust,
+  scala,
   scss,
   sql,
   svg,
+  svelte,
   swift,
+  toml,
   typescript,
   visualBasic,
   vue,
   webassembly,
   xml,
   yaml,
+  zig,
   zsh
 ];
 
-// src/detect.ts
+// src/match.ts
 var pathSegmentPattern = /[/\\]/;
-var detectLanguages = (filename) => {
-  const normalizedFilename = filename.trim();
-  if (!normalizedFilename) {
-    return [];
-  }
-  const basename = normalizedFilename.split(pathSegmentPattern).at(-1)?.toLowerCase() ?? "";
-  return languages.filter(
-    (language) => language.extensions.some((extension) => matchesExtension(basename, extension))
-  );
-};
-var detectLanguage = (filename) => detectLanguages(filename).at(0);
+var getBasename = (filename) => filename.trim().split(pathSegmentPattern).at(-1)?.toLowerCase() ?? "";
 var matchesExtension = (basename, extension) => {
   const normalizedExtension = extension.toLowerCase();
   if (normalizedExtension.startsWith(".")) {
@@ -1154,6 +1617,21 @@ var matchesExtension = (basename, extension) => {
   }
   return basename === normalizedExtension || basename.endsWith(`.${normalizedExtension}`);
 };
+var detectMatchingEntries = (entries, filename) => {
+  const basename = getBasename(filename);
+  if (!basename) {
+    return [];
+  }
+  return entries.filter(
+    (entry) => entry.extensions.some((extension) => matchesExtension(basename, extension))
+  );
+};
+
+// src/detect.ts
+var detectLanguages = (filename) => {
+  return detectMatchingEntries(languages, filename);
+};
+var detectLanguage = (filename) => detectLanguages(filename).at(0);
 
 exports.detectLanguage = detectLanguage;
 exports.detectLanguages = detectLanguages;