code-languages 1.34.1 → 1.36.0

package/dist/languages/brainfuck.d.ts

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

package/dist/languages/brainfuck.js

@@ -0,0 +1,50 @@
+// src/languages/brainfuck.ts
+var brainfuck = {
+  slug: "brainfuck",
+  publishedDate: "1993-01-01",
+  extensions: [".bf", ".b"],
+  author: "Urban Muller",
+  website: "https://esolangs.org/wiki/Brainfuck",
+  paradigms: ["esoteric", "imperative"],
+  tooling: {
+    runtimes: ["Interpreters", "Compilers"],
+    ecosystems: ["Esoteric programming"]
+  },
+  version: "stable",
+  logo: "https://dummyimage.com/32x32/111827/ffffff.png&text=BF",
+  color: "#111827",
+  i18n: {
+    en: {
+      name: "Brainfuck",
+      description: "An esoteric minimal language built around a tape, a pointer, and eight commands.",
+      longDescription: "Brainfuck is an intentionally tiny esoteric programming language with only eight commands. Programs move a pointer across a memory tape, mutate cells, read or write bytes, and use bracketed loops for control flow.\n\nThe language is rarely used for practical software, but it is influential as a teaching, golfing, interpreter, and compiler exercise. Its extreme simplicity makes it a compact test case for parsers, virtual machines, and code generation."
+    },
+    es: {
+      name: "Brainfuck",
+      description: "Lenguaje esoterico minimo basado en una cinta, un puntero y ocho comandos.",
+      longDescription: "Brainfuck es un lenguaje de programacion esoterico deliberadamente pequeno con solo ocho comandos. Los programas mueven un puntero sobre una cinta de memoria, mutan celdas, leen o escriben bytes y usan bucles con corchetes para control de flujo.\n\nEl lenguaje casi nunca se usa para software practico, pero influye como ejercicio de ensenanza, code golf, interpretes y compiladores. Su simplicidad extrema lo vuelve un caso de prueba compacto para parsers, maquinas virtuales y generacion de codigo."
+    },
+    it: {
+      name: "Brainfuck",
+      description: "Linguaggio esoterico minimo basato su nastro, puntatore e otto comandi.",
+      longDescription: "Brainfuck e un linguaggio di programmazione esoterico volutamente minuscolo con solo otto comandi. I programmi muovono un puntatore su un nastro di memoria, modificano celle, leggono o scrivono byte e usano cicli tra parentesi quadre per il flusso di controllo.\n\nIl linguaggio e usato raramente per software pratico, ma e influente come esercizio didattico, di code golf, interpreti e compilatori. La sua estrema semplicita lo rende un caso di prova compatto per parser, macchine virtuali e generazione di codice."
+    },
+    fr: {
+      name: "Brainfuck",
+      description: "Langage esoterique minimal fonde sur un ruban, un pointeur et huit commandes.",
+      longDescription: "Brainfuck est un langage de programmation esoterique volontairement minuscule avec seulement huit commandes. Les programmes deplacent un pointeur sur un ruban memoire, modifient des cellules, lisent ou ecrivent des octets et utilisent des boucles entre crochets.\n\nLe langage est rarement utilise pour du logiciel pratique, mais il est influent comme exercice d enseignement, de code golf, d interpreteur et de compilateur. Sa simplicite extreme en fait un cas de test compact pour parseurs, machines virtuelles et generation de code."
+    },
+    de: {
+      name: "Brainfuck",
+      description: "Esoterische minimale Sprache mit Speicherband, Zeiger und acht Befehlen.",
+      longDescription: "Brainfuck ist eine absichtlich winzige esoterische Programmiersprache mit nur acht Befehlen. Programme bewegen einen Zeiger uber ein Speicherband, verandern Zellen, lesen oder schreiben Bytes und nutzen geklammerte Schleifen fur Kontrollfluss.\n\nDie Sprache wird selten fur praktische Software genutzt, ist aber einflussreich als Ubung fur Lehre, Code Golf, Interpreter und Compiler. Ihre extreme Einfachheit macht sie zu einem kompakten Testfall fur Parser, virtuelle Maschinen und Codegenerierung."
+    },
+    pt: {
+      name: "Brainfuck",
+      description: "Linguagem esoterica minima baseada em fita, ponteiro e oito comandos.",
+      longDescription: "Brainfuck e uma linguagem de programacao esoterica intencionalmente pequena com apenas oito comandos. Programas movem um ponteiro por uma fita de memoria, alteram celulas, leem ou escrevem bytes e usam loops entre colchetes para fluxo de controle.\n\nA linguagem raramente e usada para software pratico, mas e influente como exercicio de ensino, code golf, interpretadores e compiladores. Sua simplicidade extrema a torna um caso de teste compacto para parsers, maquinas virtuais e geracao de codigo."
+    }
+  }
+};
+
+export { brainfuck };

