@kya-os/cli 2.0.0 → 2.0.3

package/node_modules/zod/README.md

@@ -0,0 +1,208 @@
+<p align="center">
+  <img src="logo.svg" width="200px" align="center" alt="Zod logo" />
+  <h1 align="center">Zod</h1>
+  <p align="center">
+    TypeScript-first schema validation with static type inference
+    <br/>
+    by <a href="https://x.com/colinhacks">@colinhacks</a>
+  </p>
+</p>
+<br/>
+
+<p align="center">
+<a href="https://github.com/colinhacks/zod/actions?query=branch%3Amaster"><img src="https://github.com/colinhacks/zod/actions/workflows/test.yml/badge.svg?event=push&branch=master" alt="Zod CI status" /></a>
+<a href="https://opensource.org/licenses/MIT" rel="nofollow"><img src="https://img.shields.io/github/license/colinhacks/zod" alt="License"></a>
+<a href="https://www.npmjs.com/package/zod" rel="nofollow"><img src="https://img.shields.io/npm/dw/zod.svg" alt="npm"></a>
+<a href="https://discord.gg/KaSRdyX2vc" rel="nofollow"><img src="https://img.shields.io/discord/893487829802418277?label=Discord&logo=discord&logoColor=white" alt="discord server"></a>
+<a href="https://github.com/colinhacks/zod" rel="nofollow"><img src="https://img.shields.io/github/stars/colinhacks/zod" alt="stars"></a>
+</p>
+
+<div align="center">
+  <a href="https://zod.dev/api">Docs</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://discord.gg/RcG33DQJdf">Discord</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://twitter.com/colinhacks">𝕏</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://bsky.app/profile/zod.dev">Bluesky</a>
+  <br />
+</div>
+
+<br/>
+<br/>
+
+<h2 align="center">Featured sponsor: Jazz</h2>
+
+<div align="center">
+  <a href="https://jazz.tools/?utm_source=zod">
+    <picture width="85%" >
+      <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/garden-co/jazz/938f6767e46cdfded60e50d99bf3b533f4809c68/homepage/homepage/public/Zod%20sponsor%20message.png">
+      <img alt="jazz logo" src="https://raw.githubusercontent.com/garden-co/jazz/938f6767e46cdfded60e50d99bf3b533f4809c68/homepage/homepage/public/Zod%20sponsor%20message.png" width="85%">
+    </picture>
+  </a>
+  <br/>
+  <p><sub>Learn more about <a target="_blank" rel="noopener noreferrer" href="mailto:sponsorship@colinhacks.com">featured sponsorships</a></sub></p>
+</div>
+
+<br/>
+<br/>
+<br/>
+
+### [Read the docs →](https://zod.dev/api)
+
+<br/>
+<br/>
+
+## What is Zod?
+
+Zod is a TypeScript-first validation library. Define a schema and parse some data with it. You'll get back a strongly typed, validated result.
+
+```ts
+import { z } from "zod/v4";
+
+const User = z.object({
+  name: z.string(),
+});
+
+// some untrusted data...
+const input = {
+  /* stuff */
+};
+
+// the parsed result is validated and type safe!
+const data = User.parse(input);
+
+// so you can use it with confidence :)
+console.log(data.name);
+```
+
+<br/>
+
+## Features
+
+- Zero external dependencies
+- Works in Node.js and all modern browsers
+- Tiny: `2kb` core bundle (gzipped)
+- Immutable API: methods return a new instance
+- Concise interface
+- Works with TypeScript and plain JS
+- Built-in JSON Schema conversion
+- Extensive ecosystem
+
+<br/>
+
+## Installation
+
+```sh
+npm install zod
+```
+
+<br/>
+
+## Basic usage
+
+Before you can do anything else, you need to define a schema. For the purposes of this guide, we'll use a simple object schema.
+
+```ts
+import { z } from "zod/v4";
+
+const Player = z.object({
+  username: z.string(),
+  xp: z.number(),
+});
+```
+
+### Parsing data
+
+Given any Zod schema, use `.parse` to validate an input. If it's valid, Zod returns a strongly-typed _deep clone_ of the input.
+
+```ts
+Player.parse({ username: "billie", xp: 100 });
+// => returns { username: "billie", xp: 100 }
+```
+
+**Note** — If your schema uses certain asynchronous APIs like `async` [refinements](#refine) or [transforms](#transform), you'll need to use the `.parseAsync()` method instead.
+
+```ts
+const schema = z.string().refine(async (val) => val.length <= 8);
+
+await schema.parseAsync("hello");
+// => "hello"
+```
+
+### Handling errors
+
+When validation fails, the `.parse()` method will throw a `ZodError` instance with granular information about the validation issues.
+
+```ts
+try {
+  Player.parse({ username: 42, xp: "100" });
+} catch (err) {
+  if (err instanceof z.ZodError) {
+    err.issues;
+    /* [
+      {
+        expected: 'string',
+        code: 'invalid_type',
+        path: [ 'username' ],
+        message: 'Invalid input: expected string'
+      },
+      {
+        expected: 'number',
+        code: 'invalid_type',
+        path: [ 'xp' ],
+        message: 'Invalid input: expected number'
+      }
+    ] */
+  }
+}
+```
+
+To avoid a `try/catch` block, you can use the `.safeParse()` method to get back a plain result object containing either the successfully parsed data or a `ZodError`. The result type is a [discriminated union](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#discriminated-unions), so you can handle both cases conveniently.
+
+```ts
+const result = Player.safeParse({ username: 42, xp: "100" });
+if (!result.success) {
+  result.error; // ZodError instance
+} else {
+  result.data; // { username: string; xp: number }
+}
+```
+
+**Note** — If your schema uses certain asynchronous APIs like `async` [refinements](#refine) or [transforms](#transform), you'll need to use the `.safeParseAsync()` method instead.
+
+```ts
+const schema = z.string().refine(async (val) => val.length <= 8);
+
+await schema.safeParseAsync("hello");
+// => { success: true; data: "hello" }
+```
+
+### Inferring types
+
+Zod infers a static type from your schema definitions. You can extract this type with the `z.infer<>` utility and use it however you like.
+
+```ts
+const Player = z.object({
+  username: z.string(),
+  xp: z.number(),
+});
+
+// extract the inferred type
+type Player = z.infer<typeof Player>;
+
+// use it in your code
+const player: Player = { username: "billie", xp: 100 };
+```
+
+In some cases, the input & output types of a schema can diverge. For instance, the `.transform()` API can convert the input from one type to another. In these cases, you can extract the input and output types independently:
+
+```ts
+const mySchema = z.string().transform((val) => val.length);
+
+type MySchemaIn = z.input<typeof mySchema>;
+// => string
+
+type MySchemaOut = z.output<typeof mySchema>; // equivalent to z.infer<typeof mySchema>
+// number
+```

package/node_modules/zod/dist/cjs/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = __importDefault(require("./v3/index.js"));
+__exportStar(require("./v3/index.js"), exports);
+exports.default = index_js_1.default;

package/node_modules/zod/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/node_modules/zod/dist/cjs/v3/ZodError.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZodError = exports.quotelessJson = exports.ZodIssueCode = void 0;
+const util_js_1 = require("./helpers/util.js");
+exports.ZodIssueCode = util_js_1.util.arrayToEnum([
+    "invalid_type",
+    "invalid_literal",
+    "custom",
+    "invalid_union",
+    "invalid_union_discriminator",
+    "invalid_enum_value",
+    "unrecognized_keys",
+    "invalid_arguments",
+    "invalid_return_type",
+    "invalid_date",
+    "invalid_string",
+    "too_small",
+    "too_big",
+    "invalid_intersection_types",
+    "not_multiple_of",
+    "not_finite",
+]);
+const quotelessJson = (obj) => {
+    const json = JSON.stringify(obj, null, 2);
+    return json.replace(/"([^"]+)":/g, "$1:");
+};
+exports.quotelessJson = quotelessJson;
+class ZodError extends Error {
+    get errors() {
+        return this.issues;
+    }
+    constructor(issues) {
+        super();
+        this.issues = [];
+        this.addIssue = (sub) => {
+            this.issues = [...this.issues, sub];
+        };
+        this.addIssues = (subs = []) => {
+            this.issues = [...this.issues, ...subs];
+        };
+        const actualProto = new.target.prototype;
+        if (Object.setPrototypeOf) {
+            // eslint-disable-next-line ban/ban
+            Object.setPrototypeOf(this, actualProto);
+        }
+        else {
+            this.__proto__ = actualProto;
+        }
+        this.name = "ZodError";
+        this.issues = issues;
+    }
+    format(_mapper) {
+        const mapper = _mapper ||
+            function (issue) {
+                return issue.message;
+            };
+        const fieldErrors = { _errors: [] };
+        const processError = (error) => {
+            for (const issue of error.issues) {
+                if (issue.code === "invalid_union") {
+                    issue.unionErrors.map(processError);
+                }
+                else if (issue.code === "invalid_return_type") {
+                    processError(issue.returnTypeError);
+                }
+                else if (issue.code === "invalid_arguments") {
+                    processError(issue.argumentsError);
+                }
+                else if (issue.path.length === 0) {
+                    fieldErrors._errors.push(mapper(issue));
+                }
+                else {
+                    let curr = fieldErrors;
+                    let i = 0;
+                    while (i < issue.path.length) {
+                        const el = issue.path[i];
+                        const terminal = i === issue.path.length - 1;
+                        if (!terminal) {
+                            curr[el] = curr[el] || { _errors: [] };
+                            // if (typeof el === "string") {
+                            //   curr[el] = curr[el] || { _errors: [] };
+                            // } else if (typeof el === "number") {
+                            //   const errorArray: any = [];
+                            //   errorArray._errors = [];
+                            //   curr[el] = curr[el] || errorArray;
+                            // }
+                        }
+                        else {
+                            curr[el] = curr[el] || { _errors: [] };
+                            curr[el]._errors.push(mapper(issue));
+                        }
+                        curr = curr[el];
+                        i++;
+                    }
+                }
+            }
+        };
+        processError(this);
+        return fieldErrors;
+    }
+    static assert(value) {
+        if (!(value instanceof ZodError)) {
+            throw new Error(`Not a ZodError: ${value}`);
+        }
+    }
+    toString() {
+        return this.message;
+    }
+    get message() {
+        return JSON.stringify(this.issues, util_js_1.util.jsonStringifyReplacer, 2);
+    }
+    get isEmpty() {
+        return this.issues.length === 0;
+    }
+    flatten(mapper = (issue) => issue.message) {
+        const fieldErrors = {};
+        const formErrors = [];
+        for (const sub of this.issues) {
+            if (sub.path.length > 0) {
+                fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
+                fieldErrors[sub.path[0]].push(mapper(sub));
+            }
+            else {
+                formErrors.push(mapper(sub));
+            }
+        }
+        return { formErrors, fieldErrors };
+    }
+    get formErrors() {
+        return this.flatten();
+    }
+}
+exports.ZodError = ZodError;
+ZodError.create = (issues) => {
+    const error = new ZodError(issues);
+    return error;
+};

package/node_modules/zod/dist/cjs/v3/benchmarks/datetime.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const benchmark_1 = __importDefault(require("benchmark"));
+const datetimeValidationSuite = new benchmark_1.default.Suite("datetime");
+const DATA = "2021-01-01";
+const MONTHS_31 = new Set([1, 3, 5, 7, 8, 10, 12]);
+const MONTHS_30 = new Set([4, 6, 9, 11]);
+const simpleDatetimeRegex = /^(\d{4})-(\d{2})-(\d{2})$/;
+const datetimeRegexNoLeapYearValidation = /^\d{4}-((0[13578]|10|12)-31|(0[13-9]|1[0-2])-30|(0[1-9]|1[0-2])-(0[1-9]|1\d|2\d))$/;
+const datetimeRegexWithLeapYearValidation = /^((\d\d[2468][048]|\d\d[13579][26]|\d\d0[48]|[02468][048]00|[13579][26]00)-02-29|\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\d|3[01])|(0[469]|11)-(0[1-9]|[12]\d|30)|(02)-(0[1-9]|1\d|2[0-8])))$/;
+datetimeValidationSuite
+    .add("new Date()", () => {
+    return !Number.isNaN(new Date(DATA).getTime());
+})
+    .add("regex (no validation)", () => {
+    return simpleDatetimeRegex.test(DATA);
+})
+    .add("regex (no leap year)", () => {
+    return datetimeRegexNoLeapYearValidation.test(DATA);
+})
+    .add("regex (w/ leap year)", () => {
+    return datetimeRegexWithLeapYearValidation.test(DATA);
+})
+    .add("capture groups + code", () => {
+    const match = DATA.match(simpleDatetimeRegex);
+    if (!match)
+        return false;
+    // Extract year, month, and day from the capture groups
+    const year = Number.parseInt(match[1], 10);
+    const month = Number.parseInt(match[2], 10); // month is 0-indexed in JavaScript Date, so subtract 1
+    const day = Number.parseInt(match[3], 10);
+    if (month === 2) {
+        if ((year % 4 === 0 && year % 100 !== 0) || year % 400 === 0) {
+            return day <= 29;
+        }
+        return day <= 28;
+    }
+    if (MONTHS_30.has(month)) {
+        return day <= 30;
+    }
+    if (MONTHS_31.has(month)) {
+        return day <= 31;
+    }
+    return false;
+})
+    .on("cycle", (e) => {
+    console.log(`${datetimeValidationSuite.name}: ${e.target}`);
+});
+exports.default = {
+    suites: [datetimeValidationSuite],
+};

