storybook 10.0.0-beta.4 → 10.0.0-beta.5

package/dist/bin/dispatcher.js

@@ -1,31 +1,31 @@
 #!/usr/bin/env node
-import CJS_COMPAT_NODE_URL_bdftjtsviyb from 'node:url';
-import CJS_COMPAT_NODE_PATH_bdftjtsviyb from 'node:path';
-import CJS_COMPAT_NODE_MODULE_bdftjtsviyb from "node:module";
+import CJS_COMPAT_NODE_URL_0oz6lpav6bgq from 'node:url';
+import CJS_COMPAT_NODE_PATH_0oz6lpav6bgq from 'node:path';
+import CJS_COMPAT_NODE_MODULE_0oz6lpav6bgq from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_bdftjtsviyb.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_bdftjtsviyb.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_bdftjtsviyb.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_0oz6lpav6bgq.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_0oz6lpav6bgq.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_0oz6lpav6bgq.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Storybook's esbuild configuration
 // ------------------------------------------------------------
 import {
   versions_default
-} from "../_node-chunks/chunk-CHJLO2LV.js";
+} from "../_node-chunks/chunk-DWJ7TV2O.js";
 import {
   resolvePackageDir
-} from "../_node-chunks/chunk-TBAIXCHN.js";
+} from "../_node-chunks/chunk-KU3JBNPY.js";
 import {
   join
-} from "../_node-chunks/chunk-4VGW2SQA.js";
+} from "../_node-chunks/chunk-4VDRH7SM.js";
 import {
   require_dist
-} from "../_node-chunks/chunk-NOSGJ5PL.js";
+} from "../_node-chunks/chunk-P7YMEOXF.js";
 import {
   __name,
   __toESM
-} from "../_node-chunks/chunk-MOO2Y4GI.js";
+} from "../_node-chunks/chunk-2VMDKLSW.js";
 
 // src/bin/dispatcher.ts
 import { spawn } from "node:child_process";

package/dist/bin/loader.js

@@ -1,20 +1,20 @@
-import CJS_COMPAT_NODE_URL_bdftjtsviyb from 'node:url';
-import CJS_COMPAT_NODE_PATH_bdftjtsviyb from 'node:path';
-import CJS_COMPAT_NODE_MODULE_bdftjtsviyb from "node:module";
+import CJS_COMPAT_NODE_URL_0oz6lpav6bgq from 'node:url';
+import CJS_COMPAT_NODE_PATH_0oz6lpav6bgq from 'node:path';
+import CJS_COMPAT_NODE_MODULE_0oz6lpav6bgq from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_bdftjtsviyb.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_bdftjtsviyb.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_bdftjtsviyb.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_0oz6lpav6bgq.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_0oz6lpav6bgq.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_0oz6lpav6bgq.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Storybook's esbuild configuration
 // ------------------------------------------------------------
 import {
   NODE_TARGET
-} from "../_node-chunks/chunk-FWFQ2GU7.js";
+} from "../_node-chunks/chunk-QHIU5I7C.js";
 import {
   __name
-} from "../_node-chunks/chunk-MOO2Y4GI.js";
+} from "../_node-chunks/chunk-2VMDKLSW.js";
 
 // src/bin/loader.ts
 import { readFile } from "node:fs/promises";

package/dist/cli/index.d.ts

