code-languages 1.26.0 → 1.27.0

package/dist/languages/ballerina.cjs

@@ -0,0 +1,55 @@
+'use strict';
+
+// src/languages/ballerina.ts
+var ballerina = {
+  slug: "ballerina",
+  publishedDate: "2017-02-01",
+  extensions: [".bal"],
+  author: "WSO2",
+  website: "https://ballerina.io",
+  paradigms: ["concurrent", "functional", "imperative", "object-oriented"],
+  tooling: {
+    runtimes: ["Ballerina runtime (JVM-based)"],
+    packageManagers: ["Ballerina Central"],
+    ecosystems: ["Cloud", "Microservices", "Integration", "APIs"]
+  },
+  version: "2201.12.0",
+  logo: "https://ballerina.io/images/ballerina-logo.svg",
+  color: "#20B6B0",
+  i18n: {
+    en: {
+      name: "Ballerina",
+      description: "A cloud-native programming language designed for writing network services and APIs with built-in concurrency and type safety.",
+      longDescription: "Ballerina is a statically typed, compiled language created by WSO2 specifically for cloud-native integration and network programming. It has built-in abstractions for network services, HTTP, GraphQL, gRPC, WebSockets, and data formats like JSON and XML, making service-to-service communication a first-class concern.\n\nBallerina features a sequence diagram-based visualization of code, explicit error handling, transactional support, and a strong type system with union types and structural typing. It compiles to native code via GraalVM or runs on the JVM, and its package ecosystem is hosted on Ballerina Central."
+    },
+    es: {
+      name: "Ballerina",
+      description: "Un lenguaje de programaci\xF3n nativo de la nube dise\xF1ado para escribir servicios de red y APIs con concurrencia y seguridad de tipos integradas.",
+      longDescription: "Ballerina es un lenguaje compilado de tipo est\xE1tico creado por WSO2 espec\xEDficamente para integraci\xF3n nativa de la nube y programaci\xF3n de redes. Tiene abstracciones integradas para servicios de red, HTTP, GraphQL, gRPC, WebSockets y formatos de datos como JSON y XML.\n\nBallerina presenta una visualizaci\xF3n del c\xF3digo basada en diagramas de secuencia, manejo expl\xEDcito de errores, soporte transaccional y un sistema de tipos fuerte con tipos uni\xF3n y tipado estructural. Compila a c\xF3digo nativo via GraalVM o se ejecuta en la JVM."
+    },
+    it: {
+      name: "Ballerina",
+      description: "Un linguaggio di programmazione cloud-native progettato per scrivere servizi di rete e API con concorrenza e sicurezza dei tipi integrate.",
+      longDescription: "Ballerina \xE8 un linguaggio compilato staticamente tipizzato creato da WSO2 specificamente per l'integrazione cloud-native e la programmazione di rete. Ha astrazioni integrate per servizi di rete, HTTP, GraphQL, gRPC, WebSocket e formati di dati come JSON e XML.\n\nBallerina presenta una visualizzazione del codice basata su diagrammi di sequenza, gestione esplicita degli errori, supporto transazionale e un sistema di tipi forte con tipi unione e tipizzazione strutturale. Compila in codice nativo tramite GraalVM o viene eseguito sulla JVM."
+    },
+    fr: {
+      name: "Ballerina",
+      description: "Un langage de programmation cloud-native con\xE7u pour \xE9crire des services r\xE9seau et des APIs avec concurrence et s\xE9curit\xE9 des types int\xE9gr\xE9es.",
+      longDescription: "Ballerina est un langage compil\xE9 statiquement typ\xE9 cr\xE9\xE9 par WSO2 sp\xE9cifiquement pour l'int\xE9gration cloud-native et la programmation r\xE9seau. Il dispose d'abstractions int\xE9gr\xE9es pour les services r\xE9seau, HTTP, GraphQL, gRPC, WebSockets et les formats de donn\xE9es comme JSON et XML.\n\nBallerina pr\xE9sente une visualisation du code bas\xE9e sur des diagrammes de s\xE9quence, une gestion explicite des erreurs, un support transactionnel et un syst\xE8me de types fort avec des types union et un typage structurel. Il se compile en code natif via GraalVM ou s'ex\xE9cute sur la JVM."
+    },
+    de: {
+      name: "Ballerina",
+      description: "Eine Cloud-native Programmiersprache f\xFCr Netzwerkdienste und APIs mit eingebauter Nebenl\xE4ufigkeit und Typsicherheit.",
+      longDescription: "Ballerina ist eine statisch typisierte, kompilierte Sprache, die von WSO2 speziell f\xFCr Cloud-native Integration und Netzwerkprogrammierung entwickelt wurde. Sie hat eingebaute Abstraktionen f\xFCr Netzwerkdienste, HTTP, GraphQL, gRPC, WebSockets und Datenformate wie JSON und XML.\n\nBallerina bietet eine sequenzdiagrammbasierte Visualisierung des Codes, explizites Fehlerhandling, transaktionale Unterst\xFCtzung und ein starkes Typsystem mit Union-Types und struktureller Typisierung. Es kompiliert zu nativem Code via GraalVM oder l\xE4uft auf der JVM."
+    },
+    pt: {
+      name: "Ballerina",
+      description: "Uma linguagem de programa\xE7\xE3o cloud-native projetada para escrever servi\xE7os de rede e APIs com concorr\xEAncia e seguran\xE7a de tipos integradas.",
+      longDescription: "Ballerina \xE9 uma linguagem compilada estaticamente tipada criada pela WSO2 especificamente para integra\xE7\xE3o cloud-native e programa\xE7\xE3o de rede. Possui abstra\xE7\xF5es integradas para servi\xE7os de rede, HTTP, GraphQL, gRPC, WebSockets e formatos de dados como JSON e XML.\n\nBallerina apresenta uma visualiza\xE7\xE3o do c\xF3digo baseada em diagramas de sequ\xEAncia, tratamento expl\xEDcito de erros, suporte transacional e um sistema de tipos forte com tipos union e tipagem estrutural. Compila para c\xF3digo nativo via GraalVM ou executa na JVM."
+    }
+  }
+};
+
+exports.ballerina = ballerina;
+//# sourceMappingURL=ballerina.cjs.map
+//# sourceMappingURL=ballerina.cjs.map

