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

package/dist/shared/{src-BWVOVy_u.mjs → src-CkG0t1KT.mjs}

@@ -1,8 +1,9 @@
 import { and, arraify, code, exclude, id, include, moduleType, noop, or, unimplemented, unreachable, unsupported } from "./dist-DvBwroyk.mjs";
-import { augmentCodeLocation, error, logCycleLoading, logDuplicateJsxConfig, logInputHookInOutputPlugin, logInvalidLogPosition, logMultiplyNotifyOption, logPluginError, parseAst } from "./parse-ast-index-rwZvDBjW.mjs";
+import { augmentCodeLocation, error, logCycleLoading, logDuplicateJsxConfig, logInputHookInOutputPlugin, logInvalidLogPosition, logMultiplyNotifyOption, logPluginError, parseAst } from "./parse-ast-index-Z-sG_A0I.mjs";
 import { BindingAttachDebugInfo, BindingBundler, BindingCallableBuiltinPlugin, BindingChunkModuleOrderBy, BindingJsx, BindingLogLevel, BindingPluginOrder, BindingWatcher, ParallelJsPluginRegistry, shutdownAsyncRuntime, startAsyncRuntime } from "../rolldown-binding.wasi.cjs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import fsp from "node:fs/promises";
 import os from "node:os";
 import { Worker } from "node:worker_threads";
 
@@ -33,7 +34,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 //#endregion
 //#region package.json
-var version = "1.0.0-beta.29-commit.fe1bea3";
+var version = "1.0.0-beta.30";
 var description$1 = "Fast JavaScript/TypeScript bundler in Rust with Rollup-compatible API.";
 
 //#endregion
@@ -112,27 +113,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);
 }
@@ -1476,10 +1456,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);
 	}
 }
@@ -1496,10 +1475,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":
@@ -1509,57 +1487,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;
@@ -1569,80 +1536,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) {
@@ -1717,31 +1669,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;
@@ -1749,11 +1696,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 = [];
@@ -1765,52 +1711,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) {
@@ -1887,7 +1824,7 @@ function toJsonSchema(schema, config) {
 
 //#endregion
 //#region ../../node_modules/.pnpm/ansis@4.1.0/node_modules/ansis/index.cjs
-var require_ansis = __commonJS({ "../../node_modules/.pnpm/ansis@4.1.0/node_modules/ansis/index.cjs"(exports, module) {
+var require_ansis = /* @__PURE__ */ __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 [
@@ -1988,11 +1925,11 @@ var require_ansis = __commonJS({ "../../node_modules/.pnpm/ansis@4.1.0/node_modu
 		})), 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 = __toESM(require_ansis(), 1);
+var import_ansis = /* @__PURE__ */ __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;
 
@@ -2144,7 +2081,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,
@@ -2299,6 +2239,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)),
@@ -2616,44 +2557,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
@@ -2663,7 +2598,6 @@ function bindingifyFilterExprImpl(expr, list) {
 				payload: expr.pattern
 			});
 			break;
-		}
 		default: throw new Error(`Unknown filter expression: ${expr}`);
 	}
 }
@@ -2714,9 +2648,28 @@ function bindingAssetSource(source) {
 	return { inner: source };
 }
 
+//#endregion
+//#region src/plugin/fs.ts
+const fsModule = {
+	appendFile: fsp.appendFile,
+	copyFile: fsp.copyFile,
+	mkdir: fsp.mkdir,
+	mkdtemp: fsp.mkdtemp,
+	readdir: fsp.readdir,
+	readFile: fsp.readFile,
+	realpath: fsp.realpath,
+	rename: fsp.rename,
+	rmdir: fsp.rmdir,
+	stat: fsp.stat,
+	lstat: fsp.lstat,
+	unlink: fsp.unlink,
+	writeFile: fsp.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);
@@ -3634,7 +3587,7 @@ var ChunkingContextImpl = class {
 //#endregion
 //#region src/utils/bindingify-output-options.ts
 function bindingifyOutputOptions(outputOptions) {
-	const { dir, format, exports, 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, 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,
@@ -3643,6 +3596,7 @@ function bindingifyOutputOptions(outputOptions) {
 		exports,
 		hashCharacters,
 		sourcemap: bindingifySourcemap(sourcemap),
+		sourcemapBaseUrl,
 		sourcemapDebugIds,
 		sourcemapIgnoreList: bindingifySourcemapIgnoreList(sourcemapIgnoreList),
 		sourcemapPathTransform,
@@ -4377,8 +4331,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);
@@ -4556,4 +4514,4 @@ function defineConfig(config) {
 const VERSION = version;
 
 //#endregion
-export { BuiltinPlugin, PluginContextData, PluginDriver, VERSION, __commonJS, __toESM, ansis_default, assetPlugin, bindingifyPlugin, build, buildImportAnalysisPlugin, createBundlerImpl, defineConfig, description$1 as description, dynamicImportVarsPlugin, getInputCliKeys, getJsonSchema, getOutputCliKeys, handleOutputErrors, importGlobPlugin, isolatedDeclarationPlugin, jsonPlugin, loadFallbackPlugin, manifestPlugin, moduleFederationPlugin, modulePreloadPolyfillPlugin, normalizedStringOrRegex, reporterPlugin, rolldown, validateCliOptions, version, viteResolvePlugin, wasmFallbackPlugin, wasmHelperPlugin, watch, webWorkerPostPlugin };
+export { BuiltinPlugin, PluginContextData, PluginDriver, VERSION, __commonJS, __toESM, ansis_default, assetPlugin, bindingifyPlugin, build, buildImportAnalysisPlugin, createBundlerImpl, defineConfig, description$1 as description, dynamicImportVarsPlugin, getInputCliKeys, getJsonSchema, getOutputCliKeys, handleOutputErrors, importGlobPlugin, isolatedDeclarationPlugin, jsonPlugin, loadFallbackPlugin, manifestPlugin, modulePreloadPolyfillPlugin, normalizedStringOrRegex, reporterPlugin, rolldown, validateCliOptions, version, viteResolvePlugin, wasmFallbackPlugin, wasmHelperPlugin, watch, webWorkerPostPlugin };