@@ -913,13 +913,16 @@ type Primitive = string | number | symbol | bigint | boolean | null | undefined;
 declare namespace util {
     type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? true : false;
     export type isAny<T> = 0 extends 1 & T ? true : false;
-    export const assertEqual: <A, B>(val: AssertEqual<A, B>) => AssertEqual<A, B>;
+    export const assertEqual: <A, B>(_: AssertEqual<A, B>) => void;
     export function assertIs<T>(_arg: T): void;
     export function assertNever(_x: never): never;
     export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
     export type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;
     export type MakePartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
     export type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;
+    export type InexactPartial<T> = {
+        [k in keyof T]?: T[k] | undefined;
+    };
     export const arrayToEnum: <T extends string, U extends [T, ...T[]]>(items: U) => { [k in U[number]]: k; };
     export const getValidEnumValues: (obj: any) => any[];
     export const objectValues: (obj: any) => any[];
@@ -970,24 +973,24 @@ declare namespace objectUtil {
 }
 declare const ZodParsedType: {
     string: "string";
-    number: "number";
-    bigint: "bigint";
-    boolean: "boolean";
-    symbol: "symbol";
-    undefined: "undefined";
-    object: "object";
-    function: "function";
-    map: "map";
     nan: "nan";
+    number: "number";
     integer: "integer";
     float: "float";
+    boolean: "boolean";
     date: "date";
+    bigint: "bigint";
+    symbol: "symbol";
+    function: "function";
+    undefined: "undefined";
     null: "null";
     array: "array";
+    object: "object";
     unknown: "unknown";
     promise: "promise";
     void: "void";
     never: "never";
+    map: "map";
     set: "set";
 };
 type ZodParsedType = keyof typeof ZodParsedType;
@@ -1020,7 +1023,7 @@ declare const ZodIssueCode: {
 type ZodIssueCode = keyof typeof ZodIssueCode;
 type ZodIssueBase = {
     path: (string | number)[];
-    message?: string;
+    message?: string | undefined;
 };
 interface ZodInvalidTypeIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.invalid_type;
@@ -1062,7 +1065,7 @@ interface ZodInvalidDateIssue extends ZodIssueBase {
 }
 type StringValidation = "email" | "url" | "emoji" | "uuid" | "nanoid" | "regex" | "cuid" | "cuid2" | "ulid" | "datetime" | "date" | "time" | "duration" | "ip" | "cidr" | "base64" | "jwt" | "base64url" | {
     includes: string;
-    position?: number;
+    position?: number | undefined;
 } | {
     startsWith: string;
 } | {
@@ -1104,7 +1107,7 @@ interface ZodCustomIssue extends ZodIssueBase {
 }
 type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodInvalidLiteralIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodNotFiniteIssue | ZodCustomIssue;
 type ZodIssue = ZodIssueOptionalMessage & {
-    fatal?: boolean;
+    fatal?: boolean | undefined;
     message: string;
 };
 type recursiveZodFormattedError<T> = T extends [any, ...any[]] ? {
@@ -1137,7 +1140,7 @@ declare class ZodError<T = any> extends Error {
 type stripPath<T extends object> = T extends any ? util.OmitKeys<T, "path"> : never;
 type IssueData = stripPath<ZodIssueOptionalMessage> & {
     path?: (string | number)[];
-    fatal?: boolean;
+    fatal?: boolean | undefined;
 };
 type ErrorMapCtx = {
     defaultError: string;
@@ -1157,11 +1160,11 @@ type ParsePath = ParsePathComponent[];
 interface ParseContext {
     readonly common: {
         readonly issues: ZodIssue[];
-        readonly contextualErrorMap?: ZodErrorMap;
+        readonly contextualErrorMap?: ZodErrorMap | undefined;
         readonly async: boolean;
     };
     readonly path: ParsePath;
-    readonly schemaErrorMap?: ZodErrorMap;
+    readonly schemaErrorMap?: ZodErrorMap | undefined;
     readonly parent: ParseContext | null;
     readonly data: any;
     readonly parsedType: ZodParsedType;
@@ -1215,7 +1218,7 @@ declare namespace enumUtil {
 
 declare namespace errorUtil {
     type ErrMessage = string | {
-        message?: string;
+        message?: string | undefined;
     };
     const errToObj: (message?: ErrMessage) => {
         message?: string | undefined;
@@ -1348,15 +1351,15 @@ type output<T extends ZodType<any, any, any>> = T["_output"];
 
 type CustomErrorParams = Partial<util.Omit<ZodCustomIssue, "code">>;
 interface ZodTypeDef {
-    errorMap?: ZodErrorMap;
-    description?: string;
+    errorMap?: ZodErrorMap | undefined;
+    description?: string | undefined;
 }
 type RawCreateParams = {
-    errorMap?: ZodErrorMap;
-    invalid_type_error?: string;
-    required_error?: string;
-    message?: string;
-    description?: string;
+    errorMap?: ZodErrorMap | undefined;
+    invalid_type_error?: string | undefined;
+    required_error?: string | undefined;
+    message?: string | undefined;
+    description?: string | undefined;
 } | undefined;
 type SafeParseSuccess<Output> = {
     success: true;
@@ -1385,13 +1388,13 @@ declare abstract class ZodType<Output = any, Def extends ZodTypeDef = ZodTypeDef
     };
     _parseSync(input: ParseInput): SyncParseReturnType<Output>;
     _parseAsync(input: ParseInput): AsyncParseReturnType<Output>;
-    parse(data: unknown, params?: Partial<ParseParams>): Output;
-    safeParse(data: unknown, params?: Partial<ParseParams>): SafeParseReturnType<Input, Output>;
+    parse(data: unknown, params?: util.InexactPartial<ParseParams>): Output;
+    safeParse(data: unknown, params?: util.InexactPartial<ParseParams>): SafeParseReturnType<Input, Output>;
     "~validate"(data: unknown): StandardSchemaV1.Result<Output> | Promise<StandardSchemaV1.Result<Output>>;
-    parseAsync(data: unknown, params?: Partial<ParseParams>): Promise<Output>;
-    safeParseAsync(data: unknown, params?: Partial<ParseParams>): Promise<SafeParseReturnType<Input, Output>>;
+    parseAsync(data: unknown, params?: util.InexactPartial<ParseParams>): Promise<Output>;
+    safeParseAsync(data: unknown, params?: util.InexactPartial<ParseParams>): Promise<SafeParseReturnType<Input, Output>>;
     /** Alias of safeParseAsync */
-    spa: (data: unknown, params?: Partial<ParseParams>) => Promise<SafeParseReturnType<Input, Output>>;
+    spa: (data: unknown, params?: util.InexactPartial<ParseParams>) => Promise<SafeParseReturnType<Input, Output>>;
     refine<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, RefinedOutput, Input>;
     refine(check: (arg: Output) => unknown | Promise<unknown>, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, Output, Input>;
     refinement<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, RefinedOutput, Input>;
@@ -1427,22 +1430,22 @@ type ZodNumberCheck = {
     kind: "min";
     value: number;
     inclusive: boolean;
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "max";
     value: number;
     inclusive: boolean;
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "int";
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "multipleOf";
     value: number;
-    message?: string;
+    message?: string | undefined;
 } | {
     kind: "finite";
-    message?: string;
+    message?: string | undefined;
 };
 interface ZodNumberDef extends ZodTypeDef {
     checks: ZodNumberCheck[];
@@ -1491,15 +1494,15 @@ interface ZodArrayDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     typeName: ZodFirstPartyTypeKind.ZodArray;
     exactLength: {
         value: number;
-        message?: string;
+        message?: string | undefined;
     } | null;
     minLength: {
         value: number;
-        message?: string;
+        message?: string | undefined;
     } | null;
     maxLength: {
         value: number;
-        message?: string;
+        message?: string | undefined;
     } | null;
 }
 type ArrayCardinality = "many" | "atleastone";
@@ -1511,7 +1514,7 @@ declare class ZodArray<T extends ZodTypeAny, Cardinality extends ArrayCardinalit
     max(maxLength: number, message?: errorUtil.ErrMessage): this;
     length(len: number, message?: errorUtil.ErrMessage): this;
     nonempty(message?: errorUtil.ErrMessage): ZodArray<T, "atleastone">;
-    static create: <T_1 extends ZodTypeAny>(schema: T_1, params?: RawCreateParams) => ZodArray<T_1, "many">;
+    static create: <El extends ZodTypeAny>(schema: El, params?: RawCreateParams) => ZodArray<El>;
 }
 type UnknownKeysParam = "passthrough" | "strict" | "strip";
 interface ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
@@ -1596,24 +1599,20 @@ declare class ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysPa
         [k in keyof T]: k extends keyof Mask ? deoptional<T[k]> : T[k];
     }>, UnknownKeys, Catchall>;
     keyof(): ZodEnum<enumUtil.UnionToTupleString<keyof T>>;
-    static create: <T_1 extends ZodRawShape>(shape: T_1, params?: RawCreateParams) => ZodObject<T_1, "strip", ZodTypeAny, objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any> extends infer T_2 ? { [k in keyof T_2]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any>[k]; } : never, baseObjectInputType<T_1> extends infer T_3 ? { [k_1 in keyof T_3]: baseObjectInputType<T_1>[k_1]; } : never>;
-    static strictCreate: <T_1 extends ZodRawShape>(shape: T_1, params?: RawCreateParams) => ZodObject<T_1, "strict", ZodTypeAny, objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any> extends infer T_2 ? { [k in keyof T_2]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any>[k]; } : never, baseObjectInputType<T_1> extends infer T_3 ? { [k_1 in keyof T_3]: baseObjectInputType<T_1>[k_1]; } : never>;
-    static lazycreate: <T_1 extends ZodRawShape>(shape: () => T_1, params?: RawCreateParams) => ZodObject<T_1, "strip", ZodTypeAny, objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any> extends infer T_2 ? { [k in keyof T_2]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any>[k]; } : never, baseObjectInputType<T_1> extends infer T_3 ? { [k_1 in keyof T_3]: baseObjectInputType<T_1>[k_1]; } : never>;
+    static create: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strip", ZodTypeAny, objectOutputType<Shape, ZodTypeAny, "strip">, objectInputType<Shape, ZodTypeAny, "strip">>;
+    static strictCreate: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strict">;
+    static lazycreate: <Shape extends ZodRawShape>(shape: () => Shape, params?: RawCreateParams) => ZodObject<Shape, "strip">;
 }
 type AnyZodObject = ZodObject<any, any, any>;
 type ZodUnionOptions = Readonly<[ZodTypeAny, ...ZodTypeAny[]]>;
-interface ZodUnionDef<T extends ZodUnionOptions = Readonly<[
-    ZodTypeAny,
-    ZodTypeAny,
-    ...ZodTypeAny[]
-]>> extends ZodTypeDef {
+interface ZodUnionDef<T extends ZodUnionOptions = Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>> extends ZodTypeDef {
     options: T;
     typeName: ZodFirstPartyTypeKind.ZodUnion;
 }
 declare class ZodUnion<T extends ZodUnionOptions> extends ZodType<T[number]["_output"], ZodUnionDef<T>, T[number]["_input"]> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     get options(): T;
-    static create: <T_1 extends readonly [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>(types: T_1, params?: RawCreateParams) => ZodUnion<T_1>;
+    static create: <Options extends Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>>(types: Options, params?: RawCreateParams) => ZodUnion<Options>;
 }
 interface ZodIntersectionDef<T extends ZodTypeAny = ZodTypeAny, U extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     left: T;
@@ -1622,7 +1621,7 @@ interface ZodIntersectionDef<T extends ZodTypeAny = ZodTypeAny, U extends ZodTyp
 }
 declare class ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny> extends ZodType<T["_output"] & U["_output"], ZodIntersectionDef<T, U>, T["_input"] & U["_input"]> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <T_1 extends ZodTypeAny, U_1 extends ZodTypeAny>(left: T_1, right: U_1, params?: RawCreateParams) => ZodIntersection<T_1, U_1>;
+    static create: <TSchema extends ZodTypeAny, USchema extends ZodTypeAny>(left: TSchema, right: USchema, params?: RawCreateParams) => ZodIntersection<TSchema, USchema>;
 }
 type ZodTupleItems = [ZodTypeAny, ...ZodTypeAny[]];
 type AssertArray<T> = T extends any[] ? T : never;
@@ -1639,11 +1638,11 @@ interface ZodTupleDef<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends
     rest: Rest;
     typeName: ZodFirstPartyTypeKind.ZodTuple;
 }
-declare class ZodTuple<T extends [ZodTypeAny, ...ZodTypeAny[]] | [] = [ZodTypeAny, ...ZodTypeAny[]], Rest extends ZodTypeAny | null = null> extends ZodType<OutputTypeOfTupleWithRest<T, Rest>, ZodTupleDef<T, Rest>, InputTypeOfTupleWithRest<T, Rest>> {
+declare class ZodTuple<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends ZodTypeAny | null = null> extends ZodType<OutputTypeOfTupleWithRest<T, Rest>, ZodTupleDef<T, Rest>, InputTypeOfTupleWithRest<T, Rest>> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     get items(): T;
-    rest<Rest extends ZodTypeAny>(rest: Rest): ZodTuple<T, Rest>;
-    static create: <T_1 extends [] | [ZodTypeAny, ...ZodTypeAny[]]>(schemas: T_1, params?: RawCreateParams) => ZodTuple<T_1, null>;
+    rest<RestSchema extends ZodTypeAny>(rest: RestSchema): ZodTuple<T, RestSchema>;
+    static create: <Items extends [ZodTypeAny, ...ZodTypeAny[]] | []>(schemas: Items, params?: RawCreateParams) => ZodTuple<Items, null>;
 }
 type EnumValues<T extends string = string> = readonly [T, ...T[]];
 type Values<T extends EnumValues> = {
@@ -1661,7 +1660,7 @@ type typecast<A, T> = A extends T ? A : never;
 declare function createZodEnum<U extends string, T extends Readonly<[U, ...U[]]>>(values: T, params?: RawCreateParams): ZodEnum<Writeable<T>>;
 declare function createZodEnum<U extends string, T extends [U, ...U[]]>(values: T, params?: RawCreateParams): ZodEnum<T>;
 declare class ZodEnum<T extends [string, ...string[]]> extends ZodType<T[number], ZodEnumDef<T>, T[number]> {
-    #private;
+    _cache: Set<T[number]> | undefined;
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     get options(): T;
     get enum(): Values<T>;
@@ -1678,7 +1677,7 @@ interface ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
 declare class ZodPromise<T extends ZodTypeAny> extends ZodType<Promise<T["_output"]>, ZodPromiseDef<T>, Promise<T["_input"]>> {
     unwrap(): T;
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <T_1 extends ZodTypeAny>(schema: T_1, params?: RawCreateParams) => ZodPromise<T_1>;
+    static create: <Inner extends ZodTypeAny>(schema: Inner, params?: RawCreateParams) => ZodPromise<Inner>;
 }
 type RefinementEffect<T> = {
     type: "refinement";
@@ -1713,7 +1712,7 @@ interface ZodOptionalDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
 declare class ZodOptional<T extends ZodTypeAny> extends ZodType<T["_output"] | undefined, ZodOptionalDef<T>, T["_input"] | undefined> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     unwrap(): T;
-    static create: <T_1 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodOptional<T_1>;
+    static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodOptional<Inner>;
 }
 interface ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     innerType: T;
@@ -1722,7 +1721,7 @@ interface ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
 declare class ZodNullable<T extends ZodTypeAny> extends ZodType<T["_output"] | null, ZodNullableDef<T>, T["_input"] | null> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     unwrap(): T;
-    static create: <T_1 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodNullable<T_1>;
+    static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodNullable<Inner>;
 }
 interface ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     innerType: T;
@@ -1732,15 +1731,9 @@ interface ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
 declare class ZodDefault<T extends ZodTypeAny> extends ZodType<util.noUndefined<T["_output"]>, ZodDefaultDef<T>, T["_input"] | undefined> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     removeDefault(): T;
-    static create: <T_1 extends ZodTypeAny>(type: T_1, params: {
-        errorMap?: ZodErrorMap | undefined;
-        invalid_type_error?: string | undefined;
-        required_error?: string | undefined;
-        message?: string | undefined;
-        description?: string | undefined;
-    } & {
-        default: T_1["_input"] | (() => util.noUndefined<T_1["_input"]>);
-    }) => ZodDefault<T_1>;
+    static create: <Inner extends ZodTypeAny>(type: Inner, params: RawCreateParams & {
+        default: Inner["_input"] | (() => util.noUndefined<Inner["_input"]>);
+    }) => ZodDefault<Inner>;
 }
 interface ZodCatchDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     innerType: T;
@@ -1753,15 +1746,9 @@ interface ZodCatchDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
 declare class ZodCatch<T extends ZodTypeAny> extends ZodType<T["_output"], ZodCatchDef<T>, unknown> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     removeCatch(): T;
-    static create: <T_1 extends ZodTypeAny>(type: T_1, params: {
-        errorMap?: ZodErrorMap | undefined;
-        invalid_type_error?: string | undefined;
-        required_error?: string | undefined;
-        message?: string | undefined;
-        description?: string | undefined;
-    } & {
-        catch: T_1["_output"] | (() => T_1["_output"]);
-    }) => ZodCatch<T_1>;
+    static create: <Inner extends ZodTypeAny>(type: Inner, params: RawCreateParams & {
+        catch: Inner["_output"] | (() => Inner["_output"]);
+    }) => ZodCatch<Inner>;
 }
 interface ZodBrandedDef<T extends ZodTypeAny> extends ZodTypeDef {
     type: T;
@@ -1784,7 +1771,7 @@ interface ZodPipelineDef<A extends ZodTypeAny, B extends ZodTypeAny> extends Zod
 }
 declare class ZodPipeline<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodType<B["_output"], ZodPipelineDef<A, B>, A["_input"]> {
     _parse(input: ParseInput): ParseReturnType<any>;
-    static create<A extends ZodTypeAny, B extends ZodTypeAny>(a: A, b: B): ZodPipeline<A, B>;
+    static create<ASchema extends ZodTypeAny, BSchema extends ZodTypeAny>(a: ASchema, b: BSchema): ZodPipeline<ASchema, BSchema>;
 }
 type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
     readonly [Symbol.toStringTag]: string;
@@ -1796,7 +1783,7 @@ interface ZodReadonlyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
 }
 declare class ZodReadonly<T extends ZodTypeAny> extends ZodType<MakeReadonly<T["_output"]>, ZodReadonlyDef<T>, MakeReadonly<T["_input"]>> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <T_1 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodReadonly<T_1>;
+    static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodReadonly<Inner>;
     unwrap(): T;
 }
 declare enum ZodFirstPartyTypeKind {

package/dist/cli/index.js

@@ -1,56 +1,57 @@
-import CJS_COMPAT_NODE_URL_bdftjtsviyb from 'node:url';
-import CJS_COMPAT_NODE_PATH_bdftjtsviyb from 'node:path';
-import CJS_COMPAT_NODE_MODULE_bdftjtsviyb from "node:module";
+import CJS_COMPAT_NODE_URL_0oz6lpav6bgq from 'node:url';
+import CJS_COMPAT_NODE_PATH_0oz6lpav6bgq from 'node:path';
+import CJS_COMPAT_NODE_MODULE_0oz6lpav6bgq from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_bdftjtsviyb.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_bdftjtsviyb.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_bdftjtsviyb.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_0oz6lpav6bgq.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_0oz6lpav6bgq.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_0oz6lpav6bgq.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Storybook's esbuild configuration
 // ------------------------------------------------------------
 import {
   boxen
-} from "../_node-chunks/chunk-JP4LEAXM.js";
+} from "../_node-chunks/chunk-TVKUJ3SE.js";
+import "../_node-chunks/chunk-AK5PHLUA.js";
 import {
   Settings,
   _clearGlobalSettings,
   globalSettings
-} from "../_node-chunks/chunk-4FMOVB65.js";
+} from "../_node-chunks/chunk-D7SDB4XE.js";
 import {
   any,
   up2 as up
-} from "../_node-chunks/chunk-JSSBBVU5.js";
+} from "../_node-chunks/chunk-DZJNLBBL.js";
 import {
   invariant
-} from "../_node-chunks/chunk-USDZSU5L.js";
+} from "../_node-chunks/chunk-VWSUFVUF.js";
 import {
   resolvePackageDir
-} from "../_node-chunks/chunk-TBAIXCHN.js";
-import "../_node-chunks/chunk-4VGW2SQA.js";
+} from "../_node-chunks/chunk-KU3JBNPY.js";
+import "../_node-chunks/chunk-4VDRH7SM.js";
 import {
   require_prompts
-} from "../_node-chunks/chunk-3J7DQ6TI.js";
+} from "../_node-chunks/chunk-VX5P3IYA.js";
 import {
   require_dist
-} from "../_node-chunks/chunk-NOSGJ5PL.js";
+} from "../_node-chunks/chunk-P7YMEOXF.js";
 import {
   babelParse,
   recast,
   traverse,
   types
-} from "../_node-chunks/chunk-YJHXEN7U.js";
-import "../_node-chunks/chunk-6COBULLV.js";
-import "../_node-chunks/chunk-AXFNB3AN.js";
+} from "../_node-chunks/chunk-TKN5TEZV.js";
+import "../_node-chunks/chunk-KZB7ELL6.js";
+import "../_node-chunks/chunk-H52PBBSK.js";
 import {
   require_picocolors
-} from "../_node-chunks/chunk-N3GFXZDP.js";
+} from "../_node-chunks/chunk-P3TWEOO5.js";
 import {
   __commonJS,
   __name,
   __require,
   __toESM
-} from "../_node-chunks/chunk-MOO2Y4GI.js";
+} from "../_node-chunks/chunk-2VMDKLSW.js";
 
 // ../node_modules/wrappy/wrappy.js
 var require_wrappy = __commonJS({
@@ -136,6 +137,7 @@ var require_end_of_stream = __commonJS({
     var once = require_once();
     var noop = /* @__PURE__ */ __name(function() {
     }, "noop");
+    var qnt = global.Bare ? queueMicrotask : process.nextTick.bind(process);
     var isRequest = /* @__PURE__ */ __name(function(stream) {
       return stream.setHeader && typeof stream.abort === "function";
     }, "isRequest");
@@ -169,7 +171,7 @@ var require_end_of_stream = __commonJS({
         callback.call(stream, err);
       }, "onerror");
       var onclose = /* @__PURE__ */ __name(function() {
-        process.nextTick(onclosenexttick);
+        qnt(onclosenexttick);
       }, "onclose");
       var onclosenexttick = /* @__PURE__ */ __name(function() {
         if (cancelled) return;
@@ -224,7 +226,7 @@ var require_pump = __commonJS({
     }
     var noop = /* @__PURE__ */ __name(function() {
     }, "noop");
-    var ancient = /^v?\.0/.test(process.version);
+    var ancient = typeof process === "undefined" ? false : /^v?\.0/.test(process.version);
     var isFn = /* @__PURE__ */ __name(function(fn) {
       return typeof fn === "function";
     }, "isFn");
@@ -4651,12 +4653,15 @@ var require_tar_fs = __commonJS({
           if (win32) return next();
           xfs.unlink(name, function() {
             var srcpath = path.join(cwd, path.join("/", header.linkname));
-            xfs.link(srcpath, name, function(err) {
-              if (err && err.code === "EPERM" && opts.hardlinkAsFilesFallback) {
-                stream = xfs.createReadStream(srcpath);
-                return onfile();
-              }
-              stat(err);
+            xfs.realpath(srcpath, function(err, dst) {
+              if (err || !dst.startsWith(path.resolve(cwd))) return next(new Error(name + " is not a valid hardlink"));
+              xfs.link(dst, name, function(err2) {
+                if (err2 && err2.code === "EPERM" && opts.hardlinkAsFilesFallback) {
+                  stream = xfs.createReadStream(srcpath);
+                  return onfile();
+                }
+                stat(err2);
+              });
             });
           });
         }, "onlink");
@@ -27461,7 +27466,7 @@ import { coerce, satisfies } from "semver";
 var singleComment = Symbol("singleComment");
 var multiComment = Symbol("multiComment");
 var stripWithoutWhitespace = /* @__PURE__ */ __name(() => "", "stripWithoutWhitespace");
-var stripWithWhitespace = /* @__PURE__ */ __name((string, start, end) => string.slice(start, end).replace(/\S/g, " "), "stripWithWhitespace");
+var stripWithWhitespace = /* @__PURE__ */ __name((string, start, end) => string.slice(start, end).replace(/[^ \t\r\n]/g, " "), "stripWithWhitespace");
 var isEscaped = /* @__PURE__ */ __name((jsonString, quotePosition) => {
   let index = quotePosition - 1;
   let backslashCount = 0;
@@ -27542,7 +27547,8 @@ function stripJsonComments(jsonString, { whitespace = true, trailingCommas = fal
       }
     }
   }
-  return result + buffer + (isInsideComment ? strip(jsonString.slice(offset)) : jsonString.slice(offset));
+  const remaining = isInsideComment === singleComment ? strip(jsonString, offset) : jsonString.slice(offset);
+  return result + buffer + remaining;
 }
 __name(stripJsonComments, "stripJsonComments");
 
@@ -28323,6 +28329,10 @@ import { logger as logger4, prompt } from "storybook/internal/node-logger";
 var INDENT_REGEX = /^(?:( )+|\t+)/;
 var INDENT_TYPE_SPACE = "space";
 var INDENT_TYPE_TAB = "tab";
+function shouldIgnoreSingleSpace(ignoreSingleSpaces, indentType, value) {
+  return ignoreSingleSpaces && indentType === INDENT_TYPE_SPACE && value === 1;
+}
+__name(shouldIgnoreSingleSpace, "shouldIgnoreSingleSpace");
 function makeIndentsMap(string, ignoreSingleSpaces) {
   const indents = /* @__PURE__ */ new Map();
   let previousSize = 0;
@@ -28332,39 +28342,36 @@ function makeIndentsMap(string, ignoreSingleSpaces) {
     if (!line) {
       continue;
     }
-    let indent;
-    let indentType;
-    let use;
-    let weight;
-    let entry;
     const matches = line.match(INDENT_REGEX);
     if (matches === null) {
       previousSize = 0;
       previousIndentType = "";
     } else {
-      indent = matches[0].length;
-      indentType = matches[1] ? INDENT_TYPE_SPACE : INDENT_TYPE_TAB;
-      if (ignoreSingleSpaces && indentType === INDENT_TYPE_SPACE && indent === 1) {
+      const indent = matches[0].length;
+      const indentType = matches[1] ? INDENT_TYPE_SPACE : INDENT_TYPE_TAB;
+      if (shouldIgnoreSingleSpace(ignoreSingleSpaces, indentType, indent)) {
         continue;
       }
       if (indentType !== previousIndentType) {
         previousSize = 0;
       }
       previousIndentType = indentType;
-      use = 1;
-      weight = 0;
+      let use = 1;
+      let weight = 0;
       const indentDifference = indent - previousSize;
       previousSize = indent;
       if (indentDifference === 0) {
         use = 0;
         weight = 1;
       } else {
-        const absoluteIndentDifference = indentDifference > 0 ? indentDifference : -indentDifference;
+        const absoluteIndentDifference = Math.abs(indentDifference);
+        if (shouldIgnoreSingleSpace(ignoreSingleSpaces, indentType, absoluteIndentDifference)) {
+          continue;
+        }
         key = encodeIndentsKey(indentType, absoluteIndentDifference);
       }
-      entry = indents.get(key);
-      entry = entry === void 0 ? [1, 0] : [entry[0] + use, entry[1] + weight];
-      indents.set(key, entry);
+      const entry = indents.get(key);
+      indents.set(key, entry === void 0 ? [1, 0] : [entry[0] + use, entry[1] + weight]);
     }
   }
   return indents;