code-languages 1.28.0 → 1.29.1

package/dist/languages/nickel.js

@@ -0,0 +1,50 @@
+// src/languages/nickel.ts
+var nickel = {
+  slug: "nickel",
+  publishedDate: "2022-03-09",
+  extensions: [".ncl"],
+  author: "Tweag I/O",
+  website: "https://nickel-lang.org",
+  paradigms: ["declarative", "functional"],
+  tooling: {
+    runtimes: ["nickel CLI"],
+    ecosystems: ["Configuration", "Infrastructure", "Nix", "DevOps"]
+  },
+  version: "1.16.0",
+  logo: "https://avatars.githubusercontent.com/u/83021462?v=4",
+  color: "#3C6EB4",
+  i18n: {
+    en: {
+      name: "Nickel",
+      description: "A safe, gradually-typed configuration language with gradual contracts and blame tracking, designed as an evolution of Nix expressions.",
+      longDescription: "Nickel is a configuration language developed by Tweag I/O to address the shortcomings of ad-hoc YAML/JSON and the complexity of the Nix language. It is designed to be simple enough for configuration authors while being expressive enough for library authors building reusable abstractions.\n\nNickel features gradual typing with contracts \u2014 runtime-checked refinement types that can express invariants like 'a port number between 0 and 65535'. When a contract is violated, Nickel provides precise blame tracking to identify the source of the error. It supports lazy evaluation, a record merge operator for composing configurations, and can export to JSON, YAML, and TOML."
+    },
+    es: {
+      name: "Nickel",
+      description: "Un lenguaje de configuraci\xF3n seguro y gradualmente tipado con contratos y rastreo de culpa, dise\xF1ado como una evoluci\xF3n de las expresiones Nix.",
+      longDescription: "Nickel es un lenguaje de configuraci\xF3n desarrollado por Tweag I/O para resolver las deficiencias de YAML/JSON ad-hoc y la complejidad del lenguaje Nix. Est\xE1 dise\xF1ado para ser suficientemente simple para autores de configuraci\xF3n y suficientemente expresivo para autores de bibliotecas.\n\nNickel incluye tipado gradual con contratos \u2014 tipos de refinamiento verificados en tiempo de ejecuci\xF3n que pueden expresar invariantes. Cuando se viola un contrato, Nickel proporciona rastreo preciso de culpa. Soporta evaluaci\xF3n perezosa y un operador de fusi\xF3n de registros para componer configuraciones."
+    },
+    it: {
+      name: "Nickel",
+      description: "Un linguaggio di configurazione sicuro e gradualmente tipizzato con contratti graduali e blame tracking, progettato come evoluzione delle espressioni Nix.",
+      longDescription: "Nickel \xE8 un linguaggio di configurazione sviluppato da Tweag I/O per risolvere i limiti di YAML/JSON ad-hoc e la complessit\xE0 del linguaggio Nix. \xC8 progettato per essere abbastanza semplice per gli autori di configurazioni e abbastanza espressivo per gli autori di librerie.\n\nNickel include tipizzazione graduale con contratti \u2014 tipi di raffinamento verificati a runtime che possono esprimere invarianti. Quando un contratto viene violato, Nickel fornisce un blame tracking preciso. Supporta la valutazione lazy e un operatore di fusione di record."
+    },
+    fr: {
+      name: "Nickel",
+      description: "Un langage de configuration s\xFBr et graduellement typ\xE9 avec des contrats graduels et un suivi de responsabilit\xE9, con\xE7u comme une \xE9volution des expressions Nix.",
+      longDescription: "Nickel est un langage de configuration d\xE9velopp\xE9 par Tweag I/O pour rem\xE9dier aux lacunes de YAML/JSON ad-hoc et \xE0 la complexit\xE9 du langage Nix. Il est con\xE7u pour \xEAtre suffisamment simple pour les auteurs de configurations et suffisamment expressif pour les auteurs de biblioth\xE8ques.\n\nNickel propose un typage graduel avec des contrats \u2014 des types de raffinement v\xE9rifi\xE9s \xE0 l'ex\xE9cution. En cas de violation de contrat, Nickel fournit un suivi pr\xE9cis de la responsabilit\xE9. Il supporte l'\xE9valuation paresseuse et un op\xE9rateur de fusion de records."
+    },
+    de: {
+      name: "Nickel",
+      description: "Eine sichere, graduell typisierte Konfigurationssprache mit graduellen Contracts und Blame-Tracking, entwickelt als Weiterentwicklung von Nix-Ausdr\xFCcken.",
+      longDescription: "Nickel ist eine von Tweag I/O entwickelte Konfigurationssprache, um die Schw\xE4chen von ad-hoc YAML/JSON und die Komplexit\xE4t der Nix-Sprache zu beheben. Sie ist einfach genug f\xFCr Konfigurationsautoren und ausdrucksstark genug f\xFCr Bibliotheksautoren.\n\nNickel bietet graduelles Typsystem mit Contracts \u2014 laufzeitgepr\xFCfte Verfeinerungstypen, die Invarianten ausdr\xFCcken k\xF6nnen. Bei einem Contract-Versto\xDF liefert Nickel pr\xE4zises Blame-Tracking. Es unterst\xFCtzt Lazy Evaluation und einen Record-Merge-Operator."
+    },
+    pt: {
+      name: "Nickel",
+      description: "Linguagem de configura\xE7\xE3o segura e gradualmente tipada com contratos e rastreamento de responsabilidade, projetada como evolu\xE7\xE3o das express\xF5es Nix.",
+      longDescription: "Nickel \xE9 uma linguagem de configura\xE7\xE3o desenvolvida pela Tweag I/O para resolver as defici\xEAncias de YAML/JSON ad-hoc e a complexidade da linguagem Nix. \xC9 projetada para ser simples o suficiente para autores de configura\xE7\xE3o e expressiva o suficiente para autores de bibliotecas.\n\nNickel inclui tipagem gradual com contratos \u2014 tipos de refinamento verificados em tempo de execu\xE7\xE3o que podem expressar invariantes. Quando um contrato \xE9 violado, o Nickel fornece rastreamento preciso de responsabilidade. Suporta avalia\xE7\xE3o pregui\xE7osa e um operador de mesclagem de registros."
+    }
+  }
+};
+
+export { nickel };

