zod 3.25.13 → 3.25.15

package/dist/v4/classic/tests/enum.test.js

@@ -0,0 +1,260 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const z = __importStar(require("zod/v4"));
+(0, vitest_1.test)("enum from string array", () => {
+    const MyEnum = z.enum(["Red", "Green", "Blue"]);
+    (0, vitest_1.expect)(MyEnum.enum.Red).toEqual("Red");
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+});
+(0, vitest_1.test)("enum from const object", () => {
+    const Fruits = {
+        Apple: "apple",
+        Banana: "banana",
+    };
+    const fruitEnum = z.nativeEnum(Fruits);
+    fruitEnum.parse("apple");
+    fruitEnum.parse("banana");
+    fruitEnum.parse(Fruits.Apple);
+    fruitEnum.parse(Fruits.Banana);
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+});
+(0, vitest_1.test)("enum from native enum", () => {
+    let Fruits;
+    (function (Fruits) {
+        Fruits["Apple"] = "apple";
+        Fruits["Banana"] = "banana";
+        Fruits[Fruits["Orange"] = 3] = "Orange";
+    })(Fruits || (Fruits = {}));
+    // @ts-ignore
+    const fruitEnum = z.nativeEnum(Fruits);
+    fruitEnum.parse("apple");
+    fruitEnum.parse("banana");
+    fruitEnum.parse(Fruits.Apple);
+    fruitEnum.parse(Fruits.Banana);
+    (0, vitest_1.expect)(fruitEnum.safeParse("Apple").success).toEqual(false);
+    (0, vitest_1.expect)(fruitEnum.safeParse("Cantaloupe").success).toEqual(false);
+    (0, vitest_1.expectTypeOf)().toMatchTypeOf();
+    (0, vitest_1.expectTypeOf)().toMatchTypeOf();
+});
+(0, vitest_1.test)("enum from native enum with numeric keys", () => {
+    const FruitValues = {
+        Apple: 10,
+        Banana: 20,
+        // @ts-ignore
+    };
+    const fruitEnum = z.nativeEnum(FruitValues);
+    fruitEnum.parse(10);
+    fruitEnum.parse(20);
+    fruitEnum.parse(FruitValues.Apple);
+    fruitEnum.parse(FruitValues.Banana);
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+});
+(0, vitest_1.test)("issue metadata", () => {
+    const schema = z.enum(["Red", "Green", "Blue"]);
+    const result = schema.safeParse("Yellow");
+    (0, vitest_1.expect)(result.error.issues[0]).toMatchInlineSnapshot(`
+    {
+      "code": "invalid_value",
+      "message": "Invalid option: expected one of "Red"|"Green"|"Blue"",
+      "path": [],
+      "values": [
+        "Red",
+        "Green",
+        "Blue",
+      ],
+    }
+  `);
+});
+(0, vitest_1.test)("enum from non-const inputs", () => {
+    const foods = ["Pasta", "Pizza", "Tacos", "Burgers", "Salad"];
+    const FoodEnum = z.enum(foods);
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expect)(FoodEnum.safeParse("Pasta").success).toEqual(true);
+    (0, vitest_1.expect)(FoodEnum.safeParse("Cucumbers").success).toEqual(false);
+});
+(0, vitest_1.test)("get options", () => {
+    (0, vitest_1.expect)(z.enum(["tuna", "trout"]).options).toEqual(["tuna", "trout"]);
+});
+(0, vitest_1.test)("readonly enum", () => {
+    const HTTP_SUCCESS = ["200", "201"];
+    const arg = z.enum(HTTP_SUCCESS);
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    arg.parse("201");
+    (0, vitest_1.expect)(() => arg.parse("202")).toThrow();
+});
+(0, vitest_1.test)("error map", () => {
+    const result = z
+        .enum(["test"], { error: (iss) => (iss.input === undefined ? "REQUIRED" : undefined) })
+        .safeParse(undefined);
+    (0, vitest_1.expect)(result.success).toEqual(false);
+    if (!result.success) {
+        (0, vitest_1.expect)(result.error.issues[0].message).toEqual("REQUIRED");
+    }
+});
+(0, vitest_1.test)("type signatures", () => {
+    const a = z.enum(["a", "b", "c"]);
+    const b = z.enum(a.options);
+    (0, vitest_1.expectTypeOf)(a).toEqualTypeOf(b);
+    const c = z.enum({ a: 1, b: 2 });
+    (0, vitest_1.expectTypeOf)(c.enum).toEqualTypeOf();
+    let Fruit;
+    (function (Fruit) {
+        Fruit["Apple"] = "apple";
+        Fruit["Banana"] = "banana";
+        Fruit["Orange"] = "orange";
+    })(Fruit || (Fruit = {}));
+    const d = z.enum(Fruit);
+    (0, vitest_1.expectTypeOf)(d.enum).toEqualTypeOf(Fruit);
+    const e = z.enum({ a: 1, b: 2 });
+    (0, vitest_1.expectTypeOf)(e.enum).toEqualTypeOf();
+});
+(0, vitest_1.test)("extract", () => {
+    const foods = ["Pasta", "Pizza", "Tacos", "Burgers", "Salad"];
+    const FoodEnum = z.enum(foods);
+    const ItalianEnum = FoodEnum.extract(["Pasta", "Pizza"]);
+    (0, vitest_1.expect)(ItalianEnum.safeParse("Pasta").success).toEqual(true);
+    (0, vitest_1.expect)(ItalianEnum.safeParse("Tacos").success).toEqual(false);
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+});
+(0, vitest_1.test)("exclude", () => {
+    const foods = ["Pasta", "Pizza", "Tacos", "Burgers", "Salad"];
+    const FoodEnum = z.enum(foods);
+    const UnhealthyEnum = FoodEnum.exclude(["Salad"]);
+    (0, vitest_1.expect)(UnhealthyEnum.safeParse("Pasta").success).toEqual(true);
+    (0, vitest_1.expect)(UnhealthyEnum.safeParse("Salad").success).toEqual(false);
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    const EmptyFoodEnum = FoodEnum.exclude(foods);
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+});
+(0, vitest_1.test)("error map inheritance", () => {
+    const foods = ["Pasta", "Pizza", "Tacos", "Burgers", "Salad"];
+    const FoodEnum = z.enum(foods, { error: () => "This is not food!" });
+    const ItalianEnum = FoodEnum.extract(["Pasta", "Pizza"]);
+    const foodsError = FoodEnum.safeParse("Cucumbers");
+    const italianError = ItalianEnum.safeParse("Tacos");
+    (0, vitest_1.expect)(foodsError.error.issues[0].message).toEqual(italianError.error.issues[0].message);
+    const UnhealthyEnum = FoodEnum.exclude(["Salad"], {
+        error: () => ({ message: "This is not healthy food!" }),
+    });
+    const unhealthyError = UnhealthyEnum.safeParse("Salad");
+    if (!unhealthyError.success) {
+        (0, vitest_1.expect)(unhealthyError.error.issues[0].message).toEqual("This is not healthy food!");
+    }
+});
+(0, vitest_1.test)("readonly in ZodEnumDef", () => {
+});
+(0, vitest_1.test)("enum error message, invalid enum elementstring", () => {
+    const result = z.enum(["Tuna", "Trout"]).safeParse("Salmon");
+    (0, vitest_1.expect)(result.success).toEqual(false);
+    (0, vitest_1.expect)(result.error.issues.length).toEqual(1);
+    (0, vitest_1.expect)(result.error).toMatchInlineSnapshot(`
+    [ZodError: [
+      {
+        "code": "invalid_value",
+        "values": [
+          "Tuna",
+          "Trout"
+        ],
+        "path": [],
+        "message": "Invalid option: expected one of \\"Tuna\\"|\\"Trout\\""
+      }
+    ]]
+  `);
+});
+(0, vitest_1.test)("enum error message, invalid type", () => {
+    const result = z.enum(["Tuna", "Trout"]).safeParse(12);
+    (0, vitest_1.expect)(result.success).toEqual(false);
+    (0, vitest_1.expect)(result.error.issues.length).toEqual(1);
+    // expect(result.error!.issues[0].message).toEqual('Invalid input: expected one of "Tuna"|"Trout"');
+    (0, vitest_1.expect)(result.error).toMatchInlineSnapshot(`
+    [ZodError: [
+      {
+        "code": "invalid_value",
+        "values": [
+          "Tuna",
+          "Trout"
+        ],
+        "path": [],
+        "message": "Invalid option: expected one of \\"Tuna\\"|\\"Trout\\""
+      }
+    ]]
+  `);
+});
+(0, vitest_1.test)("nativeEnum default error message", () => {
+    let Fish;
+    (function (Fish) {
+        Fish["Tuna"] = "Tuna";
+        Fish["Trout"] = "Trout";
+    })(Fish || (Fish = {}));
+    const result = z.nativeEnum(Fish).safeParse("Salmon");
+    (0, vitest_1.expect)(result.success).toEqual(false);
+    (0, vitest_1.expect)(result.error.issues.length).toEqual(1);
+    // expect(result.error!.issues[0].message).toEqual('Invalid input: expected one of "Tuna"|"Trout"');
+    (0, vitest_1.expect)(result.error).toMatchInlineSnapshot(`
+    [ZodError: [
+      {
+        "code": "invalid_value",
+        "values": [
+          "Tuna",
+          "Trout"
+        ],
+        "path": [],
+        "message": "Invalid option: expected one of \\"Tuna\\"|\\"Trout\\""
+      }
+    ]]
+  `);
+});
+(0, vitest_1.test)("enum with message returns the custom error message", () => {
+    const schema = z.enum(["apple", "banana"], {
+        message: "the value provided is invalid",
+    });
+    const result1 = schema.safeParse("berries");
+    (0, vitest_1.expect)(result1.success).toEqual(false);
+    if (!result1.success) {
+        (0, vitest_1.expect)(result1.error.issues[0].message).toEqual("the value provided is invalid");
+    }
+    const result2 = schema.safeParse(undefined);
+    (0, vitest_1.expect)(result2.success).toEqual(false);
+    if (!result2.success) {
+        (0, vitest_1.expect)(result2.error.issues[0].message).toEqual("the value provided is invalid");
+    }
+    const result3 = schema.safeParse("banana");
+    (0, vitest_1.expect)(result3.success).toEqual(true);
+    const result4 = schema.safeParse(null);
+    (0, vitest_1.expect)(result4.success).toEqual(false);
+    if (!result4.success) {
+        (0, vitest_1.expect)(result4.error.issues[0].message).toEqual("the value provided is invalid");
+    }
+});
+(0, vitest_1.test)("enum with diagonal keys", () => {
+    const schema_02 = z.enum({
+        A: 1,
+        B: "A",
+    });
+    (0, vitest_1.expect)(schema_02.safeParse("A")).toMatchObject({ success: true });
+});