package/dist/languages/ballerina.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/languages/ballerina.ts"],"names":[],"mappings":";;;AAEO,IAAM,SAAA,GAAY;AAAA,EACvB,IAAA,EAAM,WAAA;AAAA,EACN,aAAA,EAAe,YAAA;AAAA,EACf,UAAA,EAAY,CAAC,MAAM,CAAA;AAAA,EACnB,MAAA,EAAQ,MAAA;AAAA,EACR,OAAA,EAAS,sBAAA;AAAA,EACT,SAAA,EAAW,CAAC,YAAA,EAAc,YAAA,EAAc,cAAc,iBAAiB,CAAA;AAAA,EACvE,OAAA,EAAS;AAAA,IACP,QAAA,EAAU,CAAC,+BAA+B,CAAA;AAAA,IAC1C,eAAA,EAAiB,CAAC,mBAAmB,CAAA;AAAA,IACrC,UAAA,EAAY,CAAC,OAAA,EAAS,eAAA,EAAiB,eAAe,MAAM;AAAA,GAC9D;AAAA,EACA,OAAA,EAAS,WAAA;AAAA,EACT,IAAA,EAAM,gDAAA;AAAA,EACN,KAAA,EAAO,SAAA;AAAA,EACP,IAAA,EAAM;AAAA,IACJ,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,WAAA;AAAA,MACN,WAAA,EACE,+HAAA;AAAA,MACF,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,WAAA;AAAA,MACN,WAAA,EACE,sJAAA;AAAA,MACF,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,WAAA;AAAA,MACN,WAAA,EACE,4IAAA;AAAA,MACF,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,WAAA;AAAA,MACN,WAAA,EACE,mKAAA;AAAA,MACF,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,WAAA;AAAA,MACN,WAAA,EACE,4HAAA;AAAA,MACF,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,WAAA;AAAA,MACN,WAAA,EACE,4JAAA;AAAA,MACF,eAAA,EACE;AAAA;AACJ;AAEJ","file":"ballerina.cjs","sourcesContent":["import type { Language } from \"../types\";\n\nexport const ballerina = {\n  slug: \"ballerina\",\n  publishedDate: \"2017-02-01\",\n  extensions: [\".bal\"],\n  author: \"WSO2\",\n  website: \"https://ballerina.io\",\n  paradigms: [\"concurrent\", \"functional\", \"imperative\", \"object-oriented\"],\n  tooling: {\n    runtimes: [\"Ballerina runtime (JVM-based)\"],\n    packageManagers: [\"Ballerina Central\"],\n    ecosystems: [\"Cloud\", \"Microservices\", \"Integration\", \"APIs\"],\n  },\n  version: \"2201.12.0\",\n  logo: \"https://ballerina.io/images/ballerina-logo.svg\",\n  color: \"#20B6B0\",\n  i18n: {\n    en: {\n      name: \"Ballerina\",\n      description:\n        \"A cloud-native programming language designed for writing network services and APIs with built-in concurrency and type safety.\",\n      longDescription:\n        \"Ballerina is a statically typed, compiled language created by WSO2 specifically for cloud-native integration and network programming. It has built-in abstractions for network services, HTTP, GraphQL, gRPC, WebSockets, and data formats like JSON and XML, making service-to-service communication a first-class concern.\\n\\nBallerina features a sequence diagram-based visualization of code, explicit error handling, transactional support, and a strong type system with union types and structural typing. It compiles to native code via GraalVM or runs on the JVM, and its package ecosystem is hosted on Ballerina Central.\",\n    },\n    es: {\n      name: \"Ballerina\",\n      description:\n        \"Un lenguaje de programación nativo de la nube diseñado para escribir servicios de red y APIs con concurrencia y seguridad de tipos integradas.\",\n      longDescription:\n        \"Ballerina es un lenguaje compilado de tipo estático creado por WSO2 específicamente para integración nativa de la nube y programación de redes. Tiene abstracciones integradas para servicios de red, HTTP, GraphQL, gRPC, WebSockets y formatos de datos como JSON y XML.\\n\\nBallerina presenta una visualización del código basada en diagramas de secuencia, manejo explícito de errores, soporte transaccional y un sistema de tipos fuerte con tipos unión y tipado estructural. Compila a código nativo via GraalVM o se ejecuta en la JVM.\",\n    },\n    it: {\n      name: \"Ballerina\",\n      description:\n        \"Un linguaggio di programmazione cloud-native progettato per scrivere servizi di rete e API con concorrenza e sicurezza dei tipi integrate.\",\n      longDescription:\n        \"Ballerina è un linguaggio compilato staticamente tipizzato creato da WSO2 specificamente per l'integrazione cloud-native e la programmazione di rete. Ha astrazioni integrate per servizi di rete, HTTP, GraphQL, gRPC, WebSocket e formati di dati come JSON e XML.\\n\\nBallerina presenta una visualizzazione del codice basata su diagrammi di sequenza, gestione esplicita degli errori, supporto transazionale e un sistema di tipi forte con tipi unione e tipizzazione strutturale. Compila in codice nativo tramite GraalVM o viene eseguito sulla JVM.\",\n    },\n    fr: {\n      name: \"Ballerina\",\n      description:\n        \"Un langage de programmation cloud-native conçu pour écrire des services réseau et des APIs avec concurrence et sécurité des types intégrées.\",\n      longDescription:\n        \"Ballerina est un langage compilé statiquement typé créé par WSO2 spécifiquement pour l'intégration cloud-native et la programmation réseau. Il dispose d'abstractions intégrées pour les services réseau, HTTP, GraphQL, gRPC, WebSockets et les formats de données comme JSON et XML.\\n\\nBallerina présente une visualisation du code basée sur des diagrammes de séquence, une gestion explicite des erreurs, un support transactionnel et un système de types fort avec des types union et un typage structurel. Il se compile en code natif via GraalVM ou s'exécute sur la JVM.\",\n    },\n    de: {\n      name: \"Ballerina\",\n      description:\n        \"Eine Cloud-native Programmiersprache für Netzwerkdienste und APIs mit eingebauter Nebenläufigkeit und Typsicherheit.\",\n      longDescription:\n        \"Ballerina ist eine statisch typisierte, kompilierte Sprache, die von WSO2 speziell für Cloud-native Integration und Netzwerkprogrammierung entwickelt wurde. Sie hat eingebaute Abstraktionen für Netzwerkdienste, HTTP, GraphQL, gRPC, WebSockets und Datenformate wie JSON und XML.\\n\\nBallerina bietet eine sequenzdiagrammbasierte Visualisierung des Codes, explizites Fehlerhandling, transaktionale Unterstützung und ein starkes Typsystem mit Union-Types und struktureller Typisierung. Es kompiliert zu nativem Code via GraalVM oder läuft auf der JVM.\",\n    },\n    pt: {\n      name: \"Ballerina\",\n      description:\n        \"Uma linguagem de programação cloud-native projetada para escrever serviços de rede e APIs com concorrência e segurança de tipos integradas.\",\n      longDescription:\n        \"Ballerina é uma linguagem compilada estaticamente tipada criada pela WSO2 especificamente para integração cloud-native e programação de rede. Possui abstrações integradas para serviços de rede, HTTP, GraphQL, gRPC, WebSockets e formatos de dados como JSON e XML.\\n\\nBallerina apresenta uma visualização do código baseada em diagramas de sequência, tratamento explícito de erros, suporte transacional e um sistema de tipos forte com tipos union e tipagem estrutural. Compila para código nativo via GraalVM ou executa na JVM.\",\n    },\n  },\n} satisfies Language;\n"]}

package/dist/languages/ballerina.d.cts

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

package/dist/languages/ballerina.d.ts

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

package/dist/languages/ballerina.js

@@ -0,0 +1,53 @@
+// src/languages/ballerina.ts
+var ballerina = {
+  slug: "ballerina",
+  publishedDate: "2017-02-01",
+  extensions: [".bal"],
+  author: "WSO2",
+  website: "https://ballerina.io",
+  paradigms: ["concurrent", "functional", "imperative", "object-oriented"],
+  tooling: {
+    runtimes: ["Ballerina runtime (JVM-based)"],
+    packageManagers: ["Ballerina Central"],
+    ecosystems: ["Cloud", "Microservices", "Integration", "APIs"]
+  },
+  version: "2201.12.0",
+  logo: "https://ballerina.io/images/ballerina-logo.svg",
+  color: "#20B6B0",
+  i18n: {
+    en: {
+      name: "Ballerina",
+      description: "A cloud-native programming language designed for writing network services and APIs with built-in concurrency and type safety.",
+      longDescription: "Ballerina is a statically typed, compiled language created by WSO2 specifically for cloud-native integration and network programming. It has built-in abstractions for network services, HTTP, GraphQL, gRPC, WebSockets, and data formats like JSON and XML, making service-to-service communication a first-class concern.\n\nBallerina features a sequence diagram-based visualization of code, explicit error handling, transactional support, and a strong type system with union types and structural typing. It compiles to native code via GraalVM or runs on the JVM, and its package ecosystem is hosted on Ballerina Central."
+    },
+    es: {
+      name: "Ballerina",
+      description: "Un lenguaje de programaci\xF3n nativo de la nube dise\xF1ado para escribir servicios de red y APIs con concurrencia y seguridad de tipos integradas.",
+      longDescription: "Ballerina es un lenguaje compilado de tipo est\xE1tico creado por WSO2 espec\xEDficamente para integraci\xF3n nativa de la nube y programaci\xF3n de redes. Tiene abstracciones integradas para servicios de red, HTTP, GraphQL, gRPC, WebSockets y formatos de datos como JSON y XML.\n\nBallerina presenta una visualizaci\xF3n del c\xF3digo basada en diagramas de secuencia, manejo expl\xEDcito de errores, soporte transaccional y un sistema de tipos fuerte con tipos uni\xF3n y tipado estructural. Compila a c\xF3digo nativo via GraalVM o se ejecuta en la JVM."
+    },
+    it: {
+      name: "Ballerina",
+      description: "Un linguaggio di programmazione cloud-native progettato per scrivere servizi di rete e API con concorrenza e sicurezza dei tipi integrate.",
+      longDescription: "Ballerina \xE8 un linguaggio compilato staticamente tipizzato creato da WSO2 specificamente per l'integrazione cloud-native e la programmazione di rete. Ha astrazioni integrate per servizi di rete, HTTP, GraphQL, gRPC, WebSocket e formati di dati come JSON e XML.\n\nBallerina presenta una visualizzazione del codice basata su diagrammi di sequenza, gestione esplicita degli errori, supporto transazionale e un sistema di tipi forte con tipi unione e tipizzazione strutturale. Compila in codice nativo tramite GraalVM o viene eseguito sulla JVM."
+    },
+    fr: {
+      name: "Ballerina",
+      description: "Un langage de programmation cloud-native con\xE7u pour \xE9crire des services r\xE9seau et des APIs avec concurrence et s\xE9curit\xE9 des types int\xE9gr\xE9es.",
+      longDescription: "Ballerina est un langage compil\xE9 statiquement typ\xE9 cr\xE9\xE9 par WSO2 sp\xE9cifiquement pour l'int\xE9gration cloud-native et la programmation r\xE9seau. Il dispose d'abstractions int\xE9gr\xE9es pour les services r\xE9seau, HTTP, GraphQL, gRPC, WebSockets et les formats de donn\xE9es comme JSON et XML.\n\nBallerina pr\xE9sente une visualisation du code bas\xE9e sur des diagrammes de s\xE9quence, une gestion explicite des erreurs, un support transactionnel et un syst\xE8me de types fort avec des types union et un typage structurel. Il se compile en code natif via GraalVM ou s'ex\xE9cute sur la JVM."
+    },
+    de: {
+      name: "Ballerina",
+      description: "Eine Cloud-native Programmiersprache f\xFCr Netzwerkdienste und APIs mit eingebauter Nebenl\xE4ufigkeit und Typsicherheit.",
+      longDescription: "Ballerina ist eine statisch typisierte, kompilierte Sprache, die von WSO2 speziell f\xFCr Cloud-native Integration und Netzwerkprogrammierung entwickelt wurde. Sie hat eingebaute Abstraktionen f\xFCr Netzwerkdienste, HTTP, GraphQL, gRPC, WebSockets und Datenformate wie JSON und XML.\n\nBallerina bietet eine sequenzdiagrammbasierte Visualisierung des Codes, explizites Fehlerhandling, transaktionale Unterst\xFCtzung und ein starkes Typsystem mit Union-Types und struktureller Typisierung. Es kompiliert zu nativem Code via GraalVM oder l\xE4uft auf der JVM."
+    },
+    pt: {
+      name: "Ballerina",
+      description: "Uma linguagem de programa\xE7\xE3o cloud-native projetada para escrever servi\xE7os de rede e APIs com concorr\xEAncia e seguran\xE7a de tipos integradas.",
+      longDescription: "Ballerina \xE9 uma linguagem compilada estaticamente tipada criada pela WSO2 especificamente para integra\xE7\xE3o cloud-native e programa\xE7\xE3o de rede. Possui abstra\xE7\xF5es integradas para servi\xE7os de rede, HTTP, GraphQL, gRPC, WebSockets e formatos de dados como JSON e XML.\n\nBallerina apresenta uma visualiza\xE7\xE3o do c\xF3digo baseada em diagramas de sequ\xEAncia, tratamento expl\xEDcito de erros, suporte transacional e um sistema de tipos forte com tipos union e tipagem estrutural. Compila para c\xF3digo nativo via GraalVM ou executa na JVM."
+    }
+  }
+};
+
+export { ballerina };
+//# sourceMappingURL=ballerina.js.map
+//# sourceMappingURL=ballerina.js.map

