@kya-os/cli 2.0.0 → 2.0.3

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

@@ -0,0 +1,159 @@
+"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 Mocker_js_1 = require("../tests/Mocker.js");
+const val = new Mocker_js_1.Mocker();
+const enumSuite = new benchmark_1.default.Suite("z.enum");
+const enumSchema = v3_1.z.enum(["a", "b", "c"]);
+enumSuite
+    .add("valid", () => {
+    enumSchema.parse("a");
+})
+    .add("invalid", () => {
+    try {
+        enumSchema.parse("x");
+    }
+    catch (_e) { }
+})
+    .on("cycle", (e) => {
+    console.log(`z.enum: ${e.target}`);
+});
+const longEnumSuite = new benchmark_1.default.Suite("long z.enum");
+const longEnumSchema = v3_1.z.enum([
+    "one",
+    "two",
+    "three",
+    "four",
+    "five",
+    "six",
+    "seven",
+    "eight",
+    "nine",
+    "ten",
+    "eleven",
+    "twelve",
+    "thirteen",
+    "fourteen",
+    "fifteen",
+    "sixteen",
+    "seventeen",
+]);
+longEnumSuite
+    .add("valid", () => {
+    longEnumSchema.parse("five");
+})
+    .add("invalid", () => {
+    try {
+        longEnumSchema.parse("invalid");
+    }
+    catch (_e) { }
+})
+    .on("cycle", (e) => {
+    console.log(`long z.enum: ${e.target}`);
+});
+const undefinedSuite = new benchmark_1.default.Suite("z.undefined");
+const undefinedSchema = v3_1.z.undefined();
+undefinedSuite
+    .add("valid", () => {
+    undefinedSchema.parse(undefined);
+})
+    .add("invalid", () => {
+    try {
+        undefinedSchema.parse(1);
+    }
+    catch (_e) { }
+})
+    .on("cycle", (e) => {
+    console.log(`z.undefined: ${e.target}`);
+});
+const literalSuite = new benchmark_1.default.Suite("z.literal");
+const short = "short";
+const bad = "bad";
+const literalSchema = v3_1.z.literal("short");
+literalSuite
+    .add("valid", () => {
+    literalSchema.parse(short);
+})
+    .add("invalid", () => {
+    try {
+        literalSchema.parse(bad);
+    }
+    catch (_e) { }
+})
+    .on("cycle", (e) => {
+    console.log(`z.literal: ${e.target}`);
+});
+const numberSuite = new benchmark_1.default.Suite("z.number");
+const numberSchema = v3_1.z.number().int();
+numberSuite
+    .add("valid", () => {
+    numberSchema.parse(1);
+})
+    .add("invalid type", () => {
+    try {
+        numberSchema.parse("bad");
+    }
+    catch (_e) { }
+})
+    .add("invalid number", () => {
+    try {
+        numberSchema.parse(0.5);
+    }
+    catch (_e) { }
+})
+    .on("cycle", (e) => {
+    console.log(`z.number: ${e.target}`);
+});
+const dateSuite = new benchmark_1.default.Suite("z.date");
+const plainDate = v3_1.z.date();
+const minMaxDate = v3_1.z.date().min(new Date("2021-01-01")).max(new Date("2030-01-01"));
+dateSuite
+    .add("valid", () => {
+    plainDate.parse(new Date());
+})
+    .add("invalid", () => {
+    try {
+        plainDate.parse(1);
+    }
+    catch (_e) { }
+})
+    .add("valid min and max", () => {
+    minMaxDate.parse(new Date("2023-01-01"));
+})
+    .add("invalid min", () => {
+    try {
+        minMaxDate.parse(new Date("2019-01-01"));
+    }
+    catch (_e) { }
+})
+    .add("invalid max", () => {
+    try {
+        minMaxDate.parse(new Date("2031-01-01"));
+    }
+    catch (_e) { }
+})
+    .on("cycle", (e) => {
+    console.log(`z.date: ${e.target}`);
+});
+const symbolSuite = new benchmark_1.default.Suite("z.symbol");
+const symbolSchema = v3_1.z.symbol();
+symbolSuite
+    .add("valid", () => {
+    symbolSchema.parse(val.symbol);
+})
+    .add("invalid", () => {
+    try {
+        symbolSchema.parse(1);
+    }
+    catch (_e) { }
+})
+    .on("cycle", (e) => {
+    console.log(`z.symbol: ${e.target}`);
+});
+exports.default = {
+    suites: [enumSuite, longEnumSuite, undefinedSuite, literalSuite, numberSuite, dateSuite, symbolSuite],
+};

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