package/node_modules/zod/dist/cjs/v3/benchmarks/discriminatedUnion.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const benchmark_1 = __importDefault(require("benchmark"));
+const v3_1 = require("zod/v3");
+const doubleSuite = new benchmark_1.default.Suite("z.discriminatedUnion: double");
+const manySuite = new benchmark_1.default.Suite("z.discriminatedUnion: many");
+const aSchema = v3_1.z.object({
+    type: v3_1.z.literal("a"),
+});
+const objA = {
+    type: "a",
+};
+const bSchema = v3_1.z.object({
+    type: v3_1.z.literal("b"),
+});
+const objB = {
+    type: "b",
+};
+const cSchema = v3_1.z.object({
+    type: v3_1.z.literal("c"),
+});
+const objC = {
+    type: "c",
+};
+const dSchema = v3_1.z.object({
+    type: v3_1.z.literal("d"),
+});
+const double = v3_1.z.discriminatedUnion("type", [aSchema, bSchema]);
+const many = v3_1.z.discriminatedUnion("type", [aSchema, bSchema, cSchema, dSchema]);
+doubleSuite
+    .add("valid: a", () => {
+    double.parse(objA);
+})
+    .add("valid: b", () => {
+    double.parse(objB);
+})
+    .add("invalid: null", () => {
+    try {
+        double.parse(null);
+    }
+    catch (_err) { }
+})
+    .add("invalid: wrong shape", () => {
+    try {
+        double.parse(objC);
+    }
+    catch (_err) { }
+})
+    .on("cycle", (e) => {
+    console.log(`${doubleSuite.name}: ${e.target}`);
+});
+manySuite
+    .add("valid: a", () => {
+    many.parse(objA);
+})
+    .add("valid: c", () => {
+    many.parse(objC);
+})
+    .add("invalid: null", () => {
+    try {
+        many.parse(null);
+    }
+    catch (_err) { }
+})
+    .add("invalid: wrong shape", () => {
+    try {
+        many.parse({ type: "unknown" });
+    }
+    catch (_err) { }
+})
+    .on("cycle", (e) => {
+    console.log(`${manySuite.name}: ${e.target}`);
+});
+exports.default = {
+    suites: [doubleSuite, manySuite],
+};