package/dist/languages/ballerina.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/languages/ballerina.ts"],"names":[],"mappings":";AAEO,IAAM,SAAA,GAAY;AAAA,EACvB,IAAA,EAAM,WAAA;AAAA,EACN,aAAA,EAAe,YAAA;AAAA,EACf,UAAA,EAAY,CAAC,MAAM,CAAA;AAAA,EACnB,MAAA,EAAQ,MAAA;AAAA,EACR,OAAA,EAAS,sBAAA;AAAA,EACT,SAAA,EAAW,CAAC,YAAA,EAAc,YAAA,EAAc,cAAc,iBAAiB,CAAA;AAAA,EACvE,OAAA,EAAS;AAAA,IACP,QAAA,EAAU,CAAC,+BAA+B,CAAA;AAAA,IAC1C,eAAA,EAAiB,CAAC,mBAAmB,CAAA;AAAA,IACrC,UAAA,EAAY,CAAC,OAAA,EAAS,eAAA,EAAiB,eAAe,MAAM;AAAA,GAC9D;AAAA,EACA,OAAA,EAAS,WAAA;AAAA,EACT,IAAA,EAAM,gDAAA;AAAA,EACN,KAAA,EAAO,SAAA;AAAA,EACP,IAAA,EAAM;AAAA,IACJ,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,WAAA;AAAA,MACN,WAAA,EACE,+HAAA;AAAA,MACF,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,WAAA;AAAA,MACN,WAAA,EACE,sJAAA;AAAA,MACF,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,WAAA;AAAA,MACN,WAAA,EACE,4IAAA;AAAA,MACF,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,WAAA;AAAA,MACN,WAAA,EACE,mKAAA;AAAA,MACF,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,WAAA;AAAA,MACN,WAAA,EACE,4HAAA;AAAA,MACF,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,WAAA;AAAA,MACN,WAAA,EACE,4JAAA;AAAA,MACF,eAAA,EACE;AAAA;AACJ;AAEJ","file":"ballerina.js","sourcesContent":["import type { Language } from \"../types\";\n\nexport const ballerina = {\n  slug: \"ballerina\",\n  publishedDate: \"2017-02-01\",\n  extensions: [\".bal\"],\n  author: \"WSO2\",\n  website: \"https://ballerina.io\",\n  paradigms: [\"concurrent\", \"functional\", \"imperative\", \"object-oriented\"],\n  tooling: {\n    runtimes: [\"Ballerina runtime (JVM-based)\"],\n    packageManagers: [\"Ballerina Central\"],\n    ecosystems: [\"Cloud\", \"Microservices\", \"Integration\", \"APIs\"],\n  },\n  version: \"2201.12.0\",\n  logo: \"https://ballerina.io/images/ballerina-logo.svg\",\n  color: \"#20B6B0\",\n  i18n: {\n    en: {\n      name: \"Ballerina\",\n      description:\n        \"A cloud-native programming language designed for writing network services and APIs with built-in concurrency and type safety.\",\n      longDescription:\n        \"Ballerina is a statically typed, compiled language created by WSO2 specifically for cloud-native integration and network programming. It has built-in abstractions for network services, HTTP, GraphQL, gRPC, WebSockets, and data formats like JSON and XML, making service-to-service communication a first-class concern.\\n\\nBallerina features a sequence diagram-based visualization of code, explicit error handling, transactional support, and a strong type system with union types and structural typing. It compiles to native code via GraalVM or runs on the JVM, and its package ecosystem is hosted on Ballerina Central.\",\n    },\n    es: {\n      name: \"Ballerina\",\n      description:\n        \"Un lenguaje de programación nativo de la nube diseñado para escribir servicios de red y APIs con concurrencia y seguridad de tipos integradas.\",\n      longDescription:\n        \"Ballerina es un lenguaje compilado de tipo estático creado por WSO2 específicamente para integración nativa de la nube y programación de redes. Tiene abstracciones integradas para servicios de red, HTTP, GraphQL, gRPC, WebSockets y formatos de datos como JSON y XML.\\n\\nBallerina presenta una visualización del código basada en diagramas de secuencia, manejo explícito de errores, soporte transaccional y un sistema de tipos fuerte con tipos unión y tipado estructural. Compila a código nativo via GraalVM o se ejecuta en la JVM.\",\n    },\n    it: {\n      name: \"Ballerina\",\n      description:\n        \"Un linguaggio di programmazione cloud-native progettato per scrivere servizi di rete e API con concorrenza e sicurezza dei tipi integrate.\",\n      longDescription:\n        \"Ballerina è un linguaggio compilato staticamente tipizzato creato da WSO2 specificamente per l'integrazione cloud-native e la programmazione di rete. Ha astrazioni integrate per servizi di rete, HTTP, GraphQL, gRPC, WebSocket e formati di dati come JSON e XML.\\n\\nBallerina presenta una visualizzazione del codice basata su diagrammi di sequenza, gestione esplicita degli errori, supporto transazionale e un sistema di tipi forte con tipi unione e tipizzazione strutturale. Compila in codice nativo tramite GraalVM o viene eseguito sulla JVM.\",\n    },\n    fr: {\n      name: \"Ballerina\",\n      description:\n        \"Un langage de programmation cloud-native conçu pour écrire des services réseau et des APIs avec concurrence et sécurité des types intégrées.\",\n      longDescription:\n        \"Ballerina est un langage compilé statiquement typé créé par WSO2 spécifiquement pour l'intégration cloud-native et la programmation réseau. Il dispose d'abstractions intégrées pour les services réseau, HTTP, GraphQL, gRPC, WebSockets et les formats de données comme JSON et XML.\\n\\nBallerina présente une visualisation du code basée sur des diagrammes de séquence, une gestion explicite des erreurs, un support transactionnel et un système de types fort avec des types union et un typage structurel. Il se compile en code natif via GraalVM ou s'exécute sur la JVM.\",\n    },\n    de: {\n      name: \"Ballerina\",\n      description:\n        \"Eine Cloud-native Programmiersprache für Netzwerkdienste und APIs mit eingebauter Nebenläufigkeit und Typsicherheit.\",\n      longDescription:\n        \"Ballerina ist eine statisch typisierte, kompilierte Sprache, die von WSO2 speziell für Cloud-native Integration und Netzwerkprogrammierung entwickelt wurde. Sie hat eingebaute Abstraktionen für Netzwerkdienste, HTTP, GraphQL, gRPC, WebSockets und Datenformate wie JSON und XML.\\n\\nBallerina bietet eine sequenzdiagrammbasierte Visualisierung des Codes, explizites Fehlerhandling, transaktionale Unterstützung und ein starkes Typsystem mit Union-Types und struktureller Typisierung. Es kompiliert zu nativem Code via GraalVM oder läuft auf der JVM.\",\n    },\n    pt: {\n      name: \"Ballerina\",\n      description:\n        \"Uma linguagem de programação cloud-native projetada para escrever serviços de rede e APIs com concorrência e segurança de tipos integradas.\",\n      longDescription:\n        \"Ballerina é uma linguagem compilada estaticamente tipada criada pela WSO2 especificamente para integração cloud-native e programação de rede. Possui abstrações integradas para serviços de rede, HTTP, GraphQL, gRPC, WebSockets e formatos de dados como JSON e XML.\\n\\nBallerina apresenta uma visualização do código baseada em diagramas de sequência, tratamento explícito de erros, suporte transacional e um sistema de tipos forte com tipos union e tipagem estrutural. Compila para código nativo via GraalVM ou executa na JVM.\",\n    },\n  },\n} satisfies Language;\n"]}

