code-languages 1.31.2 → 1.32.0

package/dist/languages/ante.js

@@ -0,0 +1,31 @@
+// src/languages/ante.ts
+var ante = {
+  slug: "ante",
+  publishedDate: "2019-01-01",
+  extensions: [".ante"],
+  author: "Evan Haas",
+  website: "https://antelang.org",
+  paradigms: ["functional", "imperative", "systems"],
+  tooling: {
+    runtimes: ["Ante compiler"],
+    packageManagers: ["Ante package tooling"],
+    ecosystems: ["Systems Programming", "Research", "Compiler Development"]
+  },
+  version: "experimental",
+  logo: "https://dummyimage.com/32x32/4F46E5/ffffff.png&text=A",
+  color: "#4F46E5",
+  i18n: {
+    en: {
+      name: "Ante",
+      description: "A systems language exploring algebraic effects, type inference, and safe low-level programming.",
+      longDescription: "Ante is an experimental programming language focused on combining systems-level control with high-level type system features such as algebraic effects, traits, and strong inference.\n\nIt is mainly used for language design research, compiler experimentation, and exploring how effect systems can model IO, mutation, and error handling without losing performance goals."
+    },
+    es: {
+      name: "Ante",
+      description: "Un lenguaje de sistemas que explora efectos algebraicos, inferencia y seguridad.",
+      longDescription: "Ante es un lenguaje experimental que combina control de bajo nivel con rasgos de sistema de tipos como efectos algebraicos, traits e inferencia fuerte.\n\nSe usa sobre todo para investigacion de lenguajes, experimentos de compiladores y exploracion de sistemas de efectos para IO, mutacion y errores."
+    }
+  }
+};
+
+export { ante };

package/dist/languages/austral.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+// src/languages/austral.ts
+var austral = {
+  slug: "austral",
+  publishedDate: "2021-01-01",
+  extensions: [".aum", ".aui"],
+  author: "Fernando Borretti",
+  website: "https://austral-lang.org",
+  paradigms: ["imperative", "systems", "procedural"],
+  tooling: {
+    runtimes: ["Austral compiler"],
+    ecosystems: ["Systems Programming", "Memory Safety", "Research"]
+  },
+  version: "0.1.0",
+  logo: "https://dummyimage.com/32x32/0F766E/ffffff.png&text=Au",
+  color: "#0F766E",
+  i18n: {
+    en: {
+      name: "Austral",
+      description: "A systems language built around linear types, capability safety, and explicit memory control.",
+      longDescription: "Austral is an experimental systems programming language that uses linear types to make ownership and resource handling explicit while keeping low-level control available to the programmer.\n\nIts design emphasizes capability safety, simple compilation targets, readable syntax, and research into practical ways to prevent resource misuse in native programs."
+    },
+    es: {
+      name: "Austral",
+      description: "Un lenguaje de sistemas basado en tipos lineales, capacidades y memoria explicita.",
+      longDescription: "Austral es un lenguaje experimental de sistemas que usa tipos lineales para hacer explicito el manejo de propiedad y recursos sin perder control de bajo nivel.\n\nSu diseno enfatiza seguridad por capacidades, objetivos de compilacion simples y formas practicas de evitar mal uso de recursos."
+    }
+  }
+};
+
+exports.austral = austral;

package/dist/languages/austral.d.cts

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

package/dist/languages/austral.d.ts

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

package/dist/languages/austral.js

@@ -0,0 +1,30 @@
+// src/languages/austral.ts
+var austral = {
+  slug: "austral",
+  publishedDate: "2021-01-01",
+  extensions: [".aum", ".aui"],
+  author: "Fernando Borretti",
+  website: "https://austral-lang.org",
+  paradigms: ["imperative", "systems", "procedural"],
+  tooling: {
+    runtimes: ["Austral compiler"],
+    ecosystems: ["Systems Programming", "Memory Safety", "Research"]
+  },
+  version: "0.1.0",
+  logo: "https://dummyimage.com/32x32/0F766E/ffffff.png&text=Au",
+  color: "#0F766E",
+  i18n: {
+    en: {
+      name: "Austral",
+      description: "A systems language built around linear types, capability safety, and explicit memory control.",
+      longDescription: "Austral is an experimental systems programming language that uses linear types to make ownership and resource handling explicit while keeping low-level control available to the programmer.\n\nIts design emphasizes capability safety, simple compilation targets, readable syntax, and research into practical ways to prevent resource misuse in native programs."
+    },
+    es: {
+      name: "Austral",
+      description: "Un lenguaje de sistemas basado en tipos lineales, capacidades y memoria explicita.",
+      longDescription: "Austral es un lenguaje experimental de sistemas que usa tipos lineales para hacer explicito el manejo de propiedad y recursos sin perder control de bajo nivel.\n\nSu diseno enfatiza seguridad por capacidades, objetivos de compilacion simples y formas practicas de evitar mal uso de recursos."
+    }
+  }
+};
+
+export { austral };

