@granite-js/mpack 0.0.0-dev-20250725013859

package/dist/vendors/metro/src/ModuleGraph/node-haste/ModuleCache.js

@@ -0,0 +1,43 @@
+"use strict";
+const Module = require("./Module");
+const Package = require("./Package");
+module.exports = class ModuleCache {
+  _getClosestPackage;
+  getTransformedFile;
+  modules;
+  packages;
+  constructor(getClosestPackage, getTransformedFile) {
+    this._getClosestPackage = getClosestPackage;
+    this.getTransformedFile = getTransformedFile;
+    this.modules = /* @__PURE__ */ new Map();
+    this.packages = /* @__PURE__ */ new Map();
+  }
+  getModule(path) {
+    const normalizedPath = path.startsWith("//") ? path.substr(1) : path;
+    let m = this.modules.get(normalizedPath);
+    if (!m) {
+      m = new Module(normalizedPath, this, this.getTransformedFile(normalizedPath));
+      this.modules.set(normalizedPath, m);
+    }
+    return m;
+  }
+  getPackage(path) {
+    let p = this.packages.get(path);
+    if (!p) {
+      p = new Package(path, this.getPackageData(path));
+      this.packages.set(path, p);
+    }
+    return p;
+  }
+  getPackageData(path) {
+    const pkg = this.getTransformedFile(path).package;
+    if (!pkg) {
+      throw new Error(`"${path}" does not exist`);
+    }
+    return pkg;
+  }
+  getPackageOf(filePath) {
+    const candidate = this._getClosestPackage(filePath);
+    return candidate != null ? this.getPackage(candidate) : null;
+  }
+};

package/dist/vendors/metro/src/ModuleGraph/node-haste/Package.js

@@ -0,0 +1,81 @@
+"use strict";
+const nullthrows = require("nullthrows");
+const path = require("path");
+module.exports = class Package {
+  data;
+  path;
+  root;
+  type;
+  constructor(packagePath, data) {
+    this.data = data;
+    this.path = packagePath;
+    this.root = path.dirname(packagePath);
+    this.type = "Package";
+  }
+  getMain() {
+    const replacements = getReplacements(this.data);
+    if (typeof replacements === "string") {
+      return path.join(this.root, replacements);
+    }
+    let main = getMain(this.data);
+    if (replacements && typeof replacements === "object") {
+      main = replacements[main] || replacements[main + ".js"] || replacements[main + ".json"] || replacements[main.replace(/(\.js|\.json)$/, "")] || main;
+    }
+    return path.join(this.root, main);
+  }
+  getName() {
+    return nullthrows(this.data.name);
+  }
+  isHaste() {
+    return !!this.data.name;
+  }
+  redirectRequire(name) {
+    const replacements = getReplacements(this.data);
+    if (!replacements || typeof replacements !== "object") {
+      return name;
+    }
+    if (!path.isAbsolute(name)) {
+      const replacement = replacements[name];
+      return replacement === false ? false : replacement || name;
+    }
+    let relPath = "./" + path.relative(this.root, name);
+    if (path.sep !== "/") {
+      relPath = relPath.replace(new RegExp("\\" + path.sep, "g"), "/");
+    }
+    let redirect = replacements[relPath];
+    if (redirect == null) {
+      redirect = replacements[relPath + ".js"];
+      if (redirect == null) {
+        redirect = replacements[relPath + ".json"];
+      }
+    }
+    if (redirect === false) {
+      return false;
+    }
+    if (redirect) {
+      return path.join(this.root, redirect);
+    }
+    return name;
+  }
+};
+function getMain(pkg) {
+  return pkg.main || "index";
+}
+function getReplacements(pkg) {
+  let rn = pkg["react-native"];
+  let browser = pkg.browser;
+  if (rn == null) {
+    return browser;
+  }
+  if (browser == null) {
+    return rn;
+  }
+  const main = getMain(pkg);
+  if (typeof rn !== "object") {
+    rn = { [main]: rn };
+  }
+  if (typeof browser !== "object") {
+    browser = { [main]: browser };
+  }
+  return { ...browser, ...rn };
+}

package/dist/vendors/metro/src/ModuleGraph/node-haste/node-haste.flow.js

@@ -0,0 +1 @@
+"use strict";

package/dist/vendors/metro/src/ModuleGraph/node-haste/node-haste.js

