makecoder 1.0.25

package/dist/zod/src/v3/tests/catch.test.ts

@@ -0,0 +1,220 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import { z } from "zod/v3";
+import { util } from "../helpers/util.js";
+
+test("basic catch", () => {
+  expect(z.string().catch("default").parse(undefined)).toBe("default");
+});
+
+test("catch fn does not run when parsing succeeds", () => {
+  let isCalled = false;
+  const cb = () => {
+    isCalled = true;
+    return "asdf";
+  };
+  expect(z.string().catch(cb).parse("test")).toBe("test");
+  expect(isCalled).toEqual(false);
+});
+
+test("basic catch async", async () => {
+  const result = await z.string().catch("default").parseAsync(1243);
+  expect(result).toBe("default");
+});
+
+test("catch replace wrong types", () => {
+  expect(z.string().catch("default").parse(true)).toBe("default");
+  expect(z.string().catch("default").parse(true)).toBe("default");
+  expect(z.string().catch("default").parse(15)).toBe("default");
+  expect(z.string().catch("default").parse([])).toBe("default");
+  expect(z.string().catch("default").parse(new Map())).toBe("default");
+  expect(z.string().catch("default").parse(new Set())).toBe("default");
+  expect(z.string().catch("default").parse({})).toBe("default");
+});
+
+test("catch with transform", () => {
+  const stringWithDefault = z
+    .string()
+    .transform((val) => val.toUpperCase())
+    .catch("default");
+  expect(stringWithDefault.parse(undefined)).toBe("default");
+  expect(stringWithDefault.parse(15)).toBe("default");
+  expect(stringWithDefault).toBeInstanceOf(z.ZodCatch);
+  expect(stringWithDefault._def.innerType).toBeInstanceOf(z.ZodEffects);
+  expect(stringWithDefault._def.innerType._def.schema).toBeInstanceOf(z.ZodSchema);
+
+  type inp = z.input<typeof stringWithDefault>;
+  util.assertEqual<inp, unknown>(true);
+  type out = z.output<typeof stringWithDefault>;
+  util.assertEqual<out, string>(true);
+});
+
+test("catch on existing optional", () => {
+  const stringWithDefault = z.string().optional().catch("asdf");
+  expect(stringWithDefault.parse(undefined)).toBe(undefined);
+  expect(stringWithDefault.parse(15)).toBe("asdf");
+  expect(stringWithDefault).toBeInstanceOf(z.ZodCatch);
+  expect(stringWithDefault._def.innerType).toBeInstanceOf(z.ZodOptional);
+  expect(stringWithDefault._def.innerType._def.innerType).toBeInstanceOf(z.ZodString);
+
+  type inp = z.input<typeof stringWithDefault>;
+  util.assertEqual<inp, unknown>(true);
+  type out = z.output<typeof stringWithDefault>;
+  util.assertEqual<out, string | undefined>(true);
+});
+
+test("optional on catch", () => {
+  const stringWithDefault = z.string().catch("asdf").optional();
+
+  type inp = z.input<typeof stringWithDefault>;
+  util.assertEqual<inp, unknown>(true);
+  type out = z.output<typeof stringWithDefault>;
+  util.assertEqual<out, string | undefined>(true);
+});
+
+test("complex chain example", () => {
+  const complex = z
+    .string()
+    .catch("asdf")
+    .transform((val) => val + "!")
+    .transform((val) => val.toUpperCase())
+    .catch("qwer")
+    .removeCatch()
+    .optional()
+    .catch("asdfasdf");
+
+  expect(complex.parse("qwer")).toBe("QWER!");
+  expect(complex.parse(15)).toBe("ASDF!");
+  expect(complex.parse(true)).toBe("ASDF!");
+});
+
+test("removeCatch", () => {
+  const stringWithRemovedDefault = z.string().catch("asdf").removeCatch();
+
+  type out = z.output<typeof stringWithRemovedDefault>;
+  util.assertEqual<out, string>(true);
+});
+
+test("nested", () => {
+  const inner = z.string().catch("asdf");
+  const outer = z.object({ inner }).catch({
+    inner: "asdf",
+  });
+  type input = z.input<typeof outer>;
+  util.assertEqual<input, unknown>(true);
+  type out = z.output<typeof outer>;
+  util.assertEqual<out, { inner: string }>(true);
+  expect(outer.parse(undefined)).toEqual({ inner: "asdf" });
+  expect(outer.parse({})).toEqual({ inner: "asdf" });
+  expect(outer.parse({ inner: undefined })).toEqual({ inner: "asdf" });
+});
+
+test("chained catch", () => {
+  const stringWithDefault = z.string().catch("inner").catch("outer");
+  const result = stringWithDefault.parse(undefined);
+  expect(result).toEqual("inner");
+  const resultDiff = stringWithDefault.parse(5);
+  expect(resultDiff).toEqual("inner");
+});
+
+test("factory", () => {
+  z.ZodCatch.create(z.string(), {
+    catch: "asdf",
+  }).parse(undefined);
+});
+
+test("native enum", () => {
+  enum Fruits {
+    apple = "apple",
+    orange = "orange",
+  }
+
+  const schema = z.object({
+    fruit: z.nativeEnum(Fruits).catch(Fruits.apple),
+  });
+
+  expect(schema.parse({})).toEqual({ fruit: Fruits.apple });
+  expect(schema.parse({ fruit: 15 })).toEqual({ fruit: Fruits.apple });
+});
+
+test("enum", () => {
+  const schema = z.object({
+    fruit: z.enum(["apple", "orange"]).catch("apple"),
+  });
+
+  expect(schema.parse({})).toEqual({ fruit: "apple" });
+  expect(schema.parse({ fruit: true })).toEqual({ fruit: "apple" });
+  expect(schema.parse({ fruit: 15 })).toEqual({ fruit: "apple" });
+});
+
+test("reported issues with nested usage", () => {
+  const schema = z.object({
+    string: z.string(),
+    obj: z.object({
+      sub: z.object({
+        lit: z.literal("a"),
+        subCatch: z.number().catch(23),
+      }),
+      midCatch: z.number().catch(42),
+    }),
+    number: z.number().catch(0),
+    bool: z.boolean(),
+  });
+
+  try {
+    schema.parse({
+      string: {},
+      obj: {
+        sub: {
+          lit: "b",
+          subCatch: "24",
+        },
+        midCatch: 444,
+      },
+      number: "",
+      bool: "yes",
+    });
+  } catch (error) {
+    const issues = (error as z.ZodError).issues;
+
+    expect(issues.length).toEqual(3);
+    expect(issues[0].message).toMatch("string");
+    expect(issues[1].message).toMatch("literal");
+    expect(issues[2].message).toMatch("boolean");
+  }
+});
+
+test("catch error", () => {
+  let catchError: z.ZodError | undefined = undefined;
+
+  const schema = z.object({
+    age: z.number(),
+    name: z.string().catch((ctx) => {
+      catchError = ctx.error;
+
+      return "John Doe";
+    }),
+  });
+
+  const result = schema.safeParse({
+    age: null,
+    name: null,
+  });
+
+  expect(result.success).toEqual(false);
+  expect(!result.success && result.error.issues.length).toEqual(1);
+  expect(!result.success && result.error.issues[0].message).toMatch("number");
+
+  expect(catchError).toBeInstanceOf(z.ZodError);
+  expect(catchError !== undefined && (catchError as z.ZodError).issues.length).toEqual(1);
+  expect(catchError !== undefined && (catchError as z.ZodError).issues[0].message).toMatch("string");
+});
+
+test("ctx.input", () => {
+  const schema = z.string().catch((ctx) => {
+    return String(ctx.input);
+  });
+
+  expect(schema.parse(123)).toEqual("123");
+});

