@kubb/agent 5.0.0-alpha.35 → 5.0.0-alpha.36

package/.output/server/node_modules/@kubb/plugin-zod/dist/generators-D1R6NNf2.js

@@ -0,0 +1,290 @@
+import "./chunk--u3MIqq1.js";
+import { n as Operations, t as Zod } from "./components-eECfXVou.js";
+import path from "node:path";
+import { SchemaGenerator, schemaKeywords } from "@kubb/plugin-oas";
+import { pluginTsName } from "@kubb/plugin-ts";
+import { useMode, usePluginManager } from "@kubb/core/hooks";
+import { createReactGenerator } from "@kubb/plugin-oas/generators";
+import { useOas, useOperationManager, useSchemaManager } from "@kubb/plugin-oas/hooks";
+import { getBanner, getFooter, getImports } from "@kubb/plugin-oas/utils";
+import { File } from "@kubb/react-fabric";
+import { Fragment, jsx, jsxs } from "@kubb/react-fabric/jsx-runtime";
+//#region src/generators/operationsGenerator.tsx
+const operationsGenerator = createReactGenerator({
+	name: "operations",
+	Operations({ operations, generator, plugin }) {
+		const { key: pluginKey, options: { output, importPath } } = plugin;
+		const pluginManager = usePluginManager();
+		const oas = useOas();
+		const { getFile, groupSchemasByName } = useOperationManager(generator);
+		const name = "operations";
+		const file = pluginManager.getFile({
+			name,
+			extname: ".ts",
+			pluginKey
+		});
+		const transformedOperations = operations.map((operation) => ({
+			operation,
+			data: groupSchemasByName(operation, { type: "function" })
+		}));
+		const imports = Object.entries(transformedOperations).map(([key, { data, operation }]) => {
+			const names = [
+				data.request,
+				...Object.values(data.responses),
+				...Object.values(data.parameters)
+			].filter(Boolean);
+			return /* @__PURE__ */ jsx(File.Import, {
+				name: names,
+				root: file.path,
+				path: getFile(operation).path
+			}, key);
+		}).filter(Boolean);
+		const isZodImport = importPath === "zod" || importPath === "zod/mini";
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: file.baseName,
+			path: file.path,
+			meta: file.meta,
+			banner: getBanner({
+				oas,
+				output,
+				config: pluginManager.config
+			}),
+			footer: getFooter({
+				oas,
+				output
+			}),
+			children: [
+				/* @__PURE__ */ jsx(File.Import, {
+					isTypeOnly: true,
+					name: isZodImport ? "z" : ["z"],
+					path: importPath,
+					isNameSpace: isZodImport
+				}),
+				imports,
+				/* @__PURE__ */ jsx(Operations, {
+					name,
+					operations: transformedOperations
+				})
+			]
+		});
+	}
+});
+//#endregion
+//#region src/generators/zodGenerator.tsx
+const zodGenerator = createReactGenerator({
+	name: "zod",
+	Operation({ config, operation, generator, plugin }) {
+		const { options, options: { coercion: globalCoercion, inferred, typed, mapper, wrapOutput, version, guidType, mini } } = plugin;
+		const mode = useMode();
+		const pluginManager = usePluginManager();
+		const oas = useOas();
+		const { getSchemas, getFile, getGroup } = useOperationManager(generator);
+		const schemaManager = useSchemaManager();
+		const file = getFile(operation);
+		const schemas = getSchemas(operation);
+		const schemaGenerator = new SchemaGenerator(options, {
+			fabric: generator.context.fabric,
+			oas,
+			plugin,
+			pluginManager,
+			events: generator.context.events,
+			mode,
+			override: options.override
+		});
+		const operationSchemas = [
+			schemas.pathParams,
+			schemas.queryParams,
+			schemas.headerParams,
+			schemas.statusCodes,
+			schemas.request,
+			schemas.response
+		].flat().filter(Boolean);
+		const toZodPath = path.resolve(config.root, config.output.path, ".kubb/ToZod.ts");
+		const mapOperationSchema = ({ name, schema: schemaOriginal, description, keysToOmit: keysToOmitOriginal, ...options }) => {
+			let schemaObject = schemaOriginal;
+			let keysToOmit = keysToOmitOriginal;
+			if ((schemaOriginal.anyOf || schemaOriginal.oneOf) && keysToOmitOriginal && keysToOmitOriginal.length > 0) {
+				schemaObject = structuredClone(schemaOriginal);
+				delete schemaObject.$ref;
+				for (const key of keysToOmitOriginal) delete schemaObject.properties?.[key];
+				if (Array.isArray(schemaObject.required)) schemaObject.required = schemaObject.required.filter((key) => !keysToOmitOriginal.includes(key));
+				keysToOmit = void 0;
+			}
+			const hasProperties = Object.keys(schemaObject || {}).length > 0;
+			const hasDefaults = Object.values(schemaObject.properties || {}).some((prop) => prop && Object.hasOwn(prop, "default"));
+			const optional = !(Array.isArray(schemaObject?.required) ? schemaObject.required.length > 0 : !!schemaObject?.required) && !hasDefaults && hasProperties && name.includes("Params");
+			if (!optional && Array.isArray(schemaObject.required) && !schemaObject.required.length) schemaObject.required = Object.entries(schemaObject.properties || {}).filter(([_key, value]) => value && Object.hasOwn(value, "default")).map(([key]) => key);
+			const tree = [...schemaGenerator.parse({
+				schema: schemaObject,
+				name,
+				parentName: null
+			}), optional ? { keyword: schemaKeywords.optional } : void 0].filter(Boolean);
+			const imports = getImports(tree);
+			const group = options.operation ? getGroup(options.operation) : void 0;
+			const coercion = name.includes("Params") ? {
+				numbers: true,
+				strings: false,
+				dates: true
+			} : globalCoercion;
+			const zod = {
+				name: schemaManager.getName(name, { type: "function" }),
+				inferTypeName: schemaManager.getName(name, { type: "type" }),
+				file: schemaManager.getFile(name)
+			};
+			const type = {
+				name: schemaManager.getName(name, {
+					type: "type",
+					pluginKey: [pluginTsName]
+				}),
+				file: schemaManager.getFile(options.operationName || name, {
+					pluginKey: [pluginTsName],
+					group
+				})
+			};
+			return /* @__PURE__ */ jsxs(Fragment, { children: [
+				typed && /* @__PURE__ */ jsx(File.Import, {
+					isTypeOnly: true,
+					root: file.path,
+					path: type.file.path,
+					name: [type.name]
+				}),
+				imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
+					root: file.path,
+					path: imp.path,
+					name: imp.name
+				}, [
+					imp.path,
+					imp.name,
+					imp.isTypeOnly
+				].join("-"))),
+				/* @__PURE__ */ jsx(Zod, {
+					name: zod.name,
+					typeName: typed ? type.name : void 0,
+					inferTypeName: inferred ? zod.inferTypeName : void 0,
+					description,
+					tree,
+					schema: schemaObject,
+					mapper,
+					coercion,
+					keysToOmit,
+					wrapOutput,
+					version: plugin.options.version,
+					guidType,
+					emptySchemaType: plugin.options.emptySchemaType,
+					mini
+				})
+			] });
+		};
+		const isZodImport = plugin.options.importPath === "zod" || plugin.options.importPath === "zod/mini";
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: file.baseName,
+			path: file.path,
+			meta: file.meta,
+			banner: getBanner({
+				oas,
+				output: plugin.options.output,
+				config: pluginManager.config
+			}),
+			footer: getFooter({
+				oas,
+				output: plugin.options.output
+			}),
+			children: [
+				/* @__PURE__ */ jsx(File.Import, {
+					name: isZodImport ? "z" : ["z"],
+					path: plugin.options.importPath,
+					isNameSpace: isZodImport
+				}),
+				typed && version === "3" && /* @__PURE__ */ jsx(File.Import, {
+					name: ["ToZod"],
+					isTypeOnly: true,
+					root: file.path,
+					path: toZodPath
+				}),
+				operationSchemas.map(mapOperationSchema)
+			]
+		});
+	},
+	Schema({ config, schema, plugin }) {
+		const { getName, getFile } = useSchemaManager();
+		const { options: { output, emptySchemaType, coercion, inferred, typed, mapper, importPath, wrapOutput, version, guidType, mini } } = plugin;
+		const pluginManager = usePluginManager();
+		const oas = useOas();
+		const imports = getImports(schema.tree);
+		const zod = {
+			name: getName(schema.name, { type: "function" }),
+			inferTypeName: getName(schema.name, { type: "type" }),
+			file: getFile(schema.name)
+		};
+		const type = {
+			name: getName(schema.name, {
+				type: "type",
+				pluginKey: [pluginTsName]
+			}),
+			file: getFile(schema.name, { pluginKey: [pluginTsName] })
+		};
+		const isZodImport = importPath === "zod" || importPath === "zod/mini";
+		const toZodPath = path.resolve(config.root, config.output.path, ".kubb/ToZod.ts");
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: zod.file.baseName,
+			path: zod.file.path,
+			meta: zod.file.meta,
+			banner: getBanner({
+				oas,
+				output,
+				config: pluginManager.config
+			}),
+			footer: getFooter({
+				oas,
+				output
+			}),
+			children: [
+				/* @__PURE__ */ jsx(File.Import, {
+					name: isZodImport ? "z" : ["z"],
+					path: importPath,
+					isNameSpace: isZodImport
+				}),
+				typed && /* @__PURE__ */ jsx(File.Import, {
+					isTypeOnly: true,
+					root: zod.file.path,
+					path: type.file.path,
+					name: [type.name]
+				}),
+				typed && version === "3" && /* @__PURE__ */ jsx(File.Import, {
+					name: ["ToZod"],
+					isTypeOnly: true,
+					root: zod.file.path,
+					path: toZodPath
+				}),
+				imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
+					root: zod.file.path,
+					path: imp.path,
+					name: imp.name
+				}, [
+					imp.path,
+					imp.name,
+					imp.isTypeOnly
+				].join("-"))),
+				/* @__PURE__ */ jsx(Zod, {
+					name: zod.name,
+					typeName: typed ? type.name : void 0,
+					inferTypeName: inferred ? zod.inferTypeName : void 0,
+					description: schema.value.description,
+					tree: schema.tree,
+					schema: schema.value,
+					mapper,
+					coercion,
+					wrapOutput,
+					version,
+					guidType,
+					emptySchemaType,
+					mini
+				})
+			]
+		});
+	}
+});
+//#endregion
+export { operationsGenerator as n, zodGenerator as t };
+
+//# sourceMappingURL=generators-D1R6NNf2.js.map

