code-languages 1.39.0 → 1.40.0

package/dist/api.cjs

@@ -17421,6 +17421,288 @@ var detectMatchingEntries = (entries, filename) => {
 var detectLanguageSlugs = (filename) => detectMatchingEntries(languageIndex, filename).map((entry) => entry.slug);
 var detectLanguageSlug = (filename) => detectLanguageSlugs(filename).at(0);
 
+// src/domain/ecosystem/registry.ts
+var ECOSYSTEM_REGISTRY = [
+  // Web
+  {
+    slug: "web",
+    name: "Web",
+    description: "Languages used for building websites, web apps, and web standards.",
+    aliases: ["web", "frontend", "browser"],
+    targets: ["Web", "Frontend", "JavaScript", "Static Sites", "CMS", "Web Servers"]
+  },
+  // JavaScript ecosystem
+  {
+    slug: "node",
+    name: "Node.js",
+    description: "Languages that run on or integrate with the Node.js server-side runtime.",
+    aliases: ["node", "nodejs", "node.js"],
+    targets: ["Node.js"]
+  },
+  // JVM
+  {
+    slug: "jvm",
+    name: "JVM",
+    description: "Languages that run on the Java Virtual Machine.",
+    aliases: ["jvm", "java"],
+    targets: ["JVM", "Java", "Kotlin", "Groovy", "Scala"]
+  },
+  // .NET
+  {
+    slug: "dotnet",
+    name: ".NET",
+    description: "Languages that target the .NET platform and runtime.",
+    aliases: ["dotnet", ".net", "net"],
+    targets: [".NET", "ASP.NET", "Blazor", "ASP.NET Core"]
+  },
+  // DevOps / Cloud
+  {
+    slug: "devops",
+    name: "DevOps",
+    description: "Languages used for CI/CD, infrastructure, and automation pipelines.",
+    aliases: ["devops", "cicd", "ci-cd"],
+    targets: ["DevOps", "CI/CD", "Platform Automation", "Cloud tooling"]
+  },
+  {
+    slug: "cloud",
+    name: "Cloud",
+    description: "Languages used for cloud computing, cloud-native applications, and IaC.",
+    aliases: ["cloud", "cloud-native"],
+    targets: [
+      "Cloud",
+      "Cloud Computing",
+      "Cloud Native",
+      "Infrastructure as Code",
+      "Infrastructure"
+    ]
+  },
+  {
+    slug: "kubernetes",
+    name: "Kubernetes",
+    description: "Languages and tools used in the Kubernetes ecosystem.",
+    aliases: ["kubernetes", "k8s"],
+    targets: ["Kubernetes"]
+  },
+  // Data
+  {
+    slug: "data-science",
+    name: "Data Science",
+    description: "Languages used for data analysis, machine learning, and statistical computing.",
+    aliases: ["data-science", "ml", "machine-learning", "ai"],
+    targets: ["Data Science", "Machine Learning", "AI", "ML", "Data Analysis", "Analytics"]
+  },
+  {
+    slug: "scientific",
+    name: "Scientific Computing",
+    description: "Languages used in research, numerical computing, and scientific simulations.",
+    aliases: ["scientific", "scientific-computing", "hpc", "research"],
+    targets: [
+      "Scientific Computing",
+      "Research",
+      "HPC",
+      "Numerical Computing",
+      "Numerical Analysis",
+      "Bioinformatics"
+    ]
+  },
+  // Systems & Embedded
+  {
+    slug: "systems",
+    name: "Systems",
+    description: "Languages used for operating systems, system utilities, and native development.",
+    aliases: ["systems", "systems-programming", "native"],
+    targets: [
+      "Systems",
+      "Systems Programming",
+      "Systems programming",
+      "Operating Systems",
+      "Native",
+      "Native Applications",
+      "Native applications"
+    ]
+  },
+  {
+    slug: "embedded",
+    name: "Embedded",
+    description: "Languages used in firmware, microcontrollers, and embedded hardware.",
+    aliases: ["embedded", "firmware", "iot"],
+    targets: [
+      "Embedded",
+      "Embedded Systems",
+      "Embedded systems",
+      "Firmware",
+      "IoT",
+      "Microcontroller Firmware"
+    ]
+  },
+  // Game development
+  {
+    slug: "game-dev",
+    name: "Game Development",
+    description: "Languages used for building video games and game engines.",
+    aliases: ["game-dev", "games", "game-development", "gamedev"],
+    targets: ["Game Development", "Games", "2D Games", "3D Games", "Indie Games", "Modding"]
+  },
+  // Mobile
+  {
+    slug: "mobile",
+    name: "Mobile",
+    description: "Languages used for iOS, Android, and cross-platform mobile development.",
+    aliases: ["mobile", "ios", "android"],
+    targets: ["Mobile", "iOS", "Android", "Flutter", "Mobile Applications", "Mobile UI"]
+  },
+  // Blockchain
+  {
+    slug: "blockchain",
+    name: "Blockchain",
+    description: "Languages used for smart contracts, DeFi, and blockchain development.",
+    aliases: ["blockchain", "web3", "smart-contracts", "crypto"],
+    targets: ["Blockchain", "Smart Contracts", "Ethereum", "Web3", "EVM", "DeFi"]
+  },
+  // GPU / Graphics
+  {
+    slug: "gpu",
+    name: "GPU",
+    description: "Languages used for GPU computing, graphics, and shader programming.",
+    aliases: ["gpu", "graphics", "gpu-programming"],
+    targets: [
+      "GPU Programming",
+      "GPU Computing",
+      "GPU Compute",
+      "WebGPU",
+      "WebGL",
+      "DirectX",
+      "Graphics",
+      "Khronos"
+    ]
+  },
+  // WebAssembly
+  {
+    slug: "wasm",
+    name: "WebAssembly",
+    description: "Languages that compile to or run on WebAssembly.",
+    aliases: ["wasm", "webassembly"],
+    targets: ["WebAssembly", "WASI", "WebAssembly Component Model"]
+  },
+  // Enterprise
+  {
+    slug: "enterprise",
+    name: "Enterprise",
+    description: "Languages used in large-scale enterprise software and business applications.",
+    aliases: ["enterprise"],
+    targets: ["Enterprise", "Enterprise Applications", "Enterprise Data", "Enterprise Integration"]
+  },
+  // Formal methods / Verification
+  {
+    slug: "formal-methods",
+    name: "Formal Methods",
+    description: "Languages used for formal proofs, verification, and correctness guarantees.",
+    aliases: ["formal-methods", "verification", "proof-assistants"],
+    targets: [
+      "Formal Methods",
+      "Formal methods",
+      "Verification",
+      "Proof Assistants",
+      "Proof assistants",
+      "Low-level Verification"
+    ]
+  },
+  // Compilers / Language tooling
+  {
+    slug: "compilers",
+    name: "Compilers",
+    description: "Languages used in compiler development, language design, and tooling.",
+    aliases: ["compilers", "language-design", "language-tooling"],
+    targets: [
+      "Compilers",
+      "Language Design",
+      "Language Research",
+      "Language Tools",
+      "Language Implementation",
+      "Compiler Development"
+    ]
+  },
+  // Unix / Linux
+  {
+    slug: "unix",
+    name: "Unix",
+    description: "Languages and tools used in Unix-like operating systems and shell environments.",
+    aliases: ["unix", "linux", "posix"],
+    targets: ["Unix", "Linux", "macOS", "BSD", "Operating systems"]
+  },
+  // Documentation / Publishing
+  {
+    slug: "documentation",
+    name: "Documentation",
+    description: "Languages used for writing, publishing, and technical documentation.",
+    aliases: ["documentation", "publishing", "technical-writing"],
+    targets: [
+      "Documentation",
+      "Publishing",
+      "Technical Writing",
+      "Technical writing",
+      "Academic Writing",
+      "Academic publishing"
+    ]
+  },
+  // Configuration
+  {
+    slug: "configuration",
+    name: "Configuration",
+    description: "Languages used for application and infrastructure configuration.",
+    aliases: ["configuration", "config"],
+    targets: ["Configuration", "Configuration Management"]
+  },
+  // Scripting / Automation
+  {
+    slug: "automation",
+    name: "Automation",
+    description: "Languages used for task automation, scripting, and workflow orchestration.",
+    aliases: ["automation", "scripting"],
+    targets: ["Automation", "Scripting", "DevOps", "CLI", "CLI Tools"]
+  },
+  // Apple / macOS
+  {
+    slug: "apple",
+    name: "Apple",
+    description: "Languages used for macOS, iOS, and the broader Apple platform.",
+    aliases: ["apple", "macos", "apple-platforms"],
+    targets: ["Apple", "Apple Platforms", "macOS", "iOS", "tvOS", "visionOS", "iPadOS"]
+  },
+  // Windows
+  {
+    slug: "windows",
+    name: "Windows",
+    description: "Languages used for Windows application and system development.",
+    aliases: ["windows"],
+    targets: ["Windows", "Windows Forms", "WPF", "UWP", "Desktop Applications"]
+  },
+  // Observability
+  {
+    slug: "observability",
+    name: "Observability",
+    description: "Languages used for monitoring, metrics, logging, and security analytics.",
+    aliases: ["observability", "monitoring", "metrics"],
+    targets: ["Observability", "Monitoring", "Metrics", "Security analytics"]
+  }
+];
+function findEcosystem(value) {
+  const key = value.trim().toLowerCase();
+  return ECOSYSTEM_REGISTRY.find((e) => e.aliases.includes(key));
+}
+function matchesEcosystem(lang, targets) {
+  const pool = lang.tooling?.ecosystems ?? [];
+  return targets.some((t) => pool.some((s) => s.toLowerCase().includes(t.toLowerCase())));
+}
+function ecosystemInfoFromDefinition(def) {
+  return {
+    slug: def.slug,
+    name: def.name,
+    description: def.description,
+    aliases: def.aliases
+  };
+}
+
 // src/domain/i18n/index.ts
 var localizeLanguage = (language, locale = "en") => {
   const { i18n, ...metadata } = language;
@@ -18026,7 +18308,6 @@ var languages = [
 // src/domain/package-manager/registry.ts
 var PACKAGE_MANAGER_REGISTRY = [
   {
-    slug: "npm",
     name: "npm",
     color: "#CB3837",
     logo: "https://cdn.simpleicons.org/npm",
@@ -18035,7 +18316,6 @@ var PACKAGE_MANAGER_REGISTRY = [
     targets: ["npm"]
   },
   {
-    slug: "pnpm",
     name: "pnpm",
     color: "#F69220",
     logo: "https://cdn.simpleicons.org/pnpm",
@@ -18044,7 +18324,6 @@ var PACKAGE_MANAGER_REGISTRY = [
     targets: ["pnpm"]
   },
   {
-    slug: "yarn",
     name: "Yarn",
     color: "#2C8EBB",
     logo: "https://cdn.simpleicons.org/yarn",
@@ -18053,7 +18332,6 @@ var PACKAGE_MANAGER_REGISTRY = [
     targets: ["Yarn"]
   },
   {
-    slug: "pip",
     name: "pip",
     color: "#3775A9",
     logo: "https://cdn.simpleicons.org/pypi",
@@ -18062,7 +18340,6 @@ var PACKAGE_MANAGER_REGISTRY = [
     targets: ["pip"]
   },
   {
-    slug: "poetry",
     name: "Poetry",
     color: "#60A5FA",
     logo: "https://cdn.simpleicons.org/poetry",
@@ -18071,7 +18348,6 @@ var PACKAGE_MANAGER_REGISTRY = [
     targets: ["Poetry"]
   },
   {
-    slug: "uv",
     name: "uv",
     color: "#DE5FE9",
     logo: "https://avatars.githubusercontent.com/u/115962839?v=4",
@@ -18080,7 +18356,6 @@ var PACKAGE_MANAGER_REGISTRY = [
     targets: ["uv"]
   },
   {
-    slug: "conda",
     name: "conda",
     color: "#44A833",
     logo: "https://cdn.simpleicons.org/anaconda",
@@ -18089,7 +18364,6 @@ var PACKAGE_MANAGER_REGISTRY = [
     targets: ["conda"]
   },
   {
-    slug: "cargo",
     name: "Cargo",
     color: "#CE422B",
     logo: "https://cdn.simpleicons.org/rust",
@@ -18098,7 +18372,6 @@ var PACKAGE_MANAGER_REGISTRY = [
     targets: ["Cargo"]
   },
   {
-    slug: "maven",
     name: "Maven",
     color: "#C71A36",
     logo: "https://cdn.simpleicons.org/apachemaven",
@@ -18107,7 +18380,6 @@ var PACKAGE_MANAGER_REGISTRY = [
     targets: ["Maven"]
   },
   {
-    slug: "gradle",
     name: "Gradle",
     color: "#02303A",
     logo: "https://cdn.simpleicons.org/gradle",
@@ -18116,7 +18388,6 @@ var PACKAGE_MANAGER_REGISTRY = [
     targets: ["Gradle"]
   },
   {
-    slug: "nuget",
     name: "NuGet",
     color: "#004880",
     logo: "https://cdn.simpleicons.org/nuget",
@@ -18125,7 +18396,6 @@ var PACKAGE_MANAGER_REGISTRY = [
     targets: ["NuGet"]
   },
   {
-    slug: "composer",
     name: "Composer",
     color: "#885630",
     logo: "https://cdn.simpleicons.org/composer",
@@ -18134,7 +18404,6 @@ var PACKAGE_MANAGER_REGISTRY = [
     targets: ["Composer"]
   },
   {
-    slug: "hex",
     name: "Hex",
     color: "#6E4A7E",
     logo: "https://cdn.simpleicons.org/elixir",
@@ -18143,7 +18412,6 @@ var PACKAGE_MANAGER_REGISTRY = [
     targets: ["Hex"]
   },
   {
-    slug: "mix",
     name: "Mix",
     color: "#6E4A7E",
     logo: "https://cdn.simpleicons.org/elixir",
@@ -18152,7 +18420,6 @@ var PACKAGE_MANAGER_REGISTRY = [
     targets: ["Mix"]
   },
   {
-    slug: "cabal",
     name: "Cabal",
     color: "#5D4F85",
     logo: "https://cdn.simpleicons.org/haskell",
@@ -18161,7 +18428,6 @@ var PACKAGE_MANAGER_REGISTRY = [
     targets: ["Cabal"]
   },
   {
-    slug: "stack",
     name: "Stack",
     color: "#5D4F85",
     logo: "https://cdn.simpleicons.org/haskell",
@@ -18170,7 +18436,6 @@ var PACKAGE_MANAGER_REGISTRY = [
     targets: ["Stack"]
   },
   {
-    slug: "pub",
     name: "pub",
     color: "#0175C2",
     logo: "https://cdn.simpleicons.org/dart",
@@ -18179,7 +18444,6 @@ var PACKAGE_MANAGER_REGISTRY = [
     targets: ["pub"]
   },
   {
-    slug: "cocoapods",
     name: "CocoaPods",
     color: "#EE3322",
     logo: "https://cdn.simpleicons.org/cocoapods",
@@ -18188,7 +18452,6 @@ var PACKAGE_MANAGER_REGISTRY = [
     targets: ["CocoaPods"]
   },
   {
-    slug: "spm",
     name: "Swift PM",
     color: "#F05138",
     logo: "https://cdn.simpleicons.org/swift",
@@ -18197,7 +18460,6 @@ var PACKAGE_MANAGER_REGISTRY = [
     targets: ["Swift Package Manager"]
   },
   {
-    slug: "rubygems",
     name: "RubyGems",
     color: "#E9573F",
     logo: "https://cdn.simpleicons.org/rubygems",
@@ -18206,7 +18468,6 @@ var PACKAGE_MANAGER_REGISTRY = [
     targets: ["RubyGems", "Bundler"]
   },
   {
-    slug: "go-mod",
     name: "Go modules",
     color: "#00ADD8",
     logo: "https://cdn.simpleicons.org/go",
@@ -18215,7 +18476,6 @@ var PACKAGE_MANAGER_REGISTRY = [
     targets: ["Go modules"]
   },
   {
-    slug: "luarocks",
     name: "LuaRocks",
     color: "#2C2D72",
     logo: "https://cdn.simpleicons.org/lua",
@@ -18224,7 +18484,6 @@ var PACKAGE_MANAGER_REGISTRY = [
     targets: ["LuaRocks"]
   },
   {
-    slug: "opam",
     name: "Opam",
     color: "#EF7A08",
     logo: "https://avatars.githubusercontent.com/u/1841483?v=4",
@@ -18233,7 +18492,6 @@ var PACKAGE_MANAGER_REGISTRY = [
     targets: ["opam"]
   },
   {
-    slug: "cpan",
     name: "CPAN",
     color: "#39457E",
     logo: "https://cdn.simpleicons.org/perl",
@@ -18251,8 +18509,9 @@ function matchesPackageManager(lang, targets) {
   return targets.some((t) => pool.some((s) => s.toLowerCase().includes(t.toLowerCase())));
 }
 function packageManagerInfoFromDefinition(def) {
+  const slug = def.aliases[0] ?? def.name.toLowerCase();
   return {
-    slug: def.slug,
+    slug,
     name: def.name,
     website: def.website,
     logo: def.logo,
@@ -18261,6 +18520,145 @@ function packageManagerInfoFromDefinition(def) {
   };
 }
 
+// src/domain/paradigm/registry.ts
+var PARADIGM_REGISTRY = [
+  {
+    slug: "functional",
+    name: "Functional",
+    description: "Computation through function evaluation, immutability, and avoiding side effects.",
+    aliases: ["functional", "fp", "pure-functional"],
+    targets: ["functional", "pure functional", "pure"]
+  },
+  {
+    slug: "object-oriented",
+    name: "Object-Oriented",
+    description: "Organizes code around objects with encapsulation, inheritance, and polymorphism.",
+    aliases: ["object-oriented", "oop", "object-oriented-programming"],
+    targets: ["object-oriented", "class-based", "prototype-based"]
+  },
+  {
+    slug: "imperative",
+    name: "Imperative",
+    description: "Specifies sequences of statements that change program state step by step.",
+    aliases: ["imperative", "procedural"],
+    targets: ["imperative", "procedural", "structured"]
+  },
+  {
+    slug: "declarative",
+    name: "Declarative",
+    description: "Expresses the logic of a computation without describing control flow.",
+    aliases: ["declarative"],
+    targets: ["declarative"]
+  },
+  {
+    slug: "logic",
+    name: "Logic",
+    description: "Programs expressed as logical facts, rules, and constraints.",
+    aliases: ["logic", "logic-programming", "constraint"],
+    targets: ["logic", "constraint", "relational"]
+  },
+  {
+    slug: "concurrent",
+    name: "Concurrent",
+    description: "Languages with first-class support for concurrency, actors, and message passing.",
+    aliases: ["concurrent", "actor-model", "parallel"],
+    targets: ["concurrent", "actor-model", "message-passing", "parallel", "distributed"]
+  },
+  {
+    slug: "reactive",
+    name: "Reactive",
+    description: "Languages oriented around data flows and propagation of change.",
+    aliases: ["reactive", "dataflow", "event-driven"],
+    targets: ["reactive", "dataflow", "event-driven"]
+  },
+  {
+    slug: "generic",
+    name: "Generic",
+    description: "Languages with parametric polymorphism and generic type abstractions.",
+    aliases: ["generic", "generics"],
+    targets: ["generic"]
+  },
+  {
+    slug: "scripting",
+    name: "Scripting",
+    description: "Languages designed for automation, shell scripting, and task execution.",
+    aliases: ["scripting", "shell"],
+    targets: ["scripting", "shell"]
+  },
+  {
+    slug: "query",
+    name: "Query",
+    description: "Languages for querying structured data sources and databases.",
+    aliases: ["query", "querying"],
+    targets: ["query"]
+  },
+  {
+    slug: "markup",
+    name: "Markup",
+    description: "Languages for annotating documents with structural tags and formatting.",
+    aliases: ["markup"],
+    targets: ["markup", "hypertext"]
+  },
+  {
+    slug: "templating",
+    name: "Templating",
+    description: "Languages for generating text documents from parameterized templates.",
+    aliases: ["templating", "template"],
+    targets: ["templating", "template"]
+  },
+  {
+    slug: "array",
+    name: "Array",
+    description: "Languages built around vectorized array and matrix operations.",
+    aliases: ["array", "array-oriented"],
+    targets: ["array", "array-oriented"]
+  },
+  {
+    slug: "metaprogramming",
+    name: "Metaprogramming",
+    description: "Languages with strong support for macros, code generation, and reflection.",
+    aliases: ["metaprogramming", "meta", "macro"],
+    targets: ["metaprogramming", "meta-programming", "macro"]
+  },
+  {
+    slug: "systems",
+    name: "Systems",
+    description: "Low-level languages designed for systems, embedded, and OS programming.",
+    aliases: ["systems", "low-level"],
+    targets: ["systems", "low-level"]
+  },
+  {
+    slug: "stack-based",
+    name: "Stack-Based",
+    description: "Languages where computation operates on an explicit stack.",
+    aliases: ["stack-based", "concatenative", "stack"],
+    targets: ["stack-based", "concatenative"]
+  },
+  {
+    slug: "shader",
+    name: "Shader",
+    description: "Languages for GPU programming, graphics pipelines, and shader stages.",
+    aliases: ["shader", "shading", "gpu"],
+    targets: ["shader", "shading", "gpu-programming", "gpu-compute"]
+  }
+];
+function findParadigm(value) {
+  const key = value.trim().toLowerCase();
+  return PARADIGM_REGISTRY.find((p) => p.aliases.includes(key));
+}
+function matchesParadigm(lang, targets) {
+  const pool = lang.paradigms;
+  return targets.some((t) => pool.some((s) => s.toLowerCase().includes(t.toLowerCase())));
+}
+function paradigmInfoFromDefinition(def) {
+  return {
+    slug: def.slug,
+    name: def.name,
+    description: def.description,
+    aliases: def.aliases
+  };
+}
+
 // src/domain/runtime/registry.ts
 var RUNTIME_REGISTRY = [
   // JavaScript runtimes
@@ -18759,6 +19157,7 @@ function runtimesForPackageManager(targets) {
 
 // src/api.ts
 var defaultLocale = "en";
+var languageMap = new Map(languages.map((l) => [l.slug, l]));
 var normalizeLanguageSlug = (slug) => slug.trim().toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
 var localizeOptionalLanguage = (language, locale) => language ? localizeLanguage(language, locale) : void 0;
 var createLanguageRequest = (getLanguage, loadLanguageModule) => {
@@ -18800,7 +19199,7 @@ var loadDetectedLanguages = async (filename) => {
   );
   return detectedLanguages.filter((language) => Boolean(language));
 };
-var getLanguageBySlug = (slug) => languages.find((language) => language.slug === slug);
+var getLanguageBySlug = (slug) => languageMap.get(slug);
 var getDetectedLanguages = (filename) => detectLanguageSlugs(filename).map((slug) => getLanguageBySlug(slug)).filter((language) => Boolean(language));
 var api = {
   /**
@@ -18814,7 +19213,7 @@ var api = {
   language(slug) {
     const normalizedSlug = normalizeLanguageSlug(slug);
     return createLanguageRequest(
-      () => languages.find((language) => language.slug === normalizedSlug),
+      () => languageMap.get(normalizedSlug),
       () => loadLanguage(normalizedSlug)
     );
   },
@@ -18932,6 +19331,58 @@ var api = {
       }
     };
   },
+  /**
+   * Selects every language that uses the given programming paradigm.
+   *
+   * Accepts common aliases: 'functional', 'fp', 'object-oriented', 'oop', 'declarative', etc.
+   * Searches `language.paradigms`.
+   *
+   * @example
+   * api.paradigm('functional').langs().locale('es').get();
+   * api.paradigm('oop').info();
+   */
+  paradigm(value) {
+    const definition = findParadigm(value);
+    const targets = definition?.targets ?? [value];
+    return {
+      info() {
+        return definition ? paradigmInfoFromDefinition(definition) : void 0;
+      },
+      langs() {
+        const filtered = () => languages.filter((lang) => matchesParadigm(lang, targets));
+        return createLanguageCollectionRequest(filtered, async () => {
+          const loaded = await Promise.all(filtered().map((lang) => loadLanguage(lang.slug)));
+          return loaded.filter((lang) => Boolean(lang));
+        });
+      }
+    };
+  },
+  /**
+   * Selects every language that belongs to the given ecosystem.
+   *
+   * Accepts common aliases: 'web', 'jvm', 'dotnet', 'devops', 'data-science', 'embedded', etc.
+   * Searches `tooling.ecosystems`.
+   *
+   * @example
+   * api.ecosystem('jvm').langs().locale('es').get();
+   * api.ecosystem('blockchain').info();
+   */
+  ecosystem(value) {
+    const definition = findEcosystem(value);
+    const targets = definition?.targets ?? [value];
+    return {
+      info() {
+        return definition ? ecosystemInfoFromDefinition(definition) : void 0;
+      },
+      langs() {
+        const filtered = () => languages.filter((lang) => matchesEcosystem(lang, targets));
+        return createLanguageCollectionRequest(filtered, async () => {
+          const loaded = await Promise.all(filtered().map((lang) => loadLanguage(lang.slug)));
+          return loaded.filter((lang) => Boolean(lang));
+        });
+      }
+    };
+  },
   /**
    * Detects every matching language for a filename or path.
    *