package/dist/languages/bcpl.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+// src/languages/bcpl.ts
+var bcpl = {
+  slug: "bcpl",
+  publishedDate: "1967-01-01",
+  extensions: [".bcpl"],
+  author: "Martin Richards",
+  website: "https://www.cl.cam.ac.uk/~mr10/BCPL.html",
+  paradigms: ["imperative", "procedural", "systems"],
+  tooling: {
+    runtimes: ["Cintsys BCPL", "Classic BCPL compilers"],
+    ecosystems: ["Systems Programming", "Operating Systems", "Language History"]
+  },
+  version: "Cintsys BCPL",
+  logo: "https://dummyimage.com/32x32/374151/ffffff.png&text=BC",
+  color: "#374151",
+  i18n: {
+    en: {
+      name: "BCPL",
+      description: "A compact systems language that influenced B and C through typeless procedural programming.",
+      longDescription: "BCPL was designed as a small, portable systems language with a simple compiler and a typeless model suited to early operating systems and compiler work.\n\nIts syntax, block structure, braces, comments, and procedural style influenced B and C, making it an important ancestor of modern systems programming languages."
+    },
+    es: {
+      name: "BCPL",
+      description: "Un lenguaje compacto de sistemas que influyo en B y C con programacion procedural.",
+      longDescription: "BCPL fue disenado como un lenguaje de sistemas pequeno y portable, con compilador simple y modelo sin tipos para sistemas operativos tempranos.\n\nSu sintaxis, bloques, llaves, comentarios y estilo procedural influyeron en B y C."
+    }
+  }
+};
+
+exports.bcpl = bcpl;

package/dist/languages/bcpl.d.cts

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

package/dist/languages/bcpl.d.ts

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

package/dist/languages/bcpl.js

@@ -0,0 +1,30 @@
+// src/languages/bcpl.ts
+var bcpl = {
+  slug: "bcpl",
+  publishedDate: "1967-01-01",
+  extensions: [".bcpl"],
+  author: "Martin Richards",
+  website: "https://www.cl.cam.ac.uk/~mr10/BCPL.html",
+  paradigms: ["imperative", "procedural", "systems"],
+  tooling: {
+    runtimes: ["Cintsys BCPL", "Classic BCPL compilers"],
+    ecosystems: ["Systems Programming", "Operating Systems", "Language History"]
+  },
+  version: "Cintsys BCPL",
+  logo: "https://dummyimage.com/32x32/374151/ffffff.png&text=BC",
+  color: "#374151",
+  i18n: {
+    en: {
+      name: "BCPL",
+      description: "A compact systems language that influenced B and C through typeless procedural programming.",
+      longDescription: "BCPL was designed as a small, portable systems language with a simple compiler and a typeless model suited to early operating systems and compiler work.\n\nIts syntax, block structure, braces, comments, and procedural style influenced B and C, making it an important ancestor of modern systems programming languages."
+    },
+    es: {
+      name: "BCPL",
+      description: "Un lenguaje compacto de sistemas que influyo en B y C con programacion procedural.",
+      longDescription: "BCPL fue disenado como un lenguaje de sistemas pequeno y portable, con compilador simple y modelo sin tipos para sistemas operativos tempranos.\n\nSu sintaxis, bloques, llaves, comentarios y estilo procedural influyeron en B y C."
+    }
+  }
+};
+
+export { bcpl };

package/dist/languages/bosque.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+// src/languages/bosque.ts
+var bosque = {
+  slug: "bosque",
+  publishedDate: "2019-04-15",
+  extensions: [".bsq"],
+  author: "Microsoft Research",
+  website: "https://github.com/microsoft/BosqueLanguage",
+  paradigms: ["functional", "imperative", "object-oriented"],
+  tooling: {
+    runtimes: ["Bosque reference runtime"],
+    ecosystems: ["Research", "Verification", "Application Logic"]
+  },
+  version: "experimental",
+  logo: "https://dummyimage.com/32x32/0078D4/ffffff.png&text=B",
+  color: "#0078D4",
+  i18n: {
+    en: {
+      name: "Bosque",
+      description: "A Microsoft Research language exploring regularized programming and predictable semantics.",
+      longDescription: "Bosque is a research programming language from Microsoft Research that explores regularized programming, aiming to reduce incidental complexity in control flow, mutation, and object identity.\n\nIt combines ideas from functional and object-oriented programming with immutable values, algebraic data, structured collections, and semantics meant to support tooling and automated reasoning."
+    },
+    es: {
+      name: "Bosque",
+      description: "Un lenguaje de Microsoft Research sobre programacion regularizada y semantica predecible.",
+      longDescription: "Bosque es un lenguaje de investigacion de Microsoft Research que explora programacion regularizada para reducir complejidad accidental en control, mutacion e identidad.\n\nCombina ideas funcionales y orientadas a objetos con valores inmutables, datos algebraicos y semantica pensada para herramientas."
+    }
+  }
+};
+
+exports.bosque = bosque;

