code-languages 1.31.2 → 1.32.0

package/dist/detect.cjs

@@ -198,6 +198,65 @@ var agda = {
   }
 };
 
+// src/languages/algol.ts
+var algol = {
+  slug: "algol",
+  publishedDate: "1958-01-01",
+  extensions: [".alg", ".algol"],
+  author: "ACM-GAMM committee",
+  website: "https://en.wikipedia.org/wiki/ALGOL",
+  paradigms: ["imperative", "procedural", "structured"],
+  tooling: {
+    runtimes: ["ALGOL 60 compilers", "ALGOL 68 Genie"],
+    ecosystems: ["Academic Computing", "Language Design", "Numerical Computing"]
+  },
+  version: "ALGOL 68",
+  logo: "https://dummyimage.com/32x32/6B7280/ffffff.png&text=ALG",
+  color: "#6B7280",
+  i18n: {
+    en: {
+      name: "ALGOL",
+      description: "A family of early algorithmic languages that shaped block structure and formal language design.",
+      longDescription: "ALGOL introduced influential ideas for writing algorithms, including nested blocks, lexical scope, structured control flow, and a notation close to mathematical pseudocode.\n\nAlthough few modern systems use ALGOL directly, its design strongly influenced Pascal, C, Simula, Ada, and many later languages used in scientific and systems programming."
+    },
+    es: {
+      name: "ALGOL",
+      description: "Una familia temprana de lenguajes algoritmicos que influyo en bloques y diseno formal.",
+      longDescription: "ALGOL introdujo ideas influyentes para escribir algoritmos, como bloques anidados, alcance lexico, control estructurado y una notacion cercana al pseudocodigo matematico.\n\nAunque hoy se usa poco directamente, su diseno influyo en Pascal, C, Simula, Ada y muchos lenguajes posteriores."
+    }
+  }
+};
+
+// src/languages/ante.ts
+var ante = {
+  slug: "ante",
+  publishedDate: "2019-01-01",
+  extensions: [".ante"],
+  author: "Evan Haas",
+  website: "https://antelang.org",
+  paradigms: ["functional", "imperative", "systems"],
+  tooling: {
+    runtimes: ["Ante compiler"],
+    packageManagers: ["Ante package tooling"],
+    ecosystems: ["Systems Programming", "Research", "Compiler Development"]
+  },
+  version: "experimental",
+  logo: "https://dummyimage.com/32x32/4F46E5/ffffff.png&text=A",
+  color: "#4F46E5",
+  i18n: {
+    en: {
+      name: "Ante",
+      description: "A systems language exploring algebraic effects, type inference, and safe low-level programming.",
+      longDescription: "Ante is an experimental programming language focused on combining systems-level control with high-level type system features such as algebraic effects, traits, and strong inference.\n\nIt is mainly used for language design research, compiler experimentation, and exploring how effect systems can model IO, mutation, and error handling without losing performance goals."
+    },
+    es: {
+      name: "Ante",
+      description: "Un lenguaje de sistemas que explora efectos algebraicos, inferencia y seguridad.",
+      longDescription: "Ante es un lenguaje experimental que combina control de bajo nivel con rasgos de sistema de tipos como efectos algebraicos, traits e inferencia fuerte.\n\nSe usa sobre todo para investigacion de lenguajes, experimentos de compiladores y exploracion de sistemas de efectos para IO, mutacion y errores."
+    }
+  }
+};
+
 // src/languages/antlr.ts
 var antlr = {
   slug: "antlr",
@@ -646,6 +705,35 @@ var astro = {
   }
 };
 
