code-languages 1.15.0 → 1.16.1

package/dist/languages/crystal.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/languages/crystal.ts"],"names":[],"mappings":";AAEO,IAAM,OAAA,GAAU;AAAA,EACrB,IAAA,EAAM,SAAA;AAAA,EACN,aAAA,EAAe,YAAA;AAAA,EACf,UAAA,EAAY,CAAC,KAAK,CAAA;AAAA,EAClB,MAAA,EAAQ,uEAAA;AAAA,EACR,OAAA,EAAS,0BAAA;AAAA,EACT,SAAA,EAAW,CAAC,iBAAA,EAAmB,YAAA,EAAc,cAAc,YAAY,CAAA;AAAA,EACvE,OAAA,EAAS;AAAA,IACP,QAAA,EAAU,CAAC,SAAS,CAAA;AAAA,IACpB,eAAA,EAAiB,CAAC,QAAQ,CAAA;AAAA,IAC1B,UAAA,EAAY,CAAC,KAAA,EAAO,KAAA,EAAO,WAAW,qBAAqB;AAAA,GAC7D;AAAA,EACA,OAAA,EAAS,QAAA;AAAA,EACT,IAAA,EAAM,4CAAA;AAAA,EACN,IAAA,EAAM;AAAA,IACJ,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,SAAA;AAAA,MACN,WAAA,EACE,yFAAA;AAAA,MACF,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,SAAA;AAAA,MACN,WAAA,EACE,mGAAA;AAAA,MACF,eAAA,EACE;AAAA;AACJ;AAEJ","file":"crystal.js","sourcesContent":["import type { Language } from \"../types\";\n\nexport const crystal = {\n  slug: \"crystal\",\n  publishedDate: \"2014-06-18\",\n  extensions: [\".cr\"],\n  author: \"Ary Borenszweig, Juan Wajnerman, Brian Cardiff / Crystal contributors\",\n  website: \"https://crystal-lang.org\",\n  paradigms: [\"object-oriented\", \"functional\", \"imperative\", \"concurrent\"],\n  tooling: {\n    runtimes: [\"Crystal\"],\n    packageManagers: [\"Shards\"],\n    ecosystems: [\"Web\", \"CLI\", \"Systems\", \"Native Applications\"],\n  },\n  version: \"1.20.1\",\n  logo: \"https://cdn.simpleicons.org/crystal/000000\",\n  i18n: {\n    en: {\n      name: \"Crystal\",\n      description:\n        \"A compiled, statically typed language with Ruby-inspired syntax and native performance.\",\n      longDescription:\n        \"Crystal is a general-purpose programming language with syntax inspired by Ruby, static type checking, type inference, macros, fibers, channels, C bindings, and native compilation. It aims to keep code expressive while catching type errors at compile time.\\n\\nIt is used for web services, command-line tools, automation, native applications, performance-sensitive backend systems, and projects that want Ruby-like ergonomics with a compiled toolchain.\",\n    },\n    es: {\n      name: \"Crystal\",\n      description:\n        \"Un lenguaje compilado y tipado estaticamente con sintaxis inspirada en Ruby y rendimiento nativo.\",\n      longDescription:\n        \"Crystal es un lenguaje de programacion de proposito general con sintaxis inspirada en Ruby, verificacion estatica de tipos, inferencia de tipos, macros, fibers, channels, bindings con C y compilacion nativa. Busca mantener el codigo expresivo mientras detecta errores de tipos en compilacion.\\n\\nSe usa en servicios web, herramientas de linea de comandos, automatizacion, aplicaciones nativas, backends sensibles al rendimiento y proyectos que quieren ergonomia similar a Ruby con un toolchain compilado.\",\n    },\n  },\n} satisfies Language;\n"]}
+{"version":3,"sources":["../../src/languages/crystal.ts"],"names":[],"mappings":";AAEO,IAAM,OAAA,GAAU;AAAA,EACrB,IAAA,EAAM,SAAA;AAAA,EACN,aAAA,EAAe,YAAA;AAAA,EACf,UAAA,EAAY,CAAC,KAAK,CAAA;AAAA,EAClB,MAAA,EAAQ,uEAAA;AAAA,EACR,OAAA,EAAS,0BAAA;AAAA,EACT,SAAA,EAAW,CAAC,iBAAA,EAAmB,YAAA,EAAc,cAAc,YAAY,CAAA;AAAA,EACvE,OAAA,EAAS;AAAA,IACP,QAAA,EAAU,CAAC,SAAS,CAAA;AAAA,IACpB,eAAA,EAAiB,CAAC,QAAQ,CAAA;AAAA,IAC1B,UAAA,EAAY,CAAC,KAAA,EAAO,KAAA,EAAO,WAAW,qBAAqB;AAAA,GAC7D;AAAA,EACA,OAAA,EAAS,QAAA;AAAA,EACT,IAAA,EAAM,4CAAA;AAAA,EACN,IAAA,EAAM;AAAA,IACJ,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,SAAA;AAAA,MACN,WAAA,EACE,yFAAA;AAAA,MACF,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,SAAA;AAAA,MACN,WAAA,EACE,mGAAA;AAAA,MACF,eAAA,EACE;AAAA;AACJ;AAEJ","file":"crystal.js","sourcesContent":["import type { Language } from \"../types\";\n\nexport const crystal = {\n  slug: \"crystal\",\n  publishedDate: \"2014-06-18\",\n  extensions: [\".cr\"],\n  author: \"Ary Borenszweig, Juan Wajnerman, Brian Cardiff / Crystal contributors\",\n  website: \"https://crystal-lang.org\",\n  paradigms: [\"object-oriented\", \"functional\", \"imperative\", \"concurrent\"],\n  tooling: {\n    runtimes: [\"Crystal\"],\n    packageManagers: [\"Shards\"],\n    ecosystems: [\"Web\", \"CLI\", \"Systems\", \"Native Applications\"],\n  },\n  version: \"1.20.2\",\n  logo: \"https://cdn.simpleicons.org/crystal/000000\",\n  i18n: {\n    en: {\n      name: \"Crystal\",\n      description:\n        \"A compiled, statically typed language with Ruby-inspired syntax and native performance.\",\n      longDescription:\n        \"Crystal is a general-purpose programming language with syntax inspired by Ruby, static type checking, type inference, macros, fibers, channels, C bindings, and native compilation. It aims to keep code expressive while catching type errors at compile time.\\n\\nIt is used for web services, command-line tools, automation, native applications, performance-sensitive backend systems, and projects that want Ruby-like ergonomics with a compiled toolchain.\",\n    },\n    es: {\n      name: \"Crystal\",\n      description:\n        \"Un lenguaje compilado y tipado estaticamente con sintaxis inspirada en Ruby y rendimiento nativo.\",\n      longDescription:\n        \"Crystal es un lenguaje de programacion de proposito general con sintaxis inspirada en Ruby, verificacion estatica de tipos, inferencia de tipos, macros, fibers, channels, bindings con C y compilacion nativa. Busca mantener el codigo expresivo mientras detecta errores de tipos en compilacion.\\n\\nSe usa en servicios web, herramientas de linea de comandos, automatizacion, aplicaciones nativas, backends sensibles al rendimiento y proyectos que quieren ergonomia similar a Ruby con un toolchain compilado.\",\n    },\n  },\n} satisfies Language;\n"]}

