@psiclawops/hypermem 0.8.5 → 0.9.1

package/node_modules/zod/src/v4/classic/tests/coerce.test.ts

@@ -1,160 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-
-import * as z from "zod/v4";
-
-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);
-});
-
-// test("template literal coercion", () => {
-//   const schema = z.coerce
-//     .templateLiteral()
-//     .interpolated(z.number().finite())
-//     .interpolated(
-//       z.enum(["px", "em", "rem", "vh", "vw", "vmin", "vmax"]).optional()
-//     );
-//   expect(schema.parse(300)).toEqual("300");
-//   expect(schema.parse(BigInt(300))).toEqual("300");
-//   expect(schema.parse("300")).toEqual("300");
-//   expect(schema.parse("300px")).toEqual("300px");
-//   expect(schema.parse("300em")).toEqual("300em");
-//   expect(schema.parse("300rem")).toEqual("300rem");
-//   expect(schema.parse("300vh")).toEqual("300vh");
-//   expect(schema.parse("300vw")).toEqual("300vw");
-//   expect(schema.parse("300vmin")).toEqual("300vmin");
-//   expect(schema.parse("300vmax")).toEqual("300vmax");
-//   expect(schema.parse(["300px"])).toEqual("300px");
-// });
-
-test("override input type", () => {
-  const a = z.coerce.string<any>();
-  type input = z.input<typeof a>;
-  expectTypeOf<input>().toEqualTypeOf<any>();
-  type output = z.infer<typeof a>;
-  expectTypeOf<output>().toEqualTypeOf<string>();
-});

package/node_modules/zod/src/v4/classic/tests/continuability.test.ts

