code-languages 1.40.11 → 1.42.0

package/dist/languages/j.cjs

@@ -0,0 +1,52 @@
+'use strict';
+
+// src/languages/j.ts
+var j = {
+  slug: "j",
+  publishedDate: "1990-01-01",
+  extensions: [".ijs"],
+  author: "Kenneth E. Iverson / Roger Hui",
+  website: "https://www.jsoftware.com",
+  paradigms: ["array", "functional", "tacit"],
+  tooling: {
+    runtimes: ["J Engine"],
+    ecosystems: ["Data Science", "Numerical Computing"]
+  },
+  version: "J9.6",
+  logo: "https://avatars.githubusercontent.com/u/583748?v=4",
+  color: "#9EEDFF",
+  i18n: {
+    en: {
+      name: "J",
+      description: "A terse array language by the creator of APL, using ASCII instead of symbols.",
+      longDescription: "J is an array programming language designed by Kenneth Iverson and Roger Hui as a successor to APL, replacing its special symbol set with ASCII digraphs. Programs compose verbs and adverbs over whole arrays, often in a point-free (tacit) style.\n\nJ excels at statistics, mathematical exploration, and data transformation, packing algorithms into remarkably short expressions. The interpreter, labs, and extensive vocabulary documentation are freely available from Jsoftware."
+    },
+    es: {
+      name: "J",
+      description: "Un lenguaje de arrays conciso del creador de APL, usando ASCII en lugar de s\xEDmbolos.",
+      longDescription: "J es un lenguaje de programaci\xF3n de arrays dise\xF1ado por Kenneth Iverson y Roger Hui como sucesor de APL, reemplazando su juego de s\xEDmbolos especiales por d\xEDgrafos ASCII. Los programas componen verbos y adverbios sobre arrays completos, a menudo en estilo t\xE1cito (point-free).\n\nJ destaca en estad\xEDstica, exploraci\xF3n matem\xE1tica y transformaci\xF3n de datos, condensando algoritmos en expresiones notablemente cortas. El int\xE9rprete, los laboratorios y la extensa documentaci\xF3n de vocabulario est\xE1n disponibles gratuitamente en Jsoftware."
+    },
+    it: {
+      name: "J",
+      description: "Un linguaggio di array conciso del creatore di APL, con ASCII al posto dei simboli.",
+      longDescription: "J \xE8 un linguaggio di programmazione di array progettato da Kenneth Iverson e Roger Hui come successore di APL, sostituendo il suo set di simboli speciali con digrammi ASCII. I programmi compongono verbi e avverbi su interi array, spesso in stile tacito (point-free).\n\nJ eccelle in statistica, esplorazione matematica e trasformazione dei dati, condensando algoritmi in espressioni notevolmente brevi. L'interprete, i laboratori e l'ampia documentazione del vocabolario sono disponibili gratuitamente da Jsoftware."
+    },
+    fr: {
+      name: "J",
+      description: "Un langage de tableaux concis du cr\xE9ateur d'APL, utilisant l'ASCII plut\xF4t que des symboles.",
+      longDescription: "J est un langage de programmation de tableaux con\xE7u par Kenneth Iverson et Roger Hui comme successeur d'APL, rempla\xE7ant son jeu de symboles sp\xE9ciaux par des digrammes ASCII. Les programmes composent des verbes et des adverbes sur des tableaux entiers, souvent dans un style tacite (point-free).\n\nJ excelle en statistique, en exploration math\xE9matique et en transformation de donn\xE9es, condensant les algorithmes en expressions remarquablement courtes. L'interpr\xE9teur, les laboratoires et la vaste documentation du vocabulaire sont disponibles gratuitement chez Jsoftware."
+    },
+    de: {
+      name: "J",
+      description: "Eine knappe Array-Sprache vom Sch\xF6pfer von APL, mit ASCII statt Sonderzeichen.",
+      longDescription: "J ist eine Array-Programmiersprache, die Kenneth Iverson und Roger Hui als Nachfolger von APL entworfen haben; der spezielle Symbolsatz wurde durch ASCII-Digraphen ersetzt. Programme komponieren Verben und Adverbien \xFCber ganze Arrays, oft im punktfreien (taciten) Stil.\n\nJ gl\xE4nzt bei Statistik, mathematischer Exploration und Datentransformation und verdichtet Algorithmen zu bemerkenswert kurzen Ausdr\xFCcken. Interpreter, Labs und die umfangreiche Vokabular-Dokumentation sind bei Jsoftware frei erh\xE4ltlich."
+    },
+    pt: {
+      name: "J",
+      description: "Uma linguagem de arrays concisa do criador do APL, usando ASCII em vez de s\xEDmbolos.",
+      longDescription: "J \xE9 uma linguagem de programa\xE7\xE3o de arrays projetada por Kenneth Iverson e Roger Hui como sucessora do APL, substituindo seu conjunto de s\xEDmbolos especiais por d\xEDgrafos ASCII. Os programas comp\xF5em verbos e adv\xE9rbios sobre arrays inteiros, frequentemente em estilo t\xE1cito (point-free).\n\nJ se destaca em estat\xEDstica, explora\xE7\xE3o matem\xE1tica e transforma\xE7\xE3o de dados, condensando algoritmos em express\xF5es notavelmente curtas. O interpretador, os laborat\xF3rios e a extensa documenta\xE7\xE3o de vocabul\xE1rio est\xE3o dispon\xEDveis gratuitamente na Jsoftware."
+    }
+  }
+};
+
+exports.j = j;

