@rspack/core 1.3.14 → 1.4.0-beta.0

package/compiled/webpack-sources/types.d.ts

@@ -84,8 +84,8 @@ declare interface GeneratedSourceInfo {
 	generatedColumn?: number;
 	source?: string;
 }
-declare interface Hash {
-	update: (data: string | Buffer, inputEncoding?: string) => Hash;
+declare interface HashLike {
+	update: (data: string | Buffer, inputEncoding?: string) => HashLike;
 	digest: (encoding?: string) => string | Buffer;
 }
 declare interface MapOptions {
@@ -167,6 +167,8 @@ declare interface RawSourceMap {
 	sourcesContent?: string[];
 	mappings: string;
 	file: string;
+	debugId?: string;
+	ignoreList?: number[];
 }
 declare class ReplaceSource extends Source {
 	constructor(source: Source, name?: string);
@@ -213,7 +215,7 @@ declare class Source {
 	size(): number;
 	map(options?: MapOptions): null | RawSourceMap;
 	sourceAndMap(options?: MapOptions): SourceAndMap;
-	updateHash(hash: Hash): void;
+	updateHash(hash: HashLike): void;
 }
 declare interface SourceAndMap {
 	source: SourceValue;
@@ -225,7 +227,7 @@ declare interface SourceLike {
 	size?: () => number;
 	map?: (options?: MapOptions) => null | RawSourceMap;
 	sourceAndMap?: (options?: MapOptions) => SourceAndMap;
-	updateHash?: (hash: Hash) => void;
+	updateHash?: (hash: HashLike) => void;
 }
 declare class SourceMapSource extends Source {
 	constructor(
@@ -269,7 +271,6 @@ declare interface StreamChunksOptions {
 	finalSource?: boolean;
 	columns?: boolean;
 }
-
 	export namespace util {
 		export namespace stringBufferUtils {
 			export let disableDualStringBufferCaching: () => void;
@@ -310,7 +311,7 @@ declare interface StreamChunksOptions {
 		SourceLike,
 		ConcatSourceChild,
 		Replacement,
-		Hash,
+		HashLike,
 		MapOptions,
 		RawSourceMap,
 		SourceAndMap,
@@ -318,3 +319,4 @@ declare interface StreamChunksOptions {
 		GeneratedSourceInfo,
 		StreamChunksOptions
 	};
+

package/compiled/zod/dist/types/v4/classic/schemas.d.ts

@@ -32,7 +32,7 @@ export interface ZodType<out Output = unknown, out Input = unknown, out Internal
     nonoptional(params?: string | core.$ZodNonOptionalParams): ZodNonOptional<this>;
     nullable(): ZodNullable<this>;
     nullish(): ZodOptional<ZodNullable<this>>;
-    default(def: util.NoUndefined<core.output<this>>): ZodDefault<this>;
+    default(def: core.output<this>): ZodDefault<this>;
     default(def: () => util.NoUndefined<core.output<this>>): ZodDefault<this>;
     prefault(def: () => core.input<this>): ZodPrefault<this>;
     prefault(def: core.input<this>): ZodPrefault<this>;
@@ -382,7 +382,7 @@ export interface ZodDate extends _ZodDate<core.$ZodDateInternals<Date>> {
 }
 export declare const ZodDate: core.$constructor<ZodDate>;
 export declare function date(params?: string | core.$ZodDateParams): ZodDate;
-export interface ZodArray<T extends core.SomeType = core.$ZodType> extends ZodType<any, any, core.$ZodArrayInternals<T>>, core.$ZodArray<T> {
+export interface ZodArray<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodArrayInternals<T>>, core.$ZodArray<T> {
     element: T;
     min(minLength: number, params?: string | core.$ZodCheckMinLengthParams): this;
     nonempty(params?: string | core.$ZodCheckMinLengthParams): this;
@@ -476,7 +476,7 @@ export interface ZodMap<Key extends core.SomeType = core.$ZodType, Value extends
 }
 export declare const ZodMap: core.$constructor<ZodMap>;
 export declare function map<Key extends core.SomeType, Value extends core.SomeType>(keyType: Key, valueType: Value, params?: string | core.$ZodMapParams): ZodMap<Key, Value>;
-export interface ZodSet<T extends core.SomeType = core.$ZodType> extends ZodType<any, any, core.$ZodSetInternals<T>>, core.$ZodSet<T> {
+export interface ZodSet<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodSetInternals<T>>, core.$ZodSet<T> {
     min(minSize: number, params?: string | core.$ZodCheckMinSizeParams): this;
     /** */
     nonempty(params?: string | core.$ZodCheckMinSizeParams): this;
@@ -485,7 +485,9 @@ export interface ZodSet<T extends core.SomeType = core.$ZodType> extends ZodType
 }
 export declare const ZodSet: core.$constructor<ZodSet>;
 export declare function set<Value extends core.SomeType>(valueType: Value, params?: string | core.$ZodSetParams): ZodSet<Value>;
-export interface ZodEnum<out T extends util.EnumLike = util.EnumLike> extends _ZodType<core.$ZodEnumInternals<T>>, core.$ZodEnum<T> {
+export interface ZodEnum<
+/** @ts-ignore Cast variance */
+out T extends util.EnumLike = util.EnumLike> extends _ZodType<core.$ZodEnumInternals<T>>, core.$ZodEnum<T> {
     enum: T;
     options: Array<T[keyof T]>;
     extract<const U extends readonly (keyof T)[]>(values: U, params?: string | core.$ZodEnumParams): ZodEnum<util.Flatten<Pick<T, U[number]>>>;
@@ -509,7 +511,7 @@ export interface ZodLiteral<T extends util.Primitive = util.Primitive> extends _
     value: T;
 }
 export declare const ZodLiteral: core.$constructor<ZodLiteral>;
-export declare function literal<const T extends Array<util.Literal>>(value: T, params?: string | core.$ZodLiteralParams): ZodLiteral<T[number]>;
+export declare function literal<const T extends ReadonlyArray<util.Literal>>(value: T, params?: string | core.$ZodLiteralParams): ZodLiteral<T[number]>;
 export declare function literal<const T extends util.Literal>(value: T, params?: string | core.$ZodLiteralParams): ZodLiteral<T>;
 export interface ZodFile extends _ZodType<core.$ZodFileInternals>, core.$ZodFile {
     min(size: number, params?: string | core.$ZodCheckMinSizeParams): this;
@@ -601,19 +603,22 @@ export declare function superRefine<T>(fn: (arg: T, payload: RefinementCtx<T>) =
 type ZodInstanceOfParams = core.Params<ZodCustom, core.$ZodIssueCustom, "type" | "check" | "checks" | "fn" | "abort" | "error" | "params" | "path">;
 declare function _instanceof<T extends typeof util.Class>(cls: T, params?: ZodInstanceOfParams): ZodCustom<InstanceType<T>, InstanceType<T>>;
 export { _instanceof as instanceof };
-export declare const stringbool: (_params?: string | core.$ZodStringBoolParams) => ZodPipe<ZodUnknown, ZodBoolean>;
-export type ZodJSONSchema = ZodUnion<[
+export declare const stringbool: (_params?: string | core.$ZodStringBoolParams) => ZodPipe<ZodPipe<ZodString, ZodTransform<boolean, string>>, ZodBoolean>;
+type _ZodJSONSchema = ZodUnion<[
     ZodString,
     ZodNumber,
     ZodBoolean,
     ZodNull,
     ZodArray<ZodJSONSchema>,
     ZodRecord<ZodString, ZodJSONSchema>
-]> & {
-    _zod: {
-        input: util.JSONType;
-        output: util.JSONType;
-    };
-};
+]>;
+type _ZodJSONSchemaInternals = _ZodJSONSchema["_zod"];
+export interface ZodJSONSchemaInternals extends _ZodJSONSchemaInternals {
+    output: util.JSONType;
+    input: util.JSONType;
+}
+export interface ZodJSONSchema extends _ZodJSONSchema {
+    _zod: ZodJSONSchemaInternals;
+}
 export declare function json(params?: string | core.$ZodCustomParams): ZodJSONSchema;
-export declare function preprocess<A, U extends core.SomeType>(fn: (arg: unknown, ctx: RefinementCtx) => A, schema: U): ZodPipe<ZodTransform<A, unknown>, U>;
+export declare function preprocess<A, U extends core.SomeType, B = unknown>(fn: (arg: B, ctx: RefinementCtx) => A, schema: U): ZodPipe<ZodTransform<A, B>, U>;

package/compiled/zod/dist/types/v4/core/api.d.ts

@@ -260,14 +260,15 @@ export interface $ZodStringBoolParams extends TypeParams {
     truthy?: string[];
     falsy?: string[];
     /**
-     * Options `"sensitive"`, `"insensitive"`
+     * Options: `"sensitive"`, `"insensitive"`
      *
-     * Defaults to `"insensitive"`
+     * @default `"insensitive"`
      */
     case?: "sensitive" | "insensitive" | undefined;
 }
 export declare function _stringbool(Classes: {
     Pipe?: typeof schemas.$ZodPipe;
     Boolean?: typeof schemas.$ZodBoolean;
-    Unknown?: typeof schemas.$ZodUnknown;
-}, _params?: string | $ZodStringBoolParams): schemas.$ZodPipe<schemas.$ZodUnknown, schemas.$ZodBoolean<boolean>>;
+    Transform?: typeof schemas.$ZodTransform;
+    String?: typeof schemas.$ZodString;
+}, _params?: string | $ZodStringBoolParams): schemas.$ZodPipe<schemas.$ZodPipe<schemas.$ZodString, schemas.$ZodTransform<boolean, string>>, schemas.$ZodBoolean<boolean>>;

package/compiled/zod/dist/types/v4/core/checks.d.ts

@@ -27,7 +27,7 @@ export interface $ZodCheckLessThanDef extends $ZodCheckDef {
 }
 export interface $ZodCheckLessThanInternals<T extends util.Numeric = util.Numeric> extends $ZodCheckInternals<T> {
     def: $ZodCheckLessThanDef;
-    issc: errors.$ZodIssueTooSmall<T>;
+    issc: errors.$ZodIssueTooBig<T>;
 }
 export interface $ZodCheckLessThan<T extends util.Numeric = util.Numeric> extends $ZodCheck<T> {
     _zod: $ZodCheckLessThanInternals<T>;

package/compiled/zod/dist/types/v4/core/core.d.ts

@@ -20,7 +20,7 @@ export type $brand<T extends string | number | symbol = string | number | symbol
         [k in T]: true;
     };
 };
-export type $ZodBranded<T extends schemas._$ZodType, Brand extends string | number | symbol> = T & Record<"_zod", Record<"output", output<T> & $brand<Brand>>>;
+export type $ZodBranded<T extends schemas.SomeType, Brand extends string | number | symbol> = T & Record<"_zod", Record<"output", output<T> & $brand<Brand>>>;
 export declare class $ZodAsyncError extends Error {
     constructor();
 }

package/compiled/zod/dist/types/v4/core/registries.d.ts

@@ -4,7 +4,9 @@ export declare const $output: unique symbol;
 export type $output = typeof $output;
 export declare const $input: unique symbol;
 export type $input = typeof $input;
-export type $replace<Meta, S extends $ZodType> = Meta extends $output ? core.output<S> : Meta extends $input ? core.input<S> : Meta extends (infer M)[] ? $replace<M, S>[] : Meta extends object ? {
+export type $replace<Meta, S extends $ZodType> = Meta extends $output ? core.output<S> : Meta extends $input ? core.input<S> : Meta extends (infer M)[] ? $replace<M, S>[] : Meta extends (...args: infer P) => infer R ? (...args: {
+    [K in keyof P]: $replace<P[K], S>;
+}) => $replace<R, S> : Meta extends object ? {
     [K in keyof Meta]: $replace<Meta[K], S>;
 } : Meta;
 type MetadataType = Record<string, unknown> | undefined;

package/compiled/zod/dist/types/v4/core/schemas.d.ts

@@ -78,13 +78,15 @@ export interface $ZodTypeInternals<out O = unknown, out I = unknown> extends _$Z
     input: I;
 }
 export type $ZodStandardSchema<T> = StandardSchemaV1.Props<core.input<T>, core.output<T>>;
-export interface _$ZodType<T extends _$ZodTypeInternals = _$ZodTypeInternals> {
-    _zod: T;
-}
-export type SomeType = _$ZodType;
-export interface $ZodType<O = unknown, I = unknown, Internals extends $ZodTypeInternals<O, I> = $ZodTypeInternals<O, I>> extends _$ZodType<Internals> {
+export type SomeType = {
+    _zod: _$ZodTypeInternals;
+};
+export interface $ZodType<O = unknown, I = unknown, Internals extends $ZodTypeInternals<O, I> = $ZodTypeInternals<O, I>> {
+    _zod: Internals;
     "~standard": $ZodStandardSchema<this>;
 }
+export interface _$ZodType<T extends $ZodTypeInternals = $ZodTypeInternals> extends $ZodType<T["output"], T["input"], T> {
+}
 export declare const $ZodType: core.$constructor<$ZodType>;
 export { clone } from "./util.js";
 export interface $ZodStringDef extends $ZodTypeDef {
@@ -106,8 +108,7 @@ export interface $ZodStringInternals<Input> extends $ZodTypeInternals<string, In
         contentEncoding: string;
     }>;
 }
-export interface $ZodString<Input = unknown> extends $ZodType {
-    _zod: $ZodStringInternals<Input>;
+export interface $ZodString<Input = unknown> extends _$ZodType<$ZodStringInternals<Input>> {
 }
 export declare const $ZodString: core.$constructor<$ZodString>;
 export interface $ZodStringFormatDef<Format extends checks.$ZodStringFormats = checks.$ZodStringFormats> extends $ZodStringDef, checks.$ZodCheckStringFormatDef<Format> {
@@ -509,29 +510,9 @@ export interface $ZodArrayInternals<T extends SomeType = $ZodType> extends $ZodT
     def: $ZodArrayDef<T>;
     isst: errors.$ZodIssueInvalidType;
 }
-export interface $ZodArray<T extends SomeType = $ZodType> extends $ZodType {
-    _zod: $ZodArrayInternals<T>;
+export interface $ZodArray<T extends SomeType = $ZodType> extends $ZodType<core.output<T>[], core.input<T>[], $ZodArrayInternals<T>> {
 }
 export declare const $ZodArray: core.$constructor<$ZodArray>;
-export type $ZodShape = Readonly<{
-    [k: string]: $ZodType;
-}>;
-export interface $ZodObjectDef<Shape extends $ZodShape = $ZodShape> extends $ZodTypeDef {
-    type: "object";
-    shape: Shape;
-    catchall?: $ZodType | undefined;
-}
-export interface $ZodObjectInternals<
-/** @ts-ignore Cast variance */
-out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Config extends $ZodObjectConfig = $ZodObjectConfig> extends _$ZodTypeInternals {
-    def: $ZodObjectDef<Shape>;
-    config: Config;
-    isst: errors.$ZodIssueInvalidType | errors.$ZodIssueUnrecognizedKeys;
-    propValues: util.PropValues;
-    output: $InferObjectOutput<Shape, Config["out"]>;
-    input: $InferObjectInput<Shape, Config["in"]>;
-}
-export type $ZodLooseShape = Record<string, any>;
 type OptionalOutSchema = {
     _zod: {
         optout: "optional";
@@ -542,21 +523,15 @@ type OptionalInSchema = {
         optin: "optional";
     };
 };
-export type $InferObjectOutputFallback<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? object : keyof (T & Extra) extends never ? Record<string, never> : util.Prettify<{
-    -readonly [k in keyof T]: core.output<T[k]>;
-} & Extra>;
-export type $InferObjectInputFallback<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? object : keyof (T & Extra) extends never ? Record<string, never> : util.Prettify<{
-    -readonly [k in keyof T]: core.input<T[k]>;
-} & Extra>;
 export type $InferObjectOutput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? object : keyof (T & Extra) extends never ? Record<string, never> : util.Prettify<{
-    -readonly [k in keyof T as T[k] extends OptionalOutSchema ? never : k]: core.output<T[k]>;
+    -readonly [k in keyof T as T[k] extends OptionalOutSchema ? never : k]: T[k]["_zod"]["output"];
 } & {
-    -readonly [k in keyof T as T[k] extends OptionalOutSchema ? k : never]?: core.output<T[k]>;
+    -readonly [k in keyof T as T[k] extends OptionalOutSchema ? k : never]?: T[k]["_zod"]["output"];
 } & Extra>;
 export type $InferObjectInput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? object : keyof (T & Extra) extends never ? Record<string, never> : util.Prettify<{
-    -readonly [k in keyof T as T[k] extends OptionalInSchema ? never : k]: core.input<T[k]>;
+    -readonly [k in keyof T as T[k] extends OptionalInSchema ? never : k]: T[k]["_zod"]["input"];
 } & {
-    -readonly [k in keyof T as T[k] extends OptionalInSchema ? k : never]?: core.input<T[k]>;
+    -readonly [k in keyof T as T[k] extends OptionalInSchema ? k : never]?: T[k]["_zod"]["input"];
 } & Extra>;
 export type $ZodObjectConfig = {
     out: Record<string, unknown>;
@@ -574,7 +549,7 @@ export type $strip = {
     out: {};
     in: {};
 };
-export type $catchall<T extends _$ZodType> = {
+export type $catchall<T extends SomeType> = {
     out: {
         [k: string]: core.output<T>;
     };
@@ -582,6 +557,25 @@ export type $catchall<T extends _$ZodType> = {
         [k: string]: core.input<T>;
     };
 };
+export type $ZodShape = Readonly<{
+    [k: string]: $ZodType;
+}>;
+export interface $ZodObjectDef<Shape extends $ZodShape = $ZodShape> extends $ZodTypeDef {
+    type: "object";
+    shape: Shape;
+    catchall?: $ZodType | undefined;
+}
+export interface $ZodObjectInternals<
+/** @ts-ignore Cast variance */
+out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Config extends $ZodObjectConfig = $ZodObjectConfig> extends _$ZodTypeInternals {
+    def: $ZodObjectDef<Shape>;
+    config: Config;
+    isst: errors.$ZodIssueInvalidType | errors.$ZodIssueUnrecognizedKeys;
+    propValues: util.PropValues;
+    output: $InferObjectOutput<Shape, Config["out"]>;
+    input: $InferObjectInput<Shape, Config["in"]>;
+}
+export type $ZodLooseShape = Record<string, any>;
 export interface $ZodObject<
 /** @ts-ignore Cast variance */
 out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Params extends $ZodObjectConfig = $ZodObjectConfig> extends $ZodType<any, any, $ZodObjectInternals<Shape, Params>> {

package/compiled/zod/dist/types/v4/core/to-json-schema.d.ts

@@ -70,9 +70,9 @@ export declare class JSONSchemaGenerator {
     process(schema: schemas.$ZodType, _params?: ProcessParams): JSONSchema.BaseSchema;
     emit(schema: schemas.$ZodType, _params?: EmitParams): JSONSchema.BaseSchema;
 }
-interface ToJSONSchemaParams extends Omit<JSONSchemaGeneratorParams & EmitParams, never> {
+interface ToJSONSchemaParams extends Omit<JSONSchemaGeneratorParams & EmitParams, "external"> {
 }
-interface RegistryToJSONSchemaParams extends Omit<JSONSchemaGeneratorParams & EmitParams, never> {
+interface RegistryToJSONSchemaParams extends Omit<JSONSchemaGeneratorParams & EmitParams, "external"> {
     uri?: (id: string) => string;
 }
 export declare function toJSONSchema(schema: schemas.$ZodType, _params?: ToJSONSchemaParams): JSONSchema.BaseSchema;

package/compiled/zod/dist/types/v4/core/util.d.ts

@@ -131,7 +131,7 @@ export declare function isObject(data: any): data is Record<PropertyKey, unknown
 export declare const allowsEval: {
     value: boolean;
 };
-export declare function isPlainObject(data: any): data is Record<PropertyKey, unknown>;
+export declare function isPlainObject(o: any): o is Record<PropertyKey, unknown>;
 export declare function numKeys(data: any): number;
 export declare const getParsedType: (data: any) => ParsedTypes;
 export declare const propertyKeyTypes: Set<string>;

package/compiled/zod/dist/types/v4/locales/index.d.ts

@@ -22,6 +22,7 @@ export { default as ms } from "./ms.js";
 export { default as nl } from "./nl.js";
 export { default as no } from "./no.js";
 export { default as ota } from "./ota.js";
+export { default as ps } from "./ps.js";
 export { default as pl } from "./pl.js";
 export { default as pt } from "./pt.js";
 export { default as ru } from "./ru.js";

package/compiled/zod/dist/types/v4/locales/ps.d.ts

@@ -0,0 +1,4 @@
+import type * as errors from "../core/errors.js";
+export default function (): {
+    localeError: errors.$ZodErrorMap;
+};