code-languages 1.28.0 → 1.29.1

package/dist/languages/flux.js

@@ -0,0 +1,50 @@
+// src/languages/flux.ts
+var flux = {
+  slug: "flux",
+  publishedDate: "2018-09-01",
+  extensions: [".flux"],
+  author: "InfluxData",
+  website: "https://www.influxdata.com/products/flux/",
+  paradigms: ["functional", "declarative"],
+  tooling: {
+    runtimes: ["InfluxDB", "Flux CLI"],
+    ecosystems: ["Time Series", "Monitoring", "Observability", "InfluxDB"]
+  },
+  version: "0.200.0",
+  logo: "https://avatars.githubusercontent.com/u/5713248?v=4",
+  color: "#22ADF6",
+  i18n: {
+    en: {
+      name: "Flux",
+      description: "A functional data scripting language by InfluxData for querying, analyzing, and transforming time-series data in InfluxDB.",
+      longDescription: "Flux is a functional data scripting and query language designed by InfluxData for working with time-series data. It replaced InfluxQL as the primary query language for InfluxDB 2.0 and provides a more expressive and composable approach to data transformation.\n\nFlux uses a pipe-forward operator (|>) to chain data transformations in a readable pipeline style. It supports filtering, grouping, windowing, aggregations, joins, and mathematical operations on time-series data. Flux is also capable of querying non-InfluxDB data sources and writing results back to databases, making it useful as a general ETL scripting language for monitoring and observability pipelines."
+    },
+    es: {
+      name: "Flux",
+      description: "Un lenguaje funcional de scripting de datos de InfluxData para consultar, analizar y transformar datos de series temporales en InfluxDB.",
+      longDescription: "Flux es un lenguaje funcional de scripting y consultas dise\xF1ado por InfluxData para trabajar con datos de series temporales. Reemplaz\xF3 a InfluxQL como lenguaje de consultas principal para InfluxDB 2.0 y proporciona un enfoque m\xE1s expresivo y composable para la transformaci\xF3n de datos.\n\nFlux usa el operador pipe-forward (|>) para encadenar transformaciones de datos en un estilo de pipeline legible. Soporta filtrado, agrupaci\xF3n, ventanas temporales, agregaciones, joins y operaciones matem\xE1ticas sobre datos de series temporales."
+    },
+    it: {
+      name: "Flux",
+      description: "Un linguaggio funzionale di scripting dati di InfluxData per interrogare, analizzare e trasformare dati di serie temporali in InfluxDB.",
+      longDescription: "Flux \xE8 un linguaggio funzionale di scripting e query progettato da InfluxData per lavorare con dati di serie temporali. Ha sostituito InfluxQL come linguaggio di query principale per InfluxDB 2.0 e fornisce un approccio pi\xF9 espressivo e componibile alla trasformazione dei dati.\n\nFlux usa l'operatore pipe-forward (|>) per concatenare trasformazioni di dati in uno stile di pipeline leggibile. Supporta filtraggio, raggruppamento, windowing, aggregazioni, join e operazioni matematiche su dati di serie temporali."
+    },
+    fr: {
+      name: "Flux",
+      description: "Un langage de script de donn\xE9es fonctionnel d'InfluxData pour interroger, analyser et transformer des donn\xE9es de s\xE9ries temporelles dans InfluxDB.",
+      longDescription: "Flux est un langage fonctionnel de script et de requ\xEAte con\xE7u par InfluxData pour travailler avec des donn\xE9es de s\xE9ries temporelles. Il a remplac\xE9 InfluxQL comme langage de requ\xEAte principal pour InfluxDB 2.0 et offre une approche plus expressive et composable de la transformation des donn\xE9es.\n\nFlux utilise l'op\xE9rateur pipe-forward (|>) pour cha\xEEner les transformations de donn\xE9es dans un style de pipeline lisible. Il prend en charge le filtrage, le regroupement, le fen\xEAtrage, les agr\xE9gations, les jointures et les op\xE9rations math\xE9matiques sur les donn\xE9es de s\xE9ries temporelles."
+    },
+    de: {
+      name: "Flux",
+      description: "Eine funktionale Datenskriptsprache von InfluxData zum Abfragen, Analysieren und Transformieren von Zeitreihendaten in InfluxDB.",
+      longDescription: "Flux ist eine funktionale Datenskript- und Abfragesprache, die von InfluxData f\xFCr die Arbeit mit Zeitreihendaten entwickelt wurde. Sie ersetzte InfluxQL als prim\xE4re Abfragesprache f\xFCr InfluxDB 2.0 und bietet einen ausdrucksst\xE4rkeren und kompositionsf\xE4higeren Ansatz zur Datentransformation.\n\nFlux verwendet den Pipe-Forward-Operator (|>), um Datentransformationen in einem lesbaren Pipeline-Stil zu verketten. Es unterst\xFCtzt Filterung, Gruppierung, Fenstering, Aggregationen, Joins und mathematische Operationen auf Zeitreihendaten."
+    },
+    pt: {
+      name: "Flux",
+      description: "Uma linguagem funcional de script de dados da InfluxData para consultar, analisar e transformar dados de s\xE9ries temporais no InfluxDB.",
+      longDescription: "Flux \xE9 uma linguagem funcional de script e consulta projetada pela InfluxData para trabalhar com dados de s\xE9ries temporais. Substituiu o InfluxQL como linguagem de consulta principal para o InfluxDB 2.0 e fornece uma abordagem mais expressiva e compos\xEDvel para transforma\xE7\xE3o de dados.\n\nFlux usa o operador pipe-forward (|>) para encadear transforma\xE7\xF5es de dados em um estilo de pipeline leg\xEDvel. Suporta filtragem, agrupamento, janelamento, agrega\xE7\xF5es, joins e opera\xE7\xF5es matem\xE1ticas em dados de s\xE9ries temporais."
+    }
+  }
+};
+
+export { flux };

