code-languages 1.32.1 → 1.33.0

package/dist/api.js

@@ -3035,7 +3035,7 @@ var init_eiffel = __esm({
         ecosystems: ["Enterprise", "Systems"]
       },
       version: "24.05",
-      logo: "https://www.eiffel.org/images/eiffel_logo.png",
+      logo: "https://commons.wikimedia.org/wiki/Special:FilePath/Eiffel_logo.svg",
       color: "#4D6977",
       i18n: {
         en: {
@@ -4838,7 +4838,7 @@ var init_hocon = __esm({
         ecosystems: ["JVM", "Scala", "Akka", "Play Framework", "Configuration"]
       },
       version: "1.4.3",
-      logo: "https://www.lightbend.com/assets/images/brand/lightbend-icon-reverse.svg",
+      logo: "https://dummyimage.com/32x32/F26822/ffffff.png&text=HC",
       color: "#F26822",
       i18n: {
         en: {
@@ -5492,7 +5492,7 @@ var init_json5 = __esm({
         ecosystems: ["Configuration", "Web", "Node.js"]
       },
       version: "2.2.3",
-      logo: "https://json5.org/assets/logo.svg",
+      logo: "https://dummyimage.com/32x32/267CB9/ffffff.png&text=J5",
       color: "#267CB9",
       i18n: {
         en: {
@@ -6274,6 +6274,82 @@ var init_llvm_ir = __esm({
   }
 });
 
+// src/languages/lobster.ts
+var lobster_exports = {};
+__export(lobster_exports, {
+  lobster: () => lobster
+});
+var lobster;
+var init_lobster = __esm({
+  "src/languages/lobster.ts"() {
+    lobster = {
+      slug: "lobster",
+      publishedDate: "2014-01-01",
+      extensions: [".lobster"],
+      author: "Wouter van Oortmerssen",
+      website: "https://strlen.com/lobster/",
+      paradigms: ["functional", "imperative", "game-development"],
+      tooling: {
+        runtimes: ["Lobster compiler"],
+        ecosystems: ["Games", "Interactive Graphics", "Language Experiments"]
+      },
+      version: "development snapshot",
+      logo: "https://dummyimage.com/32x32/DC2626/ffffff.png&text=Lo",
+      color: "#DC2626",
+      i18n: {
+        en: {
+          name: "Lobster",
+          description: "A statically typed language for games and graphical applications with fast iteration.",
+          longDescription: "Lobster is a statically typed programming language designed for game programming, interactive graphics, and rapid iteration. It combines functional-style values with imperative code and a compiler intended to keep feedback loops short.\n\nIts ecosystem is small, but the language is useful as a compact environment for prototypes, graphics experiments, and language design work focused on games and real-time programs."
+        },
+        es: {
+          name: "Lobster",
+          description: "Lenguaje tipado estaticamente para juegos y aplicaciones graficas con iteracion rapida.",
+          longDescription: "Lobster es un lenguaje de programacion tipado estaticamente para juegos, graficos interactivos e iteracion rapida. Combina valores de estilo funcional con codigo imperativo y un compilador pensado para ciclos de feedback cortos.\n\nSu ecosistema es pequeno, pero sirve para prototipos, experimentos graficos y trabajo de diseno de lenguajes orientado a programas en tiempo real."
+        }
+      }
+    };
+  }
+});
+
+// src/languages/logo.ts
+var logo_exports = {};
+__export(logo_exports, {
+  logo: () => logo
+});
+var logo;
+var init_logo = __esm({
+  "src/languages/logo.ts"() {
+    logo = {
+      slug: "logo",
+      publishedDate: "1967-01-01",
+      extensions: [".logo", ".lgo"],
+      author: "Wally Feurzeig, Seymour Papert, and Cynthia Solomon",
+      website: "https://people.eecs.berkeley.edu/~bh/logo.html",
+      paradigms: ["educational", "procedural", "interactive"],
+      tooling: {
+        runtimes: ["UCBLogo", "FMSLogo", "Logo interpreters"],
+        ecosystems: ["Education", "Turtle Graphics", "Creative Coding"]
+      },
+      version: "UCBLogo 6.2",
+      logo: "https://dummyimage.com/32x32/16A34A/ffffff.png&text=Lg",
+      color: "#16A34A",
+      i18n: {
+        en: {
+          name: "Logo",
+          description: "An educational language known for turtle graphics, interactivity, and procedural ideas.",
+          longDescription: "Logo is an educational programming language created to help learners explore procedures, recursion, geometry, and interactive problem solving. Its turtle graphics model made programming visual and concrete for generations of students.\n\nLogo dialects are still used in teaching, creative coding, and language-history contexts where immediate feedback and simple commands make computational ideas easier to explore."
+        },
+        es: {
+          name: "Logo",
+          description: "Lenguaje educativo conocido por graficos de tortuga, interactividad e ideas procedurales.",
+          longDescription: "Logo es un lenguaje educativo creado para explorar procedimientos, recursion, geometria y resolucion interactiva de problemas. Su modelo de graficos de tortuga hizo la programacion visual y concreta para generaciones de estudiantes.\n\nSus dialectos siguen presentes en ensenanza, codigo creativo e historia de lenguajes, donde el feedback inmediato facilita explorar ideas computacionales."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/lua.ts
 var lua_exports = {};
 __export(lua_exports, {
@@ -6739,6 +6815,45 @@ var init_mdx = __esm({
   }
 });
 
+// src/languages/mercury.ts
+var mercury_exports = {};
+__export(mercury_exports, {
+  mercury: () => mercury
+});
+var mercury;
+var init_mercury = __esm({
+  "src/languages/mercury.ts"() {
+    mercury = {
+      slug: "mercury",
+      publishedDate: "1995-04-08",
+      extensions: [".m"],
+      author: "University of Melbourne",
+      website: "https://www.mercurylang.org",
+      paradigms: ["logic", "functional", "declarative"],
+      tooling: {
+        runtimes: ["Melbourne Mercury Compiler"],
+        packageManagers: ["mmc build tooling"],
+        ecosystems: ["Logic Programming", "Declarative Systems", "Academic Computing"]
+      },
+      version: "22.01.8",
+      logo: "https://dummyimage.com/32x32/0891B2/ffffff.png&text=Me",
+      color: "#0891B2",
+      i18n: {
+        en: {
+          name: "Mercury",
+          description: "A pure logic and functional language with strong static typing and determinism analysis.",
+          longDescription: "Mercury is a declarative programming language that combines logic programming with functional programming, strong static typing, modes, and determinism analysis. It aims to make logic programs more reliable and efficient for larger software.\n\nMercury is used in research, compiler work, and specialized systems where Prolog-like relations benefit from compile-time checks, explicit module structure, and predictable execution behavior."
+        },
+        es: {
+          name: "Mercury",
+          description: "Lenguaje logico y funcional puro con tipado estatico fuerte y analisis de determinismo.",
+          longDescription: "Mercury es un lenguaje declarativo que combina programacion logica y funcional con tipado estatico fuerte, modos y analisis de determinismo. Busca que programas de estilo logico sean mas fiables y eficientes en software grande.\n\nSe usa en investigacion, compiladores y sistemas especializados donde relaciones estilo Prolog se benefician de chequeos en compilacion, modulos explicitos y ejecucion predecible."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/mermaid.ts
 var mermaid_exports = {};
 __export(mermaid_exports, {
@@ -6915,6 +7030,44 @@ var init_metal = __esm({
   }
 });
 
+// src/languages/modula-2.ts
+var modula_2_exports = {};
+__export(modula_2_exports, {
+  modula2: () => modula2
+});
+var modula2;
+var init_modula_2 = __esm({
+  "src/languages/modula-2.ts"() {
+    modula2 = {
+      slug: "modula-2",
+      publishedDate: "1978-01-01",
+      extensions: [".mod", ".def"],
+      author: "Niklaus Wirth",
+      website: "https://www.modula2.org",
+      paradigms: ["imperative", "procedural", "modular"],
+      tooling: {
+        runtimes: ["GNU Modula-2", "ADW Modula-2", "Classic compilers"],
+        ecosystems: ["Systems Programming", "Education", "Language History"]
+      },
+      version: "ISO/IEC 10514-1:1996",
+      logo: "https://dummyimage.com/32x32/2563EB/ffffff.png&text=M2",
+      color: "#2563EB",
+      i18n: {
+        en: {
+          name: "Modula-2",
+          description: "A modular systems language from Niklaus Wirth with explicit interfaces and modules.",
+          longDescription: "Modula-2 was designed as a successor to Pascal for systems programming and teaching. It emphasizes separate compilation, explicit definition modules, strong typing, coroutines, and structured imperative programming.\n\nThe language influenced later modular languages and remains relevant in compiler history, embedded systems, and educational settings where clear module boundaries and small language design matter."
+        },
+        es: {
+          name: "Modula-2",
+          description: "Lenguaje modular de sistemas de Niklaus Wirth con interfaces y modulos explicitos.",
+          longDescription: "Modula-2 fue disenado como sucesor de Pascal para sistemas y ensenanza. Enfatiza compilacion separada, modulos de definicion explicitos, tipado fuerte, corrutinas y programacion imperativa estructurada.\n\nInfluyo en lenguajes modulares posteriores y sigue siendo relevante en historia de compiladores, sistemas embebidos y contextos educativos."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/mojo.ts
 var mojo_exports = {};
 __export(mojo_exports, {
@@ -7111,7 +7264,7 @@ var init_mustache = __esm({
         ecosystems: ["Web", "Node.js", "Ruby", "Python", "Java", "Go"]
       },
       version: "1.0",
-      logo: "https://mustache.github.io/images/mustache.png",
+      logo: "https://commons.wikimedia.org/wiki/Special:FilePath/Mustache-js-logo.png",
       color: "#974A01",
       i18n: {
         en: {
@@ -7404,7 +7557,7 @@ var init_nunjucks = __esm({
         ecosystems: ["Web", "Node.js", "Static Sites"]
       },
       version: "3.2.4",
-      logo: "https://mozilla.github.io/nunjucks/img/nunjucks-logo.png",
+      logo: "https://cdn.simpleicons.org/nunjucks/1C4A1C",
       color: "#1C4A1C",
       i18n: {
         en: {
@@ -7463,7 +7616,7 @@ var init_nushell = __esm({
         ecosystems: ["Shell", "Unix", "Windows", "macOS"]
       },
       version: "0.113.1",
-      logo: "https://www.nushell.sh/icons/android-chrome-512x512.png",
+      logo: "https://cdn.simpleicons.org/nushell/3AA675",
       color: "#3AA675",
       i18n: {
         en: {
@@ -7501,6 +7654,44 @@ var init_nushell = __esm({
   }
 });
 
+// src/languages/oberon.ts
+var oberon_exports = {};
+__export(oberon_exports, {
+  oberon: () => oberon
+});
+var oberon;
+var init_oberon = __esm({
+  "src/languages/oberon.ts"() {
+    oberon = {
+      slug: "oberon",
+      publishedDate: "1987-01-01",
+      extensions: [".ob", ".mod"],
+      author: "Niklaus Wirth",
+      website: "https://people.inf.ethz.ch/wirth/Oberon/",
+      paradigms: ["imperative", "procedural", "modular"],
+      tooling: {
+        runtimes: ["Oberon System", "Oxford Oberon-2 compiler", "Classic compilers"],
+        ecosystems: ["Operating Systems", "Education", "Language Design"]
+      },
+      version: "Oberon-2",
+      logo: "https://dummyimage.com/32x32/0F766E/ffffff.png&text=Ob",
+      color: "#0F766E",
+      i18n: {
+        en: {
+          name: "Oberon",
+          description: "A compact Pascal-family language with modules, type extension, and system roots.",
+          longDescription: "Oberon is a compact language and operating-system project created by Niklaus Wirth and Jurg Gutknecht. The language simplifies Modula-2 while adding type extension and a small, strongly typed module system.\n\nOberon is important in operating-system research, compiler construction, and teaching because it shows how a small language, compiler, and environment can form a coherent software system."
+        },
+        es: {
+          name: "Oberon",
+          description: "Lenguaje compacto de la familia Pascal con modulos, extension de tipos y raices de sistema.",
+          longDescription: "Oberon es un lenguaje y proyecto de sistema operativo creado por Niklaus Wirth y Jurg Gutknecht. Simplifica Modula-2 y agrega extension de tipos junto con un sistema de modulos pequeno y fuertemente tipado.\n\nEs importante en investigacion de sistemas operativos, construccion de compiladores y ensenanza porque muestra como lenguaje, compilador y entorno pueden formar un sistema coherente."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/objective-c.ts
 var objective_c_exports = {};
 __export(objective_c_exports, {
@@ -8069,6 +8260,44 @@ var init_pkl = __esm({
   }
 });
 
+// src/languages/pl-i.ts
+var pl_i_exports = {};
+__export(pl_i_exports, {
+  plI: () => plI
+});
+var plI;
+var init_pl_i = __esm({
+  "src/languages/pl-i.ts"() {
+    plI = {
+      slug: "pl-i",
+      publishedDate: "1964-01-01",
+      extensions: [".pli", ".pl1"],
+      author: "IBM",
+      website: "https://www.ibm.com/products/pli-compiler-aix",
+      paradigms: ["imperative", "procedural", "structured"],
+      tooling: {
+        runtimes: ["IBM Enterprise PL/I", "Open PL/I compilers"],
+        ecosystems: ["Mainframe", "Enterprise", "Scientific Computing"]
+      },
+      version: "Enterprise PL/I 6.2",
+      logo: "https://dummyimage.com/32x32/1F2937/ffffff.png&text=PL1",
+      color: "#1F2937",
+      i18n: {
+        en: {
+          name: "PL/I",
+          description: "An IBM language combining business, scientific, and systems programming features.",
+          longDescription: "PL/I was designed by IBM to cover business data processing, scientific computing, and systems programming in one language. It combines block structure, strong data-description facilities, exceptions, concurrency features, and rich numeric support.\n\nPL/I remains associated with mainframe and enterprise systems, where long-lived applications depend on its data handling, batch processing, and compatibility with IBM tooling."
+        },
+        es: {
+          name: "PL/I",
+          description: "Lenguaje de IBM que combina rasgos de programacion empresarial, cientifica y de sistemas.",
+          longDescription: "PL/I fue disenado por IBM para cubrir procesamiento empresarial, computacion cientifica y programacion de sistemas en un solo lenguaje. Combina estructura de bloques, descripciones de datos, excepciones, concurrencia y soporte numerico amplio.\n\nSigue asociado a mainframes y sistemas empresariales donde aplicaciones de larga vida dependen de su manejo de datos, procesos batch y herramientas IBM."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/plantuml.ts
 var plantuml_exports = {};
 __export(plantuml_exports, {
@@ -9109,6 +9338,82 @@ var init_reasonml = __esm({
   }
 });
 
+// src/languages/rebol.ts
+var rebol_exports = {};
+__export(rebol_exports, {
+  rebol: () => rebol
+});
+var rebol;
+var init_rebol = __esm({
+  "src/languages/rebol.ts"() {
+    rebol = {
+      slug: "rebol",
+      publishedDate: "1997-01-01",
+      extensions: [".r", ".reb", ".rebol"],
+      author: "Carl Sassenrath",
+      website: "https://www.rebol.com",
+      paradigms: ["functional", "dataflow", "scripting"],
+      tooling: {
+        runtimes: ["REBOL 2", "Rebol 3", "Ren-C"],
+        ecosystems: ["Scripting", "DSLs", "Network Tools"]
+      },
+      version: "Rebol 3",
+      logo: "https://dummyimage.com/32x32/7C2D12/ffffff.png&text=Re",
+      color: "#7C2D12",
+      i18n: {
+        en: {
+          name: "Rebol",
+          description: "A compact messaging language built around code-as-data blocks and dialects.",
+          longDescription: "Rebol is a small language created around the idea of relative expressions, blocks as data, and domain-specific dialects. Its syntax makes structured data and executable code share one compact representation.\n\nRebol has been used for network utilities, GUIs, automation, lightweight data exchange, and DSL experiments. Its influence is visible in Red and other languages interested in homoiconic, message-oriented scripting."
+        },
+        es: {
+          name: "Rebol",
+          description: "Lenguaje compacto de mensajeria basado en bloques de codigo como datos y dialectos.",
+          longDescription: "Rebol es un lenguaje pequeno creado alrededor de expresiones relativas, bloques como datos y dialectos especificos de dominio. Su sintaxis hace que datos estructurados y codigo ejecutable compartan una representacion compacta.\n\nSe ha usado en utilidades de red, GUIs, automatizacion, intercambio ligero de datos y experimentos de DSL. Su influencia se ve en Red y otros lenguajes de scripting homoiconico."
+        }
+      }
+    };
+  }
+});
+
+// src/languages/red.ts
+var red_exports = {};
+__export(red_exports, {
+  red: () => red
+});
+var red;
+var init_red = __esm({
+  "src/languages/red.ts"() {
+    red = {
+      slug: "red",
+      publishedDate: "2011-02-26",
+      extensions: [".red", ".reds"],
+      author: "Nenad Rakocevic",
+      website: "https://www.red-lang.org",
+      paradigms: ["imperative", "functional", "symbolic"],
+      tooling: {
+        runtimes: ["Red toolchain", "Red/System"],
+        ecosystems: ["Scripting", "GUI Applications", "Systems Experiments"]
+      },
+      version: "0.6.6",
+      logo: "https://static.red-lang.org/red-logo.svg",
+      color: "#F00000",
+      i18n: {
+        en: {
+          name: "Red",
+          description: "A Rebol-inspired language spanning high-level scripting and low-level Red/System code.",
+          longDescription: "Red is a language inspired by Rebol that aims to cover a broad range from symbolic high-level scripting to lower-level systems programming through Red/System. It emphasizes compact syntax, DSL-friendly data notation, and GUI-oriented workflows.\n\nThe project is used for scripts, small desktop tools, experiments, and applications that benefit from homoiconic data, concise notation, and a single distribution with compiler and runtime pieces."
+        },
+        es: {
+          name: "Red",
+          description: "Lenguaje inspirado en Rebol que cubre scripting de alto nivel y codigo Red/System.",
+          longDescription: "Red es un lenguaje inspirado en Rebol que busca cubrir desde scripting simbolico de alto nivel hasta programacion de sistemas con Red/System. Enfatiza sintaxis compacta, notacion de datos apta para DSLs y flujos orientados a GUI.\n\nSe usa en scripts, herramientas pequenas de escritorio, experimentos y apps que aprovechan datos homoiconicos, notacion concisa y una distribucion con compilador y runtime."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/rego.ts
 var rego_exports = {};
 __export(rego_exports, {
@@ -9286,6 +9591,45 @@ var init_restructuredtext = __esm({
   }
 });
 
+// src/languages/roc.ts
+var roc_exports = {};
+__export(roc_exports, {
+  roc: () => roc
+});
+var roc;
+var init_roc = __esm({
+  "src/languages/roc.ts"() {
+    roc = {
+      slug: "roc",
+      publishedDate: "2021-01-01",
+      extensions: [".roc"],
+      author: "Richard Feldman and contributors",
+      website: "https://www.roc-lang.org",
+      paradigms: ["functional", "pure", "static"],
+      tooling: {
+        runtimes: ["Roc compiler"],
+        packageManagers: ["Roc packages"],
+        ecosystems: ["CLI Tools", "WebAssembly", "Functional Programming"]
+      },
+      version: "development snapshot",
+      logo: "https://avatars.githubusercontent.com/u/96867701?v=4",
+      color: "#7C3AED",
+      i18n: {
+        en: {
+          name: "Roc",
+          description: "A fast, pure functional language focused on friendly syntax and platform-based apps.",
+          longDescription: "Roc is a pure functional programming language focused on fast execution, approachable syntax, static typing, and a platform model where hosts provide capabilities to applications. It aims to make functional programming practical for command-line tools, services, and WebAssembly.\n\nThe language is still evolving, but its design explores abilities, automatic memory management without tracing GC pauses, and packaging workflows that separate application code from platform code."
+        },
+        es: {
+          name: "Roc",
+          description: "Lenguaje funcional puro y rapido con sintaxis amigable y apps basadas en plataformas.",
+          longDescription: "Roc es un lenguaje funcional puro enfocado en ejecucion rapida, sintaxis accesible, tipado estatico y un modelo de plataformas donde el host provee capacidades a las aplicaciones. Busca hacer practica la programacion funcional para CLIs, servicios y WebAssembly.\n\nEl lenguaje sigue evolucionando, pero explora abilities, manejo automatico de memoria sin pausas de GC por trazado y paquetes que separan codigo de app y plataforma."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/ruby.ts
 var ruby_exports = {};
 __export(ruby_exports, {
@@ -9638,6 +9982,44 @@ var init_scss = __esm({
   }
 });
 
+// src/languages/self.ts
+var self_exports = {};
+__export(self_exports, {
+  self: () => self
+});
+var self;
+var init_self = __esm({
+  "src/languages/self.ts"() {
+    self = {
+      slug: "self",
+      publishedDate: "1987-01-01",
+      extensions: [".self"],
+      author: "David Ungar and Randall Smith",
+      website: "https://selflanguage.org",
+      paradigms: ["prototype-based", "object-oriented", "dynamic"],
+      tooling: {
+        runtimes: ["Self VM"],
+        ecosystems: ["Language Research", "Interactive Environments", "Prototype OO"]
+      },
+      version: "2024.1",
+      logo: "https://dummyimage.com/32x32/EA580C/ffffff.png&text=Se",
+      color: "#EA580C",
+      i18n: {
+        en: {
+          name: "Self",
+          description: "A prototype-based object language that influenced JavaScript, VM design, and live IDEs.",
+          longDescription: "Self is a dynamic object-oriented language based on prototypes and message passing rather than classes. It was created as a research language for exploring object systems, live programming environments, and high-performance dynamic dispatch.\n\nSelf influenced JavaScript, Smalltalk VM work, adaptive optimization, and interactive development systems where objects can be inspected, changed, and extended while the program is running."
+        },
+        es: {
+          name: "Self",
+          description: "Lenguaje de objetos basado en prototipos que influyo en JavaScript, VMs e IDEs vivos.",
+          longDescription: "Self es un lenguaje orientado a objetos dinamico basado en prototipos y envio de mensajes, no en clases. Fue creado como lenguaje de investigacion para explorar sistemas de objetos, entornos vivos y dispatch dinamico de alto rendimiento.\n\nInfluyo en JavaScript, trabajo de VMs de Smalltalk, optimizacion adaptativa y entornos interactivos donde los objetos pueden inspeccionarse y cambiarse mientras el programa corre."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/smalltalk.ts
 var smalltalk_exports = {};
 __export(smalltalk_exports, {
@@ -12263,6 +12645,8 @@ init_less();
 init_liquid();
 init_lisp();
 init_llvm_ir();
+init_lobster();
+init_logo();
 init_lua();
 init_luau();
 init_makefile();
@@ -12271,9 +12655,11 @@ init_markdown();
 init_mathematica();
 init_matlab();
 init_mdx();
+init_mercury();
 init_mermaid();
 init_meson();
 init_metal();
+init_modula_2();
 init_mojo();
 init_moonbit();
 init_move();
@@ -12284,6 +12670,7 @@ init_nim();
 init_nix();
 init_nunjucks();
 init_nushell();
+init_oberon();
 init_objective_c();
 init_ocaml();
 init_odin();
@@ -12294,6 +12681,7 @@ init_perl();
 init_php();
 init_pine_script();
 init_pkl();
+init_pl_i();
 init_plantuml();
 init_plsql();
 init_pony();
@@ -12312,15 +12700,19 @@ init_racket();
 init_raku();
 init_razor();
 init_reasonml();
+init_rebol();
+init_red();
 init_rego();
 init_rescript();
 init_restructuredtext();
+init_roc();
 init_ruby();
 init_rust();
 init_sas();
 init_scala();
 init_scheme();
 init_scss();
+init_self();
 init_smalltalk();
 init_smarty();
 init_solidity();
@@ -12478,6 +12870,8 @@ var languages = [
   liquid,
   lisp,
   llvmIr,
+  lobster,
+  logo,
   lua,
   luau,
   makefile,
@@ -12488,8 +12882,10 @@ var languages = [
   mdx,
   mermaid,
   meson,
+  mercury,
   metal,
   mojo,
+  modula2,
   moonbit,
   move,
   mustache,
@@ -12501,6 +12897,7 @@ var languages = [
   nushell,
   objectiveC,
   ocaml,
+  oberon,
   odin,
   openapi,
   opencl,
@@ -12508,6 +12905,7 @@ var languages = [
   perl,
   php,
   pineScript,
+  plI,
   pkl,
   plantuml,
   plsql,
@@ -12526,16 +12924,20 @@ var languages = [
   racket,
   raku,
   razor,
+  rebol,
+  red,
   reasonml,
   rego,
   rescript,
   restructuredtext,
+  roc,
   ruby,
   rust,
   sas,
   scala,
   scheme,
   scss,
+  self,
   smalltalk,
   smarty,
   solidity,
@@ -12708,6 +13110,8 @@ var languageIndex = [
   { slug: "liquid", extensions: [".liquid"] },
   { slug: "lisp", extensions: [".lisp", ".lsp", ".cl", ".asd"] },
   { slug: "llvm-ir", extensions: [".ll", ".bc"] },
+  { slug: "lobster", extensions: [".lobster"] },
+  { slug: "logo", extensions: [".logo", ".lgo"] },
   { slug: "lua", extensions: [".lua", ".rockspec"] },
   { slug: "luau", extensions: [".luau"] },
   { slug: "makefile", extensions: ["Makefile", "makefile", "GNUmakefile", ".mk", ".mak"] },
@@ -12718,8 +13122,10 @@ var languageIndex = [
   { slug: "mdx", extensions: [".mdx"] },
   { slug: "mermaid", extensions: [".mmd", ".mermaid"] },
   { slug: "meson", extensions: ["meson.build", "meson_options.txt", "meson.options", ".wrap"] },
+  { slug: "mercury", extensions: [".m"] },
   { slug: "metal", extensions: [".metal"] },
   { slug: "mojo", extensions: [".mojo"] },
+  { slug: "modula-2", extensions: [".mod", ".def"] },
   { slug: "moonbit", extensions: [".mbt"] },
   { slug: "move", extensions: [".move"] },
   { slug: "mustache", extensions: [".mustache", ".mst"] },
@@ -12731,6 +13137,7 @@ var languageIndex = [
   { slug: "nushell", extensions: [".nu"] },
   { slug: "objective-c", extensions: [".m", ".mm"] },
   { slug: "ocaml", extensions: [".ml", ".mli", ".mll", ".mly", ".mlt", ".eliom", ".eliomi"] },
+  { slug: "oberon", extensions: [".ob", ".mod"] },
   { slug: "odin", extensions: [".odin"] },
   { slug: "openapi", extensions: [".openapi.json", ".openapi.yaml", ".openapi.yml"] },
   { slug: "opencl", extensions: [".cl", ".clh"] },
@@ -12738,6 +13145,7 @@ var languageIndex = [
   { slug: "perl", extensions: [".pl", ".pm", ".pod", ".t", ".psgi"] },
   { slug: "php", extensions: [".php", ".phtml", ".php3", ".php4", ".php5", ".phps"] },
   { slug: "pine-script", extensions: [".pine"] },
+  { slug: "pl-i", extensions: [".pli", ".pl1"] },
   { slug: "pkl", extensions: [".pkl"] },
   { slug: "plantuml", extensions: [".puml", ".plantuml", ".iuml"] },
   { slug: "plsql", extensions: [".pls", ".pks", ".pkb", ".plsql"] },
@@ -12756,10 +13164,13 @@ var languageIndex = [
   { slug: "racket", extensions: [".rkt", ".rktd", ".rktl", ".scrbl"] },
   { slug: "raku", extensions: [".raku", ".rakumod", ".rakudoc", ".rakutest", ".p6", ".pm6"] },
   { slug: "razor", extensions: [".cshtml", ".razor"] },
+  { slug: "rebol", extensions: [".r", ".reb", ".rebol"] },
+  { slug: "red", extensions: [".red", ".reds"] },
   { slug: "reasonml", extensions: [".re", ".rei"] },
   { slug: "rego", extensions: [".rego"] },
   { slug: "rescript", extensions: [".res", ".resi"] },
   { slug: "restructuredtext", extensions: [".rst", ".rest"] },
+  { slug: "roc", extensions: [".roc"] },
   {
     slug: "ruby",
     extensions: [".rb", ".rbw", ".rake", ".gemspec", "Gemfile", "Rakefile", "config.ru"]
@@ -12769,6 +13180,7 @@ var languageIndex = [
   { slug: "scala", extensions: [".scala", ".sc"] },
   { slug: "scheme", extensions: [".scm", ".ss", ".sld", ".sls"] },
   { slug: "scss", extensions: [".scss", ".sass"] },
+  { slug: "self", extensions: [".self"] },
   { slug: "smalltalk", extensions: [".st"] },
   { slug: "smarty", extensions: [".tpl", ".smarty"] },
   { slug: "solidity", extensions: [".sol"] },
@@ -12930,6 +13342,8 @@ var languageLoaders = {
   liquid: () => Promise.resolve().then(() => (init_liquid(), liquid_exports)).then((module) => module.liquid),
   lisp: () => Promise.resolve().then(() => (init_lisp(), lisp_exports)).then((module) => module.lisp),
   "llvm-ir": () => Promise.resolve().then(() => (init_llvm_ir(), llvm_ir_exports)).then((module) => module.llvmIr),
+  lobster: () => Promise.resolve().then(() => (init_lobster(), lobster_exports)).then((module) => module.lobster),
+  logo: () => Promise.resolve().then(() => (init_logo(), logo_exports)).then((module) => module.logo),
   lua: () => Promise.resolve().then(() => (init_lua(), lua_exports)).then((module) => module.lua),
   luau: () => Promise.resolve().then(() => (init_luau(), luau_exports)).then((module) => module.luau),
   makefile: () => Promise.resolve().then(() => (init_makefile(), makefile_exports)).then((module) => module.makefile),
@@ -12940,8 +13354,10 @@ var languageLoaders = {
   mdx: () => Promise.resolve().then(() => (init_mdx(), mdx_exports)).then((module) => module.mdx),
   mermaid: () => Promise.resolve().then(() => (init_mermaid(), mermaid_exports)).then((module) => module.mermaid),
   meson: () => Promise.resolve().then(() => (init_meson(), meson_exports)).then((module) => module.meson),
+  mercury: () => Promise.resolve().then(() => (init_mercury(), mercury_exports)).then((module) => module.mercury),
   metal: () => Promise.resolve().then(() => (init_metal(), metal_exports)).then((module) => module.metal),
   mojo: () => Promise.resolve().then(() => (init_mojo(), mojo_exports)).then((module) => module.mojo),
+  "modula-2": () => Promise.resolve().then(() => (init_modula_2(), modula_2_exports)).then((module) => module.modula2),
   moonbit: () => Promise.resolve().then(() => (init_moonbit(), moonbit_exports)).then((module) => module.moonbit),
   move: () => Promise.resolve().then(() => (init_move(), move_exports)).then((module) => module.move),
   mustache: () => Promise.resolve().then(() => (init_mustache(), mustache_exports)).then((module) => module.mustache),
@@ -12953,6 +13369,7 @@ var languageLoaders = {
   nushell: () => Promise.resolve().then(() => (init_nushell(), nushell_exports)).then((module) => module.nushell),
   "objective-c": () => Promise.resolve().then(() => (init_objective_c(), objective_c_exports)).then((module) => module.objectiveC),
   ocaml: () => Promise.resolve().then(() => (init_ocaml(), ocaml_exports)).then((module) => module.ocaml),
+  oberon: () => Promise.resolve().then(() => (init_oberon(), oberon_exports)).then((module) => module.oberon),
   odin: () => Promise.resolve().then(() => (init_odin(), odin_exports)).then((module) => module.odin),
   openapi: () => Promise.resolve().then(() => (init_openapi(), openapi_exports)).then((module) => module.openapi),
   opencl: () => Promise.resolve().then(() => (init_opencl(), opencl_exports)).then((module) => module.opencl),
@@ -12960,6 +13377,7 @@ var languageLoaders = {
   perl: () => Promise.resolve().then(() => (init_perl(), perl_exports)).then((module) => module.perl),
   php: () => Promise.resolve().then(() => (init_php(), php_exports)).then((module) => module.php),
   "pine-script": () => Promise.resolve().then(() => (init_pine_script(), pine_script_exports)).then((module) => module.pineScript),
+  "pl-i": () => Promise.resolve().then(() => (init_pl_i(), pl_i_exports)).then((module) => module.plI),
   pkl: () => Promise.resolve().then(() => (init_pkl(), pkl_exports)).then((module) => module.pkl),
   plantuml: () => Promise.resolve().then(() => (init_plantuml(), plantuml_exports)).then((module) => module.plantuml),
   plsql: () => Promise.resolve().then(() => (init_plsql(), plsql_exports)).then((module) => module.plsql),
@@ -12978,16 +13396,20 @@ var languageLoaders = {
   racket: () => Promise.resolve().then(() => (init_racket(), racket_exports)).then((module) => module.racket),
   raku: () => Promise.resolve().then(() => (init_raku(), raku_exports)).then((module) => module.raku),
   razor: () => Promise.resolve().then(() => (init_razor(), razor_exports)).then((module) => module.razor),
+  rebol: () => Promise.resolve().then(() => (init_rebol(), rebol_exports)).then((module) => module.rebol),
+  red: () => Promise.resolve().then(() => (init_red(), red_exports)).then((module) => module.red),
   reasonml: () => Promise.resolve().then(() => (init_reasonml(), reasonml_exports)).then((module) => module.reasonml),
   rego: () => Promise.resolve().then(() => (init_rego(), rego_exports)).then((module) => module.rego),
   rescript: () => Promise.resolve().then(() => (init_rescript(), rescript_exports)).then((module) => module.rescript),
   restructuredtext: () => Promise.resolve().then(() => (init_restructuredtext(), restructuredtext_exports)).then((module) => module.restructuredtext),
+  roc: () => Promise.resolve().then(() => (init_roc(), roc_exports)).then((module) => module.roc),
   ruby: () => Promise.resolve().then(() => (init_ruby(), ruby_exports)).then((module) => module.ruby),
   rust: () => Promise.resolve().then(() => (init_rust(), rust_exports)).then((module) => module.rust),
   sas: () => Promise.resolve().then(() => (init_sas(), sas_exports)).then((module) => module.sas),
   scala: () => Promise.resolve().then(() => (init_scala(), scala_exports)).then((module) => module.scala),
   scheme: () => Promise.resolve().then(() => (init_scheme(), scheme_exports)).then((module) => module.scheme),
   scss: () => Promise.resolve().then(() => (init_scss(), scss_exports)).then((module) => module.scss),
+  self: () => Promise.resolve().then(() => (init_self(), self_exports)).then((module) => module.self),
   smalltalk: () => Promise.resolve().then(() => (init_smalltalk(), smalltalk_exports)).then((module) => module.smalltalk),
   smarty: () => Promise.resolve().then(() => (init_smarty(), smarty_exports)).then((module) => module.smarty),
   solidity: () => Promise.resolve().then(() => (init_solidity(), solidity_exports)).then((module) => module.solidity),