@@ -0,0 +1,127 @@
+"use strict";
+var import_metro_file_map = require("metro-file-map");
+const { ModuleResolver } = require("../../node-haste/DependencyGraph/ModuleResolution");
+const parsePlatformFilePath = require("../../node-haste/lib/parsePlatformFilePath");
+const HasteFS = require("./HasteFS");
+const Module = require("./Module");
+const ModuleCache = require("./ModuleCache");
+const defaults = require("../../../../metro-config/src/defaults/defaults");
+const path = require("path");
+const NATIVE_PLATFORM = "native";
+const GENERIC_PLATFORM = "g";
+const PACKAGE_JSON = path.sep + "package.json";
+const NULL_MODULE = {
+  path: "/",
+  getPackage() {
+  },
+  isHaste() {
+    throw new Error("not implemented");
+  },
+  getName() {
+    throw new Error("not implemented");
+  }
+};
+const NODE_MODULES = path.sep + "node_modules" + path.sep;
+const isNodeModules = (file) => file.includes(NODE_MODULES);
+const createModuleMap = ({ files, moduleCache, sourceExts, additionalExts, platforms }) => {
+  const platformSet = new Set((platforms ?? defaults.platforms).concat([NATIVE_PLATFORM]));
+  const map = /* @__PURE__ */ new Map();
+  files.forEach((filePath) => {
+    if (isNodeModules(filePath)) {
+      return;
+    }
+    let id;
+    let module2;
+    const fileExt = path.extname(filePath).substr(1);
+    if (filePath.endsWith(PACKAGE_JSON)) {
+      module2 = moduleCache.getPackage(filePath);
+      id = module2.data.name;
+    } else if (sourceExts.has(fileExt) || additionalExts.has(fileExt)) {
+      module2 = moduleCache.getModule(filePath);
+      id = module2.name;
+    }
+    if (!(id && module2 && module2.isHaste())) {
+      return;
+    }
+    const mapModule = map.get(id) || /* @__PURE__ */ Object.create(null);
+    const platform = parsePlatformFilePath(filePath, platformSet).platform || GENERIC_PLATFORM;
+    const existingModule = mapModule[platform];
+    mapModule[platform] = [filePath, module2.type === "Package" ? 1 : 0];
+    if (existingModule && existingModule[0] !== filePath) {
+      throw new Error(
+        [
+          "@providesModule naming collision:",
+          `  Duplicate module name: \`${id}\``,
+          `  Paths: \`${filePath}\` collides with \`${existingModule[0]}\``,
+          "",
+          "This error is caused by a @providesModule declaration with the same name across two different files."
+        ].join("\n")
+      );
+    }
+    map.set(id, mapModule);
+  });
+  return map;
+};
+exports.createResolveFn = function(options) {
+  const {
+    assetExts,
+    assetResolutions,
+    extraNodeModules,
+    transformedFiles,
+    sourceExts,
+    additionalExts,
+    platform,
+    platforms
+  } = options;
+  const files = Object.keys(transformedFiles);
+  function getTransformedFile(path2) {
+    const result = transformedFiles[path2];
+    if (!result) {
+      throw new Error(`"${path2} does not exist`);
+    }
+    return result;
+  }
+  const hasteFS = new HasteFS(files);
+  const moduleCache = new ModuleCache((filePath) => hasteFS.closest(filePath, "package.json"), getTransformedFile);
+  const assetExtensions = new Set(assetExts.map((asset) => "." + asset));
+  const isAssetFile = (file) => assetExtensions.has(path.extname(file));
+  const moduleResolver = new ModuleResolver({
+    dirExists: (filePath) => hasteFS.dirExists(filePath),
+    disableHierarchicalLookup: options.disableHierarchicalLookup,
+    doesFileExist: (filePath) => hasteFS.exists(filePath),
+    emptyModulePath: options.emptyModulePath,
+    extraNodeModules,
+    isAssetFile,
+    mainFields: options.mainFields,
+    moduleCache,
+    moduleMap: new import_metro_file_map.ModuleMap({
+      duplicates: /* @__PURE__ */ new Map(),
+      map: createModuleMap({
+        files,
+        moduleCache,
+        sourceExts: new Set(sourceExts),
+        additionalExts: new Set(additionalExts),
+        platforms
+      }),
+      mocks: /* @__PURE__ */ new Map(),
+      rootDir: ""
+    }),
+    nodeModulesPaths: options.nodeModulesPaths,
+    preferNativePlatform: true,
+    projectRoot: "",
+    resolveAsset: (dirPath, assetName, extension) => {
+      const basePath = dirPath + path.sep + assetName;
+      const assets = [
+        basePath + extension,
+        ...assetResolutions.map((resolution) => basePath + "@" + resolution + "x" + extension)
+      ].filter((candidate) => hasteFS.exists(candidate));
+      return assets.length ? assets : null;
+    },
+    resolveRequest: options.resolveRequest,
+    sourceExts
+  });
+  return (id, sourcePath) => {
+    const from = sourcePath != null ? new Module(sourcePath, moduleCache, getTransformedFile(sourcePath)) : NULL_MODULE;
+    return moduleResolver.resolveDependency(from, id, true, platform, options.resolverOptions).path;
+  };
+};