package/.output/server/node_modules/@kubb/plugin-zod/dist/index.js

@@ -0,0 +1,175 @@
+import "./chunk--u3MIqq1.js";
+import { n as operationsGenerator, t as zodGenerator } from "./generators-D1R6NNf2.js";
+import { source } from "./templates/ToZod.source.js";
+import path from "node:path";
+import { PackageManager, definePlugin, getBarrelFiles, getMode } from "@kubb/core";
+import { OperationGenerator, SchemaGenerator, pluginOasName } from "@kubb/plugin-oas";
+import { pluginTsName } from "@kubb/plugin-ts";
+//#region ../../internals/utils/src/casing.ts
+/**
+* Shared implementation for camelCase and PascalCase conversion.
+* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
+* and capitalizes each word according to `pascal`.
+*
+* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
+*/
+function toCamelOrPascal(text, pascal) {
+	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
+		if (word.length > 1 && word === word.toUpperCase()) return word;
+		if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1);
+		return word.charAt(0).toUpperCase() + word.slice(1);
+	}).join("").replace(/[^a-zA-Z0-9]/g, "");
+}
+/**
+* Splits `text` on `.` and applies `transformPart` to each segment.
+* The last segment receives `isLast = true`, all earlier segments receive `false`.
+* Segments are joined with `/` to form a file path.
+*/
+function applyToFileParts(text, transformPart) {
+	const parts = text.split(".");
+	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
+}
+/**
+* Converts `text` to camelCase.
+* When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.
+*
+* @example
+* camelCase('hello-world')                   // 'helloWorld'
+* camelCase('pet.petId', { isFile: true })   // 'pet/petId'
+*/
+function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
+	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
+		prefix,
+		suffix
+	} : {}));
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+}
+/**
+* Converts `text` to PascalCase.
+* When `isFile` is `true`, the last dot-separated segment is PascalCased and earlier segments are camelCased.
+*
+* @example
+* pascalCase('hello-world')                  // 'HelloWorld'
+* pascalCase('pet.petId', { isFile: true })  // 'pet/PetId'
+*/
+function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
+	if (isFile) return applyToFileParts(text, (part, isLast) => isLast ? pascalCase(part, {
+		prefix,
+		suffix
+	}) : camelCase(part));
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
+}
+//#endregion
+//#region src/plugin.ts
+const pluginZodName = "plugin-zod";
+const pluginZod = definePlugin((options) => {
+	const { output = {
+		path: "zod",
+		barrelType: "named"
+	}, group, exclude = [], include, override = [], transformers = {}, dateType = "string", unknownType = "any", emptySchemaType = unknownType, integerType = "number", typed = false, mapper = {}, operations = false, mini = false, version = mini ? "4" : new PackageManager().isValidSync("zod", ">=4") ? "4" : "3", guidType = "uuid", importPath = mini ? "zod/mini" : version === "4" ? "zod/v4" : "zod", coercion = false, inferred = false, generators = [zodGenerator, operations ? operationsGenerator : void 0].filter(Boolean), wrapOutput = void 0, contentType } = options;
+	return {
+		name: pluginZodName,
+		options: {
+			output,
+			transformers,
+			include,
+			exclude,
+			override,
+			typed,
+			dateType,
+			unknownType,
+			emptySchemaType,
+			integerType,
+			mapper,
+			importPath,
+			coercion,
+			operations,
+			inferred,
+			group,
+			wrapOutput,
+			version,
+			guidType,
+			mini,
+			usedEnumNames: {}
+		},
+		pre: [pluginOasName, typed ? pluginTsName : void 0].filter(Boolean),
+		resolvePath(baseName, pathMode, options) {
+			const root = path.resolve(this.config.root, this.config.output.path);
+			if ((pathMode ?? getMode(path.resolve(root, output.path))) === "single")
+ /**
+			* when output is a file then we will always append to the same file(output file), see fileManager.addOrAppend
+			* Other plugins then need to call addOrAppend instead of just add from the fileManager class
+			*/
+			return path.resolve(root, output.path);
+			if (group && (options?.group?.path || options?.group?.tag)) {
+				const groupName = group?.name ? group.name : (ctx) => {
+					if (group?.type === "path") return `${ctx.group.split("/")[1]}`;
+					return `${camelCase(ctx.group)}Controller`;
+				};
+				return path.resolve(root, output.path, groupName({ group: group.type === "path" ? options.group.path : options.group.tag }), baseName);
+			}
+			return path.resolve(root, output.path, baseName);
+		},
+		resolveName(name, type) {
+			let resolvedName = camelCase(name, {
+				suffix: type ? "schema" : void 0,
+				isFile: type === "file"
+			});
+			if (type === "type") resolvedName = pascalCase(resolvedName);
+			if (type) return transformers?.name?.(resolvedName, type) || resolvedName;
+			return resolvedName;
+		},
+		async install() {
+			const root = path.resolve(this.config.root, this.config.output.path);
+			const mode = getMode(path.resolve(root, output.path));
+			const oas = await this.getOas();
+			if (this.plugin.options.typed && this.plugin.options.version === "3") await this.addFile({
+				baseName: "ToZod.ts",
+				path: path.resolve(root, ".kubb/ToZod.ts"),
+				sources: [{
+					name: "ToZod",
+					value: source
+				}],
+				imports: [],
+				exports: []
+			});
+			const schemaFiles = await new SchemaGenerator(this.plugin.options, {
+				fabric: this.fabric,
+				oas,
+				pluginManager: this.pluginManager,
+				events: this.events,
+				plugin: this.plugin,
+				contentType,
+				include: void 0,
+				override,
+				mode,
+				output: output.path
+			}).build(...generators);
+			await this.upsertFile(...schemaFiles);
+			const operationFiles = await new OperationGenerator(this.plugin.options, {
+				fabric: this.fabric,
+				oas,
+				pluginManager: this.pluginManager,
+				events: this.events,
+				plugin: this.plugin,
+				contentType,
+				exclude,
+				include,
+				override,
+				mode
+			}).build(...generators);
+			await this.upsertFile(...operationFiles);
+			const barrelFiles = await getBarrelFiles(this.fabric.files, {
+				type: output.barrelType ?? "named",
+				root,
+				output,
+				meta: { pluginKey: this.plugin.key }
+			});
+			await this.upsertFile(...barrelFiles);
+		}
+	};
+});
+//#endregion
+export { pluginZod, pluginZodName };
+
+//# sourceMappingURL=index.js.map