package/dist/languages/capnproto.cjs

@@ -0,0 +1,52 @@
+'use strict';
+
+// src/languages/capnproto.ts
+var capnproto = {
+  slug: "capnproto",
+  publishedDate: "2013-01-01",
+  extensions: [".capnp"],
+  author: "Kenton Varda",
+  website: "https://capnproto.org",
+  paradigms: ["schema", "interface definition"],
+  tooling: {
+    runtimes: ["Capn Proto compiler"],
+    ecosystems: ["RPC", "Serialization"]
+  },
+  version: "stable",
+  logo: "https://capnproto.org/images/logo.png",
+  color: "#F97316",
+  i18n: {
+    en: {
+      name: "Cap'n Proto",
+      description: "A schema language for fast serialization and capability-oriented RPC interfaces.",
+      longDescription: "Capn Proto schemas define structured messages, enums, interfaces, and constants for a zero-copy serialization system. The format is designed so data can often be used directly from its encoded representation.\n\nThe language supports code generation for multiple host languages and is paired with an RPC system built around capabilities. It is used when low latency, cross-language contracts, and efficient binary interchange matter."
+    },
+    es: {
+      name: "Cap'n Proto",
+      description: "Lenguaje de esquemas para serializacion rapida e interfaces RPC orientadas a capacidades.",
+      longDescription: "Los esquemas Capn Proto definen mensajes estructurados, enums, interfaces y constantes para un sistema de serializacion zero-copy. El formato esta disenado para que los datos puedan usarse a menudo desde su representacion codificada.\n\nEl lenguaje soporta generacion de codigo para multiples lenguajes anfitriones y se combina con un sistema RPC basado en capacidades. Se usa cuando importan baja latencia, contratos entre lenguajes e intercambio binario eficiente."
+    },
+    it: {
+      name: "Cap'n Proto",
+      description: "Linguaggio di schema per serializzazione veloce e interfacce RPC orientate a capability.",
+      longDescription: "Gli schemi Capn Proto definiscono messaggi strutturati, enum, interfacce e costanti per un sistema di serializzazione zero-copy. Il formato e progettato per usare spesso i dati direttamente dalla rappresentazione codificata.\n\nIl linguaggio supporta generazione di codice per molti linguaggi host ed e abbinato a un sistema RPC basato su capability. E usato quando contano bassa latenza, contratti cross-language e scambio binario efficiente."
+    },
+    fr: {
+      name: "Cap'n Proto",
+      description: "Langage de schema pour serialisation rapide et interfaces RPC orientees capacites.",
+      longDescription: "Les schemas Capn Proto definissent messages structures, enums, interfaces et constantes pour un systeme de serialisation zero-copy. Le format est concu pour permettre souvent l usage direct des donnees depuis leur representation encodee.\n\nLe langage prend en charge la generation de code pour plusieurs langages hotes et s accompagne d un systeme RPC fonde sur les capacites. Il est utilise quand faible latence, contrats inter-langages et echange binaire efficace comptent."
+    },
+    de: {
+      name: "Cap'n Proto",
+      description: "Schemasprache fur schnelle Serialisierung und capability-orientierte RPC-Schnittstellen.",
+      longDescription: "Capn Proto-Schemas definieren strukturierte Nachrichten, Enums, Schnittstellen und Konstanten fur ein Zero-Copy-Serialisierungssystem. Das Format ist so entworfen, dass Daten oft direkt aus ihrer kodierten Darstellung nutzbar sind.\n\nDie Sprache unterstutzt Codegenerierung fur mehrere Hostsprachen und ist mit einem RPC-System rund um Capabilities gekoppelt. Sie wird genutzt, wenn niedrige Latenz, sprachubergreifende Vertrage und effizienter Binar-Austausch wichtig sind."
+    },
+    pt: {
+      name: "Cap'n Proto",
+      description: "Linguagem de esquema para serializacao rapida e interfaces RPC orientadas a capacidades.",
+      longDescription: "Esquemas Capn Proto definem mensagens estruturadas, enums, interfaces e constantes para um sistema de serializacao zero-copy. O formato e projetado para que dados muitas vezes possam ser usados diretamente da representacao codificada.\n\nA linguagem suporta geracao de codigo para varias linguagens hospedeiras e vem junto de um sistema RPC baseado em capacidades. Ela e usada quando baixa latencia, contratos entre linguagens e intercambio binario eficiente importam."
+    }
+  }
+};
+
+exports.capnproto = capnproto;