package/dist/languages/nushell.cjs

@@ -13,7 +13,7 @@ var nushell = {
     packageManagers: ["nupm"],
     ecosystems: ["Shell", "Unix", "Windows", "macOS"]
   },
-  version: "0.103.0",
+  version: "0.113.1",
   logo: "https://www.nushell.sh/icons/android-chrome-512x512.png",
   color: "#3AA675",
   i18n: {

package/dist/languages/nushell.js

@@ -11,7 +11,7 @@ var nushell = {
     packageManagers: ["nupm"],
     ecosystems: ["Shell", "Unix", "Windows", "macOS"]
   },
-  version: "0.103.0",
+  version: "0.113.1",
   logo: "https://www.nushell.sh/icons/android-chrome-512x512.png",
   color: "#3AA675",
   i18n: {

package/dist/languages/pkl.cjs

@@ -0,0 +1,53 @@
+'use strict';
+
+// src/languages/pkl.ts
+var pkl = {
+  slug: "pkl",
+  publishedDate: "2024-02-01",
+  extensions: [".pkl"],
+  author: "Apple",
+  website: "https://pkl-lang.org",
+  paradigms: ["declarative", "functional"],
+  tooling: {
+    runtimes: ["pkl CLI", "GraalVM native image"],
+    packageManagers: ["pkl package"],
+    ecosystems: ["Configuration", "Infrastructure", "Cloud", "Kubernetes"]
+  },
+  version: "0.28.2",
+  logo: "https://avatars.githubusercontent.com/u/10639145?v=4",
+  color: "#72AE44",
+  i18n: {
+    en: {
+      name: "Pkl",
+      description: "Apple's programmable configuration language that brings type safety, validation, and code generation to structured configuration files.",
+      longDescription: "Pkl (pronounced 'Pickle') is a configuration language created by Apple and open-sourced in 2024. It is designed to replace ad-hoc YAML, JSON, and TOML configurations with a language that provides type safety, validation, reuse through inheritance, and multi-format output.\n\nPkl files can be evaluated to generate JSON, YAML, TOML, or Java properties output. It features a class-based module system, expressive templates, first-class functions, and built-in support for rendering configuration for Kubernetes, Terraform, and other cloud infrastructure tools. The CLI tool and native libraries are available for multiple languages."
+    },
+    es: {
+      name: "Pkl",
+      description: "El lenguaje de configuraci\xF3n programable de Apple que aporta seguridad de tipos, validaci\xF3n y generaci\xF3n de c\xF3digo a los archivos de configuraci\xF3n.",
+      longDescription: "Pkl (pronunciado 'Pickle') es un lenguaje de configuraci\xF3n creado por Apple y publicado como c\xF3digo abierto en 2024. Est\xE1 dise\xF1ado para reemplazar configuraciones ad-hoc de YAML, JSON y TOML con un lenguaje que ofrece seguridad de tipos, validaci\xF3n, reutilizaci\xF3n por herencia y salida en m\xFAltiples formatos.\n\nLos archivos Pkl pueden evaluarse para generar JSON, YAML, TOML o propiedades Java. Incluye un sistema de m\xF3dulos basado en clases, plantillas expresivas y soporte para Kubernetes, Terraform y otras herramientas de infraestructura."
+    },
+    it: {
+      name: "Pkl",
+      description: "Il linguaggio di configurazione programmabile di Apple che porta type safety, validazione e generazione di codice ai file di configurazione strutturati.",
+      longDescription: "Pkl (pronunciato 'Pickle') \xE8 un linguaggio di configurazione creato da Apple e reso open source nel 2024. \xC8 progettato per sostituire le configurazioni ad-hoc di YAML, JSON e TOML con un linguaggio che offre type safety, validazione, riutilizzo tramite ereditariet\xE0 e output in pi\xF9 formati.\n\nI file Pkl possono essere valutati per generare JSON, YAML, TOML o propriet\xE0 Java. Include un sistema di moduli basato su classi, template espressivi e supporto per Kubernetes, Terraform e altri strumenti di infrastruttura cloud."
+    },
+    fr: {
+      name: "Pkl",
+      description: "Le langage de configuration programmable d'Apple qui apporte la s\xFBret\xE9 de type, la validation et la g\xE9n\xE9ration de code aux fichiers de configuration structur\xE9s.",
+      longDescription: "Pkl (prononc\xE9 'Pickle') est un langage de configuration cr\xE9\xE9 par Apple et publi\xE9 en open source en 2024. Il est con\xE7u pour remplacer les configurations YAML, JSON et TOML ad-hoc par un langage offrant la s\xFBret\xE9 de type, la validation, la r\xE9utilisation par h\xE9ritage et la sortie en plusieurs formats.\n\nLes fichiers Pkl peuvent \xEAtre \xE9valu\xE9s pour g\xE9n\xE9rer du JSON, YAML, TOML ou des propri\xE9t\xE9s Java. Il comprend un syst\xE8me de modules bas\xE9 sur des classes, des templates expressifs et un support pour Kubernetes, Terraform et d'autres outils d'infrastructure cloud."
+    },
+    de: {
+      name: "Pkl",
+      description: "Apples programmierbare Konfigurationssprache, die Typsicherheit, Validierung und Code-Generierung in strukturierte Konfigurationsdateien bringt.",
+      longDescription: "Pkl (ausgesprochen 'Pickle') ist eine von Apple entwickelte Konfigurationssprache, die 2024 als Open Source ver\xF6ffentlicht wurde. Sie soll ad-hoc YAML-, JSON- und TOML-Konfigurationen durch eine Sprache ersetzen, die Typsicherheit, Validierung, Wiederverwendung durch Vererbung und Ausgabe in mehreren Formaten bietet.\n\nPkl-Dateien k\xF6nnen ausgewertet werden, um JSON, YAML, TOML oder Java-Properties zu generieren. Es umfasst ein klassenbasiertes Modulsystem, ausdrucksstarke Templates und Unterst\xFCtzung f\xFCr Kubernetes, Terraform und andere Cloud-Infrastruktur-Tools."
+    },
+    pt: {
+      name: "Pkl",
+      description: "A linguagem de configura\xE7\xE3o program\xE1vel da Apple que traz seguran\xE7a de tipos, valida\xE7\xE3o e gera\xE7\xE3o de c\xF3digo para arquivos de configura\xE7\xE3o estruturados.",
+      longDescription: "Pkl (pronunciado 'Pickle') \xE9 uma linguagem de configura\xE7\xE3o criada pela Apple e publicada como c\xF3digo aberto em 2024. Foi projetada para substituir configura\xE7\xF5es ad-hoc de YAML, JSON e TOML por uma linguagem que oferece seguran\xE7a de tipos, valida\xE7\xE3o, reutiliza\xE7\xE3o por heran\xE7a e sa\xEDda em m\xFAltiplos formatos.\n\nArquivos Pkl podem ser avaliados para gerar JSON, YAML, TOML ou propriedades Java. Inclui um sistema de m\xF3dulos baseado em classes, templates expressivos e suporte para Kubernetes, Terraform e outras ferramentas de infraestrutura cloud."
+    }
+  }
+};
+
+exports.pkl = pkl;

package/dist/languages/pkl.d.cts

@@ -0,0 +1,50 @@
+declare const pkl: {
+    slug: string;
+    publishedDate: string;
+    extensions: string[];
+    author: string;
+    website: string;
+    paradigms: string[];
+    tooling: {
+        runtimes: string[];
+        packageManagers: string[];
+        ecosystems: string[];
+    };
+    version: string;
+    logo: string;
+    color: "#72AE44";
+    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 { pkl };

package/dist/languages/pkl.d.ts

@@ -0,0 +1,50 @@
+declare const pkl: {
+    slug: string;
+    publishedDate: string;
+    extensions: string[];
+    author: string;
+    website: string;
+    paradigms: string[];
+    tooling: {
+        runtimes: string[];
+        packageManagers: string[];
+        ecosystems: string[];
+    };
+    version: string;
+    logo: string;
+    color: "#72AE44";
+    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 { pkl };

package/dist/languages/pkl.js

@@ -0,0 +1,51 @@
+// src/languages/pkl.ts
+var pkl = {
+  slug: "pkl",
+  publishedDate: "2024-02-01",
+  extensions: [".pkl"],
+  author: "Apple",
+  website: "https://pkl-lang.org",
+  paradigms: ["declarative", "functional"],
+  tooling: {
+    runtimes: ["pkl CLI", "GraalVM native image"],
+    packageManagers: ["pkl package"],
+    ecosystems: ["Configuration", "Infrastructure", "Cloud", "Kubernetes"]
+  },
+  version: "0.28.2",
+  logo: "https://avatars.githubusercontent.com/u/10639145?v=4",
+  color: "#72AE44",
+  i18n: {
+    en: {
+      name: "Pkl",
+      description: "Apple's programmable configuration language that brings type safety, validation, and code generation to structured configuration files.",
+      longDescription: "Pkl (pronounced 'Pickle') is a configuration language created by Apple and open-sourced in 2024. It is designed to replace ad-hoc YAML, JSON, and TOML configurations with a language that provides type safety, validation, reuse through inheritance, and multi-format output.\n\nPkl files can be evaluated to generate JSON, YAML, TOML, or Java properties output. It features a class-based module system, expressive templates, first-class functions, and built-in support for rendering configuration for Kubernetes, Terraform, and other cloud infrastructure tools. The CLI tool and native libraries are available for multiple languages."
+    },
+    es: {
+      name: "Pkl",
+      description: "El lenguaje de configuraci\xF3n programable de Apple que aporta seguridad de tipos, validaci\xF3n y generaci\xF3n de c\xF3digo a los archivos de configuraci\xF3n.",
+      longDescription: "Pkl (pronunciado 'Pickle') es un lenguaje de configuraci\xF3n creado por Apple y publicado como c\xF3digo abierto en 2024. Est\xE1 dise\xF1ado para reemplazar configuraciones ad-hoc de YAML, JSON y TOML con un lenguaje que ofrece seguridad de tipos, validaci\xF3n, reutilizaci\xF3n por herencia y salida en m\xFAltiples formatos.\n\nLos archivos Pkl pueden evaluarse para generar JSON, YAML, TOML o propiedades Java. Incluye un sistema de m\xF3dulos basado en clases, plantillas expresivas y soporte para Kubernetes, Terraform y otras herramientas de infraestructura."
+    },
+    it: {
+      name: "Pkl",
+      description: "Il linguaggio di configurazione programmabile di Apple che porta type safety, validazione e generazione di codice ai file di configurazione strutturati.",
+      longDescription: "Pkl (pronunciato 'Pickle') \xE8 un linguaggio di configurazione creato da Apple e reso open source nel 2024. \xC8 progettato per sostituire le configurazioni ad-hoc di YAML, JSON e TOML con un linguaggio che offre type safety, validazione, riutilizzo tramite ereditariet\xE0 e output in pi\xF9 formati.\n\nI file Pkl possono essere valutati per generare JSON, YAML, TOML o propriet\xE0 Java. Include un sistema di moduli basato su classi, template espressivi e supporto per Kubernetes, Terraform e altri strumenti di infrastruttura cloud."
+    },
+    fr: {
+      name: "Pkl",
+      description: "Le langage de configuration programmable d'Apple qui apporte la s\xFBret\xE9 de type, la validation et la g\xE9n\xE9ration de code aux fichiers de configuration structur\xE9s.",
+      longDescription: "Pkl (prononc\xE9 'Pickle') est un langage de configuration cr\xE9\xE9 par Apple et publi\xE9 en open source en 2024. Il est con\xE7u pour remplacer les configurations YAML, JSON et TOML ad-hoc par un langage offrant la s\xFBret\xE9 de type, la validation, la r\xE9utilisation par h\xE9ritage et la sortie en plusieurs formats.\n\nLes fichiers Pkl peuvent \xEAtre \xE9valu\xE9s pour g\xE9n\xE9rer du JSON, YAML, TOML ou des propri\xE9t\xE9s Java. Il comprend un syst\xE8me de modules bas\xE9 sur des classes, des templates expressifs et un support pour Kubernetes, Terraform et d'autres outils d'infrastructure cloud."
+    },
+    de: {
+      name: "Pkl",
+      description: "Apples programmierbare Konfigurationssprache, die Typsicherheit, Validierung und Code-Generierung in strukturierte Konfigurationsdateien bringt.",
+      longDescription: "Pkl (ausgesprochen 'Pickle') ist eine von Apple entwickelte Konfigurationssprache, die 2024 als Open Source ver\xF6ffentlicht wurde. Sie soll ad-hoc YAML-, JSON- und TOML-Konfigurationen durch eine Sprache ersetzen, die Typsicherheit, Validierung, Wiederverwendung durch Vererbung und Ausgabe in mehreren Formaten bietet.\n\nPkl-Dateien k\xF6nnen ausgewertet werden, um JSON, YAML, TOML oder Java-Properties zu generieren. Es umfasst ein klassenbasiertes Modulsystem, ausdrucksstarke Templates und Unterst\xFCtzung f\xFCr Kubernetes, Terraform und andere Cloud-Infrastruktur-Tools."
+    },
+    pt: {
+      name: "Pkl",
+      description: "A linguagem de configura\xE7\xE3o program\xE1vel da Apple que traz seguran\xE7a de tipos, valida\xE7\xE3o e gera\xE7\xE3o de c\xF3digo para arquivos de configura\xE7\xE3o estruturados.",
+      longDescription: "Pkl (pronunciado 'Pickle') \xE9 uma linguagem de configura\xE7\xE3o criada pela Apple e publicada como c\xF3digo aberto em 2024. Foi projetada para substituir configura\xE7\xF5es ad-hoc de YAML, JSON e TOML por uma linguagem que oferece seguran\xE7a de tipos, valida\xE7\xE3o, reutiliza\xE7\xE3o por heran\xE7a e sa\xEDda em m\xFAltiplos formatos.\n\nArquivos Pkl podem ser avaliados para gerar JSON, YAML, TOML ou propriedades Java. Inclui um sistema de m\xF3dulos baseado em classes, templates expressivos e suporte para Kubernetes, Terraform e outras ferramentas de infraestrutura cloud."
+    }
+  }
+};
+
+export { pkl };

package/dist/languages/svelte.cjs

@@ -13,7 +13,7 @@ var svelte = {
     packageManagers: ["npm", "pnpm", "Yarn", "Bun"],
     ecosystems: ["Web", "SvelteKit", "Vite"]
   },
-  version: "5.56.0",
+  version: "5.56.1",
   logo: "https://upload.wikimedia.org/wikipedia/commons/1/1b/Svelte_Logo.svg",
   color: "#FF3E00",
   i18n: {

package/dist/languages/svelte.js

@@ -11,7 +11,7 @@ var svelte = {
     packageManagers: ["npm", "pnpm", "Yarn", "Bun"],
     ecosystems: ["Web", "SvelteKit", "Vite"]
   },
-  version: "5.56.0",
+  version: "5.56.1",
   logo: "https://upload.wikimedia.org/wikipedia/commons/1/1b/Svelte_Logo.svg",
   color: "#FF3E00",
   i18n: {

package/dist/languages/twig.cjs

@@ -13,7 +13,7 @@ var twig = {
     packageManagers: ["Composer"],
     ecosystems: ["PHP", "Symfony", "Web", "CMS"]
   },
-  version: "3.27.0",
+  version: "3.27.1",
   logo: "https://twig.symfony.com/images/logo.png",
   color: "#A5C53A",
   i18n: {

package/dist/languages/twig.js

@@ -11,7 +11,7 @@ var twig = {
     packageManagers: ["Composer"],
     ecosystems: ["PHP", "Symfony", "Web", "CMS"]
   },
-  version: "3.27.0",
+  version: "3.27.1",
   logo: "https://twig.symfony.com/images/logo.png",
   color: "#A5C53A",
   i18n: {

package/dist/languages/unison.cjs

@@ -0,0 +1,53 @@
+'use strict';
+
+// src/languages/unison.ts
+var unison = {
+  slug: "unison",
+  publishedDate: "2019-10-04",
+  extensions: [".u", ".uu"],
+  author: "Paul Chiusano, R\xFAnar Bjarnason",
+  website: "https://www.unison-lang.org",
+  paradigms: ["functional", "distributed"],
+  tooling: {
+    runtimes: ["Unison runtime (UCM)"],
+    packageManagers: ["Unison Share"],
+    ecosystems: ["Distributed Systems", "Cloud", "Functional"]
+  },
+  version: "0.5.28",
+  logo: "https://avatars.githubusercontent.com/u/18563978?v=4",
+  color: "#F37B1F",
+  i18n: {
+    en: {
+      name: "Unison",
+      description: "A functional programming language where code is content-addressed by hash, eliminating dependency conflicts and enabling seamless distributed computing.",
+      longDescription: "Unison is a programming language with a radically different approach to code storage and distribution. Instead of storing code as text files, Unison stores definitions by their content hash \u2014 a definition's identity is its content, not its name or location. This eliminates package versioning conflicts and enables a novel form of distributed programming.\n\nUnison's distributed abilities are built into the type system: functions can be serialized and sent to remote nodes where they execute with their full closure. The language is purely functional with algebraic effects, a strong type system with type inference, and first-class abilities (algebraic effects). Code is managed through the Unison Codebase Manager (UCM), and libraries are shared via Unison Share."
+    },
+    es: {
+      name: "Unison",
+      description: "Lenguaje funcional donde el c\xF3digo se almacena por hash de contenido, eliminando conflictos de dependencias y habilitando computaci\xF3n distribuida.",
+      longDescription: "Unison es un lenguaje de programaci\xF3n con un enfoque radicalmente diferente al almacenamiento y distribuci\xF3n de c\xF3digo. En lugar de archivos de texto, Unison almacena definiciones por su hash de contenido. Esto elimina los conflictos de versiones de paquetes y habilita una nueva forma de programaci\xF3n distribuida.\n\nLas capacidades distribuidas de Unison est\xE1n integradas en el sistema de tipos: las funciones pueden serializarse y enviarse a nodos remotos donde se ejecutan con todo su closure. El lenguaje es puramente funcional con efectos algebraicos y un sistema de tipos fuerte con inferencia de tipos."
+    },
+    it: {
+      name: "Unison",
+      description: "Linguaggio funzionale dove il codice \xE8 indirizzato per contenuto tramite hash, eliminando i conflitti di dipendenze e abilitando il calcolo distribuito.",
+      longDescription: "Unison \xE8 un linguaggio di programmazione con un approccio radicalmente diverso all'archiviazione e distribuzione del codice. Invece di file di testo, Unison archivia le definizioni tramite il loro hash di contenuto. Questo elimina i conflitti di versioni dei pacchetti e abilita una nuova forma di programmazione distribuita.\n\nLe capacit\xE0 distribuite di Unison sono integrate nel sistema di tipi: le funzioni possono essere serializzate e inviate a nodi remoti dove vengono eseguite con la loro closure completa. Il linguaggio \xE8 puramente funzionale con effetti algebrici e un sistema di tipi forte."
+    },
+    fr: {
+      name: "Unison",
+      description: "Un langage de programmation fonctionnel o\xF9 le code est adress\xE9 par contenu via un hash, \xE9liminant les conflits de d\xE9pendances et permettant le calcul distribu\xE9.",
+      longDescription: "Unison est un langage de programmation avec une approche radicalement diff\xE9rente du stockage et de la distribution du code. Au lieu de fichiers texte, Unison stocke les d\xE9finitions par leur hash de contenu. Cela \xE9limine les conflits de versions de paquets et permet une nouvelle forme de programmation distribu\xE9e.\n\nLes capacit\xE9s distribu\xE9es d'Unison sont int\xE9gr\xE9es dans le syst\xE8me de types: les fonctions peuvent \xEAtre s\xE9rialis\xE9es et envoy\xE9es \xE0 des n\u0153uds distants o\xF9 elles s'ex\xE9cutent avec leur closure compl\xE8te. Le langage est purement fonctionnel avec des effets alg\xE9briques."
+    },
+    de: {
+      name: "Unison",
+      description: "Funktionale Programmiersprache, bei der Code per Hash inhaltsadressiert ist, Abh\xE4ngigkeitskonflikte eliminiert und verteilte Berechnung erm\xF6glicht.",
+      longDescription: "Unison ist eine Programmiersprache mit einem radikal anderen Ansatz zur Code-Speicherung und -Verteilung. Statt Textdateien speichert Unison Definitionen durch ihren Inhalts-Hash. Dies eliminiert Paketversionskonflikte und erm\xF6glicht eine neue Form des verteilten Programmierens.\n\nUnisons verteilte F\xE4higkeiten sind in das Typsystem integriert: Funktionen k\xF6nnen serialisiert und an entfernte Knoten gesendet werden, wo sie mit ihrer vollst\xE4ndigen Closure ausgef\xFChrt werden. Die Sprache ist rein funktional mit algebraischen Effekten."
+    },
+    pt: {
+      name: "Unison",
+      description: "Linguagem funcional onde o c\xF3digo \xE9 endere\xE7ado por hash de conte\xFAdo, eliminando conflitos de depend\xEAncias e permitindo computa\xE7\xE3o distribu\xEDda.",
+      longDescription: "Unison \xE9 uma linguagem de programa\xE7\xE3o com uma abordagem radicalmente diferente para armazenamento e distribui\xE7\xE3o de c\xF3digo. Em vez de arquivos de texto, o Unison armazena defini\xE7\xF5es pelo seu hash de conte\xFAdo. Isso elimina conflitos de vers\xE3o de pacotes e permite uma nova forma de programa\xE7\xE3o distribu\xEDda.\n\nAs capacidades distribu\xEDdas do Unison est\xE3o integradas no sistema de tipos: fun\xE7\xF5es podem ser serializadas e enviadas para n\xF3s remotos onde s\xE3o executadas com todo o seu closure. A linguagem \xE9 puramente funcional com efeitos alg\xE9bricos e um sistema de tipos forte."
+    }
+  }
+};
+
+exports.unison = unison;

package/dist/languages/unison.d.cts

@@ -0,0 +1,50 @@
+declare const unison: {
+    slug: string;
+    publishedDate: string;
+    extensions: string[];
+    author: string;
+    website: string;
+    paradigms: string[];
+    tooling: {
+        runtimes: string[];
+        packageManagers: string[];
+        ecosystems: string[];
+    };
+    version: string;
+    logo: string;
+    color: "#F37B1F";
+    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 { unison };

package/dist/languages/unison.d.ts

@@ -0,0 +1,50 @@
+declare const unison: {
+    slug: string;
+    publishedDate: string;
+    extensions: string[];
+    author: string;
+    website: string;
+    paradigms: string[];
+    tooling: {
+        runtimes: string[];
+        packageManagers: string[];
+        ecosystems: string[];
+    };
+    version: string;
+    logo: string;
+    color: "#F37B1F";
+    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 { unison };

package/dist/languages/unison.js

@@ -0,0 +1,51 @@
+// src/languages/unison.ts
+var unison = {
+  slug: "unison",
+  publishedDate: "2019-10-04",
+  extensions: [".u", ".uu"],
+  author: "Paul Chiusano, R\xFAnar Bjarnason",
+  website: "https://www.unison-lang.org",
+  paradigms: ["functional", "distributed"],
+  tooling: {
+    runtimes: ["Unison runtime (UCM)"],
+    packageManagers: ["Unison Share"],
+    ecosystems: ["Distributed Systems", "Cloud", "Functional"]
+  },
+  version: "0.5.28",
+  logo: "https://avatars.githubusercontent.com/u/18563978?v=4",
+  color: "#F37B1F",
+  i18n: {
+    en: {
+      name: "Unison",
+      description: "A functional programming language where code is content-addressed by hash, eliminating dependency conflicts and enabling seamless distributed computing.",
+      longDescription: "Unison is a programming language with a radically different approach to code storage and distribution. Instead of storing code as text files, Unison stores definitions by their content hash \u2014 a definition's identity is its content, not its name or location. This eliminates package versioning conflicts and enables a novel form of distributed programming.\n\nUnison's distributed abilities are built into the type system: functions can be serialized and sent to remote nodes where they execute with their full closure. The language is purely functional with algebraic effects, a strong type system with type inference, and first-class abilities (algebraic effects). Code is managed through the Unison Codebase Manager (UCM), and libraries are shared via Unison Share."
+    },
+    es: {
+      name: "Unison",
+      description: "Lenguaje funcional donde el c\xF3digo se almacena por hash de contenido, eliminando conflictos de dependencias y habilitando computaci\xF3n distribuida.",
+      longDescription: "Unison es un lenguaje de programaci\xF3n con un enfoque radicalmente diferente al almacenamiento y distribuci\xF3n de c\xF3digo. En lugar de archivos de texto, Unison almacena definiciones por su hash de contenido. Esto elimina los conflictos de versiones de paquetes y habilita una nueva forma de programaci\xF3n distribuida.\n\nLas capacidades distribuidas de Unison est\xE1n integradas en el sistema de tipos: las funciones pueden serializarse y enviarse a nodos remotos donde se ejecutan con todo su closure. El lenguaje es puramente funcional con efectos algebraicos y un sistema de tipos fuerte con inferencia de tipos."
+    },
+    it: {
+      name: "Unison",
+      description: "Linguaggio funzionale dove il codice \xE8 indirizzato per contenuto tramite hash, eliminando i conflitti di dipendenze e abilitando il calcolo distribuito.",
+      longDescription: "Unison \xE8 un linguaggio di programmazione con un approccio radicalmente diverso all'archiviazione e distribuzione del codice. Invece di file di testo, Unison archivia le definizioni tramite il loro hash di contenuto. Questo elimina i conflitti di versioni dei pacchetti e abilita una nuova forma di programmazione distribuita.\n\nLe capacit\xE0 distribuite di Unison sono integrate nel sistema di tipi: le funzioni possono essere serializzate e inviate a nodi remoti dove vengono eseguite con la loro closure completa. Il linguaggio \xE8 puramente funzionale con effetti algebrici e un sistema di tipi forte."
+    },
+    fr: {
+      name: "Unison",
+      description: "Un langage de programmation fonctionnel o\xF9 le code est adress\xE9 par contenu via un hash, \xE9liminant les conflits de d\xE9pendances et permettant le calcul distribu\xE9.",
+      longDescription: "Unison est un langage de programmation avec une approche radicalement diff\xE9rente du stockage et de la distribution du code. Au lieu de fichiers texte, Unison stocke les d\xE9finitions par leur hash de contenu. Cela \xE9limine les conflits de versions de paquets et permet une nouvelle forme de programmation distribu\xE9e.\n\nLes capacit\xE9s distribu\xE9es d'Unison sont int\xE9gr\xE9es dans le syst\xE8me de types: les fonctions peuvent \xEAtre s\xE9rialis\xE9es et envoy\xE9es \xE0 des n\u0153uds distants o\xF9 elles s'ex\xE9cutent avec leur closure compl\xE8te. Le langage est purement fonctionnel avec des effets alg\xE9briques."
+    },
+    de: {
+      name: "Unison",
+      description: "Funktionale Programmiersprache, bei der Code per Hash inhaltsadressiert ist, Abh\xE4ngigkeitskonflikte eliminiert und verteilte Berechnung erm\xF6glicht.",
+      longDescription: "Unison ist eine Programmiersprache mit einem radikal anderen Ansatz zur Code-Speicherung und -Verteilung. Statt Textdateien speichert Unison Definitionen durch ihren Inhalts-Hash. Dies eliminiert Paketversionskonflikte und erm\xF6glicht eine neue Form des verteilten Programmierens.\n\nUnisons verteilte F\xE4higkeiten sind in das Typsystem integriert: Funktionen k\xF6nnen serialisiert und an entfernte Knoten gesendet werden, wo sie mit ihrer vollst\xE4ndigen Closure ausgef\xFChrt werden. Die Sprache ist rein funktional mit algebraischen Effekten."
+    },
+    pt: {
+      name: "Unison",
+      description: "Linguagem funcional onde o c\xF3digo \xE9 endere\xE7ado por hash de conte\xFAdo, eliminando conflitos de depend\xEAncias e permitindo computa\xE7\xE3o distribu\xEDda.",
+      longDescription: "Unison \xE9 uma linguagem de programa\xE7\xE3o com uma abordagem radicalmente diferente para armazenamento e distribui\xE7\xE3o de c\xF3digo. Em vez de arquivos de texto, o Unison armazena defini\xE7\xF5es pelo seu hash de conte\xFAdo. Isso elimina conflitos de vers\xE3o de pacotes e permite uma nova forma de programa\xE7\xE3o distribu\xEDda.\n\nAs capacidades distribu\xEDdas do Unison est\xE3o integradas no sistema de tipos: fun\xE7\xF5es podem ser serializadas e enviadas para n\xF3s remotos onde s\xE3o executadas com todo o seu closure. A linguagem \xE9 puramente funcional com efeitos alg\xE9bricos e um sistema de tipos forte."
+    }
+  }
+};
+
+export { unison };

package/dist/languages/yara.cjs

@@ -0,0 +1,53 @@
+'use strict';
+
+// src/languages/yara.ts
+var yara = {
+  slug: "yara",
+  publishedDate: "2008-05-01",
+  extensions: [".yar", ".yara"],
+  author: "Victor M. Alvarez",
+  website: "https://virustotal.github.io/yara/",
+  paradigms: ["declarative", "pattern-matching"],
+  tooling: {
+    runtimes: ["yara", "yara-python", "libyara"],
+    packageManagers: ["pip (yara-python)"],
+    ecosystems: ["Security", "Malware Analysis", "Threat Intelligence", "Forensics"]
+  },
+  version: "4.5.2",
+  logo: "https://avatars.githubusercontent.com/u/6306898?v=4",
+  color: "#C62D42",
+  i18n: {
+    en: {
+      name: "YARA",
+      description: "A pattern-matching language for identifying and classifying malware samples based on textual and binary patterns, widely used in threat intelligence.",
+      longDescription: "YARA (Yet Another Recursive Acronym) is a tool and rule language designed by Victor M. Alvarez at VirusTotal for identifying and classifying malware based on patterns found in files and processes. A YARA rule combines textual strings, byte patterns, and Boolean logic to describe families of malware.\n\nYARA rules are used extensively in antivirus products, security operations centers, incident response, and threat hunting. Each rule has a set of strings \u2014 hexadecimal sequences, text strings, or regular expressions \u2014 and a condition that must be satisfied for the rule to match. YARA runs as a standalone tool, as a Python library (yara-python), and is integrated into platforms like VirusTotal, MISP, Cuckoo Sandbox, and many SIEM systems."
+    },
+    es: {
+      name: "YARA",
+      description: "Lenguaje de coincidencia de patrones para identificar muestras de malware por patrones textuales y binarios, ampliamente usado en inteligencia de amenazas.",
+      longDescription: "YARA es una herramienta y lenguaje de reglas dise\xF1ado por Victor M. Alvarez en VirusTotal para identificar y clasificar malware bas\xE1ndose en patrones encontrados en archivos y procesos. Una regla YARA combina cadenas de texto, patrones de bytes y l\xF3gica booleana para describir familias de malware.\n\nLas reglas YARA se usan ampliamente en antivirus, centros de operaciones de seguridad, respuesta a incidentes y b\xFAsqueda de amenazas. Cada regla tiene un conjunto de cadenas \u2014 secuencias hexadecimales, texto o expresiones regulares \u2014 y una condici\xF3n que debe cumplirse."
+    },
+    it: {
+      name: "YARA",
+      description: "Linguaggio di pattern matching per identificare campioni di malware su pattern testuali e binari, ampiamente usato nell'intelligence sulle minacce.",
+      longDescription: "YARA \xE8 uno strumento e un linguaggio di regole progettato da Victor M. Alvarez presso VirusTotal per identificare e classificare malware basandosi su pattern trovati in file e processi. Una regola YARA combina stringhe testuali, pattern di byte e logica booleana per descrivere famiglie di malware.\n\nLe regole YARA sono ampiamente utilizzate in antivirus, SOC, risposta agli incidenti e threat hunting. Ogni regola ha un insieme di stringhe \u2014 sequenze esadecimali, testo o espressioni regolari \u2014 e una condizione che deve essere soddisfatta."
+    },
+    fr: {
+      name: "YARA",
+      description: "Langage de correspondance de motifs pour identifier des \xE9chantillons de malware par motifs textuels et binaires, utilis\xE9 en renseignement sur les menaces.",
+      longDescription: "YARA est un outil et un langage de r\xE8gles con\xE7u par Victor M. Alvarez chez VirusTotal pour identifier et classifier les malwares en fonction de motifs trouv\xE9s dans des fichiers et des processus. Une r\xE8gle YARA combine des cha\xEEnes textuelles, des motifs d'octets et une logique bool\xE9enne pour d\xE9crire des familles de malwares.\n\nLes r\xE8gles YARA sont largement utilis\xE9es dans les antivirus, les SOC, la r\xE9ponse aux incidents et la chasse aux menaces. Chaque r\xE8gle contient un ensemble de cha\xEEnes et une condition qui doit \xEAtre satisfaite."
+    },
+    de: {
+      name: "YARA",
+      description: "Pattern-Matching-Sprache zur Identifizierung von Malware-Proben anhand textueller und bin\xE4rer Muster, weit verbreitet in der Bedrohungsanalyse.",
+      longDescription: "YARA ist ein Tool und eine Regelsprache, die von Victor M. Alvarez bei VirusTotal entwickelt wurde, um Malware anhand von Mustern in Dateien und Prozessen zu identifizieren und zu klassifizieren. Eine YARA-Regel kombiniert Textstrings, Byte-Muster und boolesche Logik, um Malware-Familien zu beschreiben.\n\nYARA-Regeln werden in Antivirenprodukten, Security Operations Centers, Incident Response und Threat Hunting eingesetzt. Jede Regel hat Strings \u2014 hexadezimale Sequenzen, Textstrings oder regul\xE4re Ausdr\xFCcke \u2014 und eine Bedingung."
+    },
+    pt: {
+      name: "YARA",
+      description: "Linguagem de correspond\xEAncia de padr\xF5es para identificar amostras de malware por padr\xF5es textuais e bin\xE1rios, amplamente usada em intelig\xEAncia de amea\xE7as.",
+      longDescription: "YARA \xE9 uma ferramenta e linguagem de regras projetada por Victor M. Alvarez na VirusTotal para identificar e classificar malware com base em padr\xF5es encontrados em arquivos e processos. Uma regra YARA combina strings de texto, padr\xF5es de bytes e l\xF3gica booleana para descrever fam\xEDlias de malware.\n\nAs regras YARA s\xE3o amplamente usadas em antiv\xEDrus, centros de opera\xE7\xF5es de seguran\xE7a, resposta a incidentes e ca\xE7a a amea\xE7as. Cada regra tem um conjunto de strings \u2014 sequ\xEAncias hexadecimais, texto ou express\xF5es regulares \u2014 e uma condi\xE7\xE3o que deve ser satisfeita."
+    }
+  }
+};
+
+exports.yara = yara;