package/dist/languages/cypher.cjs

@@ -0,0 +1,54 @@
+'use strict';
+
+// src/languages/cypher.ts
+var cypher = {
+  slug: "cypher",
+  publishedDate: "2011-02-01",
+  extensions: [".cypher", ".cyp"],
+  author: "Neo Technology (Neo4j)",
+  website: "https://neo4j.com/docs/cypher-manual/current/",
+  paradigms: ["declarative", "query"],
+  tooling: {
+    runtimes: ["Neo4j", "Amazon Neptune", "Memgraph", "RedisGraph"],
+    ecosystems: ["Graph Databases", "Data"]
+  },
+  version: "25",
+  logo: "https://dist.neo4j.com/wp-content/uploads/20210423072428/neo4j-logo-2020-1.svg",
+  color: "#018BFF",
+  i18n: {
+    en: {
+      name: "Cypher",
+      description: "A declarative graph query language for Neo4j and other graph databases, designed to express graph patterns naturally.",
+      longDescription: "Cypher is a declarative query language designed specifically for querying and updating property graphs. Its ASCII-art syntax uses parentheses for nodes and arrows for relationships, making graph patterns intuitive to read and write.\n\nOriginally developed by Neo4j, Cypher has been standardized as openCypher and is supported by multiple graph database engines including Amazon Neptune and Memgraph. It is used for social networks, recommendation engines, fraud detection, and knowledge graphs."
+    },
+    es: {
+      name: "Cypher",
+      description: "Un lenguaje declarativo de consulta de grafos para Neo4j y otras bases de datos de grafos, dise\xF1ado para expresar patrones de grafos de forma natural.",
+      longDescription: "Cypher es un lenguaje de consulta declarativo dise\xF1ado para consultar y actualizar grafos de propiedades. Su sintaxis de arte ASCII usa par\xE9ntesis para nodos y flechas para relaciones, haciendo los patrones de grafo intuitivos de leer y escribir.\n\nOriginalmente desarrollado por Neo4j, Cypher ha sido estandarizado como openCypher y es compatible con m\xFAltiples motores de bases de datos de grafos. Se usa en redes sociales, motores de recomendaci\xF3n, detecci\xF3n de fraude y grafos de conocimiento."
+    },
+    it: {
+      name: "Cypher",
+      description: "Un linguaggio di interrogazione di grafi dichiarativo per Neo4j e altri database a grafo, progettato per esprimere pattern di grafi in modo naturale.",
+      longDescription: "Cypher \xE8 un linguaggio di interrogazione dichiarativo progettato per interrogare e aggiornare grafi di propriet\xE0. La sua sintassi ASCII art usa parentesi per i nodi e frecce per le relazioni, rendendo i pattern di grafo intuitivi da leggere e scrivere.\n\nOriginariamente sviluppato da Neo4j, Cypher \xE8 stato standardizzato come openCypher ed \xE8 supportato da pi\xF9 motori di database a grafo. \xC8 utilizzato per reti sociali, motori di raccomandazione, rilevamento frodi e grafi della conoscenza."
+    },
+    fr: {
+      name: "Cypher",
+      description: "Un langage de requ\xEAte de graphes d\xE9claratif pour Neo4j et d'autres bases de donn\xE9es de graphes, con\xE7u pour exprimer des motifs de graphes naturellement.",
+      longDescription: "Cypher est un langage de requ\xEAte d\xE9claratif con\xE7u pour interroger et mettre \xE0 jour des graphes de propri\xE9t\xE9s. Sa syntaxe art ASCII utilise des parenth\xE8ses pour les n\u0153uds et des fl\xE8ches pour les relations, rendant les motifs de graphes intuitifs \xE0 lire et \xE0 \xE9crire.\n\nD\xE9velopp\xE9 initialement par Neo4j, Cypher a \xE9t\xE9 standardis\xE9 en tant qu'openCypher et est support\xE9 par plusieurs moteurs de bases de donn\xE9es de graphes. Il est utilis\xE9 pour les r\xE9seaux sociaux, les moteurs de recommandation, la d\xE9tection de fraude et les graphes de connaissances."
+    },
+    de: {
+      name: "Cypher",
+      description: "Eine deklarative Graphabfragesprache f\xFCr Neo4j und andere Graphdatenbanken, die Graphmuster nat\xFCrlich ausdr\xFCckt.",
+      longDescription: "Cypher ist eine deklarative Abfragesprache, die speziell f\xFCr die Abfrage und Aktualisierung von Eigenschaftsgraphen entwickelt wurde. Ihre ASCII-Art-Syntax verwendet Klammern f\xFCr Knoten und Pfeile f\xFCr Beziehungen, was Graphmuster intuitiv lesbar und schreibbar macht.\n\nUrspr\xFCnglich von Neo4j entwickelt, wurde Cypher als openCypher standardisiert und wird von mehreren Graphdatenbank-Engines unterst\xFCtzt. Es wird f\xFCr soziale Netzwerke, Empfehlungssysteme, Betrugserkennung und Wissensgraphen eingesetzt."
+    },
+    pt: {
+      name: "Cypher",
+      description: "Uma linguagem declarativa de consulta de grafos para Neo4j e outros bancos de dados de grafos, projetada para expressar padr\xF5es de grafos de forma natural.",
+      longDescription: "Cypher \xE9 uma linguagem de consulta declarativa projetada para consultar e atualizar grafos de propriedades. Sua sintaxe de arte ASCII usa par\xEAnteses para n\xF3s e setas para relacionamentos, tornando os padr\xF5es de grafo intuitivos de ler e escrever.\n\nOriginalmente desenvolvido pela Neo4j, o Cypher foi padronizado como openCypher e \xE9 suportado por m\xFAltiplos motores de bancos de dados de grafos. \xC9 usado em redes sociais, motores de recomenda\xE7\xE3o, detec\xE7\xE3o de fraude e grafos de conhecimento."
+    }
+  }
+};
+
+exports.cypher = cypher;
+//# sourceMappingURL=cypher.cjs.map
+//# sourceMappingURL=cypher.cjs.map