package/dist/languages/d.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+// src/languages/d.ts
+var d = {
+  slug: "d",
+  publishedDate: "2001-12-08",
+  extensions: [".d", ".di"],
+  author: "Walter Bright / D Language Foundation",
+  website: "https://dlang.org",
+  paradigms: ["systems", "imperative", "object-oriented", "generic", "functional"],
+  tooling: {
+    runtimes: ["Native", "D Runtime"],
+    packageManagers: ["DUB"],
+    ecosystems: ["Systems Programming", "Native Applications", "Tooling", "Game Development"]
+  },
+  version: "2.112.0",
+  logo: "https://cdn.simpleicons.org/d/BA595E",
+  i18n: {
+    en: {
+      name: "D",
+      description: "A systems programming language combining native performance with high-level abstractions.",
+      longDescription: "D is a general-purpose systems programming language with C-like syntax, native compilation, garbage collection, manual memory options, templates, compile-time function execution, ranges, contracts, and interoperability with C.\n\nIt is used for command-line tools, systems software, native services, high-performance applications, game tooling, compilers, and projects that want low-level control alongside expressive metaprogramming and modern language features."
+    },
+    es: {
+      name: "D",
+      description: "Un lenguaje de sistemas que combina rendimiento nativo con abstracciones de alto nivel.",
+      longDescription: "D es un lenguaje de programacion de sistemas de proposito general con sintaxis similar a C, compilacion nativa, garbage collection, opciones de memoria manual, templates, ejecucion de funciones en tiempo de compilacion, ranges, contratos e interoperabilidad con C.\n\nSe usa en herramientas de linea de comandos, software de sistemas, servicios nativos, aplicaciones de alto rendimiento, tooling para juegos, compiladores y proyectos que buscan control de bajo nivel junto con metaprogramacion expresiva y caracteristicas modernas de lenguaje."
+    }
+  }
+};
+
+exports.d = d;
+//# sourceMappingURL=d.cjs.map
+//# sourceMappingURL=d.cjs.map

package/dist/languages/d.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/languages/d.ts"],"names":[],"mappings":";;;AAEO,IAAM,CAAA,GAAI;AAAA,EACf,IAAA,EAAM,GAAA;AAAA,EACN,aAAA,EAAe,YAAA;AAAA,EACf,UAAA,EAAY,CAAC,IAAA,EAAM,KAAK,CAAA;AAAA,EACxB,MAAA,EAAQ,uCAAA;AAAA,EACR,OAAA,EAAS,mBAAA;AAAA,EACT,WAAW,CAAC,SAAA,EAAW,YAAA,EAAc,iBAAA,EAAmB,WAAW,YAAY,CAAA;AAAA,EAC/E,OAAA,EAAS;AAAA,IACP,QAAA,EAAU,CAAC,QAAA,EAAU,WAAW,CAAA;AAAA,IAChC,eAAA,EAAiB,CAAC,KAAK,CAAA;AAAA,IACvB,UAAA,EAAY,CAAC,qBAAA,EAAuB,qBAAA,EAAuB,WAAW,kBAAkB;AAAA,GAC1F;AAAA,EACA,OAAA,EAAS,SAAA;AAAA,EACT,IAAA,EAAM,sCAAA;AAAA,EACN,IAAA,EAAM;AAAA,IACJ,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,GAAA;AAAA,MACN,WAAA,EACE,2FAAA;AAAA,MACF,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,GAAA;AAAA,MACN,WAAA,EACE,yFAAA;AAAA,MACF,eAAA,EACE;AAAA;AACJ;AAEJ","file":"d.cjs","sourcesContent":["import type { Language } from \"../types\";\n\nexport const d = {\n  slug: \"d\",\n  publishedDate: \"2001-12-08\",\n  extensions: [\".d\", \".di\"],\n  author: \"Walter Bright / D Language Foundation\",\n  website: \"https://dlang.org\",\n  paradigms: [\"systems\", \"imperative\", \"object-oriented\", \"generic\", \"functional\"],\n  tooling: {\n    runtimes: [\"Native\", \"D Runtime\"],\n    packageManagers: [\"DUB\"],\n    ecosystems: [\"Systems Programming\", \"Native Applications\", \"Tooling\", \"Game Development\"],\n  },\n  version: \"2.112.0\",\n  logo: \"https://cdn.simpleicons.org/d/BA595E\",\n  i18n: {\n    en: {\n      name: \"D\",\n      description:\n        \"A systems programming language combining native performance with high-level abstractions.\",\n      longDescription:\n        \"D is a general-purpose systems programming language with C-like syntax, native compilation, garbage collection, manual memory options, templates, compile-time function execution, ranges, contracts, and interoperability with C.\\n\\nIt is used for command-line tools, systems software, native services, high-performance applications, game tooling, compilers, and projects that want low-level control alongside expressive metaprogramming and modern language features.\",\n    },\n    es: {\n      name: \"D\",\n      description:\n        \"Un lenguaje de sistemas que combina rendimiento nativo con abstracciones de alto nivel.\",\n      longDescription:\n        \"D es un lenguaje de programacion de sistemas de proposito general con sintaxis similar a C, compilacion nativa, garbage collection, opciones de memoria manual, templates, ejecucion de funciones en tiempo de compilacion, ranges, contratos e interoperabilidad con C.\\n\\nSe usa en herramientas de linea de comandos, software de sistemas, servicios nativos, aplicaciones de alto rendimiento, tooling para juegos, compiladores y proyectos que buscan control de bajo nivel junto con metaprogramacion expresiva y caracteristicas modernas de lenguaje.\",\n    },\n  },\n} satisfies Language;\n"]}

package/dist/languages/d.d.cts

@@ -0,0 +1,29 @@
+declare const d: {
+    slug: string;
+    publishedDate: string;
+    extensions: string[];
+    author: string;
+    website: string;
+    paradigms: string[];
+    tooling: {
+        runtimes: string[];
+        packageManagers: string[];
+        ecosystems: string[];
+    };
+    version: string;
+    logo: string;
+    i18n: {
+        en: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        es: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+    };
+};
+
+export { d };

package/dist/languages/d.d.ts

@@ -0,0 +1,29 @@
+declare const d: {
+    slug: string;
+    publishedDate: string;
+    extensions: string[];
+    author: string;
+    website: string;
+    paradigms: string[];
+    tooling: {
+        runtimes: string[];
+        packageManagers: string[];
+        ecosystems: string[];
+    };
+    version: string;
+    logo: string;
+    i18n: {
+        en: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        es: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+    };
+};
+
+export { d };

package/dist/languages/d.js