package/dist/languages/grain.cjs

@@ -0,0 +1,53 @@
+'use strict';
+
+// src/languages/grain.ts
+var grain = {
+  slug: "grain",
+  publishedDate: "2020-08-04",
+  extensions: [".gr"],
+  author: "Oscar Spencer",
+  website: "https://grain-lang.org",
+  paradigms: ["functional", "imperative"],
+  tooling: {
+    runtimes: ["grain CLI", "WebAssembly"],
+    packageManagers: ["grain (built-in)"],
+    ecosystems: ["WebAssembly", "Web", "Server"]
+  },
+  version: "grain-v0.7.2",
+  logo: "https://avatars.githubusercontent.com/u/54953488?v=4",
+  color: "#7C4DFF",
+  i18n: {
+    en: {
+      name: "Grain",
+      description: "A functional programming language that compiles to WebAssembly first, featuring a strong type system and memory safety without garbage collection pauses.",
+      longDescription: "Grain is a strongly typed, functional programming language that targets WebAssembly as its primary compilation target. Designed from the ground up with WebAssembly in mind, it produces compact and efficient WASM modules that run in browsers, Node.js, and any WASI-compliant runtime.\n\nGrain features algebraic data types, pattern matching, type inference, closures, and a module system. Its memory model avoids garbage collection pauses through reference counting with cycle detection. The standard library covers strings, numbers, lists, maps, file I/O, and more, making Grain suitable for building both web frontend and server-side WebAssembly applications."
+    },
+    es: {
+      name: "Grain",
+      description: "Lenguaje funcional que compila a WebAssembly, con un sistema de tipos fuerte y seguridad de memoria sin pausas de recolecci\xF3n de basura.",
+      longDescription: "Grain es un lenguaje funcional de tipado fuerte que tiene WebAssembly como destino principal de compilaci\xF3n. Dise\xF1ado desde cero pensando en WebAssembly, produce m\xF3dulos WASM compactos y eficientes que se ejecutan en navegadores, Node.js y cualquier runtime compatible con WASI.\n\nGrain incluye tipos de datos algebraicos, coincidencia de patrones, inferencia de tipos, closures y un sistema de m\xF3dulos. Su modelo de memoria evita pausas de GC mediante conteo de referencias con detecci\xF3n de ciclos."
+    },
+    it: {
+      name: "Grain",
+      description: "Linguaggio funzionale che compila in WebAssembly, con un sistema di tipi forte e sicurezza della memoria senza pause di garbage collection.",
+      longDescription: "Grain \xE8 un linguaggio funzionale fortemente tipizzato che ha WebAssembly come target di compilazione principale. Progettato da zero pensando a WebAssembly, produce moduli WASM compatti ed efficienti che girano nei browser, Node.js e qualsiasi runtime compatibile con WASI.\n\nGrain include tipi di dati algebrici, pattern matching, inferenza di tipi, closure e un sistema di moduli. Il suo modello di memoria evita le pause GC tramite reference counting con rilevamento dei cicli."
+    },
+    fr: {
+      name: "Grain",
+      description: "Langage fonctionnel qui compile vers WebAssembly, avec un syst\xE8me de types fort et une s\xE9curit\xE9 m\xE9moire sans pauses de garbage collection.",
+      longDescription: "Grain est un langage fonctionnel fortement typ\xE9 qui cible WebAssembly comme destination de compilation principale. Con\xE7u d\xE8s le d\xE9part en pensant \xE0 WebAssembly, il produit des modules WASM compacts et efficaces qui s'ex\xE9cutent dans les navigateurs, Node.js et tout runtime compatible WASI.\n\nGrain inclut des types de donn\xE9es alg\xE9briques, le pattern matching, l'inf\xE9rence de types, les closures et un syst\xE8me de modules. Son mod\xE8le m\xE9moire \xE9vite les pauses GC gr\xE2ce au comptage de r\xE9f\xE9rences avec d\xE9tection de cycles."
+    },
+    de: {
+      name: "Grain",
+      description: "Eine funktionale Programmiersprache, die prim\xE4r nach WebAssembly kompiliert, mit einem starken Typsystem und Speichersicherheit ohne Garbage-Collection-Pausen.",
+      longDescription: "Grain ist eine stark typisierte, funktionale Programmiersprache, die WebAssembly als prim\xE4res Kompilierungsziel verwendet. Von Grund auf mit WebAssembly im Sinn entwickelt, erzeugt sie kompakte und effiziente WASM-Module, die in Browsern, Node.js und jeder WASI-kompatiblen Laufzeitumgebung ausgef\xFChrt werden k\xF6nnen.\n\nGrain bietet algebraische Datentypen, Pattern Matching, Typinferenz, Closures und ein Modulsystem. Das Speichermodell vermeidet GC-Pausen durch Referenzz\xE4hlung mit Zyklenerkennung."
+    },
+    pt: {
+      name: "Grain",
+      description: "Linguagem funcional que compila para WebAssembly, com um sistema de tipos forte e seguran\xE7a de mem\xF3ria sem pausas de garbage collection.",
+      longDescription: "Grain \xE9 uma linguagem funcional fortemente tipada que tem WebAssembly como principal alvo de compila\xE7\xE3o. Projetada do zero pensando em WebAssembly, produz m\xF3dulos WASM compactos e eficientes que rodam em navegadores, Node.js e qualquer runtime compat\xEDvel com WASI.\n\nGrain inclui tipos de dados alg\xE9bricos, correspond\xEAncia de padr\xF5es, infer\xEAncia de tipos, closures e um sistema de m\xF3dulos. Seu modelo de mem\xF3ria evita pausas de GC por meio de contagem de refer\xEAncias com detec\xE7\xE3o de ciclos."
+    }
+  }
+};
+
+exports.grain = grain;