package/dist/zod/src/v3/tests/coerce.test.ts

@@ -0,0 +1,133 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import * as z from "zod/v3";
+
+test("string coercion", () => {
+  const schema = z.coerce.string();
+  expect(schema.parse("sup")).toEqual("sup");
+  expect(schema.parse("")).toEqual("");
+  expect(schema.parse(12)).toEqual("12");
+  expect(schema.parse(0)).toEqual("0");
+  expect(schema.parse(-12)).toEqual("-12");
+  expect(schema.parse(3.14)).toEqual("3.14");
+  expect(schema.parse(BigInt(15))).toEqual("15");
+  expect(schema.parse(Number.NaN)).toEqual("NaN");
+  expect(schema.parse(Number.POSITIVE_INFINITY)).toEqual("Infinity");
+  expect(schema.parse(Number.NEGATIVE_INFINITY)).toEqual("-Infinity");
+  expect(schema.parse(true)).toEqual("true");
+  expect(schema.parse(false)).toEqual("false");
+  expect(schema.parse(null)).toEqual("null");
+  expect(schema.parse(undefined)).toEqual("undefined");
+  expect(schema.parse({ hello: "world!" })).toEqual("[object Object]");
+  expect(schema.parse(["item", "another_item"])).toEqual("item,another_item");
+  expect(schema.parse([])).toEqual("");
+  expect(schema.parse(new Date("2022-01-01T00:00:00.000Z"))).toEqual(new Date("2022-01-01T00:00:00.000Z").toString());
+});
+
+test("number coercion", () => {
+  const schema = z.coerce.number();
+  expect(schema.parse("12")).toEqual(12);
+  expect(schema.parse("0")).toEqual(0);
+  expect(schema.parse("-12")).toEqual(-12);
+  expect(schema.parse("3.14")).toEqual(3.14);
+  expect(schema.parse("")).toEqual(0);
+  expect(() => schema.parse("NOT_A_NUMBER")).toThrow(); // z.ZodError
+  expect(schema.parse(12)).toEqual(12);
+  expect(schema.parse(0)).toEqual(0);
+  expect(schema.parse(-12)).toEqual(-12);
+  expect(schema.parse(3.14)).toEqual(3.14);
+  expect(schema.parse(BigInt(15))).toEqual(15);
+  expect(() => schema.parse(Number.NaN)).toThrow(); // z.ZodError
+  expect(schema.parse(Number.POSITIVE_INFINITY)).toEqual(Number.POSITIVE_INFINITY);
+  expect(schema.parse(Number.NEGATIVE_INFINITY)).toEqual(Number.NEGATIVE_INFINITY);
+  expect(schema.parse(true)).toEqual(1);
+  expect(schema.parse(false)).toEqual(0);
+  expect(schema.parse(null)).toEqual(0);
+  expect(() => schema.parse(undefined)).toThrow(); // z.ZodError
+  expect(() => schema.parse({ hello: "world!" })).toThrow(); // z.ZodError
+  expect(() => schema.parse(["item", "another_item"])).toThrow(); // z.ZodError
+  expect(schema.parse([])).toEqual(0);
+  expect(schema.parse(new Date(1670139203496))).toEqual(1670139203496);
+});
+
+test("boolean coercion", () => {
+  const schema = z.coerce.boolean();
+  expect(schema.parse("true")).toEqual(true);
+  expect(schema.parse("false")).toEqual(true);
+  expect(schema.parse("0")).toEqual(true);
+  expect(schema.parse("1")).toEqual(true);
+  expect(schema.parse("")).toEqual(false);
+  expect(schema.parse(1)).toEqual(true);
+  expect(schema.parse(0)).toEqual(false);
+  expect(schema.parse(-1)).toEqual(true);
+  expect(schema.parse(3.14)).toEqual(true);
+  expect(schema.parse(BigInt(15))).toEqual(true);
+  expect(schema.parse(Number.NaN)).toEqual(false);
+  expect(schema.parse(Number.POSITIVE_INFINITY)).toEqual(true);
+  expect(schema.parse(Number.NEGATIVE_INFINITY)).toEqual(true);
+  expect(schema.parse(true)).toEqual(true);
+  expect(schema.parse(false)).toEqual(false);
+  expect(schema.parse(null)).toEqual(false);
+  expect(schema.parse(undefined)).toEqual(false);
+  expect(schema.parse({ hello: "world!" })).toEqual(true);
+  expect(schema.parse(["item", "another_item"])).toEqual(true);
+  expect(schema.parse([])).toEqual(true);
+  expect(schema.parse(new Date(1670139203496))).toEqual(true);
+});
+
+test("bigint coercion", () => {
+  const schema = z.coerce.bigint();
+  expect(schema.parse("5")).toEqual(BigInt(5));
+  expect(schema.parse("0")).toEqual(BigInt(0));
+  expect(schema.parse("-5")).toEqual(BigInt(-5));
+  expect(() => schema.parse("3.14")).toThrow(); // not a z.ZodError!
+  expect(schema.parse("")).toEqual(BigInt(0));
+  expect(() => schema.parse("NOT_A_NUMBER")).toThrow(); // not a z.ZodError!
+  expect(schema.parse(5)).toEqual(BigInt(5));
+  expect(schema.parse(0)).toEqual(BigInt(0));
+  expect(schema.parse(-5)).toEqual(BigInt(-5));
+  expect(() => schema.parse(3.14)).toThrow(); // not a z.ZodError!
+  expect(schema.parse(BigInt(5))).toEqual(BigInt(5));
+  expect(() => schema.parse(Number.NaN)).toThrow(); // not a z.ZodError!
+  expect(() => schema.parse(Number.POSITIVE_INFINITY)).toThrow(); // not a z.ZodError!
+  expect(() => schema.parse(Number.NEGATIVE_INFINITY)).toThrow(); // not a z.ZodError!
+  expect(schema.parse(true)).toEqual(BigInt(1));
+  expect(schema.parse(false)).toEqual(BigInt(0));
+  expect(() => schema.parse(null)).toThrow(); // not a z.ZodError!
+  expect(() => schema.parse(undefined)).toThrow(); // not a z.ZodError!
+  expect(() => schema.parse({ hello: "world!" })).toThrow(); // not a z.ZodError!
+  expect(() => schema.parse(["item", "another_item"])).toThrow(); // not a z.ZodError!
+  expect(schema.parse([])).toEqual(BigInt(0));
+  expect(schema.parse(new Date(1670139203496))).toEqual(BigInt(1670139203496));
+});
+
+test("date coercion", () => {
+  const schema = z.coerce.date();
+  expect(schema.parse(new Date().toDateString())).toBeInstanceOf(Date);
+  expect(schema.parse(new Date().toISOString())).toBeInstanceOf(Date);
+  expect(schema.parse(new Date().toUTCString())).toBeInstanceOf(Date);
+  expect(schema.parse("5")).toBeInstanceOf(Date);
+  expect(schema.parse("2000-01-01")).toBeInstanceOf(Date);
+  // expect(schema.parse("0")).toBeInstanceOf(Date);
+  // expect(schema.parse("-5")).toBeInstanceOf(Date);
+  // expect(schema.parse("3.14")).toBeInstanceOf(Date);
+  expect(() => schema.parse("")).toThrow(); // z.ZodError
+  expect(() => schema.parse("NOT_A_DATE")).toThrow(); // z.ZodError
+  expect(schema.parse(5)).toBeInstanceOf(Date);
+  expect(schema.parse(0)).toBeInstanceOf(Date);
+  expect(schema.parse(-5)).toBeInstanceOf(Date);
+  expect(schema.parse(3.14)).toBeInstanceOf(Date);
+  expect(() => schema.parse(BigInt(5))).toThrow(); // not a z.ZodError!
+  expect(() => schema.parse(Number.NaN)).toThrow(); // z.ZodError
+  expect(() => schema.parse(Number.POSITIVE_INFINITY)).toThrow(); // z.ZodError
+  expect(() => schema.parse(Number.NEGATIVE_INFINITY)).toThrow(); // z.ZodError
+  expect(schema.parse(true)).toBeInstanceOf(Date);
+  expect(schema.parse(false)).toBeInstanceOf(Date);
+  expect(schema.parse(null)).toBeInstanceOf(Date);
+  expect(() => schema.parse(undefined)).toThrow(); // z.ZodError
+  expect(() => schema.parse({ hello: "world!" })).toThrow(); // z.ZodError
+  expect(() => schema.parse(["item", "another_item"])).toThrow(); // z.ZodError
+  expect(() => schema.parse([])).toThrow(); // z.ZodError
+  expect(schema.parse(new Date())).toBeInstanceOf(Date);
+});