package/dist/languages/cypher.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/languages/cypher.ts"],"names":[],"mappings":";;;AAEO,IAAM,MAAA,GAAS;AAAA,EACpB,IAAA,EAAM,QAAA;AAAA,EACN,aAAA,EAAe,YAAA;AAAA,EACf,UAAA,EAAY,CAAC,SAAA,EAAW,MAAM,CAAA;AAAA,EAC9B,MAAA,EAAQ,wBAAA;AAAA,EACR,OAAA,EAAS,+CAAA;AAAA,EACT,SAAA,EAAW,CAAC,aAAA,EAAe,OAAO,CAAA;AAAA,EAClC,OAAA,EAAS;AAAA,IACP,QAAA,EAAU,CAAC,OAAA,EAAS,gBAAA,EAAkB,YAAY,YAAY,CAAA;AAAA,IAC9D,UAAA,EAAY,CAAC,iBAAA,EAAmB,MAAM;AAAA,GACxC;AAAA,EACA,OAAA,EAAS,IAAA;AAAA,EACT,IAAA,EAAM,gFAAA;AAAA,EACN,KAAA,EAAO,SAAA;AAAA,EACP,IAAA,EAAM;AAAA,IACJ,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,QAAA;AAAA,MACN,WAAA,EACE,uHAAA;AAAA,MACF,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,QAAA;AAAA,MACN,WAAA,EACE,2JAAA;AAAA,MACF,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,QAAA;AAAA,MACN,WAAA,EACE,uJAAA;AAAA,MACF,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,QAAA;AAAA,MACN,WAAA,EACE,sKAAA;AAAA,MACF,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,QAAA;AAAA,MACN,WAAA,EACE,2HAAA;AAAA,MACF,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,QAAA;AAAA,MACN,WAAA,EACE,gKAAA;AAAA,MACF,eAAA,EACE;AAAA;AACJ;AAEJ","file":"cypher.cjs","sourcesContent":["import type { Language } from \"../types\";\n\nexport const cypher = {\n  slug: \"cypher\",\n  publishedDate: \"2011-02-01\",\n  extensions: [\".cypher\", \".cyp\"],\n  author: \"Neo Technology (Neo4j)\",\n  website: \"https://neo4j.com/docs/cypher-manual/current/\",\n  paradigms: [\"declarative\", \"query\"],\n  tooling: {\n    runtimes: [\"Neo4j\", \"Amazon Neptune\", \"Memgraph\", \"RedisGraph\"],\n    ecosystems: [\"Graph Databases\", \"Data\"],\n  },\n  version: \"25\",\n  logo: \"https://dist.neo4j.com/wp-content/uploads/20210423072428/neo4j-logo-2020-1.svg\",\n  color: \"#018BFF\",\n  i18n: {\n    en: {\n      name: \"Cypher\",\n      description:\n        \"A declarative graph query language for Neo4j and other graph databases, designed to express graph patterns naturally.\",\n      longDescription:\n        \"Cypher is a declarative query language designed specifically for querying and updating property graphs. Its ASCII-art syntax uses parentheses for nodes and arrows for relationships, making graph patterns intuitive to read and write.\\n\\nOriginally developed by Neo4j, Cypher has been standardized as openCypher and is supported by multiple graph database engines including Amazon Neptune and Memgraph. It is used for social networks, recommendation engines, fraud detection, and knowledge graphs.\",\n    },\n    es: {\n      name: \"Cypher\",\n      description:\n        \"Un lenguaje declarativo de consulta de grafos para Neo4j y otras bases de datos de grafos, diseñado para expresar patrones de grafos de forma natural.\",\n      longDescription:\n        \"Cypher es un lenguaje de consulta declarativo diseñado para consultar y actualizar grafos de propiedades. Su sintaxis de arte ASCII usa paréntesis para nodos y flechas para relaciones, haciendo los patrones de grafo intuitivos de leer y escribir.\\n\\nOriginalmente desarrollado por Neo4j, Cypher ha sido estandarizado como openCypher y es compatible con múltiples motores de bases de datos de grafos. Se usa en redes sociales, motores de recomendación, detección de fraude y grafos de conocimiento.\",\n    },\n    it: {\n      name: \"Cypher\",\n      description:\n        \"Un linguaggio di interrogazione di grafi dichiarativo per Neo4j e altri database a grafo, progettato per esprimere pattern di grafi in modo naturale.\",\n      longDescription:\n        \"Cypher è un linguaggio di interrogazione dichiarativo progettato per interrogare e aggiornare grafi di proprietà. La sua sintassi ASCII art usa parentesi per i nodi e frecce per le relazioni, rendendo i pattern di grafo intuitivi da leggere e scrivere.\\n\\nOriginariamente sviluppato da Neo4j, Cypher è stato standardizzato come openCypher ed è supportato da più motori di database a grafo. È utilizzato per reti sociali, motori di raccomandazione, rilevamento frodi e grafi della conoscenza.\",\n    },\n    fr: {\n      name: \"Cypher\",\n      description:\n        \"Un langage de requête de graphes déclaratif pour Neo4j et d'autres bases de données de graphes, conçu pour exprimer des motifs de graphes naturellement.\",\n      longDescription:\n        \"Cypher est un langage de requête déclaratif conçu pour interroger et mettre à jour des graphes de propriétés. Sa syntaxe art ASCII utilise des parenthèses pour les nœuds et des flèches pour les relations, rendant les motifs de graphes intuitifs à lire et à écrire.\\n\\nDéveloppé initialement par Neo4j, Cypher a été standardisé en tant qu'openCypher et est supporté par plusieurs moteurs de bases de données de graphes. Il est utilisé pour les réseaux sociaux, les moteurs de recommandation, la détection de fraude et les graphes de connaissances.\",\n    },\n    de: {\n      name: \"Cypher\",\n      description:\n        \"Eine deklarative Graphabfragesprache für Neo4j und andere Graphdatenbanken, die Graphmuster natürlich ausdrückt.\",\n      longDescription:\n        \"Cypher ist eine deklarative Abfragesprache, die speziell für die Abfrage und Aktualisierung von Eigenschaftsgraphen entwickelt wurde. Ihre ASCII-Art-Syntax verwendet Klammern für Knoten und Pfeile für Beziehungen, was Graphmuster intuitiv lesbar und schreibbar macht.\\n\\nUrsprünglich von Neo4j entwickelt, wurde Cypher als openCypher standardisiert und wird von mehreren Graphdatenbank-Engines unterstützt. Es wird für soziale Netzwerke, Empfehlungssysteme, Betrugserkennung und Wissensgraphen eingesetzt.\",\n    },\n    pt: {\n      name: \"Cypher\",\n      description:\n        \"Uma linguagem declarativa de consulta de grafos para Neo4j e outros bancos de dados de grafos, projetada para expressar padrões de grafos de forma natural.\",\n      longDescription:\n        \"Cypher é uma linguagem de consulta declarativa projetada para consultar e atualizar grafos de propriedades. Sua sintaxe de arte ASCII usa parênteses para nós e setas para relacionamentos, tornando os padrões de grafo intuitivos de ler e escrever.\\n\\nOriginalmente desenvolvido pela Neo4j, o Cypher foi padronizado como openCypher e é suportado por múltiplos motores de bancos de dados de grafos. É usado em redes sociais, motores de recomendação, detecção de fraude e grafos de conhecimento.\",\n    },\n  },\n} satisfies Language;\n"]}

package/dist/languages/cypher.d.cts

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

package/dist/languages/cypher.d.ts

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

package/dist/languages/cypher.js

