@auto-ai/agent 2.1.104 → 2.1.106

package/tools-runtime/code-tool/node_modules/zod/src/v4/classic/tests/index.test.ts

@@ -1,939 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/v4";
-import type { util } from "zod/v4/core";
-
-test("z.boolean", () => {
-  const a = z.boolean();
-  expect(z.parse(a, true)).toEqual(true);
-  expect(z.parse(a, false)).toEqual(false);
-  expect(() => z.parse(a, 123)).toThrow();
-  expect(() => z.parse(a, "true")).toThrow();
-  type a = z.output<typeof a>;
-  expectTypeOf<a>().toEqualTypeOf<boolean>();
-});
-
-test("z.bigint", () => {
-  const a = z.bigint();
-  expect(z.parse(a, BigInt(123))).toEqual(BigInt(123));
-  expect(() => z.parse(a, 123)).toThrow();
-  expect(() => z.parse(a, "123")).toThrow();
-});
-
-test("z.symbol", () => {
-  const a = z.symbol();
-  const sym = Symbol();
-  expect(z.parse(a, sym)).toEqual(sym);
-  expect(() => z.parse(a, "symbol")).toThrow();
-});
-
-test("z.date", () => {
-  const a = z.date();
-  const date = new Date();
-  expect(z.parse(a, date)).toEqual(date);
-  expect(() => z.parse(a, "date")).toThrow();
-});
-
-test("z.coerce.string", () => {
-  const a = z.coerce.string();
-  expect(z.parse(a, 123)).toEqual("123");
-  expect(z.parse(a, true)).toEqual("true");
-  expect(z.parse(a, null)).toEqual("null");
-  expect(z.parse(a, undefined)).toEqual("undefined");
-});
-
-test("z.coerce.number", () => {
-  const a = z.coerce.number();
-  expect(z.parse(a, "123")).toEqual(123);
-  expect(z.parse(a, "123.45")).toEqual(123.45);
-  expect(z.parse(a, true)).toEqual(1);
-  expect(z.parse(a, false)).toEqual(0);
-  expect(() => z.parse(a, "abc")).toThrow();
-});
-
-test("z.coerce.boolean", () => {
-  const a = z.coerce.boolean();
-  // test booleans
-  expect(z.parse(a, true)).toEqual(true);
-  expect(z.parse(a, false)).toEqual(false);
-  expect(z.parse(a, "true")).toEqual(true);
-  expect(z.parse(a, "false")).toEqual(true);
-  expect(z.parse(a, 1)).toEqual(true);
-  expect(z.parse(a, 0)).toEqual(false);
-  expect(z.parse(a, {})).toEqual(true);
-  expect(z.parse(a, [])).toEqual(true);
-  expect(z.parse(a, undefined)).toEqual(false);
-  expect(z.parse(a, null)).toEqual(false);
-  expect(z.parse(a, "")).toEqual(false);
-});
-
-test("z.coerce.bigint", () => {
-  const a = z.coerce.bigint();
-  expect(z.parse(a, "123")).toEqual(BigInt(123));
-  expect(z.parse(a, 123)).toEqual(BigInt(123));
-  expect(() => z.parse(a, "abc")).toThrow();
-});
-
-test("z.coerce.date", () => {
-  const a = z.coerce.date();
-  const date = new Date();
-  expect(z.parse(a, date.toISOString())).toEqual(date);
-  expect(z.parse(a, date.getTime())).toEqual(date);
-  expect(() => z.parse(a, "invalid date")).toThrow();
-});
-
-test("z.iso.datetime", () => {
-  const d1 = "2021-01-01T00:00:00Z";
-  const d2 = "2021-01-01T00:00:00.123Z";
-  const d3 = "2021-01-01T00:00:00";
-  const d4 = "2021-01-01T00:00:00+07:00";
-  const d5 = "bad data";
-
-  // local: false, offset: false, precision: null
-  const a = z.iso.datetime();
-  expect(z.safeParse(a, d1).success).toEqual(true);
-  expect(z.safeParse(a, d2).success).toEqual(true);
-  expect(z.safeParse(a, d3).success).toEqual(false);
-  expect(z.safeParse(a, d4).success).toEqual(false);
-  expect(z.safeParse(a, d5).success).toEqual(false);
-
-  const b = z.iso.datetime({ local: true });
-  expect(z.safeParse(b, d1).success).toEqual(true);
-  expect(z.safeParse(b, d2).success).toEqual(true);
-  expect(z.safeParse(b, d3).success).toEqual(true);
-  expect(z.safeParse(b, d4).success).toEqual(false);
-  expect(z.safeParse(b, d5).success).toEqual(false);
-
-  const c = z.iso.datetime({ offset: true });
-  expect(z.safeParse(c, d1).success).toEqual(true);
-  expect(z.safeParse(c, d2).success).toEqual(true);
-  expect(z.safeParse(c, d3).success).toEqual(false);
-  expect(z.safeParse(c, d4).success).toEqual(true);
-  expect(z.safeParse(c, d5).success).toEqual(false);
-
-  const d = z.iso.datetime({ precision: 3 });
-  expect(z.safeParse(d, d1).success).toEqual(false);
-  expect(z.safeParse(d, d2).success).toEqual(true);
-  expect(z.safeParse(d, d3).success).toEqual(false);
-  expect(z.safeParse(d, d4).success).toEqual(false);
-  expect(z.safeParse(d, d5).success).toEqual(false);
-});
-
-test("z.iso.date", () => {
-  const d1 = "2021-01-01";
-  const d2 = "bad data";
-
-  const a = z.iso.date();
-  expect(z.safeParse(a, d1).success).toEqual(true);
-  expect(z.safeParse(a, d2).success).toEqual(false);
-
-  const b = z.string().check(z.iso.date());
-  expect(z.safeParse(b, d1).success).toEqual(true);
-  expect(z.safeParse(b, d2).success).toEqual(false);
-});
-
-test("z.iso.time", () => {
-  const d1 = "00:00:00";
-  const d2 = "00:00:00.123";
-  const d3 = "bad data";
-
-  const a = z.iso.time();
-  expect(z.safeParse(a, d1).success).toEqual(true);
-  expect(z.safeParse(a, d2).success).toEqual(true);
-  expect(z.safeParse(a, d3).success).toEqual(false);
-
-  const b = z.iso.time({ precision: 3 });
-  expect(z.safeParse(b, d1).success).toEqual(false);
-  expect(z.safeParse(b, d2).success).toEqual(true);
-  expect(z.safeParse(b, d3).success).toEqual(false);
-
-  const c = z.string().check(z.iso.time());
-  expect(z.safeParse(c, d1).success).toEqual(true);
-  expect(z.safeParse(c, d2).success).toEqual(true);
-  expect(z.safeParse(c, d3).success).toEqual(false);
-});
-
-test("z.iso.duration", () => {
-  const d1 = "P3Y6M4DT12H30M5S";
-  const d2 = "bad data";
-
-  const a = z.iso.duration();
-  expect(z.safeParse(a, d1).success).toEqual(true);
-  expect(z.safeParse(a, d2).success).toEqual(false);
-
-  const b = z.string().check(z.iso.duration());
-  expect(z.safeParse(b, d1).success).toEqual(true);
-  expect(z.safeParse(b, d2).success).toEqual(false);
-});
-
-test("z.undefined", () => {
-  const a = z.undefined();
-  expect(z.parse(a, undefined)).toEqual(undefined);
-  expect(() => z.parse(a, "undefined")).toThrow();
-});
-
-test("z.null", () => {
-  const a = z.null();
-  expect(z.parse(a, null)).toEqual(null);
-  expect(() => z.parse(a, "null")).toThrow();
-});
-
-test("z.any", () => {
-  const a = z.any();
-  expect(z.parse(a, "hello")).toEqual("hello");
-  expect(z.parse(a, 123)).toEqual(123);
-  expect(z.parse(a, true)).toEqual(true);
-  expect(z.parse(a, null)).toEqual(null);
-  expect(z.parse(a, undefined)).toEqual(undefined);
-  z.parse(a, {});
-  z.parse(a, []);
-  z.parse(a, Symbol());
-  z.parse(a, new Date());
-});
-
-test("z.unknown", () => {
-  const a = z.unknown();
-  expect(z.parse(a, "hello")).toEqual("hello");
-  expect(z.parse(a, 123)).toEqual(123);
-  expect(z.parse(a, true)).toEqual(true);
-  expect(z.parse(a, null)).toEqual(null);
-  expect(z.parse(a, undefined)).toEqual(undefined);
-  z.parse(a, {});
-  z.parse(a, []);
-  z.parse(a, Symbol());
-  z.parse(a, new Date());
-});
-
-test("z.never", () => {
-  const a = z.never();
-  expect(() => z.parse(a, "hello")).toThrow();
-});
-
-test("z.void", () => {
-  const a = z.void();
-  expect(z.parse(a, undefined)).toEqual(undefined);
-  expect(() => z.parse(a, null)).toThrow();
-});
-
-test("z.array", () => {
-  const a = z.array(z.string());
-  expect(z.parse(a, ["hello", "world"])).toEqual(["hello", "world"]);
-  expect(() => z.parse(a, [123])).toThrow();
-  expect(() => z.parse(a, "hello")).toThrow();
-});
-
-test("z.union", () => {
-  const a = z.union([z.string(), z.number()]);
-  expect(z.parse(a, "hello")).toEqual("hello");
-  expect(z.parse(a, 123)).toEqual(123);
-  expect(() => z.parse(a, true)).toThrow();
-});
-
-test("z.intersection", () => {
-  const a = z.intersection(z.object({ a: z.string() }), z.object({ b: z.number() }));
-  expect(z.parse(a, { a: "hello", b: 123 })).toEqual({ a: "hello", b: 123 });
-  expect(() => z.parse(a, { a: "hello" })).toThrow();
-  expect(() => z.parse(a, { b: 123 })).toThrow();
-  expect(() => z.parse(a, "hello")).toThrow();
-});
-
-test("z.tuple", () => {
-  const a = z.tuple([z.string(), z.number()]);
-  expect(z.parse(a, ["hello", 123])).toEqual(["hello", 123]);
-  expect(() => z.parse(a, ["hello", "world"])).toThrow();
-  expect(() => z.parse(a, [123, 456])).toThrow();
-  expect(() => z.parse(a, "hello")).toThrow();
-
-  // tuple with rest
-  const b = z.tuple([z.string(), z.number(), z.optional(z.string())], z.boolean());
-  type b = z.output<typeof b>;
-
-  expectTypeOf<b>().toEqualTypeOf<[string, number, (string | undefined)?, ...boolean[]]>();
-  const datas = [
-    ["hello", 123],
-    ["hello", 123, "world"],
-    ["hello", 123, "world", true],
-    ["hello", 123, "world", true, false, true],
-  ];
-  for (const data of datas) {
-    expect(z.parse(b, data)).toEqual(data);
-  }
-
-  expect(() => z.parse(b, ["hello", 123, 123])).toThrow();
-  expect(() => z.parse(b, ["hello", 123, "world", 123])).toThrow();
-
-  // tuple with readonly args
-  const cArgs = [z.string(), z.number(), z.optional(z.string())] as const;
-  const c = z.tuple(cArgs, z.boolean());
-  type c = z.output<typeof c>;
-  expectTypeOf<c>().toEqualTypeOf<[string, number, (string | undefined)?, ...boolean[]]>();
-  // type c = z.output<typeof c>;
-});
-
-test("z.record", () => {
-  // record schema with enum keys
-  const a = z.record(z.string(), z.string());
-  type a = z.output<typeof a>;
-  expectTypeOf<a>().toEqualTypeOf<Record<string, string>>();
-
-  const b = z.record(z.union([z.string(), z.number(), z.symbol()]), z.string());
-  type b = z.output<typeof b>;
-  expectTypeOf<b>().toEqualTypeOf<Record<string | number | symbol, string>>();
-  expect(z.parse(b, { a: "hello", 1: "world", [Symbol.for("asdf")]: "symbol" })).toEqual({
-    a: "hello",
-    1: "world",
-    [Symbol.for("asdf")]: "symbol",
-  });
-
-  // enum keys
-  const c = z.record(z.enum(["a", "b", "c"]), z.string());
-  type c = z.output<typeof c>;
-  expectTypeOf<c>().toEqualTypeOf<Record<"a" | "b" | "c", string>>();
-  expect(z.parse(c, { a: "hello", b: "world", c: "world" })).toEqual({
-    a: "hello",
-    b: "world",
-    c: "world",
-  });
-  // missing keys
-  expect(() => z.parse(c, { a: "hello", b: "world" })).toThrow();
-  // extra keys
-  expect(() => z.parse(c, { a: "hello", b: "world", c: "world", d: "world" })).toThrow();
-
-  // partial enum
-  const d = z.record(z.enum(["a", "b"]).or(z.never()), z.string());
-  type d = z.output<typeof d>;
-  expectTypeOf<d>().toEqualTypeOf<Record<"a" | "b", string>>();
-
-  // literal union keys
-  const e = z.record(z.union([z.literal("a"), z.literal(0)]), z.string());
-  type e = z.output<typeof e>;
-  expectTypeOf<e>().toEqualTypeOf<Record<"a" | 0, string>>();
-  expect(z.parse(e, { a: "hello", 0: "world" })).toEqual({
-    a: "hello",
-    0: "world",
-  });
-
-  // TypeScript enum keys
-  enum Enum {
-    A = 0,
-    B = "hi",
-  }
-
-  const f = z.record(z.enum(Enum), z.string());
-  type f = z.output<typeof f>;
-  expectTypeOf<f>().toEqualTypeOf<Record<Enum, string>>();
-  expect(z.parse(f, { [Enum.A]: "hello", [Enum.B]: "world" })).toEqual({
-    [Enum.A]: "hello",
-    [Enum.B]: "world",
-  });
-});
-
-test("z.map", () => {
-  const a = z.map(z.string(), z.number());
-  type a = z.output<typeof a>;
-  expectTypeOf<a>().toEqualTypeOf<Map<string, number>>();
-  expect(z.parse(a, new Map([["hello", 123]]))).toEqual(new Map([["hello", 123]]));
-  expect(() => z.parse(a, new Map([["hello", "world"]]))).toThrow();
-  expect(() => z.parse(a, new Map([[1243, "world"]]))).toThrow();
-  expect(() => z.parse(a, "hello")).toThrow();
-
-  const r1 = z.safeParse(a, new Map([[123, 123]]));
-  expect(r1.error?.issues[0].code).toEqual("invalid_type");
-  expect(r1.error?.issues[0].path).toEqual([123]);
-
-  const r2: any = z.safeParse(a, new Map([[BigInt(123), 123]]));
-  expect(r2.error!.issues[0].code).toEqual("invalid_key");
-  expect(r2.error!.issues[0].path).toEqual([]);
-
-  const r3: any = z.safeParse(a, new Map([["hello", "world"]]));
-  expect(r3.error!.issues[0].code).toEqual("invalid_type");
-  expect(r3.error!.issues[0].path).toEqual(["hello"]);
-});
-
-test("z.map invalid_element", () => {
-  const a = z.map(z.bigint(), z.number());
-  const r1 = z.safeParse(a, new Map([[BigInt(123), BigInt(123)]]));
-
-  expect(r1.error!.issues[0].code).toEqual("invalid_element");
-  expect(r1.error!.issues[0].path).toEqual([]);
-});
-
-test("z.map async", async () => {
-  const a = z.map(z.string().check(z.refine(async () => true)), z.number().check(z.refine(async () => true)));
-  const d1 = new Map([["hello", 123]]);
-  expect(await z.parseAsync(a, d1)).toEqual(d1);
-
-  await expect(z.parseAsync(a, new Map([[123, 123]]))).rejects.toThrow();
-  await expect(z.parseAsync(a, new Map([["hi", "world"]]))).rejects.toThrow();
-  await expect(z.parseAsync(a, new Map([[1243, "world"]]))).rejects.toThrow();
-  await expect(z.parseAsync(a, "hello")).rejects.toThrow();
-
-  const r = await z.safeParseAsync(a, new Map([[123, 123]]));
-  expect(r.success).toEqual(false);
-  expect(r.error!.issues[0].code).toEqual("invalid_type");
-  expect(r.error!.issues[0].path).toEqual([123]);
-});
-
-test("z.set", () => {
-  const a = z.set(z.string());
-  type a = z.output<typeof a>;
-  expectTypeOf<a>().toEqualTypeOf<Set<string>>();
-  expect(z.parse(a, new Set(["hello", "world"]))).toEqual(new Set(["hello", "world"]));
-  expect(() => z.parse(a, new Set([123]))).toThrow();
-  expect(() => z.parse(a, ["hello", "world"])).toThrow();
-  expect(() => z.parse(a, "hello")).toThrow();
-
-  const b = z.set(z.number());
-  expect(z.parse(b, new Set([1, 2, 3]))).toEqual(new Set([1, 2, 3]));
-  expect(() => z.parse(b, new Set(["hello"]))).toThrow();
-  expect(() => z.parse(b, [1, 2, 3])).toThrow();
-  expect(() => z.parse(b, 123)).toThrow();
-});
-
-test("z.enum", () => {
-  const a = z.enum(["A", "B", "C"]);
-  type a = z.output<typeof a>;
-  expectTypeOf<a>().toEqualTypeOf<"A" | "B" | "C">();
-  expect(z.parse(a, "A")).toEqual("A");
-  expect(z.parse(a, "B")).toEqual("B");
-  expect(z.parse(a, "C")).toEqual("C");
-  expect(() => z.parse(a, "D")).toThrow();
-  expect(() => z.parse(a, 123)).toThrow();
-
-  expect(a.enum.A).toEqual("A");
-  expect(a.enum.B).toEqual("B");
-  expect(a.enum.C).toEqual("C");
-  expect((a.enum as any).D).toEqual(undefined);
-});
-
-test("z.enum - native", () => {
-  enum NativeEnum {
-    A = "A",
-    B = "B",
-    C = "C",
-  }
-  const a = z.enum(NativeEnum);
-  type a = z.output<typeof a>;
-  expectTypeOf<a>().toEqualTypeOf<NativeEnum>();
-  expect(z.parse(a, NativeEnum.A)).toEqual(NativeEnum.A);
-  expect(z.parse(a, NativeEnum.B)).toEqual(NativeEnum.B);
-  expect(z.parse(a, NativeEnum.C)).toEqual(NativeEnum.C);
-  expect(() => z.parse(a, "D")).toThrow();
-  expect(() => z.parse(a, 123)).toThrow();
-
-  // test a.enum
-  a;
-  expect(a.enum.A).toEqual(NativeEnum.A);
-  expect(a.enum.B).toEqual(NativeEnum.B);
-  expect(a.enum.C).toEqual(NativeEnum.C);
-});
-
-test("z.nativeEnum", () => {
-  enum NativeEnum {
-    A = "A",
-    B = "B",
-    C = "C",
-  }
-  const a = z.nativeEnum(NativeEnum);
-  type a = z.output<typeof a>;
-  expectTypeOf<a>().toEqualTypeOf<NativeEnum>();
-  expect(z.parse(a, NativeEnum.A)).toEqual(NativeEnum.A);
-  expect(z.parse(a, NativeEnum.B)).toEqual(NativeEnum.B);
-  expect(z.parse(a, NativeEnum.C)).toEqual(NativeEnum.C);
-  expect(() => z.parse(a, "D")).toThrow();
-  expect(() => z.parse(a, 123)).toThrow();
-
-  // test a.enum
-  a;
-  expect(a.enum.A).toEqual(NativeEnum.A);
-  expect(a.enum.B).toEqual(NativeEnum.B);
-  expect(a.enum.C).toEqual(NativeEnum.C);
-});
-
-test("z.literal", () => {
-  const a = z.literal("hello");
-  type a = z.output<typeof a>;
-  expectTypeOf<a>().toEqualTypeOf<"hello">();
-  expect(z.parse(a, "hello")).toEqual("hello");
-  expect(() => z.parse(a, "world")).toThrow();
-  expect(() => z.parse(a, 123)).toThrow();
-});
-
-test("z.file", () => {
-  const a = z.file();
-  const file = new File(["content"], "filename.txt", { type: "text/plain" });
-  expect(z.parse(a, file)).toEqual(file);
-  expect(() => z.parse(a, "file")).toThrow();
-  expect(() => z.parse(a, 123)).toThrow();
-});
-
-test("z.transform", () => {
-  const a = z.pipe(
-    z.string(),
-    z.transform((val) => val.toUpperCase())
-  );
-  type a = z.output<typeof a>;
-  expectTypeOf<a>().toEqualTypeOf<string>();
-  expect(z.parse(a, "hello")).toEqual("HELLO");
-  expect(() => z.parse(a, 123)).toThrow();
-});
-
-test("z.transform async", async () => {
-  const a = z.pipe(
-    z.string(),
-    z.transform(async (val) => val.toUpperCase())
-  );
-  type a = z.output<typeof a>;
-  expectTypeOf<a>().toEqualTypeOf<string>();
-  expect(await z.parseAsync(a, "hello")).toEqual("HELLO");
-  await expect(() => z.parseAsync(a, 123)).rejects.toThrow();
-});
-
-test("z.preprocess", () => {
-  const a = z.pipe(
-    z.transform((val) => String(val).toUpperCase()),
-    z.string()
-  );
-  type a = z.output<typeof a>;
-  expectTypeOf<a>().toEqualTypeOf<string>();
-  expect(z.parse(a, 123)).toEqual("123");
-  expect(z.parse(a, true)).toEqual("TRUE");
-  expect(z.parse(a, BigInt(1234))).toEqual("1234");
-  // expect(() => z.parse(a, Symbol("asdf"))).toThrow();
-});
-
-// test("z.preprocess async", () => {
-//   const a = z.preprocess(async (val) => String(val), z.string());
-//   type a = z.output<typeof a>;
-//   expectTypeOf<a>().toEqualTypeOf<string>();
-//   expect(z.parse(a, 123)).toEqual("123");
-//   expect(z.parse(a, true)).toEqual("true");
-//   expect(() => z.parse(a, {})).toThrow();
-// });
-
-test("z.optional", () => {
-  const a = z.optional(z.string());
-  type a = z.output<typeof a>;
-  expectTypeOf<a>().toEqualTypeOf<string | undefined>();
-  expect(z.parse(a, "hello")).toEqual("hello");
-  expect(z.parse(a, undefined)).toEqual(undefined);
-  expect(() => z.parse(a, 123)).toThrow();
-});
-
-test("z.nullable", () => {
-  const a = z.nullable(z.string());
-  type a = z.output<typeof a>;
-  expectTypeOf<a>().toEqualTypeOf<string | null>();
-  expect(z.parse(a, "hello")).toEqual("hello");
-  expect(z.parse(a, null)).toEqual(null);
-  expect(() => z.parse(a, 123)).toThrow();
-});
-
-test("z.default", () => {
-  const a = z._default(z.string(), "default");
-  type a = z.output<typeof a>;
-  expectTypeOf<a>().toEqualTypeOf<string>();
-  expect(z.parse(a, undefined)).toEqual("default");
-  expect(z.parse(a, "hello")).toEqual("hello");
-  expect(() => z.parse(a, 123)).toThrow();
-
-  const b = z._default(z.string(), () => "default");
-  expect(z.parse(b, undefined)).toEqual("default");
-  expect(z.parse(b, "hello")).toEqual("hello");
-  expect(() => z.parse(b, 123)).toThrow();
-});
-
-test("z.catch", () => {
-  const a = z.catch(z.string(), "default");
-  type a = z.output<typeof a>;
-  expectTypeOf<a>().toEqualTypeOf<string>();
-  expect(z.parse(a, "hello")).toEqual("hello");
-  expect(z.parse(a, 123)).toEqual("default");
-
-  const b = z.catch(z.string(), () => "default");
-  expect(z.parse(b, "hello")).toEqual("hello");
-  expect(z.parse(b, 123)).toEqual("default");
-
-  const c = z.catch(z.string(), (ctx) => {
-    return `${ctx.error.issues.length}issues`;
-  });
-  expect(z.parse(c, 1234)).toEqual("1issues");
-});
-
-test("z.nan", () => {
-  const a = z.nan();
-  type a = z.output<typeof a>;
-  expectTypeOf<a>().toEqualTypeOf<number>();
-  expect(z.parse(a, Number.NaN)).toEqual(Number.NaN);
-  expect(() => z.parse(a, 123)).toThrow();
-  expect(() => z.parse(a, "NaN")).toThrow();
-});
-
-test("z.pipe", () => {
-  const a = z.pipe(
-    z.pipe(
-      z.string(),
-      z.transform((val) => val.length)
-    ),
-    z.number()
-  );
-  type a_in = z.input<typeof a>;
-  expectTypeOf<a_in>().toEqualTypeOf<string>();
-  type a_out = z.output<typeof a>;
-  expectTypeOf<a_out>().toEqualTypeOf<number>();
-
-  expect(z.parse(a, "123")).toEqual(3);
-  expect(z.parse(a, "hello")).toEqual(5);
-  expect(() => z.parse(a, 123)).toThrow();
-});
-
-test("z.readonly", () => {
-  const a = z.readonly(z.string());
-  type a = z.output<typeof a>;
-  expectTypeOf<a>().toEqualTypeOf<Readonly<string>>();
-  expect(z.parse(a, "hello")).toEqual("hello");
-  expect(() => z.parse(a, 123)).toThrow();
-});
-
-test("z.templateLiteral", () => {
-  const a = z.templateLiteral([z.string(), z.number()]);
-  type a = z.output<typeof a>;
-  expectTypeOf<a>().toEqualTypeOf<`${string}${number}`>();
-  expect(z.parse(a, "hello123")).toEqual("hello123");
-  expect(() => z.parse(a, "hello")).toThrow();
-  expect(() => z.parse(a, 123)).toThrow();
-
-  // multipart
-  const b = z.templateLiteral([z.string(), z.number(), z.string()]);
-  type b = z.output<typeof b>;
-  expectTypeOf<b>().toEqualTypeOf<`${string}${number}${string}`>();
-  expect(z.parse(b, "hello123world")).toEqual("hello123world");
-  expect(z.parse(b, "123")).toEqual("123");
-  expect(() => z.parse(b, "hello")).toThrow();
-  expect(() => z.parse(b, 123)).toThrow();
-
-  // include boolean
-  const c = z.templateLiteral([z.string(), z.boolean()]);
-  type c = z.output<typeof c>;
-  expectTypeOf<c>().toEqualTypeOf<`${string}${boolean}`>();
-  expect(z.parse(c, "hellotrue")).toEqual("hellotrue");
-  expect(z.parse(c, "hellofalse")).toEqual("hellofalse");
-  expect(() => z.parse(c, "hello")).toThrow();
-  expect(() => z.parse(c, 123)).toThrow();
-
-  // include literal prefix
-  const d = z.templateLiteral([z.literal("hello"), z.number()]);
-  type d = z.output<typeof d>;
-  expectTypeOf<d>().toEqualTypeOf<`hello${number}`>();
-  expect(z.parse(d, "hello123")).toEqual("hello123");
-  expect(() => z.parse(d, 123)).toThrow();
-  expect(() => z.parse(d, "world123")).toThrow();
-
-  // include literal union
-  const e = z.templateLiteral([z.literal(["aa", "bb"]), z.number()]);
-  type e = z.output<typeof e>;
-  expectTypeOf<e>().toEqualTypeOf<`aa${number}` | `bb${number}`>();
-  expect(z.parse(e, "aa123")).toEqual("aa123");
-  expect(z.parse(e, "bb123")).toEqual("bb123");
-  expect(() => z.parse(e, "cc123")).toThrow();
-  expect(() => z.parse(e, 123)).toThrow();
-});
-
-// this returns both a schema and a check
-test("z.custom schema", () => {
-  const a = z.custom((val) => {
-    return typeof val === "string";
-  });
-  expect(z.parse(a, "hello")).toEqual("hello");
-  expect(() => z.parse(a, 123)).toThrow();
-});
-
-test("z.custom check", () => {
-  // @ts-expect-error Inference not possible, use z.refine()
-  z.date().check(z.custom((val) => val.getTime() > 0));
-});
-
-test("z.check", () => {
-  // this is a more flexible version of z.custom that accepts an arbitrary _parse logic
-  // the function should return base.$ZodResult
-  const a = z.any().check(
-    z.check<string>((ctx) => {
-      if (typeof ctx.value === "string") return;
-      ctx.issues.push({
-        code: "custom",
-        origin: "custom",
-        message: "Expected a string",
-        input: ctx.value,
-      });
-    })
-  );
-  expect(z.safeParse(a, "hello")).toMatchObject({
-    success: true,
-    data: "hello",
-  });
-  expect(z.safeParse(a, 123)).toMatchObject({
-    success: false,
-    error: { issues: [{ code: "custom", message: "Expected a string" }] },
-  });
-});
-
-test("z.with (alias for z.check)", () => {
-  // .with() should work exactly the same as .check()
-  const a = z.any().with(
-    z.check<string>((ctx) => {
-      if (typeof ctx.value === "string") return;
-      ctx.issues.push({
-        code: "custom",
-        origin: "custom",
-        message: "Expected a string",
-        input: ctx.value,
-      });
-    })
-  );
-  expect(z.safeParse(a, "hello")).toMatchObject({
-    success: true,
-    data: "hello",
-  });
-  expect(z.safeParse(a, 123)).toMatchObject({
-    success: false,
-    error: { issues: [{ code: "custom", message: "Expected a string" }] },
-  });
-
-  // Test with refine
-  const b = z.string().with(z.refine((val) => val.length > 3, "Must be longer than 3"));
-  expect(z.safeParse(b, "hello").success).toBe(true);
-  expect(z.safeParse(b, "hi").success).toBe(false);
-
-  // Test with function
-  const c = z.string().with(({ value, issues }) => {
-    if (value.length <= 3) {
-      issues.push({
-        code: "custom",
-        input: value,
-        message: "Must be longer than 3",
-      });
-    }
-  });
-  expect(z.safeParse(c, "hello").success).toBe(true);
-  expect(z.safeParse(c, "hi").success).toBe(false);
-});
-
-test("z.instanceof", () => {
-  class A {}
-
-  const a = z.instanceof(A);
-  expect(z.parse(a, new A())).toBeInstanceOf(A);
-  expect(() => z.parse(a, {})).toThrow();
-});
-
-test("z.refine", () => {
-  const a = z.number().check(
-    z.refine((val) => val > 3),
-    z.refine((val) => val < 10)
-  );
-  expect(z.parse(a, 5)).toEqual(5);
-  expect(() => z.parse(a, 2)).toThrow();
-  expect(() => z.parse(a, 11)).toThrow();
-  expect(() => z.parse(a, "hi")).toThrow();
-});
-
-// test("z.superRefine", () => {
-//   const a = z.number([
-//     z.superRefine((val, ctx) => {
-//       if (val < 3) {
-//         return ctx.addIssue({
-//           code: "custom",
-//           origin: "custom",
-//           message: "Too small",
-//           input: val,
-//         });
-//       }
-//       if (val > 10) {
-//         return ctx.addIssue("Too big");
-//       }
-//     }),
-//   ]);
-
-//   expect(z.parse(a, 5)).toEqual(5);
-//   expect(() => z.parse(a, 2)).toThrow();
-//   expect(() => z.parse(a, 11)).toThrow();
-//   expect(() => z.parse(a, "hi")).toThrow();
-// });
-
-test("z.transform", () => {
-  const a = z.transform((val: number) => {
-    return `${val}`;
-  });
-  type a_in = z.input<typeof a>;
-  expectTypeOf<a_in>().toEqualTypeOf<number>();
-  type a_out = z.output<typeof a>;
-  expectTypeOf<a_out>().toEqualTypeOf<string>();
-  expect(z.parse(a, 123)).toEqual("123");
-});
-
-test("z.$brand()", () => {
-  const a = z.string().brand<"my-brand">();
-  type a = z.output<typeof a>;
-  const branded = (_: a) => {};
-  // @ts-expect-error
-  branded("asdf");
-});
-
-test("z.lazy", () => {
-  const a = z.lazy(() => z.string());
-  type a = z.output<typeof a>;
-  expectTypeOf<a>().toEqualTypeOf<string>();
-  expect(z.parse(a, "hello")).toEqual("hello");
-  expect(() => z.parse(a, 123)).toThrow();
-});
-
-// schema that validates JSON-like data
-test("z.json", () => {
-  const a = z.json();
-  type a = z.output<typeof a>;
-  expectTypeOf<a>().toEqualTypeOf<util.JSONType>();
-
-  expect(z.parse(a, "hello")).toEqual("hello");
-  expect(z.parse(a, 123)).toEqual(123);
-  expect(z.parse(a, true)).toEqual(true);
-  expect(z.parse(a, null)).toEqual(null);
-  expect(z.parse(a, {})).toEqual({});
-  expect(z.parse(a, { a: "hello" })).toEqual({ a: "hello" });
-  expect(z.parse(a, [1, 2, 3])).toEqual([1, 2, 3]);
-  expect(z.parse(a, [{ a: "hello" }])).toEqual([{ a: "hello" }]);
-
-  // fail cases
-  expect(() => z.parse(a, new Date())).toThrow();
-  expect(() => z.parse(a, Symbol())).toThrow();
-  expect(() => z.parse(a, { a: new Date() })).toThrow();
-  expect(() => z.parse(a, undefined)).toThrow();
-  expect(() => z.parse(a, { a: undefined })).toThrow();
-});
-
-// promise
-test("z.promise", async () => {
-  const a = z.promise(z.string());
-  type a = z.output<typeof a>;
-  expectTypeOf<a>().toEqualTypeOf<Promise<string>>();
-
-  expect(await z.safeParseAsync(a, Promise.resolve("hello"))).toMatchObject({
-    success: true,
-    data: "hello",
-  });
-  expect(await z.safeParseAsync(a, Promise.resolve(123))).toMatchObject({
-    success: false,
-  });
-
-  const b = z.string();
-  expect(() => z.parse(b, Promise.resolve("hello"))).toThrow();
-});
-// test("type assertions", () => {
-//   const schema = z.pipe(
-//     z.string(),
-//     z.transform((val) => val.length)
-//   );
-//   schema.assertInput<string>();
-//   // @ts-expect-error
-//   schema.assertInput<number>();
-
-//   schema.assertOutput<number>();
-//   // @ts-expect-error
-//   schema.assertOutput<string>();
-// });
-
-test("isPlainObject", () => {
-  expect(z.core.util.isPlainObject({})).toEqual(true);
-  expect(z.core.util.isPlainObject(Object.create(null))).toEqual(true);
-  expect(z.core.util.isPlainObject([])).toEqual(false);
-  expect(z.core.util.isPlainObject(new Date())).toEqual(false);
-  expect(z.core.util.isPlainObject(null)).toEqual(false);
-  expect(z.core.util.isPlainObject(undefined)).toEqual(false);
-  expect(z.core.util.isPlainObject("string")).toEqual(false);
-  expect(z.core.util.isPlainObject(123)).toEqual(false);
-  expect(z.core.util.isPlainObject(Symbol())).toEqual(false);
-  expect(z.core.util.isPlainObject({ constructor: "string" })).toEqual(true);
-  expect(z.core.util.isPlainObject({ constructor: 123 })).toEqual(true);
-  expect(z.core.util.isPlainObject({ constructor: null })).toEqual(true);
-  expect(z.core.util.isPlainObject({ constructor: undefined })).toEqual(true);
-  expect(z.core.util.isPlainObject({ constructor: true })).toEqual(true);
-  expect(z.core.util.isPlainObject({ constructor: {} })).toEqual(true);
-  expect(z.core.util.isPlainObject({ constructor: [] })).toEqual(true);
-});
-
-test("shallowClone with constructor field", () => {
-  const objWithConstructor = { constructor: "string", key: "value" };
-  const cloned = z.core.util.shallowClone(objWithConstructor);
-
-  expect(cloned).toEqual(objWithConstructor);
-  expect(cloned).not.toBe(objWithConstructor);
-  expect(cloned.constructor).toBe("string");
-  expect(cloned.key).toBe("value");
-
-  const testCases = [
-    { constructor: 123, data: "test" },
-    { constructor: null, data: "test" },
-    { constructor: true, data: "test" },
-    { constructor: {}, data: "test" },
-    { constructor: [], data: "test" },
-  ];
-
-  for (const testCase of testCases) {
-    const clonedCase = z.core.util.shallowClone(testCase);
-    expect(clonedCase).toEqual(testCase);
-    expect(clonedCase).not.toBe(testCase);
-  }
-});
-
-test("def typing", () => {
-  z.string().def.type satisfies "string";
-  z.number().def.type satisfies "number";
-  z.bigint().def.type satisfies "bigint";
-  z.boolean().def.type satisfies "boolean";
-  z.date().def.type satisfies "date";
-  z.symbol().def.type satisfies "symbol";
-  z.undefined().def.type satisfies "undefined";
-  z.string().nullable().def.type satisfies "nullable";
-  z.null().def.type satisfies "null";
-  z.any().def.type satisfies "any";
-  z.unknown().def.type satisfies "unknown";
-  z.never().def.type satisfies "never";
-  z.void().def.type satisfies "void";
-  z.array(z.string()).def.type satisfies "array";
-  z.object({ key: z.string() }).def.type satisfies "object";
-  z.union([z.string(), z.number()]).def.type satisfies "union";
-  z.intersection(z.string(), z.number()).def.type satisfies "intersection";
-  z.tuple([z.string(), z.number()]).def.type satisfies "tuple";
-  z.record(z.string(), z.number()).def.type satisfies "record";
-  z.map(z.string(), z.number()).def.type satisfies "map";
-  z.set(z.string()).def.type satisfies "set";
-  z.literal("example").def.type satisfies "literal";
-  z.enum(["a", "b", "c"]).def.type satisfies "enum";
-  z.promise(z.string()).def.type satisfies "promise";
-  z.lazy(() => z.string()).def.type satisfies "lazy";
-  z.string().optional().def.type satisfies "optional";
-  z.string().default("default").def.type satisfies "default";
-  z.templateLiteral([z.literal("a"), z.literal("b")]).def.type satisfies "template_literal";
-  z.custom<string>((val) => typeof val === "string").def.type satisfies "custom";
-  z.transform((val) => val as string).def.type satisfies "transform";
-  z.string().optional().nonoptional().def.type satisfies "nonoptional";
-  z.object({ key: z.string() }).readonly().def.type satisfies "readonly";
-  z.nan().def.type satisfies "nan";
-  z.unknown().pipe(z.number()).def.type satisfies "pipe";
-  z.success(z.string()).def.type satisfies "success";
-  z.string().catch("fallback").def.type satisfies "catch";
-  z.file().def.type satisfies "file";
-});
-
-test("runtime type property exists and returns correct values", () => {
-  const stringSchema = z.string();
-  expect(stringSchema.type).toBe("string");
-});
-
-test("type narrowing works with type property", () => {
-  type ArrayOrRecord = z.ZodArray<z.ZodString> | z.ZodRecord<z.ZodString, z.ZodAny>;
-  const arraySchema = z.array(z.string()) as ArrayOrRecord;
-
-  if (arraySchema.type === "array") {
-    expectTypeOf(arraySchema).toEqualTypeOf<z.ZodArray<z.ZodString>>();
-    expect(arraySchema.element).toBeDefined();
-  }
-});