package/dist/languages/grain.d.cts

@@ -0,0 +1,50 @@
+declare const grain: {
+    slug: string;
+    publishedDate: string;
+    extensions: string[];
+    author: string;
+    website: string;
+    paradigms: string[];
+    tooling: {
+        runtimes: string[];
+        packageManagers: string[];
+        ecosystems: string[];
+    };
+    version: string;
+    logo: string;
+    color: "#7C4DFF";
+    i18n: {
+        en: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        es: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        it: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        fr: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        de: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        pt: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+    };
+};
+
+export { grain };

package/dist/languages/grain.d.ts

@@ -0,0 +1,50 @@
+declare const grain: {
+    slug: string;
+    publishedDate: string;
+    extensions: string[];
+    author: string;
+    website: string;
+    paradigms: string[];
+    tooling: {
+        runtimes: string[];
+        packageManagers: string[];
+        ecosystems: string[];
+    };
+    version: string;
+    logo: string;
+    color: "#7C4DFF";
+    i18n: {
+        en: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        es: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        it: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        fr: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        de: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        pt: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+    };
+};
+
+export { grain };

package/dist/languages/grain.js

@@ -0,0 +1,51 @@
+// src/languages/grain.ts
+var grain = {
+  slug: "grain",
+  publishedDate: "2020-08-04",
+  extensions: [".gr"],
+  author: "Oscar Spencer",
+  website: "https://grain-lang.org",
+  paradigms: ["functional", "imperative"],
+  tooling: {
+    runtimes: ["grain CLI", "WebAssembly"],
+    packageManagers: ["grain (built-in)"],
+    ecosystems: ["WebAssembly", "Web", "Server"]
+  },
+  version: "grain-v0.7.2",
+  logo: "https://avatars.githubusercontent.com/u/54953488?v=4",
+  color: "#7C4DFF",
+  i18n: {
+    en: {
+      name: "Grain",
+      description: "A functional programming language that compiles to WebAssembly first, featuring a strong type system and memory safety without garbage collection pauses.",
+      longDescription: "Grain is a strongly typed, functional programming language that targets WebAssembly as its primary compilation target. Designed from the ground up with WebAssembly in mind, it produces compact and efficient WASM modules that run in browsers, Node.js, and any WASI-compliant runtime.\n\nGrain features algebraic data types, pattern matching, type inference, closures, and a module system. Its memory model avoids garbage collection pauses through reference counting with cycle detection. The standard library covers strings, numbers, lists, maps, file I/O, and more, making Grain suitable for building both web frontend and server-side WebAssembly applications."
+    },
+    es: {
+      name: "Grain",
+      description: "Lenguaje funcional que compila a WebAssembly, con un sistema de tipos fuerte y seguridad de memoria sin pausas de recolecci\xF3n de basura.",
+      longDescription: "Grain es un lenguaje funcional de tipado fuerte que tiene WebAssembly como destino principal de compilaci\xF3n. Dise\xF1ado desde cero pensando en WebAssembly, produce m\xF3dulos WASM compactos y eficientes que se ejecutan en navegadores, Node.js y cualquier runtime compatible con WASI.\n\nGrain incluye tipos de datos algebraicos, coincidencia de patrones, inferencia de tipos, closures y un sistema de m\xF3dulos. Su modelo de memoria evita pausas de GC mediante conteo de referencias con detecci\xF3n de ciclos."
+    },
+    it: {
+      name: "Grain",
+      description: "Linguaggio funzionale che compila in WebAssembly, con un sistema di tipi forte e sicurezza della memoria senza pause di garbage collection.",
+      longDescription: "Grain \xE8 un linguaggio funzionale fortemente tipizzato che ha WebAssembly come target di compilazione principale. Progettato da zero pensando a WebAssembly, produce moduli WASM compatti ed efficienti che girano nei browser, Node.js e qualsiasi runtime compatibile con WASI.\n\nGrain include tipi di dati algebrici, pattern matching, inferenza di tipi, closure e un sistema di moduli. Il suo modello di memoria evita le pause GC tramite reference counting con rilevamento dei cicli."
+    },
+    fr: {
+      name: "Grain",
+      description: "Langage fonctionnel qui compile vers WebAssembly, avec un syst\xE8me de types fort et une s\xE9curit\xE9 m\xE9moire sans pauses de garbage collection.",
+      longDescription: "Grain est un langage fonctionnel fortement typ\xE9 qui cible WebAssembly comme destination de compilation principale. Con\xE7u d\xE8s le d\xE9part en pensant \xE0 WebAssembly, il produit des modules WASM compacts et efficaces qui s'ex\xE9cutent dans les navigateurs, Node.js et tout runtime compatible WASI.\n\nGrain inclut des types de donn\xE9es alg\xE9briques, le pattern matching, l'inf\xE9rence de types, les closures et un syst\xE8me de modules. Son mod\xE8le m\xE9moire \xE9vite les pauses GC gr\xE2ce au comptage de r\xE9f\xE9rences avec d\xE9tection de cycles."
+    },
+    de: {
+      name: "Grain",
+      description: "Eine funktionale Programmiersprache, die prim\xE4r nach WebAssembly kompiliert, mit einem starken Typsystem und Speichersicherheit ohne Garbage-Collection-Pausen.",
+      longDescription: "Grain ist eine stark typisierte, funktionale Programmiersprache, die WebAssembly als prim\xE4res Kompilierungsziel verwendet. Von Grund auf mit WebAssembly im Sinn entwickelt, erzeugt sie kompakte und effiziente WASM-Module, die in Browsern, Node.js und jeder WASI-kompatiblen Laufzeitumgebung ausgef\xFChrt werden k\xF6nnen.\n\nGrain bietet algebraische Datentypen, Pattern Matching, Typinferenz, Closures und ein Modulsystem. Das Speichermodell vermeidet GC-Pausen durch Referenzz\xE4hlung mit Zyklenerkennung."
+    },
+    pt: {
+      name: "Grain",
+      description: "Linguagem funcional que compila para WebAssembly, com um sistema de tipos forte e seguran\xE7a de mem\xF3ria sem pausas de garbage collection.",
+      longDescription: "Grain \xE9 uma linguagem funcional fortemente tipada que tem WebAssembly como principal alvo de compila\xE7\xE3o. Projetada do zero pensando em WebAssembly, produz m\xF3dulos WASM compactos e eficientes que rodam em navegadores, Node.js e qualquer runtime compat\xEDvel com WASI.\n\nGrain inclui tipos de dados alg\xE9bricos, correspond\xEAncia de padr\xF5es, infer\xEAncia de tipos, closures e um sistema de m\xF3dulos. Seu modelo de mem\xF3ria evita pausas de GC por meio de contagem de refer\xEAncias com detec\xE7\xE3o de ciclos."
+    }
+  }
+};
+
+export { grain };

