code-languages 1.16.1 → 1.18.0

package/dist/api.cjs

@@ -387,6 +387,44 @@ var init_batch = __esm({
   }
 });
 
+// src/languages/bicep.ts
+var bicep_exports = {};
+__export(bicep_exports, {
+  bicep: () => bicep
+});
+var bicep;
+var init_bicep = __esm({
+  "src/languages/bicep.ts"() {
+    bicep = {
+      slug: "bicep",
+      publishedDate: "2020-09-01",
+      extensions: [".bicep", ".bicepparam"],
+      author: "Microsoft",
+      website: "https://github.com/Azure/bicep",
+      paradigms: ["declarative", "infrastructure-as-code", "configuration"],
+      tooling: {
+        runtimes: ["Azure Resource Manager"],
+        packageManagers: ["Azure Verified Modules", "Bicep Registry"],
+        ecosystems: ["Azure", "Cloud", "DevOps", "Infrastructure as Code"]
+      },
+      version: "0.43.8",
+      logo: "https://cdn.jsdelivr.net/gh/homarr-labs/dashboard-icons/svg/azure-bicep.svg",
+      i18n: {
+        en: {
+          name: "Bicep",
+          description: "A declarative language for describing Azure infrastructure as code.",
+          longDescription: "Bicep is a domain-specific language for authoring Azure Resource Manager deployments with a concise syntax, modules, parameters, symbolic names, loops, conditions, and type-aware tooling. It compiles to ARM templates while giving authors a friendlier source format.\n\nIt is used for repeatable Azure infrastructure deployments, platform engineering, cloud governance, reusable modules, CI/CD provisioning, and environment-specific resource definitions."
+        },
+        es: {
+          name: "Bicep",
+          description: "Un lenguaje declarativo para describir infraestructura de Azure como codigo.",
+          longDescription: "Bicep es un lenguaje de dominio especifico para crear despliegues de Azure Resource Manager con sintaxis concisa, modulos, parametros, nombres simbolicos, bucles, condiciones y tooling con tipos. Compila a plantillas ARM y ofrece un formato fuente mas comodo.\n\nSe usa para despliegues repetibles de infraestructura en Azure, platform engineering, gobierno cloud, modulos reutilizables, aprovisionamiento en CI/CD y definiciones de recursos por entorno."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/c.ts
 var c_exports = {};
 __export(c_exports, {
@@ -760,6 +798,44 @@ var init_cuda = __esm({
   }
 });
 
+// src/languages/cue.ts
+var cue_exports = {};
+__export(cue_exports, {
+  cue: () => cue
+});
+var cue;
+var init_cue = __esm({
+  "src/languages/cue.ts"() {
+    cue = {
+      slug: "cue",
+      publishedDate: "2019-02-27",
+      extensions: [".cue"],
+      author: "Marcel van Lohuizen / CUE contributors",
+      website: "https://cue.dev",
+      paradigms: ["declarative", "constraint-based", "data-validation", "configuration"],
+      tooling: {
+        runtimes: ["CUE CLI", "Go"],
+        packageManagers: ["Go modules"],
+        ecosystems: ["Configuration", "Validation", "Kubernetes", "DevOps"]
+      },
+      version: "0.16.1",
+      logo: "https://avatars.githubusercontent.com/u/43867057?s=200&v=4",
+      i18n: {
+        en: {
+          name: "CUE",
+          description: "A constraint-based language for configuration, data validation, and generation.",
+          longDescription: "CUE combines configuration data, schemas, validation rules, and policy constraints in one language. Its values can be incomplete, unified, exported, and checked against structural constraints, making it useful for managing complex data definitions.\n\nIt is used with Kubernetes manifests, JSON, YAML, OpenAPI, Protobuf, CI configuration, infrastructure definitions, and systems that need one source of truth for data shape and validation."
+        },
+        es: {
+          name: "CUE",
+          description: "Un lenguaje basado en restricciones para configuracion, validacion y generacion de datos.",
+          longDescription: "CUE combina datos de configuracion, esquemas, reglas de validacion y restricciones de politica en un solo lenguaje. Sus valores pueden estar incompletos, unificarse, exportarse y comprobarse contra restricciones estructurales, lo que ayuda a gestionar definiciones de datos complejas.\n\nSe usa con manifiestos Kubernetes, JSON, YAML, OpenAPI, Protobuf, configuracion de CI, definiciones de infraestructura y sistemas que necesitan una fuente unica para forma y validacion de datos."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/d.ts
 var d_exports = {};
 __export(d_exports, {
@@ -1101,6 +1177,44 @@ var init_fsharp = __esm({
   }
 });
 
+// src/languages/gdscript.ts
+var gdscript_exports = {};
+__export(gdscript_exports, {
+  gdscript: () => gdscript
+});
+var gdscript;
+var init_gdscript = __esm({
+  "src/languages/gdscript.ts"() {
+    gdscript = {
+      slug: "gdscript",
+      publishedDate: "2014-12-15",
+      extensions: [".gd"],
+      author: "Juan Linietsky, Ariel Manzur / Godot contributors",
+      website: "https://docs.godotengine.org/en/stable/tutorials/scripting/gdscript/",
+      paradigms: ["object-oriented", "imperative", "event-driven", "scripting"],
+      tooling: {
+        runtimes: ["Godot Engine"],
+        packageManagers: ["Godot Asset Library"],
+        ecosystems: ["Game Development", "2D Games", "3D Games"]
+      },
+      version: "4.6",
+      logo: "https://cdn.simpleicons.org/godotengine/478CBF",
+      i18n: {
+        en: {
+          name: "GDScript",
+          description: "Godot Engine's integrated scripting language for gameplay and editor logic.",
+          longDescription: "GDScript is a high-level scripting language built for Godot Engine. It uses indentation-based syntax, dynamic and optional static typing, signals, scene-node integration, coroutines, resources, and editor-aware tooling tailored to game development.\n\nIt is used to implement gameplay, UI behavior, tools, animation logic, prototypes, editor plugins, and scripts that interact closely with Godot scenes and engine APIs."
+        },
+        es: {
+          name: "GDScript",
+          description: "El lenguaje de scripting integrado de Godot Engine para gameplay y logica de editor.",
+          longDescription: "GDScript es un lenguaje de scripting de alto nivel creado para Godot Engine. Usa sintaxis basada en indentacion, tipado dinamico y estatico opcional, senales, integracion con nodos de escena, corrutinas, recursos y tooling del editor orientado al desarrollo de juegos.\n\nSe usa para implementar gameplay, comportamiento de UI, herramientas, logica de animacion, prototipos, plugins del editor y scripts que interactuan de cerca con escenas y APIs de Godot."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/git.ts
 var git_exports = {};
 __export(git_exports, {
@@ -1366,6 +1480,44 @@ var init_groovy = __esm({
   }
 });
 
+// src/languages/handlebars.ts
+var handlebars_exports = {};
+__export(handlebars_exports, {
+  handlebars: () => handlebars
+});
+var handlebars;
+var init_handlebars = __esm({
+  "src/languages/handlebars.ts"() {
+    handlebars = {
+      slug: "handlebars",
+      publishedDate: "2010-07-01",
+      extensions: [".hbs", ".handlebars"],
+      author: "Yehuda Katz / Handlebars contributors",
+      website: "https://handlebarsjs.com",
+      paradigms: ["templating", "declarative", "logic-less"],
+      tooling: {
+        runtimes: ["Node.js", "Browser"],
+        packageManagers: ["npm", "Yarn", "pnpm"],
+        ecosystems: ["Web", "Email Templates", "Static Sites"]
+      },
+      version: "4.7.9",
+      logo: "https://cdn.simpleicons.org/handlebarsdotjs/000000",
+      i18n: {
+        en: {
+          name: "Handlebars",
+          description: "A logic-light template language for rendering HTML and text from data.",
+          longDescription: "Handlebars is a template language and JavaScript runtime that extends Mustache with helpers, block expressions, partials, precompilation, and escaping. It keeps templates focused on presentation while letting helpers supply reusable behavior.\n\nIt is used for server-rendered HTML, client-side views, static site generation, transactional email, documentation tools, and build systems that need predictable text generation from structured data."
+        },
+        es: {
+          name: "Handlebars",
+          description: "Un lenguaje de plantillas con poca logica para renderizar HTML y texto desde datos.",
+          longDescription: "Handlebars es un lenguaje de plantillas y runtime JavaScript que extiende Mustache con helpers, expresiones de bloque, partials, precompilacion y escapado. Mantiene las plantillas centradas en la presentacion y deja que los helpers aporten comportamiento reutilizable.\n\nSe usa para HTML renderizado en servidor, vistas de cliente, generacion de sitios estaticos, email transaccional, herramientas de documentacion y sistemas de build que generan texto desde datos estructurados."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/haskell.ts
 var haskell_exports = {};
 __export(haskell_exports, {
@@ -1625,6 +1777,44 @@ var init_javascript = __esm({
   }
 });
 
+// src/languages/jinja.ts
+var jinja_exports = {};
+__export(jinja_exports, {
+  jinja: () => jinja
+});
+var jinja;
+var init_jinja = __esm({
+  "src/languages/jinja.ts"() {
+    jinja = {
+      slug: "jinja",
+      publishedDate: "2008-07-17",
+      extensions: [".jinja", ".jinja2", ".j2"],
+      author: "Armin Ronacher / Pallets",
+      website: "https://jinja.palletsprojects.com",
+      paradigms: ["templating", "declarative", "server-side", "scripting"],
+      tooling: {
+        runtimes: ["Python"],
+        packageManagers: ["pip", "Poetry", "uv"],
+        ecosystems: ["Python", "Flask", "Ansible", "Web"]
+      },
+      version: "3.1.6",
+      logo: "https://cdn.simpleicons.org/jinja/B41717",
+      i18n: {
+        en: {
+          name: "Jinja",
+          description: "A Python template language used for web views, automation, and configuration.",
+          longDescription: "Jinja is a template engine for Python with inheritance, blocks, includes, macros, filters, tests, autoescaping, sandboxing, and whitespace control. Its syntax is expressive enough for reusable views while keeping application logic outside templates.\n\nIt is widely used in Flask applications, Ansible templates, static site generators, documentation systems, email rendering, configuration generation, and automation workflows."
+        },
+        es: {
+          name: "Jinja",
+          description: "Un lenguaje de plantillas para Python usado en vistas web, automatizacion y configuracion.",
+          longDescription: "Jinja es un motor de plantillas para Python con herencia, bloques, includes, macros, filtros, tests, autoescapado, sandboxing y control de espacios. Su sintaxis permite vistas reutilizables sin llevar la logica de aplicacion a las plantillas.\n\nSe usa ampliamente en aplicaciones Flask, plantillas de Ansible, generadores de sitios estaticos, sistemas de documentacion, renderizado de email, generacion de configuracion y flujos de automatizacion."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/json.ts
 var json_exports = {};
 __export(json_exports, {
@@ -1810,6 +2000,44 @@ var init_less = __esm({
   }
 });
 
+// src/languages/liquid.ts
+var liquid_exports = {};
+__export(liquid_exports, {
+  liquid: () => liquid
+});
+var liquid;
+var init_liquid = __esm({
+  "src/languages/liquid.ts"() {
+    liquid = {
+      slug: "liquid",
+      publishedDate: "2006-06-01",
+      extensions: [".liquid"],
+      author: "Shopify",
+      website: "https://shopify.github.io/liquid/",
+      paradigms: ["templating", "declarative", "logic-less", "server-side"],
+      tooling: {
+        runtimes: ["Ruby", "Node.js", "Shopify"],
+        packageManagers: ["RubyGems", "npm"],
+        ecosystems: ["Shopify", "Jekyll", "Static Sites", "E-commerce"]
+      },
+      version: "10.21.1",
+      logo: "https://cdn.simpleicons.org/shopify/7AB55C",
+      i18n: {
+        en: {
+          name: "Liquid",
+          description: "A safe template language used by Shopify, Jekyll, and content-driven sites.",
+          longDescription: "Liquid is a template language designed to expose controlled data to templates through tags, objects, filters, loops, conditions, and includes. It favors predictable rendering and constrained logic so non-developers can safely customize content presentation.\n\nIt is used in Shopify themes, Jekyll sites, GitHub Pages, storefront customization, content management systems, email templates, and static publishing workflows."
+        },
+        es: {
+          name: "Liquid",
+          description: "Un lenguaje de plantillas seguro usado por Shopify, Jekyll y sitios basados en contenido.",
+          longDescription: "Liquid es un lenguaje de plantillas disenado para exponer datos controlados mediante tags, objetos, filtros, bucles, condiciones e includes. Prioriza renderizado predecible y logica limitada para que personas no desarrolladoras puedan personalizar la presentacion de contenido con seguridad.\n\nSe usa en temas de Shopify, sitios Jekyll, GitHub Pages, personalizacion de tiendas, sistemas de gestion de contenido, plantillas de email y flujos de publicacion estatica."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/lisp.ts
 var lisp_exports = {};
 __export(lisp_exports, {
@@ -1994,6 +2222,82 @@ var init_matlab = __esm({
   }
 });
 
+// src/languages/mdx.ts
+var mdx_exports = {};
+__export(mdx_exports, {
+  mdx: () => mdx
+});
+var mdx;
+var init_mdx = __esm({
+  "src/languages/mdx.ts"() {
+    mdx = {
+      slug: "mdx",
+      publishedDate: "2018-03-23",
+      extensions: [".mdx"],
+      author: "MDX contributors",
+      website: "https://mdxjs.com",
+      paradigms: ["markup", "component-oriented", "declarative", "documentation"],
+      tooling: {
+        runtimes: ["React", "Node.js"],
+        packageManagers: ["npm", "Yarn", "pnpm"],
+        ecosystems: ["Documentation", "React", "Static Sites", "Content"]
+      },
+      version: "3.1.1",
+      logo: "https://cdn.simpleicons.org/mdx/1B1F24",
+      i18n: {
+        en: {
+          name: "MDX",
+          description: "A Markdown-based format that embeds JSX components in content documents.",
+          longDescription: "MDX combines Markdown prose with JSX expressions and components, allowing documents to include interactive examples, imports, exports, and component-driven layouts. It is commonly compiled into JavaScript for React-based rendering pipelines.\n\nIt is used in documentation sites, design systems, blogs, tutorials, component demos, content platforms, and static site generators that need prose and UI components in the same source file."
+        },
+        es: {
+          name: "MDX",
+          description: "Un formato basado en Markdown que inserta componentes JSX en documentos de contenido.",
+          longDescription: "MDX combina prosa Markdown con expresiones y componentes JSX, permitiendo que los documentos incluyan ejemplos interactivos, imports, exports y layouts basados en componentes. Normalmente se compila a JavaScript para pipelines de renderizado con React.\n\nSe usa en sitios de documentacion, sistemas de diseno, blogs, tutoriales, demos de componentes, plataformas de contenido y generadores de sitios estaticos que necesitan prosa y UI en el mismo archivo fuente."
+        }
+      }
+    };
+  }
+});
+
+// src/languages/mermaid.ts
+var mermaid_exports = {};
+__export(mermaid_exports, {
+  mermaid: () => mermaid
+});
+var mermaid;
+var init_mermaid = __esm({
+  "src/languages/mermaid.ts"() {
+    mermaid = {
+      slug: "mermaid",
+      publishedDate: "2014-11-04",
+      extensions: [".mmd", ".mermaid"],
+      author: "Knut Sveidqvist / Mermaid contributors",
+      website: "https://mermaid.js.org",
+      paradigms: ["declarative", "diagramming", "markup"],
+      tooling: {
+        runtimes: ["Browser", "Node.js"],
+        packageManagers: ["npm", "Yarn", "pnpm"],
+        ecosystems: ["Documentation", "Markdown", "Diagrams", "Knowledge Management"]
+      },
+      version: "11.11.0",
+      logo: "https://cdn.simpleicons.org/mermaid/FF3670",
+      i18n: {
+        en: {
+          name: "Mermaid",
+          description: "A text-based diagram language for flowcharts, sequences, timelines, and more.",
+          longDescription: "Mermaid is a diagramming language that renders structured text into diagrams such as flowcharts, sequence diagrams, class diagrams, state diagrams, entity relationship diagrams, gantt charts, timelines, and mind maps. It is designed to live comfortably beside Markdown documentation.\n\nIt is used in READMEs, architecture notes, wikis, documentation sites, issue trackers, knowledge bases, and workflows where diagrams should be versioned as plain text."
+        },
+        es: {
+          name: "Mermaid",
+          description: "Un lenguaje textual de diagramas para flujos, secuencias, lineas de tiempo y mas.",
+          longDescription: "Mermaid es un lenguaje de diagramacion que renderiza texto estructurado como diagramas de flujo, secuencia, clases, estados, entidad-relacion, gantt, lineas de tiempo y mapas mentales. Esta pensado para convivir comodamente con documentacion Markdown.\n\nSe usa en READMEs, notas de arquitectura, wikis, sitios de documentacion, issue trackers, bases de conocimiento y flujos donde los diagramas deben versionarse como texto plano."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/meson.ts
 var meson_exports = {};
 __export(meson_exports, {
@@ -2372,6 +2676,44 @@ var init_php = __esm({
   }
 });
 
+// src/languages/plantuml.ts
+var plantuml_exports = {};
+__export(plantuml_exports, {
+  plantuml: () => plantuml
+});
+var plantuml;
+var init_plantuml = __esm({
+  "src/languages/plantuml.ts"() {
+    plantuml = {
+      slug: "plantuml",
+      publishedDate: "2009-04-17",
+      extensions: [".puml", ".plantuml", ".iuml"],
+      author: "Arnaud Roques / PlantUML contributors",
+      website: "https://plantuml.com",
+      paradigms: ["declarative", "diagramming", "modeling"],
+      tooling: {
+        runtimes: ["Java", "PlantUML Server"],
+        packageManagers: ["Maven", "Gradle", "npm"],
+        ecosystems: ["UML", "Architecture", "Documentation", "Diagrams"]
+      },
+      version: "1.2026.3",
+      logo: "https://plantuml.com/logo3.png",
+      i18n: {
+        en: {
+          name: "PlantUML",
+          description: "A text-based diagram language for UML, architecture, and documentation diagrams.",
+          longDescription: "PlantUML is a diagram language and renderer for sequence, class, activity, component, state, object, deployment, timing, mind map, and architecture diagrams. It lets teams keep diagrams in source control and generate images from compact text.\n\nIt is used in software architecture documentation, design reviews, technical specs, wikis, CI-generated diagrams, and projects that prefer versionable diagrams over manually edited drawing files."
+        },
+        es: {
+          name: "PlantUML",
+          description: "Un lenguaje textual de diagramas para UML, arquitectura y documentacion.",
+          longDescription: "PlantUML es un lenguaje y renderer de diagramas para secuencia, clases, actividad, componentes, estados, objetos, despliegue, timing, mapas mentales y arquitectura. Permite mantener diagramas en control de versiones y generar imagenes desde texto compacto.\n\nSe usa en documentacion de arquitectura de software, revisiones de diseno, especificaciones tecnicas, wikis, diagramas generados en CI y proyectos que prefieren diagramas versionables a archivos de dibujo editados manualmente."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/powershell.ts
 var powershell_exports = {};
 __export(powershell_exports, {
@@ -2638,6 +2980,44 @@ var init_razor = __esm({
   }
 });
 
+// src/languages/rego.ts
+var rego_exports = {};
+__export(rego_exports, {
+  rego: () => rego
+});
+var rego;
+var init_rego = __esm({
+  "src/languages/rego.ts"() {
+    rego = {
+      slug: "rego",
+      publishedDate: "2016-01-01",
+      extensions: [".rego"],
+      author: "Open Policy Agent contributors / Styra",
+      website: "https://www.openpolicyagent.org/docs/latest/policy-language/",
+      paradigms: ["declarative", "logic", "policy-as-code", "query"],
+      tooling: {
+        runtimes: ["Open Policy Agent", "Conftest", "Gatekeeper", "Regal"],
+        packageManagers: ["OPA bundles"],
+        ecosystems: ["Policy as Code", "Kubernetes", "Cloud Native", "Authorization"]
+      },
+      version: "OPA 1.15.2",
+      logo: "https://raw.githubusercontent.com/open-policy-agent/opa/main/logo/logo.svg",
+      i18n: {
+        en: {
+          name: "Rego",
+          description: "Open Policy Agent's declarative policy language for authorization and policy as code.",
+          longDescription: "Rego is the declarative policy language used by Open Policy Agent to express rules, decisions, constraints, data queries, and authorization logic. It is designed around structured data such as JSON and lets policies evaluate inputs against rules, sets, objects, comprehensions, and built-in functions.\n\nIt is used for Kubernetes admission control, service authorization, infrastructure policy checks, CI validation, API gateways, compliance automation, and cloud-native systems that need policies kept separate from application code."
+        },
+        es: {
+          name: "Rego",
+          description: "El lenguaje declarativo de Open Policy Agent para autorizacion y policy as code.",
+          longDescription: "Rego es el lenguaje declarativo de politicas usado por Open Policy Agent para expresar reglas, decisiones, restricciones, consultas de datos y logica de autorizacion. Esta disenado alrededor de datos estructurados como JSON y permite evaluar entradas contra reglas, conjuntos, objetos, comprehensions y funciones integradas.\n\nSe usa para admission control en Kubernetes, autorizacion de servicios, validaciones de politicas de infraestructura, CI, gateways de APIs, automatizacion de cumplimiento y sistemas cloud native que necesitan mantener las politicas separadas del codigo de aplicacion."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/ruby.ts
 var ruby_exports = {};
 __export(ruby_exports, {
@@ -3032,7 +3412,7 @@ var init_tcl = __esm({
         ecosystems: ["GUI Applications", "EDA", "Automation", "Embedded Scripting"]
       },
       version: "9.0.3",
-      logo: "https://www.tcl-lang.org/images/tcl-logo.png",
+      logo: "https://commons.wikimedia.org/wiki/Special:FilePath/Tcl.svg",
       i18n: {
         en: {
           name: "Tcl/Tk",
@@ -3049,6 +3429,44 @@ var init_tcl = __esm({
   }
 });
 
+// src/languages/tex.ts
+var tex_exports = {};
+__export(tex_exports, {
+  tex: () => tex
+});
+var tex;
+var init_tex = __esm({
+  "src/languages/tex.ts"() {
+    tex = {
+      slug: "tex",
+      publishedDate: "1978-01-01",
+      extensions: [".tex", ".sty", ".cls", ".dtx", ".ins", ".ltx"],
+      author: "Donald Knuth",
+      website: "https://www.tug.org/texlive/",
+      paradigms: ["markup", "typesetting", "macro", "declarative"],
+      tooling: {
+        runtimes: ["TeX Live", "MiKTeX", "pdfTeX", "XeTeX", "LuaTeX"],
+        packageManagers: ["tlmgr", "MiKTeX Console", "CTAN"],
+        ecosystems: ["Publishing", "Academic Writing", "Scientific Documents", "Print"]
+      },
+      version: "TeX Live 2026",
+      logo: "https://cdn.simpleicons.org/latex/008080",
+      i18n: {
+        en: {
+          name: "TeX",
+          description: "Donald Knuth's macro-based typesetting system for precise technical and scientific documents.",
+          longDescription: "TeX is a programmable typesetting system built around macros, boxes, glue, mathematical layout, and precise page composition. Plain TeX, LaTeX, ConTeXt, and related formats build on the TeX engine family to produce high-quality documents from text source files.\n\nIt is used for academic papers, books, technical manuals, mathematics, physics, computer science publications, theses, and publishing workflows where reproducible typography and long-term source stability matter."
+        },
+        es: {
+          name: "TeX",
+          description: "El sistema de composicion tipografica basado en macros de Donald Knuth para documentos tecnicos.",
+          longDescription: "TeX es un sistema programable de composicion tipografica basado en macros, cajas, espaciado flexible, notacion matematica y composicion precisa de paginas. Plain TeX, LaTeX, ConTeXt y formatos relacionados se apoyan en la familia de motores TeX para producir documentos de alta calidad desde archivos fuente de texto.\n\nSe usa para articulos academicos, libros, manuales tecnicos, matematicas, fisica, publicaciones de computacion, tesis y flujos editoriales donde importan la tipografia reproducible y la estabilidad del codigo fuente a largo plazo."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/toml.ts
 var toml_exports = {};
 __export(toml_exports, {
@@ -3082,6 +3500,44 @@ var init_toml = __esm({
   }
 });
 
+// src/languages/twig.ts
+var twig_exports = {};
+__export(twig_exports, {
+  twig: () => twig
+});
+var twig;
+var init_twig = __esm({
+  "src/languages/twig.ts"() {
+    twig = {
+      slug: "twig",
+      publishedDate: "2009-10-12",
+      extensions: [".twig"],
+      author: "Fabien Potencier / Twig contributors",
+      website: "https://twig.symfony.com",
+      paradigms: ["templating", "declarative", "server-side", "scripting"],
+      tooling: {
+        runtimes: ["PHP", "Symfony"],
+        packageManagers: ["Composer"],
+        ecosystems: ["PHP", "Symfony", "Web", "CMS"]
+      },
+      version: "3.24.0",
+      logo: "https://twig.symfony.com/images/logo.png",
+      i18n: {
+        en: {
+          name: "Twig",
+          description: "A flexible, secure template language for PHP applications and Symfony projects.",
+          longDescription: "Twig is a template language for PHP that separates presentation from application logic using blocks, inheritance, includes, filters, functions, tests, macros, escaping, and sandboxing. Its syntax is designed to be readable for designers while remaining extensible for developers.\n\nIt is used in Symfony applications, PHP web projects, CMS themes, email templates, static generation workflows, and systems that need reusable server-rendered views with controlled access to application data."
+        },
+        es: {
+          name: "Twig",
+          description: "Un lenguaje de plantillas flexible y seguro para aplicaciones PHP y proyectos Symfony.",
+          longDescription: "Twig es un lenguaje de plantillas para PHP que separa la presentacion de la logica de aplicacion usando bloques, herencia, includes, filtros, funciones, tests, macros, escapado y sandboxing. Su sintaxis esta pensada para ser legible para disenadores y extensible para desarrolladores.\n\nSe usa en aplicaciones Symfony, proyectos web PHP, temas de CMS, plantillas de email, flujos de generacion estatica y sistemas que necesitan vistas renderizadas en servidor reutilizables con acceso controlado a los datos de la aplicacion."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/typescript.ts
 var typescript_exports = {};
 __export(typescript_exports, {
@@ -3120,6 +3576,44 @@ var init_typescript = __esm({
   }
 });
 
+// src/languages/verilog.ts
+var verilog_exports = {};
+__export(verilog_exports, {
+  verilog: () => verilog
+});
+var verilog;
+var init_verilog = __esm({
+  "src/languages/verilog.ts"() {
+    verilog = {
+      slug: "verilog",
+      publishedDate: "1984-01-01",
+      extensions: [".v", ".vh", ".sv", ".svh"],
+      author: "Phil Moorby / Gateway Design Automation",
+      website: "https://standards.ieee.org/standard/1800-2023.html",
+      paradigms: ["hardware-description", "concurrent", "event-driven", "verification"],
+      tooling: {
+        runtimes: ["FPGA Toolchains", "ASIC EDA Tools", "Simulators"],
+        packageManagers: ["FuseSoC"],
+        ecosystems: ["Hardware Design", "FPGA", "ASIC", "Verification"]
+      },
+      version: "IEEE 1800-2023",
+      logo: "https://cdn.jsdelivr.net/gh/vscode-icons/vscode-icons@master/icons/file_type_verilog.svg",
+      i18n: {
+        en: {
+          name: "Verilog/SystemVerilog",
+          description: "A hardware description and verification language for digital circuits and systems.",
+          longDescription: "Verilog and SystemVerilog describe digital hardware at behavioral, register-transfer, and gate levels. The language supports modules, signals, continuous assignments, procedural blocks, timing, testbenches, assertions, interfaces, classes, and constrained random verification.\n\nIt is used for FPGA designs, ASIC development, hardware simulation, synthesis, verification environments, reusable IP blocks, and electronic design automation workflows."
+        },
+        es: {
+          name: "Verilog/SystemVerilog",
+          description: "Un lenguaje de descripcion y verificacion de hardware para circuitos y sistemas digitales.",
+          longDescription: "Verilog y SystemVerilog describen hardware digital en niveles conductual, register-transfer y de compuertas. El lenguaje soporta modulos, senales, asignaciones continuas, bloques procedurales, timing, testbenches, assertions, interfaces, clases y verificacion aleatoria restringida.\n\nSe usa en disenos FPGA, desarrollo ASIC, simulacion de hardware, sintesis, entornos de verificacion, bloques IP reutilizables y flujos de automatizacion de diseno electronico."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/visual-basic.ts
 var visual_basic_exports = {};
 __export(visual_basic_exports, {
@@ -3304,6 +3798,82 @@ var init_xml = __esm({
   }
 });
 
+// src/languages/xquery.ts
+var xquery_exports = {};
+__export(xquery_exports, {
+  xquery: () => xquery
+});
+var xquery;
+var init_xquery = __esm({
+  "src/languages/xquery.ts"() {
+    xquery = {
+      slug: "xquery",
+      publishedDate: "2007-01-23",
+      extensions: [".xq", ".xql", ".xqm", ".xquery", ".xqy"],
+      author: "W3C XML Query Working Group",
+      website: "https://www.w3.org/TR/xquery/",
+      paradigms: ["query", "functional", "declarative", "xml"],
+      tooling: {
+        runtimes: ["BaseX", "Saxon", "eXist-db", "MarkLogic"],
+        packageManagers: ["EXPath Package Manager"],
+        ecosystems: ["XML", "Databases", "Publishing", "Enterprise Data"]
+      },
+      version: "XQuery 3.1",
+      logo: "https://upload.wikimedia.org/wikipedia/commons/6/68/XML.svg",
+      i18n: {
+        en: {
+          name: "XQuery",
+          description: "A W3C query and application language for XML, structured, and semi-structured data.",
+          longDescription: "XQuery is a declarative query language for XML and related structured data. It combines XPath expressions, FLWOR queries, functions, modules, sequence processing, namespaces, and type-aware operations to extract, transform, join, and construct XML or other serialized results.\n\nIt is used in native XML databases, publishing pipelines, document repositories, enterprise integrations, digital humanities, metadata processing, and applications that query large collections of XML or semi-structured content."
+        },
+        es: {
+          name: "XQuery",
+          description: "Un lenguaje W3C de consulta y aplicaciones para XML y datos estructurados o semiestructurados.",
+          longDescription: "XQuery es un lenguaje declarativo de consultas para XML y datos estructurados relacionados. Combina expresiones XPath, consultas FLWOR, funciones, modulos, procesamiento de secuencias, namespaces y operaciones con tipos para extraer, transformar, unir y construir XML u otros resultados serializados.\n\nSe usa en bases de datos XML nativas, pipelines de publicacion, repositorios documentales, integraciones empresariales, humanidades digitales, procesamiento de metadatos y aplicaciones que consultan grandes colecciones de XML o contenido semiestructurado."
+        }
+      }
+    };
+  }
+});
+
+// src/languages/xslt.ts
+var xslt_exports = {};
+__export(xslt_exports, {
+  xslt: () => xslt
+});
+var xslt;
+var init_xslt = __esm({
+  "src/languages/xslt.ts"() {
+    xslt = {
+      slug: "xslt",
+      publishedDate: "1999-11-16",
+      extensions: [".xsl", ".xslt"],
+      author: "W3C XSLT Working Group",
+      website: "https://www.w3.org/TR/xslt-30/",
+      paradigms: ["declarative", "functional", "markup", "transformation"],
+      tooling: {
+        runtimes: ["Saxon", "libxslt", "Xalan", "Browser XSLT processors"],
+        packageManagers: ["Maven", "npm", "NuGet", "APT", "Homebrew"],
+        ecosystems: ["XML", "Publishing", "Enterprise Integration", "Document Processing"]
+      },
+      version: "XSLT 3.0",
+      logo: "https://upload.wikimedia.org/wikipedia/commons/6/68/XML.svg",
+      i18n: {
+        en: {
+          name: "XSLT",
+          description: "A W3C stylesheet language for transforming XML documents into XML, HTML, text, and more.",
+          longDescription: "XSLT is a declarative transformation language for XML documents. Stylesheets use templates, modes, XPath expressions, variables, functions, keys, imports, and output declarations to match source trees and produce XML, HTML, text, or other structured results.\n\nIt is used in publishing systems, enterprise data exchange, document conversion, XML pipelines, standards-based integrations, browser-era XML workflows, and systems that need repeatable transformations between document formats."
+        },
+        es: {
+          name: "XSLT",
+          description: "Un lenguaje W3C de hojas de estilo para transformar XML en XML, HTML, texto y mas.",
+          longDescription: "XSLT es un lenguaje declarativo de transformacion para documentos XML. Las hojas de estilo usan templates, modos, expresiones XPath, variables, funciones, claves, imports y declaraciones de salida para encontrar nodos en arboles fuente y producir XML, HTML, texto u otros resultados estructurados.\n\nSe usa en sistemas de publicacion, intercambio de datos empresarial, conversion de documentos, pipelines XML, integraciones basadas en estandares, flujos XML historicos del navegador y sistemas que necesitan transformaciones repetibles entre formatos documentales."
+        }
+      }
+    };
+  }
+});
+
 // src/languages/yaml.ts
 var yaml_exports = {};
 __export(yaml_exports, {
@@ -3424,6 +3994,7 @@ init_astro();
 init_awk();
 init_bash();
 init_batch();
+init_bicep();
 init_c();
 init_clojure();
 init_cmake();
@@ -3434,6 +4005,7 @@ init_crystal();
 init_csharp();
 init_css();
 init_cuda();
+init_cue();
 init_d();
 init_dart();
 init_dockerfile();
@@ -3443,6 +4015,7 @@ init_erlang();
 init_fennel();
 init_fortran();
 init_fsharp();
+init_gdscript();
 init_git();
 init_gleam();
 init_glsl();
@@ -3450,6 +4023,7 @@ init_go();
 init_gradle();
 init_graphql();
 init_groovy();
+init_handlebars();
 init_haskell();
 init_haxe();
 init_hcl();
@@ -3457,16 +4031,20 @@ init_html();
 init_ini();
 init_java();
 init_javascript();
+init_jinja();
 init_json();
 init_julia();
 init_jupyter_notebook();
 init_kotlin();
 init_less();
+init_liquid();
 init_lisp();
 init_lua();
 init_makefile();
 init_markdown();
 init_matlab();
+init_mdx();
+init_mermaid();
 init_meson();
 init_metal();
 init_nginx();
@@ -3477,6 +4055,7 @@ init_ocaml();
 init_pascal();
 init_perl();
 init_php();
+init_plantuml();
 init_powershell();
 init_protobuf();
 init_pug();
@@ -3484,6 +4063,7 @@ init_python();
 init_r();
 init_racket();
 init_razor();
+init_rego();
 init_ruby();
 init_rust();
 init_scala();
@@ -3495,13 +4075,18 @@ init_svg();
 init_svn();
 init_swift();
 init_tcl();
+init_tex();
 init_toml();
+init_twig();
 init_typescript();
+init_verilog();
 init_visual_basic();
 init_vue();
 init_webassembly();
 init_xaml();
 init_xml();
+init_xquery();
+init_xslt();
 init_yaml();
 init_zig();
 init_zsh();
@@ -3516,6 +4101,7 @@ var languages = [
   awk,
   bash,
   batch,
+  bicep,
   c,
   cmake,
   clojure,
@@ -3525,6 +4111,7 @@ var languages = [
   csharp,
   crystal,
   css,
+  cue,
   cuda,
   d,
   dart,
@@ -3535,6 +4122,7 @@ var languages = [
   fennel,
   fortran,
   fsharp,
+  gdscript,
   git,
   gleam,
   go,
@@ -3542,6 +4130,7 @@ var languages = [
   glsl,
   graphql,
   groovy,
+  handlebars,
   haskell,
   haxe,
   hcl,
@@ -3549,16 +4138,20 @@ var languages = [
   ini,
   java,
   javascript,
+  jinja,
   json,
   jupyterNotebook,
   julia,
   kotlin,
   less,
+  liquid,
   lisp,
   lua,
   makefile,
   matlab,
   markdown,
+  mdx,
+  mermaid,
   meson,
   metal,
   svn,
@@ -3570,6 +4163,7 @@ var languages = [
   pascal,
   perl,
   php,
+  plantuml,
   powershell,
   protobuf,
   pug,
@@ -3577,6 +4171,7 @@ var languages = [
   r,
   racket,
   razor,
+  rego,
   ruby,
   rust,
   scala,
@@ -3587,13 +4182,18 @@ var languages = [
   svelte,
   swift,
   tcl,
+  tex,
   toml,
+  twig,
   typescript,
+  verilog,
   visualBasic,
   vue,
   webassembly,
   xaml,
   xml,
+  xquery,
+  xslt,
   yaml,
   zig,
   zsh
@@ -3666,6 +4266,7 @@ var languageIndex = [
     extensions: [".sh", ".bash", ".bashrc", ".bash_profile", ".bash_login", ".profile"]
   },
   { slug: "batch", extensions: [".bat", ".cmd"] },
+  { slug: "bicep", extensions: [".bicep", ".bicepparam"] },
   { slug: "c", extensions: [".c", ".h"] },
   { slug: "cmake", extensions: ["CMakeLists.txt", ".cmake"] },
   { slug: "clojure", extensions: [".clj", ".cljs", ".cljc", ".edn", ".bb"] },
@@ -3675,6 +4276,7 @@ var languageIndex = [
   { slug: "csharp", extensions: [".cs", ".csx"] },
   { slug: "crystal", extensions: [".cr"] },
   { slug: "css", extensions: [".css"] },
+  { slug: "cue", extensions: [".cue"] },
   { slug: "cuda", extensions: [".cu", ".cuh"] },
   { slug: "d", extensions: [".d", ".di"] },
   { slug: "dart", extensions: [".dart"] },
@@ -3691,6 +4293,7 @@ var languageIndex = [
     extensions: [".f", ".for", ".ftn", ".f90", ".f95", ".f03", ".f08", ".f18", ".f23"]
   },
   { slug: "fsharp", extensions: [".fs", ".fsi", ".fsx", ".fsscript"] },
+  { slug: "gdscript", extensions: [".gd"] },
   { slug: "git", extensions: [".git", ".gitignore", ".gitattributes", ".gitmodules", ".gitkeep"] },
   { slug: "gleam", extensions: [".gleam"] },
   { slug: "go", extensions: [".go"] },
@@ -3701,6 +4304,7 @@ var languageIndex = [
   },
   { slug: "graphql", extensions: [".graphql", ".gql", ".graphqls"] },
   { slug: "groovy", extensions: [".groovy", ".gvy", ".gy", ".gsh"] },
+  { slug: "handlebars", extensions: [".hbs", ".handlebars"] },
   { slug: "haskell", extensions: [".hs", ".lhs", ".hsc", ".hs-boot", ".hsig", ".cabal"] },
   { slug: "haxe", extensions: [".hx", ".hxml"] },
   { slug: "hcl", extensions: [".hcl", ".tf", ".tfvars", ".pkr.hcl", ".nomad"] },
@@ -3708,16 +4312,20 @@ var languageIndex = [
   { slug: "ini", extensions: [".ini"] },
   { slug: "java", extensions: [".java"] },
   { slug: "javascript", extensions: [".js", ".mjs", ".cjs", ".jsx"] },
+  { slug: "jinja", extensions: [".jinja", ".jinja2", ".j2"] },
   { slug: "json", extensions: [".json"] },
   { slug: "jupyter-notebook", extensions: [".ipynb"] },
   { slug: "julia", extensions: [".jl"] },
   { slug: "kotlin", extensions: [".kt", ".kts"] },
   { slug: "less", extensions: [".less"] },
+  { slug: "liquid", extensions: [".liquid"] },
   { slug: "lisp", extensions: [".lisp", ".lsp", ".cl", ".asd"] },
   { slug: "lua", extensions: [".lua", ".rockspec"] },
   { slug: "makefile", extensions: ["Makefile", "makefile", "GNUmakefile", ".mk", ".mak"] },
   { slug: "matlab", extensions: [".m", ".mlx"] },
   { slug: "markdown", extensions: [".md", ".markdown", ".mdown", ".mkd"] },
+  { slug: "mdx", extensions: [".mdx"] },
+  { slug: "mermaid", extensions: [".mmd", ".mermaid"] },
   { slug: "meson", extensions: ["meson.build", "meson_options.txt", "meson.options", ".wrap"] },
   { slug: "metal", extensions: [".metal"] },
   { slug: "svn", extensions: [".svn", "svnserve.conf"] },
@@ -3729,6 +4337,7 @@ var languageIndex = [
   { slug: "pascal", extensions: [".pas", ".pp", ".inc", ".lpr", ".dpr", ".dfm"] },
   { slug: "perl", extensions: [".pl", ".pm", ".pod", ".t", ".psgi"] },
   { slug: "php", extensions: [".php", ".phtml", ".php3", ".php4", ".php5", ".phps"] },
+  { slug: "plantuml", extensions: [".puml", ".plantuml", ".iuml"] },
   { slug: "powershell", extensions: [".ps1", ".psm1", ".psd1", ".ps1xml"] },
   { slug: "protobuf", extensions: [".proto"] },
   { slug: "pug", extensions: [".pug", ".jade"] },
@@ -3736,6 +4345,7 @@ var languageIndex = [
   { slug: "r", extensions: [".r", ".R", ".rmd", ".Rmd", ".qmd", ".Rprofile"] },
   { slug: "racket", extensions: [".rkt", ".rktd", ".rktl", ".scrbl"] },
   { slug: "razor", extensions: [".cshtml", ".razor"] },
+  { slug: "rego", extensions: [".rego"] },
   {
     slug: "ruby",
     extensions: [".rb", ".rbw", ".rake", ".gemspec", "Gemfile", "Rakefile", "config.ru"]
@@ -3749,13 +4359,18 @@ var languageIndex = [
   { slug: "svelte", extensions: [".svelte"] },
   { slug: "swift", extensions: [".swift"] },
   { slug: "tcl", extensions: [".tcl", ".tm", ".test"] },
+  { slug: "tex", extensions: [".tex", ".sty", ".cls", ".dtx", ".ins", ".ltx"] },
   { slug: "toml", extensions: [".toml"] },
+  { slug: "twig", extensions: [".twig"] },
   { slug: "typescript", extensions: [".ts", ".tsx", ".mts", ".cts"] },
+  { slug: "verilog", extensions: [".v", ".vh", ".sv", ".svh"] },
   { slug: "visual-basic", extensions: [".vb"] },
   { slug: "vue", extensions: [".vue"] },
   { slug: "webassembly", extensions: [".wasm", ".wat"] },
   { slug: "xaml", extensions: [".xaml", ".baml"] },
   { slug: "xml", extensions: [".xml", ".xsd", ".xsl", ".xslt"] },
+  { slug: "xquery", extensions: [".xq", ".xql", ".xqm", ".xquery", ".xqy"] },
+  { slug: "xslt", extensions: [".xsl", ".xslt"] },
   { slug: "yaml", extensions: [".yaml", ".yml"] },
   { slug: "zig", extensions: [".zig", ".zon"] },
   {
@@ -3774,6 +4389,7 @@ var languageLoaders = {
   awk: () => Promise.resolve().then(() => (init_awk(), awk_exports)).then((module) => module.awk),
   bash: () => Promise.resolve().then(() => (init_bash(), bash_exports)).then((module) => module.bash),
   batch: () => Promise.resolve().then(() => (init_batch(), batch_exports)).then((module) => module.batch),
+  bicep: () => Promise.resolve().then(() => (init_bicep(), bicep_exports)).then((module) => module.bicep),
   c: () => Promise.resolve().then(() => (init_c(), c_exports)).then((module) => module.c),
   cmake: () => Promise.resolve().then(() => (init_cmake(), cmake_exports)).then((module) => module.cmake),
   clojure: () => Promise.resolve().then(() => (init_clojure(), clojure_exports)).then((module) => module.clojure),
@@ -3783,6 +4399,7 @@ var languageLoaders = {
   csharp: () => Promise.resolve().then(() => (init_csharp(), csharp_exports)).then((module) => module.csharp),
   crystal: () => Promise.resolve().then(() => (init_crystal(), crystal_exports)).then((module) => module.crystal),
   css: () => Promise.resolve().then(() => (init_css(), css_exports)).then((module) => module.css),
+  cue: () => Promise.resolve().then(() => (init_cue(), cue_exports)).then((module) => module.cue),
   cuda: () => Promise.resolve().then(() => (init_cuda(), cuda_exports)).then((module) => module.cuda),
   d: () => Promise.resolve().then(() => (init_d(), d_exports)).then((module) => module.d),
   dart: () => Promise.resolve().then(() => (init_dart(), dart_exports)).then((module) => module.dart),
@@ -3793,6 +4410,7 @@ var languageLoaders = {
   fennel: () => Promise.resolve().then(() => (init_fennel(), fennel_exports)).then((module) => module.fennel),
   fortran: () => Promise.resolve().then(() => (init_fortran(), fortran_exports)).then((module) => module.fortran),
   fsharp: () => Promise.resolve().then(() => (init_fsharp(), fsharp_exports)).then((module) => module.fsharp),
+  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),
   go: () => Promise.resolve().then(() => (init_go(), go_exports)).then((module) => module.go),
@@ -3800,6 +4418,7 @@ var languageLoaders = {
   glsl: () => Promise.resolve().then(() => (init_glsl(), glsl_exports)).then((module) => module.glsl),
   graphql: () => Promise.resolve().then(() => (init_graphql(), graphql_exports)).then((module) => module.graphql),
   groovy: () => Promise.resolve().then(() => (init_groovy(), groovy_exports)).then((module) => module.groovy),
+  handlebars: () => Promise.resolve().then(() => (init_handlebars(), handlebars_exports)).then((module) => module.handlebars),
   haskell: () => Promise.resolve().then(() => (init_haskell(), haskell_exports)).then((module) => module.haskell),
   haxe: () => Promise.resolve().then(() => (init_haxe(), haxe_exports)).then((module) => module.haxe),
   hcl: () => Promise.resolve().then(() => (init_hcl(), hcl_exports)).then((module) => module.hcl),
@@ -3807,16 +4426,20 @@ var languageLoaders = {
   ini: () => Promise.resolve().then(() => (init_ini(), ini_exports)).then((module) => module.ini),
   java: () => Promise.resolve().then(() => (init_java(), java_exports)).then((module) => module.java),
   javascript: () => Promise.resolve().then(() => (init_javascript(), javascript_exports)).then((module) => module.javascript),
+  jinja: () => Promise.resolve().then(() => (init_jinja(), jinja_exports)).then((module) => module.jinja),
   json: () => Promise.resolve().then(() => (init_json(), json_exports)).then((module) => module.json),
   "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),
   kotlin: () => Promise.resolve().then(() => (init_kotlin(), kotlin_exports)).then((module) => module.kotlin),
   less: () => Promise.resolve().then(() => (init_less(), less_exports)).then((module) => module.less),
+  liquid: () => Promise.resolve().then(() => (init_liquid(), liquid_exports)).then((module) => module.liquid),
   lisp: () => Promise.resolve().then(() => (init_lisp(), lisp_exports)).then((module) => module.lisp),
   lua: () => Promise.resolve().then(() => (init_lua(), lua_exports)).then((module) => module.lua),
   makefile: () => Promise.resolve().then(() => (init_makefile(), makefile_exports)).then((module) => module.makefile),
   matlab: () => Promise.resolve().then(() => (init_matlab(), matlab_exports)).then((module) => module.matlab),
   markdown: () => Promise.resolve().then(() => (init_markdown(), markdown_exports)).then((module) => module.markdown),
+  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),
   metal: () => Promise.resolve().then(() => (init_metal(), metal_exports)).then((module) => module.metal),
   svn: () => Promise.resolve().then(() => (init_svn(), svn_exports)).then((module) => module.svn),
@@ -3828,6 +4451,7 @@ var languageLoaders = {
   pascal: () => Promise.resolve().then(() => (init_pascal(), pascal_exports)).then((module) => module.pascal),
   perl: () => Promise.resolve().then(() => (init_perl(), perl_exports)).then((module) => module.perl),
   php: () => Promise.resolve().then(() => (init_php(), php_exports)).then((module) => module.php),
+  plantuml: () => Promise.resolve().then(() => (init_plantuml(), plantuml_exports)).then((module) => module.plantuml),
   powershell: () => Promise.resolve().then(() => (init_powershell(), powershell_exports)).then((module) => module.powershell),
   protobuf: () => Promise.resolve().then(() => (init_protobuf(), protobuf_exports)).then((module) => module.protobuf),
   pug: () => Promise.resolve().then(() => (init_pug(), pug_exports)).then((module) => module.pug),
@@ -3835,6 +4459,7 @@ var languageLoaders = {
   r: () => Promise.resolve().then(() => (init_r(), r_exports)).then((module) => module.r),
   racket: () => Promise.resolve().then(() => (init_racket(), racket_exports)).then((module) => module.racket),
   razor: () => Promise.resolve().then(() => (init_razor(), razor_exports)).then((module) => module.razor),
+  rego: () => Promise.resolve().then(() => (init_rego(), rego_exports)).then((module) => module.rego),
   ruby: () => Promise.resolve().then(() => (init_ruby(), ruby_exports)).then((module) => module.ruby),
   rust: () => Promise.resolve().then(() => (init_rust(), rust_exports)).then((module) => module.rust),
   scala: () => Promise.resolve().then(() => (init_scala(), scala_exports)).then((module) => module.scala),
@@ -3845,13 +4470,18 @@ var languageLoaders = {
   svg: () => Promise.resolve().then(() => (init_svg(), svg_exports)).then((module) => module.svg),
   swift: () => Promise.resolve().then(() => (init_swift(), swift_exports)).then((module) => module.swift),
   tcl: () => Promise.resolve().then(() => (init_tcl(), tcl_exports)).then((module) => module.tcl),
+  tex: () => Promise.resolve().then(() => (init_tex(), tex_exports)).then((module) => module.tex),
   toml: () => Promise.resolve().then(() => (init_toml(), toml_exports)).then((module) => module.toml),
+  twig: () => Promise.resolve().then(() => (init_twig(), twig_exports)).then((module) => module.twig),
   typescript: () => Promise.resolve().then(() => (init_typescript(), typescript_exports)).then((module) => module.typescript),
+  verilog: () => Promise.resolve().then(() => (init_verilog(), verilog_exports)).then((module) => module.verilog),
   "visual-basic": () => Promise.resolve().then(() => (init_visual_basic(), visual_basic_exports)).then((module) => module.visualBasic),
   vue: () => Promise.resolve().then(() => (init_vue(), vue_exports)).then((module) => module.vue),
   webassembly: () => Promise.resolve().then(() => (init_webassembly(), webassembly_exports)).then((module) => module.webassembly),
   xaml: () => Promise.resolve().then(() => (init_xaml(), xaml_exports)).then((module) => module.xaml),
   xml: () => Promise.resolve().then(() => (init_xml(), xml_exports)).then((module) => module.xml),
+  xquery: () => Promise.resolve().then(() => (init_xquery(), xquery_exports)).then((module) => module.xquery),
+  xslt: () => Promise.resolve().then(() => (init_xslt(), xslt_exports)).then((module) => module.xslt),
   yaml: () => Promise.resolve().then(() => (init_yaml(), yaml_exports)).then((module) => module.yaml),
   zig: () => Promise.resolve().then(() => (init_zig(), zig_exports)).then((module) => module.zig),
   zsh: () => Promise.resolve().then(() => (init_zsh(), zsh_exports)).then((module) => module.zsh)