@rollipop/core 0.0.0 → 0.1.0-alpha.0

package/dist/index.js

@@ -0,0 +1,1619 @@
+import { n as __require, t as __export } from "./chunk-BYW8Mqxw.js";
+import path from "node:path";
+import { DEV_SERVER_ASSET_PATH, FileStorage, Logger, Logo, chalk, getCachePath } from "@rollipop/common";
+import { invariant, isNotNil, merge, mergeWith, pick, range, throttle } from "es-toolkit";
+import * as rolldown from "rolldown";
+import * as rolldownExperimental from "rolldown/experimental";
+import { dev, transformSync } from "rolldown/experimental";
+import crypto from "node:crypto";
+import { xxh32 } from "@node-rs/xxhash";
+import fs from "node:fs";
+import dedent from "dedent";
+import wrapAnsi from "wrap-ansi";
+import path$1 from "path";
+import * as babel from "@babel/core";
+import { exactRegex } from "@rolldown/pluginutils";
+import { generate } from "@babel/generator";
+import * as swc from "@swc/core";
+import flowRemoveTypes from "flow-remove-types";
+import * as hermesParser from "hermes-parser";
+import { imageSize } from "image-size";
+import { transform } from "@svgr/core";
+import * as c12 from "c12";
+
+//#region src/constants.ts
+const ROLLIPOP_VERSION = "0.1.0-alpha.0";
+const GLOBAL_IDENTIFIER = "__ROLLIPOP_GLOBAL__";
+/**
+* Unlike the Metro bundler configuration, this prioritizes resolving module(ESM) fields first.
+*
+* @see {@link https://github.com/facebook/metro/blob/0.81.x/docs/Configuration.md#resolvermainfields}
+*/
+const DEFAULT_RESOLVER_MAIN_FIELDS = [
+	"react-native",
+	"module",
+	"main"
+];
+const DEFAULT_RESOLVER_CONDITION_NAMES = [
+	"react-native",
+	"import",
+	"require"
+];
+/**
+* Unlike the Metro bundler configuration, this prioritizes resolving TypeScript and ESM first.
+*
+* @see {@link https://github.com/facebook/metro/blob/0.81.x/packages/metro-config/src/defaults/defaults.js}
+* @see {@link https://github.com/facebook/metro/blob/0.81.x/packages/metro-file-map/src/workerExclusionList.js}
+*/
+const DEFAULT_SOURCE_EXTENSIONS = [
+	"ts",
+	"tsx",
+	"js",
+	"jsx",
+	"mjs",
+	"cjs",
+	"json"
+];
+const DEFAULT_ASSET_EXTENSIONS = [
+	"bmp",
+	"gif",
+	"jpg",
+	"jpeg",
+	"png",
+	"psd",
+	"svg",
+	"webp",
+	"xml",
+	"m4v",
+	"mov",
+	"mp4",
+	"mpeg",
+	"mpg",
+	"webm",
+	"aac",
+	"aiff",
+	"caf",
+	"m4a",
+	"mp3",
+	"wav",
+	"html",
+	"pdf",
+	"yaml",
+	"yml",
+	"otf",
+	"ttf",
+	"zip"
+];
+const DEFAULT_ASSET_REGISTRY_PATH = "react-native/Libraries/Image/AssetRegistry.js";
+const DEFAULT_HMR_CLIENT_PATH = "react-native/Libraries/Utilities/HMRClient.js";
+
+//#endregion
+//#region src/utils/hash.ts
+function xxhash(data) {
+	return xxh32(data).toString(16);
+}
+function md5(data) {
+	return crypto.createHash("md5").update(data).digest("hex");
+}
+
+//#endregion
+//#region src/utils/serialize.ts
+function serialize(value) {
+	return JSON.stringify(value, (_, value$1) => {
+		if (typeof value$1 === "function") return value$1.toString();
+		if (value$1 instanceof RegExp) return value$1.toString();
+		return value$1;
+	});
+}
+
+//#endregion
+//#region src/utils/id.ts
+function createId(config, buildOptions) {
+	return md5(serialize([
+		ROLLIPOP_VERSION,
+		pick(buildOptions, ["platform", "dev"]),
+		config.resolver,
+		config.transformer,
+		config.plugins,
+		config.serializer.prelude
+	]));
+}
+
+//#endregion
+//#region src/logger.ts
+const logger = new Logger("bundler");
+
+//#endregion
+//#region src/core/cache/file-system-cache.ts
+var FileSystemCache = class {
+	constructor(cacheDirectory) {
+		this.cacheDirectory = cacheDirectory;
+		this.ensureCacheDirectory();
+		logger.debug("cache directory:", cacheDirectory);
+	}
+	ensureCacheDirectory() {
+		if (!fs.existsSync(this.cacheDirectory)) fs.mkdirSync(this.cacheDirectory, { recursive: true });
+	}
+	get(key) {
+		try {
+			return fs.readFileSync(path.join(this.cacheDirectory, key), "utf-8");
+		} catch {
+			return;
+		}
+	}
+	set(key, value) {
+		try {
+			fs.writeFileSync(path.join(this.cacheDirectory, key), value);
+		} catch {
+			logger.error("Failed to write cache file", key);
+		}
+	}
+	clear() {
+		fs.rmSync(this.cacheDirectory, {
+			recursive: true,
+			force: true
+		});
+		this.ensureCacheDirectory();
+	}
+};
+
+//#endregion
+//#region ../common/src/constants.ts
+const DEBUG_KEY = "rollipop";
+
+//#endregion
+//#region ../common/src/debug.ts
+const TRUTHY_VALUES = [
+	"yes",
+	"on",
+	"true",
+	"enabled"
+];
+const FALSY_VALUES = [
+	"no",
+	"off",
+	"false",
+	"disabled"
+];
+function parseDebugKeys() {
+	return Object.keys(process.env).filter((key) => /^debug_/i.test(key)).reduce((acc, key) => {
+		const prop = key.slice(6).toLowerCase().replace(/_([a-z])/g, (_, key$1) => key$1.toUpperCase());
+		let value = process.env[key];
+		const lowerCase = typeof value === "string" ? value.toLowerCase() : value.toString();
+		if (TRUTHY_VALUES.includes(lowerCase)) value = true;
+		else if (FALSY_VALUES.includes(lowerCase)) value = false;
+		else value = Boolean(Number(value));
+		acc[prop] = value;
+		return acc;
+	}, {});
+}
+let debugKeys = null;
+function isDebugEnabled() {
+	if (debugKeys == null) debugKeys = parseDebugKeys();
+	return debugKeys[DEBUG_KEY] ?? false;
+}
+
+//#endregion
+//#region src/utils/string.ts
+function indent(text, indent$1, space = " ") {
+	return text.replace(/^/gm, space.repeat(indent$1));
+}
+
+//#endregion
+//#region src/common/code.ts
+function asLiteral(value) {
+	return JSON.stringify(value);
+}
+function asIdentifier(name) {
+	return name;
+}
+function nodeEnvironment(dev$1) {
+	return dev$1 ? "development" : "production";
+}
+function iife(body, path$2 = "<unknown>") {
+	const bodyPlaceholder = "__BODY__";
+	return dedent`
+  // ${path$2}
+  (function (global) {
+  ${bodyPlaceholder}
+  })(${GLOBAL_IDENTIFIER});
+  `.replace(bodyPlaceholder, indent(body, 1));
+}
+
+//#endregion
+//#region src/utils/storage.ts
+function getBuildTotalModules(storage, id) {
+	return storage.get().build[id]?.totalModules ?? 0;
+}
+function setBuildTotalModules(storage, id, totalModules) {
+	storage.set({ build: { [id]: { totalModules } } });
+}
+
+//#endregion
+//#region src/utils/terminal.ts
+/**
+* Based on https://github.com/sindresorhus/log-update/blob/master/index.js
+* Based on https://github.com/unjs/webpackbar
+*/
+function eraseLines(count) {
+	let clear = "";
+	for (let i = 0; i < count; i++) clear += `\u001B[2K` + (i < count - 1 ? `\u001B[1A` : "");
+	if (count) clear += `\u001B[G`;
+	return clear;
+}
+function ellipsisLeft(value, maxLength) {
+	if (value.length <= maxLength - 3) return value;
+	return `...${value.slice(value.length - maxLength - 1)}`;
+}
+const originalWrite = Symbol("original-write");
+var StreamManager = class {
+	prevLineCount;
+	listening;
+	extraLines;
+	_streams;
+	constructor() {
+		this.prevLineCount = 0;
+		this.listening = false;
+		this.extraLines = "";
+		this._onData = this._onData.bind(this);
+		this._streams = [process.stdout, process.stderr];
+	}
+	render(lines) {
+		this.listen();
+		const wrappedLines = wrapAnsi(lines, this.columns, {
+			trim: false,
+			hard: true,
+			wordWrap: false
+		});
+		const data = eraseLines(this.prevLineCount) + wrappedLines + "\n" + this.extraLines;
+		this.write(data);
+		this.prevLineCount = data.split("\n").length;
+	}
+	get columns() {
+		return (process.stderr.columns || 80) - 2;
+	}
+	write(data) {
+		const stream = process.stderr;
+		if (stream.write[originalWrite]) stream.write[originalWrite].call(stream, data, "utf8");
+		else stream.write(data, "utf8");
+	}
+	clear() {
+		this.done();
+		this.write(eraseLines(this.prevLineCount));
+	}
+	done() {
+		this.stopListen();
+		this.prevLineCount = 0;
+		this.extraLines = "";
+	}
+	_onData(data) {
+		const lines = String(data).split("\n").length - 1;
+		if (lines > 0) {
+			this.prevLineCount += lines;
+			this.extraLines += data;
+		}
+	}
+	listen() {
+		if (this.listening) return;
+		for (const stream of this._streams) {
+			if (stream.write[originalWrite]) continue;
+			const write = (data, ...args) => {
+				if (!stream.write[originalWrite]) return stream.write(data, ...args);
+				this._onData(data);
+				return stream.write[originalWrite].call(stream, data, ...args);
+			};
+			write[originalWrite] = stream.write;
+			stream.write = write;
+		}
+		this.listening = true;
+	}
+	stopListen() {
+		for (const stream of this._streams) if (stream.write[originalWrite]) stream.write = stream.write[originalWrite];
+		this.listening = false;
+	}
+};
+
+//#endregion
+//#region src/common/progress-bar.ts
+const BAR_LENGTH = 25;
+const BLOCK_CHAR = "█";
+var ProgressBar = class {
+	columns = (process.stderr.columns || 80) - 2;
+	state = null;
+	current = 0;
+	total = 0;
+	label;
+	stale = false;
+	done = false;
+	constructor(options) {
+		this.total = options.total;
+		this.label = options.label;
+	}
+	setCurrent(current) {
+		this.current = current;
+		this.stale = true;
+		return this;
+	}
+	setTotal(total) {
+		this.total = total;
+		this.stale = true;
+		return this;
+	}
+	start() {
+		this.stale = true;
+		this.done = false;
+	}
+	end() {
+		this.done = true;
+	}
+	update(state) {
+		this.state = state;
+		this.stale = true;
+		return this;
+	}
+	render() {
+		const { state, label, current, total } = this;
+		const unknownTotal = total === 0;
+		const progress = unknownTotal ? 0 : current / total * 100;
+		let line1 = "";
+		let line2 = "";
+		if (state && "duration" in state) {
+			const icon = state.hasErrors ? chalk.red("✘") : chalk.green("✔");
+			const durationInSeconds = (state.duration / 1e3).toFixed(2);
+			line1 = `${icon} Build completed ${chalk.gray(label)}`;
+			line2 = chalk.grey(`  Built in ${durationInSeconds}s (${current}/${total} modules)`);
+		} else {
+			const width = unknownTotal ? 0 : progress * (BAR_LENGTH / 100);
+			const bg = chalk.white(BLOCK_CHAR);
+			const fg = chalk.cyan(BLOCK_CHAR);
+			const bar = range(BAR_LENGTH).map((n) => n < width ? fg : bg).join("");
+			const progressLabel = unknownTotal ? chalk.gray("(calculating...)") : `(${progress.toFixed(2)}%)`;
+			const moduleCountLabel = unknownTotal ? `${current} modules` : `${current}/${total} modules`;
+			line1 = [
+				chalk.cyan("●"),
+				bar,
+				progressLabel,
+				chalk.gray(moduleCountLabel),
+				chalk.gray(label)
+			].join(" ");
+			line2 = state?.id ? "  " + chalk.grey(ellipsisLeft(state?.id, this.columns - 10)) : "";
+		}
+		this.stale = false;
+		return `${line1}\n${line2}`;
+	}
+};
+var ProgressBarRenderer = class ProgressBarRenderer {
+	static instance = null;
+	streamManager = new StreamManager();
+	progressBars = /* @__PURE__ */ new Map();
+	throttledRender;
+	static getInstance() {
+		if (!ProgressBarRenderer.instance) ProgressBarRenderer.instance = new ProgressBarRenderer();
+		return ProgressBarRenderer.instance;
+	}
+	constructor() {
+		this.throttledRender = throttle(this._render.bind(this), 50);
+	}
+	_render() {
+		const renderedLines = Array.from(this.progressBars.values().filter((progressBar$1) => progressBar$1.stale).map((progressBar$1) => progressBar$1.render()));
+		if (renderedLines.length > 0) this.streamManager.render(renderedLines.join("\n\n"));
+	}
+	register(key, options) {
+		const progressBar$1 = this.progressBars.get(key);
+		if (progressBar$1 == null) {
+			const newProgressBar = new ProgressBar(options);
+			this.progressBars.set(key, newProgressBar);
+			return newProgressBar;
+		}
+		return progressBar$1;
+	}
+	start() {
+		console.log();
+		this.streamManager.listen();
+		this._render();
+	}
+	render() {
+		this.throttledRender();
+	}
+	release() {
+		if (this.progressBars.values().every((progressBar$1) => progressBar$1.done)) {
+			this._render();
+			this.streamManager.done();
+			console.log();
+		}
+	}
+	clear() {
+		this.streamManager.clear();
+	}
+};
+
+//#endregion
+//#region src/common/status-presets.ts
+var ProgressFlags = /* @__PURE__ */ function(ProgressFlags$1) {
+	ProgressFlags$1[ProgressFlags$1["NONE"] = 0] = "NONE";
+	ProgressFlags$1[ProgressFlags$1["BUILD_IN_PROGRESS"] = 1] = "BUILD_IN_PROGRESS";
+	ProgressFlags$1[ProgressFlags$1["WATCH_CHANGE"] = 2] = "WATCH_CHANGE";
+	return ProgressFlags$1;
+}(ProgressFlags || {});
+function progressBar(reporter, context, label) {
+	let flags = ProgressFlags.NONE;
+	const initialTotalModules = getBuildTotalModules(context.storage, context.id);
+	const progressBarRenderer = ProgressBarRenderer.getInstance();
+	const progressBar$1 = progressBarRenderer.register(context.id, {
+		label,
+		total: initialTotalModules
+	});
+	const renderProgress = (id, totalModules, transformedModules) => {
+		if (totalModules != null) progressBar$1.setTotal(totalModules);
+		progressBar$1.setCurrent(transformedModules).update({ id });
+		progressBarRenderer.render();
+	};
+	return withReporter(reporter, {
+		initialTotalModules,
+		onStart() {
+			flags = ProgressFlags.BUILD_IN_PROGRESS;
+			progressBar$1.start();
+			progressBarRenderer.start();
+		},
+		onEnd({ error, duration, totalModules }) {
+			flags = ProgressFlags.NONE;
+			progressBar$1.setTotal(totalModules).update({
+				duration,
+				hasErrors: Boolean(error)
+			}).end();
+			progressBarRenderer.release();
+			setBuildTotalModules(context.storage, context.id, totalModules);
+		},
+		onTransform({ id, totalModules, transformedModules }) {
+			switch (true) {
+				case Boolean(flags & ProgressFlags.BUILD_IN_PROGRESS):
+					renderProgress(id, totalModules, transformedModules);
+					break;
+				case Boolean(flags & ProgressFlags.WATCH_CHANGE):
+					logger.debug("Transformed changed file", { id });
+					break;
+			}
+		},
+		onWatchChange() {
+			flags = flags | ProgressFlags.WATCH_CHANGE;
+		}
+	});
+}
+function compat(reporter) {
+	return withReporter(reporter, {
+		onStart() {
+			logger.info("Build started...");
+		},
+		onEnd({ totalModules, duration }) {
+			const time = chalk.blue(`${duration.toFixed(2)}ms`);
+			const modules = chalk.blue(`(${totalModules} modules)`);
+			logger.info(`Build finished in ${time} ${modules}`);
+		}
+	});
+}
+function withReporter(reporter, statusPluginOptions) {
+	return {
+		...statusPluginOptions,
+		onStart() {
+			reporter.update({ type: "bundle_build_started" });
+			statusPluginOptions.onStart?.();
+		},
+		onEnd(result) {
+			if (result.error) reporter.update({
+				type: "bundle_build_failed",
+				error: result.error
+			});
+			else reporter.update({ type: "bundle_build_done" });
+			statusPluginOptions.onEnd?.(result);
+		},
+		onTransform(result) {
+			reporter.update({
+				type: "transform",
+				...result
+			});
+			statusPluginOptions.onTransform?.(result);
+		},
+		onWatchChange(id) {
+			reporter.update({
+				type: "watch_change",
+				id
+			});
+			statusPluginOptions.onWatchChange?.(id);
+		}
+	};
+}
+const statusPresets = {
+	progressBar,
+	compat
+};
+
+//#endregion
+//#region src/internal/react-native.ts
+function getInitializeCorePath(basePath) {
+	return __require.resolve("react-native/Libraries/Core/InitializeCore", { paths: [basePath] });
+}
+function getPolyfillScriptPaths(reactNativePath) {
+	const scriptPath = path.join(reactNativePath, "rn-get-polyfills");
+	return __require(scriptPath)();
+}
+function getGlobalVariables(dev$1, mode) {
+	return [
+		`var __BUNDLE_START_TIME__=globalThis.nativePerformanceNow?nativePerformanceNow():Date.now();`,
+		`var __DEV__=${dev$1};`,
+		`var ${GLOBAL_IDENTIFIER}=typeof globalThis!=='undefined'?globalThis:typeof global !== 'undefined'?global:typeof window!=='undefined'?window:this;`,
+		`var process=globalThis.process||{};process.env=process.env||{};process.env.NODE_ENV=process.env.NODE_ENV||"${dev$1 ? "development" : "production"}";`,
+		dev$1 && mode === "serve" ? `var $RefreshReg$ = () => {};` : null,
+		dev$1 && mode === "serve" ? `var $RefreshSig$ = () => (v) => v;` : null
+	].filter(isNotNil);
+}
+
+//#endregion
+//#region src/common/transformer.ts
+function stripFlowSyntax(code, id) {
+	const typeRemoved = flowRemoveTypes(code, {
+		all: true,
+		removeEmptyImports: true
+	});
+	const generated = generate(hermesParser.parse(typeRemoved.toString(), {
+		flow: "all",
+		babel: true
+	}), {
+		sourceMaps: true,
+		sourceFileName: path.basename(id)
+	});
+	return {
+		code: generated.code,
+		map: generated.map
+	};
+}
+function blockScoping(code, id, dev$1, UNSTABLE_enableSourceMap = false) {
+	return swc.transformSync(code, {
+		filename: path.basename(id),
+		configFile: false,
+		swcrc: false,
+		sourceMaps: UNSTABLE_enableSourceMap,
+		jsc: {
+			target: "es5",
+			parser: {
+				syntax: "typescript",
+				tsx: true
+			},
+			keepClassNames: true,
+			loose: false,
+			transform: { react: {
+				runtime: "automatic",
+				development: dev$1
+			} },
+			assumptions: {
+				setPublicClassFields: true,
+				privateFieldsAsProperties: true
+			}
+		},
+		isModule: true
+	});
+}
+
+//#endregion
+//#region src/core/assets.ts
+/**
+* **NOTE**: Type definitions are ported from `metro` implementation.
+*
+* @see https://github.com/facebook/metro/blob/0.81.x/packages/metro/src/Assets.js
+*/
+var assets_exports = /* @__PURE__ */ __export({
+	copyAssetsToDestination: () => copyAssetsToDestination,
+	getAssetPriority: () => getAssetPriority,
+	getSuffixedPath: () => getSuffixedPath,
+	platformSuffixPattern: () => platformSuffixPattern,
+	resolveAssetPath: () => resolveAssetPath,
+	resolveScaledAssets: () => resolveScaledAssets,
+	stripSuffix: () => stripSuffix
+});
+const SCALE_PATTERN = "@(\\d+\\.?\\d*)x";
+/**
+* key: platform,
+* value: allowed scales
+*
+* @see https://github.com/facebook/react-native/blob/0.83-stable/packages/community-cli-plugin/src/commands/bundle/filterPlatformAssetScales.js#L11
+*/
+const ALLOW_SCALES = { ios: [
+	1,
+	2,
+	3
+] };
+/**
+* @see https://developer.android.com/training/multiscreen/screendensities#TaskProvideAltBmp
+*/
+const ANDROID_ASSET_QUALIFIER = {
+	.75: "ldpi",
+	1: "mdpi",
+	1.5: "hdpi",
+	2: "xhdpi",
+	3: "xxhdpi",
+	4: "xxxhdpi"
+};
+async function resolveScaledAssets(options) {
+	const { projectRoot, assetPath, platform, preferNativePlatform } = options;
+	const context = {
+		platform,
+		preferNativePlatform
+	};
+	const extension = path.extname(assetPath);
+	const relativePath = path.relative(projectRoot, assetPath);
+	const dirname = path.dirname(assetPath);
+	const files = fs.readdirSync(dirname);
+	const stripedBasename = stripSuffix(assetPath, context);
+	const suffixPattern = platformSuffixPattern(context);
+	const assetRegExp = /* @__PURE__ */ new RegExp(`${stripedBasename}(${SCALE_PATTERN})?(?:${suffixPattern})?${extension}$`);
+	const scaledAssets = {};
+	for (const file of files.sort((a, b) => getAssetPriority(b, context) - getAssetPriority(a, context))) {
+		const match = assetRegExp.exec(file);
+		if (match) {
+			const [, , scale = "1"] = match;
+			if (scaledAssets[scale]) continue;
+			scaledAssets[scale] = file;
+		}
+	}
+	if (!(Object.keys(scaledAssets).length && scaledAssets[1])) throw new Error(`cannot resolve base asset of ${assetPath}`);
+	const imageData = fs.readFileSync(assetPath);
+	const dimensions = imageSize(imageData);
+	const filteredScaledAssets = Object.entries(scaledAssets).map(([scale, file]) => ({
+		scale: parseFloat(scale),
+		file
+	})).filter(({ scale }) => ALLOW_SCALES[platform]?.includes(scale) ?? true).reduce((acc, { scale, file }) => {
+		acc.files.push(file);
+		acc.scales.push(scale);
+		return acc;
+	}, {
+		scales: [],
+		files: []
+	});
+	return {
+		__packager_asset: true,
+		id: assetPath,
+		name: stripedBasename.replace(extension, ""),
+		type: extension.substring(1),
+		width: dimensions.width,
+		height: dimensions.height,
+		files: filteredScaledAssets.files,
+		scales: filteredScaledAssets.scales,
+		fileSystemLocation: path.dirname(assetPath),
+		httpServerLocation: path.join(DEV_SERVER_ASSET_PATH, path.dirname(relativePath)),
+		hash: md5(imageData)
+	};
+}
+function platformSuffixPattern(context) {
+	return [context.platform, context.preferNativePlatform ? "native" : null].filter(isNotNil).map((platform) => `.${platform}`).join("|");
+}
+function stripSuffix(assetPath, context) {
+	const basename = path.basename(assetPath);
+	const extension = path.extname(assetPath);
+	const suffixPattern = platformSuffixPattern(context);
+	return basename.replace(/* @__PURE__ */ new RegExp(`(${SCALE_PATTERN})?(?:${suffixPattern})?${extension}$`), "");
+}
+function getAssetPriority(assetPath, context) {
+	const suffixPattern = platformSuffixPattern(context);
+	if ((/* @__PURE__ */ new RegExp(`${SCALE_PATTERN}(?:${suffixPattern})`)).test(assetPath)) return 3;
+	else if ((/* @__PURE__ */ new RegExp(`(?:${suffixPattern})`)).test(assetPath)) return 2;
+	else if ((/* @__PURE__ */ new RegExp(`${SCALE_PATTERN}`)).test(assetPath)) return 1;
+	return 0;
+}
+function addSuffix(assetPath, context, options) {
+	const extension = path.extname(assetPath);
+	return stripSuffix(assetPath, context).concat(options?.scale ? `@${options.scale}x` : "").concat(options?.platform ? `.${options.platform}${extension}` : extension);
+}
+/**
+* add suffix to asset path
+*
+* ```js
+* // assetPath input
+* '/path/to/assets/image.png'
+*
+* // `platform` suffixed
+* '/path/to/assets/image.android.png'
+*
+* // `scale` suffixed
+* '/path/to/assets/image@1x.png'
+*
+* // both `platform` and `scale` suffixed
+* '/path/to/assets/image@1x.android.png'
+* ```
+*/
+function getSuffixedPath(assetPath, context, options) {
+	const suffixedBasename = addSuffix(assetPath, context, {
+		scale: options?.scale,
+		platform: options?.platform
+	});
+	const dirname = path.dirname(assetPath);
+	return path.join(dirname, suffixedBasename);
+}
+function resolveAssetPath(assetPath, context, scale) {
+	const suffixedPaths = [
+		getSuffixedPath(assetPath, context, {
+			scale,
+			platform: context.platform
+		}),
+		context.preferNativePlatform ? getSuffixedPath(assetPath, context, {
+			scale,
+			platform: "native"
+		}) : null,
+		getSuffixedPath(assetPath, context, { scale })
+	].filter(isNotNil);
+	/**
+	* When scale is 1, filename can be suffixed or non-suffixed(`image.png`).
+	*
+	* - Suffixed
+	*   - `filename.<platform>@<scale>x.ext`
+	*   - `filename.<platform>.ext`
+	*   - `filename@<scale>x.ext`
+	* - Non suffixed
+	*   - `filename.ext`
+	*
+	* 1. Resolve non-suffixed asset first.
+	* 2. If file is not exist, resolve suffixed path.
+	*/
+	if (scale === 1) try {
+		fs.statSync(assetPath);
+		return assetPath;
+	} catch {}
+	for (const suffixedPath of suffixedPaths) try {
+		fs.statSync(suffixedPath);
+		return suffixedPath;
+	} catch {}
+	throw new Error(`cannot resolve asset path for ${assetPath}`);
+}
+/**
+* @see https://github.com/facebook/react-native/blob/0.83-stable/packages/community-cli-plugin/src/commands/bundle/assetPathUtils.js
+*/
+async function copyAssetsToDestination(options) {
+	const { assets, platform, assetsDir, preferNativePlatform } = options;
+	const context = {
+		platform,
+		preferNativePlatform
+	};
+	const mkdirWithAssertPath = (targetPath) => {
+		const dirname = path.dirname(targetPath);
+		fs.mkdirSync(dirname, { recursive: true });
+	};
+	return Promise.all(assets.map((asset) => {
+		return Promise.all(asset.scales.map(async (scale) => {
+			if (platform !== "android") {
+				const from$1 = resolveAssetPath(asset.id, context, scale);
+				const to$1 = path.join(assetsDir, getIosAssetDestinationPath(asset, scale));
+				mkdirWithAssertPath(to$1);
+				return fs.copyFileSync(from$1, to$1);
+			}
+			const from = resolveAssetPath(asset.id, context, scale);
+			const to = path.join(assetsDir, getAndroidAssetDestinationPath(asset, scale));
+			mkdirWithAssertPath(to);
+			fs.copyFileSync(from, to);
+		})).then(() => void 0);
+	})).then(() => void 0);
+}
+/**
+* @see https://github.com/facebook/react-native/blob/0.83-stable/packages/community-cli-plugin/src/commands/bundle/getAssetDestPathIOS.js
+*/
+function getIosAssetDestinationPath(asset, scale) {
+	const suffix = scale === 1 ? "" : `@${scale}x`;
+	const fileName = `${asset.name + suffix}.${asset.type}`;
+	const devServerBasePath = asset.httpServerLocation.at(0) === "/" ? asset.httpServerLocation.slice(1) : asset.httpServerLocation;
+	return path.join(devServerBasePath.replace(/\.\.\//g, "_"), fileName);
+}
+function getAndroidAssetDestinationPath(asset, scale) {
+	const assetQualifierSuffix = ANDROID_ASSET_QUALIFIER[scale];
+	const assetName = `${asset.httpServerLocation.at(0) === "/" ? asset.httpServerLocation.slice(1) : asset.httpServerLocation}/${asset.name}`.toLowerCase().replace(/\//g, "_").replace(/(?:[^a-z0-9_])/g, "").replace(/^assets_/, "");
+	if (!assetQualifierSuffix) throw new Error(`invalid asset qualifier: ${asset.id}`);
+	return path.join(isDrawable(asset.type) ? `drawable-${assetQualifierSuffix}` : "raw", `${assetName}.${asset.type}`);
+}
+/**
+* @see https://developer.android.com/guide/topics/resources/drawable-resource
+*/
+function isDrawable(type) {
+	return [
+		"gif",
+		"heic",
+		"heif",
+		"jpeg",
+		"jpg",
+		"ktx",
+		"png",
+		"webp",
+		"xml"
+	].includes(type);
+}
+
+//#endregion
+//#region src/core/plugins/utils/index.ts
+const CACHE_HIT = Symbol("CACHE_HIT");
+/**
+* @internal
+*/
+function withPersistCache(plugins, options) {
+	const { enabled, sourceExtensions, context } = options;
+	if (!enabled) return plugins;
+	const includePattern = /* @__PURE__ */ new RegExp(`\\.(?:${sourceExtensions.join("|")})$`);
+	const excludePattern = /@oxc-project\+runtime/;
+	let cacheHits = 0;
+	const startMarker = {
+		name: "rollipop:persist-cache-start",
+		buildStart() {
+			cacheHits = 0;
+		},
+		buildEnd() {
+			this.debug(`Cache hits: ${cacheHits}`);
+		},
+		load: {
+			order: "pre",
+			filter: { id: {
+				include: includePattern,
+				exclude: excludePattern
+			} },
+			handler(id) {
+				const key = getCacheKey(id, context.id);
+				const cache = context.cache.get(key);
+				if (cache != null) {
+					cacheHits++;
+					return {
+						code: cache,
+						moduleType: "tsx",
+						meta: { [CACHE_HIT]: true }
+					};
+				}
+			}
+		}
+	};
+	const endMarker = {
+		name: "rollipop:persist-cache-end",
+		transform: {
+			order: "post",
+			filter: { id: {
+				include: includePattern,
+				exclude: excludePattern
+			} },
+			handler(code, id) {
+				const moduleInfo = this.getModuleInfo(id);
+				if (!(moduleInfo && isCacheHit(moduleInfo.meta))) {
+					const key = getCacheKey(id, context.id);
+					context.cache.set(key, code);
+				}
+			}
+		}
+	};
+	return [
+		startMarker,
+		...plugins,
+		endMarker
+	];
+}
+function isCacheHit(meta) {
+	return CACHE_HIT in meta;
+}
+function getCacheKey(id, buildHash) {
+	const { mtimeMs } = fs.statSync(id);
+	return xxhash(`${id}${buildHash}${mtimeMs}`);
+}
+/**
+* Enhance a plugin to cache the result. (transform hook only)
+*/
+function cacheable(plugin) {
+	const originalTransform = plugin.transform;
+	if (typeof originalTransform === "function") plugin.transform = function(code, id, meta) {
+		const moduleInfo = this.getModuleInfo(id);
+		if (moduleInfo && isCacheHit(moduleInfo.meta)) return;
+		return originalTransform.call(this, code, id, meta);
+	};
+	if (typeof originalTransform === "object") plugin.transform = {
+		...originalTransform,
+		handler(code, id, meta) {
+			const moduleInfo = this.getModuleInfo(id);
+			if (moduleInfo && isCacheHit(moduleInfo.meta)) return;
+			return originalTransform.handler.call(this, code, id, meta);
+		}
+	};
+	return plugin;
+}
+const PluginUtils = Object.freeze({ cacheable });
+
+//#endregion
+//#region src/core/plugins/react-native-plugin.ts
+var TransformFlags = /* @__PURE__ */ function(TransformFlags$1) {
+	TransformFlags$1[TransformFlags$1["SKIP_FLOW"] = 1] = "SKIP_FLOW";
+	TransformFlags$1[TransformFlags$1["NONE"] = 0] = "NONE";
+	return TransformFlags$1;
+}(TransformFlags || {});
+function reactNativePlugin(config, options) {
+	const { mode, flowFilter, codegenFilter, assetsDir, assetExtensions, assetRegistryPath } = options;
+	const assetExtensionRegex = /* @__PURE__ */ new RegExp(`\\.(?:${assetExtensions.join("|")})$`);
+	const codegenPlugin = {
+		name: "rollipop:react-native-codegen",
+		transform: {
+			order: "pre",
+			filter: codegenFilter,
+			handler(code, id) {
+				this.debug(`Transforming codegen native component ${id}`);
+				const result = babel.transformSync(code, {
+					filename: path$1.basename(id),
+					babelrc: false,
+					configFile: false,
+					sourceMaps: true,
+					parserOpts: { flow: "all" },
+					plugins: [
+						__require.resolve("babel-plugin-syntax-hermes-parser"),
+						__require.resolve("@babel/plugin-transform-flow-strip-types"),
+						[__require.resolve("@babel/plugin-syntax-typescript"), {
+							isTSX: id.endsWith("x"),
+							dts: false
+						}],
+						__require.resolve("@react-native/babel-plugin-codegen")
+					]
+				});
+				if (result?.code == null) throw new Error(`Failed to transform codegen native component: ${id}`);
+				return {
+					code: result.code,
+					map: result.map,
+					meta: setFlag(this, id, TransformFlags.SKIP_FLOW)
+				};
+			}
+		}
+	};
+	const stripFlowSyntaxPlugin = {
+		name: "rollipop:react-native-strip-flow-syntax",
+		transform: {
+			order: "pre",
+			filter: flowFilter,
+			handler(code, id) {
+				if (getFlags(this, id) & TransformFlags.SKIP_FLOW) return;
+				const result = stripFlowSyntax(code, id);
+				return {
+					code: result.code,
+					map: result.map,
+					moduleType: "tsx"
+				};
+			}
+		}
+	};
+	const blockScopingPlugin = {
+		name: "rollipop:react-native-block-scoping",
+		transform: {
+			order: "post",
+			handler(code, id) {
+				const result = blockScoping(code, id, options.dev);
+				return {
+					code: result.code,
+					map: result.map
+				};
+			}
+		}
+	};
+	const assets = [];
+	const assetPlugin = {
+		name: "rollipop:react-native-asset",
+		load: {
+			filter: { id: assetExtensionRegex },
+			async handler(id) {
+				this.debug(`Asset ${id} found`);
+				const assetData = await resolveScaledAssets({
+					projectRoot: config.root,
+					assetPath: id,
+					platform: options.platform,
+					preferNativePlatform: config.resolver.preferNativePlatform
+				});
+				assets.push(assetData);
+				return { code: `
+          module.exports = require('${assetRegistryPath}').registerAsset(${JSON.stringify(assetData)});
+          ` };
+			}
+		},
+		buildStart() {
+			assets.length = 0;
+		},
+		async buildEnd(error) {
+			if (error || mode === "serve") return;
+			if (assetsDir != null) {
+				this.debug(`Copying assets to ${assetsDir}`);
+				await copyAssetsToDestination({
+					assets,
+					assetsDir,
+					platform: options.platform,
+					preferNativePlatform: config.resolver.preferNativePlatform
+				});
+			}
+		}
+	};
+	const hmrClientImplement = fs.readFileSync(__require.resolve("@rollipop/core/hmr-client"), "utf-8");
+	const hmrClientPath = __require.resolve(process.env.ROLLIPOP_HMR_CLIENT_PATH ?? DEFAULT_HMR_CLIENT_PATH, { paths: [config.root] });
+	const replaceHMRClientPlugin = {
+		name: "rollipop:react-native-replace-hmr-client",
+		resolveId: {
+			filter: { id: /\/HMRClient\.js$/ },
+			async handler(id, importer) {
+				const resolvedId = await this.resolve(id, importer, { skipSelf: true });
+				if (resolvedId?.id === hmrClientPath) await this.load({ id: resolvedId.id });
+			}
+		},
+		load: {
+			filter: { id: exactRegex(hmrClientPath) },
+			handler(id) {
+				this.debug(`Replacing HMR client: ${id}`);
+				return hmrClientImplement;
+			}
+		}
+	};
+	const devServerPlugins = mode === "serve" ? [replaceHMRClientPlugin] : null;
+	return [
+		PluginUtils.cacheable(codegenPlugin),
+		PluginUtils.cacheable(stripFlowSyntaxPlugin),
+		PluginUtils.cacheable(blockScopingPlugin),
+		assetPlugin,
+		...devServerPlugins ?? []
+	];
+}
+function setFlag(context, id, flag) {
+	const moduleInfo = context.getModuleInfo(id);
+	if (moduleInfo && hasFlags(moduleInfo.meta)) {
+		moduleInfo.meta.flags |= flag;
+		return moduleInfo.meta;
+	} else return { meta: flag };
+}
+function hasFlags(meta) {
+	return "flags" in meta;
+}
+function getFlags(context, id) {
+	const moduleInfo = context.getModuleInfo(id);
+	if (moduleInfo && hasFlags(moduleInfo.meta)) return moduleInfo.meta.flags;
+	return TransformFlags.NONE;
+}
+
+//#endregion
+//#region src/core/plugins/react-refresh-plugin.ts
+const DEFAULT_INCLUDE_REGEX = /\.[tj]sx?(?:$|\?)/;
+const DEFAULT_EXCLUDE_REGEX = /\/node_modules\//;
+const HAS_REFRESH_REGEX = /\$RefreshReg\$\(/;
+const ONLY_REACT_COMPONENT_REGEX = /extends\s+(?:React\.)?(?:Pure)?Component/;
+function reactRefreshPlugin(options) {
+	const { include = DEFAULT_INCLUDE_REGEX, exclude = DEFAULT_EXCLUDE_REGEX } = options ?? {};
+	return {
+		name: "rollipop:react-refresh",
+		transform: {
+			filter: { id: {
+				include,
+				exclude
+			} },
+			handler(code, id, meta) {
+				const { magicString } = meta;
+				invariant(magicString != null, "magicString is not available");
+				const { code: transformedCode } = transformSync(id, code, {
+					sourcemap: true,
+					jsx: {
+						runtime: "automatic",
+						development: true,
+						refresh: {
+							refreshReg: `${GLOBAL_IDENTIFIER}.$RefreshReg$`,
+							refreshSig: `${GLOBAL_IDENTIFIER}.$RefreshSig$`
+						}
+					}
+				});
+				magicString.overwrite(0, magicString.length(), transformedCode);
+				applyRefreshWrapper(magicString, {
+					id,
+					hasRefresh: HAS_REFRESH_REGEX.test(transformedCode),
+					onlyReactComponent: ONLY_REACT_COMPONENT_REGEX.test(transformedCode)
+				});
+				return { code: magicString };
+			}
+		}
+	};
+}
+function applyRefreshWrapper(s, options) {
+	const { id, hasRefresh, onlyReactComponent } = options;
+	if (!(hasRefresh || onlyReactComponent)) return;
+	if (hasRefresh) s.prepend(`
+var __prev$RefreshReg$ = global.$RefreshReg$;
+var __prev$RefreshSig$ = global.$RefreshSig$;
+global.$RefreshReg$ = function(type, id) { return __ReactRefresh.register(type, ${JSON.stringify(id)} + ' ' + id) }
+global.$RefreshSig$ = function() { return __ReactRefresh.createSignatureFunctionForTransform(); }
+`);
+	s.append(`
+if (import.meta.hot) {
+  if (import.meta.hot.refresh == null) throw new Error('react-refresh runtime is not initialized');
+  import.meta.hot.accept((nextExports) => {
+    if (!nextExports) return;
+    if (import.meta.hot.refreshUtils.isReactRefreshBoundary(nextExports)) {
+      import.meta.hot.refresh.performReactRefresh();
+    }
+  });
+}`);
+	if (hasRefresh) s.append(`
+global.$RefreshReg$ = __prev$RefreshReg$;
+global.$RefreshSig$ = __prev$RefreshSig$;
+`);
+}
+
+//#endregion
+//#region src/core/plugins/shim.ts
+function shim() {
+	return { name: `rollipop:shim-${shim.index++}` };
+}
+shim.index = 0;
+
+//#endregion
+//#region src/core/plugins/prelude-plugin.ts
+const IS_ENTRY = Symbol("IS_ENTRY");
+function preludePlugin(options) {
+	if (options.modulePaths.length === 0) return shim();
+	const preludeImportStatements = options.modulePaths.map((modulePath) => `import '${modulePath}';`).join("\n");
+	let processed = false;
+	return {
+		name: "rollipop:prelude",
+		buildStart() {
+			processed = false;
+		},
+		resolveId: { handler: (source, _importer, extraOptions) => {
+			if (extraOptions.isEntry) return {
+				id: source,
+				meta: { [IS_ENTRY]: true }
+			};
+		} },
+		load: { handler(id) {
+			if (processed) return;
+			const moduleInfo = this.getModuleInfo(id);
+			if (moduleInfo && isEntry(moduleInfo.meta)) {
+				this.debug(`Prelude plugin found entry ${id}`);
+				const modifiedSource = [preludeImportStatements, fs.readFileSync(id, "utf-8")].join("\n");
+				processed = true;
+				return modifiedSource;
+			}
+		} }
+	};
+}
+function isEntry(meta) {
+	return IS_ENTRY in meta;
+}
+
+//#endregion
+//#region src/core/plugins/status-plugin.ts
+function statusPlugin(options) {
+	let totalModules = options?.initialTotalModules ?? 0;
+	let startedAt = 0;
+	let transformedModules = 0;
+	let unknownTotalModules = totalModules === 0;
+	return {
+		name: "rollipop:status",
+		buildStart() {
+			startedAt = performance.now();
+			transformedModules = 0;
+			options?.onStart?.();
+		},
+		buildEnd(error) {
+			totalModules = transformedModules;
+			unknownTotalModules = false;
+			options?.onEnd?.({
+				error,
+				totalModules,
+				duration: performance.now() - startedAt
+			});
+		},
+		resolveId: {
+			order: "post",
+			handler(id) {
+				options?.onResolve?.(id);
+			}
+		},
+		transform: {
+			order: "post",
+			handler(_code, id) {
+				++transformedModules;
+				if (!unknownTotalModules && totalModules < transformedModules) totalModules = transformedModules;
+				options?.onTransform?.({
+					id,
+					totalModules: unknownTotalModules ? void 0 : totalModules,
+					transformedModules
+				});
+			}
+		},
+		watchChange(id) {
+			options?.onWatchChange?.(id);
+		}
+	};
+}
+
+//#endregion
+//#region src/core/plugins/json-plugin.ts
+function jsonPlugin() {
+	return {
+		name: "rollipop:json",
+		load: {
+			filter: { id: /\.json$/ },
+			handler(id) {
+				const rawJson = fs.readFileSync(id, "utf-8");
+				return {
+					code: jsonToEsm(JSON.parse(rawJson)),
+					moduleType: "js"
+				};
+			}
+		}
+	};
+}
+function jsonToEsm(data) {
+	const declarations = [];
+	const exports = [];
+	const exportDefaultMappings = [];
+	Object.entries(data).forEach(([key, value], index) => {
+		const identifier = `_${index}`;
+		declarations.push(`const ${identifier} = ${JSON.stringify(value)};`);
+		exports.push(`export { ${identifier} as "${key}" };`);
+		exportDefaultMappings.push(`"${key}":${identifier}`);
+	});
+	return [
+		...declarations,
+		...exports,
+		`export default {${exportDefaultMappings.join(",")}};`
+	].join("\n");
+}
+
+//#endregion
+//#region src/core/plugins/svg-plugin.ts
+function svgPlugin(options) {
+	if (!options.enabled) return shim();
+	return {
+		name: "rollipop:svg",
+		load: {
+			filter: { id: /\.svg$/ },
+			async handler(id) {
+				return {
+					code: await transform(fs.readFileSync(id, "utf-8"), {
+						template: defaultTemplate,
+						plugins: [__require.resolve("@svgr/plugin-jsx")],
+						native: true
+					}, { filePath: id }),
+					moduleType: "jsx"
+				};
+			}
+		}
+	};
+}
+const SVG_COMPONENT_NAME = "SvgLogo";
+const defaultTemplate = (variables, { tpl }) => {
+	return tpl`${variables.imports};
+
+${variables.interfaces};
+
+const ${SVG_COMPONENT_NAME} = (${variables.props}) => (
+  ${variables.jsx}
+);
+
+export default ${SVG_COMPONENT_NAME};`;
+};
+
+//#endregion
+//#region src/core/plugins/index.ts
+var plugins_exports = /* @__PURE__ */ __export({
+	applyRefreshWrapper: () => applyRefreshWrapper,
+	json: () => jsonPlugin,
+	prelude: () => preludePlugin,
+	reactNative: () => reactNativePlugin,
+	reactRefresh: () => reactRefreshPlugin,
+	status: () => statusPlugin,
+	svg: () => svgPlugin
+});
+
+//#endregion
+//#region src/core/rolldown.ts
+const rolldownLogger = new Logger("rolldown");
+function resolveBuildOptions(buildOptions) {
+	return merge({
+		dev: true,
+		cache: true,
+		minify: false
+	}, buildOptions);
+}
+resolveRolldownOptions.cache = /* @__PURE__ */ new Map();
+async function resolveRolldownOptions(context, config, buildOptions) {
+	const cachedOptions = resolveRolldownOptions.cache.get(context.id);
+	if (cachedOptions != null) return cachedOptions;
+	const { platform, dev: dev$1, cache, minify } = resolveBuildOptions(buildOptions);
+	const { sourceExtensions, assetExtensions, preferNativePlatform, ...rolldownResolve } = config.resolver;
+	const { prelude: preludePaths, polyfills } = config.serializer;
+	const { flow, ...rolldownTransform } = config.transformer;
+	const { codegen, assetRegistryPath } = config.reactNative;
+	const resolvedSourceExtensions = config.transformer.svg ? [...sourceExtensions, "svg"] : sourceExtensions;
+	const resolvedAssetExtensions = config.transformer.svg ? assetExtensions.filter((extension) => extension !== "svg") : assetExtensions;
+	const mergedResolveOptions = merge({ extensions: getResolveExtensions({
+		sourceExtensions: resolvedSourceExtensions,
+		assetExtensions: resolvedAssetExtensions,
+		platform,
+		preferNativePlatform
+	}) }, rolldownResolve);
+	const mergedTransformOptions = merge({
+		target: "es2015",
+		jsx: {
+			runtime: "automatic",
+			development: dev$1
+		},
+		define: {
+			__DEV__: asLiteral(dev$1),
+			"process.env.NODE_ENV": asLiteral(nodeEnvironment(dev$1)),
+			global: asIdentifier(GLOBAL_IDENTIFIER)
+		},
+		typescript: { removeClassFieldsWithoutInitializer: true },
+		assumptions: { setPublicClassFields: true },
+		helpers: { mode: "Runtime" }
+	}, rolldownTransform);
+	const devServerPlugins = context.mode === "serve" ? [reactRefreshPlugin()] : [];
+	const statusPreset = config.terminal.status === "progress" ? statusPresets.progressBar(config.reporter, context, `[${platform}, ${buildOptions.dev ? "dev" : "prod"}]`) : statusPresets.compat(config.reporter);
+	const finalOptions = await applyDangerouslyOverrideOptionsFinalizer(config, {
+		cwd: config.root,
+		input: config.entry,
+		platform: "neutral",
+		treeshake: true,
+		resolve: mergedResolveOptions,
+		transform: mergedTransformOptions,
+		plugins: withPersistCache([
+			preludePlugin({ modulePaths: preludePaths }),
+			reactNativePlugin(config, {
+				dev: dev$1,
+				platform,
+				mode: context.mode,
+				codegenFilter: codegen.filter,
+				flowFilter: flow.filter,
+				assetsDir: buildOptions.assetsDir,
+				assetExtensions: resolvedAssetExtensions,
+				assetRegistryPath
+			}),
+			svgPlugin({ enabled: config.transformer.svg }),
+			jsonPlugin(),
+			statusPlugin(statusPreset),
+			...devServerPlugins ?? [],
+			...config.plugins ?? []
+		], {
+			enabled: cache,
+			context,
+			sourceExtensions
+		}),
+		checks: {
+			eval: false,
+			pluginTimings: false
+		},
+		logLevel: isDebugEnabled() ? "debug" : "info",
+		onLog(level, log) {
+			const { message, code } = log;
+			const logArgs = [code, message].filter(isNotNil);
+			switch (level) {
+				case "debug":
+					rolldownLogger.debug(...logArgs);
+					break;
+				case "info":
+					rolldownLogger.info(...logArgs);
+					break;
+				case "warn":
+					rolldownLogger.warn(...logArgs);
+					break;
+			}
+		}
+	}, {
+		postBanner: [...getGlobalVariables(dev$1, context.mode)].join("\n"),
+		intro: [...loadPolyfills(polyfills)].join("\n"),
+		file: buildOptions.outfile,
+		minify,
+		format: "iife",
+		keepNames: true,
+		sourcemap: true
+	});
+	resolveRolldownOptions.cache.set(context.id, finalOptions);
+	return finalOptions;
+}
+function getResolveExtensions({ platform, sourceExtensions, assetExtensions, preferNativePlatform }) {
+	const supportedExtensions = [...sourceExtensions, ...assetExtensions];
+	return [...[platform, preferNativePlatform ? "native" : null].filter(isNotNil).map((platform$1) => {
+		return supportedExtensions.map((extension) => `.${platform$1}.${extension}`);
+	}), ...supportedExtensions.map((extension) => `.${extension}`)].flat();
+}
+function loadPolyfills(polyfills) {
+	return polyfills.map((polyfill) => {
+		if (typeof polyfill === "string") return fs.readFileSync(polyfill, "utf-8");
+		const path$2 = "path" in polyfill ? polyfill.path : void 0;
+		const content = "code" in polyfill ? polyfill.code : fs.readFileSync(polyfill.path, "utf-8");
+		return polyfill.type === "iife" ? iife(content, path$2) : content;
+	});
+}
+async function applyDangerouslyOverrideOptionsFinalizer(config, inputOptions, outputOptions) {
+	if (typeof config.dangerously_overrideRolldownOptions === "function") return await config.dangerously_overrideRolldownOptions({
+		input: inputOptions,
+		output: outputOptions
+	});
+	return {
+		input: merge(inputOptions, config.dangerously_overrideRolldownOptions?.input ?? {}),
+		output: merge(outputOptions, config.dangerously_overrideRolldownOptions?.output ?? {})
+	};
+}
+function getOverrideOptionsForDevServer() {
+	return {
+		input: {
+			transform: { jsx: { development: true } },
+			experimental: {
+				devMode: { implement: fs.readFileSync(__require.resolve("@rollipop/core/hmr-runtime"), "utf-8") },
+				incrementalBuild: true,
+				strictExecutionOrder: true,
+				nativeMagicString: true
+			},
+			treeshake: false
+		},
+		output: { sourcemap: true }
+	};
+}
+
+//#endregion
+//#region src/core/bundler.ts
+var Bundler = class Bundler {
+	static async devEngine(config, buildOptions, devEngineOptions) {
+		const mode = "serve";
+		const resolvedBuildOptions = {
+			...buildOptions,
+			dev: true
+		};
+		const { input = {}, output = {} } = await resolveRolldownOptions({
+			...Bundler.createContext(mode, config, resolvedBuildOptions),
+			mode
+		}, config, resolvedBuildOptions);
+		const devServerOptions = getOverrideOptionsForDevServer();
+		return await dev(merge(input, devServerOptions.input), merge(output, devServerOptions.output), devEngineOptions);
+	}
+	static createId(config, buildOptions) {
+		return createId(config, buildOptions);
+	}
+	static createContext(mode, config, buildOptions) {
+		const id = `${mode}:${Bundler.createId(config, buildOptions)}`;
+		return {
+			id,
+			cache: new FileSystemCache(path.join(getCachePath(config.root), id)),
+			storage: FileStorage.getInstance(config.root)
+		};
+	}
+	constructor(config) {
+		this.config = config;
+		Logo.printOnce();
+	}
+	async build(buildOptions) {
+		const mode = "build";
+		const contextBase = Bundler.createContext(mode, this.config, buildOptions);
+		const { config } = this;
+		const { input, output } = await resolveRolldownOptions({
+			...contextBase,
+			mode
+		}, config, buildOptions);
+		const rolldownBuildOptions = {
+			...input,
+			output,
+			write: true
+		};
+		const chunk = (await rolldown.build(rolldownBuildOptions)).output[0];
+		invariant(chunk, "Bundled chunk is not found");
+		return chunk;
+	}
+};
+
+//#endregion
+//#region src/reporter.ts
+var TerminalReporter = class {
+	logger = new Logger("app");
+	update(event) {
+		if (event.type === "client_log") {
+			if (event.level === "group" || event.level === "groupCollapsed") {
+				this.logger.info(...event.data);
+				return;
+			} else if (event.level === "groupEnd") return;
+			this.logger[event.level](...event.data);
+		}
+	}
+};
+
+//#endregion
+//#region src/utils/node-resolve.ts
+function resolvePackagePath(basePath, packageName) {
+	let packagePath = null;
+	try {
+		packagePath = resolvePackagePathWithNodeRequire(basePath, packageName);
+		if (packagePath) return packagePath;
+	} catch {}
+	try {
+		packagePath = resolvePackagePathWithNodeRequire(basePath, packageName, "");
+		if (packagePath) return packagePath;
+	} catch {}
+	throw new Error(`Failed to resolve package path for '${packageName}'`);
+}
+function resolvePackagePathWithNodeRequire(basePath, packageName, lookupSubpath = "package.json") {
+	const lookupPath = lookupSubpath ? `/${lookupSubpath}` : "";
+	const resolvedPath = __require.resolve(`${packageName}${lookupPath}`, { paths: [basePath] });
+	const root = path.parse(resolvedPath).root;
+	let currentPath = path.dirname(resolvedPath);
+	while (currentPath !== root) {
+		if (fs.existsSync(path.join(currentPath, "package.json"))) return currentPath;
+		currentPath = path.dirname(currentPath);
+	}
+	return null;
+}
+
+//#endregion
+//#region src/config/defaults.ts
+function getDefaultConfig(basePath, context) {
+	const reactNativePath = resolvePackagePath(basePath, "react-native");
+	const isDevServer = context.command === "start";
+	return {
+		root: basePath,
+		entry: "index.js",
+		resolver: {
+			sourceExtensions: DEFAULT_SOURCE_EXTENSIONS,
+			assetExtensions: DEFAULT_ASSET_EXTENSIONS,
+			mainFields: DEFAULT_RESOLVER_MAIN_FIELDS,
+			conditionNames: DEFAULT_RESOLVER_CONDITION_NAMES,
+			preferNativePlatform: true
+		},
+		transformer: {
+			svg: true,
+			flow: { filter: {
+				id: /\.jsx?$/,
+				code: /@flow/
+			} }
+		},
+		serializer: {
+			prelude: [getInitializeCorePath(basePath)],
+			polyfills: [...getPolyfillScriptPaths(reactNativePath).map((path$2) => ({
+				type: "iife",
+				code: stripFlowSyntax(fs.readFileSync(path$2, "utf-8"), path$2).code
+			})), isDevServer ? __require.resolve("@rollipop/core/hmr-shims") : void 0].filter(isNotNil)
+		},
+		watcher: {
+			skipWrite: true,
+			useDebounce: true,
+			debounceDuration: 50
+		},
+		reactNative: {
+			codegen: { filter: { code: /codegenNativeComponent/ } },
+			assetRegistryPath: DEFAULT_ASSET_REGISTRY_PATH
+		},
+		terminal: { status: process.stderr.isTTY ? "progress" : "compat" },
+		reporter: new TerminalReporter()
+	};
+}
+
+//#endregion
+//#region src/config/define-config.ts
+function defineConfig(userConfig) {
+	return userConfig;
+}
+
+//#endregion
+//#region src/config/merge-config.ts
+function mergeConfig(baseConfig, overrideConfig) {
+	return mergeWith(baseConfig, overrideConfig, (target, source, key) => {
+		if (key === "reporter") return source.reporter ?? target.reporter;
+	});
+}
+
+//#endregion
+//#region src/config/load-config.ts
+const CONFIG_FILE_NAME = "rollipop";
+async function loadConfig(options = {}) {
+	const { cwd = process.cwd(), configFile, context = {} } = options;
+	const defaultConfig = getDefaultConfig(cwd, context);
+	const commonOptions = {
+		context: {
+			...context,
+			defaultConfig
+		},
+		rcFile: false
+	};
+	const { config: userConfig } = await c12.loadConfig(configFile ? {
+		configFile: path.resolve(cwd, configFile),
+		configFileRequired: true
+	} : {
+		cwd,
+		defaultConfig,
+		name: CONFIG_FILE_NAME,
+		...commonOptions
+	});
+	return mergeConfig(defaultConfig, userConfig);
+}
+
+//#endregion
+export { assets_exports as AssetUtils, Bundler, TerminalReporter as DefaultReporter, PluginUtils, defineConfig, getDefaultConfig, loadConfig, mergeConfig, plugins_exports as plugins, rolldown, rolldownExperimental };