@@ -0,0 +1,32 @@
+// src/languages/d.ts
+var d = {
+  slug: "d",
+  publishedDate: "2001-12-08",
+  extensions: [".d", ".di"],
+  author: "Walter Bright / D Language Foundation",
+  website: "https://dlang.org",
+  paradigms: ["systems", "imperative", "object-oriented", "generic", "functional"],
+  tooling: {
+    runtimes: ["Native", "D Runtime"],
+    packageManagers: ["DUB"],
+    ecosystems: ["Systems Programming", "Native Applications", "Tooling", "Game Development"]
+  },
+  version: "2.112.0",
+  logo: "https://cdn.simpleicons.org/d/BA595E",
+  i18n: {
+    en: {
+      name: "D",
+      description: "A systems programming language combining native performance with high-level abstractions.",
+      longDescription: "D is a general-purpose systems programming language with C-like syntax, native compilation, garbage collection, manual memory options, templates, compile-time function execution, ranges, contracts, and interoperability with C.\n\nIt is used for command-line tools, systems software, native services, high-performance applications, game tooling, compilers, and projects that want low-level control alongside expressive metaprogramming and modern language features."
+    },
+    es: {
+      name: "D",
+      description: "Un lenguaje de sistemas que combina rendimiento nativo con abstracciones de alto nivel.",
+      longDescription: "D es un lenguaje de programacion de sistemas de proposito general con sintaxis similar a C, compilacion nativa, garbage collection, opciones de memoria manual, templates, ejecucion de funciones en tiempo de compilacion, ranges, contratos e interoperabilidad con C.\n\nSe usa en herramientas de linea de comandos, software de sistemas, servicios nativos, aplicaciones de alto rendimiento, tooling para juegos, compiladores y proyectos que buscan control de bajo nivel junto con metaprogramacion expresiva y caracteristicas modernas de lenguaje."
+    }
+  }
+};
+
+export { d };
+//# sourceMappingURL=d.js.map
+//# sourceMappingURL=d.js.map

package/dist/languages/d.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/languages/d.ts"],"names":[],"mappings":";AAEO,IAAM,CAAA,GAAI;AAAA,EACf,IAAA,EAAM,GAAA;AAAA,EACN,aAAA,EAAe,YAAA;AAAA,EACf,UAAA,EAAY,CAAC,IAAA,EAAM,KAAK,CAAA;AAAA,EACxB,MAAA,EAAQ,uCAAA;AAAA,EACR,OAAA,EAAS,mBAAA;AAAA,EACT,WAAW,CAAC,SAAA,EAAW,YAAA,EAAc,iBAAA,EAAmB,WAAW,YAAY,CAAA;AAAA,EAC/E,OAAA,EAAS;AAAA,IACP,QAAA,EAAU,CAAC,QAAA,EAAU,WAAW,CAAA;AAAA,IAChC,eAAA,EAAiB,CAAC,KAAK,CAAA;AAAA,IACvB,UAAA,EAAY,CAAC,qBAAA,EAAuB,qBAAA,EAAuB,WAAW,kBAAkB;AAAA,GAC1F;AAAA,EACA,OAAA,EAAS,SAAA;AAAA,EACT,IAAA,EAAM,sCAAA;AAAA,EACN,IAAA,EAAM;AAAA,IACJ,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,GAAA;AAAA,MACN,WAAA,EACE,2FAAA;AAAA,MACF,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,GAAA;AAAA,MACN,WAAA,EACE,yFAAA;AAAA,MACF,eAAA,EACE;AAAA;AACJ;AAEJ","file":"d.js","sourcesContent":["import type { Language } from \"../types\";\n\nexport const d = {\n  slug: \"d\",\n  publishedDate: \"2001-12-08\",\n  extensions: [\".d\", \".di\"],\n  author: \"Walter Bright / D Language Foundation\",\n  website: \"https://dlang.org\",\n  paradigms: [\"systems\", \"imperative\", \"object-oriented\", \"generic\", \"functional\"],\n  tooling: {\n    runtimes: [\"Native\", \"D Runtime\"],\n    packageManagers: [\"DUB\"],\n    ecosystems: [\"Systems Programming\", \"Native Applications\", \"Tooling\", \"Game Development\"],\n  },\n  version: \"2.112.0\",\n  logo: \"https://cdn.simpleicons.org/d/BA595E\",\n  i18n: {\n    en: {\n      name: \"D\",\n      description:\n        \"A systems programming language combining native performance with high-level abstractions.\",\n      longDescription:\n        \"D is a general-purpose systems programming language with C-like syntax, native compilation, garbage collection, manual memory options, templates, compile-time function execution, ranges, contracts, and interoperability with C.\\n\\nIt is used for command-line tools, systems software, native services, high-performance applications, game tooling, compilers, and projects that want low-level control alongside expressive metaprogramming and modern language features.\",\n    },\n    es: {\n      name: \"D\",\n      description:\n        \"Un lenguaje de sistemas que combina rendimiento nativo con abstracciones de alto nivel.\",\n      longDescription:\n        \"D es un lenguaje de programacion de sistemas de proposito general con sintaxis similar a C, compilacion nativa, garbage collection, opciones de memoria manual, templates, ejecucion de funciones en tiempo de compilacion, ranges, contratos e interoperabilidad con C.\\n\\nSe usa en herramientas de linea de comandos, software de sistemas, servicios nativos, aplicaciones de alto rendimiento, tooling para juegos, compiladores y proyectos que buscan control de bajo nivel junto con metaprogramacion expresiva y caracteristicas modernas de lenguaje.\",\n    },\n  },\n} satisfies Language;\n"]}

package/dist/languages/fennel.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+// src/languages/fennel.ts
+var fennel = {
+  slug: "fennel",
+  publishedDate: "2016-10-01",
+  extensions: [".fnl"],
+  author: "Calvin Rose, Phil Hagelberg",
+  website: "https://fennel-lang.org",
+  paradigms: ["functional", "lisp", "scripting", "metaprogramming"],
+  tooling: {
+    runtimes: ["Lua", "LuaJIT"],
+    packageManagers: ["LuaRocks"],
+    ecosystems: ["Lua", "Neovim", "Game Development", "Embedded Scripting"]
+  },
+  version: "1.6.1",
+  logo: "https://fennel-lang.org/logo.svg",
+  i18n: {
+    en: {
+      name: "Fennel",
+      description: "A Lisp that compiles to Lua while preserving access to the Lua ecosystem.",
+      longDescription: "Fennel is a Lisp dialect that compiles to Lua, offering parentheses, macros, pattern matching, destructuring, functional style, and interactive development while keeping compatibility with Lua runtimes and libraries.\n\nIt is used for Lua applications, Neovim configuration, game scripting, embedded extension languages, tools, and projects that want Lisp-style syntax and macros with Lua's portability and small runtime footprint."
+    },
+    es: {
+      name: "Fennel",
+      description: "Un Lisp que compila a Lua y conserva acceso al ecosistema Lua.",
+      longDescription: "Fennel es un dialecto Lisp que compila a Lua, ofreciendo parentesis, macros, pattern matching, destructuring, estilo funcional y desarrollo interactivo mientras mantiene compatibilidad con runtimes y bibliotecas de Lua.\n\nSe usa en aplicaciones Lua, configuracion de Neovim, scripting para juegos, lenguajes embebidos de extension, herramientas y proyectos que quieren sintaxis y macros de estilo Lisp con la portabilidad y huella pequena de runtime de Lua."
+    }
+  }
+};
+
+exports.fennel = fennel;
+//# sourceMappingURL=fennel.cjs.map
+//# sourceMappingURL=fennel.cjs.map