package/dist/zod/src/v3/tests/complex.test.ts

@@ -0,0 +1,56 @@
+import { test } from "vitest";
+import * as z from "zod/v3";
+
+const crazySchema = z.object({
+  tuple: z.tuple([
+    z.string().nullable().optional(),
+    z.number().nullable().optional(),
+    z.boolean().nullable().optional(),
+    z.null().nullable().optional(),
+    z.undefined().nullable().optional(),
+    z.literal("1234").nullable().optional(),
+  ]),
+  merged: z
+    .object({
+      k1: z.string().optional(),
+    })
+    .merge(z.object({ k1: z.string().nullable(), k2: z.number() })),
+  union: z.array(z.union([z.literal("asdf"), z.literal(12)])).nonempty(),
+  array: z.array(z.number()),
+  // sumTransformer: z.transformer(z.array(z.number()), z.number(), (arg) => {
+  //   return arg.reduce((a, b) => a + b, 0);
+  // }),
+  sumMinLength: z.array(z.number()).refine((arg) => arg.length > 5),
+  intersection: z.intersection(z.object({ p1: z.string().optional() }), z.object({ p1: z.number().optional() })),
+  enum: z.intersection(z.enum(["zero", "one"]), z.enum(["one", "two"])),
+  nonstrict: z.object({ points: z.number() }).nonstrict(),
+  numProm: z.promise(z.number()),
+  lenfun: z.function(z.tuple([z.string()]), z.boolean()),
+});
+
+// const asyncCrazySchema = crazySchema.extend({
+//   // async_transform: z.transformer(
+//   //   z.array(z.number()),
+//   //   z.number(),
+//   //   async (arg) => {
+//   //     return arg.reduce((a, b) => a + b, 0);
+//   //   }
+//   // ),
+//   async_refine: z.array(z.number()).refine(async (arg) => arg.length > 5),
+// });
+
+test("parse", () => {
+  crazySchema.parse({
+    tuple: ["asdf", 1234, true, null, undefined, "1234"],
+    merged: { k1: "asdf", k2: 12 },
+    union: ["asdf", 12, "asdf", 12, "asdf", 12],
+    array: [12, 15, 16],
+    // sumTransformer: [12, 15, 16],
+    sumMinLength: [12, 15, 16, 98, 24, 63],
+    intersection: {},
+    enum: "one",
+    nonstrict: { points: 1234 },
+    numProm: Promise.resolve(12),
+    lenfun: (x: string) => x.length,
+  });
+});