+// src/languages/austral.ts
+var austral = {
+  slug: "austral",
+  publishedDate: "2021-01-01",
+  extensions: [".aum", ".aui"],
+  author: "Fernando Borretti",
+  website: "https://austral-lang.org",
+  paradigms: ["imperative", "systems", "procedural"],
+  tooling: {
+    runtimes: ["Austral compiler"],
+    ecosystems: ["Systems Programming", "Memory Safety", "Research"]
+  },
+  version: "0.1.0",
+  logo: "https://dummyimage.com/32x32/0F766E/ffffff.png&text=Au",
+  color: "#0F766E",
+  i18n: {
+    en: {
+      name: "Austral",
+      description: "A systems language built around linear types, capability safety, and explicit memory control.",
+      longDescription: "Austral is an experimental systems programming language that uses linear types to make ownership and resource handling explicit while keeping low-level control available to the programmer.\n\nIts design emphasizes capability safety, simple compilation targets, readable syntax, and research into practical ways to prevent resource misuse in native programs."
+    },
+    es: {
+      name: "Austral",
+      description: "Un lenguaje de sistemas basado en tipos lineales, capacidades y memoria explicita.",
+      longDescription: "Austral es un lenguaje experimental de sistemas que usa tipos lineales para hacer explicito el manejo de propiedad y recursos sin perder control de bajo nivel.\n\nSu diseno enfatiza seguridad por capacidades, objetivos de compilacion simples y formas practicas de evitar mal uso de recursos."
+    }
+  }
+};
+
 // src/languages/autohotkey.ts
 var autohotkey = {
   slug: "autohotkey",
@@ -944,6 +1032,35 @@ var bazel = {
   }
 };
 
+// src/languages/bcpl.ts
+var bcpl = {
+  slug: "bcpl",
+  publishedDate: "1967-01-01",
+  extensions: [".bcpl"],
+  author: "Martin Richards",
+  website: "https://www.cl.cam.ac.uk/~mr10/BCPL.html",
+  paradigms: ["imperative", "procedural", "systems"],
+  tooling: {
+    runtimes: ["Cintsys BCPL", "Classic BCPL compilers"],
+    ecosystems: ["Systems Programming", "Operating Systems", "Language History"]
+  },
+  version: "Cintsys BCPL",
+  logo: "https://dummyimage.com/32x32/374151/ffffff.png&text=BC",
+  color: "#374151",
+  i18n: {
+    en: {
+      name: "BCPL",
+      description: "A compact systems language that influenced B and C through typeless procedural programming.",
+      longDescription: "BCPL was designed as a small, portable systems language with a simple compiler and a typeless model suited to early operating systems and compiler work.\n\nIts syntax, block structure, braces, comments, and procedural style influenced B and C, making it an important ancestor of modern systems programming languages."
+    },
+    es: {
+      name: "BCPL",
+      description: "Un lenguaje compacto de sistemas que influyo en B y C con programacion procedural.",
+      longDescription: "BCPL fue disenado como un lenguaje de sistemas pequeno y portable, con compilador simple y modelo sin tipos para sistemas operativos tempranos.\n\nSu sintaxis, bloques, llaves, comentarios y estilo procedural influyeron en B y C."
+    }
+  }
+};
+
 // src/languages/bicep.ts
 var bicep = {
   slug: "bicep",
@@ -1044,6 +1161,64 @@ var blade = {
   }
 };
 