package/node_modules/zod/dist/cjs/v3/benchmarks/index.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const datetime_js_1 = __importDefault(require("./datetime.js"));
+const discriminatedUnion_js_1 = __importDefault(require("./discriminatedUnion.js"));
+const ipv4_js_1 = __importDefault(require("./ipv4.js"));
+const object_js_1 = __importDefault(require("./object.js"));
+const primitives_js_1 = __importDefault(require("./primitives.js"));
+const realworld_js_1 = __importDefault(require("./realworld.js"));
+const string_js_1 = __importDefault(require("./string.js"));
+const union_js_1 = __importDefault(require("./union.js"));
+const argv = process.argv.slice(2);
+let suites = [];
+if (!argv.length) {
+    suites = [
+        ...realworld_js_1.default.suites,
+        ...primitives_js_1.default.suites,
+        ...string_js_1.default.suites,
+        ...object_js_1.default.suites,
+        ...union_js_1.default.suites,
+        ...discriminatedUnion_js_1.default.suites,
+    ];
+}
+else {
+    if (argv.includes("--realworld")) {
+        suites.push(...realworld_js_1.default.suites);
+    }
+    if (argv.includes("--primitives")) {
+        suites.push(...primitives_js_1.default.suites);
+    }
+    if (argv.includes("--string")) {
+        suites.push(...string_js_1.default.suites);
+    }
+    if (argv.includes("--object")) {
+        suites.push(...object_js_1.default.suites);
+    }
+    if (argv.includes("--union")) {
+        suites.push(...union_js_1.default.suites);
+    }
+    if (argv.includes("--discriminatedUnion")) {
+        suites.push(...datetime_js_1.default.suites);
+    }
+    if (argv.includes("--datetime")) {
+        suites.push(...datetime_js_1.default.suites);
+    }
+    if (argv.includes("--ipv4")) {
+        suites.push(...ipv4_js_1.default.suites);
+    }
+}
+for (const suite of suites) {
+    suite.run({});
+}
+// exit on Ctrl-C
+process.on("SIGINT", function () {
+    console.log("Exiting...");
+    process.exit();
+});

