code-languages 1.40.11 → 1.41.0

package/dist/detect.js

@@ -1,3 +1,127 @@
+// src/domain/detection/match.ts
+var pathSegmentPattern = /[/\\]/;
+var indexCache = /* @__PURE__ */ new WeakMap();
+var getBasename = (filename) => {
+  const parts = filename.trim().split(pathSegmentPattern);
+  return parts.at(-1).toLowerCase();
+};
+var addIndexKey = (index, key, match) => {
+  const matches = index.get(key);
+  if (matches) {
+    matches.push(match);
+  } else {
+    index.set(key, [match]);
+  }
+};
+var buildDetectionIndex = (entries) => {
+  const index = /* @__PURE__ */ new Map();
+  entries.forEach((entry, entryIndex) => {
+    for (const extension of entry.extensions) {
+      const normalizedExtension = extension.toLowerCase();
+      const match = { entry, index: entryIndex, matchLength: extension.length };
+      if (normalizedExtension.startsWith(".")) {
+        addIndexKey(index, normalizedExtension, match);
+      } else {
+        addIndexKey(index, normalizedExtension, match);
+        addIndexKey(index, `.${normalizedExtension}`, match);
+      }
+    }
+  });
+  return index;
+};
+var getDetectionIndex = (entries) => {
+  let index = indexCache.get(entries);
+  if (!index) {
+    index = buildDetectionIndex(entries);
+    indexCache.set(entries, index);
+  }
+  return index;
+};
+var getLookupKeys = (basename) => {
+  const keys = [basename];
+  for (let position = basename.indexOf("."); position !== -1; position = basename.indexOf(".", position + 1)) {
+    const suffix = basename.slice(position);
+    if (suffix !== basename) {
+      keys.push(suffix);
+    }
+  }
+  return keys;
+};
+var detectMatchingEntries = (entries, filename) => {
+  const basename = getBasename(filename);
+  if (!basename) {
+    return [];
+  }
+  const index = getDetectionIndex(entries);
+  const bestMatches = /* @__PURE__ */ new Map();
+  for (const key of getLookupKeys(basename)) {
+    for (const match of index.get(key) ?? []) {
+      const existing = bestMatches.get(match.index);
+      if (!existing || match.matchLength > existing.matchLength) {
+        bestMatches.set(match.index, match);
+      }
+    }
+  }
+  return [...bestMatches.values()].sort((first, second) => second.matchLength - first.matchLength || first.index - second.index).map(({ entry }) => entry);
+};
+
+// src/domain/detection/shebang.ts
+var SHEBANG_INTERPRETERS = {
+  awk: "awk",
+  bash: "bash",
+  bun: "javascript",
+  crystal: "crystal",
+  csh: "tcsh",
+  dash: "bash",
+  deno: "typescript",
+  elixir: "elixir",
+  escript: "erlang",
+  expect: "tcl",
+  fish: "fish",
+  gawk: "awk",
+  groovy: "groovy",
+  guile: "scheme",
+  janet: "janet",
+  julia: "julia",
+  ksh: "bash",
+  lua: "lua",
+  mawk: "awk",
+  nawk: "awk",
+  node: "javascript",
+  nodejs: "javascript",
+  nu: "nushell",
+  osascript: "applescript",
+  perl: "perl",
+  php: "php",
+  pwsh: "powershell",
+  python: "python",
+  racket: "racket",
+  raku: "raku",
+  rscript: "r",
+  ruby: "ruby",
+  scala: "scala",
+  sh: "bash",
+  tclsh: "tcl",
+  tcsh: "tcsh",
+  wish: "tcl",
+  zsh: "zsh"
+};
+var trailingVersionPattern = /[-.]?\d[\d.]*$/;
+var lookupInterpreter = (interpreter) => SHEBANG_INTERPRETERS[interpreter] ?? SHEBANG_INTERPRETERS[interpreter.replace(trailingVersionPattern, "")];
+var detectLanguageSlugByShebang = (content) => {
+  if (!content.startsWith("#!")) {
+    return void 0;
+  }
+  const newlineIndex = content.search(/\r?\n/);
+  const firstLine = newlineIndex === -1 ? content : content.slice(0, newlineIndex);
+  const parts = firstLine.slice(2).trim().split(/\s+/);
+  let interpreter = parts[0]?.split("/").at(-1)?.toLowerCase();
+  if (interpreter === "env") {
+    interpreter = parts.slice(1).find((argument) => !argument.startsWith("-"))?.split("/").at(-1)?.toLowerCase();
+  }
+  return interpreter ? lookupInterpreter(interpreter) : void 0;
+};
+
 // src/languages/abap.ts
 var abap = {
   slug: "abap",
@@ -50,6 +174,7 @@ var abap = {
 // src/languages/actionscript.ts
 var actionscript = {
   slug: "actionscript",
+  status: "legacy",
   publishedDate: "1998-01-01",
   extensions: [".as"],
   author: "Gary Grossman / Macromedia",
@@ -199,6 +324,7 @@ var agda = {
 // src/languages/algol.ts
 var algol = {
   slug: "algol",
+  status: "historical",
   publishedDate: "1958-01-01",
   extensions: [".alg", ".algol"],
   author: "ACM-GAMM committee",
@@ -346,6 +472,7 @@ var angelscript = {
 // src/languages/ante.ts
 var ante = {
   slug: "ante",
+  status: "experimental",
   publishedDate: "2019-01-01",
   extensions: [".ante"],
   author: "Evan Haas",
@@ -793,6 +920,7 @@ var asp = {
 // src/languages/assembly.ts
 var assembly = {
   slug: "assembly",
+  aliases: ["asm"],
   publishedDate: "1949-01-01",
   extensions: [".asm", ".s", ".S", ".inc"],
   author: "Machine architecture vendors and assembler implementers",
@@ -942,6 +1070,7 @@ var astro = {
 // src/languages/austral.ts
 var austral = {
   slug: "austral",
+  status: "experimental",
   publishedDate: "2021-01-01",
   extensions: [".aum", ".aui"],
   author: "Fernando Borretti",
@@ -952,7 +1081,7 @@ var austral = {
     ecosystems: ["Systems Programming", "Memory Safety", "Research"]
   },
   version: "0.1.0",
-  logo: "https://dummyimage.com/32x32/0F766E/ffffff.png&text=Au",
+  logo: "https://avatars.githubusercontent.com/u/17337956?v=4",
   color: "#0F766E",
   i18n: {
     en: {
@@ -1383,6 +1512,7 @@ var bazel = {
 // src/languages/bcpl.ts
 var bcpl = {
   slug: "bcpl",
+  status: "historical",
   publishedDate: "1967-01-01",
   extensions: [".bcpl"],
   author: "Martin Richards",
@@ -1442,7 +1572,7 @@ var bibtex = {
     ecosystems: ["TeX", "LaTeX", "Academic publishing"]
   },
   version: "stable",
-  logo: "https://dummyimage.com/32x32/2563EB/ffffff.png&text=Bi",
+  logo: "https://upload.wikimedia.org/wikipedia/commons/9/92/LaTeX_logo.svg",
   color: "#2563EB",
   i18n: {
     en: {
@@ -1581,6 +1711,7 @@ var blade = {
 // src/languages/bosque.ts
 var bosque = {
   slug: "bosque",
+  status: "experimental",
   publishedDate: "2019-04-15",
   extensions: [".bsq"],
   author: "Microsoft Research",
@@ -1877,6 +2008,7 @@ var capnproto = {
 // src/languages/carbon.ts
 var carbon = {
   slug: "carbon",
+  status: "experimental",
   publishedDate: "2022-07-19",
   extensions: [".carbon"],
   author: "Carbon Language Project",
@@ -2324,6 +2456,7 @@ var coldfusion = {
 // src/languages/coq.ts
 var coq = {
   slug: "coq",
+  aliases: ["rocq"],
   publishedDate: "1989-01-01",
   extensions: [".v"],
   author: "INRIA / Rocq Prover Development Team",
@@ -2374,6 +2507,7 @@ var coq = {
 // src/languages/cpp.ts
 var cpp = {
   slug: "cpp",
+  aliases: ["c++", "cplusplus"],
   publishedDate: "1985-10-01",
   extensions: [".cpp", ".cc", ".cxx", ".h", ".hpp", ".hh", ".hxx"],
   author: "Bjarne Stroustrup",
@@ -2523,6 +2657,7 @@ var crystal = {
 // src/languages/csharp.ts
 var csharp = {
   slug: "csharp",
+  aliases: ["c#", "cs"],
   publishedDate: "2000-06-26",
   extensions: [".cs", ".csx"],
   author: "Anders Hejlsberg / Microsoft",
@@ -3031,7 +3166,7 @@ var dax = {
     ]
   },
   version: "DAX 2025",
-  logo: "https://dummyimage.com/32x32/F2C811/000000.png&text=DAX",
+  logo: "https://upload.wikimedia.org/wikipedia/commons/c/cf/New_Power_BI_Logo.svg",
   color: "#F2C811",
   i18n: {
     en: {
@@ -3170,6 +3305,7 @@ var dita = {
 // src/languages/dockerfile.ts
 var dockerfile = {
   slug: "dockerfile",
+  aliases: ["docker"],
   publishedDate: "2013-03-20",
   extensions: ["Dockerfile", ".dockerfile"],
   author: "Docker, Inc.",
@@ -3563,6 +3699,57 @@ var elm = {
   }
 };
 
+// src/languages/emacs-lisp.ts
+var emacsLisp = {
+  slug: "emacs-lisp",
+  aliases: ["elisp"],
+  publishedDate: "1985-03-20",
+  extensions: [".el"],
+  author: "Richard Stallman / GNU Project",
+  website: "https://www.gnu.org/software/emacs/manual/elisp.html",
+  paradigms: ["functional", "imperative", "meta-programming", "scripting"],
+  tooling: {
+    runtimes: ["GNU Emacs"],
+    packageManagers: ["package.el", "ELPA", "MELPA"],
+    ecosystems: ["Text Editors", "Scripting"]
+  },
+  version: "Emacs 30.1",
+  logo: "https://cdn.simpleicons.org/gnuemacs/7F5AB6",
+  color: "#7F5AB6",
+  i18n: {
+    en: {
+      name: "Emacs Lisp",
+      description: "The Lisp dialect used to implement and extend the GNU Emacs editor.",
+      longDescription: "Emacs Lisp is a dialect of Lisp that powers most of the GNU Emacs editor. Beyond configuration, it is a complete programming language with dynamic and lexical binding, macros, and an interactive development workflow built into the editor itself.\n\nThousands of packages distributed through ELPA and MELPA are written in Emacs Lisp, covering everything from mail clients and file managers to language servers and note-taking systems such as Org mode."
+    },
+    es: {
+      name: "Emacs Lisp",
+      description: "El dialecto de Lisp usado para implementar y extender el editor GNU Emacs.",
+      longDescription: "Emacs Lisp es un dialecto de Lisp que impulsa la mayor parte del editor GNU Emacs. M\xE1s all\xE1 de la configuraci\xF3n, es un lenguaje de programaci\xF3n completo con enlace din\xE1mico y l\xE9xico, macros y un flujo de desarrollo interactivo integrado en el propio editor.\n\nMiles de paquetes distribuidos a trav\xE9s de ELPA y MELPA est\xE1n escritos en Emacs Lisp, cubriendo desde clientes de correo y gestores de archivos hasta servidores de lenguaje y sistemas de notas como Org mode."
+    },
+    it: {
+      name: "Emacs Lisp",
+      description: "Il dialetto Lisp usato per implementare ed estendere l'editor GNU Emacs.",
+      longDescription: "Emacs Lisp \xE8 un dialetto di Lisp che alimenta la maggior parte dell'editor GNU Emacs. Oltre alla configurazione, \xE8 un linguaggio di programmazione completo con binding dinamico e lessicale, macro e un flusso di sviluppo interattivo integrato nell'editor stesso.\n\nMigliaia di pacchetti distribuiti tramite ELPA e MELPA sono scritti in Emacs Lisp, coprendo di tutto: client di posta, gestori di file, language server e sistemi di appunti come Org mode."
+    },
+    fr: {
+      name: "Emacs Lisp",
+      description: "Le dialecte Lisp utilis\xE9 pour impl\xE9menter et \xE9tendre l'\xE9diteur GNU Emacs.",
+      longDescription: "Emacs Lisp est un dialecte de Lisp qui fait fonctionner la majeure partie de l'\xE9diteur GNU Emacs. Au-del\xE0 de la configuration, c'est un langage de programmation complet avec liaison dynamique et lexicale, macros et un flux de d\xE9veloppement interactif int\xE9gr\xE9 \xE0 l'\xE9diteur lui-m\xEAme.\n\nDes milliers de paquets distribu\xE9s via ELPA et MELPA sont \xE9crits en Emacs Lisp, couvrant aussi bien des clients de messagerie et des gestionnaires de fichiers que des serveurs de langage et des syst\xE8mes de prise de notes comme Org mode."
+    },
+    de: {
+      name: "Emacs Lisp",
+      description: "Der Lisp-Dialekt, mit dem der GNU-Emacs-Editor implementiert und erweitert wird.",
+      longDescription: "Emacs Lisp ist ein Lisp-Dialekt, der den gr\xF6\xDFten Teil des GNU-Emacs-Editors antreibt. \xDCber die Konfiguration hinaus ist es eine vollst\xE4ndige Programmiersprache mit dynamischer und lexikalischer Bindung, Makros und einem interaktiven Entwicklungsworkflow direkt im Editor.\n\nTausende \xFCber ELPA und MELPA verteilte Pakete sind in Emacs Lisp geschrieben und decken alles ab: von Mail-Clients und Dateimanagern bis zu Language-Servern und Notizsystemen wie Org mode."
+    },
+    pt: {
+      name: "Emacs Lisp",
+      description: "O dialeto de Lisp usado para implementar e estender o editor GNU Emacs.",
+      longDescription: "Emacs Lisp \xE9 um dialeto de Lisp que move a maior parte do editor GNU Emacs. Al\xE9m da configura\xE7\xE3o, \xE9 uma linguagem de programa\xE7\xE3o completa com liga\xE7\xE3o din\xE2mica e l\xE9xica, macros e um fluxo de desenvolvimento interativo integrado ao pr\xF3prio editor.\n\nMilhares de pacotes distribu\xEDdos via ELPA e MELPA s\xE3o escritos em Emacs Lisp, cobrindo de clientes de e-mail e gerenciadores de arquivos a servidores de linguagem e sistemas de notas como o Org mode."
+    }
+  }
+};
+
 // src/languages/erb.ts
 var erb = {
   slug: "erb",
@@ -3716,6 +3903,7 @@ var factor = {
 // src/languages/fe.ts
 var fe = {
   slug: "fe",
+  status: "experimental",
   publishedDate: "2020-10-08",
   extensions: [".fe"],
   author: "Ethereum Foundation contributors",
@@ -4161,6 +4349,7 @@ var freemarker = {
 // src/languages/fsharp.ts
 var fsharp = {
   slug: "fsharp",
+  aliases: ["f#"],
   publishedDate: "2005-05-01",
   extensions: [".fs", ".fsi", ".fsx", ".fsscript"],
   author: "Don Syme / Microsoft Research",
@@ -4271,7 +4460,7 @@ var gcode = {
     ecosystems: ["CNC machining", "Additive manufacturing"]
   },
   version: "RS-274",
-  logo: "https://dummyimage.com/32x32/DC2626/ffffff.png&text=G",
+  logo: "https://raw.githubusercontent.com/vscode-icons/vscode-icons/master/icons/file_type_gcode.svg",
   color: "#DC2626",
   i18n: {
     en: {
@@ -4370,7 +4559,7 @@ var gettext = {
     ecosystems: ["Internationalization", "Localization"]
   },
   version: "stable",
-  logo: "https://dummyimage.com/32x32/7C3AED/ffffff.png&text=PO",
+  logo: "https://cdn.simpleicons.org/gnu/A42E2B",
   color: "#7C3AED",
   i18n: {
     en: {
@@ -4607,6 +4796,7 @@ var gml = {
 // src/languages/go.ts
 var go = {
   slug: "go",
+  aliases: ["golang"],
   publishedDate: "2012-03-28",
   extensions: [".go"],
   author: "Robert Griesemer, Rob Pike, Ken Thompson / Google",
@@ -5656,7 +5846,7 @@ var io = {
     ecosystems: ["Scripting", "Prototype Programming", "Language Exploration"]
   },
   version: "2017.09.06",
-  logo: "https://dummyimage.com/32x32/2563EB/ffffff.png&text=Io",
+  logo: "https://raw.githubusercontent.com/vscode-icons/vscode-icons/master/icons/file_type_io.svg",
   color: "#2563EB",
   i18n: {
     en: {
@@ -5844,6 +6034,7 @@ var java = {
 // src/languages/javascript.ts
 var javascript = {
   slug: "javascript",
+  aliases: ["js", "ecmascript"],
   publishedDate: "1995-12-04",
   extensions: [".js", ".mjs", ".cjs", ".jsx"],
   author: "Brendan Eich / Netscape",
@@ -5891,6 +6082,55 @@ var javascript = {
   }
 };
 
+// src/languages/jcl.ts
+var jcl = {
+  slug: "jcl",
+  publishedDate: "1964-04-07",
+  extensions: [".jcl"],
+  author: "IBM",
+  website: "https://www.ibm.com/docs/en/zos/3.1.0?topic=zos-mvs-jcl-reference",
+  paradigms: ["declarative", "batch"],
+  tooling: {
+    runtimes: ["z/OS", "MVS", "JES2", "JES3"],
+    ecosystems: ["Mainframe", "Batch Processing"]
+  },
+  version: "z/OS 3.1",
+  logo: "https://upload.wikimedia.org/wikipedia/commons/5/51/IBM_logo.svg",
+  color: "#1F70C1",
+  i18n: {
+    en: {
+      name: "JCL",
+      description: "IBM Job Control Language for describing batch jobs on z/OS mainframes.",
+      longDescription: "JCL (Job Control Language) tells IBM mainframe operating systems how to run batch work: which programs to execute, in what order, with which datasets, and how to react to failures. JOB, EXEC, and DD statements describe jobs, steps, and data allocations processed by the JES2/JES3 subsystems.\n\nIntroduced with System/360 in 1964, JCL still orchestrates nightly batch processing in banking, insurance, and government workloads on z/OS, usually alongside COBOL, PL/I, and REXX."
+    },
+    es: {
+      name: "JCL",
+      description: "El Job Control Language de IBM para describir trabajos batch en mainframes z/OS.",
+      longDescription: "JCL (Job Control Language) indica a los sistemas operativos de mainframe de IBM c\xF3mo ejecutar trabajo batch: qu\xE9 programas ejecutar, en qu\xE9 orden, con qu\xE9 datasets y c\xF3mo reaccionar ante fallos. Las sentencias JOB, EXEC y DD describen trabajos, pasos y asignaciones de datos procesados por los subsistemas JES2/JES3.\n\nIntroducido con el System/360 en 1964, JCL sigue orquestando el procesamiento batch nocturno en cargas bancarias, de seguros y gubernamentales sobre z/OS, normalmente junto a COBOL, PL/I y REXX."
+    },
+    it: {
+      name: "JCL",
+      description: "Il Job Control Language di IBM per descrivere job batch sui mainframe z/OS.",
+      longDescription: "JCL (Job Control Language) indica ai sistemi operativi mainframe di IBM come eseguire il lavoro batch: quali programmi eseguire, in quale ordine, con quali dataset e come reagire ai fallimenti. Le istruzioni JOB, EXEC e DD descrivono job, step e allocazioni di dati elaborati dai sottosistemi JES2/JES3.\n\nIntrodotto con il System/360 nel 1964, JCL orchestra ancora l'elaborazione batch notturna nei carichi bancari, assicurativi e governativi su z/OS, di solito insieme a COBOL, PL/I e REXX."
+    },
+    fr: {
+      name: "JCL",
+      description: "Le Job Control Language d'IBM pour d\xE9crire les travaux batch sur mainframes z/OS.",
+      longDescription: "JCL (Job Control Language) indique aux syst\xE8mes d'exploitation mainframe d'IBM comment ex\xE9cuter le travail batch : quels programmes lancer, dans quel ordre, avec quels datasets et comment r\xE9agir aux \xE9checs. Les instructions JOB, EXEC et DD d\xE9crivent les travaux, les \xE9tapes et les allocations de donn\xE9es trait\xE9s par les sous-syst\xE8mes JES2/JES3.\n\nIntroduit avec le System/360 en 1964, JCL orchestre encore le traitement batch nocturne des charges bancaires, d'assurance et gouvernementales sous z/OS, g\xE9n\xE9ralement aux c\xF4t\xE9s de COBOL, PL/I et REXX."
+    },
+    de: {
+      name: "JCL",
+      description: "IBMs Job Control Language zur Beschreibung von Batch-Jobs auf z/OS-Mainframes.",
+      longDescription: "JCL (Job Control Language) sagt IBM-Mainframe-Betriebssystemen, wie Batch-Arbeit auszuf\xFChren ist: welche Programme in welcher Reihenfolge laufen, mit welchen Datasets und wie auf Fehler zu reagieren ist. JOB-, EXEC- und DD-Anweisungen beschreiben Jobs, Schritte und Datenzuweisungen, die von den JES2/JES3-Subsystemen verarbeitet werden.\n\nMit dem System/360 im Jahr 1964 eingef\xFChrt, orchestriert JCL noch heute die n\xE4chtliche Batch-Verarbeitung in Bank-, Versicherungs- und Beh\xF6rden-Workloads auf z/OS, \xFCblicherweise neben COBOL, PL/I und REXX."
+    },
+    pt: {
+      name: "JCL",
+      description: "A Job Control Language da IBM para descrever jobs batch em mainframes z/OS.",
+      longDescription: "JCL (Job Control Language) diz aos sistemas operacionais de mainframe da IBM como executar trabalho batch: quais programas executar, em que ordem, com quais datasets e como reagir a falhas. As instru\xE7\xF5es JOB, EXEC e DD descrevem jobs, passos e aloca\xE7\xF5es de dados processados pelos subsistemas JES2/JES3.\n\nIntroduzida com o System/360 em 1964, a JCL ainda orquestra o processamento batch noturno em cargas banc\xE1rias, de seguros e governamentais no z/OS, geralmente ao lado de COBOL, PL/I e REXX."
+    }
+  }
+};
+
 // src/languages/jinja.ts
 var jinja = {
   slug: "jinja",
@@ -5990,6 +6230,55 @@ var jmespath = {
   }
 };
 
+// src/languages/jq.ts
+var jq = {
+  slug: "jq",
+  publishedDate: "2012-10-21",
+  extensions: [".jq"],
+  author: "Stephen Dolan",
+  website: "https://jqlang.org",
+  paradigms: ["functional", "declarative", "query"],
+  tooling: {
+    runtimes: ["jq CLI"],
+    ecosystems: ["Data Processing", "DevOps", "Scripting"]
+  },
+  version: "1.8.1",
+  logo: "https://avatars.githubusercontent.com/u/125535133?v=4",
+  color: "#C7254E",
+  i18n: {
+    en: {
+      name: "jq",
+      description: "A functional filter language for slicing, transforming, and querying JSON.",
+      longDescription: "jq is a lightweight command-line language for processing JSON. Programs are written as filter pipelines that select, reshape, and combine values, with built-in functions for iteration, reduction, string handling, and arithmetic.\n\nIt is a staple of shell scripting and DevOps workflows, used to inspect API responses, transform configuration, and glue JSON-producing tools together. Larger filters can be stored in .jq files and reused as modules."
+    },
+    es: {
+      name: "jq",
+      description: "Un lenguaje funcional de filtros para cortar, transformar y consultar JSON.",
+      longDescription: "jq es un lenguaje ligero de l\xEDnea de comandos para procesar JSON. Los programas se escriben como tuber\xEDas de filtros que seleccionan, remodelan y combinan valores, con funciones integradas para iteraci\xF3n, reducci\xF3n, manejo de cadenas y aritm\xE9tica.\n\nEs una pieza b\xE1sica del scripting de shell y de los flujos DevOps, usado para inspeccionar respuestas de API, transformar configuraci\xF3n y conectar herramientas que producen JSON. Los filtros grandes pueden guardarse en archivos .jq y reutilizarse como m\xF3dulos."
+    },
+    it: {
+      name: "jq",
+      description: "Un linguaggio funzionale di filtri per tagliare, trasformare e interrogare JSON.",
+      longDescription: "jq \xE8 un linguaggio leggero da riga di comando per elaborare JSON. I programmi si scrivono come pipeline di filtri che selezionano, rimodellano e combinano valori, con funzioni integrate per iterazione, riduzione, gestione delle stringhe e aritmetica.\n\n\xC8 un elemento fondamentale dello scripting di shell e dei flussi DevOps, usato per ispezionare risposte di API, trasformare configurazioni e collegare strumenti che producono JSON. I filtri pi\xF9 grandi possono essere salvati in file .jq e riutilizzati come moduli."
+    },
+    fr: {
+      name: "jq",
+      description: "Un langage fonctionnel de filtres pour d\xE9couper, transformer et interroger du JSON.",
+      longDescription: "jq est un langage l\xE9ger en ligne de commande pour traiter du JSON. Les programmes s'\xE9crivent comme des pipelines de filtres qui s\xE9lectionnent, remod\xE8lent et combinent des valeurs, avec des fonctions int\xE9gr\xE9es pour l'it\xE9ration, la r\xE9duction, le traitement des cha\xEEnes et l'arithm\xE9tique.\n\nC'est un incontournable des scripts shell et des workflows DevOps, utilis\xE9 pour inspecter des r\xE9ponses d'API, transformer de la configuration et relier des outils produisant du JSON. Les filtres volumineux peuvent \xEAtre stock\xE9s dans des fichiers .jq et r\xE9utilis\xE9s comme modules."
+    },
+    de: {
+      name: "jq",
+      description: "Eine funktionale Filtersprache zum Zerlegen, Transformieren und Abfragen von JSON.",
+      longDescription: "jq ist eine leichtgewichtige Kommandozeilensprache zur Verarbeitung von JSON. Programme werden als Filter-Pipelines geschrieben, die Werte ausw\xE4hlen, umformen und kombinieren, mit eingebauten Funktionen f\xFCr Iteration, Reduktion, Zeichenkettenverarbeitung und Arithmetik.\n\nSie ist ein fester Bestandteil von Shell-Skripten und DevOps-Workflows und dient dazu, API-Antworten zu untersuchen, Konfigurationen zu transformieren und JSON-erzeugende Werkzeuge zu verbinden. Gr\xF6\xDFere Filter k\xF6nnen in .jq-Dateien abgelegt und als Module wiederverwendet werden."
+    },
+    pt: {
+      name: "jq",
+      description: "Uma linguagem funcional de filtros para fatiar, transformar e consultar JSON.",
+      longDescription: "jq \xE9 uma linguagem leve de linha de comando para processar JSON. Os programas s\xE3o escritos como pipelines de filtros que selecionam, remodelam e combinam valores, com fun\xE7\xF5es embutidas para itera\xE7\xE3o, redu\xE7\xE3o, manipula\xE7\xE3o de strings e aritm\xE9tica.\n\n\xC9 um item b\xE1sico do scripting de shell e dos fluxos DevOps, usado para inspecionar respostas de API, transformar configura\xE7\xF5es e conectar ferramentas que produzem JSON. Filtros maiores podem ser guardados em arquivos .jq e reutilizados como m\xF3dulos."
+    }
+  }
+};
+
 // src/languages/json.ts
 var json = {
   slug: "json",
@@ -6535,6 +6824,7 @@ var koka = {
 // src/languages/kotlin.ts
 var kotlin = {
   slug: "kotlin",
+  aliases: ["kt"],
   publishedDate: "2016-02-15",
   extensions: [".kt", ".kts"],
   author: "JetBrains",
@@ -6731,6 +7021,56 @@ var less = {
   }
 };
 
+// src/languages/lex.ts
+var lex = {
+  slug: "lex",
+  aliases: ["flex"],
+  publishedDate: "1975-07-01",
+  extensions: [".l", ".lex"],
+  author: "Mike Lesk / Eric Schmidt (Bell Labs)",
+  website: "https://pubs.opengroup.org/onlinepubs/9699919799/utilities/lex.html",
+  paradigms: ["declarative", "generator"],
+  tooling: {
+    runtimes: ["C toolchains"],
+    ecosystems: ["Compilers", "Language Tooling", "Unix"]
+  },
+  version: "POSIX lex / flex 2.6.4",
+  logo: "https://dummyimage.com/32x32/DBCA00/000000.png&text=Lex",
+  color: "#DBCA00",
+  i18n: {
+    en: {
+      name: "Lex",
+      description: "A lexical analyzer generator that turns regex rules into scanner code.",
+      longDescription: "Lex is a classic Unix tool that generates lexical analyzers. A .l specification pairs regular expressions with C actions; the generated scanner reads input, groups characters into tokens, and hands them to a parser, typically one produced by Yacc or Bison.\n\nThe modern open-source implementation is flex, which remains a standard part of compiler courses and production language tooling wherever hand-written lexers are not required."
+    },
+    es: {
+      name: "Lex",
+      description: "Un generador de analizadores l\xE9xicos que convierte reglas regex en c\xF3digo de escaneo.",
+      longDescription: "Lex es una herramienta cl\xE1sica de Unix que genera analizadores l\xE9xicos. Una especificaci\xF3n .l empareja expresiones regulares con acciones en C; el esc\xE1ner generado lee la entrada, agrupa caracteres en tokens y los entrega a un parser, normalmente producido por Yacc o Bison.\n\nLa implementaci\xF3n moderna de c\xF3digo abierto es flex, que sigue siendo parte est\xE1ndar de los cursos de compiladores y de las herramientas de lenguajes en producci\xF3n donde no se requieren lexers escritos a mano."
+    },
+    it: {
+      name: "Lex",
+      description: "Un generatore di analizzatori lessicali che trasforma regole regex in codice scanner.",
+      longDescription: "Lex \xE8 uno strumento classico di Unix che genera analizzatori lessicali. Una specifica .l abbina espressioni regolari ad azioni in C; lo scanner generato legge l'input, raggruppa i caratteri in token e li passa a un parser, tipicamente prodotto da Yacc o Bison.\n\nL'implementazione open source moderna \xE8 flex, che rimane una parte standard dei corsi sui compilatori e degli strumenti linguistici in produzione dove non servono lexer scritti a mano."
+    },
+    fr: {
+      name: "Lex",
+      description: "Un g\xE9n\xE9rateur d'analyseurs lexicaux qui transforme des r\xE8gles regex en code de scanner.",
+      longDescription: "Lex est un outil Unix classique qui g\xE9n\xE8re des analyseurs lexicaux. Une sp\xE9cification .l associe des expressions r\xE9guli\xE8res \xE0 des actions en C ; le scanner g\xE9n\xE9r\xE9 lit l'entr\xE9e, regroupe les caract\xE8res en jetons et les transmet \xE0 un parseur, g\xE9n\xE9ralement produit par Yacc ou Bison.\n\nL'impl\xE9mentation open source moderne est flex, qui reste un \xE9l\xE9ment standard des cours de compilation et de l'outillage de langages en production lorsque des lexers \xE9crits \xE0 la main ne sont pas n\xE9cessaires."
+    },
+    de: {
+      name: "Lex",
+      description: "Ein Generator f\xFCr lexikalische Analysatoren, der Regex-Regeln in Scanner-Code \xFCbersetzt.",
+      longDescription: "Lex ist ein klassisches Unix-Werkzeug zur Erzeugung lexikalischer Analysatoren. Eine .l-Spezifikation verkn\xFCpft regul\xE4re Ausdr\xFCcke mit C-Aktionen; der erzeugte Scanner liest die Eingabe, gruppiert Zeichen zu Tokens und \xFCbergibt sie an einen Parser, der typischerweise von Yacc oder Bison erzeugt wird.\n\nDie moderne Open-Source-Implementierung ist flex, die weiterhin fester Bestandteil von Compiler-Kursen und produktivem Sprach-Tooling ist, wo keine handgeschriebenen Lexer erforderlich sind."
+    },
+    pt: {
+      name: "Lex",
+      description: "Um gerador de analisadores l\xE9xicos que converte regras regex em c\xF3digo de scanner.",
+      longDescription: "Lex \xE9 uma ferramenta cl\xE1ssica do Unix que gera analisadores l\xE9xicos. Uma especifica\xE7\xE3o .l combina express\xF5es regulares com a\xE7\xF5es em C; o scanner gerado l\xEA a entrada, agrupa caracteres em tokens e os entrega a um parser, normalmente produzido pelo Yacc ou Bison.\n\nA implementa\xE7\xE3o moderna de c\xF3digo aberto \xE9 o flex, que continua sendo parte padr\xE3o dos cursos de compiladores e das ferramentas de linguagens em produ\xE7\xE3o onde lexers escritos \xE0 m\xE3o n\xE3o s\xE3o necess\xE1rios."
+    }
+  }
+};
+
 // src/languages/ligo.ts
 var ligo = {
   slug: "ligo",
@@ -6794,7 +7134,7 @@ var linkerscript = {
     ecosystems: ["Embedded systems", "Operating systems"]
   },
   version: "stable",
-  logo: "https://dummyimage.com/32x32/475569/ffffff.png&text=LD",
+  logo: "https://cdn.simpleicons.org/gnu/A42E2B",
   color: "#475569",
   i18n: {
     en: {
@@ -6993,7 +7333,7 @@ var lobster = {
     ecosystems: ["Games", "Interactive Graphics", "Language Experiments"]
   },
   version: "development snapshot",
-  logo: "https://dummyimage.com/32x32/DC2626/ffffff.png&text=Lo",
+  logo: "https://raw.githubusercontent.com/aardappel/lobster/master/docs/lobster.png",
   color: "#DC2626",
   i18n: {
     en: {
@@ -7280,6 +7620,7 @@ var mako = {
 // src/languages/markdown.ts
 var markdown = {
   slug: "markdown",
+  aliases: ["md"],
   publishedDate: "2004-03-19",
   extensions: [".md", ".markdown", ".mdown", ".mkd"],
   author: "John Gruber / Aaron Swartz",
@@ -8560,6 +8901,7 @@ var oberon = {
 // src/languages/objective-c.ts
 var objectiveC = {
   slug: "objective-c",
+  aliases: ["objc", "objective c"],
   publishedDate: "1984-01-01",
   extensions: [".m", ".mm"],
   author: "Brad Cox / Tom Love",
@@ -9214,7 +9556,7 @@ var plI = {
     ecosystems: ["Mainframe", "Enterprise", "Scientific Computing"]
   },
   version: "Enterprise PL/I 6.2",
-  logo: "https://dummyimage.com/32x32/1F2937/ffffff.png&text=PL1",
+  logo: "https://upload.wikimedia.org/wikipedia/commons/5/51/IBM_logo.svg",
   color: "#1F2937",
   i18n: {
     en: {
@@ -9509,7 +9851,7 @@ var postscript = {
     ecosystems: ["Print", "PDF"]
   },
   version: "PostScript 3",
-  logo: "https://dummyimage.com/32x32/EC1C24/ffffff.png&text=PS",
+  logo: "https://raw.githubusercontent.com/vscode-icons/vscode-icons/master/icons/file_type_postscript.svg",
   color: "#EC1C24",
   i18n: {
     en: {
@@ -9557,7 +9899,7 @@ var powerquery = {
     ecosystems: ["Microsoft Power BI", "Excel", "Azure Data Factory", "Microsoft Fabric"]
   },
   version: "Power Query M 2025",
-  logo: "https://dummyimage.com/32x32/F2C811/000000.png&text=PQ",
+  logo: "https://upload.wikimedia.org/wikipedia/commons/c/cf/New_Power_BI_Logo.svg",
   color: "#F2C811",
   i18n: {
     en: {
@@ -9596,6 +9938,7 @@ var powerquery = {
 // src/languages/powershell.ts
 var powershell = {
   slug: "powershell",
+  aliases: ["pwsh"],
   publishedDate: "2006-11-14",
   extensions: [".ps1", ".psm1", ".psd1", ".ps1xml"],
   author: "Microsoft",
@@ -9791,9 +10134,60 @@ var promql = {
   }
 };
 
+// src/languages/properties.ts
+var properties = {
+  slug: "properties",
+  aliases: ["java properties"],
+  publishedDate: "1996-01-23",
+  extensions: [".properties"],
+  author: "Sun Microsystems",
+  website: "https://docs.oracle.com/javase/8/docs/api/java/util/Properties.html",
+  paradigms: ["declarative", "configuration"],
+  tooling: {
+    runtimes: ["JVM"],
+    ecosystems: ["JVM", "Configuration"]
+  },
+  version: "stable",
+  logo: "https://cdn.simpleicons.org/openjdk/437291",
+  color: "#2A6277",
+  i18n: {
+    en: {
+      name: "Java Properties",
+      description: "A simple key-value configuration format used across the Java ecosystem.",
+      longDescription: "Java Properties files store configuration as key-value pairs in plain text, with support for comments, escaping, and Unicode sequences. The format ships with the JDK through java.util.Properties and dates back to Java 1.0.\n\nIt remains the default configuration format across the JVM ecosystem: Spring application settings, Gradle project configuration, log4j setup, and resource bundles for internationalization all commonly live in .properties files."
+    },
+    es: {
+      name: "Java Properties",
+      description: "Un formato simple de configuraci\xF3n clave-valor usado en todo el ecosistema Java.",
+      longDescription: "Los archivos Java Properties almacenan configuraci\xF3n como pares clave-valor en texto plano, con soporte para comentarios, escapes y secuencias Unicode. El formato viene con el JDK a trav\xE9s de java.util.Properties y se remonta a Java 1.0.\n\nSigue siendo el formato de configuraci\xF3n por defecto en el ecosistema JVM: los ajustes de aplicaciones Spring, la configuraci\xF3n de proyectos Gradle, la configuraci\xF3n de log4j y los resource bundles de internacionalizaci\xF3n suelen vivir en archivos .properties."
+    },
+    it: {
+      name: "Java Properties",
+      description: "Un semplice formato di configurazione chiave-valore usato nell'ecosistema Java.",
+      longDescription: "I file Java Properties memorizzano la configurazione come coppie chiave-valore in testo semplice, con supporto per commenti, escape e sequenze Unicode. Il formato \xE8 incluso nel JDK tramite java.util.Properties e risale a Java 1.0.\n\nRimane il formato di configurazione predefinito nell'ecosistema JVM: le impostazioni delle applicazioni Spring, la configurazione dei progetti Gradle, la configurazione di log4j e i resource bundle per l'internazionalizzazione vivono comunemente in file .properties."
+    },
+    fr: {
+      name: "Java Properties",
+      description: "Un format simple de configuration cl\xE9-valeur utilis\xE9 dans tout l'\xE9cosyst\xE8me Java.",
+      longDescription: "Les fichiers Java Properties stockent la configuration sous forme de paires cl\xE9-valeur en texte brut, avec la prise en charge des commentaires, de l'\xE9chappement et des s\xE9quences Unicode. Le format est livr\xE9 avec le JDK via java.util.Properties et remonte \xE0 Java 1.0.\n\nIl reste le format de configuration par d\xE9faut de l'\xE9cosyst\xE8me JVM : les param\xE8tres d'applications Spring, la configuration de projets Gradle, la configuration de log4j et les resource bundles d'internationalisation vivent couramment dans des fichiers .properties."
+    },
+    de: {
+      name: "Java Properties",
+      description: "Ein einfaches Schl\xFCssel-Wert-Konfigurationsformat aus dem Java-\xD6kosystem.",
+      longDescription: "Java-Properties-Dateien speichern Konfiguration als Schl\xFCssel-Wert-Paare im Klartext, mit Unterst\xFCtzung f\xFCr Kommentare, Escaping und Unicode-Sequenzen. Das Format ist \xFCber java.util.Properties Teil des JDK und stammt aus Java 1.0.\n\nEs bleibt das Standard-Konfigurationsformat im JVM-\xD6kosystem: Spring-Anwendungseinstellungen, Gradle-Projektkonfiguration, log4j-Setup und Resource-Bundles f\xFCr Internationalisierung liegen \xFCblicherweise in .properties-Dateien."
+    },
+    pt: {
+      name: "Java Properties",
+      description: "Um formato simples de configura\xE7\xE3o chave-valor usado em todo o ecossistema Java.",
+      longDescription: "Os arquivos Java Properties armazenam configura\xE7\xE3o como pares chave-valor em texto simples, com suporte a coment\xE1rios, escapes e sequ\xEAncias Unicode. O formato acompanha o JDK por meio de java.util.Properties e remonta ao Java 1.0.\n\nContinua sendo o formato de configura\xE7\xE3o padr\xE3o do ecossistema JVM: as configura\xE7\xF5es de aplica\xE7\xF5es Spring, a configura\xE7\xE3o de projetos Gradle, a configura\xE7\xE3o do log4j e os resource bundles de internacionaliza\xE7\xE3o costumam viver em arquivos .properties."
+    }
+  }
+};
+
 // src/languages/protobuf.ts
 var protobuf = {
   slug: "protobuf",
+  aliases: ["proto", "protocol buffers"],
   publishedDate: "2008-07-07",
   extensions: [".proto"],
   author: "Google",
@@ -9994,6 +10388,7 @@ var purescript = {
 // src/languages/python.ts
 var python = {
   slug: "python",
+  aliases: ["py"],
   publishedDate: "1991-02-20",
   extensions: [".py", ".pyw"],
   author: "Guido van Rossum",
@@ -10293,6 +10688,7 @@ var racket = {
 // src/languages/raku.ts
 var raku = {
   slug: "raku",
+  aliases: ["perl6", "perl 6"],
   publishedDate: "2015-12-25",
   extensions: [".raku", ".rakumod", ".rakudoc", ".rakutest", ".p6", ".pm6"],
   author: "Raku Community",
@@ -10641,6 +11037,7 @@ var rescript = {
 // src/languages/restructuredtext.ts
 var restructuredtext = {
   slug: "restructuredtext",
+  aliases: ["rst"],
   publishedDate: "2001-06-01",
   extensions: [".rst", ".rest"],
   author: "David Goodger / Docutils contributors",
@@ -10688,6 +11085,55 @@ var restructuredtext = {
   }
 };
 
+// src/languages/rexx.ts
+var rexx = {
+  slug: "rexx",
+  publishedDate: "1979-03-20",
+  extensions: [".rexx", ".rex"],
+  author: "Mike Cowlishaw / IBM",
+  website: "https://www.rexxla.org",
+  paradigms: ["imperative", "procedural", "scripting"],
+  tooling: {
+    runtimes: ["z/OS", "ooRexx", "Regina REXX"],
+    ecosystems: ["Mainframe", "Scripting"]
+  },
+  version: "ANSI X3.274-1996",
+  logo: "https://raw.githubusercontent.com/vscode-icons/vscode-icons/master/icons/file_type_rexx.svg",
+  color: "#D90E09",
+  i18n: {
+    en: {
+      name: "REXX",
+      description: "A readable IBM scripting language for mainframe automation and system glue.",
+      longDescription: "REXX (Restructured Extended Executor) is a scripting language designed by Mike Cowlishaw at IBM with an emphasis on readability and ease of learning. It became the standard automation language on IBM mainframes, driving TSO/ISPF, batch jobs, and system utilities on z/OS.\n\nBeyond the mainframe, Open Object Rexx (ooRexx) and Regina bring the language to Linux, Windows, and macOS, and REXX remains in active production use wherever decades of mainframe automation live on."
+    },
+    es: {
+      name: "REXX",
+      description: "Un lenguaje de scripting legible de IBM para automatizaci\xF3n de mainframes.",
+      longDescription: "REXX (Restructured Extended Executor) es un lenguaje de scripting dise\xF1ado por Mike Cowlishaw en IBM con \xE9nfasis en la legibilidad y la facilidad de aprendizaje. Se convirti\xF3 en el lenguaje de automatizaci\xF3n est\xE1ndar de los mainframes de IBM, controlando TSO/ISPF, trabajos batch y utilidades del sistema en z/OS.\n\nM\xE1s all\xE1 del mainframe, Open Object Rexx (ooRexx) y Regina llevan el lenguaje a Linux, Windows y macOS, y REXX sigue en uso productivo activo dondequiera que perduren d\xE9cadas de automatizaci\xF3n de mainframe."
+    },
+    it: {
+      name: "REXX",
+      description: "Un linguaggio di scripting IBM leggibile per l'automazione dei mainframe.",
+      longDescription: "REXX (Restructured Extended Executor) \xE8 un linguaggio di scripting progettato da Mike Cowlishaw in IBM con enfasi sulla leggibilit\xE0 e sulla facilit\xE0 di apprendimento. \xC8 diventato il linguaggio di automazione standard sui mainframe IBM, guidando TSO/ISPF, job batch e utility di sistema su z/OS.\n\nOltre il mainframe, Open Object Rexx (ooRexx) e Regina portano il linguaggio su Linux, Windows e macOS, e REXX rimane in uso produttivo attivo ovunque sopravvivano decenni di automazione mainframe."
+    },
+    fr: {
+      name: "REXX",
+      description: "Un langage de script IBM lisible pour l'automatisation des mainframes.",
+      longDescription: "REXX (Restructured Extended Executor) est un langage de script con\xE7u par Mike Cowlishaw chez IBM avec un accent sur la lisibilit\xE9 et la facilit\xE9 d'apprentissage. Il est devenu le langage d'automatisation standard des mainframes IBM, pilotant TSO/ISPF, les travaux batch et les utilitaires syst\xE8me sous z/OS.\n\nAu-del\xE0 du mainframe, Open Object Rexx (ooRexx) et Regina portent le langage sur Linux, Windows et macOS, et REXX reste en usage productif actif partout o\xF9 survivent des d\xE9cennies d'automatisation mainframe."
+    },
+    de: {
+      name: "REXX",
+      description: "Eine gut lesbare IBM-Skriptsprache f\xFCr Mainframe-Automatisierung.",
+      longDescription: "REXX (Restructured Extended Executor) ist eine von Mike Cowlishaw bei IBM entworfene Skriptsprache mit Schwerpunkt auf Lesbarkeit und leichter Erlernbarkeit. Sie wurde zur Standard-Automatisierungssprache auf IBM-Mainframes und steuert TSO/ISPF, Batch-Jobs und Systemwerkzeuge unter z/OS.\n\nJenseits des Mainframes bringen Open Object Rexx (ooRexx) und Regina die Sprache auf Linux, Windows und macOS, und REXX bleibt \xFCberall dort im produktiven Einsatz, wo Jahrzehnte an Mainframe-Automatisierung weiterleben."
+    },
+    pt: {
+      name: "REXX",
+      description: "Uma linguagem de script leg\xEDvel da IBM para automa\xE7\xE3o de mainframes.",
+      longDescription: "REXX (Restructured Extended Executor) \xE9 uma linguagem de script projetada por Mike Cowlishaw na IBM com \xEAnfase em legibilidade e facilidade de aprendizado. Tornou-se a linguagem de automa\xE7\xE3o padr\xE3o nos mainframes da IBM, controlando TSO/ISPF, jobs batch e utilit\xE1rios de sistema no z/OS.\n\nAl\xE9m do mainframe, o Open Object Rexx (ooRexx) e o Regina levam a linguagem para Linux, Windows e macOS, e o REXX continua em uso produtivo ativo onde quer que d\xE9cadas de automa\xE7\xE3o de mainframe sobrevivam."
+    }
+  }
+};
+
 // src/languages/roc.ts
 var roc = {
   slug: "roc",
@@ -10789,6 +11235,7 @@ var rpg = {
 // src/languages/ruby.ts
 var ruby = {
   slug: "ruby",
+  aliases: ["rb"],
   publishedDate: "1995-12-21",
   extensions: [".rb", ".rbw", ".rake", ".gemspec", "Gemfile", "Rakefile", "config.ru"],
   author: "Yukihiro Matsumoto",
@@ -11136,6 +11583,7 @@ var self = {
 // src/languages/simula.ts
 var simula = {
   slug: "simula",
+  status: "historical",
   publishedDate: "1962-01-01",
   extensions: [".sim", ".simula"],
   author: "Ole-Johan Dahl and Kristen Nygaard",
@@ -11333,6 +11781,7 @@ var snakemake = {
 // src/languages/snobol.ts
 var snobol = {
   slug: "snobol",
+  status: "historical",
   publishedDate: "1962-01-01",
   extensions: [".sno", ".snobol"],
   author: "David J. Farber, Ralph Griswold, and Ivan P. Polonsky",
@@ -11491,7 +11940,7 @@ var spark = {
     ecosystems: ["Ada", "Embedded", "Safety-critical software"]
   },
   version: "SPARK Community 2021",
-  logo: "https://dummyimage.com/32x32/DC2626/ffffff.png&text=SP",
+  logo: "https://avatars.githubusercontent.com/u/7767877?v=4",
   color: "#DC2626",
   i18n: {
     en: {
@@ -11638,7 +12087,7 @@ var spss = {
     ecosystems: ["Statistics", "Data Analysis", "Social Sciences", "Business Intelligence"]
   },
   version: "29.0",
-  logo: "https://dummyimage.com/32x32/052FAD/ffffff.png&text=SPSS",
+  logo: "https://upload.wikimedia.org/wikipedia/commons/e/ea/SPSS_logo.svg",
   color: "#052FAD",
   i18n: {
     en: {
@@ -11732,7 +12181,7 @@ var squirrel = {
     ecosystems: ["Game Development", "Embedded Scripting", "Valve Source Engine"]
   },
   version: "3.2",
-  logo: "https://dummyimage.com/32x32/CC4A00/ffffff.png&text=SQ",
+  logo: "https://raw.githubusercontent.com/vscode-icons/vscode-icons/master/icons/file_type_squirrel.svg",
   color: "#CC4A00",
   i18n: {
     en: {
@@ -12266,6 +12715,7 @@ var tcsh = {
 // src/languages/tex.ts
 var tex = {
   slug: "tex",
+  aliases: ["latex"],
   publishedDate: "1978-01-01",
   extensions: [".tex", ".sty", ".cls", ".dtx", ".ins", ".ltx"],
   author: "Donald Knuth",
@@ -12710,6 +13160,7 @@ var twig = {
 // src/languages/typescript.ts
 var typescript = {
   slug: "typescript",
+  aliases: ["ts"],
   publishedDate: "2012-10-01",
   extensions: [".ts", ".tsx", ".mts", ".cts"],
   author: "Anders Hejlsberg / Microsoft",
@@ -12960,6 +13411,7 @@ var vala = {
 // src/languages/vale.ts
 var vale = {
   slug: "vale",
+  status: "experimental",
   publishedDate: "2018-01-01",
   extensions: [".vale"],
   author: "Evan Ovadia",
@@ -12970,7 +13422,7 @@ var vale = {
     ecosystems: ["Native applications", "Systems programming"]
   },
   version: "experimental",
-  logo: "https://dummyimage.com/32x32/059669/ffffff.png&text=Va",
+  logo: "https://avatars.githubusercontent.com/u/67560249?v=4",
   color: "#059669",
   i18n: {
     en: {
@@ -13018,7 +13470,7 @@ var vba = {
     ecosystems: ["Microsoft Office", "Excel", "Access", "Word", "Outlook"]
   },
   version: "VBA 7.1",
-  logo: "https://dummyimage.com/32x32/217346/ffffff.png&text=VBA",
+  logo: "https://raw.githubusercontent.com/vscode-icons/vscode-icons/master/icons/file_type_vba.svg",
   color: "#217346",
   i18n: {
     en: {
@@ -13054,6 +13506,56 @@ var vba = {
   }
 };
 
+// src/languages/vbscript.ts
+var vbscript = {
+  slug: "vbscript",
+  status: "legacy",
+  publishedDate: "1996-08-01",
+  extensions: [".vbs", ".vbe"],
+  author: "Microsoft",
+  website: "https://learn.microsoft.com/en-us/previous-versions/t0aew7h6(v=vs.85)",
+  paradigms: ["imperative", "object-based", "scripting"],
+  tooling: {
+    runtimes: ["Windows Script Host", "Classic ASP", "Internet Explorer"],
+    ecosystems: ["Windows", "Scripting"]
+  },
+  version: "5.8",
+  logo: "https://dummyimage.com/32x32/15DCDC/000000.png&text=VBS",
+  color: "#15DCDC",
+  i18n: {
+    en: {
+      name: "VBScript",
+      description: "A lightweight Visual Basic dialect for Windows automation and Classic ASP.",
+      longDescription: "VBScript is a scripting language modeled on Visual Basic and executed by the Windows Script Host, Classic ASP, and legacy Internet Explorer. It was widely used for Windows administration, logon scripts, and early server-side web pages.\n\nMicrosoft has deprecated VBScript and is phasing it out of Windows in favor of PowerShell and JavaScript, but large volumes of .vbs automation still run in enterprise environments."
+    },
+    es: {
+      name: "VBScript",
+      description: "Un dialecto ligero de Visual Basic para automatizaci\xF3n de Windows y ASP cl\xE1sico.",
+      longDescription: "VBScript es un lenguaje de scripting inspirado en Visual Basic y ejecutado por Windows Script Host, ASP cl\xE1sico e Internet Explorer heredado. Se us\xF3 ampliamente para administraci\xF3n de Windows, scripts de inicio de sesi\xF3n y las primeras p\xE1ginas web del lado del servidor.\n\nMicrosoft ha marcado VBScript como obsoleto y lo est\xE1 retirando de Windows en favor de PowerShell y JavaScript, pero grandes vol\xFAmenes de automatizaci\xF3n .vbs siguen ejecut\xE1ndose en entornos empresariales."
+    },
+    it: {
+      name: "VBScript",
+      description: "Un dialetto leggero di Visual Basic per automazione Windows e ASP classico.",
+      longDescription: "VBScript \xE8 un linguaggio di scripting modellato su Visual Basic ed eseguito da Windows Script Host, ASP classico e dal vecchio Internet Explorer. \xC8 stato ampiamente usato per l'amministrazione di Windows, gli script di accesso e le prime pagine web lato server.\n\nMicrosoft ha deprecato VBScript e lo sta rimuovendo da Windows in favore di PowerShell e JavaScript, ma grandi volumi di automazione .vbs sono ancora in esecuzione negli ambienti aziendali."
+    },
+    fr: {
+      name: "VBScript",
+      description: "Un dialecte l\xE9ger de Visual Basic pour l'automatisation Windows et l'ASP classique.",
+      longDescription: "VBScript est un langage de script inspir\xE9 de Visual Basic et ex\xE9cut\xE9 par Windows Script Host, l'ASP classique et l'ancien Internet Explorer. Il a \xE9t\xE9 largement utilis\xE9 pour l'administration Windows, les scripts d'ouverture de session et les premi\xE8res pages web c\xF4t\xE9 serveur.\n\nMicrosoft a d\xE9pr\xE9ci\xE9 VBScript et le retire progressivement de Windows au profit de PowerShell et de JavaScript, mais de grands volumes d'automatisation .vbs tournent encore dans les environnements d'entreprise."
+    },
+    de: {
+      name: "VBScript",
+      description: "Ein leichter Visual-Basic-Dialekt f\xFCr Windows-Automatisierung und Classic ASP.",
+      longDescription: "VBScript ist eine an Visual Basic angelehnte Skriptsprache, die vom Windows Script Host, Classic ASP und dem alten Internet Explorer ausgef\xFChrt wird. Sie wurde breit f\xFCr Windows-Administration, Anmeldeskripte und fr\xFChe serverseitige Webseiten eingesetzt.\n\nMicrosoft hat VBScript als veraltet markiert und entfernt es schrittweise aus Windows zugunsten von PowerShell und JavaScript, aber gro\xDFe Mengen an .vbs-Automatisierung laufen weiterhin in Unternehmensumgebungen."
+    },
+    pt: {
+      name: "VBScript",
+      description: "Um dialeto leve de Visual Basic para automa\xE7\xE3o do Windows e ASP cl\xE1ssico.",
+      longDescription: "VBScript \xE9 uma linguagem de script baseada no Visual Basic e executada pelo Windows Script Host, pelo ASP cl\xE1ssico e pelo antigo Internet Explorer. Foi amplamente usada para administra\xE7\xE3o do Windows, scripts de logon e as primeiras p\xE1ginas web do lado do servidor.\n\nA Microsoft descontinuou o VBScript e o est\xE1 removendo do Windows em favor do PowerShell e do JavaScript, mas grandes volumes de automa\xE7\xE3o .vbs ainda rodam em ambientes corporativos."
+    }
+  }
+};
+
 // src/languages/velocity.ts
 var velocity = {
   slug: "velocity",
@@ -13166,7 +13668,7 @@ var verse = {
     ecosystems: ["Unreal Engine", "Fortnite Creator"]
   },
   version: "UEFN Verse",
-  logo: "https://dummyimage.com/32x32/111827/ffffff.png&text=Ve",
+  logo: "https://cdn.simpleicons.org/epicgames",
   color: "#111827",
   i18n: {
     en: {
@@ -13252,9 +13754,61 @@ var vhdl = {
   }
 };
 
+// src/languages/vimscript.ts
+var vimscript = {
+  slug: "vimscript",
+  aliases: ["vim", "vim script", "viml"],
+  publishedDate: "1991-11-02",
+  extensions: [".vim", ".vimrc", ".gvimrc"],
+  author: "Bram Moolenaar",
+  website: "https://www.vim.org",
+  paradigms: ["imperative", "scripting"],
+  tooling: {
+    runtimes: ["Vim", "Neovim"],
+    packageManagers: ["vim-plug", "lazy.nvim", "packer.nvim"],
+    ecosystems: ["Text Editors", "Scripting"]
+  },
+  version: "Vim 9.1",
+  logo: "https://cdn.simpleicons.org/vim/019733",
+  color: "#019733",
+  i18n: {
+    en: {
+      name: "Vim script",
+      description: "The scripting language built into the Vim editor for configuration & plugins.",
+      longDescription: "Vim script is the scripting language embedded in the Vim text editor. It drives user configuration through vimrc files and powers a large plugin ecosystem, with commands, autocommands, functions, and access to buffers, windows, and registers.\n\nVim 9 introduced Vim9 script, a faster, more structured dialect with typed variables and compiled functions, while Neovim pairs the legacy dialect with Lua as an alternative extension language."
+    },
+    es: {
+      name: "Vim script",
+      description: "El lenguaje de scripting integrado en el editor Vim para configuraci\xF3n y plugins.",
+      longDescription: "Vim script es el lenguaje de scripting integrado en el editor de texto Vim. Gestiona la configuraci\xF3n del usuario mediante archivos vimrc e impulsa un gran ecosistema de plugins, con comandos, autocomandos, funciones y acceso a buffers, ventanas y registros.\n\nVim 9 introdujo Vim9 script, un dialecto m\xE1s r\xE1pido y estructurado con variables tipadas y funciones compiladas, mientras que Neovim combina el dialecto cl\xE1sico con Lua como lenguaje de extensi\xF3n alternativo."
+    },
+    it: {
+      name: "Vim script",
+      description: "Il linguaggio di scripting integrato nell'editor Vim per configurazione e plugin.",
+      longDescription: "Vim script \xE8 il linguaggio di scripting incorporato nell'editor di testo Vim. Gestisce la configurazione dell'utente tramite i file vimrc e alimenta un vasto ecosistema di plugin, con comandi, autocomandi, funzioni e accesso a buffer, finestre e registri.\n\nVim 9 ha introdotto Vim9 script, un dialetto pi\xF9 veloce e strutturato con variabili tipate e funzioni compilate, mentre Neovim affianca al dialetto classico Lua come linguaggio di estensione alternativo."
+    },
+    fr: {
+      name: "Vim script",
+      description: "Le langage de script int\xE9gr\xE9 \xE0 l'\xE9diteur Vim pour la configuration et les plugins.",
+      longDescription: "Vim script est le langage de script int\xE9gr\xE9 \xE0 l'\xE9diteur de texte Vim. Il pilote la configuration de l'utilisateur via les fichiers vimrc et alimente un vaste \xE9cosyst\xE8me de plugins, avec des commandes, des autocommandes, des fonctions et un acc\xE8s aux tampons, fen\xEAtres et registres.\n\nVim 9 a introduit Vim9 script, un dialecte plus rapide et plus structur\xE9 avec des variables typ\xE9es et des fonctions compil\xE9es, tandis que Neovim associe le dialecte historique \xE0 Lua comme langage d'extension alternatif."
+    },
+    de: {
+      name: "Vim script",
+      description: "Die im Vim-Editor eingebaute Skriptsprache f\xFCr Konfiguration und Plugins.",
+      longDescription: "Vim script ist die in den Texteditor Vim eingebettete Skriptsprache. Sie steuert die Benutzerkonfiguration \xFCber vimrc-Dateien und treibt ein gro\xDFes Plugin-\xD6kosystem an, mit Befehlen, Autokommandos, Funktionen und Zugriff auf Puffer, Fenster und Register.\n\nVim 9 f\xFChrte Vim9 script ein, einen schnelleren, st\xE4rker strukturierten Dialekt mit typisierten Variablen und kompilierten Funktionen, w\xE4hrend Neovim den klassischen Dialekt mit Lua als alternativer Erweiterungssprache kombiniert."
+    },
+    pt: {
+      name: "Vim script",
+      description: "A linguagem de script embutida no editor Vim para configura\xE7\xE3o e plugins.",
+      longDescription: "Vim script \xE9 a linguagem de script embutida no editor de texto Vim. Ela controla a configura\xE7\xE3o do usu\xE1rio por meio de arquivos vimrc e move um grande ecossistema de plugins, com comandos, autocomandos, fun\xE7\xF5es e acesso a buffers, janelas e registradores.\n\nO Vim 9 introduziu o Vim9 script, um dialeto mais r\xE1pido e estruturado com vari\xE1veis tipadas e fun\xE7\xF5es compiladas, enquanto o Neovim combina o dialeto cl\xE1ssico com Lua como linguagem de extens\xE3o alternativa."
+    }
+  }
+};
+
 // src/languages/visual-basic.ts
 var visualBasic = {
   slug: "visual-basic",
+  aliases: ["vb", "vb.net"],
   publishedDate: "2001-02-13",
   extensions: [".vb"],
   author: "Microsoft",
@@ -13454,6 +14008,7 @@ var wdl = {
 // src/languages/webassembly.ts
 var webassembly = {
   slug: "webassembly",
+  aliases: ["wasm", "wat"],
   publishedDate: "2017-03-07",
   extensions: [".wasm", ".wat"],
   author: "W3C WebAssembly Community Group",
@@ -13842,6 +14397,58 @@ var xslt = {
   }
 };
 
+// src/languages/yacc.ts
+var yacc = {
+  slug: "yacc",
+  aliases: ["bison"],
+  publishedDate: "1973-01-01",
+  extensions: [".y", ".yacc"],
+  author: "Stephen C. Johnson (Bell Labs)",
+  website: "https://pubs.opengroup.org/onlinepubs/9699919799/utilities/yacc.html",
+  paradigms: ["declarative", "generator"],
+  tooling: {
+    runtimes: ["C toolchains"],
+    ecosystems: ["Compilers", "Language Tooling", "Unix"]
+  },
+  version: "POSIX yacc / Bison 3.8.2",
+  logo: "https://cdn.simpleicons.org/gnu/A42E2B",
+  color: "#4B6C4B",
+  i18n: {
+    en: {
+      name: "Yacc",
+      description: "A parser generator that turns context-free grammars into LALR parser code.",
+      longDescription: 'Yacc ("Yet Another Compiler-Compiler") is a classic Unix parser generator. A .y grammar file declares tokens, precedences, and production rules with embedded C actions, from which Yacc produces an LALR(1) parser that pairs naturally with a Lex-generated scanner.\n\nGNU Bison is the dominant modern implementation and remains widely used to build compilers, interpreters, configuration readers, and query languages across open-source projects.'
+    },
+    es: {
+      name: "Yacc",
+      description: "Un generador de parsers que convierte gram\xE1ticas libres de contexto en parsers LALR.",
+      longDescription: 'Yacc ("Yet Another Compiler-Compiler") es un generador de parsers cl\xE1sico de Unix. Un archivo de gram\xE1tica .y declara tokens, precedencias y reglas de producci\xF3n con acciones en C incrustadas, a partir de las cuales Yacc produce un parser LALR(1) que se combina de forma natural con un esc\xE1ner generado por Lex.\n\nGNU Bison es la implementaci\xF3n moderna dominante y sigue siendo muy usada para construir compiladores, int\xE9rpretes, lectores de configuraci\xF3n y lenguajes de consulta en proyectos de c\xF3digo abierto.'
+    },
+    it: {
+      name: "Yacc",
+      description: "Un generatore di parser che trasforma grammatiche libere dal contesto in parser LALR.",
+      longDescription: `Yacc ("Yet Another Compiler-Compiler") \xE8 un generatore di parser classico di Unix. Un file di grammatica .y dichiara token, precedenze e regole di produzione con azioni C incorporate, da cui Yacc produce un parser LALR(1) che si abbina naturalmente a uno scanner generato da Lex.
+
+GNU Bison \xE8 l'implementazione moderna dominante e rimane ampiamente usata per costruire compilatori, interpreti, lettori di configurazione e linguaggi di interrogazione nei progetti open source.`
+    },
+    fr: {
+      name: "Yacc",
+      description: "Un g\xE9n\xE9rateur de parseurs qui transforme des grammaires hors contexte en parseurs LALR.",
+      longDescription: "Yacc (\xAB Yet Another Compiler-Compiler \xBB) est un g\xE9n\xE9rateur de parseurs Unix classique. Un fichier de grammaire .y d\xE9clare des jetons, des pr\xE9c\xE9dences et des r\xE8gles de production avec des actions C int\xE9gr\xE9es, \xE0 partir desquelles Yacc produit un parseur LALR(1) qui se combine naturellement avec un scanner g\xE9n\xE9r\xE9 par Lex.\n\nGNU Bison est l'impl\xE9mentation moderne dominante et reste largement utilis\xE9e pour construire des compilateurs, des interpr\xE9teurs, des lecteurs de configuration et des langages de requ\xEAte dans les projets open source."
+    },
+    de: {
+      name: "Yacc",
+      description: "Ein Parser-Generator, der kontextfreie Grammatiken in LALR-Parser-Code \xFCbersetzt.",
+      longDescription: 'Yacc (\u201EYet Another Compiler-Compiler") ist ein klassischer Unix-Parser-Generator. Eine .y-Grammatikdatei deklariert Tokens, Pr\xE4zedenzen und Produktionsregeln mit eingebetteten C-Aktionen, aus denen Yacc einen LALR(1)-Parser erzeugt, der sich nat\xFCrlich mit einem von Lex erzeugten Scanner kombinieren l\xE4sst.\n\nGNU Bison ist die dominierende moderne Implementierung und wird weiterhin breit eingesetzt, um Compiler, Interpreter, Konfigurationsleser und Abfragesprachen in Open-Source-Projekten zu bauen.'
+    },
+    pt: {
+      name: "Yacc",
+      description: "Um gerador de parsers que converte gram\xE1ticas livres de contexto em parsers LALR.",
+      longDescription: 'Yacc ("Yet Another Compiler-Compiler") \xE9 um gerador de parsers cl\xE1ssico do Unix. Um arquivo de gram\xE1tica .y declara tokens, preced\xEAncias e regras de produ\xE7\xE3o com a\xE7\xF5es em C embutidas, a partir das quais o Yacc produz um parser LALR(1) que combina naturalmente com um scanner gerado pelo Lex.\n\nO GNU Bison \xE9 a implementa\xE7\xE3o moderna dominante e continua amplamente usado para construir compiladores, interpretadores, leitores de configura\xE7\xE3o e linguagens de consulta em projetos de c\xF3digo aberto.'
+    }
+  }
+};
+
 // src/languages/yaml.ts
 var yaml = {
   slug: "yaml",
@@ -14144,31 +14751,31 @@ var languages = [
   agda,
   algol,
   ampl,
+  angelscript,
   ante,
   antlr,
   apex,
   apl,
   applescript,
-  arduino,
   aql,
+  arduino,
   asciidoc,
   asp,
   assembly,
   assemblyscript,
-  angelscript,
   astro,
   austral,
   autohotkey,
   avroIdl,
   awk,
   ballerina,
-  basic,
   bash,
+  basic,
   batch,
   bazel,
   bcpl,
-  bicep,
   bibtex,
+  bicep,
   blade,
   bosque,
   bqn,
@@ -14187,8 +14794,8 @@ var languages = [
   coldfusion,
   coq,
   cpp,
-  crystal,
   cql,
+  crystal,
   csharp,
   css,
   cuda,
@@ -14210,6 +14817,7 @@ var languages = [
   ejs,
   elixir,
   elm,
+  emacsLisp,
   erb,
   erlang,
   factor,
@@ -14220,17 +14828,17 @@ var languages = [
   flux,
   forth,
   fortran,
-  freemarker,
   fql,
+  freemarker,
   fsharp,
   fstar,
-  gdscript,
   gcode,
+  gdscript,
   gettext,
   git,
   gleam,
-  gml,
   glsl,
+  gml,
   go,
   gradle,
   grain,
@@ -14257,8 +14865,10 @@ var languages = [
   janet,
   java,
   javascript,
+  jcl,
   jinja,
   jmespath,
+  jq,
   json,
   json5,
   jsonata,
@@ -14274,9 +14884,10 @@ var languages = [
   kql,
   lean,
   less,
+  lex,
   ligo,
-  liquid,
   linkerscript,
+  liquid,
   lisp,
   llvmIr,
   lobster,
@@ -14291,13 +14902,13 @@ var languages = [
   matlab,
   maxima,
   mdx,
+  mercury,
   mermaid,
   meson,
-  mercury,
   metal,
   modelica,
-  mojo,
   modula2,
+  mojo,
   moonbit,
   move,
   mumps,
@@ -14310,10 +14921,10 @@ var languages = [
   nix,
   nunjucks,
   nushell,
+  oberon,
   objectiveC,
   ocaml,
   octave,
-  oberon,
   odin,
   openapi,
   opencl,
@@ -14323,8 +14934,8 @@ var languages = [
   perl,
   php,
   pineScript,
-  plI,
   pkl,
+  plI,
   plantuml,
   plpgsql,
   plsql,
@@ -14336,24 +14947,26 @@ var languages = [
   processing,
   prolog,
   promql,
+  properties,
   protobuf,
   pug,
   puppet,
   purescript,
   python,
-  qml,
   qmake,
+  qml,
   qsharp,
   r,
   racket,
   raku,
   razor,
+  reasonml,
   rebol,
   red,
-  reasonml,
   rego,
   rescript,
   restructuredtext,
+  rexx,
   roc,
   rpg,
   ruby,
@@ -14370,8 +14983,8 @@ var languages = [
   snobol,
   solidity,
   soql,
-  sparql,
   spark,
+  sparql,
   spl,
   spss,
   sql,
@@ -14400,17 +15013,19 @@ var languages = [
   unison,
   v,
   vala,
-  vba,
   vale,
+  vba,
+  vbscript,
   velocity,
   verilog,
   verse,
   vhdl,
+  vimscript,
   visualBasic,
   vue,
   vyper,
-  webassembly,
   wdl,
+  webassembly,
   wgsl,
   wren,
   xaml,
@@ -14418,6 +15033,7 @@ var languages = [
   xpath,
   xquery,
   xslt,
+  yacc,
   yaml,
   yara,
   zeek,
@@ -14426,37 +15042,14 @@ var languages = [
   zsh
 ];
 
-// src/domain/detection/match.ts
-var pathSegmentPattern = /[/\\]/;
-var getBasename = (filename) => {
-  const parts = filename.trim().split(pathSegmentPattern);
-  return parts.at(-1).toLowerCase();
-};
-var matchesExtension = (basename, extension) => {
-  const normalizedExtension = extension.toLowerCase();
-  if (normalizedExtension.startsWith(".")) {
-    return basename.endsWith(normalizedExtension);
-  }
-  return basename === normalizedExtension || basename.endsWith(`.${normalizedExtension}`);
-};
-var detectMatchingEntries = (entries, filename) => {
-  const basename = getBasename(filename);
-  if (!basename) {
-    return [];
-  }
-  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/domain/detection/detect.ts
 var detectLanguages = (filename) => {
   return detectMatchingEntries(languages, filename);
 };
 var detectLanguage = (filename) => detectLanguages(filename).at(0);
+var detectLanguageByShebang = (content) => {
+  const slug = detectLanguageSlugByShebang(content);
+  return slug ? languages.find((language) => language.slug === slug) : void 0;
+};
 
-export { detectLanguage, detectLanguages };
+export { detectLanguage, detectLanguageByShebang, detectLanguageSlugByShebang, detectLanguages };