package/dist/languages/fennel.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/languages/fennel.ts"],"names":[],"mappings":";;;AAEO,IAAM,MAAA,GAAS;AAAA,EACpB,IAAA,EAAM,QAAA;AAAA,EACN,aAAA,EAAe,YAAA;AAAA,EACf,UAAA,EAAY,CAAC,MAAM,CAAA;AAAA,EACnB,MAAA,EAAQ,6BAAA;AAAA,EACR,OAAA,EAAS,yBAAA;AAAA,EACT,SAAA,EAAW,CAAC,YAAA,EAAc,MAAA,EAAQ,aAAa,iBAAiB,CAAA;AAAA,EAChE,OAAA,EAAS;AAAA,IACP,QAAA,EAAU,CAAC,KAAA,EAAO,QAAQ,CAAA;AAAA,IAC1B,eAAA,EAAiB,CAAC,UAAU,CAAA;AAAA,IAC5B,UAAA,EAAY,CAAC,KAAA,EAAO,QAAA,EAAU,oBAAoB,oBAAoB;AAAA,GACxE;AAAA,EACA,OAAA,EAAS,OAAA;AAAA,EACT,IAAA,EAAM,kCAAA;AAAA,EACN,IAAA,EAAM;AAAA,IACJ,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,QAAA;AAAA,MACN,WAAA,EAAa,2EAAA;AAAA,MACb,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,QAAA;AAAA,MACN,WAAA,EAAa,gEAAA;AAAA,MACb,eAAA,EACE;AAAA;AACJ;AAEJ","file":"fennel.cjs","sourcesContent":["import type { Language } from \"../types\";\n\nexport const fennel = {\n  slug: \"fennel\",\n  publishedDate: \"2016-10-01\",\n  extensions: [\".fnl\"],\n  author: \"Calvin Rose, Phil Hagelberg\",\n  website: \"https://fennel-lang.org\",\n  paradigms: [\"functional\", \"lisp\", \"scripting\", \"metaprogramming\"],\n  tooling: {\n    runtimes: [\"Lua\", \"LuaJIT\"],\n    packageManagers: [\"LuaRocks\"],\n    ecosystems: [\"Lua\", \"Neovim\", \"Game Development\", \"Embedded Scripting\"],\n  },\n  version: \"1.6.1\",\n  logo: \"https://fennel-lang.org/logo.svg\",\n  i18n: {\n    en: {\n      name: \"Fennel\",\n      description: \"A Lisp that compiles to Lua while preserving access to the Lua ecosystem.\",\n      longDescription:\n        \"Fennel is a Lisp dialect that compiles to Lua, offering parentheses, macros, pattern matching, destructuring, functional style, and interactive development while keeping compatibility with Lua runtimes and libraries.\\n\\nIt is used for Lua applications, Neovim configuration, game scripting, embedded extension languages, tools, and projects that want Lisp-style syntax and macros with Lua's portability and small runtime footprint.\",\n    },\n    es: {\n      name: \"Fennel\",\n      description: \"Un Lisp que compila a Lua y conserva acceso al ecosistema Lua.\",\n      longDescription:\n        \"Fennel es un dialecto Lisp que compila a Lua, ofreciendo parentesis, macros, pattern matching, destructuring, estilo funcional y desarrollo interactivo mientras mantiene compatibilidad con runtimes y bibliotecas de Lua.\\n\\nSe usa en aplicaciones Lua, configuracion de Neovim, scripting para juegos, lenguajes embebidos de extension, herramientas y proyectos que quieren sintaxis y macros de estilo Lisp con la portabilidad y huella pequena de runtime de Lua.\",\n    },\n  },\n} satisfies Language;\n"]}

package/dist/languages/fennel.d.cts

@@ -0,0 +1,29 @@
+declare const fennel: {
+    slug: string;
+    publishedDate: string;
+    extensions: string[];
+    author: string;
+    website: string;
+    paradigms: string[];
+    tooling: {
+        runtimes: string[];
+        packageManagers: string[];
+        ecosystems: string[];
+    };
+    version: string;
+    logo: string;
+    i18n: {
+        en: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        es: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+    };
+};
+
+export { fennel };

package/dist/languages/fennel.d.ts

@@ -0,0 +1,29 @@
+declare const fennel: {
+    slug: string;
+    publishedDate: string;
+    extensions: string[];
+    author: string;
+    website: string;
+    paradigms: string[];
+    tooling: {
+        runtimes: string[];
+        packageManagers: string[];
+        ecosystems: string[];
+    };
+    version: string;
+    logo: string;
+    i18n: {
+        en: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        es: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+    };
+};
+
+export { fennel };

package/dist/languages/fennel.js

@@ -0,0 +1,32 @@
+// src/languages/fennel.ts
+var fennel = {
+  slug: "fennel",
+  publishedDate: "2016-10-01",
+  extensions: [".fnl"],
+  author: "Calvin Rose, Phil Hagelberg",
+  website: "https://fennel-lang.org",
+  paradigms: ["functional", "lisp", "scripting", "metaprogramming"],
+  tooling: {
+    runtimes: ["Lua", "LuaJIT"],
+    packageManagers: ["LuaRocks"],
+    ecosystems: ["Lua", "Neovim", "Game Development", "Embedded Scripting"]
+  },
+  version: "1.6.1",
+  logo: "https://fennel-lang.org/logo.svg",
+  i18n: {
+    en: {
+      name: "Fennel",
+      description: "A Lisp that compiles to Lua while preserving access to the Lua ecosystem.",
+      longDescription: "Fennel is a Lisp dialect that compiles to Lua, offering parentheses, macros, pattern matching, destructuring, functional style, and interactive development while keeping compatibility with Lua runtimes and libraries.\n\nIt is used for Lua applications, Neovim configuration, game scripting, embedded extension languages, tools, and projects that want Lisp-style syntax and macros with Lua's portability and small runtime footprint."
+    },
+    es: {
+      name: "Fennel",
+      description: "Un Lisp que compila a Lua y conserva acceso al ecosistema Lua.",
+      longDescription: "Fennel es un dialecto Lisp que compila a Lua, ofreciendo parentesis, macros, pattern matching, destructuring, estilo funcional y desarrollo interactivo mientras mantiene compatibilidad con runtimes y bibliotecas de Lua.\n\nSe usa en aplicaciones Lua, configuracion de Neovim, scripting para juegos, lenguajes embebidos de extension, herramientas y proyectos que quieren sintaxis y macros de estilo Lisp con la portabilidad y huella pequena de runtime de Lua."
+    }
+  }
+};
+
+export { fennel };
+//# sourceMappingURL=fennel.js.map
+//# sourceMappingURL=fennel.js.map