@@ -1,374 +0,0 @@
-import { expect, test } from "vitest";
-import * as z from "zod/v4";
-
-test("continuability", () => {
-  /** 
-   *  | $ZodGUID
-  | $ZodUUID
-  | $ZodEmail
-  | $ZodURL
-  | $ZodEmoji
-  | $ZodNanoID
-  | $ZodCUID
-  | $ZodCUID2
-  | $ZodULID
-  | $ZodXID
-  | $ZodKSUID
-  | $ZodISODateTime
-  | $ZodISODate
-  | $ZodISOTime
-  | $ZodISODuration
-  | $ZodIPv4
-  | $ZodIPv6
-  | $ZodCIDRv4
-  | $ZodCIDRv6
-  | $ZodBase64
-  | $ZodBase64URL
-  | $ZodE164
-  | $ZodJWT;
-   */
-  expect(
-    z
-      .email()
-      .refine(() => false)
-      .safeParse("invalid_value").error!.issues
-  ).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "invalid_format",
-        "format": "email",
-        "message": "Invalid email address",
-        "origin": "string",
-        "path": [],
-        "pattern": "/^(?!\\.)(?!.*\\.\\.)([A-Za-z0-9_'+\\-\\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$/",
-      },
-      {
-        "code": "custom",
-        "message": "Invalid input",
-        "path": [],
-      },
-    ]
-  `);
-  expect(
-    z
-      .uuid()
-      .refine(() => false)
-      .safeParse("invalid_value").error!.issues
-  ).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "invalid_format",
-        "format": "uuid",
-        "message": "Invalid UUID",
-        "origin": "string",
-        "path": [],
-        "pattern": "/^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/",
-      },
-      {
-        "code": "custom",
-        "message": "Invalid input",
-        "path": [],
-      },
-    ]
-  `);
-  expect(
-    z
-      .url()
-      .refine(() => false)
-      .safeParse("invalid_value").error!.issues
-  ).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "invalid_format",
-        "format": "url",
-        "message": "Invalid URL",
-        "path": [],
-      },
-      {
-        "code": "custom",
-        "message": "Invalid input",
-        "path": [],
-      },
-    ]
-  `);
-  expect(
-    z
-      .jwt()
-      .refine(() => false)
-      .safeParse("invalid_value").error!.issues
-  ).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "invalid_format",
-        "format": "jwt",
-        "message": "Invalid JWT",
-        "path": [],
-      },
-      {
-        "code": "custom",
-        "message": "Invalid input",
-        "path": [],
-      },
-    ]
-  `);
-  expect(
-    z
-      .cidrv4()
-      .refine(() => false)
-      .safeParse("invalid_value").error!.issues
-  ).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "invalid_format",
-        "format": "cidrv4",
-        "message": "Invalid IPv4 range",
-        "origin": "string",
-        "path": [],
-        "pattern": "/^((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])\\/([0-9]|[1-2][0-9]|3[0-2])$/",
-      },
-      {
-        "code": "custom",
-        "message": "Invalid input",
-        "path": [],
-      },
-    ]
-  `);
-  expect(
-    z
-      .cidrv6()
-      .refine(() => false)
-      .safeParse("invalid_value").error!.issues
-  ).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "invalid_format",
-        "format": "cidrv6",
-        "message": "Invalid IPv6 range",
-        "path": [],
-      },
-      {
-        "code": "custom",
-        "message": "Invalid input",
-        "path": [],
-      },
-    ]
-  `);
-  expect(
-    z
-      .ipv4()
-      .refine(() => false)
-      .safeParse("invalid_value").error!.issues
-  ).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "invalid_format",
-        "format": "ipv4",
-        "message": "Invalid IPv4 address",
-        "origin": "string",
-        "path": [],
-        "pattern": "/^(?:(?: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])$/",
-      },
-      {
-        "code": "custom",
-        "message": "Invalid input",
-        "path": [],
-      },
-    ]
-  `);
-  expect(
-    z
-      .ipv6()
-      .refine(() => false)
-      .safeParse("invalid_value").error!.issues
-  ).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "invalid_format",
-        "format": "ipv6",
-        "message": "Invalid IPv6 address",
-        "path": [],
-      },
-      {
-        "code": "custom",
-        "message": "Invalid input",
-        "path": [],
-      },
-    ]
-  `);
-  expect(
-    z
-      .mac()
-      .refine(() => false)
-      .safeParse("invalid_value").error!.issues
-  ).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "invalid_format",
-        "format": "mac",
-        "message": "Invalid MAC address",
-        "origin": "string",
-        "path": [],
-        "pattern": "/^(?:[0-9A-F]{2}:){5}[0-9A-F]{2}$|^(?:[0-9a-f]{2}:){5}[0-9a-f]{2}$/",
-      },
-      {
-        "code": "custom",
-        "message": "Invalid input",
-        "path": [],
-      },
-    ]
-  `);
-  expect(
-    z
-      .emoji()
-      .refine(() => false)
-      .safeParse("invalid_value").error!.issues
-  ).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "invalid_format",
-        "format": "emoji",
-        "message": "Invalid emoji",
-        "origin": "string",
-        "path": [],
-        "pattern": "/^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$/u",
-      },
-      {
-        "code": "custom",
-        "message": "Invalid input",
-        "path": [],
-      },
-    ]
-  `);
-  expect(
-    z
-      .nanoid()
-      .refine(() => false)
-      .safeParse("invalid_value").error!.issues
-  ).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "invalid_format",
-        "format": "nanoid",
-        "message": "Invalid nanoid",
-        "origin": "string",
-        "path": [],
-        "pattern": "/^[a-zA-Z0-9_-]{21}$/",
-      },
-      {
-        "code": "custom",
-        "message": "Invalid input",
-        "path": [],
-      },
-    ]
-  `);
-  expect(
-    z
-      .cuid()
-      .refine(() => false)
-      .safeParse("invalid_value").error!.issues
-  ).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "invalid_format",
-        "format": "cuid",
-        "message": "Invalid cuid",
-        "origin": "string",
-        "path": [],
-        "pattern": "/^[cC][^\\s-]{8,}$/",
-      },
-      {
-        "code": "custom",
-        "message": "Invalid input",
-        "path": [],
-      },
-    ]
-  `);
-  expect(
-    z
-      .cuid2()
-      .refine(() => false)
-      .safeParse("invalid_value").error!.issues
-  ).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "invalid_format",
-        "format": "cuid2",
-        "message": "Invalid cuid2",
-        "origin": "string",
-        "path": [],
-        "pattern": "/^[0-9a-z]+$/",
-      },
-      {
-        "code": "custom",
-        "message": "Invalid input",
-        "path": [],
-      },
-    ]
-  `);
-  expect(
-    z
-      .ulid()
-      .refine(() => false)
-      .safeParse("invalid_value").error!.issues
-  ).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "invalid_format",
-        "format": "ulid",
-        "message": "Invalid ULID",
-        "origin": "string",
-        "path": [],
-        "pattern": "/^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/",
-      },
-      {
-        "code": "custom",
-        "message": "Invalid input",
-        "path": [],
-      },
-    ]
-  `);
-  expect(
-    z
-      .xid()
-      .refine(() => false)
-      .safeParse("invalid_value").error!.issues
-  ).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "invalid_format",
-        "format": "xid",
-        "message": "Invalid XID",
-        "origin": "string",
-        "path": [],
-        "pattern": "/^[0-9a-vA-V]{20}$/",
-      },
-      {
-        "code": "custom",
-        "message": "Invalid input",
-        "path": [],
-      },
-    ]
-  `);
-  expect(
-    z
-      .ksuid()
-      .refine(() => false)
-      .safeParse("invalid_value").error!.issues
-  ).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "invalid_format",
-        "format": "ksuid",
-        "message": "Invalid KSUID",
-        "origin": "string",
-        "path": [],
-        "pattern": "/^[A-Za-z0-9]{27}$/",
-      },
-      {
-        "code": "custom",
-        "message": "Invalid input",
-        "path": [],
-      },
-    ]
-  `);
-});

