@rspack/core 1.3.15 → 1.4.0-beta.1

package/compiled/tinypool/dist/utils-B--2TaWv.js

@@ -0,0 +1,38 @@
+import { pathToFileURL } from "node:url";
+
+//#region src/entry/utils.ts
+let importESMCached;
+function getImportESM() {
+	if (importESMCached === void 0) importESMCached = new Function("specifier", "return import(specifier)");
+	return importESMCached;
+}
+const handlerCache = new Map();
+async function getHandler(filename, name) {
+	let handler = handlerCache.get(`${filename}/${name}`);
+	if (handler !== void 0) return handler;
+	try {
+		const handlerModule = await import(filename);
+		handler = typeof handlerModule.default !== "function" && handlerModule.default || handlerModule;
+		if (typeof handler !== "function") handler = await handler[name];
+	} catch {}
+	if (typeof handler !== "function") {
+		handler = await getImportESM()(pathToFileURL(filename).href);
+		if (typeof handler !== "function") handler = await handler[name];
+	}
+	if (typeof handler !== "function") return null;
+	if (handlerCache.size > 1e3) {
+		const [handler$1] = handlerCache;
+		const key = handler$1[0];
+		handlerCache.delete(key);
+	}
+	handlerCache.set(`${filename}/${name}`, handler);
+	return handler;
+}
+function throwInNextTick(error) {
+	process.nextTick(() => {
+		throw error;
+	});
+}
+
+//#endregion
+export { getHandler, throwInNextTick };

package/compiled/tinypool/dist/utils-De75vAgL.js

@@ -0,0 +1,10 @@
+//#region src/utils.ts
+function stdout() {
+	return console._stdout || process.stdout || void 0;
+}
+function stderr() {
+	return console._stderr || process.stderr || void 0;
+}
+
+//#endregion
+export { stderr, stdout };

package/compiled/tinypool/package.json

@@ -1,7 +1,8 @@
 {
   "name": "tinypool",
   "type": "module",
-  "version": "1.0.2",
+  "version": "1.1.0",
+  "packageManager": "pnpm@9.0.6",
   "description": "A minimal and tiny Node.js Worker Thread Pool implementation, a fork of piscina, but with fewer features",
   "license": "MIT",
   "homepage": "https://github.com/tinylibs/tinypool#readme",
@@ -30,26 +31,9 @@
   "files": [
     "dist"
   ],
-  "devDependencies": {
-    "@types/node": "^20.12.8",
-    "clean-publish": "^3.4.4",
-    "eslint": "^9.4.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-prettier": "^5.1.3",
-    "eslint-plugin-unicorn": "^53.0.0",
-    "prettier": "^3.3.2",
-    "tsup": "^8.0.2",
-    "typescript": "^5.4.5",
-    "typescript-eslint": "^7.13.0",
-    "vite": "^5.2.11",
-    "vitest": "^2.0.5"
-  },
-  "scripts": {
-    "test": "vitest",
-    "bench": "vitest bench",
-    "dev": "tsup --watch",
-    "build": "tsup",
-    "lint": "eslint --max-warnings=0",
-    "typecheck": "tsc --noEmit"
+  "pnpm": {
+    "overrides": {
+      "vitest>tinypool": "link:./"
+    }
   }
 }

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;
+};