package/dist/languages/fennel.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/languages/fennel.ts"],"names":[],"mappings":";AAEO,IAAM,MAAA,GAAS;AAAA,EACpB,IAAA,EAAM,QAAA;AAAA,EACN,aAAA,EAAe,YAAA;AAAA,EACf,UAAA,EAAY,CAAC,MAAM,CAAA;AAAA,EACnB,MAAA,EAAQ,6BAAA;AAAA,EACR,OAAA,EAAS,yBAAA;AAAA,EACT,SAAA,EAAW,CAAC,YAAA,EAAc,MAAA,EAAQ,aAAa,iBAAiB,CAAA;AAAA,EAChE,OAAA,EAAS;AAAA,IACP,QAAA,EAAU,CAAC,KAAA,EAAO,QAAQ,CAAA;AAAA,IAC1B,eAAA,EAAiB,CAAC,UAAU,CAAA;AAAA,IAC5B,UAAA,EAAY,CAAC,KAAA,EAAO,QAAA,EAAU,oBAAoB,oBAAoB;AAAA,GACxE;AAAA,EACA,OAAA,EAAS,OAAA;AAAA,EACT,IAAA,EAAM,kCAAA;AAAA,EACN,IAAA,EAAM;AAAA,IACJ,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,QAAA;AAAA,MACN,WAAA,EAAa,2EAAA;AAAA,MACb,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,QAAA;AAAA,MACN,WAAA,EAAa,gEAAA;AAAA,MACb,eAAA,EACE;AAAA;AACJ;AAEJ","file":"fennel.js","sourcesContent":["import type { Language } from \"../types\";\n\nexport const fennel = {\n  slug: \"fennel\",\n  publishedDate: \"2016-10-01\",\n  extensions: [\".fnl\"],\n  author: \"Calvin Rose, Phil Hagelberg\",\n  website: \"https://fennel-lang.org\",\n  paradigms: [\"functional\", \"lisp\", \"scripting\", \"metaprogramming\"],\n  tooling: {\n    runtimes: [\"Lua\", \"LuaJIT\"],\n    packageManagers: [\"LuaRocks\"],\n    ecosystems: [\"Lua\", \"Neovim\", \"Game Development\", \"Embedded Scripting\"],\n  },\n  version: \"1.6.1\",\n  logo: \"https://fennel-lang.org/logo.svg\",\n  i18n: {\n    en: {\n      name: \"Fennel\",\n      description: \"A Lisp that compiles to Lua while preserving access to the Lua ecosystem.\",\n      longDescription:\n        \"Fennel is a Lisp dialect that compiles to Lua, offering parentheses, macros, pattern matching, destructuring, functional style, and interactive development while keeping compatibility with Lua runtimes and libraries.\\n\\nIt is used for Lua applications, Neovim configuration, game scripting, embedded extension languages, tools, and projects that want Lisp-style syntax and macros with Lua's portability and small runtime footprint.\",\n    },\n    es: {\n      name: \"Fennel\",\n      description: \"Un Lisp que compila a Lua y conserva acceso al ecosistema Lua.\",\n      longDescription:\n        \"Fennel es un dialecto Lisp que compila a Lua, ofreciendo parentesis, macros, pattern matching, destructuring, estilo funcional y desarrollo interactivo mientras mantiene compatibilidad con runtimes y bibliotecas de Lua.\\n\\nSe usa en aplicaciones Lua, configuracion de Neovim, scripting para juegos, lenguajes embebidos de extension, herramientas y proyectos que quieren sintaxis y macros de estilo Lisp con la portabilidad y huella pequena de runtime de Lua.\",\n    },\n  },\n} satisfies Language;\n"]}

package/dist/languages/gleam.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+// src/languages/gleam.ts
+var gleam = {
+  slug: "gleam",
+  publishedDate: "2019-04-15",
+  extensions: [".gleam"],
+  author: "Louis Pilfold",
+  website: "https://gleam.run",
+  paradigms: ["functional", "statically typed", "concurrent", "actor-model"],
+  tooling: {
+    runtimes: ["Erlang/OTP", "BEAM", "JavaScript"],
+    packageManagers: ["gleam", "Hex"],
+    ecosystems: ["BEAM", "Erlang", "Elixir", "JavaScript", "Web"]
+  },
+  version: "1.16.0",
+  logo: "https://cdn.simpleicons.org/gleam/FFAFF3",
+  i18n: {
+    en: {
+      name: "Gleam",
+      description: "A friendly statically typed functional language for the BEAM and JavaScript.",
+      longDescription: "Gleam is a statically typed functional programming language that compiles to Erlang and JavaScript. It provides algebraic data types, pattern matching, immutable data, a small syntax, helpful compiler errors, and interoperability with Erlang and Elixir libraries on the BEAM.\n\nIt is used for web services, concurrent systems, command-line tools, full-stack applications, and projects that want BEAM reliability with a lightweight type system and approachable functional programming model."
+    },
+    es: {
+      name: "Gleam",
+      description: "Un lenguaje funcional amigable y de tipado estatico para BEAM y JavaScript.",
+      longDescription: "Gleam es un lenguaje de programacion funcional con tipado estatico que compila a Erlang y JavaScript. Ofrece tipos algebraicos, pattern matching, datos inmutables, una sintaxis pequena, errores de compilador utiles e interoperabilidad con bibliotecas Erlang y Elixir sobre BEAM.\n\nSe usa en servicios web, sistemas concurrentes, herramientas de linea de comandos, aplicaciones full-stack y proyectos que buscan la confiabilidad de BEAM con un sistema de tipos ligero y un modelo funcional accesible."
+    }
+  }
+};
+
+exports.gleam = gleam;
+//# sourceMappingURL=gleam.cjs.map
+//# sourceMappingURL=gleam.cjs.map

package/dist/languages/gleam.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/languages/gleam.ts"],"names":[],"mappings":";;;AAEO,IAAM,KAAA,GAAQ;AAAA,EACnB,IAAA,EAAM,OAAA;AAAA,EACN,aAAA,EAAe,YAAA;AAAA,EACf,UAAA,EAAY,CAAC,QAAQ,CAAA;AAAA,EACrB,MAAA,EAAQ,eAAA;AAAA,EACR,OAAA,EAAS,mBAAA;AAAA,EACT,SAAA,EAAW,CAAC,YAAA,EAAc,kBAAA,EAAoB,cAAc,aAAa,CAAA;AAAA,EACzE,OAAA,EAAS;AAAA,IACP,QAAA,EAAU,CAAC,YAAA,EAAc,MAAA,EAAQ,YAAY,CAAA;AAAA,IAC7C,eAAA,EAAiB,CAAC,OAAA,EAAS,KAAK,CAAA;AAAA,IAChC,YAAY,CAAC,MAAA,EAAQ,QAAA,EAAU,QAAA,EAAU,cAAc,KAAK;AAAA,GAC9D;AAAA,EACA,OAAA,EAAS,QAAA;AAAA,EACT,IAAA,EAAM,0CAAA;AAAA,EACN,IAAA,EAAM;AAAA,IACJ,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,OAAA;AAAA,MACN,WAAA,EAAa,8EAAA;AAAA,MACb,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,OAAA;AAAA,MACN,WAAA,EAAa,6EAAA;AAAA,MACb,eAAA,EACE;AAAA;AACJ;AAEJ","file":"gleam.cjs","sourcesContent":["import type { Language } from \"../types\";\n\nexport const gleam = {\n  slug: \"gleam\",\n  publishedDate: \"2019-04-15\",\n  extensions: [\".gleam\"],\n  author: \"Louis Pilfold\",\n  website: \"https://gleam.run\",\n  paradigms: [\"functional\", \"statically typed\", \"concurrent\", \"actor-model\"],\n  tooling: {\n    runtimes: [\"Erlang/OTP\", \"BEAM\", \"JavaScript\"],\n    packageManagers: [\"gleam\", \"Hex\"],\n    ecosystems: [\"BEAM\", \"Erlang\", \"Elixir\", \"JavaScript\", \"Web\"],\n  },\n  version: \"1.16.0\",\n  logo: \"https://cdn.simpleicons.org/gleam/FFAFF3\",\n  i18n: {\n    en: {\n      name: \"Gleam\",\n      description: \"A friendly statically typed functional language for the BEAM and JavaScript.\",\n      longDescription:\n        \"Gleam is a statically typed functional programming language that compiles to Erlang and JavaScript. It provides algebraic data types, pattern matching, immutable data, a small syntax, helpful compiler errors, and interoperability with Erlang and Elixir libraries on the BEAM.\\n\\nIt is used for web services, concurrent systems, command-line tools, full-stack applications, and projects that want BEAM reliability with a lightweight type system and approachable functional programming model.\",\n    },\n    es: {\n      name: \"Gleam\",\n      description: \"Un lenguaje funcional amigable y de tipado estatico para BEAM y JavaScript.\",\n      longDescription:\n        \"Gleam es un lenguaje de programacion funcional con tipado estatico que compila a Erlang y JavaScript. Ofrece tipos algebraicos, pattern matching, datos inmutables, una sintaxis pequena, errores de compilador utiles e interoperabilidad con bibliotecas Erlang y Elixir sobre BEAM.\\n\\nSe usa en servicios web, sistemas concurrentes, herramientas de linea de comandos, aplicaciones full-stack y proyectos que buscan la confiabilidad de BEAM con un sistema de tipos ligero y un modelo funcional accesible.\",\n    },\n  },\n} satisfies Language;\n"]}