package/dist/languages/hare.cjs

@@ -0,0 +1,53 @@
+'use strict';
+
+// src/languages/hare.ts
+var hare = {
+  slug: "hare",
+  publishedDate: "2022-04-25",
+  extensions: [".ha"],
+  author: "Drew DeVault",
+  website: "https://harelang.org",
+  paradigms: ["imperative", "systems"],
+  tooling: {
+    runtimes: ["hare"],
+    packageManagers: ["hare (built-in modules)"],
+    ecosystems: ["Systems", "Embedded", "Unix", "Linux"]
+  },
+  version: "0.25.1",
+  logo: "https://harelang.org/mascot.png",
+  color: "#5D4E37",
+  i18n: {
+    en: {
+      name: "Hare",
+      description: "A systems programming language designed to be simple, stable, and robust, with explicit memory management and no hidden control flow.",
+      longDescription: "Hare is a systems programming language designed by Drew DeVault with an emphasis on simplicity, stability, and long-term maintainability. It targets Unix-like operating systems and bare-metal environments, serving as a modern alternative to C.\n\nHare has no runtime, no garbage collector, and no hidden control flow. Memory management is manual and explicit. The language includes tagged unions, slices, deferred function calls, and a standard library that covers I/O, networking, cryptography, and datetime handling. Hare uses a reproducible build system and aims for a stable specification that does not change, making it suitable for long-lived systems software."
+    },
+    es: {
+      name: "Hare",
+      description: "Un lenguaje de programaci\xF3n de sistemas dise\xF1ado para ser simple, estable y robusto, con gesti\xF3n de memoria expl\xEDcita y sin flujo de control oculto.",
+      longDescription: "Hare es un lenguaje de programaci\xF3n de sistemas dise\xF1ado por Drew DeVault con \xE9nfasis en la simplicidad, estabilidad y mantenibilidad a largo plazo. Est\xE1 dirigido a sistemas operativos Unix-like y entornos bare-metal, como alternativa moderna a C.\n\nHare no tiene runtime ni recolector de basura, y no tiene flujo de control oculto. La gesti\xF3n de memoria es manual y expl\xEDcita. El lenguaje incluye uniones etiquetadas, slices, llamadas diferidas y una biblioteca est\xE1ndar que cubre E/S, redes, criptograf\xEDa y fechas."
+    },
+    it: {
+      name: "Hare",
+      description: "Linguaggio di sistema semplice e stabile con gestione esplicita della memoria e senza flusso di controllo nascosto.",
+      longDescription: "Hare \xE8 un linguaggio di programmazione di sistema progettato da Drew DeVault con enfasi su semplicit\xE0, stabilit\xE0 e manutenibilit\xE0 a lungo termine. \xC8 destinato a sistemi operativi Unix-like e ambienti bare-metal, come alternativa moderna a C.\n\nHare non ha runtime n\xE9 garbage collector, e non ha flusso di controllo nascosto. La gestione della memoria \xE8 manuale ed esplicita. Il linguaggio include union taggate, slice, chiamate differite e una libreria standard che copre I/O, rete, crittografia e gestione delle date."
+    },
+    fr: {
+      name: "Hare",
+      description: "Un langage de programmation syst\xE8me con\xE7u pour \xEAtre simple, stable et robuste, avec une gestion de m\xE9moire explicite et sans flux de contr\xF4le cach\xE9.",
+      longDescription: "Hare est un langage de programmation syst\xE8me con\xE7u par Drew DeVault avec un accent sur la simplicit\xE9, la stabilit\xE9 et la maintenabilit\xE9 \xE0 long terme. Il cible les syst\xE8mes d'exploitation de type Unix et les environnements bare-metal, comme alternative moderne \xE0 C.\n\nHare n'a pas de runtime ni de garbage collector, et pas de flux de contr\xF4le cach\xE9. La gestion de la m\xE9moire est manuelle et explicite. Le langage inclut des unions \xE9tiquet\xE9es, des slices, des appels diff\xE9r\xE9s et une biblioth\xE8que standard couvrant l'I/O, le r\xE9seau, la cryptographie et la gestion des dates."
+    },
+    de: {
+      name: "Hare",
+      description: "Systemprogrammiersprache f\xFCr Einfachheit, Stabilit\xE4t und Robustheit, mit expliziter Speicherverwaltung und ohne verborgenen Kontrollfluss.",
+      longDescription: "Hare ist eine von Drew DeVault entwickelte Systemprogrammiersprache mit Schwerpunkt auf Einfachheit, Stabilit\xE4t und langfristiger Wartbarkeit. Sie zielt auf Unix-\xE4hnliche Betriebssysteme und Bare-Metal-Umgebungen als moderne Alternative zu C.\n\nHare hat keine Laufzeitumgebung, keinen Garbage Collector und keinen verborgenen Kontrollfluss. Die Speicherverwaltung ist manuell und explizit. Die Sprache umfasst Tagged Unions, Slices, verz\xF6gerte Funktionsaufrufe und eine Standardbibliothek f\xFCr I/O, Netzwerk, Kryptographie und Datumsverwaltung."
+    },
+    pt: {
+      name: "Hare",
+      description: "Uma linguagem de programa\xE7\xE3o de sistemas projetada para ser simples, est\xE1vel e robusta, com gerenciamento de mem\xF3ria expl\xEDcito e sem fluxo de controle oculto.",
+      longDescription: "Hare \xE9 uma linguagem de programa\xE7\xE3o de sistemas projetada por Drew DeVault com \xEAnfase em simplicidade, estabilidade e manutenibilidade a longo prazo. Destina-se a sistemas operacionais Unix-like e ambientes bare-metal, como alternativa moderna ao C.\n\nHare n\xE3o tem runtime nem coletor de lixo, e n\xE3o tem fluxo de controle oculto. O gerenciamento de mem\xF3ria \xE9 manual e expl\xEDcito. A linguagem inclui uni\xF5es marcadas, slices, chamadas diferidas e uma biblioteca padr\xE3o que cobre I/O, rede, criptografia e manipula\xE7\xE3o de datas."
+    }
+  }
+};
+
+exports.hare = hare;