package/dist/vendors/metro/src/ModuleGraph/output/indexed-ram-bundle.js

@@ -0,0 +1,71 @@
+"use strict";
+const { createRamBundleGroups } = require("../../Bundler/util");
+const { buildTableAndContents, createModuleGroups } = require("../../shared/output/RamBundle/as-indexed-file");
+const buildSourcemapWithMetadata = require("../../shared/output/RamBundle/buildSourcemapWithMetadata.js");
+const { getModuleCodeAndMap, partition, toModuleTransport } = require("./util");
+const invariant = require("invariant");
+function asIndexedRamBundle({
+  dependencyMapReservedName,
+  filename,
+  globalPrefix,
+  idsForPath,
+  modules,
+  preloadedModules,
+  ramGroupHeads,
+  requireCalls
+}) {
+  const idForPath = (x) => idsForPath(x).moduleId;
+  const [startup, deferred] = partition(modules, preloadedModules);
+  const startupModules = [...startup, ...requireCalls];
+  const deferredModules = deferred.map(
+    (m) => toModuleTransport(m, idsForPath, { dependencyMapReservedName, globalPrefix })
+  );
+  for (const m of deferredModules) {
+    invariant(
+      m.id >= 0,
+      `A script (non-module) cannot be part of the deferred modules of a RAM bundle (\`${m.sourcePath}\`, id=${m.id})`
+    );
+  }
+  const ramGroups = createRamBundleGroups(ramGroupHeads || [], deferredModules, subtree);
+  const moduleGroups = createModuleGroups(ramGroups, deferredModules);
+  const tableAndContents = buildTableAndContents(
+    startupModules.map(
+      (m) => getModuleCodeAndMap(m, idForPath, {
+        dependencyMapReservedName,
+        enableIDInlining: true,
+        globalPrefix
+      }).moduleCode
+    ).join("\n"),
+    deferredModules,
+    moduleGroups,
+    "utf8"
+  );
+  return {
+    code: Buffer.concat(tableAndContents),
+    map: buildSourcemapWithMetadata({
+      fixWrapperOffset: false,
+      lazyModules: deferredModules,
+      moduleGroups,
+      startupModules: startupModules.map(
+        (m) => toModuleTransport(m, idsForPath, {
+          dependencyMapReservedName,
+          globalPrefix
+        })
+      )
+    })
+  };
+}
+function* subtree(moduleTransport, moduleTransportsByPath, seen = /* @__PURE__ */ new Set()) {
+  seen.add(moduleTransport.id);
+  for (const { path } of moduleTransport.dependencies) {
+    const dependency = moduleTransportsByPath.get(path);
+    if (dependency && !seen.has(dependency.id)) {
+      yield dependency.id;
+      yield* subtree(dependency, moduleTransportsByPath, seen);
+    }
+  }
+}
+function createBuilder(preloadedModules, ramGroupHeads) {
+  return (x) => asIndexedRamBundle({ ...x, preloadedModules, ramGroupHeads });
+}
+exports.createBuilder = createBuilder;

package/dist/vendors/metro/src/ModuleGraph/output/multiple-files-ram-bundle.js