package/dist/languages/gleam.d.cts

@@ -0,0 +1,29 @@
+declare const gleam: {
+    slug: string;
+    publishedDate: string;
+    extensions: string[];
+    author: string;
+    website: string;
+    paradigms: string[];
+    tooling: {
+        runtimes: string[];
+        packageManagers: string[];
+        ecosystems: string[];
+    };
+    version: string;
+    logo: string;
+    i18n: {
+        en: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        es: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+    };
+};
+
+export { gleam };

package/dist/languages/gleam.d.ts

@@ -0,0 +1,29 @@
+declare const gleam: {
+    slug: string;
+    publishedDate: string;
+    extensions: string[];
+    author: string;
+    website: string;
+    paradigms: string[];
+    tooling: {
+        runtimes: string[];
+        packageManagers: string[];
+        ecosystems: string[];
+    };
+    version: string;
+    logo: string;
+    i18n: {
+        en: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        es: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+    };
+};
+
+export { gleam };

package/dist/languages/gleam.js

@@ -0,0 +1,32 @@
+// src/languages/gleam.ts
+var gleam = {
+  slug: "gleam",
+  publishedDate: "2019-04-15",
+  extensions: [".gleam"],
+  author: "Louis Pilfold",
+  website: "https://gleam.run",
+  paradigms: ["functional", "statically typed", "concurrent", "actor-model"],
+  tooling: {
+    runtimes: ["Erlang/OTP", "BEAM", "JavaScript"],
+    packageManagers: ["gleam", "Hex"],
+    ecosystems: ["BEAM", "Erlang", "Elixir", "JavaScript", "Web"]
+  },
+  version: "1.16.0",
+  logo: "https://cdn.simpleicons.org/gleam/FFAFF3",
+  i18n: {
+    en: {
+      name: "Gleam",
+      description: "A friendly statically typed functional language for the BEAM and JavaScript.",
+      longDescription: "Gleam is a statically typed functional programming language that compiles to Erlang and JavaScript. It provides algebraic data types, pattern matching, immutable data, a small syntax, helpful compiler errors, and interoperability with Erlang and Elixir libraries on the BEAM.\n\nIt is used for web services, concurrent systems, command-line tools, full-stack applications, and projects that want BEAM reliability with a lightweight type system and approachable functional programming model."
+    },
+    es: {
+      name: "Gleam",
+      description: "Un lenguaje funcional amigable y de tipado estatico para BEAM y JavaScript.",
+      longDescription: "Gleam es un lenguaje de programacion funcional con tipado estatico que compila a Erlang y JavaScript. Ofrece tipos algebraicos, pattern matching, datos inmutables, una sintaxis pequena, errores de compilador utiles e interoperabilidad con bibliotecas Erlang y Elixir sobre BEAM.\n\nSe usa en servicios web, sistemas concurrentes, herramientas de linea de comandos, aplicaciones full-stack y proyectos que buscan la confiabilidad de BEAM con un sistema de tipos ligero y un modelo funcional accesible."
+    }
+  }
+};
+
+export { gleam };
+//# sourceMappingURL=gleam.js.map
+//# sourceMappingURL=gleam.js.map

package/dist/languages/gleam.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/languages/gleam.ts"],"names":[],"mappings":";AAEO,IAAM,KAAA,GAAQ;AAAA,EACnB,IAAA,EAAM,OAAA;AAAA,EACN,aAAA,EAAe,YAAA;AAAA,EACf,UAAA,EAAY,CAAC,QAAQ,CAAA;AAAA,EACrB,MAAA,EAAQ,eAAA;AAAA,EACR,OAAA,EAAS,mBAAA;AAAA,EACT,SAAA,EAAW,CAAC,YAAA,EAAc,kBAAA,EAAoB,cAAc,aAAa,CAAA;AAAA,EACzE,OAAA,EAAS;AAAA,IACP,QAAA,EAAU,CAAC,YAAA,EAAc,MAAA,EAAQ,YAAY,CAAA;AAAA,IAC7C,eAAA,EAAiB,CAAC,OAAA,EAAS,KAAK,CAAA;AAAA,IAChC,YAAY,CAAC,MAAA,EAAQ,QAAA,EAAU,QAAA,EAAU,cAAc,KAAK;AAAA,GAC9D;AAAA,EACA,OAAA,EAAS,QAAA;AAAA,EACT,IAAA,EAAM,0CAAA;AAAA,EACN,IAAA,EAAM;AAAA,IACJ,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,OAAA;AAAA,MACN,WAAA,EAAa,8EAAA;AAAA,MACb,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,OAAA;AAAA,MACN,WAAA,EAAa,6EAAA;AAAA,MACb,eAAA,EACE;AAAA;AACJ;AAEJ","file":"gleam.js","sourcesContent":["import type { Language } from \"../types\";\n\nexport const gleam = {\n  slug: \"gleam\",\n  publishedDate: \"2019-04-15\",\n  extensions: [\".gleam\"],\n  author: \"Louis Pilfold\",\n  website: \"https://gleam.run\",\n  paradigms: [\"functional\", \"statically typed\", \"concurrent\", \"actor-model\"],\n  tooling: {\n    runtimes: [\"Erlang/OTP\", \"BEAM\", \"JavaScript\"],\n    packageManagers: [\"gleam\", \"Hex\"],\n    ecosystems: [\"BEAM\", \"Erlang\", \"Elixir\", \"JavaScript\", \"Web\"],\n  },\n  version: \"1.16.0\",\n  logo: \"https://cdn.simpleicons.org/gleam/FFAFF3\",\n  i18n: {\n    en: {\n      name: \"Gleam\",\n      description: \"A friendly statically typed functional language for the BEAM and JavaScript.\",\n      longDescription:\n        \"Gleam is a statically typed functional programming language that compiles to Erlang and JavaScript. It provides algebraic data types, pattern matching, immutable data, a small syntax, helpful compiler errors, and interoperability with Erlang and Elixir libraries on the BEAM.\\n\\nIt is used for web services, concurrent systems, command-line tools, full-stack applications, and projects that want BEAM reliability with a lightweight type system and approachable functional programming model.\",\n    },\n    es: {\n      name: \"Gleam\",\n      description: \"Un lenguaje funcional amigable y de tipado estatico para BEAM y JavaScript.\",\n      longDescription:\n        \"Gleam es un lenguaje de programacion funcional con tipado estatico que compila a Erlang y JavaScript. Ofrece tipos algebraicos, pattern matching, datos inmutables, una sintaxis pequena, errores de compilador utiles e interoperabilidad con bibliotecas Erlang y Elixir sobre BEAM.\\n\\nSe usa en servicios web, sistemas concurrentes, herramientas de linea de comandos, aplicaciones full-stack y proyectos que buscan la confiabilidad de BEAM con un sistema de tipos ligero y un modelo funcional accesible.\",\n    },\n  },\n} satisfies Language;\n"]}