package/dist/zod/src/v3/tests/custom.test.ts

@@ -0,0 +1,31 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import * as z from "zod/v3";
+
+test("passing validations", () => {
+  const example1 = z.custom<number>((x) => typeof x === "number");
+  example1.parse(1234);
+  expect(() => example1.parse({})).toThrow();
+});
+
+test("string params", () => {
+  const example1 = z.custom<number>((x) => typeof x !== "number", "customerr");
+  const result = example1.safeParse(1234);
+  expect(result.success).toEqual(false);
+  // @ts-ignore
+  expect(JSON.stringify(result.error).includes("customerr")).toEqual(true);
+});
+
+test("async validations", async () => {
+  const example1 = z.custom<number>(async (x) => {
+    return typeof x === "number";
+  });
+  const r1 = await example1.safeParseAsync(1234);
+  expect(r1.success).toEqual(true);
+  expect(r1.data).toEqual(1234);
+
+  const r2 = await example1.safeParseAsync("asdf");
+  expect(r2.success).toEqual(false);
+  expect(r2.error!.issues.length).toEqual(1);
+});

package/dist/zod/src/v3/tests/date.test.ts

@@ -0,0 +1,32 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import * as z from "zod/v3";
+
+const beforeBenchmarkDate = new Date(2022, 10, 4);
+const benchmarkDate = new Date(2022, 10, 5);
+const afterBenchmarkDate = new Date(2022, 10, 6);
+
+const minCheck = z.date().min(benchmarkDate);
+const maxCheck = z.date().max(benchmarkDate);
+
+test("passing validations", () => {
+  minCheck.parse(benchmarkDate);
+  minCheck.parse(afterBenchmarkDate);
+
+  maxCheck.parse(benchmarkDate);
+  maxCheck.parse(beforeBenchmarkDate);
+});
+
+test("failing validations", () => {
+  expect(() => minCheck.parse(beforeBenchmarkDate)).toThrow();
+  expect(() => maxCheck.parse(afterBenchmarkDate)).toThrow();
+});
+
+test("min max getters", () => {
+  expect(minCheck.minDate).toEqual(benchmarkDate);
+  expect(minCheck.min(afterBenchmarkDate).minDate).toEqual(afterBenchmarkDate);
+
+  expect(maxCheck.maxDate).toEqual(benchmarkDate);
+  expect(maxCheck.max(beforeBenchmarkDate).maxDate).toEqual(beforeBenchmarkDate);
+});

