@rolldown/browser 1.0.0-rc.1 → 1.0.0-rc.2

package/dist/{rolldown-build-C4tDS_XC.js → rolldown-build-BntP6Bjl.js}

@@ -451,7 +451,7 @@ const win32 = /* @__PURE__ */ mix(";");
 
 //#endregion
 //#region package.json
-var version = "1.0.0-rc.1";
+var version = "1.0.0-rc.2";
 
 //#endregion
 //#region src/version.ts
@@ -1083,6 +1083,19 @@ function getDefault(schema, dataset, config$1) {
 	return typeof schema.default === "function" ? schema.default(dataset, config$1) : schema.default;
 }
 /**
+* Checks if the input matches the schema. By using a type predicate, this
+* function can be used as a type guard.
+*
+* @param schema The schema to be used.
+* @param input The input to be tested.
+*
+* @returns Whether the input matches the schema.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function is(schema, input) {
+	return !schema["~run"]({ value: input }, { abortEarly: true }).issues;
+}
+/**
 * Creates an any schema.
 *
 * Hint: This schema function exists only for completeness and is not
@@ -1255,74 +1268,6 @@ function literal(literal_, message$1) {
 	};
 }
 /* @__NO_SIDE_EFFECTS__ */
-function looseObject(entries$1, message$1) {
-	return {
-		kind: "schema",
-		type: "loose_object",
-		reference: looseObject,
-		expects: "Object",
-		async: false,
-		entries: entries$1,
-		message: message$1,
-		get "~standard"() {
-			return /* @__PURE__ */ _getStandardProps(this);
-		},
-		"~run"(dataset, config$1) {
-			const input = dataset.value;
-			if (input && typeof input === "object") {
-				dataset.typed = true;
-				dataset.value = {};
-				for (const key in this.entries) {
-					const valueSchema = this.entries[key];
-					if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
-						const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
-						const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
-						if (valueDataset.issues) {
-							const pathItem = {
-								type: "object",
-								origin: "value",
-								input,
-								key,
-								value: value$1
-							};
-							for (const issue of valueDataset.issues) {
-								if (issue.path) issue.path.unshift(pathItem);
-								else issue.path = [pathItem];
-								dataset.issues?.push(issue);
-							}
-							if (!dataset.issues) dataset.issues = valueDataset.issues;
-							if (config$1.abortEarly) {
-								dataset.typed = false;
-								break;
-							}
-						}
-						if (!valueDataset.typed) dataset.typed = false;
-						dataset.value[key] = valueDataset.value;
-					} else if (valueSchema.fallback !== void 0) dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
-					else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
-						_addIssue(this, "key", dataset, config$1, {
-							input: void 0,
-							expected: `"${key}"`,
-							path: [{
-								type: "object",
-								origin: "key",
-								input,
-								key,
-								value: input[key]
-							}]
-						});
-						if (config$1.abortEarly) break;
-					}
-				}
-				if (!dataset.issues || !config$1.abortEarly) {
-					for (const key in input) if (/* @__PURE__ */ _isValidObjectKey(input, key) && !(key in this.entries)) dataset.value[key] = input[key];
-				}
-			} else _addIssue(this, "type", dataset, config$1);
-			return dataset;
-		}
-	};
-}
-/* @__NO_SIDE_EFFECTS__ */
 function never(message$1) {
 	return {
 		kind: "schema",
@@ -1943,7 +1888,9 @@ function styleText(...args) {
 
 //#endregion
 //#region src/utils/validator.ts
+function isTypeTrue() {}
 const StringOrRegExpSchema = union([string(), instance(RegExp)]);
+isTypeTrue();
 function vFunction() {
 	return function_();
 }
@@ -1952,25 +1899,32 @@ const LogLevelSchema = union([
 	literal("info"),
 	literal("warn")
 ]);
+isTypeTrue();
 const LogLevelOptionSchema = union([LogLevelSchema, literal("silent")]);
+isTypeTrue();
 const LogLevelWithErrorSchema = union([LogLevelSchema, literal("error")]);
+isTypeTrue();
 const RollupLogSchema = any();
 const RollupLogWithStringSchema = union([RollupLogSchema, string()]);
+isTypeTrue();
 const InputOptionSchema = union([
 	string(),
 	array(string()),
 	record(string(), string())
 ]);
+isTypeTrue();
 const ExternalOptionFunctionSchema = pipe(vFunction(), args(tuple([
 	string(),
 	optional(string()),
 	boolean()
 ])), returns(nullish(boolean())));
+isTypeTrue();
 const ExternalOptionSchema = union([
 	StringOrRegExpSchema,
 	array(StringOrRegExpSchema),
 	ExternalOptionFunctionSchema
 ]);
+isTypeTrue();
 const ModuleTypesSchema = record(string(), union([
 	literal("asset"),
 	literal("base64"),
@@ -1985,21 +1939,26 @@ const ModuleTypesSchema = record(string(), union([
 	literal("ts"),
 	literal("tsx")
 ]));
+isTypeTrue();
 const JsxOptionsSchema = strictObject({
 	runtime: pipe(optional(union([literal("classic"), literal("automatic")])), description("Which runtime to use")),
 	development: pipe(optional(boolean()), description("Development specific information")),
 	throwIfNamespace: pipe(optional(boolean()), description("Toggles whether to throw an error when a tag name uses an XML namespace")),
+	pure: pipe(optional(boolean()), description("Mark JSX elements and top-level React method calls as pure for tree shaking.")),
 	importSource: pipe(optional(string()), description("Import the factory of element and fragment if mode is classic")),
 	pragma: pipe(optional(string()), description("Jsx element transformation")),
 	pragmaFrag: pipe(optional(string()), description("Jsx fragment transformation")),
-	refresh: pipe(optional(boolean()), description("Enable react fast refresh"))
+	refresh: pipe(optional(union([boolean(), any()])), description("Enable react fast refresh"))
 });
+isTypeTrue();
 const HelperModeSchema = union([literal("Runtime"), literal("External")]);
 const DecoratorOptionSchema = object({
 	legacy: optional(boolean()),
 	emitDecoratorMetadata: optional(boolean())
 });
+isTypeTrue();
 const HelpersSchema = object({ mode: optional(HelperModeSchema) });
+isTypeTrue();
 const RewriteImportExtensionsSchema = union([
 	literal("rewrite"),
 	literal("remove"),
@@ -2011,12 +1970,14 @@ const TypescriptSchema = object({
 	onlyRemoveTypeImports: optional(boolean()),
 	allowNamespaces: optional(boolean()),
 	allowDeclareFields: optional(boolean()),
+	removeClassFieldsWithoutInitializer: optional(boolean()),
 	declaration: optional(object({
 		stripInternal: optional(boolean()),
 		sourcemap: optional(boolean())
 	})),
 	rewriteImportExtensions: optional(RewriteImportExtensionsSchema)
 });
+isTypeTrue();
 const AssumptionsSchema = object({
 	ignoreFunctionLength: optional(boolean()),
 	noDocumentAll: optional(boolean()),
@@ -2024,11 +1985,17 @@ const AssumptionsSchema = object({
 	pureGetters: optional(boolean()),
 	setPublicClassFields: optional(boolean())
 });
+isTypeTrue();
+const TransformPluginsSchema = object({
+	styledComponents: optional(any()),
+	taggedTemplateEscape: optional(boolean())
+});
+isTypeTrue();
 const TransformOptionsSchema = object({
 	assumptions: optional(AssumptionsSchema),
 	typescript: optional(TypescriptSchema),
 	helpers: optional(HelpersSchema),
-	decorators: optional(DecoratorOptionSchema),
+	decorator: optional(DecoratorOptionSchema),
 	jsx: optional(union([
 		literal(false),
 		literal("preserve"),
@@ -2039,9 +2006,11 @@ const TransformOptionsSchema = object({
 	target: pipe(optional(union([string(), array(string())])), description("The JavaScript target environment")),
 	define: pipe(optional(record(string(), string())), description("Define global variables (syntax: key=value,key2=value2)")),
 	inject: pipe(optional(record(string(), union([string(), tuple([string(), string()])]))), description("Inject import statements on demand")),
-	dropLabels: pipe(optional(array(string())), description("Remove labeled statements with these label names"))
+	dropLabels: pipe(optional(array(string())), description("Remove labeled statements with these label names")),
+	plugins: pipe(optional(TransformPluginsSchema), description("Third-party plugins to use"))
 });
-const WatchOptionsSchema = strictObject({
+isTypeTrue();
+const WatcherOptionsSchema = strictObject({
 	chokidar: optional(never(`The "watch.chokidar" option is deprecated, please use "watch.notify" instead of it`)),
 	exclude: optional(union([StringOrRegExpSchema, array(StringOrRegExpSchema)])),
 	include: optional(union([StringOrRegExpSchema, array(StringOrRegExpSchema)])),
@@ -2052,8 +2021,9 @@ const WatchOptionsSchema = strictObject({
 	skipWrite: pipe(optional(boolean()), description("Skip the bundle.write() step")),
 	buildDelay: pipe(optional(number()), description("Throttle watch rebuilds")),
 	clearScreen: pipe(optional(boolean()), description("Whether to clear the screen when a rebuild is triggered")),
-	onInvalidate: pipe(optional(pipe(function_(), args(tuple([string()])))), description("An optional function that will be called immediately every time a module changes that is part of the build."))
+	onInvalidate: pipe(optional(vFunction()), description("An optional function that will be called immediately every time a module changes that is part of the build."))
 });
+isTypeTrue();
 const ChecksOptionsSchema = strictObject({
 	circularDependency: pipe(optional(boolean()), description("Whether to emit warnings when detecting circular dependency")),
 	eval: pipe(optional(boolean()), description("Whether to emit warnings when detecting uses of direct `eval`s")),
@@ -2071,46 +2041,55 @@ const ChecksOptionsSchema = strictObject({
 	configurationFieldConflict: pipe(optional(boolean()), description("Whether to emit warnings when a config value is overridden by another config value with a higher priority")),
 	preferBuiltinFeature: pipe(optional(boolean()), description("Whether to emit warnings when a plugin that is covered by a built-in feature is used")),
 	couldNotCleanDirectory: pipe(optional(boolean()), description("Whether to emit warnings when Rolldown could not clean the output directory")),
-	pluginTimings: pipe(optional(boolean()), description("Whether to emit warnings when plugins take significant time during the build process"))
+	pluginTimings: pipe(optional(boolean()), description("Whether to emit warnings when plugins take significant time during the build process")),
+	duplicateShebang: pipe(optional(boolean()), description("Whether to emit warnings when both the code and postBanner contain shebang"))
 });
+isTypeTrue();
 const CompressOptionsKeepNamesSchema = strictObject({
 	function: boolean(),
 	class: boolean()
 });
+isTypeTrue();
+const CompressTreeshakeOptionsSchema = strictObject({
+	annotations: optional(boolean()),
+	manualPureFunctions: optional(array(string())),
+	propertyReadSideEffects: optional(union([boolean(), literal("always")])),
+	unknownGlobalSideEffects: optional(boolean()),
+	invalidImportSideEffects: optional(boolean())
+});
+isTypeTrue();
 const CompressOptionsSchema = strictObject({
-	target: optional(union([
-		literal("esnext"),
-		literal("es2015"),
-		literal("es2016"),
-		literal("es2017"),
-		literal("es2018"),
-		literal("es2019"),
-		literal("es2020"),
-		literal("es2021"),
-		literal("es2022"),
-		literal("es2023"),
-		literal("es2024")
-	])),
+	target: optional(union([string(), array(string())])),
 	dropConsole: optional(boolean()),
 	dropDebugger: optional(boolean()),
 	keepNames: optional(CompressOptionsKeepNamesSchema),
-	unused: optional(union([boolean(), literal("keep_assign")]))
+	unused: optional(union([boolean(), literal("keep_assign")])),
+	joinVars: optional(boolean()),
+	sequences: optional(boolean()),
+	dropLabels: optional(array(string())),
+	maxIterations: optional(number()),
+	treeshake: optional(CompressTreeshakeOptionsSchema)
 });
+isTypeTrue();
 const MangleOptionsKeepNamesSchema = strictObject({
 	function: boolean(),
 	class: boolean()
 });
+isTypeTrue();
 const MangleOptionsSchema = strictObject({
 	toplevel: optional(boolean()),
 	keepNames: optional(union([boolean(), MangleOptionsKeepNamesSchema])),
 	debug: optional(boolean())
 });
+isTypeTrue();
 const CodegenOptionsSchema = strictObject({ removeWhitespace: optional(boolean()) });
+isTypeTrue();
 const MinifyOptionsSchema = strictObject({
 	compress: optional(union([boolean(), CompressOptionsSchema])),
 	mangle: optional(union([boolean(), MangleOptionsSchema])),
 	codegen: optional(union([boolean(), CodegenOptionsSchema]))
 });
+isTypeTrue();
 const ResolveOptionsSchema = strictObject({
 	alias: optional(record(string(), union([
 		literal(false),
@@ -2126,17 +2105,20 @@ const ResolveOptionsSchema = strictObject({
 	mainFiles: optional(array(string())),
 	modules: optional(array(string())),
 	symlinks: optional(boolean()),
-	yarnPnp: optional(boolean())
+	tsconfigFilename: optional(string())
 });
-const TreeshakingOptionsSchema = union([boolean(), looseObject({
+isTypeTrue();
+const TreeshakingOptionsSchema = strictObject({
+	moduleSideEffects: optional(any()),
 	annotations: optional(boolean()),
-	manualPureFunctions: optional(array(string())),
+	manualPureFunctions: optional(custom((input) => is(array(string()), input), "string array")),
 	unknownGlobalSideEffects: optional(boolean()),
 	invalidImportSideEffects: optional(boolean()),
 	commonjs: optional(boolean()),
 	propertyReadSideEffects: optional(union([literal(false), literal("always")])),
 	propertyWriteSideEffects: optional(union([literal(false), literal("always")]))
-})]);
+});
+isTypeTrue();
 const OptimizationOptionsSchema = strictObject({
 	inlineConst: pipe(optional(union([boolean(), strictObject({
 		mode: optional(union([literal("all"), literal("smart")])),
@@ -2144,19 +2126,24 @@ const OptimizationOptionsSchema = strictObject({
 	})])), description("Enable crossmodule constant inlining")),
 	pifeForModuleWrappers: pipe(optional(boolean()), description("Use PIFE pattern for module wrappers"))
 });
+isTypeTrue();
 const LogOrStringHandlerSchema = pipe(vFunction(), args(tuple([LogLevelWithErrorSchema, RollupLogWithStringSchema])));
+isTypeTrue();
 const OnLogSchema = pipe(vFunction(), args(tuple([
 	LogLevelSchema,
 	RollupLogSchema,
 	LogOrStringHandlerSchema
 ])));
+isTypeTrue();
 const OnwarnSchema = pipe(vFunction(), args(tuple([RollupLogSchema, pipe(vFunction(), args(tuple([union([RollupLogWithStringSchema, pipe(vFunction(), returns(RollupLogWithStringSchema))])])))])));
+isTypeTrue();
 const DevModeSchema = union([boolean(), strictObject({
 	port: optional(number()),
 	host: optional(string()),
 	implement: optional(string()),
 	lazy: optional(boolean())
 })]);
+isTypeTrue();
 const InputOptionsSchema = strictObject({
 	input: optional(InputOptionSchema),
 	plugins: optional(custom(() => true)),
@@ -2170,35 +2157,34 @@ const InputOptionsSchema = strictObject({
 		literal("node")
 	])), description(`Platform for which the code should be generated (node, ${styleText("underline", "browser")}, neutral)`)),
 	shimMissingExports: pipe(optional(boolean()), description("Create shim variables for missing exports")),
-	treeshake: optional(TreeshakingOptionsSchema),
+	treeshake: optional(union([boolean(), TreeshakingOptionsSchema])),
 	optimization: optional(OptimizationOptionsSchema),
 	logLevel: pipe(optional(LogLevelOptionSchema), description(`Log level (${styleText("dim", "silent")}, ${styleText(["underline", "gray"], "info")}, debug, ${styleText("yellow", "warn")})`)),
 	onLog: optional(OnLogSchema),
 	onwarn: optional(OnwarnSchema),
 	moduleTypes: pipe(optional(ModuleTypesSchema), description("Module types for customized extensions")),
 	experimental: optional(strictObject({
-		enableComposingJsPlugins: optional(boolean()),
 		viteMode: optional(boolean()),
 		resolveNewUrlToAsset: optional(boolean()),
-		strictExecutionOrder: optional(boolean()),
-		onDemandWrapping: optional(boolean()),
-		incrementalBuild: optional(boolean()),
 		devMode: optional(DevModeSchema),
+		chunkModulesOrder: optional(union([literal("module-id"), literal("exec-order")])),
 		attachDebugInfo: optional(union([
 			literal("none"),
 			literal("simple"),
 			literal("full")
 		])),
-		chunkModulesOrder: optional(union([literal("module-id"), literal("exec-order")])),
 		chunkImportMap: optional(union([boolean(), object({
 			baseUrl: optional(string()),
 			fileName: optional(string())
 		})])),
+		onDemandWrapping: optional(boolean()),
+		incrementalBuild: optional(boolean()),
 		nativeMagicString: optional(boolean()),
-		chunkOptimization: optional(boolean())
+		chunkOptimization: optional(boolean()),
+		lazyBarrel: optional(boolean())
 	})),
 	transform: optional(TransformOptionsSchema),
-	watch: optional(union([WatchOptionsSchema, literal(false)])),
+	watch: optional(union([WatcherOptionsSchema, literal(false)])),
 	checks: optional(ChecksOptionsSchema),
 	devtools: pipe(optional(object({ sessionId: pipe(optional(string()), description("Used to name the build.")) })), description("Enable debug mode. Emit debug information to disk. This might slow down the build process significantly.")),
 	preserveEntrySignatures: pipe(optional(union([
@@ -2207,8 +2193,10 @@ const InputOptionsSchema = strictObject({
 		literal("exports-only"),
 		literal(false)
 	]))),
+	context: pipe(optional(string()), description("The value of `this` at the top level of each module.")),
 	tsconfig: pipe(optional(union([boolean(), string()])), description("Path to the tsconfig.json file."))
 });
+isTypeTrue();
 const InputCliOverrideSchema = strictObject({
 	input: pipe(optional(array(string())), description("Entry file")),
 	external: pipe(optional(array(string())), description("Comma-separated list of module ids to exclude from the bundle `<module-id>,...`")),
@@ -2237,22 +2225,32 @@ const ModuleFormatSchema = union([
 	literal("iife"),
 	literal("umd")
 ]);
+isTypeTrue();
 const AddonFunctionSchema = pipe(vFunction(), args(tuple([custom(() => true)])), returnsAsync(unionAsync([string(), pipeAsync(promise(), awaitAsync(), string())])));
+isTypeTrue();
 const ChunkFileNamesFunctionSchema = pipe(vFunction(), args(tuple([custom(() => true)])), returns(string()));
+isTypeTrue();
 const ChunkFileNamesSchema = union([string(), ChunkFileNamesFunctionSchema]);
 const AssetFileNamesFunctionSchema = pipe(vFunction(), args(tuple([custom(() => true)])), returns(string()));
+isTypeTrue();
 const AssetFileNamesSchema = union([string(), AssetFileNamesFunctionSchema]);
 const SanitizeFileNameFunctionSchema = pipe(vFunction(), args(tuple([string()])), returns(string()));
+isTypeTrue();
 const SanitizeFileNameSchema = union([boolean(), SanitizeFileNameFunctionSchema]);
 const GlobalsFunctionSchema = pipe(vFunction(), args(tuple([string()])), returns(string()));
+isTypeTrue();
 const PathsFunctionSchema = pipe(vFunction(), args(tuple([string()])), returns(string()));
+isTypeTrue();
 const ManualChunksFunctionSchema = pipe(vFunction(), args(tuple([string(), object({})])), returns(nullish(string())));
+isTypeTrue();
 const AdvancedChunksNameFunctionSchema = pipe(vFunction(), args(tuple([string(), object({})])), returns(nullish(string())));
+isTypeTrue();
 const AdvancedChunksTestFunctionSchema = pipe(vFunction(), args(tuple([string()])), returns(union([
 	boolean(),
 	void_(),
 	undefined_()
 ])));
+isTypeTrue();
 const AdvancedChunksSchema = strictObject({
 	includeDependenciesRecursively: optional(boolean()),
 	minSize: optional(number()),
@@ -2271,12 +2269,15 @@ const AdvancedChunksSchema = strictObject({
 		maxModuleSize: optional(number())
 	})))
 });
+isTypeTrue();
 const GeneratedCodePresetSchema = union([literal("es5"), literal("es2015")]);
+isTypeTrue();
 const GeneratedCodeOptionsSchema = strictObject({
 	symbols: pipe(optional(boolean()), description("Whether to use Symbol.toStringTag for namespace objects")),
-	preset: GeneratedCodePresetSchema,
+	preset: optional(GeneratedCodePresetSchema),
 	profilerNames: pipe(optional(boolean()), description("Whether to add readable names to internal variables for profiling purposes"))
 });
+isTypeTrue();
 const OutputOptionsSchema = strictObject({
 	dir: pipe(optional(string()), description("Output directory, defaults to `dist` if `file` is not set")),
 	file: pipe(optional(string()), description("Single output file")),
@@ -2344,8 +2345,10 @@ const OutputOptionsSchema = strictObject({
 	minifyInternalExports: pipe(optional(boolean()), description("Minify internal exports")),
 	topLevelVar: pipe(optional(boolean()), description("Rewrite top-level declarations to use `var`.")),
 	cleanDir: pipe(optional(boolean()), description("Clean output directory before emitting output")),
-	keepNames: pipe(optional(boolean()), description("Keep function and class names after bundling"))
+	keepNames: pipe(optional(boolean()), description("Keep function and class names after bundling")),
+	strictExecutionOrder: pipe(optional(boolean()), description("Lets modules be executed in the order they are declared."))
 });
+isTypeTrue();
 const getAddonDescription = (placement, wrapper) => {
 	return `Code to insert the ${styleText("bold", placement)} of the bundled file (${styleText("bold", wrapper)} the wrapper function)`;
 };
@@ -2548,7 +2551,7 @@ function bindingAssetSource(source) {
 }
 
 //#endregion
-//#region \0@oxc-project+runtime@0.110.0/helpers/decorate.js
+//#region \0@oxc-project+runtime@0.111.0/helpers/decorate.js
 function __decorate(decorators, target, key, desc) {
 	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
 	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -2937,7 +2940,7 @@ var RolldownOutputImpl = class extends PlainObjectLike {
 __decorate([lazyProp], RolldownOutputImpl.prototype, "output", null);
 
 //#endregion
-//#region ../../node_modules/.pnpm/oxc-parser@0.110.0/node_modules/oxc-parser/src-js/wrap.js
+//#region ../../node_modules/.pnpm/oxc-parser@0.111.0/node_modules/oxc-parser/src-js/wrap.js
 function wrap$1(result) {
 	let program, module, comments, errors;
 	return {
@@ -3507,10 +3510,14 @@ var PluginContextImpl = class extends MinimalPluginContextImpl {
 	emitFile = (file) => {
 		if (file.type === "prebuilt-chunk") return this.context.emitPrebuiltChunk({
 			fileName: file.fileName,
+			name: file.name,
 			code: file.code,
 			exports: file.exports,
 			map: bindingifySourcemap$1(file.map),
-			sourcemapFileName: file.sourcemapFileName
+			sourcemapFileName: file.sourcemapFileName,
+			facadeModuleId: file.facadeModuleId,
+			isEntry: file.isEntry,
+			isDynamicEntry: file.isDynamicEntry
 		});
 		if (file.type === "chunk") return this.context.emitChunk({
 			preserveEntrySignatures: bindingifyPreserveEntrySignatures(file.preserveSignature),
@@ -4626,7 +4633,8 @@ function bindingifyExperimental(experimental) {
 		onDemandWrapping: experimental?.onDemandWrapping,
 		incrementalBuild: experimental?.incrementalBuild,
 		nativeMagicString: experimental?.nativeMagicString,
-		chunkOptimization: experimental?.chunkOptimization
+		chunkOptimization: experimental?.chunkOptimization,
+		lazyBarrel: experimental?.lazyBarrel
 	};
 }
 function bindingifyResolve(resolve) {

package/dist/shared/{bindingify-input-options-Bp2kpiI8.mjs → bindingify-input-options-CObJx_Uj.mjs}

@@ -1,13 +1,13 @@
 import { a as logInvalidLogPosition, c as logPluginError, n as error, r as logCycleLoading, t as augmentCodeLocation } from "./logs-B2CASPcx.mjs";
 import { i as bindingifyManifestPlugin, n as BuiltinPlugin, r as bindingifyBuiltInPlugin, t as normalizedStringOrRegex } from "./normalize-string-or-regex-DIwprzLy.mjs";
 import { _ as noop, a as id, b as unsupported, f as or, h as arraify, n as code, r as exclude, s as include, t as and, u as moduleType, y as unreachable } from "./composable-filters-CIxSuZSM.mjs";
-import { t as parseAst } from "./parse-ast-index-2ahkCVK6.mjs";
+import { t as parseAst } from "./parse-ast-index-BQpfNG1v.mjs";
 import { BindingAttachDebugInfo, BindingChunkModuleOrderBy, BindingLogLevel, BindingMagicString, BindingPluginOrder, BindingPropertyReadSideEffects, BindingPropertyWriteSideEffects } from "../rolldown-binding.wasi.cjs";
 import path from "node:path";
 import fsp from "node:fs/promises";
 
 //#region package.json
-var version = "1.0.0-rc.1";
+var version = "1.0.0-rc.2";
 var description = "Fast JavaScript/TypeScript bundler in Rust with Rollup-compatible API.";
 
 //#endregion
@@ -219,7 +219,7 @@ function bindingAssetSource(source) {
 }
 
 //#endregion
-//#region \0@oxc-project+runtime@0.110.0/helpers/decorate.js
+//#region \0@oxc-project+runtime@0.111.0/helpers/decorate.js
 function __decorate(decorators, target, key, desc) {
 	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
 	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -977,10 +977,14 @@ var PluginContextImpl = class extends MinimalPluginContextImpl {
 	emitFile = (file) => {
 		if (file.type === "prebuilt-chunk") return this.context.emitPrebuiltChunk({
 			fileName: file.fileName,
+			name: file.name,
 			code: file.code,
 			exports: file.exports,
 			map: bindingifySourcemap(file.map),
-			sourcemapFileName: file.sourcemapFileName
+			sourcemapFileName: file.sourcemapFileName,
+			facadeModuleId: file.facadeModuleId,
+			isEntry: file.isEntry,
+			isDynamicEntry: file.isDynamicEntry
 		});
 		if (file.type === "chunk") return this.context.emitChunk({
 			preserveEntrySignatures: bindingifyPreserveEntrySignatures(file.preserveSignature),
@@ -2096,7 +2100,8 @@ function bindingifyExperimental(experimental) {
 		onDemandWrapping: experimental?.onDemandWrapping,
 		incrementalBuild: experimental?.incrementalBuild,
 		nativeMagicString: experimental?.nativeMagicString,
-		chunkOptimization: experimental?.chunkOptimization
+		chunkOptimization: experimental?.chunkOptimization,
+		lazyBarrel: experimental?.lazyBarrel
 	};
 }
 function bindingifyResolve(resolve) {