package/dist/languages/haxe.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+// src/languages/haxe.ts
+var haxe = {
+  slug: "haxe",
+  publishedDate: "2005-10-01",
+  extensions: [".hx", ".hxml"],
+  author: "Nicolas Cannasse / Haxe Foundation",
+  website: "https://haxe.org",
+  paradigms: ["object-oriented", "functional", "cross-platform", "statically typed"],
+  tooling: {
+    runtimes: ["JavaScript", "HashLink", "JVM", "C++", "C#", "PHP", "Lua", "Python"],
+    packageManagers: ["haxelib"],
+    ecosystems: ["Games", "Web", "Cross-platform Applications", "OpenFL", "Heaps"]
+  },
+  version: "4.3.7",
+  logo: "https://cdn.simpleicons.org/haxe/EA8220",
+  i18n: {
+    en: {
+      name: "Haxe",
+      description: "A cross-platform typed language that compiles to many runtimes and targets.",
+      longDescription: "Haxe is a high-level, statically typed programming language and compiler toolkit that targets JavaScript, C++, C#, Java, JVM bytecode, PHP, Lua, Python, HashLink, and other platforms. It includes type inference, macros, abstracts, generics, pattern matching, and a shared standard library.\n\nIt is used for games, web applications, creative coding, cross-platform tools, multimedia frameworks, and codebases that need to share typed business or engine logic across many targets."
+    },
+    es: {
+      name: "Haxe",
+      description: "Un lenguaje tipado multiplataforma que compila a muchos runtimes y destinos.",
+      longDescription: "Haxe es un lenguaje de programacion de alto nivel con tipado estatico y un toolkit de compilador que apunta a JavaScript, C++, C#, Java, bytecode JVM, PHP, Lua, Python, HashLink y otras plataformas. Incluye inferencia de tipos, macros, abstracts, genericos, pattern matching y una biblioteca estandar compartida.\n\nSe usa en juegos, aplicaciones web, creative coding, herramientas multiplataforma, frameworks multimedia y codebases que necesitan compartir logica tipada de negocio o motor entre muchos destinos."
+    }
+  }
+};
+
+exports.haxe = haxe;
+//# sourceMappingURL=haxe.cjs.map
+//# sourceMappingURL=haxe.cjs.map

package/dist/languages/haxe.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/languages/haxe.ts"],"names":[],"mappings":";;;AAEO,IAAM,IAAA,GAAO;AAAA,EAClB,IAAA,EAAM,MAAA;AAAA,EACN,aAAA,EAAe,YAAA;AAAA,EACf,UAAA,EAAY,CAAC,KAAA,EAAO,OAAO,CAAA;AAAA,EAC3B,MAAA,EAAQ,oCAAA;AAAA,EACR,OAAA,EAAS,kBAAA;AAAA,EACT,SAAA,EAAW,CAAC,iBAAA,EAAmB,YAAA,EAAc,kBAAkB,kBAAkB,CAAA;AAAA,EACjF,OAAA,EAAS;AAAA,IACP,QAAA,EAAU,CAAC,YAAA,EAAc,UAAA,EAAY,OAAO,KAAA,EAAO,IAAA,EAAM,KAAA,EAAO,KAAA,EAAO,QAAQ,CAAA;AAAA,IAC/E,eAAA,EAAiB,CAAC,SAAS,CAAA;AAAA,IAC3B,YAAY,CAAC,OAAA,EAAS,KAAA,EAAO,6BAAA,EAA+B,UAAU,OAAO;AAAA,GAC/E;AAAA,EACA,OAAA,EAAS,OAAA;AAAA,EACT,IAAA,EAAM,yCAAA;AAAA,EACN,IAAA,EAAM;AAAA,IACJ,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,MAAA;AAAA,MACN,WAAA,EAAa,6EAAA;AAAA,MACb,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,MAAA;AAAA,MACN,WAAA,EAAa,8EAAA;AAAA,MACb,eAAA,EACE;AAAA;AACJ;AAEJ","file":"haxe.cjs","sourcesContent":["import type { Language } from \"../types\";\n\nexport const haxe = {\n  slug: \"haxe\",\n  publishedDate: \"2005-10-01\",\n  extensions: [\".hx\", \".hxml\"],\n  author: \"Nicolas Cannasse / Haxe Foundation\",\n  website: \"https://haxe.org\",\n  paradigms: [\"object-oriented\", \"functional\", \"cross-platform\", \"statically typed\"],\n  tooling: {\n    runtimes: [\"JavaScript\", \"HashLink\", \"JVM\", \"C++\", \"C#\", \"PHP\", \"Lua\", \"Python\"],\n    packageManagers: [\"haxelib\"],\n    ecosystems: [\"Games\", \"Web\", \"Cross-platform Applications\", \"OpenFL\", \"Heaps\"],\n  },\n  version: \"4.3.7\",\n  logo: \"https://cdn.simpleicons.org/haxe/EA8220\",\n  i18n: {\n    en: {\n      name: \"Haxe\",\n      description: \"A cross-platform typed language that compiles to many runtimes and targets.\",\n      longDescription:\n        \"Haxe is a high-level, statically typed programming language and compiler toolkit that targets JavaScript, C++, C#, Java, JVM bytecode, PHP, Lua, Python, HashLink, and other platforms. It includes type inference, macros, abstracts, generics, pattern matching, and a shared standard library.\\n\\nIt is used for games, web applications, creative coding, cross-platform tools, multimedia frameworks, and codebases that need to share typed business or engine logic across many targets.\",\n    },\n    es: {\n      name: \"Haxe\",\n      description: \"Un lenguaje tipado multiplataforma que compila a muchos runtimes y destinos.\",\n      longDescription:\n        \"Haxe es un lenguaje de programacion de alto nivel con tipado estatico y un toolkit de compilador que apunta a JavaScript, C++, C#, Java, bytecode JVM, PHP, Lua, Python, HashLink y otras plataformas. Incluye inferencia de tipos, macros, abstracts, genericos, pattern matching y una biblioteca estandar compartida.\\n\\nSe usa en juegos, aplicaciones web, creative coding, herramientas multiplataforma, frameworks multimedia y codebases que necesitan compartir logica tipada de negocio o motor entre muchos destinos.\",\n    },\n  },\n} satisfies Language;\n"]}

package/dist/languages/haxe.d.cts

