@rolldown/browser 1.0.0-beta.29 → 1.0.0-beta.30

package/dist/shared/{src-CkSl8yxM.cjs → src-CXCXfLrc.cjs}

@@ -1,14 +1,15 @@
 const require_chunk = require('./chunk-DDkG_k5U.cjs');
 const require_dist = require('./dist-BVAp8sOm.cjs');
-const require_parse_ast_index = require('./parse-ast-index-CLjgl4c8.cjs');
+const require_parse_ast_index = require('./parse-ast-index-ZiMOspE_.cjs');
 const src_rolldown_binding_wasi_cjs = require_chunk.__toESM(require("../rolldown-binding.wasi.cjs"));
 const node_path = require_chunk.__toESM(require("node:path"));
 const node_url = require_chunk.__toESM(require("node:url"));
+const node_fs_promises = require_chunk.__toESM(require("node:fs/promises"));
 const node_os = require_chunk.__toESM(require("node:os"));
 const node_worker_threads = require_chunk.__toESM(require("node:worker_threads"));
 
 //#region package.json
-var version = "1.0.0-beta.29";
+var version = "1.0.0-beta.30";
 var description$1 = "Fast JavaScript/TypeScript bundler in Rust with Rollup-compatible API.";
 
 //#endregion
@@ -87,27 +88,6 @@ function viteResolvePlugin(config) {
 	const builtinPlugin = new BuiltinPlugin("builtin:vite-resolve", config);
 	return makeBuiltinPluginCallable(builtinPlugin);
 }
-function moduleFederationPlugin(config) {
-	return new BuiltinPlugin("builtin:module-federation", {
-		...config,
-		remotes: config.remotes && Object.entries(config.remotes).map(([name, remote]) => {
-			if (typeof remote === "string") {
-				const [entryGlobalName] = remote.split("@");
-				const entry = remote.replace(entryGlobalName + "@", "");
-				return {
-					entry,
-					name,
-					entryGlobalName
-				};
-			}
-			return {
-				...remote,
-				name: remote.name ?? name
-			};
-		}),
-		manifest: config.manifest === false ? void 0 : config.manifest === true ? {} : config.manifest
-	});
-}
 function isolatedDeclarationPlugin(config) {
 	return new BuiltinPlugin("builtin:isolated-declaration", config);
 }