@@ -0,0 +1,52 @@
+// src/languages/cypher.ts
+var cypher = {
+  slug: "cypher",
+  publishedDate: "2011-02-01",
+  extensions: [".cypher", ".cyp"],
+  author: "Neo Technology (Neo4j)",
+  website: "https://neo4j.com/docs/cypher-manual/current/",
+  paradigms: ["declarative", "query"],
+  tooling: {
+    runtimes: ["Neo4j", "Amazon Neptune", "Memgraph", "RedisGraph"],
+    ecosystems: ["Graph Databases", "Data"]
+  },
+  version: "25",
+  logo: "https://dist.neo4j.com/wp-content/uploads/20210423072428/neo4j-logo-2020-1.svg",
+  color: "#018BFF",
+  i18n: {
+    en: {
+      name: "Cypher",
+      description: "A declarative graph query language for Neo4j and other graph databases, designed to express graph patterns naturally.",
+      longDescription: "Cypher is a declarative query language designed specifically for querying and updating property graphs. Its ASCII-art syntax uses parentheses for nodes and arrows for relationships, making graph patterns intuitive to read and write.\n\nOriginally developed by Neo4j, Cypher has been standardized as openCypher and is supported by multiple graph database engines including Amazon Neptune and Memgraph. It is used for social networks, recommendation engines, fraud detection, and knowledge graphs."
+    },
+    es: {
+      name: "Cypher",
+      description: "Un lenguaje declarativo de consulta de grafos para Neo4j y otras bases de datos de grafos, dise\xF1ado para expresar patrones de grafos de forma natural.",
+      longDescription: "Cypher es un lenguaje de consulta declarativo dise\xF1ado para consultar y actualizar grafos de propiedades. Su sintaxis de arte ASCII usa par\xE9ntesis para nodos y flechas para relaciones, haciendo los patrones de grafo intuitivos de leer y escribir.\n\nOriginalmente desarrollado por Neo4j, Cypher ha sido estandarizado como openCypher y es compatible con m\xFAltiples motores de bases de datos de grafos. Se usa en redes sociales, motores de recomendaci\xF3n, detecci\xF3n de fraude y grafos de conocimiento."
+    },
+    it: {
+      name: "Cypher",
+      description: "Un linguaggio di interrogazione di grafi dichiarativo per Neo4j e altri database a grafo, progettato per esprimere pattern di grafi in modo naturale.",
+      longDescription: "Cypher \xE8 un linguaggio di interrogazione dichiarativo progettato per interrogare e aggiornare grafi di propriet\xE0. La sua sintassi ASCII art usa parentesi per i nodi e frecce per le relazioni, rendendo i pattern di grafo intuitivi da leggere e scrivere.\n\nOriginariamente sviluppato da Neo4j, Cypher \xE8 stato standardizzato come openCypher ed \xE8 supportato da pi\xF9 motori di database a grafo. \xC8 utilizzato per reti sociali, motori di raccomandazione, rilevamento frodi e grafi della conoscenza."
+    },
+    fr: {
+      name: "Cypher",
+      description: "Un langage de requ\xEAte de graphes d\xE9claratif pour Neo4j et d'autres bases de donn\xE9es de graphes, con\xE7u pour exprimer des motifs de graphes naturellement.",
+      longDescription: "Cypher est un langage de requ\xEAte d\xE9claratif con\xE7u pour interroger et mettre \xE0 jour des graphes de propri\xE9t\xE9s. Sa syntaxe art ASCII utilise des parenth\xE8ses pour les n\u0153uds et des fl\xE8ches pour les relations, rendant les motifs de graphes intuitifs \xE0 lire et \xE0 \xE9crire.\n\nD\xE9velopp\xE9 initialement par Neo4j, Cypher a \xE9t\xE9 standardis\xE9 en tant qu'openCypher et est support\xE9 par plusieurs moteurs de bases de donn\xE9es de graphes. Il est utilis\xE9 pour les r\xE9seaux sociaux, les moteurs de recommandation, la d\xE9tection de fraude et les graphes de connaissances."
+    },
+    de: {
+      name: "Cypher",
+      description: "Eine deklarative Graphabfragesprache f\xFCr Neo4j und andere Graphdatenbanken, die Graphmuster nat\xFCrlich ausdr\xFCckt.",
+      longDescription: "Cypher ist eine deklarative Abfragesprache, die speziell f\xFCr die Abfrage und Aktualisierung von Eigenschaftsgraphen entwickelt wurde. Ihre ASCII-Art-Syntax verwendet Klammern f\xFCr Knoten und Pfeile f\xFCr Beziehungen, was Graphmuster intuitiv lesbar und schreibbar macht.\n\nUrspr\xFCnglich von Neo4j entwickelt, wurde Cypher als openCypher standardisiert und wird von mehreren Graphdatenbank-Engines unterst\xFCtzt. Es wird f\xFCr soziale Netzwerke, Empfehlungssysteme, Betrugserkennung und Wissensgraphen eingesetzt."
+    },
+    pt: {
+      name: "Cypher",
+      description: "Uma linguagem declarativa de consulta de grafos para Neo4j e outros bancos de dados de grafos, projetada para expressar padr\xF5es de grafos de forma natural.",
+      longDescription: "Cypher \xE9 uma linguagem de consulta declarativa projetada para consultar e atualizar grafos de propriedades. Sua sintaxe de arte ASCII usa par\xEAnteses para n\xF3s e setas para relacionamentos, tornando os padr\xF5es de grafo intuitivos de ler e escrever.\n\nOriginalmente desenvolvido pela Neo4j, o Cypher foi padronizado como openCypher e \xE9 suportado por m\xFAltiplos motores de bancos de dados de grafos. \xC9 usado em redes sociais, motores de recomenda\xE7\xE3o, detec\xE7\xE3o de fraude e grafos de conhecimento."
+    }
+  }
+};
+
+export { cypher };
+//# sourceMappingURL=cypher.js.map
+//# sourceMappingURL=cypher.js.map

package/dist/languages/cypher.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/languages/cypher.ts"],"names":[],"mappings":";AAEO,IAAM,MAAA,GAAS;AAAA,EACpB,IAAA,EAAM,QAAA;AAAA,EACN,aAAA,EAAe,YAAA;AAAA,EACf,UAAA,EAAY,CAAC,SAAA,EAAW,MAAM,CAAA;AAAA,EAC9B,MAAA,EAAQ,wBAAA;AAAA,EACR,OAAA,EAAS,+CAAA;AAAA,EACT,SAAA,EAAW,CAAC,aAAA,EAAe,OAAO,CAAA;AAAA,EAClC,OAAA,EAAS;AAAA,IACP,QAAA,EAAU,CAAC,OAAA,EAAS,gBAAA,EAAkB,YAAY,YAAY,CAAA;AAAA,IAC9D,UAAA,EAAY,CAAC,iBAAA,EAAmB,MAAM;AAAA,GACxC;AAAA,EACA,OAAA,EAAS,IAAA;AAAA,EACT,IAAA,EAAM,gFAAA;AAAA,EACN,KAAA,EAAO,SAAA;AAAA,EACP,IAAA,EAAM;AAAA,IACJ,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,QAAA;AAAA,MACN,WAAA,EACE,uHAAA;AAAA,MACF,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,QAAA;AAAA,MACN,WAAA,EACE,2JAAA;AAAA,MACF,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,QAAA;AAAA,MACN,WAAA,EACE,uJAAA;AAAA,MACF,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,QAAA;AAAA,MACN,WAAA,EACE,sKAAA;AAAA,MACF,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,QAAA;AAAA,MACN,WAAA,EACE,2HAAA;AAAA,MACF,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,QAAA;AAAA,MACN,WAAA,EACE,gKAAA;AAAA,MACF,eAAA,EACE;AAAA;AACJ;AAEJ","file":"cypher.js","sourcesContent":["import type { Language } from \"../types\";\n\nexport const cypher = {\n  slug: \"cypher\",\n  publishedDate: \"2011-02-01\",\n  extensions: [\".cypher\", \".cyp\"],\n  author: \"Neo Technology (Neo4j)\",\n  website: \"https://neo4j.com/docs/cypher-manual/current/\",\n  paradigms: [\"declarative\", \"query\"],\n  tooling: {\n    runtimes: [\"Neo4j\", \"Amazon Neptune\", \"Memgraph\", \"RedisGraph\"],\n    ecosystems: [\"Graph Databases\", \"Data\"],\n  },\n  version: \"25\",\n  logo: \"https://dist.neo4j.com/wp-content/uploads/20210423072428/neo4j-logo-2020-1.svg\",\n  color: \"#018BFF\",\n  i18n: {\n    en: {\n      name: \"Cypher\",\n      description:\n        \"A declarative graph query language for Neo4j and other graph databases, designed to express graph patterns naturally.\",\n      longDescription:\n        \"Cypher is a declarative query language designed specifically for querying and updating property graphs. Its ASCII-art syntax uses parentheses for nodes and arrows for relationships, making graph patterns intuitive to read and write.\\n\\nOriginally developed by Neo4j, Cypher has been standardized as openCypher and is supported by multiple graph database engines including Amazon Neptune and Memgraph. It is used for social networks, recommendation engines, fraud detection, and knowledge graphs.\",\n    },\n    es: {\n      name: \"Cypher\",\n      description:\n        \"Un lenguaje declarativo de consulta de grafos para Neo4j y otras bases de datos de grafos, diseñado para expresar patrones de grafos de forma natural.\",\n      longDescription:\n        \"Cypher es un lenguaje de consulta declarativo diseñado para consultar y actualizar grafos de propiedades. Su sintaxis de arte ASCII usa paréntesis para nodos y flechas para relaciones, haciendo los patrones de grafo intuitivos de leer y escribir.\\n\\nOriginalmente desarrollado por Neo4j, Cypher ha sido estandarizado como openCypher y es compatible con múltiples motores de bases de datos de grafos. Se usa en redes sociales, motores de recomendación, detección de fraude y grafos de conocimiento.\",\n    },\n    it: {\n      name: \"Cypher\",\n      description:\n        \"Un linguaggio di interrogazione di grafi dichiarativo per Neo4j e altri database a grafo, progettato per esprimere pattern di grafi in modo naturale.\",\n      longDescription:\n        \"Cypher è un linguaggio di interrogazione dichiarativo progettato per interrogare e aggiornare grafi di proprietà. La sua sintassi ASCII art usa parentesi per i nodi e frecce per le relazioni, rendendo i pattern di grafo intuitivi da leggere e scrivere.\\n\\nOriginariamente sviluppato da Neo4j, Cypher è stato standardizzato come openCypher ed è supportato da più motori di database a grafo. È utilizzato per reti sociali, motori di raccomandazione, rilevamento frodi e grafi della conoscenza.\",\n    },\n    fr: {\n      name: \"Cypher\",\n      description:\n        \"Un langage de requête de graphes déclaratif pour Neo4j et d'autres bases de données de graphes, conçu pour exprimer des motifs de graphes naturellement.\",\n      longDescription:\n        \"Cypher est un langage de requête déclaratif conçu pour interroger et mettre à jour des graphes de propriétés. Sa syntaxe art ASCII utilise des parenthèses pour les nœuds et des flèches pour les relations, rendant les motifs de graphes intuitifs à lire et à écrire.\\n\\nDéveloppé initialement par Neo4j, Cypher a été standardisé en tant qu'openCypher et est supporté par plusieurs moteurs de bases de données de graphes. Il est utilisé pour les réseaux sociaux, les moteurs de recommandation, la détection de fraude et les graphes de connaissances.\",\n    },\n    de: {\n      name: \"Cypher\",\n      description:\n        \"Eine deklarative Graphabfragesprache für Neo4j und andere Graphdatenbanken, die Graphmuster natürlich ausdrückt.\",\n      longDescription:\n        \"Cypher ist eine deklarative Abfragesprache, die speziell für die Abfrage und Aktualisierung von Eigenschaftsgraphen entwickelt wurde. Ihre ASCII-Art-Syntax verwendet Klammern für Knoten und Pfeile für Beziehungen, was Graphmuster intuitiv lesbar und schreibbar macht.\\n\\nUrsprünglich von Neo4j entwickelt, wurde Cypher als openCypher standardisiert und wird von mehreren Graphdatenbank-Engines unterstützt. Es wird für soziale Netzwerke, Empfehlungssysteme, Betrugserkennung und Wissensgraphen eingesetzt.\",\n    },\n    pt: {\n      name: \"Cypher\",\n      description:\n        \"Uma linguagem declarativa de consulta de grafos para Neo4j e outros bancos de dados de grafos, projetada para expressar padrões de grafos de forma natural.\",\n      longDescription:\n        \"Cypher é uma linguagem de consulta declarativa projetada para consultar e atualizar grafos de propriedades. Sua sintaxe de arte ASCII usa parênteses para nós e setas para relacionamentos, tornando os padrões de grafo intuitivos de ler e escrever.\\n\\nOriginalmente desenvolvido pela Neo4j, o Cypher foi padronizado como openCypher e é suportado por múltiplos motores de bancos de dados de grafos. É usado em redes sociais, motores de recomendação, detecção de fraude e grafos de conhecimento.\",\n    },\n  },\n} satisfies Language;\n"]}