@@ -0,0 +1,53 @@
+"use strict";
+const buildSourcemapWithMetadata = require("../../shared/output/RamBundle/buildSourcemapWithMetadata.js");
+const MAGIC_UNBUNDLE_NUMBER = require("../../shared/output/RamBundle/magic-number");
+const { getModuleCodeAndMap, partition, toModuleTransport } = require("./util");
+const path = require("path");
+const MAGIC_UNBUNDLE_FILENAME = "UNBUNDLE";
+const JS_MODULES = "js-modules";
+function asMultipleFilesRamBundle({
+  dependencyMapReservedName,
+  filename,
+  globalPrefix,
+  idsForPath,
+  modules,
+  requireCalls,
+  preloadedModules
+}) {
+  const idForPath = (x) => idsForPath(x).moduleId;
+  const [startup, deferred] = partition(modules, preloadedModules);
+  const startupModules = [...startup, ...requireCalls];
+  const deferredModules = deferred.map(
+    (m) => toModuleTransport(m, idsForPath, { dependencyMapReservedName, globalPrefix })
+  );
+  const magicFileContents = Buffer.alloc(4);
+  const code = startupModules.map(
+    (m) => getModuleCodeAndMap(m, idForPath, {
+      dependencyMapReservedName,
+      enableIDInlining: true,
+      globalPrefix
+    }).moduleCode
+  ).join("\n");
+  const extraFiles = /* @__PURE__ */ new Map();
+  deferredModules.forEach((deferredModule) => {
+    extraFiles.set(path.join(JS_MODULES, deferredModule.id + ".js"), deferredModule.code);
+  });
+  magicFileContents.writeUInt32LE(MAGIC_UNBUNDLE_NUMBER, 0);
+  extraFiles.set(path.join(JS_MODULES, MAGIC_UNBUNDLE_FILENAME), magicFileContents);
+  const map = buildSourcemapWithMetadata({
+    fixWrapperOffset: false,
+    lazyModules: deferredModules,
+    moduleGroups: null,
+    startupModules: startupModules.map(
+      (m) => toModuleTransport(m, idsForPath, {
+        dependencyMapReservedName,
+        globalPrefix
+      })
+    )
+  });
+  return { code, extraFiles, map };
+}
+function createBuilder(preloadedModules, ramGroupHeads) {
+  return (x) => asMultipleFilesRamBundle({ ...x, preloadedModules, ramGroupHeads });
+}
+exports.createBuilder = createBuilder;

package/dist/vendors/metro/src/ModuleGraph/output/plain-bundle.js

@@ -0,0 +1,36 @@
+"use strict";
+const meta = require("../../shared/output/meta");
+const { concat, getModuleCodeAndMap } = require("./util");
+const { BundleBuilder } = require("metro-source-map");
+function asPlainBundle({
+  dependencyMapReservedName,
+  filename,
+  globalPrefix,
+  idsForPath,
+  modules,
+  requireCalls,
+  sourceMapPath,
+  enableIDInlining
+}) {
+  const builder = new BundleBuilder(filename);
+  const modIdForPath = (x) => idsForPath(x).moduleId;
+  for (const module2 of concat(modules, requireCalls)) {
+    const { moduleCode, moduleMap } = getModuleCodeAndMap(module2, modIdForPath, {
+      dependencyMapReservedName,
+      enableIDInlining,
+      globalPrefix
+    });
+    builder.append(moduleCode + "\n", moduleMap);
+  }
+  if (sourceMapPath) {
+    builder.append(`//# sourceMappingURL=${sourceMapPath}`);
+  }
+  const code = builder.getCode();
+  const map = builder.getMap();
+  return {
+    code,
+    extraFiles: [[`${filename}.meta`, meta(code)]],
+    map
+  };
+}
+module.exports = asPlainBundle;

package/dist/vendors/metro/src/ModuleGraph/output/reverse-dependency-map-references.js