package/dist/languages/capnproto.d.cts

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

package/dist/languages/capnproto.d.ts

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

package/dist/languages/capnproto.js

@@ -0,0 +1,50 @@
+// src/languages/capnproto.ts
+var capnproto = {
+  slug: "capnproto",
+  publishedDate: "2013-01-01",
+  extensions: [".capnp"],
+  author: "Kenton Varda",
+  website: "https://capnproto.org",
+  paradigms: ["schema", "interface definition"],
+  tooling: {
+    runtimes: ["Capn Proto compiler"],
+    ecosystems: ["RPC", "Serialization"]
+  },
+  version: "stable",
+  logo: "https://capnproto.org/images/logo.png",
+  color: "#F97316",
+  i18n: {
+    en: {
+      name: "Cap'n Proto",
+      description: "A schema language for fast serialization and capability-oriented RPC interfaces.",
+      longDescription: "Capn Proto schemas define structured messages, enums, interfaces, and constants for a zero-copy serialization system. The format is designed so data can often be used directly from its encoded representation.\n\nThe language supports code generation for multiple host languages and is paired with an RPC system built around capabilities. It is used when low latency, cross-language contracts, and efficient binary interchange matter."
+    },
+    es: {
+      name: "Cap'n Proto",
+      description: "Lenguaje de esquemas para serializacion rapida e interfaces RPC orientadas a capacidades.",
+      longDescription: "Los esquemas Capn Proto definen mensajes estructurados, enums, interfaces y constantes para un sistema de serializacion zero-copy. El formato esta disenado para que los datos puedan usarse a menudo desde su representacion codificada.\n\nEl lenguaje soporta generacion de codigo para multiples lenguajes anfitriones y se combina con un sistema RPC basado en capacidades. Se usa cuando importan baja latencia, contratos entre lenguajes e intercambio binario eficiente."
+    },
+    it: {
+      name: "Cap'n Proto",
+      description: "Linguaggio di schema per serializzazione veloce e interfacce RPC orientate a capability.",
+      longDescription: "Gli schemi Capn Proto definiscono messaggi strutturati, enum, interfacce e costanti per un sistema di serializzazione zero-copy. Il formato e progettato per usare spesso i dati direttamente dalla rappresentazione codificata.\n\nIl linguaggio supporta generazione di codice per molti linguaggi host ed e abbinato a un sistema RPC basato su capability. E usato quando contano bassa latenza, contratti cross-language e scambio binario efficiente."
+    },
+    fr: {
+      name: "Cap'n Proto",
+      description: "Langage de schema pour serialisation rapide et interfaces RPC orientees capacites.",
+      longDescription: "Les schemas Capn Proto definissent messages structures, enums, interfaces et constantes pour un systeme de serialisation zero-copy. Le format est concu pour permettre souvent l usage direct des donnees depuis leur representation encodee.\n\nLe langage prend en charge la generation de code pour plusieurs langages hotes et s accompagne d un systeme RPC fonde sur les capacites. Il est utilise quand faible latence, contrats inter-langages et echange binaire efficace comptent."
+    },
+    de: {
+      name: "Cap'n Proto",
+      description: "Schemasprache fur schnelle Serialisierung und capability-orientierte RPC-Schnittstellen.",
+      longDescription: "Capn Proto-Schemas definieren strukturierte Nachrichten, Enums, Schnittstellen und Konstanten fur ein Zero-Copy-Serialisierungssystem. Das Format ist so entworfen, dass Daten oft direkt aus ihrer kodierten Darstellung nutzbar sind.\n\nDie Sprache unterstutzt Codegenerierung fur mehrere Hostsprachen und ist mit einem RPC-System rund um Capabilities gekoppelt. Sie wird genutzt, wenn niedrige Latenz, sprachubergreifende Vertrage und effizienter Binar-Austausch wichtig sind."
+    },
+    pt: {
+      name: "Cap'n Proto",
+      description: "Linguagem de esquema para serializacao rapida e interfaces RPC orientadas a capacidades.",
+      longDescription: "Esquemas Capn Proto definem mensagens estruturadas, enums, interfaces e constantes para um sistema de serializacao zero-copy. O formato e projetado para que dados muitas vezes possam ser usados diretamente da representacao codificada.\n\nA linguagem suporta geracao de codigo para varias linguagens hospedeiras e vem junto de um sistema RPC baseado em capacidades. Ela e usada quando baixa latencia, contratos entre linguagens e intercambio binario eficiente importam."
+    }
+  }
+};
+
+export { capnproto };