package/dist/languages/eiffel.cjs

@@ -0,0 +1,55 @@
+'use strict';
+
+// src/languages/eiffel.ts
+var eiffel = {
+  slug: "eiffel",
+  publishedDate: "1986-01-01",
+  extensions: [".e"],
+  author: "Bertrand Meyer",
+  website: "https://www.eiffel.org",
+  paradigms: ["object-oriented", "concurrent", "generic", "imperative"],
+  tooling: {
+    runtimes: ["EiffelStudio", "Native"],
+    packageManagers: ["iron"],
+    ecosystems: ["Enterprise", "Systems"]
+  },
+  version: "24.05",
+  logo: "https://www.eiffel.org/images/eiffel_logo.png",
+  color: "#4D6977",
+  i18n: {
+    en: {
+      name: "Eiffel",
+      description: "An object-oriented language by Bertrand Meyer that pioneered Design by Contract, generics, and multiple inheritance.",
+      longDescription: "Eiffel is an object-oriented programming language designed by Bertrand Meyer and first released in 1986. It introduced the concept of Design by Contract (DbC), where preconditions, postconditions, and class invariants are first-class language features that enforce correctness at runtime.\n\nEiffel supports multiple inheritance, generics, and automatic memory management. It has influenced many modern languages including Java and C#. EiffelStudio is the primary IDE and compiler, targeting native code. Eiffel is used in safety-critical, financial, and enterprise software systems."
+    },
+    es: {
+      name: "Eiffel",
+      description: "Un lenguaje orientado a objetos de Bertrand Meyer que fue pionero en el Dise\xF1o por Contrato, los gen\xE9ricos y la herencia m\xFAltiple.",
+      longDescription: "Eiffel es un lenguaje de programaci\xF3n orientado a objetos dise\xF1ado por Bertrand Meyer y lanzado por primera vez en 1986. Introdujo el concepto de Dise\xF1o por Contrato (DbC), donde las precondiciones, postcondiciones e invariantes de clase son caracter\xEDsticas del lenguaje de primera clase.\n\nEiffel soporta herencia m\xFAltiple, gen\xE9ricos y gesti\xF3n autom\xE1tica de memoria. Ha influenciado muchos lenguajes modernos incluyendo Java y C#. Se usa en sistemas de software de misi\xF3n cr\xEDtica, financieros y empresariales."
+    },
+    it: {
+      name: "Eiffel",
+      description: "Un linguaggio orientato agli oggetti di Bertrand Meyer che ha introdotto il Design by Contract, i generici e l'ereditariet\xE0 multipla.",
+      longDescription: "Eiffel \xE8 un linguaggio di programmazione orientato agli oggetti progettato da Bertrand Meyer e rilasciato per la prima volta nel 1986. Ha introdotto il concetto di Design by Contract (DbC), dove le precondizioni, le postcondizioni e gli invarianti di classe sono funzionalit\xE0 di prima classe del linguaggio.\n\nEiffel supporta l'ereditariet\xE0 multipla, i generici e la gestione automatica della memoria. Ha influenzato molti linguaggi moderni tra cui Java e C#. Viene utilizzato in sistemi software mission-critical, finanziari e aziendali."
+    },
+    fr: {
+      name: "Eiffel",
+      description: "Un langage orient\xE9 objet de Bertrand Meyer qui a introduit la Conception par Contrat, les g\xE9n\xE9riques et l'h\xE9ritage multiple.",
+      longDescription: "Eiffel est un langage de programmation orient\xE9 objet con\xE7u par Bertrand Meyer et publi\xE9 pour la premi\xE8re fois en 1986. Il a introduit le concept de Conception par Contrat (DbC), o\xF9 les pr\xE9conditions, les postconditions et les invariants de classe sont des fonctionnalit\xE9s de premi\xE8re classe du langage.\n\nEiffel supporte l'h\xE9ritage multiple, les g\xE9n\xE9riques et la gestion automatique de la m\xE9moire. Il a influenc\xE9 de nombreux langages modernes dont Java et C#. Il est utilis\xE9 dans les syst\xE8mes logiciels critiques, financiers et d'entreprise."
+    },
+    de: {
+      name: "Eiffel",
+      description: "Eine objektorientierte Sprache von Bertrand Meyer, die Design by Contract, Generics und Mehrfachvererbung eingef\xFChrt hat.",
+      longDescription: "Eiffel ist eine objektorientierte Programmiersprache, die von Bertrand Meyer entworfen und erstmals 1986 ver\xF6ffentlicht wurde. Sie f\xFChrte das Konzept des Design by Contract (DbC) ein, bei dem Vorbedingungen, Nachbedingungen und Klasseninvarianten erstklassige Sprachmerkmale sind.\n\nEiffel unterst\xFCtzt Mehrfachvererbung, Generics und automatisches Speichermanagement. Es hat viele moderne Sprachen wie Java und C# beeinflusst. EiffelStudio ist die prim\xE4re IDE und der Compiler. Eiffel wird in sicherheitskritischen, finanziellen und Unternehmenssoftwaresystemen eingesetzt."
+    },
+    pt: {
+      name: "Eiffel",
+      description: "Uma linguagem orientada a objetos de Bertrand Meyer que foi pioneira no Design by Contract, generics e heran\xE7a m\xFAltipla.",
+      longDescription: "Eiffel \xE9 uma linguagem de programa\xE7\xE3o orientada a objetos projetada por Bertrand Meyer e lan\xE7ada pela primeira vez em 1986. Introduziu o conceito de Design by Contract (DbC), onde pr\xE9-condi\xE7\xF5es, p\xF3s-condi\xE7\xF5es e invariantes de classe s\xE3o recursos de primeira classe da linguagem.\n\nEiffel suporta heran\xE7a m\xFAltipla, generics e gerenciamento autom\xE1tico de mem\xF3ria. Influenciou muitas linguagens modernas incluindo Java e C#. EiffelStudio \xE9 a IDE e compilador principal. \xC9 usado em sistemas de software de miss\xE3o cr\xEDtica, financeiros e empresariais."
+    }
+  }
+};
+
+exports.eiffel = eiffel;
+//# sourceMappingURL=eiffel.cjs.map
+//# sourceMappingURL=eiffel.cjs.map