package/dist/languages/bosque.d.cts

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

package/dist/languages/bosque.d.ts

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

package/dist/languages/bosque.js

@@ -0,0 +1,30 @@
+// src/languages/bosque.ts
+var bosque = {
+  slug: "bosque",
+  publishedDate: "2019-04-15",
+  extensions: [".bsq"],
+  author: "Microsoft Research",
+  website: "https://github.com/microsoft/BosqueLanguage",
+  paradigms: ["functional", "imperative", "object-oriented"],
+  tooling: {
+    runtimes: ["Bosque reference runtime"],
+    ecosystems: ["Research", "Verification", "Application Logic"]
+  },
+  version: "experimental",
+  logo: "https://dummyimage.com/32x32/0078D4/ffffff.png&text=B",
+  color: "#0078D4",
+  i18n: {
+    en: {
+      name: "Bosque",
+      description: "A Microsoft Research language exploring regularized programming and predictable semantics.",
+      longDescription: "Bosque is a research programming language from Microsoft Research that explores regularized programming, aiming to reduce incidental complexity in control flow, mutation, and object identity.\n\nIt combines ideas from functional and object-oriented programming with immutable values, algebraic data, structured collections, and semantics meant to support tooling and automated reasoning."
+    },
+    es: {
+      name: "Bosque",
+      description: "Un lenguaje de Microsoft Research sobre programacion regularizada y semantica predecible.",
+      longDescription: "Bosque es un lenguaje de investigacion de Microsoft Research que explora programacion regularizada para reducir complejidad accidental en control, mutacion e identidad.\n\nCombina ideas funcionales y orientadas a objetos con valores inmutables, datos algebraicos y semantica pensada para herramientas."
+    }
+  }
+};
+
+export { bosque };

package/dist/languages/bqn.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+// src/languages/bqn.ts
+var bqn = {
+  slug: "bqn",
+  publishedDate: "2020-01-01",
+  extensions: [".bqn"],
+  author: "Marshall Lochbaum",
+  website: "https://mlochbaum.github.io/BQN/",
+  paradigms: ["array", "functional", "tacit"],
+  tooling: {
+    runtimes: ["CBQN", "BQN.js"],
+    ecosystems: ["Array Programming", "Data Transformation", "Recreational Computing"]
+  },
+  version: "BQN specification",
+  logo: "https://dummyimage.com/32x32/7C3AED/ffffff.png&text=BQN",
+  color: "#7C3AED",
+  i18n: {
+    en: {
+      name: "BQN",
+      description: "An array programming language in the APL family with modern notation and tacit features.",
+      longDescription: "BQN is an array-oriented language influenced by APL, J, and K. It uses concise symbols to express operations over arrays, functions, modifiers, and trains.\n\nIt is used for compact data manipulation, algorithm exploration, teaching array thinking, and experiments with high-level notation backed by interpreters such as CBQN and BQN.js."
+    },
+    es: {
+      name: "BQN",
+      description: "Un lenguaje de programacion de arreglos de la familia APL con notacion moderna.",
+      longDescription: "BQN es un lenguaje orientado a arreglos influido por APL, J y K. Usa simbolos concisos para expresar operaciones sobre arreglos, funciones y modificadores.\n\nSe usa para manipulacion compacta de datos, exploracion de algoritmos y ensenanza de pensamiento basado en arreglos."
+    }
+  }
+};
+
+exports.bqn = bqn;

package/dist/languages/bqn.d.cts

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

package/dist/languages/bqn.d.ts

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

package/dist/languages/bqn.js