package/node_modules/zod/src/v4/classic/tests/custom.test.ts

@@ -1,40 +0,0 @@
-import { expect, test } from "vitest";
-
-import * as z from "zod/v4";
-
-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);
-  expect(JSON.stringify(result.error).includes("customerr")).toEqual(true);
-});
-
-test("instanceof", () => {
-  const fn = (value: string) => Uint8Array.from(Buffer.from(value, "base64"));
-
-  // Argument of type 'ZodCustom<Uint8Array<ArrayBuffer>, unknown>' is not assignable to parameter of type '$ZodType<any, Uint8Array<ArrayBuffer>>'.
-  z.string().transform(fn).pipe(z.instanceof(Uint8Array));
-});
-
-test("non-continuable by default", () => {
-  const A = z
-    .custom<string>((val) => typeof val === "string")
-    .transform((_) => {
-      throw new Error("Invalid input");
-    });
-  expect(A.safeParse(123).error!).toMatchInlineSnapshot(`
-    [ZodError: [
-      {
-        "code": "custom",
-        "path": [],
-        "message": "Invalid input"
-      }
-    ]]
-  `);
-});

package/node_modules/zod/src/v4/classic/tests/date.test.ts

@@ -1,62 +0,0 @@
-import { expect, test } from "vitest";
-
-import * as z from "zod/v4";
-
-const beforeBenchmarkDate = new Date(Date.UTC(2022, 10, 4));
-const benchmarkDate = new Date(Date.UTC(2022, 10, 5));
-const afterBenchmarkDate = new Date(Date.UTC(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("date min", () => {
-  const result = minCheck.safeParse(beforeBenchmarkDate);
-
-  expect(result.success).toEqual(false);
-  expect(result.error!.issues).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "too_small",
-        "inclusive": true,
-        "message": "Too small: expected date to be >=1667606400000",
-        "minimum": 1667606400000,
-        "origin": "date",
-        "path": [],
-      },
-    ]
-  `);
-});
-
-test("date max", () => {
-  const result = maxCheck.safeParse(afterBenchmarkDate);
-
-  expect(result.success).toEqual(false);
-  expect(result.error!.issues).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "too_big",
-        "inclusive": true,
-        "maximum": 1667606400000,
-        "message": "Too big: expected date to be <=1667606400000",
-        "origin": "date",
-        "path": [],
-      },
-    ]
-  `);
-});
-
-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);
-});