react-native-bundle-discovery 2.5.0 → 2.7.0-rc.0

package/dist/index.js

@@ -0,0 +1,731 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let node_buffer = require("node:buffer");
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs);
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+let chalk = require("chalk");
+chalk = __toESM(chalk);
+let acorn = require("acorn");
+acorn = __toESM(acorn);
+let acorn_walk = require("acorn-walk");
+acorn_walk = __toESM(acorn_walk);
+//#region package.json
+var name = "react-native-bundle-discovery";
+//#endregion
+//#region src/packageMetadata.ts
+const DEFAULT_REGISTRY = "https://registry.npmjs.org";
+const DEFAULT_TIMEOUT_MS = 5e3;
+const DEFAULT_CONCURRENCY = 5;
+const cache = /* @__PURE__ */ new Map();
+/**
+* `@babel/runtime` -> `@babel%2fruntime`
+*/
+function encodePackageName(name) {
+	return name.startsWith("@") ? `@${encodeURIComponent(name.slice(1))}` : name;
+}
+async function fetchJson(url, timeoutMs) {
+	const res = await fetch(url, {
+		headers: { Accept: "application/json" },
+		signal: AbortSignal.timeout(timeoutMs)
+	});
+	if (res.status === 404) return null;
+	if (!res.ok) throw new Error(`${res.status} ${res.statusText} (${url})`);
+	return res.json();
+}
+/**
+* The version manifest (`/<name>/<version>`) has no publish date,
+* so the packument is fetched once and only the fields we need are kept.
+*/
+async function fetchPackageSummary(name, { registry, timeoutMs }) {
+	const packument = await fetchJson(`${registry}/${encodePackageName(name)}`, timeoutMs);
+	if (!packument) return null;
+	const versions = {};
+	for (const [version, manifest] of Object.entries(packument.versions ?? {})) versions[version] = {
+		createdAt: packument.time?.[version] ?? null,
+		deprecated: manifest.deprecated || false
+	};
+	return {
+		latestVersion: packument["dist-tags"]?.latest ?? null,
+		versions
+	};
+}
+function getPackageSummary(name, { registry, timeoutMs }) {
+	const key = `${registry}|${name}`;
+	let promise = cache.get(key);
+	if (!promise) {
+		promise = fetchPackageSummary(name, {
+			registry,
+			timeoutMs
+		}).catch((error) => {
+			cache.delete(key);
+			throw error;
+		});
+		cache.set(key, promise);
+	}
+	return promise;
+}
+/**
+* Returns metadata of a specific (installed) package version, not the latest one.
+*
+* @returns `null` when the package/version is not found in the registry.
+*/
+async function getPackageMetadata(name, version, { registry = DEFAULT_REGISTRY, timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+	const summary = await getPackageSummary(name, {
+		registry,
+		timeoutMs
+	});
+	const info = summary?.versions[version];
+	if (!summary || !info) return null;
+	return {
+		createdAt: info.createdAt,
+		deprecated: info.deprecated,
+		isLatest: summary.latestVersion === version,
+		latestVersion: summary.latestVersion
+	};
+}
+async function mapWithConcurrency(items, limit, fn) {
+	const results = new Array(items.length);
+	let index = 0;
+	async function worker() {
+		while (index < items.length) {
+			const i = index++;
+			results[i] = await fn(items[i], i);
+		}
+	}
+	await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+	return results;
+}
+/**
+* Adds a `metadata` field to every package of the report.
+* Failed lookups result in `metadata: null` and are passed to `onError`.
+*/
+async function withPackagesMetadata(packages, { registry = DEFAULT_REGISTRY, timeoutMs = DEFAULT_TIMEOUT_MS, concurrency = DEFAULT_CONCURRENCY, onError = () => {} } = {}) {
+	return mapWithConcurrency(packages, concurrency, async (pkg) => {
+		if (!pkg.version) return {
+			...pkg,
+			metadata: null
+		};
+		try {
+			const metadata = await getPackageMetadata(pkg.name, pkg.version, {
+				registry,
+				timeoutMs
+			});
+			return {
+				...pkg,
+				metadata
+			};
+		} catch (error) {
+			onError(error, pkg);
+			return {
+				...pkg,
+				metadata: null
+			};
+		}
+	});
+}
+//#endregion
+//#region src/parseUtils.ts
+function isNumericId(node) {
+	return node.type === "Literal" && node.value !== null && node.value !== void 0 && Number.isInteger(node.value) && node.value >= 0;
+}
+function isModuleId(node) {
+	return node !== null && node.type === "Literal" && (isNumericId(node) || typeof node.value === "string");
+}
+function isModuleWrapper(node) {
+	return (node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") && !node.id || isModuleId(node) || node.type === "ArrayExpression" && node.elements.length > 1 && isModuleId(node.elements[0]);
+}
+function isModulesHash(node) {
+	return node !== null && node.type === "ObjectExpression" && node.properties.filter((property) => property.type !== "SpreadElement").map((node) => node.value).every(isModuleWrapper);
+}
+function isModulesArray(node) {
+	return node !== null && node.type === "ArrayExpression" && node.elements.every((elem) => !elem || isModuleWrapper(elem));
+}
+function isSimpleModulesList(node) {
+	return isModulesHash(node) || isModulesArray(node);
+}
+function isOptimizedModulesArray(node) {
+	return node !== null && node.type === "CallExpression" && node.callee.type === "MemberExpression" && node.callee.object.type === "CallExpression" && node.callee.object.callee.type === "Identifier" && node.callee.object.callee.name === "Array" && node.callee.object.arguments.length === 1 && node.callee.object.arguments[0].type !== "SpreadElement" && isNumericId(node.callee.object.arguments[0]) && node.callee.property.type === "Identifier" && node.callee.property.name === "concat" && node.arguments.length === 1 && isModulesArray(node.arguments[0]);
+}
+function isModulesList(node) {
+	return isSimpleModulesList(node) || isOptimizedModulesArray(node);
+}
+function getModuleLocation(node) {
+	return {
+		start: node.start,
+		end: node.end
+	};
+}
+function getModulesLocations(node) {
+	if (node.type === "ObjectExpression") return node.properties.reduce((result, moduleNode) => {
+		if (moduleNode.type !== "Property") return result;
+		const moduleId = moduleNode.key.type === "Identifier" ? moduleNode.key.name : moduleNode.key.value;
+		if (moduleId === "undefined") return result;
+		result[moduleId] = getModuleLocation(moduleNode.value);
+		return result;
+	}, {});
+	const isOptimizedArray = node.type === "CallExpression";
+	if (node.type === "ArrayExpression" || isOptimizedArray) {
+		const minId = isOptimizedArray && node.callee.type === "MemberExpression" && node.callee.object.type === "CallExpression" && node.callee.object.arguments[0].type === "Literal" ? node.callee.object.arguments[0].value : 0;
+		return (isOptimizedArray ? node.arguments[0].type === "ArrayExpression" ? node.arguments[0].elements : [] : node.elements).reduce((result, moduleNode, i) => {
+			if (moduleNode) result[i + minId] = getModuleLocation(moduleNode);
+			return result;
+		}, {});
+	}
+	return {};
+}
+function getIIFECallExpression(node) {
+	if (node.expression.type === "CallExpression") return node.expression;
+	if (node.expression.type === "UnaryExpression" && node.expression.argument.type === "CallExpression") return node.expression.argument;
+	return null;
+}
+function callsModulesMap(node, modulesVariableName) {
+	let callsModule = false;
+	acorn_walk.simple(node, { CallExpression(callExpression) {
+		const { callee } = callExpression;
+		if (callee.type === "MemberExpression" && (callee.object.type === "Identifier" && callee.object.name === modulesVariableName || callee.object.type === "MemberExpression" && callee.object.object.type === "Identifier" && callee.object.object.name === modulesVariableName)) callsModule = true;
+	} });
+	return callsModule;
+}
+function hasWebpackModulesRuntime(body, modulesDeclaration, modulesVariableName) {
+	const declarationIndex = body.body.indexOf(modulesDeclaration);
+	return body.body.slice(declarationIndex + 1).some((statement) => callsModulesMap(statement, modulesVariableName));
+}
+function getWebpack5IIFEModulesCandidate(node, isTopLevel) {
+	if (node.arguments.length !== 0 || node.callee.type !== "FunctionExpression" && node.callee.type !== "ArrowFunctionExpression" || node.callee.params.length !== 0 || node.callee.body.type !== "BlockStatement") return null;
+	const firstVariableDeclaration = node.callee.body.body.find((node) => node.type === "VariableDeclaration");
+	if (firstVariableDeclaration) {
+		for (const declaration of firstVariableDeclaration.declarations) if (declaration.init && isModulesList(declaration.init)) {
+			const locations = getModulesLocations(declaration.init);
+			if (Object.keys(locations).length === 0) continue;
+			return {
+				locations,
+				hasWebpackRuntime: declaration.id.type === "Identifier" && hasWebpackModulesRuntime(node.callee.body, firstVariableDeclaration, declaration.id.name),
+				isTopLevel
+			};
+		}
+	}
+	return null;
+}
+function selectWebpack5IIFECandidate(candidates) {
+	return candidates.find((candidate) => candidate.hasWebpackRuntime && candidate.isTopLevel) || candidates.find((candidate) => candidate.hasWebpackRuntime) || candidates.find((candidate) => candidate.isTopLevel) || null;
+}
+function selectWebpack5IIFEModulesLocations(candidates, expectedModuleIds) {
+	if (candidates.length === 0) return null;
+	if (expectedModuleIds?.length) {
+		const expectedIds = new Set(expectedModuleIds.map(String));
+		const rankedCandidates = candidates.map((candidate) => ({
+			candidate,
+			expectedIdsIntersection: Object.keys(candidate.locations).filter((moduleId) => expectedIds.has(moduleId)).length
+		})).toSorted((candidateA, candidateB) => candidateB.expectedIdsIntersection - candidateA.expectedIdsIntersection);
+		if (rankedCandidates[0].expectedIdsIntersection > 0) return selectWebpack5IIFECandidate(rankedCandidates.filter((rankedCandidate) => rankedCandidate.expectedIdsIntersection === rankedCandidates[0].expectedIdsIntersection).map((rankedCandidate) => rankedCandidate.candidate))?.locations || null;
+	}
+	return selectWebpack5IIFECandidate(candidates)?.locations || null;
+}
+function isChunkIds(node) {
+	return node.type === "ArrayExpression" && node.elements.every(isModuleId);
+}
+function mayBeAsyncChunkArguments(args) {
+	return args.length >= 2 && args[0] !== null && args[0].type !== "SpreadElement" && isChunkIds(args[0]);
+}
+/** Returns bundle source except modules */
+function getBundleRuntime(content, modulesLocations) {
+	const sortedLocations = Object.values(modulesLocations || {}).toSorted((a, b) => a.start - b.start);
+	let result = "";
+	let lastIndex = 0;
+	for (const { start, end } of sortedLocations) {
+		result += content.slice(lastIndex, start);
+		lastIndex = end;
+	}
+	return result + content.slice(lastIndex);
+}
+function isAsyncChunkPushExpression(node) {
+	const { callee, arguments: args } = node;
+	return callee.type === "MemberExpression" && callee.property.type === "Identifier" && callee.property.name === "push" && callee.object.type === "AssignmentExpression" && args.length === 1 && args[0].type === "ArrayExpression" && mayBeAsyncChunkArguments(args[0].elements) && isModulesList(args[0].elements[1]);
+}
+function isAsyncWebWorkerChunkExpression(node) {
+	const { callee, type, arguments: args } = node;
+	return type === "CallExpression" && callee.type === "MemberExpression" && args.length === 2 && args[0].type !== "SpreadElement" && isChunkIds(args[0]) && isModulesList(args[1]);
+}
+function parseBundle(bundlePath, opts) {
+	const { sourceType = "script", expectedModuleIds } = opts || {};
+	const content = node_fs.default.readFileSync(bundlePath, "utf8");
+	const ast = acorn.parse(content, {
+		sourceType,
+		ecmaVersion: "latest"
+	});
+	const topLevelIIFECalls = /* @__PURE__ */ new Set();
+	for (const node of ast.body) if (node.type === "ExpressionStatement") {
+		const iifeCall = getIIFECallExpression(node);
+		if (iifeCall) topLevelIIFECalls.add(iifeCall);
+	}
+	const walkState = {
+		locations: null,
+		webpack5IIFECandidates: []
+	};
+	acorn_walk.recursive(ast, walkState, {
+		AssignmentExpression(node, state) {
+			if (state.locations) return;
+			const { left, right } = node;
+			if (left && left.type === "MemberExpression" && left.object && left.object.type === "Identifier" && left.object.name === "exports" && left.property && left.property.type === "Identifier" && left.property.name === "modules" && isModulesHash(right)) state.locations = getModulesLocations(right);
+		},
+		CallExpression(node, state, callback) {
+			if (state.locations) return;
+			const args = node.arguments;
+			const webpack5IIFEModulesCandidate = getWebpack5IIFEModulesCandidate(node, topLevelIIFECalls.has(node));
+			if (webpack5IIFEModulesCandidate) state.webpack5IIFECandidates.push(webpack5IIFEModulesCandidate);
+			if (node.callee.type === "FunctionExpression" && !node.callee.id && args.length === 1 && isSimpleModulesList(args[0])) {
+				state.locations = getModulesLocations(args[0]);
+				return;
+			}
+			// webpackJsonp([<chunks>], <modules>, ...)
+			if (node.callee.type === "Identifier" && mayBeAsyncChunkArguments(args) && args[1].type !== "SpreadElement" && isModulesList(args[1])) {
+				state.locations = getModulesLocations(args[1]);
+				return;
+			}
+			if (isAsyncChunkPushExpression(node) && args[0].type === "ArrayExpression" && args[0].elements[1]) {
+				state.locations = getModulesLocations(args[0].elements[1]);
+				return;
+			}
+			if (isAsyncWebWorkerChunkExpression(node)) {
+				state.locations = getModulesLocations(args[1]);
+				return;
+			}
+			for (const arg of args) callback(arg, state);
+		}
+	});
+	const modulesLocations = walkState.locations || selectWebpack5IIFEModulesLocations(walkState.webpack5IIFECandidates, expectedModuleIds);
+	const modules = {};
+	if (modulesLocations) for (const [id, loc] of Object.entries(modulesLocations)) modules[id] = content.slice(loc.start, loc.end);
+	return {
+		modules,
+		src: content,
+		runtimeSrc: getBundleRuntime(content, modulesLocations)
+	};
+}
+//#endregion
+//#region src/webpack.ts
+const NAME$1 = name;
+const packageRegex = /(?:^|\/)node_modules\/((?:@[^/]+\/)?[^/]+)/g;
+/**
+* Simple Webpack/Rspack plugin
+*   to adapt stats object https://webpack.js.org/api/stats/
+*   to metro-stats.json format used by `react-native-bundle-discovery`
+*/
+var BundleDiscoveryPlugin = class {
+	options;
+	filename;
+	enabled;
+	fetchPackagesMetadata;
+	constructor({ filename, options, enabled, fetchPackagesMetadata } = {}) {
+		this.options = options;
+		this.filename = filename || "metro-stats.json";
+		this.enabled = enabled ?? true;
+		this.fetchPackagesMetadata = fetchPackagesMetadata ?? true;
+	}
+	extractSizesFromJsBundle(statAsset, options) {
+		const assetFile = node_path.default.join(options.output.path, statAsset.name);
+		try {
+			return parseBundle(assetFile, { sourceType: statAsset.info.javascriptModule ? "module" : "script" });
+		} catch {
+			return null;
+		}
+	}
+	apply(compiler) {
+		if (!this.enabled) return;
+		compiler.hooks.done.tap("GenerateStatsJsonPlugin", (stats) => {
+			const json = stats.toJson({
+				version: true,
+				builtAt: true,
+				modules: true,
+				reasons: true,
+				assets: true,
+				ids: true,
+				...this.options,
+				all: false,
+				source: true
+			});
+			const statsJson = this.formatStat(json, this.extractSizesFromJsBundle(json.assets[0], compiler.options), compiler.options);
+			const outputPath = node_path.default.resolve(compiler.options.context, this.filename);
+			const keepAlive = setInterval(() => {}, 1e3);
+			this.writeReport(statsJson, outputPath).catch((error) => {
+				console.error(`${chalk.default.yellow(`[${NAME$1}]`)}: Failed to create JSON report: ${error.message}`);
+			}).finally(() => clearInterval(keepAlive));
+		});
+	}
+	async writeReport(statsJson, outputPath) {
+		if (this.fetchPackagesMetadata) statsJson.packages = await withPackagesMetadata(statsJson.packages, { onError: (error, pkg) => {
+			console.warn(`${chalk.default.yellow(`[${NAME$1}]`)}: Failed to fetch metadata for ${pkg.name}@${pkg.version}: ${error.message}`);
+		} });
+		node_fs.default.writeFileSync(outputPath, JSON.stringify(statsJson, null, 2));
+		console.log(`${chalk.default.yellow(`[${NAME$1}]`)}: Saved stats to ${chalk.default.green(outputPath)}`);
+	}
+	readSource(filePath) {
+		const fallback = {
+			code: "",
+			lineCount: 0,
+			sizeInBytes: 0
+		};
+		try {
+			const code = node_fs.default.readFileSync(filePath, "utf-8");
+			const lineCount = code.split("\n").length;
+			const sizeInBytes = Buffer.byteLength(code, "utf-8");
+			return {
+				code: this.options?.source === false ? "" : code,
+				lineCount,
+				sizeInBytes
+			};
+		} catch {
+			return fallback;
+		}
+	}
+	getPkgVersionFromPath(path) {
+		try {
+			const matches = [...path.matchAll(/\.pnpm\/([^/]+)\/node_modules/g)];
+			if (!matches.length) return null;
+			const versionMatch = matches[matches.length - 1][1].match(/^@?[^@]+@([^_]+)/);
+			return versionMatch ? versionMatch[1] : null;
+		} catch {
+			return "";
+		}
+	}
+	getPackages(statsJson) {
+		const packagesMap = /* @__PURE__ */ new Map();
+		for (const mdl of statsJson.modules) {
+			const filePath = mdl.nameForCondition;
+			if (!filePath) continue;
+			let lastMatch = null;
+			packageRegex.lastIndex = 0;
+			let match = packageRegex.exec(filePath);
+			while (match !== null) {
+				lastMatch = match;
+				match = packageRegex.exec(filePath);
+			}
+			if (!lastMatch) continue;
+			const packageName = lastMatch[1];
+			const matchIndex = lastMatch.index;
+			const cutIndex = matchIndex + (filePath[matchIndex] === "/" ? 1 : 0) + 13 + packageName.length;
+			const absolutePath = filePath.slice(0, cutIndex);
+			let version = "";
+			try {
+				version = require(node_path.default.join(absolutePath, "package.json")).version;
+			} catch (e) {
+				const verFromPath = this.getPkgVersionFromPath(absolutePath);
+				if (verFromPath) version = verFromPath;
+				else if (e?.code === "MODULE_NOT_FOUND") console.warn(`[${NAME$1}] getPackages: unexpected path resolution`, {
+					filePath,
+					absolutePath
+				});
+				else throw e;
+			}
+			if (!packagesMap.has(absolutePath)) packagesMap.set(absolutePath, {
+				name: packageName,
+				absolutePath,
+				version
+			});
+		}
+		return Array.from(packagesMap.values());
+	}
+	getEntryFile(statsJson, rootFolder) {
+		const fallbackValue = node_path.default.join(rootFolder, "index.js");
+		return statsJson.modules.find((mdl) => !mdl.nameForCondition?.includes("node_modules/") && mdl.reasons?.length === 1 && mdl.reasons?.[0].type === "entry")?.nameForCondition || fallbackValue;
+	}
+	getModuleOutput(mdl, bundleModules) {
+		const jsCodeStrFromJSBundle = bundleModules?.modules?.[String(mdl.id)];
+		if (jsCodeStrFromJSBundle) {
+			const formatted = jsCodeStrFromJSBundle.startsWith("function(") && jsCodeStrFromJSBundle.endsWith("}") ? jsCodeStrFromJSBundle.replace("function(", "function module(") : jsCodeStrFromJSBundle;
+			return {
+				code: formatted,
+				lineCount: formatted.split("\n").length ?? 0,
+				sizeInBytes: Buffer.byteLength(jsCodeStrFromJSBundle, "utf-8")
+			};
+		}
+		return {
+			code: mdl.source ?? "",
+			lineCount: mdl.source?.split("\n").length ?? 0,
+			sizeInBytes: mdl.size ?? 0
+		};
+	}
+	formatStat(statsJson, bundleModules, compilerOptions) {
+		const modulesDeps = this.buildImportsMapFromReasons(statsJson, compilerOptions);
+		const context = compilerOptions.context;
+		return {
+			kind: "webpack",
+			date: statsJson.builtAt || Date.now(),
+			entryPoint: this.getEntryFile(statsJson, context),
+			rootFolder: this.findCommonRoot(statsJson.modules.map((m) => m.nameForCondition).filter((p) => Boolean(p))) || context,
+			transformOptions: {
+				dev: compilerOptions.mode !== "production",
+				minify: compilerOptions.optimization?.minimize ?? false,
+				platform: compilerOptions.name ?? "ios"
+			},
+			modules: statsJson.modules.map((mdl) => {
+				if (mdl.type === "runtime modules") {
+					if (!bundleModules) return null;
+					const sourceAndOutput = {
+						code: bundleModules.runtimeSrc ?? "",
+						lineCount: bundleModules.runtimeSrc?.split("\n").length ?? 0,
+						sizeInBytes: Buffer.byteLength(bundleModules.runtimeSrc ?? "", "utf-8")
+					};
+					return {
+						path: "__runtime__",
+						source: sourceAndOutput,
+						output: sourceAndOutput,
+						dependencies: []
+					};
+				}
+				if (!mdl.nameForCondition) return null;
+				return {
+					path: mdl.nameForCondition,
+					source: this.readSource(mdl.nameForCondition),
+					output: this.getModuleOutput(mdl, bundleModules),
+					dependencies: modulesDeps.get(mdl.nameForCondition) ?? []
+				};
+			}).filter((e) => e !== null && Boolean(e.path)),
+			packages: this.getPackages(statsJson)
+		};
+	}
+	buildImportsMapFromReasons(statsJson, compilerOptions) {
+		const modules = Array.isArray(statsJson?.modules) ? statsJson.modules : [];
+		const importsMap = /* @__PURE__ */ new Map();
+		const getAbs = (p) => {
+			if (!p || typeof p !== "string") return null;
+			if (node_path.default.isAbsolute(p)) return p;
+			return compilerOptions?.context ? node_path.default.resolve(compilerOptions?.context, p) : p;
+		};
+		const getModulePath = (m) => m?.path || m?.nameForCondition || m?.identifier || null;
+		for (const depModule of modules) {
+			const depAbsolutePath = getAbs(getModulePath(depModule));
+			if (!depAbsolutePath) continue;
+			const reasons = Array.isArray(depModule.reasons) ? depModule.reasons : [];
+			for (const reason of reasons) {
+				if (reason?.type === "entry") continue;
+				const importerPath = getAbs(reason?.modulePath || reason?.moduleNameForCondition || reason?.resolvedModule || reason?.moduleIdentifier);
+				if (!importerPath) continue;
+				let deps = importsMap.get(importerPath);
+				if (!deps) {
+					deps = [];
+					importsMap.set(importerPath, deps);
+				}
+				if (!deps.some((d) => d.absolutePath === depAbsolutePath)) deps.push({
+					absolutePath: depAbsolutePath,
+					name: reason?.userRequest || ""
+				});
+			}
+		}
+		return importsMap;
+	}
+	findCommonRoot(paths) {
+		if (!paths || paths.length === 0) return "";
+		if (paths.length === 1) {
+			const lastSlash = paths[0].lastIndexOf("/");
+			return lastSlash === -1 ? "" : paths[0].slice(0, lastSlash);
+		}
+		const first = paths[0];
+		let maxLen = first.length;
+		for (let i = 1; i < paths.length; i++) {
+			const current = paths[i];
+			const limit = Math.min(maxLen, current.length);
+			let j = 0;
+			while (j < limit && first.charCodeAt(j) === current.charCodeAt(j)) j++;
+			maxLen = j;
+			if (maxLen === 0) return "";
+		}
+		if (maxLen === first.length) {
+			const lastSlash = first.lastIndexOf("/");
+			return lastSlash === -1 ? "" : first.slice(0, lastSlash);
+		}
+		const commonSlice = first.slice(0, maxLen);
+		const lastSlash = commonSlice.lastIndexOf("/");
+		return lastSlash === -1 ? "" : commonSlice.slice(0, lastSlash);
+	}
+};
+//#endregion
+//#region src/index.ts
+const NAME = name;
+function getDefault(module) {
+	return module.__esModule ? module.default : module;
+}
+function getDefaultSerializer() {
+	const metroPath = (0, node_path.parse)(require.resolve("metro/package.json")).dir;
+	const bundleToString = getDefault(require(`${metroPath}/src/lib/bundleToString.js`));
+	const baseJSBundle = getDefault(require(`${metroPath}/src/DeltaBundler/Serializers/baseJSBundle.js`));
+	return function defaultSerializer(entryPoint, preModules, graph, options) {
+		let bundle = baseJSBundle(entryPoint, preModules, graph, options);
+		if (typeof options?.sentryBundleCallback === "function") bundle = options.sentryBundleCallback(bundle);
+		return bundleToString(bundle).code;
+	};
+}
+function getStringSizeInBytes(str) {
+	return node_buffer.Buffer.byteLength(str, "utf8");
+}
+/**
+* `/Users/i/app/node_modules/metro/node_modules/@babel/runtime/helpers/createClass.js` -> `@babel/runtime`
+* `/Users/i/app/node_modules/react/jsx-runtime.js` -> `react`
+*/
+function getPackageNameFromPath(path) {
+	const parts = path.split("node_modules/");
+	const lastPart = parts[parts.length - 1];
+	if (lastPart.startsWith("@")) return lastPart.split("/").slice(0, 2).join("/");
+	return lastPart.split("/")[0];
+}
+/**
+* `/Users/i/app/node_modules/metro/node_modules/@babel/runtime/helpers/createClass.js` -> `/Users/i/app/node_modules/metro/node_modules/@babel/runtime`
+* `/Users/i/app/node_modules/react/jsx-runtime.js` -> `/Users/i/app/node_modules/react`
+*/
+function getPackageAbsolutePath(path, pkgName) {
+	const parts = path.split("node_modules/");
+	parts[parts.length - 1] = pkgName;
+	return parts.join("node_modules/");
+}
+function toPackages(modules) {
+	const packages = /* @__PURE__ */ new Map();
+	modules.forEach((module) => {
+		if (!module.path.includes("node_modules/")) return;
+		const pkgName = getPackageNameFromPath(module.path);
+		const absolutePkgPath = getPackageAbsolutePath(module.path, pkgName);
+		if (!packages.has(absolutePkgPath)) packages.set(absolutePkgPath, {
+			name: pkgName,
+			absolutePath: absolutePkgPath,
+			version: require((0, node_path.resolve)(absolutePkgPath, "package.json")).version
+		});
+	});
+	return Array.from(packages.values()).sort((a, b) => a.name.localeCompare(b.name));
+}
+function toModuleStruct(m, includeCode) {
+	const sourceCode = m.getSource().toString("utf8");
+	const outputCode = m.output[0].data.code;
+	return {
+		path: m.path,
+		source: {
+			code: includeCode ? sourceCode : "",
+			lineCount: sourceCode.split("\n").length,
+			sizeInBytes: getStringSizeInBytes(sourceCode)
+		},
+		output: {
+			code: includeCode ? outputCode : "",
+			lineCount: m.output[0].data.lineCount,
+			sizeInBytes: getStringSizeInBytes(outputCode)
+		},
+		dependencies: Array.from(m?.dependencies?.values?.() ?? []).filter((e) => e.absolutePath).map((e) => ({
+			absolutePath: e.absolutePath,
+			name: e.data.name
+		}))
+	};
+}
+async function createJsonReport({ graph, entryPoint, includeEnvs, preModules, includeCode, outputJsonPath, rootFolder, silent, options, fetchPackagesMetadata }) {
+	const { processModuleFilter = () => true } = options || {};
+	const dependencies = Array.from(graph.dependencies.values()).filter(processModuleFilter);
+	let packages = toPackages(preModules).concat(toPackages(dependencies));
+	const modules = preModules.map((m) => toModuleStruct(m, includeCode)).concat(dependencies.map((m) => toModuleStruct(m, includeCode)));
+	if (fetchPackagesMetadata) packages = await withPackagesMetadata(packages, { onError: (error, pkg) => {
+		if (!silent) console.warn(`${chalk.default.yellow(`[${NAME}]`)}: Failed to fetch metadata for ${pkg.name}@${pkg.version}: ${error.message}`);
+	} });
+	const stats = {
+		date: Date.now(),
+		entryPoint,
+		transformOptions: graph.transformOptions,
+		envs: includeEnvs.reduce((acc, envName) => {
+			acc[envName] = process.env[envName];
+			return acc;
+		}, {}),
+		rootFolder,
+		packages,
+		modules
+	};
+	(0, node_fs.writeFileSync)(outputJsonPath, JSON.stringify(stats));
+	if (!silent) console.log(`${chalk.default.yellow(`[${NAME}]`)}: Saved stats to ${chalk.default.green(outputJsonPath)}`);
+}
+/**
+* Creates a custom serializer function for Metro bundler, which generates a JSON report
+* and optionally modifies the serialization process.
+*
+* @param options - Configuration options for the serializer.
+* @returns A custom serializer function to be used by Metro.
+* @throws Throws an error if the project root does not exist.
+*/
+function createSerializer({ serializer, projectRoot, outputJsonPath, includeCode = true, silent = false, includeEnvs = [], fetchPackagesMetadata = true } = {}) {
+	const mySerializer = serializer || getDefaultSerializer();
+	if (!(0, node_fs.existsSync)(projectRoot)) throw new Error(`[${NAME}]: Project root does not exist: ${projectRoot}`);
+	const myOutputJsonPath = outputJsonPath ?? (0, node_path.resolve)(projectRoot, "metro-stats.json");
+	function customSerializer(entryPoint, preModules, graph, options) {
+		const code = mySerializer(entryPoint, preModules, graph, options);
+		const keepAlive = setInterval(() => {}, 1e3);
+		createJsonReport({
+			graph,
+			entryPoint,
+			includeEnvs,
+			preModules,
+			includeCode,
+			outputJsonPath: myOutputJsonPath,
+			rootFolder: projectRoot,
+			silent,
+			options,
+			fetchPackagesMetadata
+		}).finally(() => clearInterval(keepAlive));
+		return code;
+	}
+	return customSerializer;
+}
+const empty = { type: "empty" };
+/**
+* Usage:
+*
+* ```js
+* // metro.config.js
+* const { createResolveRequest } = require("react-native-bundle-discovery");
+* const resolveRequest = createResolveRequest({
+*   removePromisePolyfill: true,
+* });
+* const config = {
+*   resolver: {
+*     resolveRequest,
+*   },
+* };
+* ```
+*/
+const createResolveRequest = ({ removeNewRenderer = false, removeUTFSequence = false } = {}) => {
+	const resolveRequest = (context, ...rest) => {
+		const result = context.resolveRequest(context, ...rest);
+		if (context.dev) return result;
+		if (removeUTFSequence && result?.filePath?.endsWith("/react-native/Libraries/UTFSequence.js")) return empty;
+		if (removeNewRenderer && result?.filePath?.endsWith("/react-native/Libraries/Renderer/shims/ReactFabric.js")) return empty;
+		return result;
+	};
+	return resolveRequest;
+};
+/**
+* @deprecated Use `createResolveRequest` instead.
+*/
+const createProcessModuleFilter = ({ removePromisePolyfill = false, removeUTFSequence = false } = {}) => (module) => {
+	if (removePromisePolyfill && module.path.endsWith("/react-native/Libraries/Promise.js")) return false;
+	if (removeUTFSequence && module.path.endsWith("/react-native/Libraries/UTFSequence.js")) return false;
+	return true;
+};
+//#endregion
+exports.BundleDiscoveryPlugin = BundleDiscoveryPlugin;
+exports.createProcessModuleFilter = createProcessModuleFilter;
+exports.createResolveRequest = createResolveRequest;
+exports.createSerializer = createSerializer;