package/node_modules/zod/dist/cjs/v3/benchmarks/ipv4.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const benchmark_1 = __importDefault(require("benchmark"));
+const suite = new benchmark_1.default.Suite("ipv4");
+const DATA = "127.0.0.1";
+const ipv4RegexA = /^(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))$/;
+const ipv4RegexB = /^(?:(?:(?=(25[0-5]))\1|(?=(2[0-4][0-9]))\2|(?=(1[0-9]{2}))\3|(?=([0-9]{1,2}))\4)\.){3}(?:(?=(25[0-5]))\5|(?=(2[0-4][0-9]))\6|(?=(1[0-9]{2}))\7|(?=([0-9]{1,2}))\8)$/;
+const ipv4RegexC = /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/;
+const ipv4RegexD = /^(\b25[0-5]|\b2[0-4][0-9]|\b[01]?[0-9][0-9]?)(\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}$/;
+const ipv4RegexE = /^((25[0-5]|(2[0-4]|1\d|[1-9]|)\d)\.){3}(25[0-5]|(2[0-4]|1\d|[1-9]|)\d)$/;
+const ipv4RegexF = /^((25[0-5]|(2[0-4]|1\d|[1-9]|)\d)\.?\b){4}$/;
+const ipv4RegexG = /^((25[0-5]|(2[0-4]|1\d|[1-9]|)\d)(\.(?!$)|$)){4}$/;
+const ipv4RegexH = /^((25[0-5]|(2[0-4]|1[0-9]|[1-9]|)[0-9])(\.(?!$)|$)){4}$/;
+const ipv4RegexI = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
+suite
+    .add("A", () => {
+    return ipv4RegexA.test(DATA);
+})
+    .add("B", () => {
+    return ipv4RegexB.test(DATA);
+})
+    .add("C", () => {
+    return ipv4RegexC.test(DATA);
+})
+    .add("D", () => {
+    return ipv4RegexD.test(DATA);
+})
+    .add("E", () => {
+    return ipv4RegexE.test(DATA);
+})
+    .add("F", () => {
+    return ipv4RegexF.test(DATA);
+})
+    .add("G", () => {
+    return ipv4RegexG.test(DATA);
+})
+    .add("H", () => {
+    return ipv4RegexH.test(DATA);
+})
+    .add("I", () => {
+    return ipv4RegexI.test(DATA);
+})
+    .on("cycle", (e) => {
+    console.log(`${suite.name}: ${e.target}`);
+});
+exports.default = {
+    suites: [suite],
+};
+if (require.main === module) {
+    suite.run();
+}