package/dist/languages/cel.cjs

@@ -0,0 +1,52 @@
+'use strict';
+
+// src/languages/cel.ts
+var cel = {
+  slug: "cel",
+  publishedDate: "2018-01-01",
+  extensions: [".cel"],
+  author: "Google / CEL community",
+  website: "https://cel.dev",
+  paradigms: ["expression", "declarative", "configuration"],
+  tooling: {
+    runtimes: ["cel-go", "cel-java", "cel-cpp"],
+    ecosystems: ["Cloud Native", "Policy", "Configuration"]
+  },
+  version: "0.25.2",
+  logo: "https://www.gstatic.com/devrel-devsite/prod/v20cdb2337f656fc22df509b6d5402b3836a1b55334a8eea3301423a87970c4d5/cel/images/touchicon-180.png",
+  color: "#4285F4",
+  i18n: {
+    en: {
+      name: "Common Expression Language",
+      description: "A portable, non-Turing-complete language for fast and safe expression evaluation.",
+      longDescription: "Common Expression Language provides a compact syntax for evaluating conditions, transformations, and policy rules inside host applications. Its non-Turing-complete design keeps evaluation predictable and suitable for untrusted expressions.\n\nCEL is embedded in cloud APIs, validation systems, authorization policies, and configuration tools. A shared specification and conformance tests support compatible implementations across several host languages."
+    },
+    es: {
+      name: "Lenguaje Comun de Expresiones",
+      description: "Lenguaje portable y no Turing-completo para evaluar expresiones de forma rapida y segura.",
+      longDescription: "Common Expression Language ofrece una sintaxis compacta para evaluar condiciones, transformaciones y reglas de politica dentro de aplicaciones anfitrionas. Su diseno no Turing-completo mantiene la evaluacion predecible y apta para expresiones no confiables.\n\nCEL se integra en API de nube, sistemas de validacion, politicas de autorizacion y herramientas de configuracion. Una especificacion comun y pruebas de conformidad permiten implementaciones compatibles en varios lenguajes."
+    },
+    it: {
+      name: "Common Expression Language",
+      description: "Linguaggio portabile e non Turing-completo per valutare espressioni in modo rapido e sicuro.",
+      longDescription: "Common Expression Language offre una sintassi compatta per valutare condizioni, trasformazioni e regole di policy nelle applicazioni host. Il design non Turing-completo rende la valutazione prevedibile e adatta a espressioni non attendibili.\n\nCEL viene incorporato in API cloud, sistemi di validazione, policy di autorizzazione e strumenti di configurazione. Una specifica comune e test di conformita supportano implementazioni compatibili in diversi linguaggi."
+    },
+    fr: {
+      name: "Common Expression Language",
+      description: "Langage portable et non Turing-complet pour evaluer des expressions rapidement et surement.",
+      longDescription: "Common Expression Language fournit une syntaxe compacte pour evaluer conditions, transformations et regles de politique dans des applications hotes. Sa conception non Turing-complete rend l evaluation previsible et adaptee aux expressions non fiables.\n\nCEL est integre aux API cloud, systemes de validation, politiques d autorisation et outils de configuration. Une specification commune et des tests de conformite assurent des implementations compatibles dans plusieurs langages."
+    },
+    de: {
+      name: "Common Expression Language",
+      description: "Portable, nicht Turing-vollstandige Sprache zur schnellen und sicheren Ausdrucksauswertung.",
+      longDescription: "Common Expression Language bietet eine kompakte Syntax zur Auswertung von Bedingungen, Transformationen und Richtlinien in Host-Anwendungen. Das nicht Turing-vollstandige Design macht die Auswertung vorhersehbar und fur nicht vertrauenswurdige Ausdrucke geeignet.\n\nCEL wird in Cloud-APIs, Validierungssysteme, Autorisierungsrichtlinien und Konfigurationswerkzeuge eingebettet. Eine gemeinsame Spezifikation und Konformitatstests ermoglichen kompatible Implementierungen in mehreren Sprachen."
+    },
+    pt: {
+      name: "Common Expression Language",
+      description: "Linguagem portavel e nao Turing-completa para avaliar expressoes com rapidez e seguranca.",
+      longDescription: "Common Expression Language oferece sintaxe compacta para avaliar condicoes, transformacoes e regras de politica em aplicacoes hospedeiras. Seu design nao Turing-completo torna a avaliacao previsivel e adequada para expressoes nao confiaveis.\n\nCEL e incorporada em APIs de nuvem, sistemas de validacao, politicas de autorizacao e ferramentas de configuracao. Uma especificacao comum e testes de conformidade sustentam implementacoes compativeis em varias linguagens."
+    }
+  }
+};
+
+exports.cel = cel;