package/dist/languages/hare.d.cts

@@ -0,0 +1,50 @@
+declare const hare: {
+    slug: string;
+    publishedDate: string;
+    extensions: string[];
+    author: string;
+    website: string;
+    paradigms: string[];
+    tooling: {
+        runtimes: string[];
+        packageManagers: string[];
+        ecosystems: string[];
+    };
+    version: string;
+    logo: string;
+    color: "#5D4E37";
+    i18n: {
+        en: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        es: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        it: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        fr: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        de: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        pt: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+    };
+};
+
+export { hare };

package/dist/languages/hare.d.ts

@@ -0,0 +1,50 @@
+declare const hare: {
+    slug: string;
+    publishedDate: string;
+    extensions: string[];
+    author: string;
+    website: string;
+    paradigms: string[];
+    tooling: {
+        runtimes: string[];
+        packageManagers: string[];
+        ecosystems: string[];
+    };
+    version: string;
+    logo: string;
+    color: "#5D4E37";
+    i18n: {
+        en: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        es: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        it: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        fr: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        de: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        pt: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+    };
+};
+
+export { hare };

package/dist/languages/hare.js

@@ -0,0 +1,51 @@
+// src/languages/hare.ts
+var hare = {
+  slug: "hare",
+  publishedDate: "2022-04-25",
+  extensions: [".ha"],
+  author: "Drew DeVault",
+  website: "https://harelang.org",
+  paradigms: ["imperative", "systems"],
+  tooling: {
+    runtimes: ["hare"],
+    packageManagers: ["hare (built-in modules)"],
+    ecosystems: ["Systems", "Embedded", "Unix", "Linux"]
+  },
+  version: "0.25.1",
+  logo: "https://harelang.org/mascot.png",
+  color: "#5D4E37",
+  i18n: {
+    en: {
+      name: "Hare",
+      description: "A systems programming language designed to be simple, stable, and robust, with explicit memory management and no hidden control flow.",
+      longDescription: "Hare is a systems programming language designed by Drew DeVault with an emphasis on simplicity, stability, and long-term maintainability. It targets Unix-like operating systems and bare-metal environments, serving as a modern alternative to C.\n\nHare has no runtime, no garbage collector, and no hidden control flow. Memory management is manual and explicit. The language includes tagged unions, slices, deferred function calls, and a standard library that covers I/O, networking, cryptography, and datetime handling. Hare uses a reproducible build system and aims for a stable specification that does not change, making it suitable for long-lived systems software."
+    },
+    es: {
+      name: "Hare",
+      description: "Un lenguaje de programaci\xF3n de sistemas dise\xF1ado para ser simple, estable y robusto, con gesti\xF3n de memoria expl\xEDcita y sin flujo de control oculto.",
+      longDescription: "Hare es un lenguaje de programaci\xF3n de sistemas dise\xF1ado por Drew DeVault con \xE9nfasis en la simplicidad, estabilidad y mantenibilidad a largo plazo. Est\xE1 dirigido a sistemas operativos Unix-like y entornos bare-metal, como alternativa moderna a C.\n\nHare no tiene runtime ni recolector de basura, y no tiene flujo de control oculto. La gesti\xF3n de memoria es manual y expl\xEDcita. El lenguaje incluye uniones etiquetadas, slices, llamadas diferidas y una biblioteca est\xE1ndar que cubre E/S, redes, criptograf\xEDa y fechas."
+    },
+    it: {
+      name: "Hare",
+      description: "Linguaggio di sistema semplice e stabile con gestione esplicita della memoria e senza flusso di controllo nascosto.",
+      longDescription: "Hare \xE8 un linguaggio di programmazione di sistema progettato da Drew DeVault con enfasi su semplicit\xE0, stabilit\xE0 e manutenibilit\xE0 a lungo termine. \xC8 destinato a sistemi operativi Unix-like e ambienti bare-metal, come alternativa moderna a C.\n\nHare non ha runtime n\xE9 garbage collector, e non ha flusso di controllo nascosto. La gestione della memoria \xE8 manuale ed esplicita. Il linguaggio include union taggate, slice, chiamate differite e una libreria standard che copre I/O, rete, crittografia e gestione delle date."
+    },
+    fr: {
+      name: "Hare",
+      description: "Un langage de programmation syst\xE8me con\xE7u pour \xEAtre simple, stable et robuste, avec une gestion de m\xE9moire explicite et sans flux de contr\xF4le cach\xE9.",
+      longDescription: "Hare est un langage de programmation syst\xE8me con\xE7u par Drew DeVault avec un accent sur la simplicit\xE9, la stabilit\xE9 et la maintenabilit\xE9 \xE0 long terme. Il cible les syst\xE8mes d'exploitation de type Unix et les environnements bare-metal, comme alternative moderne \xE0 C.\n\nHare n'a pas de runtime ni de garbage collector, et pas de flux de contr\xF4le cach\xE9. La gestion de la m\xE9moire est manuelle et explicite. Le langage inclut des unions \xE9tiquet\xE9es, des slices, des appels diff\xE9r\xE9s et une biblioth\xE8que standard couvrant l'I/O, le r\xE9seau, la cryptographie et la gestion des dates."
+    },
+    de: {
+      name: "Hare",
+      description: "Systemprogrammiersprache f\xFCr Einfachheit, Stabilit\xE4t und Robustheit, mit expliziter Speicherverwaltung und ohne verborgenen Kontrollfluss.",
+      longDescription: "Hare ist eine von Drew DeVault entwickelte Systemprogrammiersprache mit Schwerpunkt auf Einfachheit, Stabilit\xE4t und langfristiger Wartbarkeit. Sie zielt auf Unix-\xE4hnliche Betriebssysteme und Bare-Metal-Umgebungen als moderne Alternative zu C.\n\nHare hat keine Laufzeitumgebung, keinen Garbage Collector und keinen verborgenen Kontrollfluss. Die Speicherverwaltung ist manuell und explizit. Die Sprache umfasst Tagged Unions, Slices, verz\xF6gerte Funktionsaufrufe und eine Standardbibliothek f\xFCr I/O, Netzwerk, Kryptographie und Datumsverwaltung."
+    },
+    pt: {
+      name: "Hare",
+      description: "Uma linguagem de programa\xE7\xE3o de sistemas projetada para ser simples, est\xE1vel e robusta, com gerenciamento de mem\xF3ria expl\xEDcito e sem fluxo de controle oculto.",
+      longDescription: "Hare \xE9 uma linguagem de programa\xE7\xE3o de sistemas projetada por Drew DeVault com \xEAnfase em simplicidade, estabilidade e manutenibilidade a longo prazo. Destina-se a sistemas operacionais Unix-like e ambientes bare-metal, como alternativa moderna ao C.\n\nHare n\xE3o tem runtime nem coletor de lixo, e n\xE3o tem fluxo de controle oculto. O gerenciamento de mem\xF3ria \xE9 manual e expl\xEDcito. A linguagem inclui uni\xF5es marcadas, slices, chamadas diferidas e uma biblioteca padr\xE3o que cobre I/O, rede, criptografia e manipula\xE7\xE3o de datas."
+    }
+  }
+};
+
+export { hare };

