code-languages 1.29.1 → 1.30.1

package/dist/api.cjs

@@ -2415,6 +2415,45 @@ var init_d = __esm({
   }
 });
 
+// src/languages/dafny.ts
+var dafny_exports = {};
+__export(dafny_exports, {
+  dafny: () => dafny
+});
+var dafny;
+var init_dafny = __esm({
+  "src/languages/dafny.ts"() {
+    dafny = {
+      slug: "dafny",
+      publishedDate: "2009-01-01",
+      extensions: [".dfy"],
+      author: "K. Rustan M. Leino / Microsoft Research",
+      website: "https://dafny.org",
+      paradigms: ["imperative", "functional", "object-oriented", "formal verification"],
+      tooling: {
+        runtimes: [".NET", "Java", "JavaScript", "Go", "Python"],
+        packageManagers: ["NuGet", "Homebrew"],
+        ecosystems: ["Formal Methods", ".NET", "Verification"]
+      },
+      version: "4.11.0",
+      logo: "https://dummyimage.com/32x32/0B6D91/ffffff.png&text=D",
+      color: "#0B6D91",
+      i18n: {
+        en: {
+          name: "Dafny",
+          description: "A verification-aware programming language with specifications, proofs, and compilation to several mainstream targets.",
+          longDescription: "Dafny is a programming language and verifier designed for writing correct-by-construction software. Programs can include preconditions, postconditions, invariants, termination metrics, and assertions that are checked by an automated verifier.\n\nIt combines imperative, functional, and object-oriented features with formal specification syntax. Dafny code can be compiled to targets such as C#, Java, JavaScript, Go, and Python, making it useful for teaching, research, and high-assurance software components."
+        },
+        es: {
+          name: "Dafny",
+          description: "Lenguaje de programacion orientado a verificacion, con especificaciones, pruebas y compilacion a varios destinos comunes.",
+          longDescription: "Dafny es un lenguaje de programacion y verificador pensado para escribir software correcto por construccion. Los programas pueden incluir precondiciones, postcondiciones, invariantes, metricas de terminacion y aserciones que revisa un verificador automatico.\n\nCombina rasgos imperativos, funcionales y orientados a objetos con sintaxis de especificacion formal. El codigo Dafny puede compilarse a destinos como C#, Java, JavaScript, Go y Python."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/dart.ts
 var dart_exports = {};
 __export(dart_exports, {
@@ -2768,6 +2807,45 @@ var init_eiffel = __esm({
   }
 });
 
+// src/languages/ejs.ts
+var ejs_exports = {};
+__export(ejs_exports, {
+  ejs: () => ejs
+});
+var ejs;
+var init_ejs = __esm({
+  "src/languages/ejs.ts"() {
+    ejs = {
+      slug: "ejs",
+      publishedDate: "2011-02-01",
+      extensions: [".ejs"],
+      author: "Matthew Eernisse",
+      website: "https://ejs.co",
+      paradigms: ["template", "embedded", "imperative"],
+      tooling: {
+        runtimes: ["Node.js", "Browser"],
+        packageManagers: ["npm", "pnpm", "Yarn"],
+        ecosystems: ["JavaScript", "Web", "Express"]
+      },
+      version: "3.1.10",
+      logo: "https://cdn.simpleicons.org/ejs/B4CA65",
+      color: "#B4CA65",
+      i18n: {
+        en: {
+          name: "EJS",
+          description: "An embedded JavaScript templating language for generating HTML and text from familiar JavaScript expressions.",
+          longDescription: "EJS, short for Embedded JavaScript, is a templating language that lets developers generate markup with ordinary JavaScript control flow and interpolation. Templates are commonly used to render server-side HTML in Node.js applications.\n\nIt is intentionally small and direct: template files mix literal output with tags for evaluation, escaped output, and unescaped output. EJS is popular in Express applications, documentation generators, and simple build workflows."
+        },
+        es: {
+          name: "EJS",
+          description: "Lenguaje de plantillas con JavaScript embebido para generar HTML y texto usando expresiones familiares.",
+          longDescription: "EJS, abreviatura de Embedded JavaScript, es un lenguaje de plantillas que permite generar marcado con interpolacion y control de flujo de JavaScript. Se usa con frecuencia para renderizar HTML del lado del servidor en aplicaciones Node.js.\n\nEs pequeno y directo: los archivos mezclan salida literal con etiquetas para evaluacion, salida escapada y salida sin escapar. EJS es comun en aplicaciones Express, generadores de documentacion y flujos de build simples."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/elixir.ts
 var elixir_exports = {};
 __export(elixir_exports, {
@@ -3297,6 +3375,45 @@ var init_fortran = __esm({
   }
 });
 
+// src/languages/freemarker.ts
+var freemarker_exports = {};
+__export(freemarker_exports, {
+  freemarker: () => freemarker
+});
+var freemarker;
+var init_freemarker = __esm({
+  "src/languages/freemarker.ts"() {
+    freemarker = {
+      slug: "freemarker",
+      publishedDate: "1999-01-01",
+      extensions: [".ftl", ".ftlh", ".ftlx"],
+      author: "Apache Software Foundation",
+      website: "https://freemarker.apache.org",
+      paradigms: ["template", "declarative"],
+      tooling: {
+        runtimes: ["JVM"],
+        packageManagers: ["Maven", "Gradle"],
+        ecosystems: ["Java", "Web", "Apache"]
+      },
+      version: "2.3.34",
+      logo: "https://dummyimage.com/32x32/326CE5/ffffff.png&text=FM",
+      color: "#326CE5",
+      i18n: {
+        en: {
+          name: "FreeMarker",
+          description: "A JVM template language used to generate HTML, emails, configuration files, and other text output.",
+          longDescription: "Apache FreeMarker is a template engine and template language for Java applications. It separates presentation text from application code and can generate HTML pages, emails, source files, configuration files, and other structured text.\n\nFreeMarker templates use expressions, directives, macros, includes, and data-model access rather than embedding Java code directly. It is common in server-side Java web applications and code generation workflows."
+        },
+        es: {
+          name: "FreeMarker",
+          description: "Lenguaje de plantillas para la JVM usado para generar HTML, correos, configuracion y otras salidas de texto.",
+          longDescription: "Apache FreeMarker es un motor y lenguaje de plantillas para aplicaciones Java. Separa el texto de presentacion del codigo de aplicacion y puede generar paginas HTML, correos, codigo fuente, archivos de configuracion y otros textos estructurados.\n\nLas plantillas FreeMarker usan expresiones, directivas, macros, inclusiones y acceso a modelos de datos en lugar de embeber codigo Java directamente."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/fsharp.ts
 var fsharp_exports = {};
 __export(fsharp_exports, {
@@ -3356,6 +3473,45 @@ var init_fsharp = __esm({
   }
 });
 
+// src/languages/fstar.ts
+var fstar_exports = {};
+__export(fstar_exports, {
+  fstar: () => fstar
+});
+var fstar;
+var init_fstar = __esm({
+  "src/languages/fstar.ts"() {
+    fstar = {
+      slug: "fstar",
+      publishedDate: "2011-01-01",
+      extensions: [".fst", ".fsti"],
+      author: "Microsoft Research / INRIA",
+      website: "https://www.fstar-lang.org",
+      paradigms: ["functional", "dependent types", "formal verification"],
+      tooling: {
+        runtimes: ["F* toolchain", "OCaml", "F#", "C"],
+        packageManagers: ["opam", "NuGet"],
+        ecosystems: ["Formal Methods", "ML", "Low-level Verification"]
+      },
+      version: "2026.04.17",
+      logo: "https://dummyimage.com/32x32/572E91/ffffff.png&text=F%2A",
+      color: "#572E91",
+      i18n: {
+        en: {
+          name: "F*",
+          description: "A dependently typed functional language for program verification, proofs, and extraction to executable code.",
+          longDescription: "F* is a verification-oriented functional language with dependent types, refinement types, effects, and proof automation. It is used to specify and verify functional correctness, security properties, and low-level systems code.\n\nPrograms and proofs can be checked by the F* toolchain and extracted to targets such as OCaml, F#, and C through related tooling. The language is used in research and high-assurance projects where executable code and machine-checked proofs need to stay close together."
+        },
+        es: {
+          name: "F*",
+          description: "Lenguaje funcional con tipos dependientes para verificacion de programas, pruebas y extraccion a codigo ejecutable.",
+          longDescription: "F* es un lenguaje funcional orientado a verificacion con tipos dependientes, tipos refinados, efectos y automatizacion de pruebas. Se usa para especificar y verificar correccion funcional, propiedades de seguridad y codigo de sistemas de bajo nivel.\n\nLos programas y pruebas se revisan con la cadena de herramientas de F* y pueden extraerse a destinos como OCaml, F# y C mediante herramientas relacionadas."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/gdscript.ts
 var gdscript_exports = {};
 __export(gdscript_exports, {
@@ -4644,6 +4800,44 @@ var init_ini = __esm({
   }
 });
 
+// src/languages/isabelle.ts
+var isabelle_exports = {};
+__export(isabelle_exports, {
+  isabelle: () => isabelle
+});
+var isabelle;
+var init_isabelle = __esm({
+  "src/languages/isabelle.ts"() {
+    isabelle = {
+      slug: "isabelle",
+      publishedDate: "1986-01-01",
+      extensions: [".thy"],
+      author: "Lawrence Paulson / University of Cambridge and TU Munich",
+      website: "https://isabelle.in.tum.de",
+      paradigms: ["theorem proving", "declarative", "functional"],
+      tooling: {
+        runtimes: ["Isabelle/jEdit", "Poly/ML", "Scala"],
+        ecosystems: ["Formal Methods", "Proof Assistants", "Higher-order Logic"]
+      },
+      version: "Isabelle2025-2",
+      logo: "https://dummyimage.com/32x32/6A5ACD/ffffff.png&text=Is",
+      color: "#6A5ACD",
+      i18n: {
+        en: {
+          name: "Isabelle",
+          description: "A proof assistant and theory language for machine-checked mathematics, logic, and formal verification.",
+          longDescription: "Isabelle is a generic proof assistant with a rich theory language used to develop machine-checked mathematics and formal verification projects. Its most common object logic is Isabelle/HOL, a higher-order logic used in many academic and industrial verification efforts.\n\nIsabelle theory files combine definitions, lemmas, structured Isar proofs, automation, and document-oriented markup. The system includes an IDE, libraries, code generation support, and integrations with external automated provers."
+        },
+        es: {
+          name: "Isabelle",
+          description: "Asistente de pruebas y lenguaje de teorias para matematica, logica y verificacion formal comprobadas por maquina.",
+          longDescription: "Isabelle es un asistente de pruebas generico con un lenguaje de teorias usado para desarrollar matematica comprobada por maquina y proyectos de verificacion formal. Su logica objeto mas comun es Isabelle/HOL, una logica de orden superior usada en muchos trabajos academicos e industriales.\n\nLos archivos de teoria combinan definiciones, lemas, pruebas estructuradas Isar, automatizacion y marcado orientado a documentos."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/janet.ts
 var janet_exports = {};
 __export(janet_exports, {
@@ -4993,6 +5187,44 @@ var init_json5 = __esm({
   }
 });
 
+// src/languages/jsonc.ts
+var jsonc_exports = {};
+__export(jsonc_exports, {
+  jsonc: () => jsonc
+});
+var jsonc;
+var init_jsonc = __esm({
+  "src/languages/jsonc.ts"() {
+    jsonc = {
+      slug: "jsonc",
+      publishedDate: "2015-04-29",
+      extensions: [".jsonc", ".code-workspace"],
+      author: "Microsoft",
+      website: "https://jsonc.org",
+      paradigms: ["data serialization", "configuration"],
+      tooling: {
+        runtimes: ["Editors", "Build tools"],
+        ecosystems: ["JavaScript", "TypeScript", "Configuration"]
+      },
+      version: "JSON with Comments",
+      logo: "https://raw.githubusercontent.com/vscode-icons/vscode-icons/master/icons/file_type_json.svg",
+      color: "#F5DE19",
+      i18n: {
+        en: {
+          name: "JSONC",
+          description: "A JSON-compatible configuration format that permits JavaScript-style comments and optional editor-friendly extensions.",
+          longDescription: "JSONC, or JSON with Comments, is a JSON-derived configuration format that allows comments while preserving the familiar JSON data model. It is widely recognized because Visual Studio Code uses it for settings, launch configurations, and workspace files.\n\nThe format is intended for human-maintained configuration rather than data interchange between services. Tooling usually parses JSONC into ordinary JSON-like values after stripping comments and handling the accepted extensions."
+        },
+        es: {
+          name: "JSONC",
+          description: "Formato de configuracion compatible con JSON que permite comentarios estilo JavaScript y extensiones amigables para editores.",
+          longDescription: "JSONC, o JSON con comentarios, es un formato de configuracion derivado de JSON que permite comentarios sin abandonar el modelo de datos familiar. Es muy conocido porque Visual Studio Code lo usa en ajustes, configuraciones de ejecucion y archivos de workspace.\n\nEsta pensado para configuracion mantenida por humanos, no para intercambio de datos entre servicios. Las herramientas suelen convertir JSONC a valores similares a JSON tras quitar comentarios."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/jsonnet.ts
 var jsonnet_exports = {};
 __export(jsonnet_exports, {
@@ -5170,6 +5402,45 @@ var init_jupyter_notebook = __esm({
   }
 });
 
+// src/languages/just.ts
+var just_exports = {};
+__export(just_exports, {
+  just: () => just
+});
+var just;
+var init_just = __esm({
+  "src/languages/just.ts"() {
+    just = {
+      slug: "just",
+      publishedDate: "2016-03-13",
+      extensions: ["justfile", "Justfile", ".just"],
+      author: "Casey Rodarmor",
+      website: "https://just.systems",
+      paradigms: ["task automation", "command runner"],
+      tooling: {
+        runtimes: ["just"],
+        packageManagers: ["Cargo", "Homebrew", "Scoop"],
+        ecosystems: ["CLI", "Build Automation", "DevOps"]
+      },
+      version: "1.44.0",
+      logo: "https://raw.githubusercontent.com/vscode-icons/vscode-icons/master/icons/file_type_just.svg",
+      color: "#384D54",
+      i18n: {
+        en: {
+          name: "Just",
+          description: "A command-runner language for project recipes, task automation, and repeatable developer workflows.",
+          longDescription: "Just is a command runner whose justfile syntax defines named recipes for common project tasks. It is often used as a friendlier alternative to ad hoc shell scripts or make targets when dependency graph semantics are not needed.\n\nRecipes can accept parameters, set variables, choose shells, load dotenv files, and compose other recipes. The format is popular for local development workflows, CI helpers, release commands, and cross-platform project automation."
+        },
+        es: {
+          name: "Just",
+          description: "Lenguaje de recetas para ejecutar comandos de proyecto, automatizar tareas y repetir flujos de desarrollo.",
+          longDescription: "Just es un ejecutor de comandos cuya sintaxis justfile define recetas con nombre para tareas comunes del proyecto. Se usa como alternativa mas amable a scripts shell dispersos o targets de make cuando no se necesita un grafo de dependencias.\n\nLas recetas pueden aceptar parametros, definir variables, elegir shells, cargar archivos dotenv y componer otras recetas. Es comun en desarrollo local, ayudas de CI, comandos de release y automatizacion multiplataforma."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/kcl.ts
 var kcl_exports = {};
 __export(kcl_exports, {
@@ -5229,6 +5500,44 @@ var init_kcl = __esm({
   }
 });
 
+// src/languages/kdl.ts
+var kdl_exports = {};
+__export(kdl_exports, {
+  kdl: () => kdl
+});
+var kdl;
+var init_kdl = __esm({
+  "src/languages/kdl.ts"() {
+    kdl = {
+      slug: "kdl",
+      publishedDate: "2021-08-29",
+      extensions: [".kdl"],
+      author: "Kat Marchan and contributors",
+      website: "https://kdl.dev",
+      paradigms: ["configuration", "document language", "data serialization"],
+      tooling: {
+        runtimes: ["Parsers", "CLI tools"],
+        ecosystems: ["Configuration", "Rust", "Structured Documents"]
+      },
+      version: "2.0.0",
+      logo: "https://dummyimage.com/32x32/6B4E9B/ffffff.png&text=KDL",
+      color: "#6B4E9B",
+      i18n: {
+        en: {
+          name: "KDL",
+          description: "A node-based document language for readable configuration, structured data, and tree-shaped documents.",
+          longDescription: "KDL is a document language built around named nodes with arguments, properties, and nested children. Its syntax is designed to be easier to read and edit by hand than many dense data formats while still mapping cleanly to structured data.\n\nIt is used for configuration files, domain-specific documents, and tools that need comments, ordering, and tree-shaped data. The KDL ecosystem includes parsers for multiple languages and a versioned specification."
+        },
+        es: {
+          name: "KDL",
+          description: "Lenguaje documental basado en nodos para configuracion legible, datos estructurados y documentos en forma de arbol.",
+          longDescription: "KDL es un lenguaje documental basado en nodos con argumentos, propiedades e hijos anidados. Su sintaxis busca ser mas facil de leer y editar a mano que muchos formatos densos, sin perder una correspondencia clara con datos estructurados.\n\nSe usa para archivos de configuracion, documentos especificos de dominio y herramientas que necesitan comentarios, orden y datos en forma de arbol."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/kotlin.ts
 var kotlin_exports = {};
 __export(kotlin_exports, {
@@ -5249,7 +5558,7 @@ var init_kotlin = __esm({
         packageManagers: ["Gradle", "Maven"],
         ecosystems: ["JVM", "Android", "Kotlin Multiplatform"]
       },
-      version: "2.3.21",
+      version: "2.4.0",
       logo: "https://upload.wikimedia.org/wikipedia/commons/7/74/Kotlin_Icon.png",
       color: "#7F52FF",
       i18n: {
@@ -6987,6 +7296,45 @@ var init_odin = __esm({
   }
 });
 
+// src/languages/openapi.ts
+var openapi_exports = {};
+__export(openapi_exports, {
+  openapi: () => openapi
+});
+var openapi;
+var init_openapi = __esm({
+  "src/languages/openapi.ts"() {
+    openapi = {
+      slug: "openapi",
+      publishedDate: "2011-08-10",
+      extensions: [".openapi.json", ".openapi.yaml", ".openapi.yml"],
+      author: "OpenAPI Initiative",
+      website: "https://www.openapis.org",
+      paradigms: ["api description", "schema", "declarative"],
+      tooling: {
+        runtimes: ["OpenAPI tooling"],
+        packageManagers: ["npm", "Maven", "Docker"],
+        ecosystems: ["HTTP APIs", "REST", "Documentation"]
+      },
+      version: "3.2.0",
+      logo: "https://cdn.simpleicons.org/openapiinitiative/6BA539",
+      color: "#6BA539",
+      i18n: {
+        en: {
+          name: "OpenAPI",
+          description: "A language-neutral specification format for describing HTTP APIs, schemas, operations, and documentation.",
+          longDescription: "OpenAPI is a specification format for describing HTTP APIs in a machine-readable and human-readable way. OpenAPI documents define paths, operations, parameters, request bodies, responses, authentication, reusable components, and schema information.\n\nThe format is commonly written in YAML or JSON and powers API documentation, client and server generation, contract testing, governance, and design workflows. It originated as Swagger and is now maintained by the OpenAPI Initiative."
+        },
+        es: {
+          name: "OpenAPI",
+          description: "Formato de especificacion neutral al lenguaje para describir APIs HTTP, esquemas, operaciones y documentacion.",
+          longDescription: "OpenAPI es un formato de especificacion para describir APIs HTTP de manera legible para maquinas y personas. Los documentos OpenAPI definen rutas, operaciones, parametros, cuerpos de solicitud, respuestas, autenticacion, componentes reutilizables e informacion de esquemas.\n\nSuele escribirse en YAML o JSON y alimenta documentacion de APIs, generacion de clientes y servidores, pruebas de contrato, gobierno y flujos de diseno."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/opencl.ts
 var opencl_exports = {};
 __export(opencl_exports, {
@@ -7809,6 +8157,45 @@ var init_pug = __esm({
   }
 });
 
+// src/languages/puppet.ts
+var puppet_exports = {};
+__export(puppet_exports, {
+  puppet: () => puppet
+});
+var puppet;
+var init_puppet = __esm({
+  "src/languages/puppet.ts"() {
+    puppet = {
+      slug: "puppet",
+      publishedDate: "2005-01-01",
+      extensions: [".pp", ".epp"],
+      author: "Luke Kanies / Puppet, Inc.",
+      website: "https://www.puppet.com/docs/puppet/latest/lang_summary",
+      paradigms: ["declarative", "configuration management", "infrastructure as code"],
+      tooling: {
+        runtimes: ["Puppet Agent", "Puppet Server"],
+        packageManagers: ["Puppet Forge", "r10k", "Code Manager"],
+        ecosystems: ["DevOps", "Infrastructure as Code", "Configuration Management"]
+      },
+      version: "Puppet 8",
+      logo: "https://cdn.simpleicons.org/puppet/FFAE1A",
+      color: "#FFAE1A",
+      i18n: {
+        en: {
+          name: "Puppet",
+          description: "A declarative infrastructure language for describing system resources, configuration state, and reusable modules.",
+          longDescription: "The Puppet language describes desired infrastructure state using resources, classes, defined types, variables, conditionals, and modules. Puppet agents apply catalogs compiled from this language to converge systems toward the declared configuration.\n\nIt is used for configuration management, compliance, provisioning, and infrastructure automation across servers and services. The language favors declarative resource relationships over imperative shell-style steps."
+        },
+        es: {
+          name: "Puppet",
+          description: "Lenguaje declarativo de infraestructura para describir recursos del sistema, estado de configuracion y modulos reutilizables.",
+          longDescription: "El lenguaje Puppet describe el estado deseado de la infraestructura mediante recursos, clases, tipos definidos, variables, condicionales y modulos. Los agentes Puppet aplican catalogos compilados desde este lenguaje para converger los sistemas hacia la configuracion declarada.\n\nSe usa para gestion de configuracion, cumplimiento, aprovisionamiento y automatizacion de infraestructura en servidores y servicios."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/purescript.ts
 var purescript_exports = {};
 __export(purescript_exports, {
@@ -11359,12 +11746,14 @@ init_cue();
 init_cypher();
 init_cython();
 init_d();
+init_dafny();
 init_dart();
 init_dhall();
 init_dita();
 init_dockerfile();
 init_earthly();
 init_eiffel();
+init_ejs();
 init_elixir();
 init_elm();
 init_erb();
@@ -11374,7 +11763,9 @@ init_fish();
 init_flux();
 init_forth();
 init_fortran();
+init_freemarker();
 init_fsharp();
+init_fstar();
 init_gdscript();
 init_git();
 init_gleam();
@@ -11397,16 +11788,20 @@ init_html();
 init_hy();
 init_idris();
 init_ini();
+init_isabelle();
 init_janet();
 init_java();
 init_javascript();
 init_jinja();
 init_json();
 init_json5();
+init_jsonc();
 init_jsonnet();
 init_julia();
 init_jupyter_notebook();
+init_just();
 init_kcl();
+init_kdl();
 init_kotlin();
 init_lean();
 init_less();
@@ -11437,6 +11832,7 @@ init_nushell();
 init_objective_c();
 init_ocaml();
 init_odin();
+init_openapi();
 init_opencl();
 init_pascal();
 init_perl();
@@ -11451,6 +11847,7 @@ init_prolog();
 init_promql();
 init_protobuf();
 init_pug();
+init_puppet();
 init_purescript();
 init_python();
 init_qml();
@@ -11553,10 +11950,12 @@ var languages = [
   cuda,
   cython,
   d,
+  dafny,
   dart,
   dhall,
   dita,
   dockerfile,
+  ejs,
   eiffel,
   earthly,
   elixir,
@@ -11566,9 +11965,11 @@ var languages = [
   fish,
   fennel,
   flux,
+  freemarker,
   fortran,
   forth,
   fsharp,
+  fstar,
   gdscript,
   git,
   gleam,
@@ -11591,16 +11992,20 @@ var languages = [
   hy,
   idris,
   ini,
+  isabelle,
   java,
   javascript,
   janet,
   jinja,
   json,
   json5,
+  jsonc,
   jsonnet,
   jupyterNotebook,
   julia,
+  just,
   kcl,
+  kdl,
   kotlin,
   lean,
   less,
@@ -11633,6 +12038,7 @@ var languages = [
   objectiveC,
   odin,
   opencl,
+  openapi,
   pascal,
   pkl,
   perl,
@@ -11646,6 +12052,7 @@ var languages = [
   promql,
   protobuf,
   pug,
+  puppet,
   purescript,
   python,
   qml,
@@ -11756,10 +12163,12 @@ var languageIndex = [
   { slug: "cuda", extensions: [".cu", ".cuh"] },
   { slug: "cython", extensions: [".pyx", ".pxd", ".pxi"] },
   { slug: "d", extensions: [".d", ".di"] },
+  { slug: "dafny", extensions: [".dfy"] },
   { slug: "dart", extensions: [".dart"] },
   { slug: "dhall", extensions: [".dhall"] },
   { slug: "dita", extensions: [".dita", ".ditamap", ".ditaval"] },
   { slug: "dockerfile", extensions: ["Dockerfile", ".dockerfile"] },
+  { slug: "ejs", extensions: [".ejs"] },
   { slug: "eiffel", extensions: [".e"] },
   { slug: "earthly", extensions: ["Earthfile"] },
   { slug: "elixir", extensions: [".ex", ".exs", ".eex", ".leex", ".heex"] },
@@ -11772,12 +12181,14 @@ var languageIndex = [
   { slug: "fish", extensions: [".fish"] },
   { slug: "fennel", extensions: [".fnl"] },
   { slug: "flux", extensions: [".flux"] },
+  { slug: "freemarker", extensions: [".ftl", ".ftlh", ".ftlx"] },
   {
     slug: "fortran",
     extensions: [".f", ".for", ".ftn", ".f90", ".f95", ".f03", ".f08", ".f18", ".f23"]
   },
   { slug: "forth", extensions: [".fs", ".fth", ".forth", ".4th"] },
   { slug: "fsharp", extensions: [".fs", ".fsi", ".fsx", ".fsscript"] },
+  { slug: "fstar", extensions: [".fst", ".fsti"] },
   { slug: "gdscript", extensions: [".gd"] },
   { slug: "git", extensions: [".git", ".gitignore", ".gitattributes", ".gitmodules", ".gitkeep"] },
   { slug: "gleam", extensions: [".gleam"] },
@@ -11803,16 +12214,20 @@ var languageIndex = [
   { slug: "hy", extensions: [".hy"] },
   { slug: "idris", extensions: [".idr", ".lidr", ".ipkg"] },
   { slug: "ini", extensions: [".ini"] },
+  { slug: "isabelle", extensions: [".thy"] },
   { slug: "java", extensions: [".java"] },
   { slug: "javascript", extensions: [".js", ".mjs", ".cjs", ".jsx"] },
   { slug: "janet", extensions: [".janet", ".jdn"] },
   { slug: "jinja", extensions: [".jinja", ".jinja2", ".j2"] },
   { slug: "json", extensions: [".json"] },
   { slug: "json5", extensions: [".json5"] },
+  { slug: "jsonc", extensions: [".jsonc", ".code-workspace"] },
   { slug: "jsonnet", extensions: [".jsonnet", ".libsonnet"] },
   { slug: "jupyter-notebook", extensions: [".ipynb"] },
   { slug: "julia", extensions: [".jl"] },
+  { slug: "just", extensions: ["justfile", "Justfile", ".just"] },
   { slug: "kcl", extensions: [".k", ".kcl"] },
+  { slug: "kdl", extensions: [".kdl"] },
   { slug: "kotlin", extensions: [".kt", ".kts"] },
   { slug: "lean", extensions: [".lean"] },
   { slug: "less", extensions: [".less"] },
@@ -11845,6 +12260,7 @@ var languageIndex = [
   { slug: "objective-c", extensions: [".m", ".mm"] },
   { slug: "odin", extensions: [".odin"] },
   { slug: "opencl", extensions: [".cl", ".clh"] },
+  { slug: "openapi", extensions: [".openapi.json", ".openapi.yaml", ".openapi.yml"] },
   { slug: "pascal", extensions: [".pas", ".pp", ".inc", ".lpr", ".dpr", ".dfm"] },
   { slug: "pkl", extensions: [".pkl"] },
   { slug: "perl", extensions: [".pl", ".pm", ".pod", ".t", ".psgi"] },
@@ -11858,6 +12274,7 @@ var languageIndex = [
   { slug: "promql", extensions: [".promql"] },
   { slug: "protobuf", extensions: [".proto"] },
   { slug: "pug", extensions: [".pug", ".jade"] },
+  { slug: "puppet", extensions: [".pp", ".epp"] },
   { slug: "purescript", extensions: [".purs"] },
   { slug: "python", extensions: [".py", ".pyw"] },
   { slug: "qml", extensions: [".qml", ".qmltypes", ".qmlproject"] },
@@ -11966,10 +12383,12 @@ var languageLoaders = {
   cuda: () => Promise.resolve().then(() => (init_cuda(), cuda_exports)).then((module) => module.cuda),
   cython: () => Promise.resolve().then(() => (init_cython(), cython_exports)).then((module) => module.cython),
   d: () => Promise.resolve().then(() => (init_d(), d_exports)).then((module) => module.d),
+  dafny: () => Promise.resolve().then(() => (init_dafny(), dafny_exports)).then((module) => module.dafny),
   dart: () => Promise.resolve().then(() => (init_dart(), dart_exports)).then((module) => module.dart),
   dhall: () => Promise.resolve().then(() => (init_dhall(), dhall_exports)).then((module) => module.dhall),
   dita: () => Promise.resolve().then(() => (init_dita(), dita_exports)).then((module) => module.dita),
   dockerfile: () => Promise.resolve().then(() => (init_dockerfile(), dockerfile_exports)).then((module) => module.dockerfile),
+  ejs: () => Promise.resolve().then(() => (init_ejs(), ejs_exports)).then((module) => module.ejs),
   eiffel: () => Promise.resolve().then(() => (init_eiffel(), eiffel_exports)).then((module) => module.eiffel),
   earthly: () => Promise.resolve().then(() => (init_earthly(), earthly_exports)).then((module) => module.earthly),
   elixir: () => Promise.resolve().then(() => (init_elixir(), elixir_exports)).then((module) => module.elixir),
@@ -11979,9 +12398,11 @@ var languageLoaders = {
   fish: () => Promise.resolve().then(() => (init_fish(), fish_exports)).then((module) => module.fish),
   flux: () => Promise.resolve().then(() => (init_flux(), flux_exports)).then((module) => module.flux),
   fennel: () => Promise.resolve().then(() => (init_fennel(), fennel_exports)).then((module) => module.fennel),
+  freemarker: () => Promise.resolve().then(() => (init_freemarker(), freemarker_exports)).then((module) => module.freemarker),
   fortran: () => Promise.resolve().then(() => (init_fortran(), fortran_exports)).then((module) => module.fortran),
   forth: () => Promise.resolve().then(() => (init_forth(), forth_exports)).then((module) => module.forth),
   fsharp: () => Promise.resolve().then(() => (init_fsharp(), fsharp_exports)).then((module) => module.fsharp),
+  fstar: () => Promise.resolve().then(() => (init_fstar(), fstar_exports)).then((module) => module.fstar),
   gdscript: () => Promise.resolve().then(() => (init_gdscript(), gdscript_exports)).then((module) => module.gdscript),
   git: () => Promise.resolve().then(() => (init_git(), git_exports)).then((module) => module.git),
   gleam: () => Promise.resolve().then(() => (init_gleam(), gleam_exports)).then((module) => module.gleam),
@@ -12004,16 +12425,20 @@ var languageLoaders = {
   hy: () => Promise.resolve().then(() => (init_hy(), hy_exports)).then((module) => module.hy),
   idris: () => Promise.resolve().then(() => (init_idris(), idris_exports)).then((module) => module.idris),
   ini: () => Promise.resolve().then(() => (init_ini(), ini_exports)).then((module) => module.ini),
+  isabelle: () => Promise.resolve().then(() => (init_isabelle(), isabelle_exports)).then((module) => module.isabelle),
   java: () => Promise.resolve().then(() => (init_java(), java_exports)).then((module) => module.java),
   javascript: () => Promise.resolve().then(() => (init_javascript(), javascript_exports)).then((module) => module.javascript),
   janet: () => Promise.resolve().then(() => (init_janet(), janet_exports)).then((module) => module.janet),
   jinja: () => Promise.resolve().then(() => (init_jinja(), jinja_exports)).then((module) => module.jinja),
   json: () => Promise.resolve().then(() => (init_json(), json_exports)).then((module) => module.json),
   json5: () => Promise.resolve().then(() => (init_json5(), json5_exports)).then((module) => module.json5),
+  jsonc: () => Promise.resolve().then(() => (init_jsonc(), jsonc_exports)).then((module) => module.jsonc),
   jsonnet: () => Promise.resolve().then(() => (init_jsonnet(), jsonnet_exports)).then((module) => module.jsonnet),
   "jupyter-notebook": () => Promise.resolve().then(() => (init_jupyter_notebook(), jupyter_notebook_exports)).then((module) => module.jupyterNotebook),
   julia: () => Promise.resolve().then(() => (init_julia(), julia_exports)).then((module) => module.julia),
+  just: () => Promise.resolve().then(() => (init_just(), just_exports)).then((module) => module.just),
   kcl: () => Promise.resolve().then(() => (init_kcl(), kcl_exports)).then((module) => module.kcl),
+  kdl: () => Promise.resolve().then(() => (init_kdl(), kdl_exports)).then((module) => module.kdl),
   kotlin: () => Promise.resolve().then(() => (init_kotlin(), kotlin_exports)).then((module) => module.kotlin),
   lean: () => Promise.resolve().then(() => (init_lean(), lean_exports)).then((module) => module.lean),
   less: () => Promise.resolve().then(() => (init_less(), less_exports)).then((module) => module.less),
@@ -12046,6 +12471,7 @@ var languageLoaders = {
   "objective-c": () => Promise.resolve().then(() => (init_objective_c(), objective_c_exports)).then((module) => module.objectiveC),
   odin: () => Promise.resolve().then(() => (init_odin(), odin_exports)).then((module) => module.odin),
   opencl: () => Promise.resolve().then(() => (init_opencl(), opencl_exports)).then((module) => module.opencl),
+  openapi: () => Promise.resolve().then(() => (init_openapi(), openapi_exports)).then((module) => module.openapi),
   pascal: () => Promise.resolve().then(() => (init_pascal(), pascal_exports)).then((module) => module.pascal),
   pkl: () => Promise.resolve().then(() => (init_pkl(), pkl_exports)).then((module) => module.pkl),
   perl: () => Promise.resolve().then(() => (init_perl(), perl_exports)).then((module) => module.perl),
@@ -12059,6 +12485,7 @@ var languageLoaders = {
   promql: () => Promise.resolve().then(() => (init_promql(), promql_exports)).then((module) => module.promql),
   protobuf: () => Promise.resolve().then(() => (init_protobuf(), protobuf_exports)).then((module) => module.protobuf),
   pug: () => Promise.resolve().then(() => (init_pug(), pug_exports)).then((module) => module.pug),
+  puppet: () => Promise.resolve().then(() => (init_puppet(), puppet_exports)).then((module) => module.puppet),
   purescript: () => Promise.resolve().then(() => (init_purescript(), purescript_exports)).then((module) => module.purescript),
   python: () => Promise.resolve().then(() => (init_python(), python_exports)).then((module) => module.python),
   qml: () => Promise.resolve().then(() => (init_qml(), qml_exports)).then((module) => module.qml),