@@ -0,0 +1,53 @@
+"use strict";
+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 (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_invariant = __toESM(require("invariant"));
+var import_nullthrows = __toESM(require("nullthrows"));
+function reverseDependencyMapReferences({ types: t }) {
+  return {
+    visitor: {
+      CallExpression(path, state) {
+        const { node } = path;
+        if (node.callee.name === `${state.opts.globalPrefix}__d`) {
+          const lastArg = node.arguments[0].params.slice(-1)[0];
+          const depMapName = lastArg && lastArg.name;
+          if (depMapName == null) {
+            return;
+          }
+          const body = path.get("arguments.0.body");
+          (0, import_invariant.default)(!Array.isArray(body), "meetro: Expected `body` to be a single path.");
+          const scope = body.scope;
+          const binding = (0, import_nullthrows.default)(scope.getBinding(depMapName));
+          binding.referencePaths.forEach(({ parentPath }) => {
+            const memberNode = parentPath?.node;
+            if (memberNode != null && memberNode.type === "MemberExpression" && memberNode.property.type === "NumericLiteral") {
+              const numericLiteral = t.numericLiteral(state.opts.dependencyIds[memberNode.property.value]);
+              (0, import_nullthrows.default)(parentPath).replaceWith(numericLiteral);
+            }
+          });
+        }
+      }
+    }
+  };
+}
+module.exports = reverseDependencyMapReferences;

package/dist/vendors/metro/src/ModuleGraph/output/util.js

@@ -0,0 +1,168 @@
+"use strict";
+const virtualModule = require("../module").virtual;
+const generate = require("../worker/generate");
+const mergeSourceMaps = require("../worker/mergeSourceMaps");
+const reverseDependencyMapReferences = require("./reverse-dependency-map-references");
+const { parseSync, transformFromAstSync } = require("@babel/core");
+const { passthroughSyntaxPlugins } = require("metro-react-native-babel-preset");
+const { addParamsToDefineCall } = require("metro-transform-plugins");
+const nullthrows = require("nullthrows");
+function addModuleIdsToModuleWrapper(module2, idForPath) {
+  const { dependencies, file } = module2;
+  const { code } = file;
+  const fileId = idForPath(file);
+  const paramsToAdd = [fileId];
+  if (dependencies.length) {
+    paramsToAdd.push(dependencies.map(idForPath));
+  }
+  return addParamsToDefineCall(code, ...paramsToAdd);
+}
+exports.addModuleIdsToModuleWrapper = addModuleIdsToModuleWrapper;
+function isTypeScriptSource(fileName) {
+  return !!fileName && fileName.endsWith(".ts");
+}
+function isTSXSource(fileName) {
+  return !!fileName && fileName.endsWith(".tsx");
+}
+function inlineModuleIds(module2, idForPath, { dependencyMapReservedName, globalPrefix, ignoreMissingDependencyMapReference = false, hermesParser = false }) {
+  const { dependencies, file } = module2;
+  const { code, map, path } = file;
+  const fileId = idForPath(file);
+  const dependencyIds = dependencies.map(idForPath);
+  if (!dependencyIds.length) {
+    return { fileId, moduleCode: code, moduleMap: map };
+  }
+  if (dependencyMapReservedName != null) {
+    if (!code.includes(dependencyMapReservedName)) {
+      if (ignoreMissingDependencyMapReference) {
+        return { fileId, moduleCode: code, moduleMap: map };
+      }
+      throw new Error(
+        `Module has dependencies but does not use the preconfigured dependency map name '${dependencyMapReservedName}': ${file.path}
+This is an internal error in Metro.`
+      );
+    }
+    const WS = "[	 ]*";
+    const depMapReferenceRegex = new RegExp(
+      escapeRegex(dependencyMapReservedName) + `${WS}\\[${WS}([0-9]+)${WS}\\]`,
+      "g"
+    );
+    const inlinedCode = code.replace(depMapReferenceRegex, (match, depIndex) => {
+      const idStr = dependencyIds[Number.parseInt(depIndex, 10)].toString();
+      if (idStr.length > match.length) {
+        throw new Error(
+          `Module ID doesn't fit in available space; add ${idStr.length - match.length} more characters to 'dependencyMapReservedName'.`
+        );
+      }
+      return idStr.padEnd(match.length);
+    });
+    return {
+      fileId,
+      moduleCode: inlinedCode,
+      moduleMap: map
+    };
+  }
+  const babelConfig = {
+    ast: true,
+    babelrc: false,
+    browserslistConfigFile: false,
+    code: false,
+    configFile: false,
+    plugins: [...passthroughSyntaxPlugins, [reverseDependencyMapReferences, { dependencyIds, globalPrefix }]]
+  };
+  const sourceAst = isTypeScriptSource(path) || isTSXSource(path) || !hermesParser ? parseSync(code, babelConfig) : require("hermes-parser").parse(code, {
+    babel: true,
+    // $FlowFixMe[prop-missing]
+    sourceType: babelConfig.sourceType
+  });
+  const ast = nullthrows(transformFromAstSync(sourceAst, code, babelConfig).ast);
+  const { code: generatedCode, map: generatedMap } = generate(ast, path, "");
+  return {
+    fileId,
+    moduleCode: generatedCode,
+    moduleMap: map && generatedMap && mergeSourceMaps(path, map, generatedMap)
+  };
+}
+function inlineModuleIdsAndAddParamsToDefineCall(module2, idForPath, options) {
+  const { fileId, moduleCode, moduleMap } = inlineModuleIds(module2, idForPath, options);
+  return { moduleCode: addParamsToDefineCall(moduleCode, fileId), moduleMap };
+}
+exports.inlineModuleIds = inlineModuleIds;
+exports.inlineModuleIdsAndAddParamsToDefineCall = inlineModuleIdsAndAddParamsToDefineCall;
+function escapeRegex(str) {
+  return str.replace(/([.?*+^$[\]\\(){}|-])/g, "\\$1");
+}
+function getModuleCodeAndMap(module2, idForPath, options) {
+  const { file } = module2;
+  let moduleCode, moduleMap;
+  if (file.type !== "module") {
+    moduleCode = file.code;
+    moduleMap = file.map;
+  } else if (!options.enableIDInlining) {
+    moduleCode = addModuleIdsToModuleWrapper(module2, idForPath);
+    moduleMap = file.map;
+  } else {
+    ({ moduleCode, moduleMap } = inlineModuleIdsAndAddParamsToDefineCall(module2, idForPath, {
+      dependencyMapReservedName: options.dependencyMapReservedName,
+      globalPrefix: options.globalPrefix
+    }));
+  }
+  if (moduleMap && moduleMap.sources) {
+    const x_facebook_sources = [];
+    if (moduleMap.sources.length >= 1) {
+      x_facebook_sources.push([module2.file.functionMap]);
+    }
+    moduleMap = { ...moduleMap, x_facebook_sources };
+  }
+  return { moduleCode, moduleMap };
+}
+exports.getModuleCodeAndMap = getModuleCodeAndMap;
+exports.concat = function* concat(...iterables) {
+  for (const it of iterables) {
+    yield* it;
+  }
+};
+exports.createIdForPathFn = () => {
+  const seen = /* @__PURE__ */ new Map();
+  let next = 0;
+  return ({ path }) => {
+    let id = seen.get(path);
+    if (id == null) {
+      id = next++;
+      seen.set(path, id);
+    }
+    return id;
+  };
+};
+exports.requireCallsTo = function* (modules, idForPath, getRunModuleStatement) {
+  for (const module2 of modules) {
+    const id = idForPath(module2.file);
+    yield virtualModule(getRunModuleStatement(id), `/<generated>/require-${id}.js`);
+  }
+};
+exports.partition = (modules, preloadedModules) => {
+  const startup = [];
+  const deferred = [];
+  for (const module2 of modules) {
+    (preloadedModules.has(module2.file.path) ? startup : deferred).push(module2);
+  }
+  return [startup, deferred];
+};
+function toModuleTransport(module2, idsForPath, { dependencyMapReservedName, globalPrefix }) {
+  const { dependencies, file } = module2;
+  const { moduleCode, moduleMap } = getModuleCodeAndMap(module2, (x) => idsForPath(x).moduleId, {
+    dependencyMapReservedName,
+    enableIDInlining: true,
+    globalPrefix
+  });
+  return {
+    code: moduleCode,
+    dependencies,
+    // ID is required but we provide an invalid one for "script"s.
+    id: file.type === "module" ? nullthrows(idsForPath(file).localId) : -1,
+    map: moduleMap,
+    name: file.path,
+    sourcePath: file.path
+  };
+}
+exports.toModuleTransport = toModuleTransport;

package/dist/vendors/metro/src/ModuleGraph/silent-console.js

@@ -0,0 +1,5 @@
+"use strict";
+const { Console } = require("console");
+const { Writable } = require("stream");
+const write = (_, __, callback) => callback();
+module.exports = new Console(new Writable({ write, writev: write }));

package/dist/vendors/metro/src/ModuleGraph/types.flow.js

@@ -0,0 +1 @@
+"use strict";