@wopee-io/wopee.wdio 4.0.0

package/node_modules/zod/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./lib";
+export as namespace Zod;

package/node_modules/zod/lib/ZodError.d.ts

@@ -0,0 +1,164 @@
+import type { TypeOf, ZodType } from ".";
+import { Primitive } from "./helpers/typeAliases";
+import { util, ZodParsedType } from "./helpers/util";
+declare type allKeys<T> = T extends any ? keyof T : never;
+export declare type inferFlattenedErrors<T extends ZodType<any, any, any>, U = string> = typeToFlattenedError<TypeOf<T>, U>;
+export declare type typeToFlattenedError<T, U = string> = {
+    formErrors: U[];
+    fieldErrors: {
+        [P in allKeys<T>]?: U[];
+    };
+};
+export declare const ZodIssueCode: {
+    invalid_type: "invalid_type";
+    invalid_literal: "invalid_literal";
+    custom: "custom";
+    invalid_union: "invalid_union";
+    invalid_union_discriminator: "invalid_union_discriminator";
+    invalid_enum_value: "invalid_enum_value";
+    unrecognized_keys: "unrecognized_keys";
+    invalid_arguments: "invalid_arguments";
+    invalid_return_type: "invalid_return_type";
+    invalid_date: "invalid_date";
+    invalid_string: "invalid_string";
+    too_small: "too_small";
+    too_big: "too_big";
+    invalid_intersection_types: "invalid_intersection_types";
+    not_multiple_of: "not_multiple_of";
+    not_finite: "not_finite";
+};
+export declare type ZodIssueCode = keyof typeof ZodIssueCode;
+export declare type ZodIssueBase = {
+    path: (string | number)[];
+    message?: string;
+};
+export interface ZodInvalidTypeIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_type;
+    expected: ZodParsedType;
+    received: ZodParsedType;
+}
+export interface ZodInvalidLiteralIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_literal;
+    expected: unknown;
+    received: unknown;
+}
+export interface ZodUnrecognizedKeysIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.unrecognized_keys;
+    keys: string[];
+}
+export interface ZodInvalidUnionIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_union;
+    unionErrors: ZodError[];
+}
+export interface ZodInvalidUnionDiscriminatorIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_union_discriminator;
+    options: Primitive[];
+}
+export interface ZodInvalidEnumValueIssue extends ZodIssueBase {
+    received: string | number;
+    code: typeof ZodIssueCode.invalid_enum_value;
+    options: (string | number)[];
+}
+export interface ZodInvalidArgumentsIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_arguments;
+    argumentsError: ZodError;
+}
+export interface ZodInvalidReturnTypeIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_return_type;
+    returnTypeError: ZodError;
+}
+export interface ZodInvalidDateIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_date;
+}
+export declare type StringValidation = "email" | "url" | "emoji" | "uuid" | "nanoid" | "regex" | "cuid" | "cuid2" | "ulid" | "datetime" | "date" | "time" | "duration" | "ip" | "base64" | {
+    includes: string;
+    position?: number;
+} | {
+    startsWith: string;
+} | {
+    endsWith: string;
+};
+export interface ZodInvalidStringIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_string;
+    validation: StringValidation;
+}
+export interface ZodTooSmallIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.too_small;
+    minimum: number | bigint;
+    inclusive: boolean;
+    exact?: boolean;
+    type: "array" | "string" | "number" | "set" | "date" | "bigint";
+}
+export interface ZodTooBigIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.too_big;
+    maximum: number | bigint;
+    inclusive: boolean;
+    exact?: boolean;
+    type: "array" | "string" | "number" | "set" | "date" | "bigint";
+}
+export interface ZodInvalidIntersectionTypesIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_intersection_types;
+}
+export interface ZodNotMultipleOfIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.not_multiple_of;
+    multipleOf: number | bigint;
+}
+export interface ZodNotFiniteIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.not_finite;
+}
+export interface ZodCustomIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.custom;
+    params?: {
+        [k: string]: any;
+    };
+}
+export declare type DenormalizedError = {
+    [k: string]: DenormalizedError | string[];
+};
+export declare type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodInvalidLiteralIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodNotFiniteIssue | ZodCustomIssue;
+export declare type ZodIssue = ZodIssueOptionalMessage & {
+    fatal?: boolean;
+    message: string;
+};
+export declare const quotelessJson: (obj: any) => string;
+declare type recursiveZodFormattedError<T> = T extends [any, ...any[]] ? {
+    [K in keyof T]?: ZodFormattedError<T[K]>;
+} : T extends any[] ? {
+    [k: number]: ZodFormattedError<T[number]>;
+} : T extends object ? {
+    [K in keyof T]?: ZodFormattedError<T[K]>;
+} : unknown;
+export declare type ZodFormattedError<T, U = string> = {
+    _errors: U[];
+} & recursiveZodFormattedError<NonNullable<T>>;
+export declare type inferFormattedError<T extends ZodType<any, any, any>, U = string> = ZodFormattedError<TypeOf<T>, U>;
+export declare class ZodError<T = any> extends Error {
+    issues: ZodIssue[];
+    get errors(): ZodIssue[];
+    constructor(issues: ZodIssue[]);
+    format(): ZodFormattedError<T>;
+    format<U>(mapper: (issue: ZodIssue) => U): ZodFormattedError<T, U>;
+    static create: (issues: ZodIssue[]) => ZodError<any>;
+    static assert(value: unknown): asserts value is ZodError;
+    toString(): string;
+    get message(): string;
+    get isEmpty(): boolean;
+    addIssue: (sub: ZodIssue) => void;
+    addIssues: (subs?: ZodIssue[]) => void;
+    flatten(): typeToFlattenedError<T>;
+    flatten<U>(mapper?: (issue: ZodIssue) => U): typeToFlattenedError<T, U>;
+    get formErrors(): typeToFlattenedError<T, string>;
+}
+declare type stripPath<T extends object> = T extends any ? util.OmitKeys<T, "path"> : never;
+export declare type IssueData = stripPath<ZodIssueOptionalMessage> & {
+    path?: (string | number)[];
+    fatal?: boolean;
+};
+export declare type ErrorMapCtx = {
+    defaultError: string;
+    data: any;
+};
+export declare type ZodErrorMap = (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
+    message: string;
+};
+export {};