+// src/languages/bosque.ts
+var bosque = {
+  slug: "bosque",
+  publishedDate: "2019-04-15",
+  extensions: [".bsq"],
+  author: "Microsoft Research",
+  website: "https://github.com/microsoft/BosqueLanguage",
+  paradigms: ["functional", "imperative", "object-oriented"],
+  tooling: {
+    runtimes: ["Bosque reference runtime"],
+    ecosystems: ["Research", "Verification", "Application Logic"]
+  },
+  version: "experimental",
+  logo: "https://dummyimage.com/32x32/0078D4/ffffff.png&text=B",
+  color: "#0078D4",
+  i18n: {
+    en: {
+      name: "Bosque",
+      description: "A Microsoft Research language exploring regularized programming and predictable semantics.",
+      longDescription: "Bosque is a research programming language from Microsoft Research that explores regularized programming, aiming to reduce incidental complexity in control flow, mutation, and object identity.\n\nIt combines ideas from functional and object-oriented programming with immutable values, algebraic data, structured collections, and semantics meant to support tooling and automated reasoning."
+    },
+    es: {
+      name: "Bosque",
+      description: "Un lenguaje de Microsoft Research sobre programacion regularizada y semantica predecible.",
+      longDescription: "Bosque es un lenguaje de investigacion de Microsoft Research que explora programacion regularizada para reducir complejidad accidental en control, mutacion e identidad.\n\nCombina ideas funcionales y orientadas a objetos con valores inmutables, datos algebraicos y semantica pensada para herramientas."
+    }
+  }
+};
+
+// src/languages/bqn.ts
+var bqn = {
+  slug: "bqn",
+  publishedDate: "2020-01-01",
+  extensions: [".bqn"],
+  author: "Marshall Lochbaum",
+  website: "https://mlochbaum.github.io/BQN/",
+  paradigms: ["array", "functional", "tacit"],
+  tooling: {
+    runtimes: ["CBQN", "BQN.js"],
+    ecosystems: ["Array Programming", "Data Transformation", "Recreational Computing"]
+  },
+  version: "BQN specification",
+  logo: "https://dummyimage.com/32x32/7C3AED/ffffff.png&text=BQN",
+  color: "#7C3AED",
+  i18n: {
+    en: {
+      name: "BQN",
+      description: "An array programming language in the APL family with modern notation and tacit features.",
+      longDescription: "BQN is an array-oriented language influenced by APL, J, and K. It uses concise symbols to express operations over arrays, functions, modifiers, and trains.\n\nIt is used for compact data manipulation, algorithm exploration, teaching array thinking, and experiments with high-level notation backed by interpreters such as CBQN and BQN.js."
+    },
+    es: {
+      name: "BQN",
+      description: "Un lenguaje de programacion de arreglos de la familia APL con notacion moderna.",
+      longDescription: "BQN es un lenguaje orientado a arreglos influido por APL, J y K. Usa simbolos concisos para expresar operaciones sobre arreglos, funciones y modificadores.\n\nSe usa para manipulacion compacta de datos, exploracion de algoritmos y ensenanza de pensamiento basado en arreglos."
+    }
+  }
+};
+
 // src/languages/c.ts
 var c = {
   slug: "c",
@@ -1887,6 +2062,36 @@ var cue = {
   }
 };
 
+// src/languages/curry.ts
+var curry = {
+  slug: "curry",
+  publishedDate: "1997-01-01",
+  extensions: [".curry", ".lcurry"],
+  author: "Curry language community",
+  website: "https://www.curry-language.org",
+  paradigms: ["functional", "logic", "declarative"],
+  tooling: {
+    runtimes: ["KiCS2", "PAKCS"],
+    packageManagers: ["Curry Package Manager"],
+    ecosystems: ["Functional Logic Programming", "Constraint Solving", "Research"]
+  },
+  version: "Curry 0.9.0",
+  logo: "https://dummyimage.com/32x32/BE123C/ffffff.png&text=Cu",
+  color: "#BE123C",
+  i18n: {
+    en: {
+      name: "Curry",
+      description: "A functional logic language that combines Haskell-style functions with logic variables.",
+      longDescription: "Curry combines functional programming with logic programming, enabling lazy evaluation, higher-order functions, logic variables, non-determinism, and constraint-based computation in one language.\n\nIt is used in academic research, teaching declarative programming, symbolic computation, program analysis, and systems that benefit from mixing functional abstraction with logic search."
+    },
+    es: {
+      name: "Curry",
+      description: "Un lenguaje funcional-logico que combina funciones estilo Haskell con variables logicas.",
+      longDescription: "Curry combina programacion funcional y logica con evaluacion perezosa, funciones de orden superior, variables logicas, no determinismo y restricciones.\n\nSe usa en investigacion, docencia de programacion declarativa, computacion simbolica y analisis de programas."
+    }
+  }
+};
+
 // src/languages/cypher.ts
 var cypher = {
   slug: "cypher",
@@ -2595,6 +2800,36 @@ var erlang = {
   }
 };
 