package/dist/languages/cel.d.cts

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

package/dist/languages/cel.d.ts

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

package/dist/languages/cel.js

@@ -0,0 +1,50 @@
+// src/languages/cel.ts
+var cel = {
+  slug: "cel",
+  publishedDate: "2018-01-01",
+  extensions: [".cel"],
+  author: "Google / CEL community",
+  website: "https://cel.dev",
+  paradigms: ["expression", "declarative", "configuration"],
+  tooling: {
+    runtimes: ["cel-go", "cel-java", "cel-cpp"],
+    ecosystems: ["Cloud Native", "Policy", "Configuration"]
+  },
+  version: "0.25.2",
+  logo: "https://www.gstatic.com/devrel-devsite/prod/v20cdb2337f656fc22df509b6d5402b3836a1b55334a8eea3301423a87970c4d5/cel/images/touchicon-180.png",
+  color: "#4285F4",
+  i18n: {
+    en: {
+      name: "Common Expression Language",
+      description: "A portable, non-Turing-complete language for fast and safe expression evaluation.",
+      longDescription: "Common Expression Language provides a compact syntax for evaluating conditions, transformations, and policy rules inside host applications. Its non-Turing-complete design keeps evaluation predictable and suitable for untrusted expressions.\n\nCEL is embedded in cloud APIs, validation systems, authorization policies, and configuration tools. A shared specification and conformance tests support compatible implementations across several host languages."
+    },
+    es: {
+      name: "Lenguaje Comun de Expresiones",
+      description: "Lenguaje portable y no Turing-completo para evaluar expresiones de forma rapida y segura.",
+      longDescription: "Common Expression Language ofrece una sintaxis compacta para evaluar condiciones, transformaciones y reglas de politica dentro de aplicaciones anfitrionas. Su diseno no Turing-completo mantiene la evaluacion predecible y apta para expresiones no confiables.\n\nCEL se integra en API de nube, sistemas de validacion, politicas de autorizacion y herramientas de configuracion. Una especificacion comun y pruebas de conformidad permiten implementaciones compatibles en varios lenguajes."
+    },
+    it: {
+      name: "Common Expression Language",
+      description: "Linguaggio portabile e non Turing-completo per valutare espressioni in modo rapido e sicuro.",
+      longDescription: "Common Expression Language offre una sintassi compatta per valutare condizioni, trasformazioni e regole di policy nelle applicazioni host. Il design non Turing-completo rende la valutazione prevedibile e adatta a espressioni non attendibili.\n\nCEL viene incorporato in API cloud, sistemi di validazione, policy di autorizzazione e strumenti di configurazione. Una specifica comune e test di conformita supportano implementazioni compatibili in diversi linguaggi."
+    },
+    fr: {
+      name: "Common Expression Language",
+      description: "Langage portable et non Turing-complet pour evaluer des expressions rapidement et surement.",
+      longDescription: "Common Expression Language fournit une syntaxe compacte pour evaluer conditions, transformations et regles de politique dans des applications hotes. Sa conception non Turing-complete rend l evaluation previsible et adaptee aux expressions non fiables.\n\nCEL est integre aux API cloud, systemes de validation, politiques d autorisation et outils de configuration. Une specification commune et des tests de conformite assurent des implementations compatibles dans plusieurs langages."
+    },
+    de: {
+      name: "Common Expression Language",
+      description: "Portable, nicht Turing-vollstandige Sprache zur schnellen und sicheren Ausdrucksauswertung.",
+      longDescription: "Common Expression Language bietet eine kompakte Syntax zur Auswertung von Bedingungen, Transformationen und Richtlinien in Host-Anwendungen. Das nicht Turing-vollstandige Design macht die Auswertung vorhersehbar und fur nicht vertrauenswurdige Ausdrucke geeignet.\n\nCEL wird in Cloud-APIs, Validierungssysteme, Autorisierungsrichtlinien und Konfigurationswerkzeuge eingebettet. Eine gemeinsame Spezifikation und Konformitatstests ermoglichen kompatible Implementierungen in mehreren Sprachen."
+    },
+    pt: {
+      name: "Common Expression Language",
+      description: "Linguagem portavel e nao Turing-completa para avaliar expressoes com rapidez e seguranca.",
+      longDescription: "Common Expression Language oferece sintaxe compacta para avaliar condicoes, transformacoes e regras de politica em aplicacoes hospedeiras. Seu design nao Turing-completo torna a avaliacao previsivel e adequada para expressoes nao confiaveis.\n\nCEL e incorporada em APIs de nuvem, sistemas de validacao, politicas de autorizacao e ferramentas de configuracao. Uma especificacao comum e testes de conformidade sustentam implementacoes compativeis em varias linguagens."
+    }
+  }
+};
+
+export { cel };