package/.output/server/node_modules/@kubb/plugin-zod/dist/templates/ToZod.source.js

@@ -0,0 +1,6 @@
+//#region src/templates/ToZod.source.ts
+const source = "/**\n * See https://github.com/colinhacks/tozod/blob/master/src/index.ts\n * Adapted based on https://github.com/colinhacks/zod/issues/372\n */\n\nimport type * as z from 'zod'\n\ntype IsAny<T> = [any extends T ? 'true' : 'false'] extends ['true'] ? true : false\ntype NonOptional<T> = T extends undefined ? never : T\ntype NonNullable<T> = T extends null ? never : T\ntype Equals<X, Y> = [X] extends [Y] ? ([Y] extends [X] ? true : false) : false\n\ntype ZodKey<T> =\n  IsAny<T> extends true\n    ? 'any'\n    : Equals<T, boolean> extends true //[T] extends [booleanUtil.Type]\n      ? 'boolean'\n      : [undefined] extends [T]\n        ? 'optional'\n        : [null] extends [T]\n          ? 'nullable'\n          : T extends any[]\n            ? 'array'\n            : Equals<T, string> extends true\n              ? 'string'\n              : Equals<T, bigint> extends true //[T] extends [bigintUtil.Type]\n                ? 'bigint'\n                : Equals<T, number> extends true //[T] extends [numberUtil.Type]\n                  ? 'number'\n                  : Equals<T, Date> extends true //[T] extends [dateUtil.Type]\n                    ? 'date'\n                    : T extends { [k: string]: any } //[T] extends [structUtil.Type]\n                      ? 'object'\n                      : 'rest'\n\nexport type ToZod<T> = {\n  any: z.ZodAny\n  optional: z.ZodOptional<ToZod<NonOptional<T>>>\n  nullable: z.ZodNullable<ToZod<NonNullable<T>>>\n  array: T extends Array<infer U> ? z.ZodArray<ToZod<U>> : never\n  string: z.ZodString\n  bigint: z.ZodBigInt\n  number: z.ZodNumber\n  boolean: z.ZodBoolean\n  date: z.ZodDate\n  object: z.ZodObject<\n    // @ts-expect-error cannot convert without Extract but Extract removes the type\n    {\n      [K in keyof T]: T[K]\n    },\n    'passthrough',\n    unknown,\n    T\n  >\n  rest: z.ZodType<T>\n}[ZodKey<T>]\n\nexport type ZodShape<T> = {\n  // Require all the keys from T\n  [key in keyof T]-?: ToZod<T[key]>\n}\n";
+//#endregion
+export { source };
+
+//# sourceMappingURL=ToZod.source.js.map