@@ -1451,10 +1431,9 @@ function addError(errors, message) {
 function handleError(message, config) {
 	switch (config?.errorMode) {
 		case "ignore": break;
-		case "warn": {
+		case "warn":
 			console.warn(message);
 			break;
-		}
 		default: throw new Error(message);
 	}
 }
@@ -1471,10 +1450,9 @@ function convertAction(jsonSchema, valibotAction, config) {
 	if (config?.ignoreActions?.includes(valibotAction.type)) return jsonSchema;
 	let errors;
 	switch (valibotAction.type) {
-		case "base64": {
+		case "base64":
 			jsonSchema.contentEncoding = "base64";
 			break;
-		}
 		case "bic":
 		case "cuid2":
 		case "decimal":
@@ -1484,57 +1462,46 @@ function convertAction(jsonSchema, valibotAction, config) {
 		case "hex_color":
 		case "nanoid":
 		case "octal":
-		case "ulid": {
+		case "ulid":
 			jsonSchema.pattern = valibotAction.requirement.source;
 			break;
-		}
-		case "description": {
+		case "description":
 			jsonSchema.description = valibotAction.description;
 			break;
-		}
-		case "email": {
+		case "email":
 			jsonSchema.format = "email";
 			break;
-		}
-		case "empty": {
+		case "empty":
 			if (jsonSchema.type === "array") jsonSchema.maxItems = 0;
 			else {
 				if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
 				jsonSchema.maxLength = 0;
 			}
 			break;
-		}
-		case "entries": {
+		case "entries":
 			jsonSchema.minProperties = valibotAction.requirement;
 			jsonSchema.maxProperties = valibotAction.requirement;
 			break;
-		}
-		case "integer": {
+		case "integer":
 			jsonSchema.type = "integer";
 			break;
-		}
-		case "ipv4": {
+		case "ipv4":
 			jsonSchema.format = "ipv4";
 			break;
-		}
-		case "ipv6": {
+		case "ipv6":
 			jsonSchema.format = "ipv6";
 			break;
-		}
-		case "iso_date": {
+		case "iso_date":
 			jsonSchema.format = "date";
 			break;
-		}
 		case "iso_date_time":
-		case "iso_timestamp": {
+		case "iso_timestamp":
 			jsonSchema.format = "date-time";
 			break;
-		}
-		case "iso_time": {
+		case "iso_time":
 			jsonSchema.format = "time";
 			break;
-		}
-		case "length": {
+		case "length":
 			if (jsonSchema.type === "array") {
 				jsonSchema.minItems = valibotAction.requirement;
 				jsonSchema.maxItems = valibotAction.requirement;
@@ -1544,80 +1511,65 @@ function convertAction(jsonSchema, valibotAction, config) {
 				jsonSchema.maxLength = valibotAction.requirement;
 			}
 			break;
-		}
-		case "max_entries": {
+		case "max_entries":
 			jsonSchema.maxProperties = valibotAction.requirement;
 			break;
-		}
-		case "max_length": {
+		case "max_length":
 			if (jsonSchema.type === "array") jsonSchema.maxItems = valibotAction.requirement;
 			else {
 				if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
 				jsonSchema.maxLength = valibotAction.requirement;
 			}
 			break;
-		}
-		case "max_value": {
+		case "max_value":
 			if (jsonSchema.type !== "number") errors = addError(errors, `The "max_value" action is not supported on type "${jsonSchema.type}".`);
 			jsonSchema.maximum = valibotAction.requirement;
 			break;
-		}
-		case "metadata": {
+		case "metadata":
 			if (typeof valibotAction.metadata.title === "string") jsonSchema.title = valibotAction.metadata.title;
 			if (typeof valibotAction.metadata.description === "string") jsonSchema.description = valibotAction.metadata.description;
 			if (Array.isArray(valibotAction.metadata.examples)) jsonSchema.examples = valibotAction.metadata.examples;
 			break;
-		}
-		case "min_entries": {
+		case "min_entries":
 			jsonSchema.minProperties = valibotAction.requirement;
 			break;
-		}
-		case "min_length": {
+		case "min_length":
 			if (jsonSchema.type === "array") jsonSchema.minItems = valibotAction.requirement;
 			else {
 				if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
 				jsonSchema.minLength = valibotAction.requirement;
 			}
 			break;
-		}
-		case "min_value": {
+		case "min_value":
 			if (jsonSchema.type !== "number") errors = addError(errors, `The "min_value" action is not supported on type "${jsonSchema.type}".`);
 			jsonSchema.minimum = valibotAction.requirement;
 			break;
-		}
-		case "multiple_of": {
+		case "multiple_of":
 			jsonSchema.multipleOf = valibotAction.requirement;
 			break;
-		}
-		case "non_empty": {
+		case "non_empty":
 			if (jsonSchema.type === "array") jsonSchema.minItems = 1;
 			else {
 				if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
 				jsonSchema.minLength = 1;
 			}
 			break;
-		}
-		case "regex": {
+		case "regex":
 			if (valibotAction.requirement.flags) errors = addError(errors, "RegExp flags are not supported by JSON Schema.");
 			jsonSchema.pattern = valibotAction.requirement.source;
 			break;
-		}
-		case "title": {
+		case "title":
 			jsonSchema.title = valibotAction.title;
 			break;
-		}
-		case "url": {
+		case "url":
 			jsonSchema.format = "uri";
 			break;
-		}
-		case "uuid": {
+		case "uuid":
 			jsonSchema.format = "uuid";
 			break;
-		}
-		case "value": {
+		case "value":
 			jsonSchema.const = valibotAction.requirement;
 			break;
-		}
 		default: errors = addError(errors, `The "${valibotAction.type}" action cannot be converted to JSON Schema.`);
 	}
 	if (config?.overrideAction) {
@@ -1692,31 +1644,26 @@ function convertSchema(jsonSchema, valibotSchema, config, context, skipRef = fal
 	}
 	let errors;
 	switch (valibotSchema.type) {
-		case "boolean": {
+		case "boolean":
 			jsonSchema.type = "boolean";
 			break;
-		}
-		case "null": {
+		case "null":
 			jsonSchema.type = "null";
 			break;
-		}
-		case "number": {
+		case "number":
 			jsonSchema.type = "number";
 			break;
-		}
-		case "string": {
+		case "string":
 			jsonSchema.type = "string";
 			break;
-		}
-		case "array": {
+		case "array":
 			jsonSchema.type = "array";
 			jsonSchema.items = convertSchema({}, valibotSchema.item, config, context);
 			break;
-		}
 		case "tuple":
 		case "tuple_with_rest":
 		case "loose_tuple":
-		case "strict_tuple": {
+		case "strict_tuple":
 			jsonSchema.type = "array";
 			jsonSchema.items = [];
 			jsonSchema.minItems = valibotSchema.items.length;
@@ -1724,11 +1671,10 @@ function convertSchema(jsonSchema, valibotSchema, config, context, skipRef = fal
 			if (valibotSchema.type === "tuple_with_rest") jsonSchema.additionalItems = convertSchema({}, valibotSchema.rest, config, context);
 			else if (valibotSchema.type === "strict_tuple") jsonSchema.additionalItems = false;
 			break;
-		}
 		case "object":
 		case "object_with_rest":
 		case "loose_object":
-		case "strict_object": {
+		case "strict_object":
 			jsonSchema.type = "object";
 			jsonSchema.properties = {};
 			jsonSchema.required = [];
@@ -1740,52 +1686,43 @@ function convertSchema(jsonSchema, valibotSchema, config, context, skipRef = fal
 			if (valibotSchema.type === "object_with_rest") jsonSchema.additionalProperties = convertSchema({}, valibotSchema.rest, config, context);
 			else if (valibotSchema.type === "strict_object") jsonSchema.additionalProperties = false;
 			break;
-		}
-		case "record": {
+		case "record":
 			if ("pipe" in valibotSchema.key) errors = addError(errors, "The \"record\" schema with a schema for the key that contains a \"pipe\" cannot be converted to JSON Schema.");
 			if (valibotSchema.key.type !== "string") errors = addError(errors, `The "record" schema with the "${valibotSchema.key.type}" schema for the key cannot be converted to JSON Schema.`);
 			jsonSchema.type = "object";
 			jsonSchema.additionalProperties = convertSchema({}, valibotSchema.value, config, context);
 			break;
-		}
 		case "any":
 		case "unknown": break;
 		case "nullable":
-		case "nullish": {
+		case "nullish":
 			jsonSchema.anyOf = [convertSchema({}, valibotSchema.wrapped, config, context), { type: "null" }];
 			if (valibotSchema.default !== void 0) jsonSchema.default = getDefault(valibotSchema);
 			break;
-		}
 		case "exact_optional":
 		case "optional":
-		case "undefinedable": {
+		case "undefinedable":
 			jsonSchema = convertSchema(jsonSchema, valibotSchema.wrapped, config, context);
 			if (valibotSchema.default !== void 0) jsonSchema.default = getDefault(valibotSchema);
 			break;
-		}
-		case "literal": {
+		case "literal":
 			if (typeof valibotSchema.literal !== "boolean" && typeof valibotSchema.literal !== "number" && typeof valibotSchema.literal !== "string") errors = addError(errors, "The value of the \"literal\" schema is not JSON compatible.");
 			jsonSchema.const = valibotSchema.literal;
 			break;
-		}
-		case "enum": {
+		case "enum":
 			jsonSchema.enum = valibotSchema.options;
 			break;
-		}
-		case "picklist": {
+		case "picklist":
 			if (valibotSchema.options.some((option) => typeof option !== "number" && typeof option !== "string")) errors = addError(errors, "An option of the \"picklist\" schema is not JSON compatible.");
 			jsonSchema.enum = valibotSchema.options;
 			break;
-		}
 		case "union":
-		case "variant": {
+		case "variant":
 			jsonSchema.anyOf = valibotSchema.options.map((option) => convertSchema({}, option, config, context));
 			break;
-		}
-		case "intersect": {
+		case "intersect":
 			jsonSchema.allOf = valibotSchema.options.map((option) => convertSchema({}, option, config, context));
 			break;
-		}
 		case "lazy": {
 			let wrappedValibotSchema = context.getterMap.get(valibotSchema.getter);
 			if (!wrappedValibotSchema) {
@@ -1862,7 +1799,7 @@ function toJsonSchema(schema, config) {
 
 //#endregion
 //#region ../../node_modules/.pnpm/ansis@4.1.0/node_modules/ansis/index.cjs
-var require_ansis = require_chunk.__commonJS({ "../../node_modules/.pnpm/ansis@4.1.0/node_modules/ansis/index.cjs"(exports, module) {
+var require_ansis = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/.pnpm/ansis@4.1.0/node_modules/ansis/index.cjs": ((exports, module) => {
 	let e, t, r, { defineProperty: n, setPrototypeOf: l, create: o, keys: s } = Object, i$1 = "", { round: c, max: a$1 } = Math, p = (e$1) => {
 		let t$1 = /([a-f\d]{3,6})/i.exec(e$1)?.[1], r$1 = t$1?.length, n$1 = parseInt(6 ^ r$1 ? 3 ^ r$1 ? "0" : t$1[0] + t$1[0] + t$1[1] + t$1[1] + t$1[2] + t$1[2] : t$1, 16);
 		return [
@@ -1963,11 +1900,11 @@ var require_ansis = require_chunk.__commonJS({ "../../node_modules/.pnpm/ansis@4
 		})), t$1.extend(M);
 	}, y = new w();
 	module.exports = y, y.default = y;
-} });
+}) });
 
 //#endregion
 //#region ../../node_modules/.pnpm/ansis@4.1.0/node_modules/ansis/index.mjs
-var import_ansis = require_chunk.__toESM(require_ansis(), 1);
+var import_ansis = /* @__PURE__ */ require_chunk.__toESM(require_ansis(), 1);
 var ansis_default = import_ansis.default;
 const { Ansis, fg, bg, rgb, bgRgb, hex, bgHex, reset, inverse, hidden, visible, bold, dim, italic, underline, strikethrough, black, red, green, yellow, blue, magenta, cyan, white, gray, redBright, greenBright, yellowBright, blueBright, magentaBright, cyanBright, whiteBright, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bgGray, bgRedBright, bgGreenBright, bgYellowBright, bgBlueBright, bgMagentaBright, bgCyanBright, bgWhiteBright } = import_ansis.default;
 
@@ -2091,6 +2028,7 @@ const ChecksOptionsSchema = strictObject({
 	filenameConflict: pipe(optional(boolean()), description("Whether to emit warning when detecting filename conflict")),
 	commonJsVariableInEsm: pipe(optional(boolean()), description("Whether to emit warning when detecting common js variable in esm")),
 	importIsUndefined: pipe(optional(boolean()), description("Whether to emit warning when detecting import is undefined")),
+	emptyImportMeta: pipe(optional(boolean()), description("Whether to emit warning when detecting empty import meta")),
 	configurationFieldConflict: pipe(optional(boolean()), description("Whether to emit warning when detecting configuration field conflict"))
 });
 const MinifyOptionsSchema = strictObject({
@@ -2118,7 +2056,10 @@ const TreeshakingOptionsSchema = union([boolean(), looseObject({
 	unknownGlobalSideEffects: optional(boolean()),
 	commonjs: optional(boolean())
 })]);
-const OptimizationOptionsSchema = strictObject({ inlineConst: pipe(optional(boolean()), description("Enable crossmodule constant inlining")) });
+const OptimizationOptionsSchema = strictObject({
+	inlineConst: pipe(optional(boolean()), description("Enable crossmodule constant inlining")),
+	pifeForModuleWrappers: pipe(optional(boolean()), description("Use PIFE pattern for module wrappers"))
+});
 const OnLogSchema = pipe(function_(), args(tuple([
 	LogLevelSchema,
 	RollupLogSchema,
@@ -2273,6 +2214,7 @@ const OutputOptionsSchema = strictObject({
 		literal("inline"),
 		literal("hidden")
 	])), description(`Generate sourcemap (\`-s inline\` for inline, or ${ansis_default.bold("pass the `-s` on the last argument if you want to generate `.map` file")})`)),
+	sourcemapBaseUrl: pipe(optional(string()), description("Base URL used to prefix sourcemap paths")),
 	sourcemapDebugIds: pipe(optional(boolean()), description("Inject sourcemap debug IDs")),
 	sourcemapIgnoreList: optional(union([boolean(), custom(() => true)])),
 	sourcemapPathTransform: optional(custom(() => true)),
@@ -2590,44 +2532,38 @@ function bindingifyFilterExprImpl(expr, list) {
 			});
 			break;
 		}
-		case "not": {
+		case "not":
 			bindingifyFilterExprImpl(expr.expr, list);
 			list.push({ kind: "Not" });
 			break;
-		}
-		case "id": {
+		case "id":
 			list.push({
 				kind: "Id",
 				payload: expr.pattern
 			});
 			if (expr.params.cleanUrl) list.push({ kind: "CleanUrl" });
 			break;
-		}
-		case "moduleType": {
+		case "moduleType":
 			list.push({
 				kind: "ModuleType",
 				payload: expr.pattern
 			});
 			break;
-		}
-		case "code": {
+		case "code":
 			list.push({
 				kind: "Code",
 				payload: expr.pattern
 			});
 			break;
-		}
-		case "include": {
+		case "include":
 			bindingifyFilterExprImpl(expr.expr, list);
 			list.push({ kind: "Include" });
 			break;
-		}
-		case "exclude": {
+		case "exclude":
 			bindingifyFilterExprImpl(expr.expr, list);
 			list.push({ kind: "Exclude" });
 			break;
-		}
-		case "query": {
+		case "query":
 			list.push({
 				kind: "QueryKey",
 				payload: expr.key
@@ -2637,7 +2573,6 @@ function bindingifyFilterExprImpl(expr, list) {
 				payload: expr.pattern
 			});
 			break;
-		}
 		default: throw new Error(`Unknown filter expression: ${expr}`);
 	}
 }
@@ -2688,9 +2623,28 @@ function bindingAssetSource(source) {
 	return { inner: source };
 }
 
+//#endregion
+//#region src/plugin/fs.ts
+const fsModule = {
+	appendFile: node_fs_promises.default.appendFile,
+	copyFile: node_fs_promises.default.copyFile,
+	mkdir: node_fs_promises.default.mkdir,
+	mkdtemp: node_fs_promises.default.mkdtemp,
+	readdir: node_fs_promises.default.readdir,
+	readFile: node_fs_promises.default.readFile,
+	realpath: node_fs_promises.default.realpath,
+	rename: node_fs_promises.default.rename,
+	rmdir: node_fs_promises.default.rmdir,
+	stat: node_fs_promises.default.stat,
+	lstat: node_fs_promises.default.lstat,
+	unlink: node_fs_promises.default.unlink,
+	writeFile: node_fs_promises.default.writeFile
+};
+
 //#endregion
 //#region src/plugin/plugin-context.ts
 var PluginContextImpl = class extends MinimalPluginContextImpl {
+	fs = fsModule;
 	getModuleInfo;
 	constructor(outputOptions, context, plugin, data, onLog, logLevel, watchMode, currentLoadingModule) {
 		super(onLog, logLevel, plugin.name, watchMode);
@@ -3608,7 +3562,7 @@ var ChunkingContextImpl = class {
 //#endregion
 //#region src/utils/bindingify-output-options.ts
 function bindingifyOutputOptions(outputOptions) {
-	const { dir, format, exports: exports$1, hashCharacters, sourcemap, sourcemapDebugIds, sourcemapIgnoreList, sourcemapPathTransform, name, assetFileNames, entryFileNames, chunkFileNames, cssEntryFileNames, cssChunkFileNames, banner, footer, intro, outro, esModule, globals, file, sanitizeFileName, preserveModules, virtualDirname, legalComments, preserveModulesRoot, manualChunks, topLevelVar } = outputOptions;
+	const { dir, format, exports: exports$1, hashCharacters, sourcemap, sourcemapBaseUrl, sourcemapDebugIds, sourcemapIgnoreList, sourcemapPathTransform, name, assetFileNames, entryFileNames, chunkFileNames, cssEntryFileNames, cssChunkFileNames, banner, footer, intro, outro, esModule, globals, file, sanitizeFileName, preserveModules, virtualDirname, legalComments, preserveModulesRoot, manualChunks, topLevelVar } = outputOptions;
 	const advancedChunks = bindingifyAdvancedChunks(outputOptions.advancedChunks, manualChunks);
 	return {
 		dir,
@@ -3617,6 +3571,7 @@ function bindingifyOutputOptions(outputOptions) {
 		exports: exports$1,
 		hashCharacters,
 		sourcemap: bindingifySourcemap(sourcemap),
+		sourcemapBaseUrl,
 		sourcemapDebugIds,
 		sourcemapIgnoreList: bindingifySourcemapIgnoreList(sourcemapIgnoreList),
 		sourcemapPathTransform,
@@ -4351,8 +4306,12 @@ var RolldownBuild = class {
 		await this.close();
 	}
 	async generateHmrPatch(changedFiles) {
-		const output = await this.#bundlerImpl.impl.generateHmrPatch(changedFiles);
-		return transformHmrPatchOutput(output);
+		const ret = await this.#bundlerImpl.impl.generateHmrPatch(changedFiles);
+		switch (ret.type) {
+			case "Ok": return ret.field0;
+			case "Error": throw normalizeErrors(ret.field0);
+			default: throw new Error("Unknown error");
+		}
 	}
 	async hmrInvalidate(file, firstInvalidatedBy) {
 		const output = await this.#bundlerImpl.impl.hmrInvalidate(file, firstInvalidatedBy);
@@ -4662,12 +4621,6 @@ Object.defineProperty(exports, 'manifestPlugin', {
     return manifestPlugin;
   }
 });
-Object.defineProperty(exports, 'moduleFederationPlugin', {
-  enumerable: true,
-  get: function () {
-    return moduleFederationPlugin;
-  }
-});
 Object.defineProperty(exports, 'modulePreloadPolyfillPlugin', {
   enumerable: true,
   get: function () {