package/dist/zod/src/v3/tests/deepmasking.test.ts

@@ -0,0 +1,186 @@
+// @ts-ignore TS6133
+import { test } from "vitest";
+
+import * as z from "zod/v3";
+
+test("test", () => {
+  z;
+});
+
+// const fish = z.object({
+//   name: z.string(),
+//   props: z.object({
+//     color: z.string(),
+//     numScales: z.number(),
+//   }),
+// });
+
+// const nonStrict = z
+//   .object({
+//     name: z.string(),
+//     color: z.string(),
+//   })
+//   .nonstrict();
+
+// test('object pick type', () => {
+//   const modNonStrictFish = nonStrict.omit({ name: true });
+//   modNonStrictFish.parse({ color: 'asdf' });
+
+//   const bad1 = () => fish.pick({ props: { unknown: true } } as any);
+//   const bad2 = () => fish.omit({ name: true, props: { unknown: true } } as any);
+
+//   expect(bad1).toThrow();
+//   expect(bad2).toThrow();
+// });
+
+// test('f1', () => {
+//   const f1 = fish.pick(true);
+//   f1.parse({ name: 'a', props: { color: 'b', numScales: 3 } });
+// });
+// test('f2', () => {
+//   const f2 = fish.pick({ props: true });
+//   f2.parse({ props: { color: 'asdf', numScales: 1 } });
+//   const badcheck2 = () => f2.parse({ name: 'a', props: { color: 'b', numScales: 3 } } as any);
+//   expect(badcheck2).toThrow();
+// });
+// test('f3', () => {
+//   const f3 = fish.pick({ props: { color: true } });
+//   f3.parse({ props: { color: 'b' } });
+//   const badcheck3 = () => f3.parse({ name: 'a', props: { color: 'b', numScales: 3 } } as any);
+//   expect(badcheck3).toThrow();
+// });
+// test('f4', () => {
+//   const badcheck4 = () => fish.pick({ props: { color: true, unknown: true } });
+//   expect(badcheck4).toThrow();
+// });
+// test('f6', () => {
+//   const f6 = fish.omit({ props: true });
+//   const badcheck6 = () => f6.parse({ name: 'a', props: { color: 'b', numScales: 3 } } as any);
+//   f6.parse({ name: 'adsf' });
+//   expect(badcheck6).toThrow();
+// });
+// test('f7', () => {
+//   const f7 = fish.omit({ props: { color: true } });
+//   f7.parse({ name: 'a', props: { numScales: 3 } });
+//   const badcheck7 = () => f7.parse({ name: 'a', props: { color: 'b', numScales: 3 } } as any);
+//   expect(badcheck7).toThrow();
+// });
+// test('f8', () => {
+//   const badcheck8 = () => fish.omit({ props: { color: true, unknown: true } });
+//   expect(badcheck8).toThrow();
+// });
+// test('f9', () => {
+//   const f9 = nonStrict.pick(true);
+//   f9.parse({ name: 'a', color: 'asdf' });
+// });
+// test('f10', () => {
+//   const f10 = nonStrict.pick({ name: true });
+//   f10.parse({ name: 'a' });
+//   const val = f10.parse({ name: 'a', color: 'b' });
+//   expect(val).toEqual({ name: 'a' });
+// });
+// test('f12', () => {
+//   const badfcheck12 = () => nonStrict.omit({ color: true, asdf: true });
+//   expect(badfcheck12).toThrow();
+// });
+
+// test('array masking', () => {
+//   const fishArray = z.array(fish);
+//   const modFishArray = fishArray.pick({
+//     name: true,
+//     props: {
+//       numScales: true,
+//     },
+//   });
+
+//   modFishArray.parse([{ name: 'fish', props: { numScales: 12 } }]);
+//   const bad1 = () => modFishArray.parse([{ name: 'fish', props: { numScales: 12, color: 'asdf' } }] as any);
+//   expect(bad1).toThrow();
+// });
+
+// test('array masking', () => {
+//   const fishArray = z.array(fish);
+//   const fail = () =>
+//     fishArray.pick({
+//       name: true,
+//       props: {
+//         whatever: true,
+//       },
+//     } as any);
+//   expect(fail).toThrow();
+// });
+
+// test('array masking', () => {
+//   const fishArray = z.array(fish);
+//   const fail = () =>
+//     fishArray.omit({
+//       whateve: true,
+//     } as any);
+//   expect(fail).toThrow();
+// });
+
+// test('array masking', () => {
+//   const fishArray = z.array(fish);
+//   const modFishList = fishArray.omit({
+//     name: true,
+//     props: {
+//       color: true,
+//     },
+//   });
+
+//   modFishList.parse([{ props: { numScales: 12 } }]);
+//   const fail = () => modFishList.parse([{ name: 'hello', props: { numScales: 12 } }] as any);
+//   expect(fail).toThrow();
+// });
+
+// test('primitive array masking', () => {
+//   const fishArray = z.array(z.number());
+//   const fail = () => fishArray.pick({} as any);
+//   expect(fail).toThrow();
+// });
+
+// test('other array masking', () => {
+//   const fishArray = z.array(z.array(z.number()));
+//   const fail = () => fishArray.pick({} as any);
+//   expect(fail).toThrow();
+// });
+
+// test('invalid mask #1', () => {
+//   const fail = () => fish.pick(1 as any);
+//   expect(fail).toThrow();
+// });
+
+// test('invalid mask #2', () => {
+//   const fail = () => fish.pick([] as any);
+//   expect(fail).toThrow();
+// });
+
+// test('invalid mask #3', () => {
+//   const fail = () => fish.pick(false as any);
+//   expect(fail).toThrow();
+// });
+
+// test('invalid mask #4', () => {
+//   const fail = () => fish.pick('asdf' as any);
+//   expect(fail).toThrow();
+// });
+
+// test('invalid mask #5', () => {
+//   const fail = () => fish.omit(1 as any);
+//   expect(fail).toThrow();
+// });
+
+// test('invalid mask #6', () => {
+//   const fail = () => fish.omit([] as any);
+//   expect(fail).toThrow();
+// });
+
+// test('invalid mask #7', () => {
+//   const fail = () => fish.omit(false as any);
+//   expect(fail).toThrow();
+// });
+
+// test('invalid mask #8', () => {
+//   const fail = () => fish.omit('asdf' as any);
+//   expect(fail).toThrow();
+// });