package/.output/server/node_modules/@kubb/plugin-zod/package.json

@@ -0,0 +1,112 @@
+{
+  "name": "@kubb/plugin-zod",
+  "version": "4.37.2",
+  "description": "Zod schema generator plugin for Kubb, creating type-safe validation schemas from OpenAPI specifications for runtime data validation.",
+  "keywords": [
+    "zod",
+    "schema",
+    "schema-validation",
+    "validation",
+    "runtime-validation",
+    "type-safety",
+    "type-safe",
+    "typescript",
+    "openapi",
+    "swagger",
+    "oas",
+    "code-generator",
+    "codegen",
+    "plugins",
+    "kubb"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kubb-labs/kubb.git",
+    "directory": "packages/plugin-zod"
+  },
+  "license": "MIT",
+  "author": "stijnvanhulle",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./components": {
+      "import": "./dist/components.js",
+      "require": "./dist/components.cjs"
+    },
+    "./generators": {
+      "import": "./dist/generators.js",
+      "require": "./dist/generators.cjs"
+    },
+    "./templates/ToZod.source": {
+      "import": "./dist/templates/ToZod.source.js",
+      "require": "./dist/templates/ToZod.source.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "types": "./dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "components": [
+        "./dist/components.d.ts"
+      ],
+      "generators": [
+        "./dist/generators.d.ts"
+      ],
+      "templates/ToZod.source": [
+        "./dist/templates/ToZod.source.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "src",
+    "templates",
+    "dist",
+    "!/**/**.test.**",
+    "!/**/__tests__/**",
+    "!/**/__snapshots__/**"
+  ],
+  "size-limit": [
+    {
+      "path": "./dist/*.js",
+      "limit": "510 KiB",
+      "gzip": true
+    }
+  ],
+  "dependencies": {
+    "@kubb/react-fabric": "0.14.0",
+    "remeda": "^2.33.6",
+    "@kubb/core": "4.37.2",
+    "@kubb/oas": "4.37.2",
+    "@kubb/plugin-ts": "4.37.2",
+    "@kubb/plugin-oas": "4.37.2"
+  },
+  "devDependencies": {
+    "@asteasolutions/zod-to-openapi": "^8.5.0",
+    "zod": "^3.25.76",
+    "@internals/utils": "0.0.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "scripts": {
+    "build": "tsdown && size-limit",
+    "clean": "npx rimraf ./dist",
+    "lint": "bun biome lint .",
+    "lint:fix": "bun biome lint --fix --unsafe .",
+    "release": "pnpm publish --no-git-check",
+    "release:canary": "bash ../../.github/canary.sh && node ../../scripts/build.js canary && pnpm publish --no-git-check",
+    "start": "tsdown --watch",
+    "test": "vitest --passWithNoTests",
+    "typecheck": "tsc -p ./tsconfig.json --noEmit --emitDeclarationOnly false"
+  }
+}

package/.output/server/node_modules/@kubb/react-fabric/dist/chunk-BGCRLu6H.js

@@ -0,0 +1,38 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", {
+	value,
+	configurable: true
+});
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+export { __toESM as a, __reExport as i, __exportAll as n, __name as r, __commonJSMin as t };