package/dist/languages/hy.cjs

@@ -0,0 +1,53 @@
+'use strict';
+
+// src/languages/hy.ts
+var hy = {
+  slug: "hy",
+  publishedDate: "2013-04-03",
+  extensions: [".hy"],
+  author: "Paul Tagliamonte",
+  website: "https://hylang.org",
+  paradigms: ["functional", "meta-programming", "object-oriented"],
+  tooling: {
+    runtimes: ["hy (Python-based)"],
+    packageManagers: ["pip"],
+    ecosystems: ["Python", "Machine Learning", "Data Science", "Scripting"]
+  },
+  version: "1.0.0",
+  logo: "https://avatars.githubusercontent.com/u/10551643?v=4",
+  color: "#35B9E9",
+  i18n: {
+    en: {
+      name: "Hy",
+      description: "A Lisp dialect embedded in Python that compiles to Python AST, giving full access to the Python ecosystem with a macro-capable Lisp syntax.",
+      longDescription: "Hy is a Lisp dialect that is embedded directly in Python. Hy code is compiled to Python's abstract syntax tree (AST) and therefore has complete, bidirectional interoperability with Python: Python can import Hy modules and Hy can import Python modules.\n\nHy brings Lisp's powerful macro system to Python, enabling code generation and domain-specific languages. It supports all Python data types and features, including classes, decorators, generators, and async/await. The entire Python standard library and third-party ecosystem \u2014 NumPy, Pandas, TensorFlow \u2014 are available natively. Hy is particularly popular for Python developers who want to explore Lisp without leaving their familiar ecosystem."
+    },
+    es: {
+      name: "Hy",
+      description: "Un dialecto Lisp integrado en Python que compila a AST de Python, dando acceso completo al ecosistema de Python con una sintaxis Lisp con macros.",
+      longDescription: "Hy es un dialecto Lisp integrado directamente en Python. El c\xF3digo Hy se compila al \xE1rbol de sintaxis abstracta (AST) de Python, por lo que tiene interoperabilidad completa y bidireccional con Python.\n\nHy trae el potente sistema de macros de Lisp a Python, permitiendo la generaci\xF3n de c\xF3digo y lenguajes espec\xEDficos de dominio. Soporta todos los tipos de datos y caracter\xEDsticas de Python, incluidos clases, decoradores, generadores y async/await. Todo el ecosistema Python \u2014 NumPy, Pandas, TensorFlow \u2014 est\xE1 disponible de forma nativa."
+    },
+    it: {
+      name: "Hy",
+      description: "Un dialetto Lisp integrato in Python che compila in AST Python, offrendo accesso completo all'ecosistema Python con una sintassi Lisp con macro.",
+      longDescription: "Hy \xE8 un dialetto Lisp integrato direttamente in Python. Il codice Hy viene compilato nell'albero di sintassi astratta (AST) di Python e ha quindi una completa interoperabilit\xE0 bidirezionale con Python.\n\nHy porta il potente sistema di macro di Lisp in Python, abilitando la generazione di codice e i linguaggi specifici di dominio. Supporta tutti i tipi di dati e le funzionalit\xE0 di Python, incluse classi, decoratori, generatori e async/await. L'intero ecosistema Python \u2014 NumPy, Pandas, TensorFlow \u2014 \xE8 disponibile nativamente."
+    },
+    fr: {
+      name: "Hy",
+      description: "Un dialecte Lisp int\xE9gr\xE9 dans Python qui compile vers l'AST Python, donnant un acc\xE8s complet \xE0 l'\xE9cosyst\xE8me Python avec une syntaxe Lisp capable de macros.",
+      longDescription: "Hy est un dialecte Lisp int\xE9gr\xE9 directement dans Python. Le code Hy est compil\xE9 vers l'arbre de syntaxe abstraite (AST) de Python et dispose donc d'une interop\xE9rabilit\xE9 compl\xE8te et bidirectionnelle avec Python.\n\nHy apporte le puissant syst\xE8me de macros de Lisp \xE0 Python, permettant la g\xE9n\xE9ration de code et les langages sp\xE9cifiques \xE0 un domaine. Il prend en charge tous les types de donn\xE9es et fonctionnalit\xE9s Python, y compris les classes, d\xE9corateurs, g\xE9n\xE9rateurs et async/await. Tout l'\xE9cosyst\xE8me Python est disponible nativement."
+    },
+    de: {
+      name: "Hy",
+      description: "Ein in Python eingebetteter Lisp-Dialekt, der zu Python-AST kompiliert und vollen Zugang zum Python-\xD6kosystem mit einer makrof\xE4higen Lisp-Syntax bietet.",
+      longDescription: "Hy ist ein Lisp-Dialekt, der direkt in Python eingebettet ist. Hy-Code wird zu Pythons abstrakter Syntaxbaumdarstellung (AST) kompiliert und hat daher vollst\xE4ndige, bidirektionale Interoperabilit\xE4t mit Python.\n\nHy bringt Lisps leistungsstarkes Makrosystem nach Python und erm\xF6glicht Code-Generierung und dom\xE4nenspezifische Sprachen. Es unterst\xFCtzt alle Python-Datentypen und -Funktionen, einschlie\xDFlich Klassen, Dekoratoren, Generatoren und async/await. Das gesamte Python-\xD6kosystem \u2014 NumPy, Pandas, TensorFlow \u2014 ist nativ verf\xFCgbar."
+    },
+    pt: {
+      name: "Hy",
+      description: "Um dialeto Lisp embutido no Python que compila para a AST do Python, dando acesso completo ao ecossistema Python com uma sintaxe Lisp com suporte a macros.",
+      longDescription: "Hy \xE9 um dialeto Lisp integrado diretamente no Python. O c\xF3digo Hy \xE9 compilado para a \xE1rvore de sintaxe abstrata (AST) do Python e, portanto, tem interoperabilidade completa e bidirecional com Python.\n\nHy traz o poderoso sistema de macros do Lisp para o Python, permitindo gera\xE7\xE3o de c\xF3digo e linguagens espec\xEDficas de dom\xEDnio. Suporta todos os tipos de dados e recursos do Python, incluindo classes, decoradores, geradores e async/await. Todo o ecossistema Python \u2014 NumPy, Pandas, TensorFlow \u2014 est\xE1 dispon\xEDvel nativamente."
+    }
+  }
+};
+
+exports.hy = hy;

package/dist/languages/hy.d.cts

@@ -0,0 +1,50 @@
+declare const hy: {
+    slug: string;
+    publishedDate: string;
+    extensions: string[];
+    author: string;
+    website: string;
+    paradigms: string[];
+    tooling: {
+        runtimes: string[];
+        packageManagers: string[];
+        ecosystems: string[];
+    };
+    version: string;
+    logo: string;
+    color: "#35B9E9";
+    i18n: {
+        en: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        es: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        it: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        fr: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        de: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        pt: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+    };
+};
+
+export { hy };

package/dist/languages/hy.d.ts

@@ -0,0 +1,50 @@
+declare const hy: {
+    slug: string;
+    publishedDate: string;
+    extensions: string[];
+    author: string;
+    website: string;
+    paradigms: string[];
+    tooling: {
+        runtimes: string[];
+        packageManagers: string[];
+        ecosystems: string[];
+    };
+    version: string;
+    logo: string;
+    color: "#35B9E9";
+    i18n: {
+        en: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        es: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        it: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        fr: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        de: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        pt: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+    };
+};
+
+export { hy };