package/dist/languages/cql.cjs

@@ -0,0 +1,52 @@
+'use strict';
+
+// src/languages/cql.ts
+var cql = {
+  slug: "cql",
+  publishedDate: "2008-01-01",
+  extensions: [".cql"],
+  author: "Apache Cassandra project",
+  website: "https://cassandra.apache.org/doc/latest/cassandra/developing/cql/index.html",
+  paradigms: ["query", "declarative"],
+  tooling: {
+    runtimes: ["Apache Cassandra"],
+    ecosystems: ["NoSQL", "Distributed databases"]
+  },
+  version: "CQL 3",
+  logo: "https://cdn.simpleicons.org/apachecassandra/1287B1",
+  color: "#1287B1",
+  i18n: {
+    en: {
+      name: "CQL",
+      description: "A SQL-like query language for Apache Cassandra tables and keyspaces.",
+      longDescription: "Cassandra Query Language is the primary interface for defining and querying data in Apache Cassandra. It models keyspaces, tables, columns, indexes, materialized views, and statements for reading and writing partitioned data.\n\nCQL looks familiar to SQL users, but its behavior follows Cassandra storage and distribution rules. Effective CQL design focuses on partition keys, clustering columns, denormalized tables, and queries shaped around access patterns."
+    },
+    es: {
+      name: "CQL",
+      description: "Lenguaje de consultas tipo SQL para tablas y keyspaces de Apache Cassandra.",
+      longDescription: "Cassandra Query Language es la interfaz principal para definir y consultar datos en Apache Cassandra. Modela keyspaces, tablas, columnas, indices, vistas materializadas y sentencias para leer y escribir datos particionados.\n\nCQL resulta familiar para usuarios de SQL, pero su comportamiento sigue las reglas de almacenamiento y distribucion de Cassandra. Un buen diseno CQL se centra en claves de particion, columnas de ordenamiento, tablas desnormalizadas y consultas guiadas por patrones de acceso."
+    },
+    it: {
+      name: "CQL",
+      description: "Linguaggio di query simile a SQL per tabelle e keyspace Apache Cassandra.",
+      longDescription: "Cassandra Query Language e l interfaccia principale per definire e interrogare dati in Apache Cassandra. Modella keyspace, tabelle, colonne, indici, viste materializzate e istruzioni per leggere e scrivere dati partizionati.\n\nCQL risulta familiare agli utenti SQL, ma il suo comportamento segue le regole di archiviazione e distribuzione di Cassandra. Un buon design CQL si concentra su chiavi di partizione, colonne di clustering, tabelle denormalizzate e query modellate sui pattern di accesso."
+    },
+    fr: {
+      name: "CQL",
+      description: "Langage de requete proche de SQL pour tables et keyspaces Apache Cassandra.",
+      longDescription: "Cassandra Query Language est l interface principale pour definir et interroger les donnees dans Apache Cassandra. Il modelise keyspaces, tables, colonnes, index, vues materialisees et instructions pour lire et ecrire des donnees partitionnees.\n\nCQL parait familier aux utilisateurs SQL, mais son comportement suit les regles de stockage et de distribution de Cassandra. Une bonne conception CQL se concentre sur cles de partition, colonnes de clustering, tables denormalisees et requetes guidees par les acces."
+    },
+    de: {
+      name: "CQL",
+      description: "SQL-ahnliche Abfragesprache fur Apache-Cassandra-Tabellen und Keyspaces.",
+      longDescription: "Cassandra Query Language ist die wichtigste Schnittstelle zum Definieren und Abfragen von Daten in Apache Cassandra. Sie modelliert Keyspaces, Tabellen, Spalten, Indizes, materialisierte Views und Anweisungen zum Lesen und Schreiben partitionierter Daten.\n\nCQL wirkt fur SQL-Nutzer vertraut, folgt aber den Speicher- und Verteilungsregeln von Cassandra. Gutes CQL-Design konzentriert sich auf Partitionsschlussel, Clustering-Spalten, denormalisierte Tabellen und Abfragen nach Zugriffsmustern."
+    },
+    pt: {
+      name: "CQL",
+      description: "Linguagem de consulta parecida com SQL para tabelas e keyspaces Cassandra.",
+      longDescription: "Cassandra Query Language e a principal interface para definir e consultar dados no Apache Cassandra. Ela modela keyspaces, tabelas, colunas, indices, visoes materializadas e comandos para ler e gravar dados particionados.\n\nCQL parece familiar para usuarios de SQL, mas seu comportamento segue as regras de armazenamento e distribuicao do Cassandra. Bom design em CQL foca chaves de particao, colunas de clustering, tabelas desnormalizadas e consultas moldadas por padroes de acesso."
+    }
+  }
+};
+
+exports.cql = cql;

package/dist/languages/cql.d.cts

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