@@ -0,0 +1,29 @@
+declare const haxe: {
+    slug: string;
+    publishedDate: string;
+    extensions: string[];
+    author: string;
+    website: string;
+    paradigms: string[];
+    tooling: {
+        runtimes: string[];
+        packageManagers: string[];
+        ecosystems: string[];
+    };
+    version: string;
+    logo: string;
+    i18n: {
+        en: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        es: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+    };
+};
+
+export { haxe };

package/dist/languages/haxe.d.ts

@@ -0,0 +1,29 @@
+declare const haxe: {
+    slug: string;
+    publishedDate: string;
+    extensions: string[];
+    author: string;
+    website: string;
+    paradigms: string[];
+    tooling: {
+        runtimes: string[];
+        packageManagers: string[];
+        ecosystems: string[];
+    };
+    version: string;
+    logo: string;
+    i18n: {
+        en: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+        es: {
+            name: string;
+            description: string;
+            longDescription: string;
+        };
+    };
+};
+
+export { haxe };

package/dist/languages/haxe.js

@@ -0,0 +1,32 @@
+// src/languages/haxe.ts
+var haxe = {
+  slug: "haxe",
+  publishedDate: "2005-10-01",
+  extensions: [".hx", ".hxml"],
+  author: "Nicolas Cannasse / Haxe Foundation",
+  website: "https://haxe.org",
+  paradigms: ["object-oriented", "functional", "cross-platform", "statically typed"],
+  tooling: {
+    runtimes: ["JavaScript", "HashLink", "JVM", "C++", "C#", "PHP", "Lua", "Python"],
+    packageManagers: ["haxelib"],
+    ecosystems: ["Games", "Web", "Cross-platform Applications", "OpenFL", "Heaps"]
+  },
+  version: "4.3.7",
+  logo: "https://cdn.simpleicons.org/haxe/EA8220",
+  i18n: {
+    en: {
+      name: "Haxe",
+      description: "A cross-platform typed language that compiles to many runtimes and targets.",
+      longDescription: "Haxe is a high-level, statically typed programming language and compiler toolkit that targets JavaScript, C++, C#, Java, JVM bytecode, PHP, Lua, Python, HashLink, and other platforms. It includes type inference, macros, abstracts, generics, pattern matching, and a shared standard library.\n\nIt is used for games, web applications, creative coding, cross-platform tools, multimedia frameworks, and codebases that need to share typed business or engine logic across many targets."
+    },
+    es: {
+      name: "Haxe",
+      description: "Un lenguaje tipado multiplataforma que compila a muchos runtimes y destinos.",
+      longDescription: "Haxe es un lenguaje de programacion de alto nivel con tipado estatico y un toolkit de compilador que apunta a JavaScript, C++, C#, Java, bytecode JVM, PHP, Lua, Python, HashLink y otras plataformas. Incluye inferencia de tipos, macros, abstracts, genericos, pattern matching y una biblioteca estandar compartida.\n\nSe usa en juegos, aplicaciones web, creative coding, herramientas multiplataforma, frameworks multimedia y codebases que necesitan compartir logica tipada de negocio o motor entre muchos destinos."
+    }
+  }
+};
+
+export { haxe };
+//# sourceMappingURL=haxe.js.map
+//# sourceMappingURL=haxe.js.map

package/dist/languages/haxe.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/languages/haxe.ts"],"names":[],"mappings":";AAEO,IAAM,IAAA,GAAO;AAAA,EAClB,IAAA,EAAM,MAAA;AAAA,EACN,aAAA,EAAe,YAAA;AAAA,EACf,UAAA,EAAY,CAAC,KAAA,EAAO,OAAO,CAAA;AAAA,EAC3B,MAAA,EAAQ,oCAAA;AAAA,EACR,OAAA,EAAS,kBAAA;AAAA,EACT,SAAA,EAAW,CAAC,iBAAA,EAAmB,YAAA,EAAc,kBAAkB,kBAAkB,CAAA;AAAA,EACjF,OAAA,EAAS;AAAA,IACP,QAAA,EAAU,CAAC,YAAA,EAAc,UAAA,EAAY,OAAO,KAAA,EAAO,IAAA,EAAM,KAAA,EAAO,KAAA,EAAO,QAAQ,CAAA;AAAA,IAC/E,eAAA,EAAiB,CAAC,SAAS,CAAA;AAAA,IAC3B,YAAY,CAAC,OAAA,EAAS,KAAA,EAAO,6BAAA,EAA+B,UAAU,OAAO;AAAA,GAC/E;AAAA,EACA,OAAA,EAAS,OAAA;AAAA,EACT,IAAA,EAAM,yCAAA;AAAA,EACN,IAAA,EAAM;AAAA,IACJ,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,MAAA;AAAA,MACN,WAAA,EAAa,6EAAA;AAAA,MACb,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,MAAA;AAAA,MACN,WAAA,EAAa,8EAAA;AAAA,MACb,eAAA,EACE;AAAA;AACJ;AAEJ","file":"haxe.js","sourcesContent":["import type { Language } from \"../types\";\n\nexport const haxe = {\n  slug: \"haxe\",\n  publishedDate: \"2005-10-01\",\n  extensions: [\".hx\", \".hxml\"],\n  author: \"Nicolas Cannasse / Haxe Foundation\",\n  website: \"https://haxe.org\",\n  paradigms: [\"object-oriented\", \"functional\", \"cross-platform\", \"statically typed\"],\n  tooling: {\n    runtimes: [\"JavaScript\", \"HashLink\", \"JVM\", \"C++\", \"C#\", \"PHP\", \"Lua\", \"Python\"],\n    packageManagers: [\"haxelib\"],\n    ecosystems: [\"Games\", \"Web\", \"Cross-platform Applications\", \"OpenFL\", \"Heaps\"],\n  },\n  version: \"4.3.7\",\n  logo: \"https://cdn.simpleicons.org/haxe/EA8220\",\n  i18n: {\n    en: {\n      name: \"Haxe\",\n      description: \"A cross-platform typed language that compiles to many runtimes and targets.\",\n      longDescription:\n        \"Haxe is a high-level, statically typed programming language and compiler toolkit that targets JavaScript, C++, C#, Java, JVM bytecode, PHP, Lua, Python, HashLink, and other platforms. It includes type inference, macros, abstracts, generics, pattern matching, and a shared standard library.\\n\\nIt is used for games, web applications, creative coding, cross-platform tools, multimedia frameworks, and codebases that need to share typed business or engine logic across many targets.\",\n    },\n    es: {\n      name: \"Haxe\",\n      description: \"Un lenguaje tipado multiplataforma que compila a muchos runtimes y destinos.\",\n      longDescription:\n        \"Haxe es un lenguaje de programacion de alto nivel con tipado estatico y un toolkit de compilador que apunta a JavaScript, C++, C#, Java, bytecode JVM, PHP, Lua, Python, HashLink y otras plataformas. Incluye inferencia de tipos, macros, abstracts, genericos, pattern matching y una biblioteca estandar compartida.\\n\\nSe usa en juegos, aplicaciones web, creative coding, herramientas multiplataforma, frameworks multimedia y codebases que necesitan compartir logica tipada de negocio o motor entre muchos destinos.\",\n    },\n  },\n} satisfies Language;\n"]}