@@ -0,0 +1,30 @@
+// src/languages/bqn.ts
+var bqn = {
+  slug: "bqn",
+  publishedDate: "2020-01-01",
+  extensions: [".bqn"],
+  author: "Marshall Lochbaum",
+  website: "https://mlochbaum.github.io/BQN/",
+  paradigms: ["array", "functional", "tacit"],
+  tooling: {
+    runtimes: ["CBQN", "BQN.js"],
+    ecosystems: ["Array Programming", "Data Transformation", "Recreational Computing"]
+  },
+  version: "BQN specification",
+  logo: "https://dummyimage.com/32x32/7C3AED/ffffff.png&text=BQN",
+  color: "#7C3AED",
+  i18n: {
+    en: {
+      name: "BQN",
+      description: "An array programming language in the APL family with modern notation and tacit features.",
+      longDescription: "BQN is an array-oriented language influenced by APL, J, and K. It uses concise symbols to express operations over arrays, functions, modifiers, and trains.\n\nIt is used for compact data manipulation, algorithm exploration, teaching array thinking, and experiments with high-level notation backed by interpreters such as CBQN and BQN.js."
+    },
+    es: {
+      name: "BQN",
+      description: "Un lenguaje de programacion de arreglos de la familia APL con notacion moderna.",
+      longDescription: "BQN es un lenguaje orientado a arreglos influido por APL, J y K. Usa simbolos concisos para expresar operaciones sobre arreglos, funciones y modificadores.\n\nSe usa para manipulacion compacta de datos, exploracion de algoritmos y ensenanza de pensamiento basado en arreglos."
+    }
+  }
+};
+
+export { bqn };

package/dist/languages/curry.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+// src/languages/curry.ts
+var curry = {
+  slug: "curry",
+  publishedDate: "1997-01-01",
+  extensions: [".curry", ".lcurry"],
+  author: "Curry language community",
+  website: "https://www.curry-language.org",
+  paradigms: ["functional", "logic", "declarative"],
+  tooling: {
+    runtimes: ["KiCS2", "PAKCS"],
+    packageManagers: ["Curry Package Manager"],
+    ecosystems: ["Functional Logic Programming", "Constraint Solving", "Research"]
+  },
+  version: "Curry 0.9.0",
+  logo: "https://dummyimage.com/32x32/BE123C/ffffff.png&text=Cu",
+  color: "#BE123C",
+  i18n: {
+    en: {
+      name: "Curry",
+      description: "A functional logic language that combines Haskell-style functions with logic variables.",
+      longDescription: "Curry combines functional programming with logic programming, enabling lazy evaluation, higher-order functions, logic variables, non-determinism, and constraint-based computation in one language.\n\nIt is used in academic research, teaching declarative programming, symbolic computation, program analysis, and systems that benefit from mixing functional abstraction with logic search."
+    },
+    es: {
+      name: "Curry",
+      description: "Un lenguaje funcional-logico que combina funciones estilo Haskell con variables logicas.",
+      longDescription: "Curry combina programacion funcional y logica con evaluacion perezosa, funciones de orden superior, variables logicas, no determinismo y restricciones.\n\nSe usa en investigacion, docencia de programacion declarativa, computacion simbolica y analisis de programas."
+    }
+  }
+};
+
+exports.curry = curry;

package/dist/languages/curry.d.cts

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

package/dist/languages/curry.d.ts

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

package/dist/languages/curry.js

@@ -0,0 +1,31 @@
+// src/languages/curry.ts
+var curry = {
+  slug: "curry",
+  publishedDate: "1997-01-01",
+  extensions: [".curry", ".lcurry"],
+  author: "Curry language community",
+  website: "https://www.curry-language.org",
+  paradigms: ["functional", "logic", "declarative"],
+  tooling: {
+    runtimes: ["KiCS2", "PAKCS"],
+    packageManagers: ["Curry Package Manager"],
+    ecosystems: ["Functional Logic Programming", "Constraint Solving", "Research"]
+  },
+  version: "Curry 0.9.0",
+  logo: "https://dummyimage.com/32x32/BE123C/ffffff.png&text=Cu",
+  color: "#BE123C",
+  i18n: {
+    en: {
+      name: "Curry",
+      description: "A functional logic language that combines Haskell-style functions with logic variables.",
+      longDescription: "Curry combines functional programming with logic programming, enabling lazy evaluation, higher-order functions, logic variables, non-determinism, and constraint-based computation in one language.\n\nIt is used in academic research, teaching declarative programming, symbolic computation, program analysis, and systems that benefit from mixing functional abstraction with logic search."
+    },
+    es: {
+      name: "Curry",
+      description: "Un lenguaje funcional-logico que combina funciones estilo Haskell con variables logicas.",
+      longDescription: "Curry combina programacion funcional y logica con evaluacion perezosa, funciones de orden superior, variables logicas, no determinismo y restricciones.\n\nSe usa en investigacion, docencia de programacion declarativa, computacion simbolica y analisis de programas."
+    }
+  }
+};
+
+export { curry };