@@ -0,0 +1,56 @@
+"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 shortSuite = new benchmark_1.default.Suite("realworld");
+const People = v3_1.z.array(v3_1.z.object({
+    type: v3_1.z.literal("person"),
+    hair: v3_1.z.enum(["blue", "brown"]),
+    active: v3_1.z.boolean(),
+    name: v3_1.z.string(),
+    age: v3_1.z.number().int(),
+    hobbies: v3_1.z.array(v3_1.z.string()),
+    address: v3_1.z.object({
+        street: v3_1.z.string(),
+        zip: v3_1.z.string(),
+        country: v3_1.z.string(),
+    }),
+}));
+let i = 0;
+function num() {
+    return ++i;
+}
+function str() {
+    return (++i % 100).toString(16);
+}
+function array(fn) {
+    return Array.from({ length: ++i % 10 }, () => fn());
+}
+const people = Array.from({ length: 100 }, () => {
+    return {
+        type: "person",
+        hair: i % 2 ? "blue" : "brown",
+        active: !!(i % 2),
+        name: str(),
+        age: num(),
+        hobbies: array(str),
+        address: {
+            street: str(),
+            zip: str(),
+            country: str(),
+        },
+    };
+});
+shortSuite
+    .add("valid", () => {
+    People.parse(people);
+})
+    .on("cycle", (e) => {
+    console.log(`${shortSuite.name}: ${e.target}`);
+});
+exports.default = {
+    suites: [shortSuite],
+};

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

@@ -0,0 +1,55 @@
+"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 SUITE_NAME = "z.string";
+const suite = new benchmark_1.default.Suite(SUITE_NAME);
+const empty = "";
+const short = "short";
+const long = "long".repeat(256);
+const manual = (str) => {
+    if (typeof str !== "string") {
+        throw new Error("Not a string");
+    }
+    return str;
+};
+const stringSchema = v3_1.z.string();
+const optionalStringSchema = v3_1.z.string().optional();
+const optionalNullableStringSchema = v3_1.z.string().optional().nullable();
+suite
+    .add("empty string", () => {
+    stringSchema.parse(empty);
+})
+    .add("short string", () => {
+    stringSchema.parse(short);
+})
+    .add("long string", () => {
+    stringSchema.parse(long);
+})
+    .add("optional string", () => {
+    optionalStringSchema.parse(long);
+})
+    .add("nullable string", () => {
+    optionalNullableStringSchema.parse(long);
+})
+    .add("nullable (null) string", () => {
+    optionalNullableStringSchema.parse(null);
+})
+    .add("invalid: null", () => {
+    try {
+        stringSchema.parse(null);
+    }
+    catch (_err) { }
+})
+    .add("manual parser: long", () => {
+    manual(long);
+})
+    .on("cycle", (e) => {
+    console.log(`${SUITE_NAME}: ${e.target}`);
+});
+exports.default = {
+    suites: [suite],
+};

