code-languages 1.7.0 → 1.9.0

package/dist/detect.cjs

@@ -28,6 +28,35 @@ var abap = {
   }
 };
 
+// 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",
@@ -115,6 +144,34 @@ var bash = {
   }
 };
 
+// src/languages/batch.ts
+var batch = {
+  slug: "batch",
+  publishedDate: "1981-08-12",
+  extensions: [".bat", ".cmd"],
+  author: "Microsoft / IBM",
+  website: "https://learn.microsoft.com/windows-server/administration/windows-commands/windows-commands",
+  paradigms: ["command", "imperative", "scripting", "shell"],
+  tooling: {
+    runtimes: ["Command Prompt", "cmd.exe", "MS-DOS"],
+    ecosystems: ["Windows", "DOS", "Automation"]
+  },
+  version: "Windows Command Processor",
+  logo: "https://icons.iconarchive.com/icons/simpleicons-team/simple/128/windowsterminal-icon.png",
+  i18n: {
+    en: {
+      name: "Batch",
+      description: "A Windows command scripting format used to automate command-line tasks with cmd.exe.",
+      longDescription: "Batch files contain commands interpreted by the Windows Command Processor, including command invocation, variables, labels, conditionals, loops, argument handling, and process control.\n\nThey are used for Windows setup scripts, developer shortcuts, administrative automation, legacy DOS workflows, and simple command-line task orchestration on Windows systems."
+    },
+    es: {
+      name: "Batch",
+      description: "Un formato de scripting de comandos de Windows usado para automatizar tareas con cmd.exe.",
+      longDescription: "Los archivos Batch contienen comandos interpretados por Windows Command Processor, incluyendo invocacion de comandos, variables, etiquetas, condicionales, bucles, manejo de argumentos y control de procesos.\n\nSe usan para scripts de configuracion en Windows, accesos rapidos de desarrollo, automatizacion administrativa, flujos legacy de DOS y orquestacion simple de tareas de linea de comandos en sistemas Windows."
+    }
+  }
+};
+
 // src/languages/c.ts
 var c = {
   slug: "c",
@@ -311,6 +368,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",
@@ -368,6 +454,63 @@ 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/git.ts
+var git = {
+  slug: "git",
+  publishedDate: "2005-04-07",
+  extensions: [".git", ".gitignore", ".gitattributes", ".gitmodules", ".gitkeep"],
+  author: "Linus Torvalds / Junio C Hamano",
+  website: "https://git-scm.com",
+  paradigms: ["configuration", "version-control", "ignore-patterns"],
+  tooling: {
+    runtimes: ["Git"],
+    ecosystems: ["Version Control", "DevOps", "Source Control"]
+  },
+  version: "2.54.0",
+  logo: "https://cdn.simpleicons.org/git/F05032",
+  i18n: {
+    en: {
+      name: "Git",
+      description: "Metadata and configuration files used by Git repositories and version-control workflows.",
+      longDescription: "Git-related files define repository ignore rules, attributes, submodules, local configuration, placeholders, and repository metadata used by Git tooling.\n\nThey are used in software projects to control which files are tracked, how paths are treated, how submodules are linked, and how repository-specific automation or conventions behave."
+    },
+    es: {
+      name: "Git",
+      description: "Archivos de metadata y configuracion usados por repositorios Git y flujos de control de versiones.",
+      longDescription: "Los archivos relacionados con Git definen reglas de ignorado, atributos, submodulos, configuracion local, placeholders y metadata de repositorio usada por herramientas Git.\n\nSe usan en proyectos de software para controlar que archivos se versionan, como se tratan las rutas, como se enlazan submodulos y como se comportan automatizaciones o convenciones especificas del repositorio."
+    }
+  }
+};
+
 // src/languages/go.ts
 var go = {
   slug: "go",
@@ -397,6 +540,35 @@ var go = {
   }
 };
 
+// src/languages/gradle.ts
+var gradle = {
+  slug: "gradle",
+  publishedDate: "2007-07-01",
+  extensions: [".gradle", ".gradle.kts"],
+  author: "Hans Dockter / Gradle Inc.",
+  website: "https://gradle.org",
+  paradigms: ["build-automation", "declarative", "imperative", "configuration"],
+  tooling: {
+    runtimes: ["JVM", "Gradle"],
+    packageManagers: ["Gradle"],
+    ecosystems: ["JVM", "Android", "Java", "Kotlin", "Groovy"]
+  },
+  version: "9.5.0",
+  logo: "https://cdn.simpleicons.org/gradle/02303A",
+  i18n: {
+    en: {
+      name: "Gradle",
+      description: "A build automation DSL and tool used to define, configure, and run software builds.",
+      longDescription: "Gradle build scripts define projects, plugins, dependencies, repositories, tasks, test suites, publishing rules, and multi-project build logic using Groovy DSL or Kotlin DSL files.\n\nIt is widely used in Java, Kotlin, Android, JVM, and polyglot projects that need reproducible builds, dependency management, custom automation, and integration with CI/CD pipelines."
+    },
+    es: {
+      name: "Gradle",
+      description: "Un DSL y herramienta de automatizacion de builds usado para definir, configurar y ejecutar builds.",
+      longDescription: "Los scripts de build de Gradle definen proyectos, plugins, dependencias, repositorios, tareas, suites de prueba, reglas de publicacion y logica de builds multiproyecto usando archivos Groovy DSL o Kotlin DSL.\n\nSe usa ampliamente en proyectos Java, Kotlin, Android, JVM y poliglotas que necesitan builds reproducibles, gestion de dependencias, automatizacion personalizada e integracion con pipelines CI/CD."
+    }
+  }
+};
+
 // src/languages/graphql.ts
 var graphql = {
   slug: "graphql",
@@ -561,6 +733,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",
@@ -700,6 +901,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",
@@ -757,6 +987,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",
@@ -815,6 +1074,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",
@@ -844,6 +1132,35 @@ 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",
@@ -902,6 +1219,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",
@@ -1041,6 +1387,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",
@@ -1205,6 +1575,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",
@@ -1237,9 +1636,11 @@ var zsh = {
 // src/catalog.ts
 var languages = [
   abap,
+  asp,
   astro,
   assembly,
   bash,
+  batch,
   c,
   cmake,
   coffeescript,
@@ -1247,54 +1648,56 @@ var languages = [
   cpp,
   csharp,
   css,
+  cuda,
   dart,
   dockerfile,
+  fsharp,
+  git,
   go,
+  gradle,
   graphql,
   groovy,
   html,
   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(".")) {
@@ -1302,6 +1705,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;