@rho-workspace/rho 0.5.2 → 0.5.3

package/node_modules/zod/README.md

@@ -1,218 +0,0 @@
-<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%3Amain"><img src="https://github.com/colinhacks/zod/actions/workflows/test.yml/badge.svg?event=push&branch=main" 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/>
-
-### [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 * as z from "zod";
-
-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 * as z from "zod";
-
-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](https://zod.dev/api#refinements) or [transforms](https://zod.dev/api#transforms), 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"
-```
-
-### AOT compilation
-
-For hot validation paths, `z.compile(schema)` returns a schema clone with an ahead-of-time compiled fast path. Valid inputs take the compiled path; invalid inputs fall back to the regular parser so error reporting stays identical.
-
-Across a 55-schema benchmark the median speedup is **2.4x**, and it scales with how much work the schema does per parse: a large array of objects is ~9x, a 20-key object ~9x, a nested object ~4.5x, while a bare `z.string()` gains nothing — compilation removes per-node dispatch and allocation, and a single `typeof` has none to remove.
-
-```ts
-const CompiledPlayer = z.compile(Player);
-
-CompiledPlayer.parse({ username: "billie", xp: 100 });
-```
-
-To enable compilation globally for schemas constructed after import:
-
-```ts
-import "zod/compile"; // place before modules that define schemas
-```
-
-Things to know:
-
-- Compilation uses `new Function`. Global mode is automatically disabled when `z.config({ jitless: true })` is set (e.g. CSP environments); calling `z.compile()` directly is an explicit opt-in.
-- Schemas with async refinements or transforms can't be compiled, and neither can a few other constructs. That is not an error: `z.compile()` hands the schema back unchanged and it keeps using the regular parser, exactly as global mode leaves it. Pass `{ strict: true }` to throw `ZodCompileAsyncError` / `ZodCompileUnsupportedError` instead.
-- On invalid input, refinements and transforms may run twice (fast path, then fallback).
-- Deriving a new schema from a compiled one (`.refine()`, `.extend()`, etc.) returns an uncompiled schema — compile the final schema.
-
-See [`compile` docs](https://zod.dev/compile) for details.
-
-### 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, received number'
-      },
-      {
-        expected: 'number',
-        code: 'invalid_type',
-        path: [ 'xp' ],
-        message: 'Invalid input: expected number, received string'
-      }
-    ] */
-  }
-}
-```
-
-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](https://zod.dev/api#refinements) or [transforms](https://zod.dev/api#transforms), 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/src/compile.ts

@@ -1,56 +0,0 @@
-// Side-effect-only: installs the post-processor on `globalConfig`. Listed in `package.json`'s `sideEffects`, and nothing else references it, so apps that never import it drop the compiler.
-//
-// Usage:
-//
-//   import "zod/compile";
-//   import * as z from "zod";
-//   // every schema constructed below this is compiled on first parse
-//
-// Module evaluation order matters: schemas constructed in modules that evaluate before this import will not be compiled. Place this import in the app entry point, before any module that constructs schemas at top level.
-//
-// Failure handling: if the compiler refuses a schema (async refinement, unsupported feature, etc.) the shim permanently restores the runtime `_zod.run` for that schema. The schema continues to work via the regular runtime parser — no observable difference to the caller.
-
-import { compile } from "./v4/core/compile.js";
-import * as core from "./v4/core/index.js";
-
-let compiling = false;
-
-core.globalConfig.postProcessor = (inst: any) => {
-  if (compiling) return;
-  const originalRun = inst._zod?.run;
-  if (typeof originalRun !== "function") return;
-
-  const shim = (payload: any, ctx: any): any => {
-    // Bypass the fast path for any non-forward / non-sync / check-skipping call. The runtime owns those contracts.
-    if (ctx?.async || ctx?.direction === "backward" || ctx?.skipChecks) {
-      return originalRun(payload, ctx);
-    }
-
-    compiling = true;
-    try {
-      // Respect the jitless config: it exists precisely so CSP/no-eval environments never reach `new Function`. Global mode must not bypass it (explicit z.compile calls remain an explicit opt-in).
-      if (core.globalConfig.jitless) {
-        inst._zod.run = originalRun;
-        return originalRun(payload, ctx);
-      }
-      // Strict: the shim owns its own fallback below, and a non-strict compile would hand back `inst` — whose run is this shim — and reinstall it on itself.
-      const compiled = compile(inst, { strict: true });
-      // Only the run wrapper. Copying the compiled parse/safeParse closures would make their fallback re-enter this instance and run user callbacks a third time.
-      inst._zod.run = compiled._zod.run;
-      inst._zod.bag.fallbackRun = compiled._zod.bag.fallbackRun;
-      inst._zod.bag.validator = compiled._zod.bag.validator;
-    } catch {
-      // Permanent fallback for unsupported schemas.
-      inst._zod.run = originalRun;
-    } finally {
-      compiling = false;
-    }
-
-    return inst._zod.run(payload, ctx);
-  };
-
-  // Expose the pre-shim runtime so `compile()` invoked elsewhere can unwrap past the shim and capture the source-of-truth runtime. Without this, a user calling `z.compile(s)` after global mode is enabled would capture the shim itself, which would feed the wrapper into itself on fallback.
-  (shim as any).__originalRun = originalRun;
-
-  inst._zod.run = shim;
-};

package/node_modules/zod/src/index.ts

@@ -1,7 +0,0 @@
-import * as z from "./v4/classic/external.js";
-export * from "./v4/classic/external.js";
-// Aliasing the binding, instead of `export default z`, keeps the default export a
-// re-export of `z` rather than a fresh namespace value. Rollup and Webpack can then
-// shake `import z from "zod"` as they already shake `import { z } from "zod"` — without
-// this they pull in every locale. See #6050.
-export { z, z as default };

package/node_modules/zod/src/locales/index.ts

@@ -1 +0,0 @@
-export * from "../v4/locales/index.js";

package/node_modules/zod/src/mini/index.ts

@@ -1,3 +0,0 @@
-import * as z from "../v4/mini/external.js";
-export * from "../v4/mini/external.js";
-export { z };

package/node_modules/zod/src/v3/ZodError.ts

@@ -1,340 +0,0 @@
-import type { Primitive } from "./helpers/typeAliases.js";
-import { util, type ZodParsedType } from "./helpers/util.js";
-import type { TypeOf, ZodType } from "./index.js";
-
-type allKeys<T> = T extends any ? keyof T : never;
-
-export type inferFlattenedErrors<T extends ZodType<any, any, any>, U = string> = typeToFlattenedError<TypeOf<T>, U>;
-export type typeToFlattenedError<T, U = string> = {
-  formErrors: U[];
-  fieldErrors: {
-    [P in allKeys<T>]?: U[];
-  };
-};
-
-export const ZodIssueCode = 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",
-]);
-
-export type ZodIssueCode = keyof typeof ZodIssueCode;
-
-export type ZodIssueBase = {
-  path: (string | number)[];
-  message?: string | undefined;
-};
-
-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 type StringValidation =
-  | "email"
-  | "url"
-  | "emoji"
-  | "uuid"
-  | "nanoid"
-  | "regex"
-  | "cuid"
-  | "cuid2"
-  | "ulid"
-  | "datetime"
-  | "date"
-  | "time"
-  | "duration"
-  | "ip"
-  | "cidr"
-  | "base64"
-  | "jwt"
-  | "base64url"
-  | { includes: string; position?: number | undefined }
-  | { 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 type DenormalizedError = { [k: string]: DenormalizedError | string[] };
-
-export type ZodIssueOptionalMessage =
-  | ZodInvalidTypeIssue
-  | ZodInvalidLiteralIssue
-  | ZodUnrecognizedKeysIssue
-  | ZodInvalidUnionIssue
-  | ZodInvalidUnionDiscriminatorIssue
-  | ZodInvalidEnumValueIssue
-  | ZodInvalidArgumentsIssue
-  | ZodInvalidReturnTypeIssue
-  | ZodInvalidDateIssue
-  | ZodInvalidStringIssue
-  | ZodTooSmallIssue
-  | ZodTooBigIssue
-  | ZodInvalidIntersectionTypesIssue
-  | ZodNotMultipleOfIssue
-  | ZodNotFiniteIssue
-  | ZodCustomIssue;
-
-export type ZodIssue = ZodIssueOptionalMessage & {
-  fatal?: boolean | undefined;
-  message: string;
-};
-
-export const quotelessJson = (obj: any) => {
-  const json = JSON.stringify(obj, null, 2);
-  return json.replace(/"([^"]+)":/g, "$1:");
-};
-
-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 type ZodFormattedError<T, U = string> = {
-  _errors: U[];
-} & recursiveZodFormattedError<NonNullable<T>>;
-
-export type inferFormattedError<T extends ZodType<any, any, any>, U = string> = ZodFormattedError<TypeOf<T>, U>;
-
-export class ZodError<T = any> extends Error {
-  issues: ZodIssue[] = [];
-
-  get errors() {
-    return this.issues;
-  }
-
-  constructor(issues: ZodIssue[]) {
-    super();
-
-    const actualProto = new.target.prototype;
-    if (Object.setPrototypeOf) {
-      // eslint-disable-next-line ban/ban
-      Object.setPrototypeOf(this, actualProto);
-    } else {
-      (this as any).__proto__ = actualProto;
-    }
-    this.name = "ZodError";
-    this.issues = issues;
-  }
-
-  format(): ZodFormattedError<T>;
-  format<U>(mapper: (issue: ZodIssue) => U): ZodFormattedError<T, U>;
-  format(_mapper?: any) {
-    const mapper: (issue: ZodIssue) => any =
-      _mapper ||
-      function (issue: ZodIssue) {
-        return issue.message;
-      };
-    const fieldErrors: ZodFormattedError<T> = { _errors: [] } as any;
-    const processError = (error: ZodError) => {
-      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 as any)._errors.push(mapper(issue));
-        } else {
-          let curr: any = fieldErrors;
-          let i = 0;
-          while (i < issue.path.length) {
-            const el = issue.path[i]!;
-            const terminal = i === issue.path.length - 1;
-
-            // `_errors` is reserved by this legacy format, so merge a matching path segment into the current node instead of treating its array as a child.
-            if (el === "_errors") {
-              if (terminal) curr._errors.push(mapper(issue));
-              i++;
-              continue;
-            }
-
-            // Create `el` as an own data property. A segment naming an inherited member ("toString", "constructor") would otherwise read through to the prototype, and assigning "__proto__" would hit the setter and walk into Object.prototype.
-            if (!Object.prototype.hasOwnProperty.call(curr, el)) {
-              if (el === "__proto__") {
-                Object.defineProperty(curr, el, {
-                  value: { _errors: [] },
-                  writable: true,
-                  enumerable: true,
-                  configurable: true,
-                });
-              } else {
-                curr[el] = { _errors: [] };
-              }
-            }
-
-            curr = curr[el];
-            if (terminal) {
-              curr._errors.push(mapper(issue));
-            }
-            i++;
-          }
-        }
-      }
-    };
-
-    processError(this);
-    return fieldErrors;
-  }
-
-  static create = (issues: ZodIssue[]) => {
-    const error = new ZodError(issues);
-    return error;
-  };
-
-  static assert(value: unknown): asserts value is ZodError {
-    if (!(value instanceof ZodError)) {
-      throw new Error(`Not a ZodError: ${value}`);
-    }
-  }
-
-  override toString() {
-    return this.message;
-  }
-  override get message() {
-    return JSON.stringify(this.issues, util.jsonStringifyReplacer, 2);
-  }
-
-  get isEmpty(): boolean {
-    return this.issues.length === 0;
-  }
-
-  addIssue = (sub: ZodIssue) => {
-    this.issues = [...this.issues, sub];
-  };
-
-  addIssues = (subs: ZodIssue[] = []) => {
-    this.issues = [...this.issues, ...subs];
-  };
-
-  flatten(): typeToFlattenedError<T>;
-  flatten<U>(mapper?: (issue: ZodIssue) => U): typeToFlattenedError<T, U>;
-  flatten<U = string>(mapper: (issue: ZodIssue) => U = (issue: ZodIssue) => issue.message as any): any {
-    const fieldErrors: any = Object.create(null);
-    const formErrors: U[] = [];
-    for (const sub of this.issues) {
-      if (sub.path.length > 0) {
-        const firstEl = sub.path[0]!;
-        fieldErrors[firstEl] = fieldErrors[firstEl] || [];
-        fieldErrors[firstEl].push(mapper(sub));
-      } else {
-        formErrors.push(mapper(sub));
-      }
-    }
-    return { formErrors, fieldErrors };
-  }
-
-  get formErrors() {
-    return this.flatten();
-  }
-}
-
-type stripPath<T extends object> = T extends any ? util.OmitKeys<T, "path"> : never;
-
-export type IssueData = stripPath<ZodIssueOptionalMessage> & {
-  path?: (string | number)[];
-  fatal?: boolean | undefined;
-};
-
-export type ErrorMapCtx = {
-  defaultError: string;
-  data: any;
-};
-
-export type ZodErrorMap = (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => { message: string };

package/node_modules/zod/src/v3/benchmarks/datetime.ts

@@ -1,58 +0,0 @@
-import Benchmark from "benchmark";
-
-const datetimeValidationSuite = new Benchmark.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: Benchmark.Event) => {
-    console.log(`${datetimeValidationSuite.name!}: ${e.target}`);
-  });
-
-export default {
-  suites: [datetimeValidationSuite],
-};