package/node_modules/zod/dist/cjs/v3/benchmarks/union.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.union: double");
+const manySuite = new benchmark_1.default.Suite("z.union: 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.union([aSchema, bSchema]);
+const many = v3_1.z.union([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/errors.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultErrorMap = void 0;
+exports.setErrorMap = setErrorMap;
+exports.getErrorMap = getErrorMap;
+const en_js_1 = __importDefault(require("./locales/en.js"));
+exports.defaultErrorMap = en_js_1.default;
+let overrideErrorMap = en_js_1.default;
+function setErrorMap(map) {
+    overrideErrorMap = map;
+}
+function getErrorMap() {
+    return overrideErrorMap;
+}

package/node_modules/zod/dist/cjs/v3/external.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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./errors.js"), exports);
+__exportStar(require("./helpers/parseUtil.js"), exports);
+__exportStar(require("./helpers/typeAliases.js"), exports);
+__exportStar(require("./helpers/util.js"), exports);
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./ZodError.js"), exports);

package/node_modules/zod/dist/cjs/v3/helpers/enumUtil.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/node_modules/zod/dist/cjs/v3/helpers/errorUtil.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorUtil = void 0;
+var errorUtil;
+(function (errorUtil) {
+    errorUtil.errToObj = (message) => typeof message === "string" ? { message } : message || {};
+    // biome-ignore lint:
+    errorUtil.toString = (message) => typeof message === "string" ? message : message?.message;
+})(errorUtil || (exports.errorUtil = errorUtil = {}));

package/node_modules/zod/dist/cjs/v3/helpers/parseUtil.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAsync = exports.isValid = exports.isDirty = exports.isAborted = exports.OK = exports.DIRTY = exports.INVALID = exports.ParseStatus = exports.EMPTY_PATH = exports.makeIssue = void 0;
+exports.addIssueToContext = addIssueToContext;
+const errors_js_1 = require("../errors.js");
+const en_js_1 = __importDefault(require("../locales/en.js"));
+const makeIssue = (params) => {
+    const { data, path, errorMaps, issueData } = params;
+    const fullPath = [...path, ...(issueData.path || [])];
+    const fullIssue = {
+        ...issueData,
+        path: fullPath,
+    };
+    if (issueData.message !== undefined) {
+        return {
+            ...issueData,
+            path: fullPath,
+            message: issueData.message,
+        };
+    }
+    let errorMessage = "";
+    const maps = errorMaps
+        .filter((m) => !!m)
+        .slice()
+        .reverse();
+    for (const map of maps) {
+        errorMessage = map(fullIssue, { data, defaultError: errorMessage }).message;
+    }
+    return {
+        ...issueData,
+        path: fullPath,
+        message: errorMessage,
+    };
+};
+exports.makeIssue = makeIssue;
+exports.EMPTY_PATH = [];
+function addIssueToContext(ctx, issueData) {
+    const overrideMap = (0, errors_js_1.getErrorMap)();
+    const issue = (0, exports.makeIssue)({
+        issueData: issueData,
+        data: ctx.data,
+        path: ctx.path,
+        errorMaps: [
+            ctx.common.contextualErrorMap, // contextual error map is first priority
+            ctx.schemaErrorMap, // then schema-bound map if available
+            overrideMap, // then global override map
+            overrideMap === en_js_1.default ? undefined : en_js_1.default, // then global default map
+        ].filter((x) => !!x),
+    });
+    ctx.common.issues.push(issue);
+}
+class ParseStatus {
+    constructor() {
+        this.value = "valid";
+    }
+    dirty() {
+        if (this.value === "valid")
+            this.value = "dirty";
+    }
+    abort() {
+        if (this.value !== "aborted")
+            this.value = "aborted";
+    }
+    static mergeArray(status, results) {
+        const arrayValue = [];
+        for (const s of results) {
+            if (s.status === "aborted")
+                return exports.INVALID;
+            if (s.status === "dirty")
+                status.dirty();
+            arrayValue.push(s.value);
+        }
+        return { status: status.value, value: arrayValue };
+    }
+    static async mergeObjectAsync(status, pairs) {
+        const syncPairs = [];
+        for (const pair of pairs) {
+            const key = await pair.key;
+            const value = await pair.value;
+            syncPairs.push({
+                key,
+                value,
+            });
+        }
+        return ParseStatus.mergeObjectSync(status, syncPairs);
+    }
+    static mergeObjectSync(status, pairs) {
+        const finalObject = {};
+        for (const pair of pairs) {
+            const { key, value } = pair;
+            if (key.status === "aborted")
+                return exports.INVALID;
+            if (value.status === "aborted")
+                return exports.INVALID;
+            if (key.status === "dirty")
+                status.dirty();
+            if (value.status === "dirty")
+                status.dirty();
+            if (key.value !== "__proto__" && (typeof value.value !== "undefined" || pair.alwaysSet)) {
+                finalObject[key.value] = value.value;
+            }
+        }
+        return { status: status.value, value: finalObject };
+    }
+}
+exports.ParseStatus = ParseStatus;
+exports.INVALID = Object.freeze({
+    status: "aborted",
+});
+const DIRTY = (value) => ({ status: "dirty", value });
+exports.DIRTY = DIRTY;
+const OK = (value) => ({ status: "valid", value });
+exports.OK = OK;
+const isAborted = (x) => x.status === "aborted";
+exports.isAborted = isAborted;
+const isDirty = (x) => x.status === "dirty";
+exports.isDirty = isDirty;
+const isValid = (x) => x.status === "valid";
+exports.isValid = isValid;
+const isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;
+exports.isAsync = isAsync;

package/node_modules/zod/dist/cjs/v3/helpers/partialUtil.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/node_modules/zod/dist/cjs/v3/helpers/typeAliases.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/node_modules/zod/dist/cjs/v3/helpers/util.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getParsedType = exports.ZodParsedType = exports.objectUtil = exports.util = void 0;
+var util;
+(function (util) {
+    util.assertEqual = (_) => { };
+    function assertIs(_arg) { }
+    util.assertIs = assertIs;
+    function assertNever(_x) {
+        throw new Error();
+    }
+    util.assertNever = assertNever;
+    util.arrayToEnum = (items) => {
+        const obj = {};
+        for (const item of items) {
+            obj[item] = item;
+        }
+        return obj;
+    };
+    util.getValidEnumValues = (obj) => {
+        const validKeys = util.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
+        const filtered = {};
+        for (const k of validKeys) {
+            filtered[k] = obj[k];
+        }
+        return util.objectValues(filtered);
+    };
+    util.objectValues = (obj) => {
+        return util.objectKeys(obj).map(function (e) {
+            return obj[e];
+        });
+    };
+    util.objectKeys = typeof Object.keys === "function" // eslint-disable-line ban/ban
+        ? (obj) => Object.keys(obj) // eslint-disable-line ban/ban
+        : (object) => {
+            const keys = [];
+            for (const key in object) {
+                if (Object.prototype.hasOwnProperty.call(object, key)) {
+                    keys.push(key);
+                }
+            }
+            return keys;
+        };
+    util.find = (arr, checker) => {
+        for (const item of arr) {
+            if (checker(item))
+                return item;
+        }
+        return undefined;
+    };
+    util.isInteger = typeof Number.isInteger === "function"
+        ? (val) => Number.isInteger(val) // eslint-disable-line ban/ban
+        : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val;
+    function joinValues(array, separator = " | ") {
+        return array.map((val) => (typeof val === "string" ? `'${val}'` : val)).join(separator);
+    }
+    util.joinValues = joinValues;
+    util.jsonStringifyReplacer = (_, value) => {
+        if (typeof value === "bigint") {
+            return value.toString();
+        }
+        return value;
+    };
+})(util || (exports.util = util = {}));
+var objectUtil;
+(function (objectUtil) {
+    objectUtil.mergeShapes = (first, second) => {
+        return {
+            ...first,
+            ...second, // second overwrites first
+        };
+    };
+})(objectUtil || (exports.objectUtil = objectUtil = {}));
+exports.ZodParsedType = util.arrayToEnum([
+    "string",
+    "nan",
+    "number",
+    "integer",
+    "float",
+    "boolean",
+    "date",
+    "bigint",
+    "symbol",
+    "function",
+    "undefined",
+    "null",
+    "array",
+    "object",
+    "unknown",
+    "promise",
+    "void",
+    "never",
+    "map",
+    "set",
+]);
+const getParsedType = (data) => {
+    const t = typeof data;
+    switch (t) {
+        case "undefined":
+            return exports.ZodParsedType.undefined;
+        case "string":
+            return exports.ZodParsedType.string;
+        case "number":
+            return Number.isNaN(data) ? exports.ZodParsedType.nan : exports.ZodParsedType.number;
+        case "boolean":
+            return exports.ZodParsedType.boolean;
+        case "function":
+            return exports.ZodParsedType.function;
+        case "bigint":
+            return exports.ZodParsedType.bigint;
+        case "symbol":
+            return exports.ZodParsedType.symbol;
+        case "object":
+            if (Array.isArray(data)) {
+                return exports.ZodParsedType.array;
+            }
+            if (data === null) {
+                return exports.ZodParsedType.null;
+            }
+            if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
+                return exports.ZodParsedType.promise;
+            }
+            if (typeof Map !== "undefined" && data instanceof Map) {
+                return exports.ZodParsedType.map;
+            }
+            if (typeof Set !== "undefined" && data instanceof Set) {
+                return exports.ZodParsedType.set;
+            }
+            if (typeof Date !== "undefined" && data instanceof Date) {
+                return exports.ZodParsedType.date;
+            }
+            return exports.ZodParsedType.object;
+        default:
+            return exports.ZodParsedType.unknown;
+    }
+};
+exports.getParsedType = getParsedType;