+// src/languages/factor.ts
+var factor = {
+  slug: "factor",
+  publishedDate: "2003-01-01",
+  extensions: [".factor"],
+  author: "Slava Pestov",
+  website: "https://factorcode.org",
+  paradigms: ["concatenative", "functional", "stack-based"],
+  tooling: {
+    runtimes: ["Factor VM"],
+    packageManagers: ["Factor vocabularies"],
+    ecosystems: ["Interactive Development", "Language Research", "Desktop Tools"]
+  },
+  version: "0.101",
+  logo: "https://dummyimage.com/32x32/F97316/ffffff.png&text=F",
+  color: "#F97316",
+  i18n: {
+    en: {
+      name: "Factor",
+      description: "A concatenative, stack-based language with an interactive image and rich standard library.",
+      longDescription: "Factor is a concatenative programming language where programs are composed by chaining words that transform a data stack. It includes an optimizing compiler, interactive environment, and image-based workflow.\n\nIts ecosystem includes libraries called vocabularies for UI, parsing, networking, math, databases, and tooling, making it useful for language experimentation and interactive development."
+    },
+    es: {
+      name: "Factor",
+      description: "Un lenguaje concatenativo basado en pila con imagen interactiva y biblioteca amplia.",
+      longDescription: "Factor es un lenguaje concatenativo donde los programas encadenan palabras que transforman una pila de datos. Incluye compilador optimizador y entorno interactivo.\n\nSu ecosistema usa vocabularios para UI, parsing, redes, matematicas, bases de datos y herramientas."
+    }
+  }
+};
+
 // src/languages/fennel.ts
 var fennel = {
   slug: "fennel",
@@ -4043,6 +4278,35 @@ var ini = {
   }
 };
 
+// src/languages/io.ts
+var io = {
+  slug: "io",
+  publishedDate: "2002-03-07",
+  extensions: [".io"],
+  author: "Steve Dekorte",
+  website: "https://iolanguage.org",
+  paradigms: ["prototype-based", "object-oriented", "dynamic"],
+  tooling: {
+    runtimes: ["Io VM"],
+    ecosystems: ["Scripting", "Prototype Programming", "Language Exploration"]
+  },
+  version: "2017.09.06",
+  logo: "https://dummyimage.com/32x32/2563EB/ffffff.png&text=Io",
+  color: "#2563EB",
+  i18n: {
+    en: {
+      name: "Io",
+      description: "A small prototype-based language focused on message passing and minimal syntax.",
+      longDescription: "Io is a dynamic prototype-based language inspired by Smalltalk, Self, Lisp, and Lua. Its object model is based on cloning prototypes and sending messages rather than class declarations.\n\nThe language has a compact syntax, coroutines, actors, reflection, and an embeddable runtime, making it a useful reference point for prototype programming and language design."
+    },
+    es: {
+      name: "Io",
+      description: "Un lenguaje pequeno basado en prototipos, paso de mensajes y sintaxis minima.",
+      longDescription: "Io es un lenguaje dinamico basado en prototipos e inspirado por Smalltalk, Self, Lisp y Lua. Su modelo usa clonacion y envio de mensajes, no clases.\n\nIncluye sintaxis compacta, corrutinas, actores, reflexion y runtime embebible."
+    }
+  }
+};
+
 // src/languages/isabelle.ts
 var isabelle = {
   slug: "isabelle",
@@ -4655,6 +4919,36 @@ var kdl = {
   }
 };
 