package/dist/languages/j.d.cts

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

package/dist/languages/j.d.ts

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

package/dist/languages/j.js

@@ -0,0 +1,50 @@
+// src/languages/j.ts
+var j = {
+  slug: "j",
+  publishedDate: "1990-01-01",
+  extensions: [".ijs"],
+  author: "Kenneth E. Iverson / Roger Hui",
+  website: "https://www.jsoftware.com",
+  paradigms: ["array", "functional", "tacit"],
+  tooling: {
+    runtimes: ["J Engine"],
+    ecosystems: ["Data Science", "Numerical Computing"]
+  },
+  version: "J9.6",
+  logo: "https://avatars.githubusercontent.com/u/583748?v=4",
+  color: "#9EEDFF",
+  i18n: {
+    en: {
+      name: "J",
+      description: "A terse array language by the creator of APL, using ASCII instead of symbols.",
+      longDescription: "J is an array programming language designed by Kenneth Iverson and Roger Hui as a successor to APL, replacing its special symbol set with ASCII digraphs. Programs compose verbs and adverbs over whole arrays, often in a point-free (tacit) style.\n\nJ excels at statistics, mathematical exploration, and data transformation, packing algorithms into remarkably short expressions. The interpreter, labs, and extensive vocabulary documentation are freely available from Jsoftware."
+    },
+    es: {
+      name: "J",
+      description: "Un lenguaje de arrays conciso del creador de APL, usando ASCII en lugar de s\xEDmbolos.",
+      longDescription: "J es un lenguaje de programaci\xF3n de arrays dise\xF1ado por Kenneth Iverson y Roger Hui como sucesor de APL, reemplazando su juego de s\xEDmbolos especiales por d\xEDgrafos ASCII. Los programas componen verbos y adverbios sobre arrays completos, a menudo en estilo t\xE1cito (point-free).\n\nJ destaca en estad\xEDstica, exploraci\xF3n matem\xE1tica y transformaci\xF3n de datos, condensando algoritmos en expresiones notablemente cortas. El int\xE9rprete, los laboratorios y la extensa documentaci\xF3n de vocabulario est\xE1n disponibles gratuitamente en Jsoftware."
+    },
+    it: {
+      name: "J",
+      description: "Un linguaggio di array conciso del creatore di APL, con ASCII al posto dei simboli.",
+      longDescription: "J \xE8 un linguaggio di programmazione di array progettato da Kenneth Iverson e Roger Hui come successore di APL, sostituendo il suo set di simboli speciali con digrammi ASCII. I programmi compongono verbi e avverbi su interi array, spesso in stile tacito (point-free).\n\nJ eccelle in statistica, esplorazione matematica e trasformazione dei dati, condensando algoritmi in espressioni notevolmente brevi. L'interprete, i laboratori e l'ampia documentazione del vocabolario sono disponibili gratuitamente da Jsoftware."
+    },
+    fr: {
+      name: "J",
+      description: "Un langage de tableaux concis du cr\xE9ateur d'APL, utilisant l'ASCII plut\xF4t que des symboles.",
+      longDescription: "J est un langage de programmation de tableaux con\xE7u par Kenneth Iverson et Roger Hui comme successeur d'APL, rempla\xE7ant son jeu de symboles sp\xE9ciaux par des digrammes ASCII. Les programmes composent des verbes et des adverbes sur des tableaux entiers, souvent dans un style tacite (point-free).\n\nJ excelle en statistique, en exploration math\xE9matique et en transformation de donn\xE9es, condensant les algorithmes en expressions remarquablement courtes. L'interpr\xE9teur, les laboratoires et la vaste documentation du vocabulaire sont disponibles gratuitement chez Jsoftware."
+    },
+    de: {
+      name: "J",
+      description: "Eine knappe Array-Sprache vom Sch\xF6pfer von APL, mit ASCII statt Sonderzeichen.",
+      longDescription: "J ist eine Array-Programmiersprache, die Kenneth Iverson und Roger Hui als Nachfolger von APL entworfen haben; der spezielle Symbolsatz wurde durch ASCII-Digraphen ersetzt. Programme komponieren Verben und Adverbien \xFCber ganze Arrays, oft im punktfreien (taciten) Stil.\n\nJ gl\xE4nzt bei Statistik, mathematischer Exploration und Datentransformation und verdichtet Algorithmen zu bemerkenswert kurzen Ausdr\xFCcken. Interpreter, Labs und die umfangreiche Vokabular-Dokumentation sind bei Jsoftware frei erh\xE4ltlich."
+    },
+    pt: {
+      name: "J",
+      description: "Uma linguagem de arrays concisa do criador do APL, usando ASCII em vez de s\xEDmbolos.",
+      longDescription: "J \xE9 uma linguagem de programa\xE7\xE3o de arrays projetada por Kenneth Iverson e Roger Hui como sucessora do APL, substituindo seu conjunto de s\xEDmbolos especiais por d\xEDgrafos ASCII. Os programas comp\xF5em verbos e adv\xE9rbios sobre arrays inteiros, frequentemente em estilo t\xE1cito (point-free).\n\nJ se destaca em estat\xEDstica, explora\xE7\xE3o matem\xE1tica e transforma\xE7\xE3o de dados, condensando algoritmos em express\xF5es notavelmente curtas. O interpretador, os laborat\xF3rios e a extensa documenta\xE7\xE3o de vocabul\xE1rio est\xE3o dispon\xEDveis gratuitamente na Jsoftware."
+    }
+  }
+};
+
+export { j };