package/dist/languages/eiffel.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/languages/eiffel.ts"],"names":[],"mappings":";;;AAEO,IAAM,MAAA,GAAS;AAAA,EACpB,IAAA,EAAM,QAAA;AAAA,EACN,aAAA,EAAe,YAAA;AAAA,EACf,UAAA,EAAY,CAAC,IAAI,CAAA;AAAA,EACjB,MAAA,EAAQ,gBAAA;AAAA,EACR,OAAA,EAAS,wBAAA;AAAA,EACT,SAAA,EAAW,CAAC,iBAAA,EAAmB,YAAA,EAAc,WAAW,YAAY,CAAA;AAAA,EACpE,OAAA,EAAS;AAAA,IACP,QAAA,EAAU,CAAC,cAAA,EAAgB,QAAQ,CAAA;AAAA,IACnC,eAAA,EAAiB,CAAC,MAAM,CAAA;AAAA,IACxB,UAAA,EAAY,CAAC,YAAA,EAAc,SAAS;AAAA,GACtC;AAAA,EACA,OAAA,EAAS,OAAA;AAAA,EACT,IAAA,EAAM,+CAAA;AAAA,EACN,KAAA,EAAO,SAAA;AAAA,EACP,IAAA,EAAM;AAAA,IACJ,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,QAAA;AAAA,MACN,WAAA,EACE,sHAAA;AAAA,MACF,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,QAAA;AAAA,MACN,WAAA,EACE,6IAAA;AAAA,MACF,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,QAAA;AAAA,MACN,WAAA,EACE,0IAAA;AAAA,MACF,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,QAAA;AAAA,MACN,WAAA,EACE,0IAAA;AAAA,MACF,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,QAAA;AAAA,MACN,WAAA,EACE,8HAAA;AAAA,MACF,eAAA,EACE;AAAA,KACJ;AAAA,IACA,EAAA,EAAI;AAAA,MACF,IAAA,EAAM,QAAA;AAAA,MACN,WAAA,EACE,gIAAA;AAAA,MACF,eAAA,EACE;AAAA;AACJ;AAEJ","file":"eiffel.cjs","sourcesContent":["import type { Language } from \"../types\";\n\nexport const eiffel = {\n  slug: \"eiffel\",\n  publishedDate: \"1986-01-01\",\n  extensions: [\".e\"],\n  author: \"Bertrand Meyer\",\n  website: \"https://www.eiffel.org\",\n  paradigms: [\"object-oriented\", \"concurrent\", \"generic\", \"imperative\"],\n  tooling: {\n    runtimes: [\"EiffelStudio\", \"Native\"],\n    packageManagers: [\"iron\"],\n    ecosystems: [\"Enterprise\", \"Systems\"],\n  },\n  version: \"24.05\",\n  logo: \"https://www.eiffel.org/images/eiffel_logo.png\",\n  color: \"#4D6977\",\n  i18n: {\n    en: {\n      name: \"Eiffel\",\n      description:\n        \"An object-oriented language by Bertrand Meyer that pioneered Design by Contract, generics, and multiple inheritance.\",\n      longDescription:\n        \"Eiffel is an object-oriented programming language designed by Bertrand Meyer and first released in 1986. It introduced the concept of Design by Contract (DbC), where preconditions, postconditions, and class invariants are first-class language features that enforce correctness at runtime.\\n\\nEiffel supports multiple inheritance, generics, and automatic memory management. It has influenced many modern languages including Java and C#. EiffelStudio is the primary IDE and compiler, targeting native code. Eiffel is used in safety-critical, financial, and enterprise software systems.\",\n    },\n    es: {\n      name: \"Eiffel\",\n      description:\n        \"Un lenguaje orientado a objetos de Bertrand Meyer que fue pionero en el Diseño por Contrato, los genéricos y la herencia múltiple.\",\n      longDescription:\n        \"Eiffel es un lenguaje de programación orientado a objetos diseñado por Bertrand Meyer y lanzado por primera vez en 1986. Introdujo el concepto de Diseño por Contrato (DbC), donde las precondiciones, postcondiciones e invariantes de clase son características del lenguaje de primera clase.\\n\\nEiffel soporta herencia múltiple, genéricos y gestión automática de memoria. Ha influenciado muchos lenguajes modernos incluyendo Java y C#. Se usa en sistemas de software de misión crítica, financieros y empresariales.\",\n    },\n    it: {\n      name: \"Eiffel\",\n      description:\n        \"Un linguaggio orientato agli oggetti di Bertrand Meyer che ha introdotto il Design by Contract, i generici e l'ereditarietà multipla.\",\n      longDescription:\n        \"Eiffel è un linguaggio di programmazione orientato agli oggetti progettato da Bertrand Meyer e rilasciato per la prima volta nel 1986. Ha introdotto il concetto di Design by Contract (DbC), dove le precondizioni, le postcondizioni e gli invarianti di classe sono funzionalità di prima classe del linguaggio.\\n\\nEiffel supporta l'ereditarietà multipla, i generici e la gestione automatica della memoria. Ha influenzato molti linguaggi moderni tra cui Java e C#. Viene utilizzato in sistemi software mission-critical, finanziari e aziendali.\",\n    },\n    fr: {\n      name: \"Eiffel\",\n      description:\n        \"Un langage orienté objet de Bertrand Meyer qui a introduit la Conception par Contrat, les génériques et l'héritage multiple.\",\n      longDescription:\n        \"Eiffel est un langage de programmation orienté objet conçu par Bertrand Meyer et publié pour la première fois en 1986. Il a introduit le concept de Conception par Contrat (DbC), où les préconditions, les postconditions et les invariants de classe sont des fonctionnalités de première classe du langage.\\n\\nEiffel supporte l'héritage multiple, les génériques et la gestion automatique de la mémoire. Il a influencé de nombreux langages modernes dont Java et C#. Il est utilisé dans les systèmes logiciels critiques, financiers et d'entreprise.\",\n    },\n    de: {\n      name: \"Eiffel\",\n      description:\n        \"Eine objektorientierte Sprache von Bertrand Meyer, die Design by Contract, Generics und Mehrfachvererbung eingeführt hat.\",\n      longDescription:\n        \"Eiffel ist eine objektorientierte Programmiersprache, die von Bertrand Meyer entworfen und erstmals 1986 veröffentlicht wurde. Sie führte das Konzept des Design by Contract (DbC) ein, bei dem Vorbedingungen, Nachbedingungen und Klasseninvarianten erstklassige Sprachmerkmale sind.\\n\\nEiffel unterstützt Mehrfachvererbung, Generics und automatisches Speichermanagement. Es hat viele moderne Sprachen wie Java und C# beeinflusst. EiffelStudio ist die primäre IDE und der Compiler. Eiffel wird in sicherheitskritischen, finanziellen und Unternehmenssoftwaresystemen eingesetzt.\",\n    },\n    pt: {\n      name: \"Eiffel\",\n      description:\n        \"Uma linguagem orientada a objetos de Bertrand Meyer que foi pioneira no Design by Contract, generics e herança múltipla.\",\n      longDescription:\n        \"Eiffel é uma linguagem de programação orientada a objetos projetada por Bertrand Meyer e lançada pela primeira vez em 1986. Introduziu o conceito de Design by Contract (DbC), onde pré-condições, pós-condições e invariantes de classe são recursos de primeira classe da linguagem.\\n\\nEiffel suporta herança múltipla, generics e gerenciamento automático de memória. Influenciou muitas linguagens modernas incluindo Java e C#. EiffelStudio é a IDE e compilador principal. É usado em sistemas de software de missão crítica, financeiros e empresariais.\",\n    },\n  },\n} satisfies Language;\n"]}

package/dist/languages/eiffel.d.cts

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