package/node_modules/zod/dist/cjs/v3/benchmarks/object.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const benchmark_1 = __importDefault(require("benchmark"));
+const v3_1 = require("zod/v3");
+const emptySuite = new benchmark_1.default.Suite("z.object: empty");
+const shortSuite = new benchmark_1.default.Suite("z.object: short");
+const longSuite = new benchmark_1.default.Suite("z.object: long");
+const empty = v3_1.z.object({});
+const short = v3_1.z.object({
+    string: v3_1.z.string(),
+});
+const long = v3_1.z.object({
+    string: v3_1.z.string(),
+    number: v3_1.z.number(),
+    boolean: v3_1.z.boolean(),
+});
+emptySuite
+    .add("valid", () => {
+    empty.parse({});
+})
+    .add("valid: extra keys", () => {
+    empty.parse({ string: "string" });
+})
+    .add("invalid: null", () => {
+    try {
+        empty.parse(null);
+    }
+    catch (_err) { }
+})
+    .on("cycle", (e) => {
+    console.log(`${emptySuite.name}: ${e.target}`);
+});
+shortSuite
+    .add("valid", () => {
+    short.parse({ string: "string" });
+})
+    .add("valid: extra keys", () => {
+    short.parse({ string: "string", number: 42 });
+})
+    .add("invalid: null", () => {
+    try {
+        short.parse(null);
+    }
+    catch (_err) { }
+})
+    .on("cycle", (e) => {
+    console.log(`${shortSuite.name}: ${e.target}`);
+});
+longSuite
+    .add("valid", () => {
+    long.parse({ string: "string", number: 42, boolean: true });
+})
+    .add("valid: extra keys", () => {
+    long.parse({ string: "string", number: 42, boolean: true, list: [] });
+})
+    .add("invalid: null", () => {
+    try {
+        long.parse(null);
+    }
+    catch (_err) { }
+})
+    .on("cycle", (e) => {
+    console.log(`${longSuite.name}: ${e.target}`);
+});
+exports.default = {
+    suites: [emptySuite, shortSuite, longSuite],
+};