package/node_modules/zod/lib/ZodError.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZodError = exports.quotelessJson = exports.ZodIssueCode = void 0;
+const util_1 = require("./helpers/util");
+exports.ZodIssueCode = util_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 {
+    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;
+    }
+    get errors() {
+        return this.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_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/lib/__tests__/Mocker.d.ts

@@ -0,0 +1,17 @@
+export declare class Mocker {
+    pick: (...args: any[]) => any;
+    get string(): string;
+    get number(): number;
+    get bigint(): bigint;
+    get boolean(): boolean;
+    get date(): Date;
+    get symbol(): symbol;
+    get null(): null;
+    get undefined(): undefined;
+    get stringOptional(): any;
+    get stringNullable(): any;
+    get numberOptional(): any;
+    get numberNullable(): any;
+    get booleanOptional(): any;
+    get booleanNullable(): any;
+}

package/node_modules/zod/lib/__tests__/Mocker.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Mocker = void 0;
+function getRandomInt(max) {
+    return Math.floor(Math.random() * Math.floor(max));
+}
+const testSymbol = Symbol("test");
+class Mocker {
+    constructor() {
+        this.pick = (...args) => {
+            return args[getRandomInt(args.length)];
+        };
+    }
+    get string() {
+        return Math.random().toString(36).substring(7);
+    }
+    get number() {
+        return Math.random() * 100;
+    }
+    get bigint() {
+        return BigInt(Math.floor(Math.random() * 10000));
+    }
+    get boolean() {
+        return Math.random() < 0.5;
+    }
+    get date() {
+        return new Date(Math.floor(Date.now() * Math.random()));
+    }
+    get symbol() {
+        return testSymbol;
+    }
+    get null() {
+        return null;
+    }
+    get undefined() {
+        return undefined;
+    }
+    get stringOptional() {
+        return this.pick(this.string, this.undefined);
+    }
+    get stringNullable() {
+        return this.pick(this.string, this.null);
+    }
+    get numberOptional() {
+        return this.pick(this.number, this.undefined);
+    }
+    get numberNullable() {
+        return this.pick(this.number, this.null);
+    }
+    get booleanOptional() {
+        return this.pick(this.boolean, this.undefined);
+    }
+    get booleanNullable() {
+        return this.pick(this.boolean, this.null);
+    }
+}
+exports.Mocker = Mocker;

package/node_modules/zod/lib/benchmarks/datetime.d.ts

@@ -0,0 +1,5 @@
+import Benchmark from "benchmark";
+declare const _default: {
+    suites: Benchmark.Suite[];
+};
+export default _default;

package/node_modules/zod/lib/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 !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/lib/benchmarks/discriminatedUnion.d.ts

@@ -0,0 +1,5 @@
+import Benchmark from "benchmark";
+declare const _default: {
+    suites: Benchmark.Suite[];
+};
+export default _default;

package/node_modules/zod/lib/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 index_1 = require("../index");
+const doubleSuite = new benchmark_1.default.Suite("z.discriminatedUnion: double");
+const manySuite = new benchmark_1.default.Suite("z.discriminatedUnion: many");
+const aSchema = index_1.z.object({
+    type: index_1.z.literal("a"),
+});
+const objA = {
+    type: "a",
+};
+const bSchema = index_1.z.object({
+    type: index_1.z.literal("b"),
+});
+const objB = {
+    type: "b",
+};
+const cSchema = index_1.z.object({
+    type: index_1.z.literal("c"),
+});
+const objC = {
+    type: "c",
+};
+const dSchema = index_1.z.object({
+    type: index_1.z.literal("d"),
+});
+const double = index_1.z.discriminatedUnion("type", [aSchema, bSchema]);
+const many = index_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/lib/benchmarks/index.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/zod/lib/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_1 = __importDefault(require("./datetime"));
+const discriminatedUnion_1 = __importDefault(require("./discriminatedUnion"));
+const ipv4_1 = __importDefault(require("./ipv4"));
+const object_1 = __importDefault(require("./object"));
+const primitives_1 = __importDefault(require("./primitives"));
+const realworld_1 = __importDefault(require("./realworld"));
+const string_1 = __importDefault(require("./string"));
+const union_1 = __importDefault(require("./union"));
+const argv = process.argv.slice(2);
+let suites = [];
+if (!argv.length) {
+    suites = [
+        ...realworld_1.default.suites,
+        ...primitives_1.default.suites,
+        ...string_1.default.suites,
+        ...object_1.default.suites,
+        ...union_1.default.suites,
+        ...discriminatedUnion_1.default.suites,
+    ];
+}
+else {
+    if (argv.includes("--realworld")) {
+        suites.push(...realworld_1.default.suites);
+    }
+    if (argv.includes("--primitives")) {
+        suites.push(...primitives_1.default.suites);
+    }
+    if (argv.includes("--string")) {
+        suites.push(...string_1.default.suites);
+    }
+    if (argv.includes("--object")) {
+        suites.push(...object_1.default.suites);
+    }
+    if (argv.includes("--union")) {
+        suites.push(...union_1.default.suites);
+    }
+    if (argv.includes("--discriminatedUnion")) {
+        suites.push(...datetime_1.default.suites);
+    }
+    if (argv.includes("--datetime")) {
+        suites.push(...datetime_1.default.suites);
+    }
+    if (argv.includes("--ipv4")) {
+        suites.push(...ipv4_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/lib/benchmarks/ipv4.d.ts

@@ -0,0 +1,5 @@
+import Benchmark from "benchmark";
+declare const _default: {
+    suites: Benchmark.Suite[];
+};
+export default _default;

package/node_modules/zod/lib/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/lib/benchmarks/object.d.ts

@@ -0,0 +1,5 @@
+import Benchmark from "benchmark";
+declare const _default: {
+    suites: Benchmark.Suite[];
+};
+export default _default;