package/dist/v4/classic/tests/error-utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/v4/classic/tests/error-utils.test.js

@@ -0,0 +1,411 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const z = __importStar(require("zod/v4"));
+const Test = z.object({
+    f1: z.number(),
+    f2: z.string().optional(),
+    f3: z.string().nullable(),
+    f4: z.array(z.object({ t: z.union([z.string(), z.boolean()]) })),
+});
+// type TestFlattenedErrors = core.inferFlattenedErrors<typeof Test, { message: string; code: number }>;
+// type TestFormErrors = core.inferFlattenedErrors<typeof Test>;
+const parsed = Test.safeParse({});
+(0, vitest_1.test)("regular error", () => {
+    (0, vitest_1.expect)(parsed).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "expected": "number",
+        "code": "invalid_type",
+        "path": [
+          "f1"
+        ],
+        "message": "Invalid input: expected number, received undefined"
+      },
+      {
+        "expected": "string",
+        "code": "invalid_type",
+        "path": [
+          "f3"
+        ],
+        "message": "Invalid input: expected string, received undefined"
+      },
+      {
+        "expected": "array",
+        "code": "invalid_type",
+        "path": [
+          "f4"
+        ],
+        "message": "Invalid input: expected array, received undefined"
+      }
+    ]],
+      "success": false,
+    }
+  `);
+});
+(0, vitest_1.test)(".flatten()", () => {
+    const flattened = parsed.error.flatten();
+    // flattened.
+    (0, vitest_1.expectTypeOf)(flattened).toMatchTypeOf();
+    (0, vitest_1.expect)(flattened).toMatchInlineSnapshot(`
+    {
+      "fieldErrors": {
+        "f1": [
+          "Invalid input: expected number, received undefined",
+        ],
+        "f3": [
+          "Invalid input: expected string, received undefined",
+        ],
+        "f4": [
+          "Invalid input: expected array, received undefined",
+        ],
+      },
+      "formErrors": [],
+    }
+  `);
+});
+(0, vitest_1.test)("custom .flatten()", () => {
+    const flattened = parsed.error.flatten((iss) => ({ message: iss.message, code: 1234 }));
+    (0, vitest_1.expectTypeOf)(flattened).toMatchTypeOf();
+    (0, vitest_1.expect)(flattened).toMatchInlineSnapshot(`
+    {
+      "fieldErrors": {
+        "f1": [
+          {
+            "code": 1234,
+            "message": "Invalid input: expected number, received undefined",
+          },
+        ],
+        "f3": [
+          {
+            "code": 1234,
+            "message": "Invalid input: expected string, received undefined",
+          },
+        ],
+        "f4": [
+          {
+            "code": 1234,
+            "message": "Invalid input: expected array, received undefined",
+          },
+        ],
+      },
+      "formErrors": [],
+    }
+  `);
+});
+(0, vitest_1.test)(".format()", () => {
+    const formatted = parsed.error.format();
+    (0, vitest_1.expectTypeOf)(formatted).toMatchTypeOf();
+    (0, vitest_1.expect)(formatted).toMatchInlineSnapshot(`
+    {
+      "_errors": [],
+      "f1": {
+        "_errors": [
+          "Invalid input: expected number, received undefined",
+        ],
+      },
+      "f3": {
+        "_errors": [
+          "Invalid input: expected string, received undefined",
+        ],
+      },
+      "f4": {
+        "_errors": [
+          "Invalid input: expected array, received undefined",
+        ],
+      },
+    }
+  `);
+});
+(0, vitest_1.test)("custom .format()", () => {
+    const formatted = parsed.error.format((iss) => ({ message: iss.message, code: 1234 }));
+    (0, vitest_1.expectTypeOf)(formatted).toMatchTypeOf();
+    (0, vitest_1.expect)(formatted).toMatchInlineSnapshot(`
+    {
+      "_errors": [],
+      "f1": {
+        "_errors": [
+          {
+            "code": 1234,
+            "message": "Invalid input: expected number, received undefined",
+          },
+        ],
+      },
+      "f3": {
+        "_errors": [
+          {
+            "code": 1234,
+            "message": "Invalid input: expected string, received undefined",
+          },
+        ],
+      },
+      "f4": {
+        "_errors": [
+          {
+            "code": 1234,
+            "message": "Invalid input: expected array, received undefined",
+          },
+        ],
+      },
+    }
+  `);
+});
+(0, vitest_1.test)("all errors", () => {
+    const propertySchema = z.string();
+    const schema = z
+        .object({
+        a: propertySchema,
+        b: propertySchema,
+    })
+        .refine((val) => {
+        return val.a === val.b;
+    }, { message: "Must be equal" });
+    const r1 = schema.safeParse({
+        a: "asdf",
+        b: "qwer",
+    });
+    (0, vitest_1.expect)(z.core.flattenError(r1.error)).toEqual({
+        formErrors: ["Must be equal"],
+        fieldErrors: {},
+    });
+    const r2 = schema.safeParse({
+        a: null,
+        b: null,
+    });
+    // const error = _error as z.ZodError;
+    (0, vitest_1.expect)(z.core.flattenError(r2.error)).toMatchInlineSnapshot(`
+    {
+      "fieldErrors": {
+        "a": [
+          "Invalid input: expected string, received null",
+        ],
+        "b": [
+          "Invalid input: expected string, received null",
+        ],
+      },
+      "formErrors": [],
+    }
+  `);
+    (0, vitest_1.expect)(z.core.flattenError(r2.error, (iss) => iss.message.toUpperCase())).toMatchInlineSnapshot(`
+    {
+      "fieldErrors": {
+        "a": [
+          "INVALID INPUT: EXPECTED STRING, RECEIVED NULL",
+        ],
+        "b": [
+          "INVALID INPUT: EXPECTED STRING, RECEIVED NULL",
+        ],
+      },
+      "formErrors": [],
+    }
+  `);
+    // Test identity
+    (0, vitest_1.expect)(z.core.flattenError(r2.error, (i) => i)).toMatchInlineSnapshot(`
+    {
+      "fieldErrors": {
+        "a": [
+          {
+            "code": "invalid_type",
+            "expected": "string",
+            "message": "Invalid input: expected string, received null",
+            "path": [
+              "a",
+            ],
+          },
+        ],
+        "b": [
+          {
+            "code": "invalid_type",
+            "expected": "string",
+            "message": "Invalid input: expected string, received null",
+            "path": [
+              "b",
+            ],
+          },
+        ],
+      },
+      "formErrors": [],
+    }
+  `);
+    // Test mapping
+    const f1 = z.core.flattenError(r2.error, (i) => i.message.length);
+    (0, vitest_1.expect)(f1).toMatchInlineSnapshot(`
+    {
+      "fieldErrors": {
+        "a": [
+          45,
+        ],
+        "b": [
+          45,
+        ],
+      },
+      "formErrors": [],
+    }
+  `);
+    // expect(f1.fieldErrors.a![0]).toEqual("Invalid input: expected string".length);
+    // expect(f1).toMatchObject({
+    //   formErrors: [],
+    //   fieldErrors: {
+    //     a: ["Invalid input: expected string".length],
+    //     b: ["Invalid input: expected string".length],
+    //   },
+    // });
+});
+const schema = z.strictObject({
+    username: z.string(),
+    favoriteNumbers: z.array(z.number()),
+    nesting: z.object({
+        a: z.string(),
+    }),
+});
+const result = schema.safeParse({
+    username: 1234,
+    favoriteNumbers: [1234, "4567"],
+    nesting: {
+        a: 123,
+    },
+    extra: 1234,
+});
+(0, vitest_1.test)("z.treeifyError", () => {
+    (0, vitest_1.expect)(z.treeifyError(result.error)).toMatchInlineSnapshot(`
+    {
+      "errors": [
+        "Unrecognized key: "extra"",
+      ],
+      "properties": {
+        "favoriteNumbers": {
+          "errors": [],
+          "items": [
+            ,
+            {
+              "errors": [
+                "Invalid input: expected number, received string",
+              ],
+            },
+          ],
+        },
+        "nesting": {
+          "errors": [],
+          "properties": {
+            "a": {
+              "errors": [
+                "Invalid input: expected string, received number",
+              ],
+            },
+          },
+        },
+        "username": {
+          "errors": [
+            "Invalid input: expected string, received number",
+          ],
+        },
+      },
+    }
+  `);
+});
+(0, vitest_1.test)("z.treeifyError 2", () => {
+    const schema = z.strictObject({
+        name: z.string(),
+        logLevel: z.union([z.string(), z.number()]),
+        env: z.literal(["production", "development"]),
+    });
+    const data = {
+        name: 1000,
+        logLevel: false,
+        extra: 1000,
+    };
+    const result = schema.safeParse(data);
+    const err = z.treeifyError(result.error);
+    (0, vitest_1.expect)(err).toMatchInlineSnapshot(`
+    {
+      "errors": [
+        "Unrecognized key: "extra"",
+      ],
+      "properties": {
+        "env": {
+          "errors": [
+            "Invalid option: expected one of "production"|"development"",
+          ],
+        },
+        "logLevel": {
+          "errors": [
+            "Invalid input: expected string, received boolean",
+            "Invalid input: expected number, received boolean",
+          ],
+        },
+        "name": {
+          "errors": [
+            "Invalid input: expected string, received number",
+          ],
+        },
+      },
+    }
+  `);
+});
+(0, vitest_1.test)("z.prettifyError", () => {
+    (0, vitest_1.expect)(z.prettifyError(result.error)).toMatchInlineSnapshot(`
+    "✖ Unrecognized key: "extra"
+    ✖ Invalid input: expected string, received number
+      → at username
+    ✖ Invalid input: expected number, received string
+      → at favoriteNumbers[1]
+    ✖ Invalid input: expected string, received number
+      → at nesting.a"
+  `);
+});
+(0, vitest_1.test)("z.toDotPath", () => {
+    (0, vitest_1.expect)(z.core.toDotPath(["a", "b", 0, "c"])).toMatchInlineSnapshot(`"a.b[0].c"`);
+    (0, vitest_1.expect)(z.core.toDotPath(["a", Symbol("b"), 0, "c"])).toMatchInlineSnapshot(`"a["Symbol(b)"][0].c"`);
+    // Test with periods in keys
+    (0, vitest_1.expect)(z.core.toDotPath(["user.name", "first.last"])).toMatchInlineSnapshot(`"["user.name"]["first.last"]"`);
+    // Test with special characters
+    (0, vitest_1.expect)(z.core.toDotPath(["user", "$special", Symbol("#symbol")])).toMatchInlineSnapshot(`"user.$special["Symbol(#symbol)"]"`);
+    // Test with dots and quotes
+    (0, vitest_1.expect)(z.core.toDotPath(["search", `query("foo.bar"="abc")`])).toMatchInlineSnapshot(`"search["query(\\"foo.bar\\"=\\"abc\\")"]"`);
+    // Test with newlines
+    (0, vitest_1.expect)(z.core.toDotPath(["search", `foo\nbar`])).toMatchInlineSnapshot(`"search["foo\\nbar"]"`);
+    // Test with empty strings
+    (0, vitest_1.expect)(z.core.toDotPath(["", "empty"])).toMatchInlineSnapshot(`".empty"`);
+    // Test with array indices
+    (0, vitest_1.expect)(z.core.toDotPath(["items", 0, 1, 2])).toMatchInlineSnapshot(`"items[0][1][2]"`);
+    // Test with mixed path elements
+    (0, vitest_1.expect)(z.core.toDotPath(["users", "user.config", 0, "settings.theme"])).toMatchInlineSnapshot(`"users["user.config"][0]["settings.theme"]"`);
+    // Test with square brackets in keys
+    (0, vitest_1.expect)(z.core.toDotPath(["data[0]", "value"])).toMatchInlineSnapshot(`"["data[0]"].value"`);
+    // Test with empty path
+    (0, vitest_1.expect)(z.core.toDotPath([])).toMatchInlineSnapshot(`""`);
+});
+(0, vitest_1.test)("inheritance", () => {
+    const e1 = new z.ZodError([]);
+    (0, vitest_1.expect)(e1).toBeInstanceOf(z.core.$ZodError);
+    (0, vitest_1.expect)(e1).toBeInstanceOf(z.ZodError);
+    // expect(e1).not.toBeInstanceOf(Error);
+    const e2 = new z.ZodRealError([]);
+    (0, vitest_1.expect)(e2).toBeInstanceOf(z.ZodError);
+    (0, vitest_1.expect)(e2).toBeInstanceOf(z.ZodRealError);
+    (0, vitest_1.expect)(e2).toBeInstanceOf(Error);
+});

package/dist/v4/classic/tests/error.test.d.ts

@@ -0,0 +1 @@
+export {};