react-native-bundle-discovery-ui 2.8.0 → 2.9.0

package/dist/src-Bp8pPQrQ.js

@@ -0,0 +1,1545 @@
+const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.js");
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+let chalk = require("chalk");
+chalk = require_rolldown_runtime.__toESM(chalk);
+//#region ../shared/src/packageGroups.ts
+const LODASH_FAMILY_GROUP = "lodash (please use only one)";
+function getDuplicateGroupName(packageName) {
+  if (
+    packageName === "lodash" ||
+    packageName === "lodash-es" ||
+    packageName === "underscore" ||
+    packageName === "ramda" ||
+    packageName.startsWith("lodash.")
+  )
+    return LODASH_FAMILY_GROUP;
+  return packageName;
+}
+function getPackageGroups(report, sort = "size") {
+  const groupedPackages = report.packages.reduce((map, pkg) => {
+    const name = pkg?.name ?? "<unknown>";
+    const duplicateGroupName = getDuplicateGroupName(name);
+    const version = pkg?.version ?? "<unknown>";
+    const packagePath = pkg?.path ?? pkg?.absolutePath ?? "<unknown>";
+    const sizeInBytes = pkg?.sizeInBytes ?? 0;
+    let entries = map.get(duplicateGroupName);
+    if (!entries) {
+      entries = [];
+      map.set(duplicateGroupName, entries);
+    }
+    entries.push({
+      name,
+      version,
+      path: packagePath,
+      absolutePath: pkg?.absolutePath ?? packagePath,
+      sizeInBytes,
+    });
+    return map;
+  }, /* @__PURE__ */ new Map());
+  const packageGroups = Array.from(groupedPackages.entries()).map(
+    ([name, entries]) => {
+      return {
+        name,
+        entries,
+        totalSizeInBytes: entries.reduce(
+          (sum, entry) => sum + entry.sizeInBytes,
+          0,
+        ),
+      };
+    },
+  );
+  if (sort === "name")
+    packageGroups.sort((a, b) => a.name.localeCompare(b.name));
+  else packageGroups.sort((a, b) => b.totalSizeInBytes - a.totalSizeInBytes);
+  return packageGroups;
+}
+//#endregion
+//#region ../shared/src/esbuild.ts
+const RNX_PRELUDE = "virtual:metro:__rnx_prelude__";
+const packageRegex = /(?:^|\/)node_modules\/((?:@[^/]+\/)?[^/]+)/g;
+const isEsbuildMetafile = (reportJson, reportPath, noLogs) => {
+  try {
+    if (
+      reportJson?.inputs &&
+      typeof reportJson.inputs === "object" &&
+      reportJson?.outputs &&
+      typeof reportJson.outputs === "object" &&
+      !Array.isArray(reportJson?.modules)
+    ) {
+      !noLogs &&
+        console.info(
+          `Detected ${chalk.default.red("esbuild metafile")} format in the input file: ${chalk.default.green(reportPath)}`,
+        );
+      return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+};
+const isEsbuildMetafilePath = (reportPath) => {
+  try {
+    const reportJson = require(reportPath);
+    return isEsbuildMetafile(reportJson, reportPath, true);
+  } catch {
+    return false;
+  }
+};
+const isVirtual = (inputPath) =>
+  !(0, node_path.isAbsolute)(inputPath) && /^[\w-]+:/.test(inputPath);
+/**
+ * Metafile paths are relative to esbuild's working directory, which is not stored in the file.
+ * Try the metafile folder (and its parents) and then `process.cwd()`; pick the first one where the inputs exist.
+ */
+const getRootFolder = (metafile, reportPath) => {
+  const probe = Object.keys(metafile.inputs).find((p) => !isVirtual(p));
+  const candidates = [];
+  let dir = (0, node_path.dirname)(reportPath);
+  while (!candidates.includes(dir)) {
+    candidates.push(dir);
+    dir = (0, node_path.dirname)(dir);
+  }
+  candidates.push(process.cwd());
+  return (
+    (probe &&
+      candidates.find((root) =>
+        (0, node_fs.existsSync)((0, node_path.resolve)(root, probe)),
+      )) ||
+    (0, node_path.dirname)(reportPath)
+  );
+};
+const getPlatform = (paths) => {
+  const count = (platform) =>
+    paths.filter((p) => new RegExp(`\\.${platform}\\.[cm]?[jt]sx?$`).test(p))
+      .length;
+  return count("android") > count("ios") ? "android" : "ios";
+};
+const getPackages = (modulePaths) => {
+  const packages = /* @__PURE__ */ new Map();
+  for (const filePath of modulePaths) {
+    const lastMatch = [...filePath.matchAll(packageRegex)].pop();
+    if (!lastMatch) continue;
+    const name = lastMatch[1];
+    const end = filePath.indexOf(name, lastMatch.index) + name.length;
+    const absolutePath = filePath.slice(0, end);
+    if (packages.has(absolutePath)) continue;
+    let version = "";
+    try {
+      version = JSON.parse(
+        (0, node_fs.readFileSync)(
+          (0, node_path.resolve)(absolutePath, "package.json"),
+          "utf8",
+        ),
+      ).version;
+    } catch {}
+    packages.set(absolutePath, {
+      name,
+      absolutePath,
+      version,
+    });
+  }
+  return Array.from(packages.values()).sort((a, b) =>
+    a.name.localeCompare(b.name),
+  );
+};
+/**
+ * Converts an esbuild metafile (e.g. written by `@rnx-kit/metro-serializer-esbuild` with the `metafile` option)
+ * to the `metro-stats.json` format.
+ *
+ * Output sizes are `bytesInOutput` (after tree shaking and minification); modules removed by tree shaking are omitted.
+ * Code is not included: esbuild hoists all modules into a single scope.
+ */
+const transformEsbuildMetafile = (metafile, reportPath) => {
+  const rootFolder = getRootFolder(metafile, reportPath);
+  const toAbsolute = (p) =>
+    isVirtual(p) ? p : (0, node_path.resolve)(rootFolder, p);
+  const outputs = Object.entries(metafile.outputs).filter(
+    ([outputPath]) => !outputPath.endsWith(".map"),
+  );
+  const bytesInOutput = /* @__PURE__ */ new Map();
+  for (const [, output] of outputs)
+    for (const [inputPath, { bytesInOutput: bytes }] of Object.entries(
+      output.inputs,
+    ))
+      bytesInOutput.set(inputPath, (bytesInOutput.get(inputPath) ?? 0) + bytes);
+  const bundledInputs = Object.keys(metafile.inputs).filter(
+    (p) => (bytesInOutput.get(p) ?? 0) > 0,
+  );
+  const bundled = new Set(bundledInputs);
+  let entryPoint = outputs.find(([, o]) => o.entryPoint)?.[1].entryPoint ?? "";
+  if (entryPoint === RNX_PRELUDE)
+    entryPoint = metafile.inputs[RNX_PRELUDE]?.imports.at(-1)?.path ?? "";
+  const modules = bundledInputs.map((inputPath) => {
+    const input = metafile.inputs[inputPath];
+    return {
+      path: toAbsolute(inputPath),
+      source: {
+        code: "",
+        lineCount: 0,
+        sizeInBytes: input.bytes,
+      },
+      output: {
+        code: "",
+        lineCount: 0,
+        sizeInBytes: bytesInOutput.get(inputPath) ?? 0,
+      },
+      dependencies: input.imports
+        .filter((imp) => !imp.external && bundled.has(imp.path))
+        .map((imp) => ({
+          absolutePath: toAbsolute(imp.path),
+          name: imp.original ?? imp.path,
+        })),
+    };
+  });
+  return {
+    date: Date.now(),
+    entryPoint: entryPoint ? toAbsolute(entryPoint) : "",
+    rootFolder,
+    transformOptions: {
+      dev: false,
+      minify: true,
+      platform: getPlatform(bundledInputs),
+    },
+    packages: getPackages(modules.map((m) => m.path)),
+    modules,
+  };
+};
+//#endregion
+//#region ../shared/src/isRsdoctorReport.ts
+const isRsdoctorReport = (reportJson, reportPath, noLogs) => {
+  try {
+    if (
+      Array.isArray(reportJson?.data?.moduleGraph?.modules) ||
+      Array.isArray(reportJson?.data?.packageGraph?.packages)
+    ) {
+      !noLogs &&
+        console.info(
+          `Detected ${chalk.default.red("rsdoctor")} format in the input file: ${chalk.default.green(reportPath)}`,
+        );
+      return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+};
+const isRsdoctorReportPath = (reportPath) => {
+  try {
+    const reportJson = require(reportPath);
+    return isRsdoctorReport(reportJson, reportPath);
+  } catch {
+    return false;
+  }
+};
+//#endregion
+//#region ../shared/src/rsdoctor.ts
+const possibleEntryFiles = [
+  "index.js",
+  "index.jsx",
+  "index.ts",
+  "index.tsx",
+  "index.mjs",
+  "index.cjs",
+];
+const doStructureCheck = (rsdoctorData) => {
+  if (!(
+    Array.isArray(rsdoctorData?.data?.configs) &&
+    rsdoctorData.data.configs.length === 1
+  ))
+    throw new Error(
+      `Unexpected number of "data.configs[]" in rsdoctor-data.json. Work only with single config. Found: ${rsdoctorData?.data?.configs?.length}`,
+    );
+  if (!Array.isArray(rsdoctorData?.data?.packageGraph?.packages))
+    throw new Error(
+      `Unexpected "data.packageGraph.packages[]" in rsdoctor-data.json. Expected array. Found: ${typeof rsdoctorData?.data?.packageGraph?.packages}`,
+    );
+  const firstConfig = rsdoctorData.data.configs[0];
+  if (!(firstConfig.name === "rspack" || firstConfig.name === "webpack"))
+    throw new Error(
+      `Unsupported bundler: ${firstConfig.name}@${firstConfig.version}. Only 'rspack' and 'webpack' are supported.`,
+    );
+};
+const getDependenciesMap = (rsdoctorData) => {
+  return new Map(
+    rsdoctorData.data.moduleGraph.dependencies.map((dep) => [dep.id, dep]),
+  );
+};
+const getEntryFile = (rsdoctorData) => {
+  const firstConfig = rsdoctorData.data.configs[0];
+  const main = firstConfig.config.entry?.main;
+  const entryFile =
+    typeof main === "string"
+      ? main
+      : typeof main?.import === "string"
+        ? main.import
+        : main?.import[0];
+  if (entryFile) return (0, node_path.resolve)(firstConfig.root, entryFile);
+  const pathsToCheck = possibleEntryFiles.map((f) =>
+    (0, node_path.resolve)(firstConfig.root, f),
+  );
+  const indexFile = rsdoctorData.data.moduleGraph.modules.find((mdl) =>
+    pathsToCheck.some((entry) => mdl.path === entry),
+  );
+  if (indexFile && indexFile.imported?.length === 0) return indexFile.path;
+  return `${firstConfig.root}/index.js`;
+};
+const transformRSDoctorData = (rsdoctorData) => {
+  doStructureCheck(rsdoctorData);
+  const tmpDependenciesMap = getDependenciesMap(rsdoctorData);
+  const firstConfig = rsdoctorData.data.configs[0];
+  return {
+    date: Date.now(),
+    entryPoint: getEntryFile(rsdoctorData),
+    rootFolder: firstConfig.root,
+    transformOptions: {
+      dev: firstConfig.config.mode !== "production",
+      minify: firstConfig.config.optimization?.minimize ?? false,
+      platform: firstConfig.config.name ?? "ios",
+    },
+    packages: rsdoctorData.data.packageGraph.packages.map((pkg) => ({
+      name: pkg.name,
+      absolutePath: pkg.root,
+      version: pkg.version,
+      source: { sizeInBytes: pkg.size?.sourceSize ?? 1 },
+      output: { sizeInBytes: pkg.size?.parsedSize ?? 1 },
+    })),
+    modules: rsdoctorData.data.moduleGraph.modules.map((mdl) => ({
+      path: mdl.path,
+      source: {
+        code: "",
+        lineCount: 0,
+        sizeInBytes: mdl.size?.sourceSize ?? 0,
+      },
+      output: {
+        code: "",
+        lineCount: 0,
+        sizeInBytes: mdl.size?.parsedSize ?? 0,
+      },
+      dependencies: mdl.dependencies
+        .map((depNumId) => {
+          const dep = tmpDependenciesMap.get(depNumId);
+          return dep
+            ? {
+                absolutePath: dep.resolvedRequest,
+                name: dep.request,
+              }
+            : null;
+        })
+        .filter((e) => e !== null),
+    })),
+  };
+};
+//#endregion
+//#region ../shared/src/prepareReport.ts
+function normalizeReportData(report, reportPath, noLogs) {
+  if (isRsdoctorReport(report, reportPath, noLogs))
+    return transformRSDoctorData(report);
+  if (isEsbuildMetafile(report, reportPath, noLogs))
+    return transformEsbuildMetafile(report, reportPath);
+  return report;
+}
+/** Modules that belong to the package itself (without its nested `node_modules`) */
+function getPackageModules(report, pkg) {
+  const packagePrefix = `${pkg.absolutePath}/`;
+  return report.modules.filter(
+    (module) =>
+      module.path.startsWith(packagePrefix) &&
+      !module.path.slice(packagePrefix.length).includes("/node_modules/"),
+  );
+}
+function sumModulesSize(modules) {
+  return modules.reduce(
+    (sum, module) => sum + (module.output?.sizeInBytes ?? 0),
+    0,
+  );
+}
+function prepareReport(_report, reportPath, noLogs) {
+  const report = normalizeReportData(_report, reportPath, noLogs);
+  const packages = report.packages.map((pkg) => {
+    const sizeInBytes = sumModulesSize(getPackageModules(report, pkg));
+    return {
+      ...pkg,
+      path: pkg.absolutePath.replace(`${report.rootFolder}/`, ""),
+      sizeInBytes,
+    };
+  });
+  return Object.assign(report, { packages });
+}
+//#endregion
+//#region ../shared/src/recommendations/savings.ts
+function getModulesSavings(modules) {
+  const unique = Array.from(new Set(modules));
+  return {
+    sizeInBytes: sumModulesSize(unique),
+    modules: unique.map((module) => module.path),
+  };
+}
+function getPackagesSavings(report, packages) {
+  return getModulesSavings(
+    packages.flatMap((pkg) => getPackageModules(report, pkg)),
+  );
+}
+//#endregion
+//#region ../shared/src/recommendations/deprecated-packages.ts
+function findDeprecatedPackages(report) {
+  const matches = /* @__PURE__ */ new Map();
+  for (const pkg of report.packages) {
+    const deprecated = pkg?.metadata?.deprecated;
+    if (!deprecated) continue;
+    const id = `${pkg.name}@${pkg.version}`;
+    if (!matches.has(id))
+      matches.set(id, {
+        id,
+        reason: typeof deprecated === "string" ? deprecated.trim() : null,
+        latestVersion: pkg.metadata?.latestVersion ?? null,
+      });
+  }
+  return Array.from(matches.values());
+}
+const recommendation$14 = {
+  id: "deprecated-packages",
+  title: "Replace deprecated packages",
+  check: (report) => {
+    const deprecatedPackages = findDeprecatedPackages(report);
+    if (deprecatedPackages.length === 0) return null;
+    const details = deprecatedPackages
+      .map(({ id, reason, latestVersion }) => {
+        const latest = latestVersion ? ` (latest: ${latestVersion})` : "";
+        return reason ? ` - ${id}${latest}: ${reason}` : ` - ${id}${latest}`;
+      })
+      .join("\n");
+    return {
+      message: `Detected ${deprecatedPackages.length} deprecated package(s) in the bundle:
+${details}
+
+Deprecated packages are no longer maintained and may contain bugs or security issues.
+Upgrade to a non-deprecated version or migrate to the recommended replacement.
+`,
+      packages: deprecatedPackages.map(({ id }) => id),
+      docsUrl:
+        "https://docs.npmjs.com/deprecating-and-undeprecating-packages-or-package-versions",
+      modules: getModulesSavings(
+        report.packages
+          .filter((pkg) => pkg?.metadata?.deprecated)
+          .flatMap((pkg) => getPackageModules(report, pkg)),
+      ).modules,
+    };
+  },
+};
+//#endregion
+//#region ../shared/src/compare.ts
+const COMPARED_TRANSFORM_OPTIONS = [
+  "dev",
+  "minify",
+  "unstable_transformProfile",
+];
+const CONTRIBUTORS_LIMIT = 5;
+/**
+ * Makes paths comparable between machines and package managers:
+ * `/Users/i/app/src/App.js` -> `src/App.js`
+ * `/ci/app/node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/get.js` -> `node_modules/lodash/get.js`
+ */
+function normalizePath(absolutePath, rootFolder) {
+  const value = absolutePath ?? "<unknown>";
+  const rootPrefix = rootFolder ? `${rootFolder}/` : null;
+  return (
+    rootPrefix && value.startsWith(rootPrefix)
+      ? value.slice(rootPrefix.length)
+      : value
+  ).replace(/node_modules\/\.pnpm\/[^/]+\/node_modules\//g, "node_modules/");
+}
+/**
+ * `node_modules/@babel/runtime/helpers/createClass.js` -> `@babel/runtime`
+ * `src/screens/Home/index.js` -> `src/screens`
+ */
+function getContributorName(modulePath) {
+  const index = modulePath.lastIndexOf("node_modules/");
+  if (index !== -1) {
+    const parts = modulePath.slice(index + 13).split("/");
+    return parts[0].startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+  }
+  return modulePath.split("/").slice(0, -1).slice(0, 2).join("/") || modulePath;
+}
+function getTotalSize(report) {
+  return report.modules.reduce(
+    (sum, module) => sum + (module?.output?.sizeInBytes ?? 0),
+    0,
+  );
+}
+function getTransformOptionsDiff(before, after) {
+  if (!before.transformOptions || !after.transformOptions) return [];
+  return COMPARED_TRANSFORM_OPTIONS.filter(
+    (option) =>
+      before.transformOptions[option] !== after.transformOptions[option],
+  ).map((option) => ({
+    option,
+    before: before.transformOptions[option],
+    after: after.transformOptions[option],
+  }));
+}
+function getModuleSizes(report) {
+  const sizes = /* @__PURE__ */ new Map();
+  report.modules.forEach((module) => {
+    const modulePath = normalizePath(module?.path, report.rootFolder);
+    sizes.set(
+      modulePath,
+      (sizes.get(modulePath) ?? 0) + (module?.output?.sizeInBytes ?? 0),
+    );
+  });
+  return sizes;
+}
+function compareModules(before, after) {
+  const beforeSizes = getModuleSizes(before);
+  const afterSizes = getModuleSizes(after);
+  const added = [];
+  const removed = [];
+  const changed = [];
+  afterSizes.forEach((sizeInBytes, path) => {
+    const beforeSizeInBytes = beforeSizes.get(path);
+    if (beforeSizeInBytes === void 0) {
+      added.push({
+        path,
+        sizeInBytes,
+        deltaInBytes: sizeInBytes,
+      });
+      return;
+    }
+    if (beforeSizeInBytes !== sizeInBytes)
+      changed.push({
+        path,
+        beforeSizeInBytes,
+        afterSizeInBytes: sizeInBytes,
+        deltaInBytes: sizeInBytes - beforeSizeInBytes,
+      });
+  });
+  beforeSizes.forEach((sizeInBytes, path) => {
+    if (!afterSizes.has(path))
+      removed.push({
+        path,
+        sizeInBytes,
+        deltaInBytes: -sizeInBytes,
+      });
+  });
+  added.sort((a, b) => b.sizeInBytes - a.sizeInBytes);
+  removed.sort((a, b) => b.sizeInBytes - a.sizeInBytes);
+  changed.sort((a, b) => Math.abs(b.deltaInBytes) - Math.abs(a.deltaInBytes));
+  return {
+    added,
+    removed,
+    changed,
+  };
+}
+function getPackagesByName(report) {
+  const packages = /* @__PURE__ */ new Map();
+  report.packages.forEach((pkg) => {
+    const name = pkg?.name ?? "<unknown>";
+    let entry = packages.get(name);
+    if (!entry) {
+      entry = {
+        name,
+        versions: [],
+        sizeInBytes: 0,
+      };
+      packages.set(name, entry);
+    }
+    entry.versions.push(pkg?.version ?? "<unknown>");
+    entry.sizeInBytes += pkg?.sizeInBytes ?? 0;
+  });
+  packages.forEach((entry) => {
+    entry.versions = Array.from(new Set(entry.versions)).sort();
+  });
+  return packages;
+}
+function getNewDuplicates(before, after) {
+  const beforeGroups = new Map(
+    getPackageGroups(before).map((group) => [group.name, group]),
+  );
+  return getPackageGroups(after)
+    .filter(
+      (group) =>
+        group.entries.length > 1 &&
+        group.entries.length >
+          (beforeGroups.get(group.name)?.entries.length ?? 0),
+    )
+    .map((group) => ({
+      name: group.name,
+      count: group.entries.length,
+      sizeInBytes: group.totalSizeInBytes,
+      entries: group.entries.map((entry) => ({
+        name: entry.name,
+        version: entry.version,
+        path: normalizePath(entry.path, null),
+      })),
+    }));
+}
+function compareDeprecated(before, after) {
+  const beforeDeprecated = findDeprecatedPackages(before);
+  const afterDeprecated = findDeprecatedPackages(after);
+  const beforeIds = new Set(beforeDeprecated.map(({ id }) => id));
+  return {
+    beforeCount: beforeDeprecated.length,
+    afterCount: afterDeprecated.length,
+    added: afterDeprecated.filter(({ id }) => !beforeIds.has(id)),
+  };
+}
+function comparePackages(before, after) {
+  const beforePackages = getPackagesByName(before);
+  const afterPackages = getPackagesByName(after);
+  const added = [];
+  const removed = [];
+  const versionChanges = [];
+  afterPackages.forEach((pkg, name) => {
+    const beforePkg = beforePackages.get(name);
+    if (!beforePkg) {
+      added.push(pkg);
+      return;
+    }
+    if (beforePkg.versions.join() !== pkg.versions.join())
+      versionChanges.push({
+        name,
+        beforeVersions: beforePkg.versions,
+        afterVersions: pkg.versions,
+        deltaInBytes: pkg.sizeInBytes - beforePkg.sizeInBytes,
+      });
+  });
+  beforePackages.forEach((pkg, name) => {
+    if (!afterPackages.has(name)) removed.push(pkg);
+  });
+  added.sort((a, b) => b.sizeInBytes - a.sizeInBytes);
+  removed.sort((a, b) => b.sizeInBytes - a.sizeInBytes);
+  versionChanges.sort(
+    (a, b) => Math.abs(b.deltaInBytes) - Math.abs(a.deltaInBytes),
+  );
+  return {
+    added,
+    removed,
+    versionChanges,
+    newDuplicates: getNewDuplicates(before, after),
+    deprecated: compareDeprecated(before, after),
+  };
+}
+function getBiggestContributors(modules, packages) {
+  const deltas = /* @__PURE__ */ new Map();
+  [...modules.added, ...modules.removed, ...modules.changed].forEach(
+    (module) => {
+      const name = getContributorName(module.path);
+      deltas.set(name, (deltas.get(name) ?? 0) + module.deltaInBytes);
+    },
+  );
+  const addedNames = new Set(packages.added.map(({ name }) => name));
+  const versionChanges = new Map(
+    packages.versionChanges.map((change) => [change.name, change]),
+  );
+  return Array.from(deltas.entries())
+    .filter(([, deltaInBytes]) => deltaInBytes > 0)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, CONTRIBUTORS_LIMIT)
+    .map(([name, deltaInBytes]) => {
+      let note = null;
+      const change = versionChanges.get(name);
+      if (addedNames.has(name)) note = "new package";
+      else if (change)
+        note = `${change.beforeVersions.join(", ")} → ${change.afterVersions.join(", ")}`;
+      return {
+        name,
+        deltaInBytes,
+        note,
+      };
+    });
+}
+function withUniquePackages(report) {
+  const seen = /* @__PURE__ */ new Set();
+  return {
+    ...report,
+    packages: report.packages.filter((pkg) => {
+      const key = `${pkg?.name}@${pkg?.absolutePath ?? pkg?.path}`;
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    }),
+  };
+}
+function compareReports(_before, _after) {
+  const before = withUniquePackages(_before);
+  const after = withUniquePackages(_after);
+  const beforeSizeInBytes = getTotalSize(before);
+  const afterSizeInBytes = getTotalSize(after);
+  const modules = compareModules(before, after);
+  const packages = comparePackages(before, after);
+  return {
+    transformOptionsDiff: getTransformOptionsDiff(before, after),
+    summary: {
+      before: {
+        platform: before.transformOptions?.platform ?? null,
+        sizeInBytes: beforeSizeInBytes,
+        modules: before.modules.length,
+        packages: before.packages.length,
+      },
+      after: {
+        platform: after.transformOptions?.platform ?? null,
+        sizeInBytes: afterSizeInBytes,
+        modules: after.modules.length,
+        packages: after.packages.length,
+      },
+      deltaInBytes: afterSizeInBytes - beforeSizeInBytes,
+      deltaPercent:
+        beforeSizeInBytes > 0
+          ? ((afterSizeInBytes - beforeSizeInBytes) / beforeSizeInBytes) * 100
+          : null,
+    },
+    modules,
+    packages,
+    biggestContributors: getBiggestContributors(modules, packages),
+  };
+}
+function getBeforeModules(before, changed) {
+  const paths = new Set(changed.map((module) => module.path));
+  const result = {};
+  before.modules.forEach((module) => {
+    const modulePath = normalizePath(module?.path, before.rootFolder);
+    if (paths.has(modulePath) && !result[modulePath])
+      result[modulePath] = {
+        source: module.source?.code ?? "",
+        output: module.output?.code ?? "",
+      };
+  });
+  return result;
+}
+/** Attaches the diff against a "before" report (raw JSON of any supported format) */
+function withComparison(report, before, beforePath) {
+  const beforeReport = prepareReport(before, beforePath, true);
+  const comparison = compareReports(
+    beforeReport,
+    prepareReport({ ...report }, "", true),
+  );
+  return Object.assign(report, {
+    comparison: {
+      ...comparison,
+      beforeFile: beforePath.split("/").pop() ?? beforePath,
+      beforeModules: getBeforeModules(beforeReport, comparison.modules.changed),
+    },
+  });
+}
+//#endregion
+//#region ../shared/src/recommendations/dev-files.ts
+const devFileNamePattern = /\b(development|debug|dev|storybook)\b/i;
+function findDevFilesInBundle(report) {
+  return report.modules.filter((module) =>
+    devFileNamePattern.test(module?.path?.replace(report.rootFolder, "")),
+  );
+}
+const recommendation$13 = {
+  id: "dev-files-in-production-bundle",
+  title: "Exclude dev/debug files from production bundle",
+  check: (report) => {
+    const devFiles = findDevFilesInBundle(report);
+    if (devFiles.length === 0) return null;
+    const sample = devFiles
+      .slice(0, 5)
+      .map((module) => module.path.replace(report.rootFolder, ""))
+      .join("\n - ");
+    return {
+      message: `Detected ${devFiles.length} dev/debug file(s) in the production bundle.
+Files matching development|debug|dev|storybook should be excluded from release builds.
+Example paths:\n - ${sample}`,
+      packages: [],
+      docsUrl: null,
+      ...getModulesSavings(devFiles),
+    };
+  },
+};
+//#endregion
+//#region ../shared/src/versions.ts
+function getReactNativeVersion(packages) {
+  if (!Array.isArray(packages)) return;
+  return packages.find((pkg) => pkg?.name === "react-native")?.version;
+}
+function parseVersion(version) {
+  if (typeof version !== "string") return null;
+  const match = version.match(/^(\d+)\.(\d+)\.(\d+)/);
+  if (!match) return null;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+  };
+}
+function isVersionGte(version, targetVersion) {
+  const current = parseVersion(version);
+  const target = parseVersion(targetVersion);
+  if (!current || !target) return false;
+  if (current.major !== target.major) return current.major > target.major;
+  if (current.minor !== target.minor) return current.minor > target.minor;
+  return current.patch >= target.patch;
+}
+function formatRnVersionToDocsFormat(version) {
+  return version.split(".").slice(0, 2).join(".");
+}
+//#endregion
+//#region ../shared/src/recommendations/dev-only-packages.ts
+const rn74PlusDevOnlyPackages = [
+  "prop-types",
+  "deprecated-react-native-prop-types",
+];
+const devOnlyPackages = [
+  "redux-logger",
+  "redux-devtools",
+  "@redux-devtools/core",
+  "@redux-devtools/extension",
+  "redux-devtools-extension",
+  "@redux-devtools/instrument",
+  "@redux-devtools/remote-redux-devtools",
+  "@storybook/react",
+  "@storybook/react-native",
+  "@storybook/addon-actions",
+  "@storybook/addon-links",
+  "json-server",
+  "miragejs",
+  "@faker-js/faker",
+  "msw",
+  "eruda",
+  "vconsole",
+  "react-developer-tools",
+  "react-render-tracker",
+  "why-did-you-render",
+  "@welldone-software/why-did-you-render",
+  "use-what-changed",
+  "mobx-react-devtools",
+  "mobx-devtools",
+  "@tanstack/react-query-devtools",
+  "react-devtools-core",
+  "react-refresh",
+];
+function findBundledDevPackages(report, _devOnlyPackages) {
+  const packages = report.packages;
+  const modules = report.modules;
+  const matches = /* @__PURE__ */ new Set();
+  const matchedModules = [];
+  for (const pkg of packages)
+    if (
+      _devOnlyPackages.includes(pkg?.name) &&
+      Number(pkg?.sizeInBytes ?? 0) > 1e3
+    )
+      matches.add(`${pkg.name}@${pkg.version}`);
+  for (const module of modules) {
+    const modulePath = module?.path;
+    if (typeof modulePath !== "string") continue;
+    for (const pkgName of _devOnlyPackages)
+      if (
+        modulePath.includes(`/node_modules/${pkgName}/`) ||
+        modulePath.endsWith(`/node_modules/${pkgName}`)
+      ) {
+        const pkgVersion = packages.find(
+          (pkg) => pkg?.name === pkgName,
+        )?.version;
+        matches.add(pkgVersion ? `${pkgName}@${pkgVersion}` : pkgName);
+        matchedModules.push(module);
+      }
+  }
+  return {
+    names: Array.from(matches),
+    modules: matchedModules,
+  };
+}
+const recommendation$12 = {
+  id: "dev-only-packages-in-production-bundle",
+  title: "Remove dev-only packages from production bundle",
+  check: (report) => {
+    const { names: bundledDevPackages, modules } = findBundledDevPackages(
+      report,
+      isVersionGte(getReactNativeVersion(report.packages), "0.74.0")
+        ? [...devOnlyPackages, ...rn74PlusDevOnlyPackages]
+        : devOnlyPackages,
+    );
+    if (bundledDevPackages.length === 0) return null;
+    return {
+      message: `Detected dev-only packages in the production bundle: ${bundledDevPackages.join(", ")}. 
+
+Move debug-only imports/usage behind \`__DEV__\` checks so Metro can exclude them from release builds, see example below:
+
+\`\`\`js
+// Init dev-only packages conditionally
+if (__DEV__) {
+  const { whyDidYouRender } = require('@welldone-software/why-did-you-render');
+  whyDidYouRender(React, { trackAllPureComponents: true });
+}
+
+// Or PropTypes
+if (__DEV__) {
+  const PropTypes = require('prop-types');
+  Calendar.propTypes = { minDate: PropTypes.string };
+}
+\`\`\`
+      `,
+      packages: bundledDevPackages,
+      docsUrl: "https://reactnative.dev/docs/global-__DEV__",
+      ...getModulesSavings(modules),
+    };
+  },
+};
+//#endregion
+//#region ../shared/src/recommendations/duplicate-packages.ts
+const cliPackageName = "react-native-bundle-discovery-cli";
+const recommendation$11 = {
+  id: "duplicate-packages",
+  title: "Deduplicate repeated packages in the bundle",
+  check(report) {
+    const duplicateGroups = getPackageGroups(report, "size").filter(
+      (group) => group.entries.length > 1,
+    );
+    if (duplicateGroups.length === 0) return null;
+    return duplicateGroups.map((group) => {
+      const { name, entries } = group;
+      const versions = Array.from(
+        new Set(
+          entries.map(
+            (entry) => `${entry.name}@${entry.version} (${entry.path})`,
+          ),
+        ),
+      );
+      const packages = `${name === "lodash (please use only one)" ? "lodash" : name} x${entries.length}:\n             - ${versions.join("\n             - ")}`;
+      const hasDotLodash = entries.some((e) => e.name.startsWith("lodash."));
+      const hasESLodash = entries.some((e) => e.name === "lodash-es");
+      const hasSimpleLodash = entries.some((e) => e.name === "lodash");
+      const hasUnderscore = entries.some((e) => e.name === "underscore");
+      const hasRamda = entries.some((e) => e.name === "ramda");
+      const [kept, ...otherEntries] = [...entries].sort(
+        (a, b) => b.sizeInBytes - a.sizeInBytes,
+      );
+      const savings = getPackagesSavings(
+        report,
+        otherEntries.filter(
+          (entry) => entry.absolutePath !== kept.absolutePath,
+        ),
+      );
+      const message = [
+        hasDotLodash &&
+          hasSimpleLodash &&
+          "You can simply use `lodash/*` imports and remove `lodash.*` packages",
+        hasESLodash &&
+          hasSimpleLodash &&
+          "You don't need two copies of `lodash` and `lodash-es`! Just use one",
+        (hasSimpleLodash || hasESLodash || hasDotLodash) &&
+          hasUnderscore &&
+          "You have both `underscore` and `lodash` in your project. Consider using only one library to reduce bundle size.",
+        (hasSimpleLodash || hasESLodash || hasDotLodash) &&
+          hasRamda &&
+          "You have both `ramda` and `lodash` in your project. Consider using only one library to reduce bundle size.",
+      ]
+        .filter(Boolean)
+        .join("; ");
+      if (name === "lodash (please use only one)")
+        return {
+          packages,
+          message: `${message}
+
+Or you can use \`patch-package\` to remove usage of specific package, example lodash: 
+\`\`\`diff
+-const get = require('lodash.get');
++const get = require('lodash/get');
+\`\`\``,
+          docsUrl: null,
+          ...savings,
+        };
+      return {
+        packages,
+        message: `Found ${duplicateGroups.length} duplicate packages. 
+
+Align versions or use dependency \`overrides\` (npm) / \`resolutions\` (yarn) to keep a single copy per package.
+
+To see more use the next command: "${cliPackageName} packages <file>"`,
+        docsUrl: [
+          "https://docs.npmjs.com/cli/v10/configuring-npm/package-json#overrides",
+          "https://classic.yarnpkg.com/lang/en/docs/selective-version-resolutions/",
+        ],
+        ...savings,
+      };
+    });
+  },
+};
+//#endregion
+//#region ../shared/src/recommendations/linear-gradient.ts
+const recommendation$10 = {
+  id: "linear-gradient-vs-background-image",
+  title:
+    "Replace third-party linear gradient libraries with built-in backgroundImage",
+  check(report) {
+    const packages = report.packages;
+    const gradientPkgs = packages.filter(
+      (pkg) =>
+        pkg?.name === "react-native-linear-gradient" ||
+        pkg?.name === "expo-linear-gradient",
+    );
+    if (gradientPkgs.length === 0) return null;
+    const reactNativeVersion = getReactNativeVersion(packages);
+    if (!reactNativeVersion || !isVersionGte(reactNativeVersion, "0.76.0"))
+      return null;
+    const isStableBackgroundImage = isVersionGte(reactNativeVersion, "0.87.0");
+    const backgroundImageProp = isStableBackgroundImage
+      ? "backgroundImage"
+      : "experimental_backgroundImage";
+    const docsAnchor = isStableBackgroundImage
+      ? "backgroundimage"
+      : "experimental_backgroundimage";
+    return {
+      message: `React Native ships built-in \`linear-gradient()\` support (starting React Native 0.76.x+).
+You can remove ${gradientPkgs.map((e) => e.name).join(", ")} 
+and migrate to a simple View with a \`${backgroundImageProp}\` style prop.`,
+      packages: [
+        ...gradientPkgs.map((e) => `${e.name}@${e.version}`),
+        `react-native@${reactNativeVersion}`,
+      ],
+      docsUrl: `https://reactnative.dev/docs/${formatRnVersionToDocsFormat(reactNativeVersion)}/view-style-props#${docsAnchor}`,
+      ...getPackagesSavings(report, gradientPkgs),
+    };
+  },
+};
+//#endregion
+//#region ../shared/src/recommendations/outdated-packages.ts
+const MAX_AGE_YEARS = 4;
+const MS_PER_YEAR = 315576e5;
+function findOutdatedPackages(report, now = Date.now()) {
+  const matches = /* @__PURE__ */ new Map();
+  for (const pkg of report.packages) {
+    const metadata = pkg?.metadata;
+    if (!metadata || metadata.isLatest || metadata.deprecated) continue;
+    const createdAt = Date.parse(metadata.createdAt);
+    if (Number.isNaN(createdAt)) continue;
+    const ageInYears = (now - createdAt) / MS_PER_YEAR;
+    if (ageInYears < MAX_AGE_YEARS) continue;
+    const id = `${pkg.name}@${pkg.version}`;
+    if (!matches.has(id))
+      matches.set(id, {
+        id,
+        createdAt: metadata.createdAt,
+        ageInYears,
+        latestVersion: metadata.latestVersion ?? null,
+      });
+  }
+  return Array.from(matches.values()).sort(
+    (a, b) => b.ageInYears - a.ageInYears,
+  );
+}
+const recommendation$9 = {
+  id: "outdated-packages",
+  title: "Update outdated packages",
+  check: (report) => {
+    const outdatedPackages = findOutdatedPackages(report);
+    if (outdatedPackages.length === 0) return null;
+    const details = outdatedPackages
+      .map(({ id, createdAt, ageInYears, latestVersion }) => {
+        return ` - ${id} (${`published ${createdAt.slice(0, 10)}, ${ageInYears.toFixed(1)} years ago`}${latestVersion ? `, latest: ${latestVersion}` : ""})`;
+      })
+      .join("\n");
+    return {
+      message: `Detected ${outdatedPackages.length} outdated package(s) in the bundle:
+${details}
+
+Old package versions miss bug fixes, performance and bundle size improvements, and may contain known security issues.
+Upgrade them to the latest version or consider a maintained alternative.
+`,
+      packages: outdatedPackages.map(({ id }) => id),
+    };
+  },
+};
+//#endregion
+//#region ../shared/src/recommendations/package-json-files.ts
+function findBundledDependencyPackageJsonFiles(report) {
+  return report.modules.filter((module) =>
+    module?.path?.endsWith("package.json"),
+  );
+}
+const recommendation$8 = {
+  id: "bundled-package-json-files",
+  title: "Avoid bundling dependency package.json files",
+  check: (report) => {
+    const packageJsonFiles = findBundledDependencyPackageJsonFiles(report);
+    if (packageJsonFiles.length === 0) return null;
+    const sample = packageJsonFiles
+      .slice(0, 3)
+      .map((module) => module.path)
+      .join("\n - ");
+    return {
+      message: `Detected ${packageJsonFiles.length} dependency package.json file(s) in the bundle.
+They are often used to get only the package \`version/name\` but all other fields are not needed in the bundle.
+Remove package.json imports from app code and dependencies (use a \`patch-packages\` for node_modules if needed).
+Example paths:\n - ${sample}
+`,
+      packages: [],
+      docsUrl: null,
+      ...getModulesSavings(packageJsonFiles),
+    };
+  },
+};
+//#endregion
+//#region ../shared/src/recommendations/radial-gradient.ts
+const recommendation$7 = {
+  id: "radial-gradient-vs-background-image",
+  title:
+    "Replace third-party radial gradient libraries with built-in backgroundImage",
+  check(report) {
+    const packages = report.packages;
+    const gradientPkgs = packages.filter(
+      (pkg) =>
+        pkg?.name === "react-native-radial-gradient" ||
+        pkg?.name === "expo-radial-gradient",
+    );
+    if (gradientPkgs.length === 0) return null;
+    const reactNativeVersion = getReactNativeVersion(packages);
+    if (!reactNativeVersion || !isVersionGte(reactNativeVersion, "0.80.0"))
+      return null;
+    const isStableBackgroundImage = isVersionGte(reactNativeVersion, "0.87.0");
+    const backgroundImageProp = isStableBackgroundImage
+      ? "backgroundImage"
+      : "experimental_backgroundImage";
+    const docsAnchor = isStableBackgroundImage
+      ? "backgroundimage"
+      : "experimental_backgroundimage";
+    return {
+      message: `React Native ships built-in \`radial-gradient()\` support (starting React Native 0.80.x+).
+You can remove ${gradientPkgs.map((e) => e.name).join(", ")} 
+and migrate to a simple View with a \`${backgroundImageProp}\` style prop.`,
+      packages: [
+        ...gradientPkgs.map((e) => `${e.name}@${e.version}`),
+        `react-native@${reactNativeVersion}`,
+      ],
+      docsUrl: `https://reactnative.dev/docs/${formatRnVersionToDocsFormat(reactNativeVersion)}/view-style-props#${docsAnchor}`,
+      ...getPackagesSavings(report, gradientPkgs),
+    };
+  },
+};
+//#endregion
+//#region ../shared/src/recommendations/rn-inline-plugin.ts
+const TARGET_MODULE_PATH =
+  "react-native/Libraries/Components/Pressable/useAndroidRippleForView.js";
+const ANDROID_PLATFORM_CHECK_PATTERN = /['"]android['"]===\w\.default\.OS/;
+const DOCS_URL = "https://github.com/react/react-native/pull/57848";
+const SAVED_BYTES = {
+  ios: Math.round(18186.24),
+  android: Math.round(20080.64),
+};
+function findAffectedModules(report) {
+  return report.modules.find((module) => {
+    return (
+      module?.path?.includes(TARGET_MODULE_PATH) &&
+      ANDROID_PLATFORM_CHECK_PATTERN.test(module?.output?.code ?? "")
+    );
+  });
+}
+const recommendation$6 = {
+  id: "rn-inline-platform-plugin",
+  title: "Remove platform-specific dead code from production bundle",
+  check: (report) => {
+    const packages = report.packages;
+    const reactNativeVersion = getReactNativeVersion(packages);
+    if (
+      isVersionGte(reactNativeVersion, "0.88.0") ||
+      !isVersionGte(reactNativeVersion, "0.85.0")
+    )
+      return null;
+    const affectedModule = findAffectedModules(report);
+    if (!affectedModule) return null;
+    return {
+      message: `Detected dead code for ${report?.transformOptions?.platform === "android" ? "iOS" : "Android"} platform. 
+
+You can save bundle size by removing that code as ${report?.transformOptions?.platform === "android" ? "iOS" : "Android"} code won't be executed on ${report?.transformOptions?.platform === "android" ? "Android" : "iOS"} platform.
+
+🍏 iOS: -17.76 KB
+🤖 Android: -19.61 KB
+
+To fix the issue you can bump \`@react-native/babel-preset\` to \`0.88.x\` or \`rc\` (if \`0.88.x\` not released yet).`,
+      packages: ["@react-native/babel-preset"],
+      docsUrl: DOCS_URL,
+      sizeInBytes: SAVED_BYTES[report?.transformOptions?.platform],
+      modules: [affectedModule.path],
+    };
+  },
+};
+//#endregion
+//#region ../shared/src/recommendations/rn-issue-abort-controller.ts
+const recommendation$5 = {
+  id: "rn-issue-abort-controller-polyfill",
+  title: "Remove abort-controller polyfill on React Native 0.87+",
+  check: (report) => {
+    const packages = report.packages;
+    const abortControllerNames = [
+      "abort-controller",
+      "abort-controller-x",
+      "abort-controller-es5",
+      "abortcontroller-polyfill",
+      "@chainsafe/abort-controller",
+    ];
+    const abortControllerPkgs = packages.filter((pkg) =>
+      abortControllerNames.includes(pkg?.name),
+    );
+    if (abortControllerPkgs.length === 0) return null;
+    const reactNativeVersion = getReactNativeVersion(packages);
+    if (!isVersionGte(reactNativeVersion, "0.87.0")) return null;
+    return {
+      message: `React Native 0.87.x+ includes built-in AbortController / AbortSignal support, 
+so you can remove the \`${abortControllerPkgs.map((pkg) => pkg.name).join(", ")}\` polyfill(s) from the bundle.`,
+      packages: [
+        ...abortControllerPkgs.map((pkg) => `${pkg.name}@${pkg.version}`),
+        `react-native@${reactNativeVersion}`,
+      ],
+      docsUrl:
+        "https://github.com/react/react-native/commit/6f3375a140b10cffe9bed3dd72a017ece97bbbba",
+      ...getPackagesSavings(report, abortControllerPkgs),
+    };
+  },
+};
+//#endregion
+//#region ../shared/src/recommendations/rn-issue-babel-runtime.ts
+const babelRuntimeInlineCode = [
+  "function _interopRequireWildcard(",
+  "function _callSuper(",
+  "function _isNativeReflectConstruct(",
+  "Boolean.prototype.valueOf.call(Reflect.construct(Boolean",
+  "Object.defineProperty)&&Object.getOwnPropertyDescriptor(",
+];
+function hasBabelRuntimeInlineCode(code) {
+  return babelRuntimeInlineCode.some((chunk) => code.includes(chunk));
+}
+function hasInlinedBabelRuntimeHelpers(module) {
+  const outputCode = module?.output?.code;
+  const sourceCode = module?.source?.code;
+  if (typeof outputCode !== "string" || typeof sourceCode !== "string")
+    return false;
+  return (
+    hasBabelRuntimeInlineCode(outputCode) &&
+    !hasBabelRuntimeInlineCode(sourceCode)
+  );
+}
+const recommendation$4 = {
+  id: "rn-issue-babel-runtime-inline-helpers",
+  title: "Enable Babel runtime helpers deduplication",
+  check: (report) => {
+    const inlinedHelpersModules = report.modules.filter(
+      hasInlinedBabelRuntimeHelpers,
+    );
+    if (inlinedHelpersModules.length === 0) return null;
+    const babelRuntimeVersion = report?.packages?.find(
+      (pkg) => pkg?.name === "@babel/runtime",
+    )?.version;
+    const runtimeVersionForConfig = babelRuntimeVersion ?? "x.x.x";
+    return {
+      message: `Bundle contains inlined Babel runtime helpers in ${inlinedHelpersModules.length} module(s).
+
+To fix the issue, add the \`enableBabelRuntime\` option to your Babel config, 
+where value is \`@babel/runtime\` version installed in your project:
+
+\`\`\`js
+// babel.config.js
+module.exports = {
+  presets: [
+    [
+      'module:@react-native/babel-preset', 
+      { enableBabelRuntime: '${runtimeVersionForConfig}' }
+    ],
+  ],
+};
+\`\`\``,
+      packages: babelRuntimeVersion
+        ? [`@babel/runtime@${babelRuntimeVersion}`]
+        : [],
+      docsUrl: "https://github.com/react/react-native/issues/57123",
+      modules: inlinedHelpersModules.map((module) => module.path),
+    };
+  },
+};
+//#endregion
+//#region ../shared/src/recommendations/rn-issue-hermesv1-profile.ts
+const filesToCheck = [
+  "react-native/Libraries/Blob/File.js",
+  "react-native/Libraries/Utilities/PixelRatio.js",
+];
+const recommendation$3 = {
+  id: "rn-issue-hermes-transform-profile",
+  title: "Prefer hermes-stable transform profile for React Native 0.84+",
+  check: (report) => {
+    const reactNativeVersion = getReactNativeVersion(report?.packages);
+    if (!isVersionGte(reactNativeVersion, "0.85.0")) return null;
+    if (
+      report.modules.some(
+        (module) =>
+          filesToCheck.some((file) => module?.path?.endsWith(file)) &&
+          module?.output?.code?.includes("class "),
+      )
+    )
+      return null;
+    return {
+      message: `Hermes V1 is enabled, but Babel is targeting ES5 because it uses the default transform profile.
+
+To fix the issue, you can set the \`unstable_transformProfile\` option to \`hermes-stable\` in your Babel config:
+
+\`\`\`js
+// babel.config.js
+module.exports = {
+  presets: [
+    [
+      'module:@react-native/babel-preset',
+      { unstable_transformProfile: 'hermes-stable' },
+    ],
+  ],
+};
+\`\`\``,
+      packages: [`react-native@${reactNativeVersion}`],
+      docsUrl: [
+        "https://reactnative.dev/blog/2026/02/11/react-native-0.84",
+        "https://github.com/react/react-native/issues/57174",
+      ],
+    };
+  },
+};
+//#endregion
+//#region ../shared/src/recommendations/rn-issue-promise-polyfill.ts
+const deadCode = "react-native/Libraries/Promise.js";
+const promiseTryWithResolversEntries = [
+  "promise.try",
+  "promise-try",
+  "core-js/es/promise/try",
+  "promise.withresolvers",
+  "core-js/es/promise/with-resolvers",
+];
+const promiseAnyAllSettledEntries = [
+  "promise.any",
+  "promise-any-polyfill",
+  "core-js/es/promise/any",
+  "promise.allsettled",
+  "core-js/es/promise/all-settled",
+];
+function findMatchingPromisePolyfills(report, entries) {
+  const packages = report.packages;
+  const modules = report.modules;
+  const matches = /* @__PURE__ */ new Set();
+  const matchedModules = [];
+  const entriesCoreJs = entries.filter((entry) => entry.startsWith("core-js/"));
+  const entriesNonCoreJs = entries.filter(
+    (entry) => !entry.startsWith("core-js/"),
+  );
+  packages.forEach((pkg) => {
+    if (entriesNonCoreJs.includes(pkg?.name)) {
+      matches.add(pkg.name);
+      matchedModules.push(...getPackageModules(report, pkg));
+    }
+  });
+  modules.forEach((module) => {
+    if (entriesCoreJs.some((entry) => module?.path?.includes(entry))) {
+      matches.add(module.path);
+      matchedModules.push(module);
+    }
+  });
+  return {
+    names: Array.from(matches),
+    modules: matchedModules,
+  };
+}
+const recommendation$2 = {
+  id: "rn-issue-promise-polyfill",
+  title: "Remove Promise polyfills",
+  check: (report) => {
+    if (report.kind === "webpack") return null;
+    const packages = report.packages;
+    const modules = report.modules;
+    const reactNativeVersion = getReactNativeVersion(packages);
+    const deadPromiseModules = modules.filter((module) =>
+      module?.path?.includes(deadCode),
+    );
+    const hasDeadPromiseModule = deadPromiseModules.length > 0;
+    const removablePolyfills = [];
+    const removableModules = [...deadPromiseModules];
+    const entriesToCheck = [
+      isVersionGte(reactNativeVersion, "0.86.0") &&
+        promiseTryWithResolversEntries,
+      isVersionGte(reactNativeVersion, "0.75.0") && promiseAnyAllSettledEntries,
+    ];
+    for (const entries of entriesToCheck)
+      if (entries) {
+        const found = findMatchingPromisePolyfills(report, entries);
+        removablePolyfills.push(...found.names);
+        removableModules.push(...found.modules);
+      }
+    const uniquePolyfills = Array.from(new Set(removablePolyfills));
+    if (!hasDeadPromiseModule && uniquePolyfills.length === 0) return null;
+    const messageParts = [];
+    if (hasDeadPromiseModule)
+      messageParts.push(`Bundle contains \`react-native/Libraries/Promise.js\`. 
+This file is dead code because Hermes already provides Promise out of the box. 
+You can update 'metro.config.js' to remove this file from the bundle:
+
+\`\`\`js
+const { createResolveRequest } = require('react-native-bundle-discovery');
+const resolveRequest = createResolveRequest({ removePromisePolyfill: true });
+
+const config = {
+  resolver: { resolveRequest },
+};
+\`\`\``);
+    if (uniquePolyfills.length > 0)
+      messageParts.push(`Bundle also includes Promise polyfill modules/packages that Hermes already supports natively.
+Consider removing: ${uniquePolyfills.join(", ")}.`);
+    return {
+      message: messageParts.join("\n\n"),
+      packages: reactNativeVersion
+        ? [`react-native@${reactNativeVersion}`]
+        : [],
+      docsUrl: [
+        "https://github.com/react/react-native/issues/57702",
+        "https://github.com/react/react-native/pull/57215",
+      ],
+      ...getModulesSavings(removableModules),
+    };
+  },
+};
+//#endregion
+//#region ../shared/src/recommendations/worklets-bundle-mode.ts
+const BUNDLE_MODE_MODULES_PATH =
+  "node_modules/react-native-worklets/.worklets/";
+const recommendation$1 = {
+  id: "worklets-bundle-mode",
+  title: "Enable Bundle Mode in react-native-worklets",
+  check: (report) => {
+    const packages = report.packages;
+    const workletsPkg = packages.find(
+      (pkg) =>
+        pkg?.name === "react-native-worklets" &&
+        isVersionGte(pkg.version, "0.10.0"),
+    );
+    if (!workletsPkg) return null;
+    const reactNativeVersion = getReactNativeVersion(packages);
+    if (!isVersionGte(reactNativeVersion, "0.82.4")) return null;
+    if (
+      report.modules.some((module) =>
+        module?.path?.includes(BUNDLE_MODE_MODULES_PATH),
+      )
+    )
+      return null;
+    return {
+      message: `\`react-native-worklets\` 0.10.x+ supports Bundle Mode, which gives worklets access to the entire JavaScript bundle.
+Third-party libraries can be used in worklets without patching, and worklets benefit from pre-compiled bytecode instead of runtime evaluation.
+Consider enabling Bundle Mode (it will become the default way of using worklets in the future).
+More details: https://x.com/tell_me_mur/status/2105190960363880647`,
+      packages: [
+        `${workletsPkg.name}@${workletsPkg.version}`,
+        `react-native@${reactNativeVersion}`,
+      ],
+      docsUrl:
+        "https://docs.swmansion.com/react-native-worklets/docs/bundleMode/",
+    };
+  },
+};
+//#endregion
+//#region ../shared/src/recommendations/wrong-platform-files.ts
+const OTHER_PLATFORM = {
+  ios: "android",
+  android: "ios",
+};
+const PLATFORM_CHECK_PATTERN = /is[-_]?(android|ios)/gi;
+function findWrongPlatformFiles(report, otherPlatform) {
+  return report.modules.filter((module) =>
+    module.path
+      .replace(`${report.rootFolder}/`, "")
+      .replace(PLATFORM_CHECK_PATTERN, "")
+      .includes(otherPlatform),
+  );
+}
+//#endregion
+//#region ../shared/src/recommendations/index.ts
+const recommendations = [
+  recommendation$10,
+  recommendation$7,
+  recommendation$11,
+  recommendation$5,
+  recommendation$4,
+  recommendation$3,
+  recommendation$6,
+  recommendation$2,
+  recommendation$12,
+  recommendation$8,
+  recommendation$13,
+  recommendation$14,
+  recommendation$9,
+  recommendation$1,
+  {
+    id: "wrong-platform-files",
+    title: "Exclude other platform files from the bundle",
+    check: (report) => {
+      const platform = report?.transformOptions?.platform;
+      const otherPlatform = OTHER_PLATFORM[platform];
+      if (!otherPlatform) return null;
+      const wrongFiles = findWrongPlatformFiles(report, otherPlatform);
+      if (wrongFiles.length === 0) return null;
+      const sample = wrongFiles
+        .slice(0, 5)
+        .map((module) => module.path.replace(`${report.rootFolder}/`, ""))
+        .join("\n - ");
+      return {
+        message: `Detected ${wrongFiles.length} file(s) with "${otherPlatform}" in the path in the ${platform} bundle.
+These files are likely not used on ${platform} and can be excluded to save bundle size.
+Example paths:\n - ${sample}`,
+        packages: [],
+        docsUrl: null,
+        ...getModulesSavings(wrongFiles),
+      };
+    },
+  },
+];
+function collectRecommendations(report) {
+  return recommendations.flatMap((recommendation) => {
+    const finding = recommendation.check(report);
+    if (!finding) return [];
+    return (Array.isArray(finding) ? finding : [finding]).map((f) => {
+      return {
+        id: recommendation.id,
+        title: recommendation.title,
+        ...f,
+      };
+    });
+  });
+}
+function withRecommendations(report) {
+  return Object.assign(report, {
+    recommendations:
+      report.transformOptions?.dev === false
+        ? collectRecommendations(prepareReport({ ...report }, "", true))
+        : null,
+  });
+}
+//#endregion
+Object.defineProperty(exports, "isEsbuildMetafilePath", {
+  enumerable: true,
+  get: function () {
+    return isEsbuildMetafilePath;
+  },
+});
+Object.defineProperty(exports, "isRsdoctorReportPath", {
+  enumerable: true,
+  get: function () {
+    return isRsdoctorReportPath;
+  },
+});
+Object.defineProperty(exports, "transformEsbuildMetafile", {
+  enumerable: true,
+  get: function () {
+    return transformEsbuildMetafile;
+  },
+});
+Object.defineProperty(exports, "transformRSDoctorData", {
+  enumerable: true,
+  get: function () {
+    return transformRSDoctorData;
+  },
+});
+Object.defineProperty(exports, "withComparison", {
+  enumerable: true,
+  get: function () {
+    return withComparison;
+  },
+});
+Object.defineProperty(exports, "withRecommendations", {
+  enumerable: true,
+  get: function () {
+    return withRecommendations;
+  },
+});