package/dist/languages/javascript.cjs

@@ -3,6 +3,7 @@
 // src/languages/javascript.ts
 var javascript = {
   slug: "javascript",
+  aliases: ["js", "ecmascript"],
   publishedDate: "1995-12-04",
   extensions: [".js", ".mjs", ".cjs", ".jsx"],
   author: "Brendan Eich / Netscape",

package/dist/languages/javascript.d.cts

@@ -1,5 +1,6 @@
 declare const javascript: {
     slug: string;
+    aliases: string[];
     publishedDate: string;
     extensions: string[];
     author: string;

package/dist/languages/javascript.d.ts

@@ -1,5 +1,6 @@
 declare const javascript: {
     slug: string;
+    aliases: string[];
     publishedDate: string;
     extensions: string[];
     author: string;

package/dist/languages/javascript.js

@@ -1,6 +1,7 @@
 // src/languages/javascript.ts
 var javascript = {
   slug: "javascript",
+  aliases: ["js", "ecmascript"],
   publishedDate: "1995-12-04",
   extensions: [".js", ".mjs", ".cjs", ".jsx"],
   author: "Brendan Eich / Netscape",

package/dist/languages/jcl.cjs

@@ -0,0 +1,52 @@
+'use strict';
+
+// src/languages/jcl.ts
+var jcl = {
+  slug: "jcl",
+  publishedDate: "1964-04-07",
+  extensions: [".jcl"],
+  author: "IBM",
+  website: "https://www.ibm.com/docs/en/zos/3.1.0?topic=zos-mvs-jcl-reference",
+  paradigms: ["declarative", "batch"],
+  tooling: {
+    runtimes: ["z/OS", "MVS", "JES2", "JES3"],
+    ecosystems: ["Mainframe", "Batch Processing"]
+  },
+  version: "z/OS 3.1",
+  logo: "https://upload.wikimedia.org/wikipedia/commons/5/51/IBM_logo.svg",
+  color: "#1F70C1",
+  i18n: {
+    en: {
+      name: "JCL",
+      description: "IBM Job Control Language for describing batch jobs on z/OS mainframes.",
+      longDescription: "JCL (Job Control Language) tells IBM mainframe operating systems how to run batch work: which programs to execute, in what order, with which datasets, and how to react to failures. JOB, EXEC, and DD statements describe jobs, steps, and data allocations processed by the JES2/JES3 subsystems.\n\nIntroduced with System/360 in 1964, JCL still orchestrates nightly batch processing in banking, insurance, and government workloads on z/OS, usually alongside COBOL, PL/I, and REXX."
+    },
+    es: {
+      name: "JCL",
+      description: "El Job Control Language de IBM para describir trabajos batch en mainframes z/OS.",
+      longDescription: "JCL (Job Control Language) indica a los sistemas operativos de mainframe de IBM c\xF3mo ejecutar trabajo batch: qu\xE9 programas ejecutar, en qu\xE9 orden, con qu\xE9 datasets y c\xF3mo reaccionar ante fallos. Las sentencias JOB, EXEC y DD describen trabajos, pasos y asignaciones de datos procesados por los subsistemas JES2/JES3.\n\nIntroducido con el System/360 en 1964, JCL sigue orquestando el procesamiento batch nocturno en cargas bancarias, de seguros y gubernamentales sobre z/OS, normalmente junto a COBOL, PL/I y REXX."
+    },
+    it: {
+      name: "JCL",
+      description: "Il Job Control Language di IBM per descrivere job batch sui mainframe z/OS.",
+      longDescription: "JCL (Job Control Language) indica ai sistemi operativi mainframe di IBM come eseguire il lavoro batch: quali programmi eseguire, in quale ordine, con quali dataset e come reagire ai fallimenti. Le istruzioni JOB, EXEC e DD descrivono job, step e allocazioni di dati elaborati dai sottosistemi JES2/JES3.\n\nIntrodotto con il System/360 nel 1964, JCL orchestra ancora l'elaborazione batch notturna nei carichi bancari, assicurativi e governativi su z/OS, di solito insieme a COBOL, PL/I e REXX."
+    },
+    fr: {
+      name: "JCL",
+      description: "Le Job Control Language d'IBM pour d\xE9crire les travaux batch sur mainframes z/OS.",
+      longDescription: "JCL (Job Control Language) indique aux syst\xE8mes d'exploitation mainframe d'IBM comment ex\xE9cuter le travail batch : quels programmes lancer, dans quel ordre, avec quels datasets et comment r\xE9agir aux \xE9checs. Les instructions JOB, EXEC et DD d\xE9crivent les travaux, les \xE9tapes et les allocations de donn\xE9es trait\xE9s par les sous-syst\xE8mes JES2/JES3.\n\nIntroduit avec le System/360 en 1964, JCL orchestre encore le traitement batch nocturne des charges bancaires, d'assurance et gouvernementales sous z/OS, g\xE9n\xE9ralement aux c\xF4t\xE9s de COBOL, PL/I et REXX."
+    },
+    de: {
+      name: "JCL",
+      description: "IBMs Job Control Language zur Beschreibung von Batch-Jobs auf z/OS-Mainframes.",
+      longDescription: "JCL (Job Control Language) sagt IBM-Mainframe-Betriebssystemen, wie Batch-Arbeit auszuf\xFChren ist: welche Programme in welcher Reihenfolge laufen, mit welchen Datasets und wie auf Fehler zu reagieren ist. JOB-, EXEC- und DD-Anweisungen beschreiben Jobs, Schritte und Datenzuweisungen, die von den JES2/JES3-Subsystemen verarbeitet werden.\n\nMit dem System/360 im Jahr 1964 eingef\xFChrt, orchestriert JCL noch heute die n\xE4chtliche Batch-Verarbeitung in Bank-, Versicherungs- und Beh\xF6rden-Workloads auf z/OS, \xFCblicherweise neben COBOL, PL/I und REXX."
+    },
+    pt: {
+      name: "JCL",
+      description: "A Job Control Language da IBM para descrever jobs batch em mainframes z/OS.",
+      longDescription: "JCL (Job Control Language) diz aos sistemas operacionais de mainframe da IBM como executar trabalho batch: quais programas executar, em que ordem, com quais datasets e como reagir a falhas. As instru\xE7\xF5es JOB, EXEC e DD descrevem jobs, passos e aloca\xE7\xF5es de dados processados pelos subsistemas JES2/JES3.\n\nIntroduzida com o System/360 em 1964, a JCL ainda orquestra o processamento batch noturno em cargas banc\xE1rias, de seguros e governamentais no z/OS, geralmente ao lado de COBOL, PL/I e REXX."
+    }
+  }
+};
+
+exports.jcl = jcl;

package/dist/languages/jcl.d.cts

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

package/dist/languages/jcl.d.ts

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

package/dist/languages/jcl.js

@@ -0,0 +1,50 @@
+// src/languages/jcl.ts
+var jcl = {
+  slug: "jcl",
+  publishedDate: "1964-04-07",
+  extensions: [".jcl"],
+  author: "IBM",
+  website: "https://www.ibm.com/docs/en/zos/3.1.0?topic=zos-mvs-jcl-reference",
+  paradigms: ["declarative", "batch"],
+  tooling: {
+    runtimes: ["z/OS", "MVS", "JES2", "JES3"],
+    ecosystems: ["Mainframe", "Batch Processing"]
+  },
+  version: "z/OS 3.1",
+  logo: "https://upload.wikimedia.org/wikipedia/commons/5/51/IBM_logo.svg",
+  color: "#1F70C1",
+  i18n: {
+    en: {
+      name: "JCL",
+      description: "IBM Job Control Language for describing batch jobs on z/OS mainframes.",
+      longDescription: "JCL (Job Control Language) tells IBM mainframe operating systems how to run batch work: which programs to execute, in what order, with which datasets, and how to react to failures. JOB, EXEC, and DD statements describe jobs, steps, and data allocations processed by the JES2/JES3 subsystems.\n\nIntroduced with System/360 in 1964, JCL still orchestrates nightly batch processing in banking, insurance, and government workloads on z/OS, usually alongside COBOL, PL/I, and REXX."
+    },
+    es: {
+      name: "JCL",
+      description: "El Job Control Language de IBM para describir trabajos batch en mainframes z/OS.",
+      longDescription: "JCL (Job Control Language) indica a los sistemas operativos de mainframe de IBM c\xF3mo ejecutar trabajo batch: qu\xE9 programas ejecutar, en qu\xE9 orden, con qu\xE9 datasets y c\xF3mo reaccionar ante fallos. Las sentencias JOB, EXEC y DD describen trabajos, pasos y asignaciones de datos procesados por los subsistemas JES2/JES3.\n\nIntroducido con el System/360 en 1964, JCL sigue orquestando el procesamiento batch nocturno en cargas bancarias, de seguros y gubernamentales sobre z/OS, normalmente junto a COBOL, PL/I y REXX."
+    },
+    it: {
+      name: "JCL",
+      description: "Il Job Control Language di IBM per descrivere job batch sui mainframe z/OS.",
+      longDescription: "JCL (Job Control Language) indica ai sistemi operativi mainframe di IBM come eseguire il lavoro batch: quali programmi eseguire, in quale ordine, con quali dataset e come reagire ai fallimenti. Le istruzioni JOB, EXEC e DD descrivono job, step e allocazioni di dati elaborati dai sottosistemi JES2/JES3.\n\nIntrodotto con il System/360 nel 1964, JCL orchestra ancora l'elaborazione batch notturna nei carichi bancari, assicurativi e governativi su z/OS, di solito insieme a COBOL, PL/I e REXX."
+    },
+    fr: {
+      name: "JCL",
+      description: "Le Job Control Language d'IBM pour d\xE9crire les travaux batch sur mainframes z/OS.",
+      longDescription: "JCL (Job Control Language) indique aux syst\xE8mes d'exploitation mainframe d'IBM comment ex\xE9cuter le travail batch : quels programmes lancer, dans quel ordre, avec quels datasets et comment r\xE9agir aux \xE9checs. Les instructions JOB, EXEC et DD d\xE9crivent les travaux, les \xE9tapes et les allocations de donn\xE9es trait\xE9s par les sous-syst\xE8mes JES2/JES3.\n\nIntroduit avec le System/360 en 1964, JCL orchestre encore le traitement batch nocturne des charges bancaires, d'assurance et gouvernementales sous z/OS, g\xE9n\xE9ralement aux c\xF4t\xE9s de COBOL, PL/I et REXX."
+    },
+    de: {
+      name: "JCL",
+      description: "IBMs Job Control Language zur Beschreibung von Batch-Jobs auf z/OS-Mainframes.",
+      longDescription: "JCL (Job Control Language) sagt IBM-Mainframe-Betriebssystemen, wie Batch-Arbeit auszuf\xFChren ist: welche Programme in welcher Reihenfolge laufen, mit welchen Datasets und wie auf Fehler zu reagieren ist. JOB-, EXEC- und DD-Anweisungen beschreiben Jobs, Schritte und Datenzuweisungen, die von den JES2/JES3-Subsystemen verarbeitet werden.\n\nMit dem System/360 im Jahr 1964 eingef\xFChrt, orchestriert JCL noch heute die n\xE4chtliche Batch-Verarbeitung in Bank-, Versicherungs- und Beh\xF6rden-Workloads auf z/OS, \xFCblicherweise neben COBOL, PL/I und REXX."
+    },
+    pt: {
+      name: "JCL",
+      description: "A Job Control Language da IBM para descrever jobs batch em mainframes z/OS.",
+      longDescription: "JCL (Job Control Language) diz aos sistemas operacionais de mainframe da IBM como executar trabalho batch: quais programas executar, em que ordem, com quais datasets e como reagir a falhas. As instru\xE7\xF5es JOB, EXEC e DD descrevem jobs, passos e aloca\xE7\xF5es de dados processados pelos subsistemas JES2/JES3.\n\nIntroduzida com o System/360 em 1964, a JCL ainda orquestra o processamento batch noturno em cargas banc\xE1rias, de seguros e governamentais no z/OS, geralmente ao lado de COBOL, PL/I e REXX."
+    }
+  }
+};
+
+export { jcl };

package/dist/languages/jq.cjs

@@ -0,0 +1,52 @@
+'use strict';
+
+// src/languages/jq.ts
+var jq = {
+  slug: "jq",
+  publishedDate: "2012-10-21",
+  extensions: [".jq"],
+  author: "Stephen Dolan",
+  website: "https://jqlang.org",
+  paradigms: ["functional", "declarative", "query"],
+  tooling: {
+    runtimes: ["jq CLI"],
+    ecosystems: ["Data Processing", "DevOps", "Scripting"]
+  },
+  version: "1.8.1",
+  logo: "https://avatars.githubusercontent.com/u/125535133?v=4",
+  color: "#C7254E",
+  i18n: {
+    en: {
+      name: "jq",
+      description: "A functional filter language for slicing, transforming, and querying JSON.",
+      longDescription: "jq is a lightweight command-line language for processing JSON. Programs are written as filter pipelines that select, reshape, and combine values, with built-in functions for iteration, reduction, string handling, and arithmetic.\n\nIt is a staple of shell scripting and DevOps workflows, used to inspect API responses, transform configuration, and glue JSON-producing tools together. Larger filters can be stored in .jq files and reused as modules."
+    },
+    es: {
+      name: "jq",
+      description: "Un lenguaje funcional de filtros para cortar, transformar y consultar JSON.",
+      longDescription: "jq es un lenguaje ligero de l\xEDnea de comandos para procesar JSON. Los programas se escriben como tuber\xEDas de filtros que seleccionan, remodelan y combinan valores, con funciones integradas para iteraci\xF3n, reducci\xF3n, manejo de cadenas y aritm\xE9tica.\n\nEs una pieza b\xE1sica del scripting de shell y de los flujos DevOps, usado para inspeccionar respuestas de API, transformar configuraci\xF3n y conectar herramientas que producen JSON. Los filtros grandes pueden guardarse en archivos .jq y reutilizarse como m\xF3dulos."
+    },
+    it: {
+      name: "jq",
+      description: "Un linguaggio funzionale di filtri per tagliare, trasformare e interrogare JSON.",
+      longDescription: "jq \xE8 un linguaggio leggero da riga di comando per elaborare JSON. I programmi si scrivono come pipeline di filtri che selezionano, rimodellano e combinano valori, con funzioni integrate per iterazione, riduzione, gestione delle stringhe e aritmetica.\n\n\xC8 un elemento fondamentale dello scripting di shell e dei flussi DevOps, usato per ispezionare risposte di API, trasformare configurazioni e collegare strumenti che producono JSON. I filtri pi\xF9 grandi possono essere salvati in file .jq e riutilizzati come moduli."
+    },
+    fr: {
+      name: "jq",
+      description: "Un langage fonctionnel de filtres pour d\xE9couper, transformer et interroger du JSON.",
+      longDescription: "jq est un langage l\xE9ger en ligne de commande pour traiter du JSON. Les programmes s'\xE9crivent comme des pipelines de filtres qui s\xE9lectionnent, remod\xE8lent et combinent des valeurs, avec des fonctions int\xE9gr\xE9es pour l'it\xE9ration, la r\xE9duction, le traitement des cha\xEEnes et l'arithm\xE9tique.\n\nC'est un incontournable des scripts shell et des workflows DevOps, utilis\xE9 pour inspecter des r\xE9ponses d'API, transformer de la configuration et relier des outils produisant du JSON. Les filtres volumineux peuvent \xEAtre stock\xE9s dans des fichiers .jq et r\xE9utilis\xE9s comme modules."
+    },
+    de: {
+      name: "jq",
+      description: "Eine funktionale Filtersprache zum Zerlegen, Transformieren und Abfragen von JSON.",
+      longDescription: "jq ist eine leichtgewichtige Kommandozeilensprache zur Verarbeitung von JSON. Programme werden als Filter-Pipelines geschrieben, die Werte ausw\xE4hlen, umformen und kombinieren, mit eingebauten Funktionen f\xFCr Iteration, Reduktion, Zeichenkettenverarbeitung und Arithmetik.\n\nSie ist ein fester Bestandteil von Shell-Skripten und DevOps-Workflows und dient dazu, API-Antworten zu untersuchen, Konfigurationen zu transformieren und JSON-erzeugende Werkzeuge zu verbinden. Gr\xF6\xDFere Filter k\xF6nnen in .jq-Dateien abgelegt und als Module wiederverwendet werden."
+    },
+    pt: {
+      name: "jq",
+      description: "Uma linguagem funcional de filtros para fatiar, transformar e consultar JSON.",
+      longDescription: "jq \xE9 uma linguagem leve de linha de comando para processar JSON. Os programas s\xE3o escritos como pipelines de filtros que selecionam, remodelam e combinam valores, com fun\xE7\xF5es embutidas para itera\xE7\xE3o, redu\xE7\xE3o, manipula\xE7\xE3o de strings e aritm\xE9tica.\n\n\xC9 um item b\xE1sico do scripting de shell e dos fluxos DevOps, usado para inspecionar respostas de API, transformar configura\xE7\xF5es e conectar ferramentas que produzem JSON. Filtros maiores podem ser guardados em arquivos .jq e reutilizados como m\xF3dulos."
+    }
+  }
+};
+
+exports.jq = jq;

package/dist/languages/jq.d.cts

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

package/dist/languages/jq.d.ts

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

package/dist/languages/jq.js

@@ -0,0 +1,50 @@
+// src/languages/jq.ts
+var jq = {
+  slug: "jq",
+  publishedDate: "2012-10-21",
+  extensions: [".jq"],
+  author: "Stephen Dolan",
+  website: "https://jqlang.org",
+  paradigms: ["functional", "declarative", "query"],
+  tooling: {
+    runtimes: ["jq CLI"],
+    ecosystems: ["Data Processing", "DevOps", "Scripting"]
+  },
+  version: "1.8.1",
+  logo: "https://avatars.githubusercontent.com/u/125535133?v=4",
+  color: "#C7254E",
+  i18n: {
+    en: {
+      name: "jq",
+      description: "A functional filter language for slicing, transforming, and querying JSON.",
+      longDescription: "jq is a lightweight command-line language for processing JSON. Programs are written as filter pipelines that select, reshape, and combine values, with built-in functions for iteration, reduction, string handling, and arithmetic.\n\nIt is a staple of shell scripting and DevOps workflows, used to inspect API responses, transform configuration, and glue JSON-producing tools together. Larger filters can be stored in .jq files and reused as modules."
+    },
+    es: {
+      name: "jq",
+      description: "Un lenguaje funcional de filtros para cortar, transformar y consultar JSON.",
+      longDescription: "jq es un lenguaje ligero de l\xEDnea de comandos para procesar JSON. Los programas se escriben como tuber\xEDas de filtros que seleccionan, remodelan y combinan valores, con funciones integradas para iteraci\xF3n, reducci\xF3n, manejo de cadenas y aritm\xE9tica.\n\nEs una pieza b\xE1sica del scripting de shell y de los flujos DevOps, usado para inspeccionar respuestas de API, transformar configuraci\xF3n y conectar herramientas que producen JSON. Los filtros grandes pueden guardarse en archivos .jq y reutilizarse como m\xF3dulos."
+    },
+    it: {
+      name: "jq",
+      description: "Un linguaggio funzionale di filtri per tagliare, trasformare e interrogare JSON.",
+      longDescription: "jq \xE8 un linguaggio leggero da riga di comando per elaborare JSON. I programmi si scrivono come pipeline di filtri che selezionano, rimodellano e combinano valori, con funzioni integrate per iterazione, riduzione, gestione delle stringhe e aritmetica.\n\n\xC8 un elemento fondamentale dello scripting di shell e dei flussi DevOps, usato per ispezionare risposte di API, trasformare configurazioni e collegare strumenti che producono JSON. I filtri pi\xF9 grandi possono essere salvati in file .jq e riutilizzati come moduli."
+    },
+    fr: {
+      name: "jq",
+      description: "Un langage fonctionnel de filtres pour d\xE9couper, transformer et interroger du JSON.",
+      longDescription: "jq est un langage l\xE9ger en ligne de commande pour traiter du JSON. Les programmes s'\xE9crivent comme des pipelines de filtres qui s\xE9lectionnent, remod\xE8lent et combinent des valeurs, avec des fonctions int\xE9gr\xE9es pour l'it\xE9ration, la r\xE9duction, le traitement des cha\xEEnes et l'arithm\xE9tique.\n\nC'est un incontournable des scripts shell et des workflows DevOps, utilis\xE9 pour inspecter des r\xE9ponses d'API, transformer de la configuration et relier des outils produisant du JSON. Les filtres volumineux peuvent \xEAtre stock\xE9s dans des fichiers .jq et r\xE9utilis\xE9s comme modules."
+    },
+    de: {
+      name: "jq",
+      description: "Eine funktionale Filtersprache zum Zerlegen, Transformieren und Abfragen von JSON.",
+      longDescription: "jq ist eine leichtgewichtige Kommandozeilensprache zur Verarbeitung von JSON. Programme werden als Filter-Pipelines geschrieben, die Werte ausw\xE4hlen, umformen und kombinieren, mit eingebauten Funktionen f\xFCr Iteration, Reduktion, Zeichenkettenverarbeitung und Arithmetik.\n\nSie ist ein fester Bestandteil von Shell-Skripten und DevOps-Workflows und dient dazu, API-Antworten zu untersuchen, Konfigurationen zu transformieren und JSON-erzeugende Werkzeuge zu verbinden. Gr\xF6\xDFere Filter k\xF6nnen in .jq-Dateien abgelegt und als Module wiederverwendet werden."
+    },
+    pt: {
+      name: "jq",
+      description: "Uma linguagem funcional de filtros para fatiar, transformar e consultar JSON.",
+      longDescription: "jq \xE9 uma linguagem leve de linha de comando para processar JSON. Os programas s\xE3o escritos como pipelines de filtros que selecionam, remodelam e combinam valores, com fun\xE7\xF5es embutidas para itera\xE7\xE3o, redu\xE7\xE3o, manipula\xE7\xE3o de strings e aritm\xE9tica.\n\n\xC9 um item b\xE1sico do scripting de shell e dos fluxos DevOps, usado para inspecionar respostas de API, transformar configura\xE7\xF5es e conectar ferramentas que produzem JSON. Filtros maiores podem ser guardados em arquivos .jq e reutilizados como m\xF3dulos."
+    }
+  }
+};
+
+export { jq };