+// src/languages/koka.ts
+var koka = {
+  slug: "koka",
+  publishedDate: "2012-01-01",
+  extensions: [".kk"],
+  author: "Daan Leijen",
+  website: "https://koka-lang.github.io",
+  paradigms: ["functional", "effect-oriented", "strongly typed"],
+  tooling: {
+    runtimes: ["Koka compiler"],
+    packageManagers: ["Koka package tooling"],
+    ecosystems: ["Effect Systems", "Functional Programming", "Research"]
+  },
+  version: "3.2.2",
+  logo: "https://dummyimage.com/32x32/0891B2/ffffff.png&text=K",
+  color: "#0891B2",
+  i18n: {
+    en: {
+      name: "Koka",
+      description: "A functional language with effect types for tracking side effects and resource use.",
+      longDescription: "Koka is a strongly typed functional language centered on algebraic effect types. Functions describe the effects they may perform, which helps model exceptions, state, IO, and control flow.\n\nIt is used for research and practical experiments in effect systems, with a compiler that targets native and JavaScript environments while keeping memory management predictable."
+    },
+    es: {
+      name: "Koka",
+      description: "Un lenguaje funcional con tipos de efectos para rastrear efectos laterales y recursos.",
+      longDescription: "Koka es un lenguaje funcional de tipado fuerte centrado en tipos de efectos algebraicos. Las funciones describen los efectos que pueden realizar.\n\nSe usa para investigacion y experimentos practicos en sistemas de efectos, con compilacion a entornos nativos y JavaScript."
+    }
+  }
+};
+
 // src/languages/kotlin.ts
 var kotlin = {
   slug: "kotlin",
@@ -9927,6 +10221,8 @@ var languages = [
   actionscript,
   ada,
   agda,
+  algol,
+  ante,
   antlr,
   apex,
   apl,
@@ -9934,34 +10230,39 @@ var languages = [
   arduino,
   asciidoc,
   asp,
-  astro,
   assembly,
-  awk,
+  astro,
+  austral,
   autohotkey,
+  awk,
   ballerina,
   bash,
   batch,
   bazel,
+  bcpl,
   bicep,
   blade,
+  bosque,
+  bqn,
   c,
   cairo,
   carbon,
   chapel,
   circom,
-  cmake,
   clojure,
+  cmake,
+  cobol,
   coffeescript,
   coldfusion,
-  cobol,
   coq,
   cpp,
-  cypher,
-  csharp,
   crystal,
+  csharp,
   css,
-  cue,
   cuda,
+  cue,
+  curry,
+  cypher,
   cython,
   d,
   dafny,
@@ -9969,57 +10270,60 @@ var languages = [
   dhall,
   dita,
   dockerfile,
-  ejs,
-  eiffel,
   earthly,
+  eiffel,
+  ejs,
   elixir,
   elm,
   erb,
   erlang,
-  fish,
+  factor,
   fennel,
+  fish,
   flux,
-  freemarker,
-  fortran,
   forth,
+  fortran,
+  freemarker,
   fsharp,
   fstar,
   gdscript,
   git,
   gleam,
+  glsl,
   go,
-  grain,
   gradle,
-  glsl,
+  grain,
   graphql,
   groovy,
-  handlebars,
   hack,
   haml,
+  handlebars,
   hare,
-  hocon,
   haskell,
   haxe,
   hcl,
   hlsl,
+  hocon,
   html,
   hy,
   idris,
   ini,
+  io,
   isabelle,
+  janet,
   java,
   javascript,
-  janet,
   jinja,
   json,
   json5,
   jsonc,
   jsonnet,
-  jupyterNotebook,
   julia,
+  jupyterNotebook,
   just,
   kcl,
   kdl,
+  koka,
   kotlin,
   lean,
   less,
@@ -10028,36 +10332,35 @@ var languages = [
   llvmIr,
   lua,
   luau,
-  mako,
   makefile,
+  mako,
+  markdown,
   mathematica,
   matlab,
-  markdown,
   mdx,
   mermaid,
   meson,
   metal,
-  mustache,
-  move,
   mojo,
   moonbit,
-  svn,
+  move,
+  mustache,
   nginx,
   nickel,
-  nunjucks,
-  nushell,
   nim,
   nix,
-  ocaml,
+  nunjucks,
+  nushell,
   objectiveC,
+  ocaml,
   odin,
-  opencl,
   openapi,
+  opencl,
   pascal,
-  pkl,
   perl,
   php,
   pineScript,
+  pkl,
   plantuml,
   plsql,
   pony,
@@ -10072,8 +10375,8 @@ var languages = [
   qml,
   qsharp,
   r,
-  raku,
   racket,
+  raku,
   razor,
   reasonml,
   rego,
@@ -10083,8 +10386,8 @@ var languages = [
   rust,
   sas,
   scala,
-  scss,
   scheme,
+  scss,
   smalltalk,
   smarty,
   solidity,
@@ -10094,8 +10397,9 @@ var languages = [
   starlark,
   stata,
   stylus,
-  svg,
   svelte,
+  svg,
+  svn,
   swift,
   tcl,
   tex,
@@ -10144,9 +10448,13 @@ var detectMatchingEntries = (entries, filename) => {
   if (!basename) {
     return [];
   }
-  return entries.filter(
-    (entry) => entry.extensions.some((extension) => matchesExtension(basename, extension))
-  );
+  return entries.map((entry, index) => ({
+    entry,
+    index,
+    matchLength: Math.max(
+      ...entry.extensions.filter((extension) => matchesExtension(basename, extension)).map((extension) => extension.length)
+    )
+  })).filter(({ matchLength }) => Number.isFinite(matchLength)).sort((first, second) => second.matchLength - first.matchLength || first.index - second.index).map(({ entry }) => entry);
 };
 
 // src/detect.ts