@granite-js/mpack 0.0.0-dev-20250725013859

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

@@ -0,0 +1,223 @@
+"use strict";
+var import_metro_file_map = require("metro-file-map");
+const canonicalize = require("../../../metro-core/src/canonicalize");
+const createHasteMap = require("./DependencyGraph/createHasteMap");
+const { ModuleResolver } = require("./DependencyGraph/ModuleResolution");
+const ModuleCache = require("./ModuleCache");
+const { EventEmitter } = require("events");
+const fs = require("fs");
+const {
+  AmbiguousModuleResolutionError,
+  Logger: { createActionStartEntry, createActionEndEntry, log },
+  PackageResolutionError
+} = require("../../../metro-core/src");
+const { InvalidPackageError } = require("metro-resolver");
+const nullthrows = require("nullthrows");
+const path = require("path");
+const isPnP = require("../isPnP");
+let pnpapi;
+if (isPnP()) {
+  pnpapi = require("pnpapi");
+}
+const { DuplicateHasteCandidatesError } = import_metro_file_map.ModuleMap;
+const NULL_PLATFORM = Symbol();
+function getOrCreateMap(map, field) {
+  let subMap = map.get(field);
+  if (!subMap) {
+    subMap = /* @__PURE__ */ new Map();
+    map.set(field, subMap);
+  }
+  return subMap;
+}
+class DependencyGraph extends EventEmitter {
+  _assetExtensions;
+  _config;
+  _haste;
+  _hasteFS;
+  _moduleCache;
+  _moduleMap;
+  _moduleResolver;
+  _resolutionCache;
+  _readyPromise;
+  constructor(config, options) {
+    super();
+    this._config = config;
+    this._assetExtensions = new Set(config.resolver.assetExts.map((asset) => "." + asset));
+    const { hasReducedPerformance, watch } = options ?? {};
+    const initializingMetroLogEntry = log(createActionStartEntry("Initializing Metro"));
+    config.reporter.update({
+      type: "dep_graph_loading",
+      hasReducedPerformance: !!hasReducedPerformance
+    });
+    const haste = createHasteMap(config, { watch });
+    haste.setMaxListeners(1e3);
+    this._haste = haste;
+    this._readyPromise = haste.build().then(({ hasteFS, moduleMap }) => {
+      log(createActionEndEntry(initializingMetroLogEntry));
+      config.reporter.update({ type: "dep_graph_loaded" });
+      this._hasteFS = hasteFS;
+      this._moduleMap = moduleMap;
+      this._haste.on("change", this._onHasteChange.bind(this));
+      this._resolutionCache = /* @__PURE__ */ new Map();
+      this._moduleCache = this._createModuleCache();
+      this._createModuleResolver();
+    });
+  }
+  // Waits for the dependency graph to become ready after initialisation.
+  // Don't read anything from the graph until this resolves.
+  async ready() {
+    await this._readyPromise;
+  }
+  // Creates the dependency graph and waits for it to become ready.
+  // @deprecated Use the constructor + ready() directly.
+  static async load(config, options) {
+    const self = new DependencyGraph(config, options);
+    await self.ready();
+    return self;
+  }
+  _getClosestPackage(filePath) {
+    const parsedPath = path.parse(filePath);
+    const root = parsedPath.root;
+    let dir = parsedPath.dir;
+    do {
+      const candidate = path.join(dir, "package.json");
+      if (this._hasteFS.exists(candidate)) {
+        return candidate;
+      }
+      dir = path.dirname(dir);
+    } while (dir !== "." && dir !== root);
+    return null;
+  }
+  /* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
+   * LTI update could not be added via codemod */
+  _onHasteChange({ eventsQueue, hasteFS, moduleMap }) {
+    this._hasteFS = hasteFS;
+    this._resolutionCache = /* @__PURE__ */ new Map();
+    this._moduleMap = moduleMap;
+    eventsQueue.forEach(({ type, filePath }) => this._moduleCache.processFileChange(type, filePath));
+    this._createModuleResolver();
+    this.emit("change");
+  }
+  _createModuleResolver() {
+    this._moduleResolver = new ModuleResolver({
+      dirExists: (filePath) => {
+        try {
+          return fs.lstatSync(filePath).isDirectory();
+        } catch (e) {
+        }
+        return false;
+      },
+      disableHierarchicalLookup: this._config.resolver.disableHierarchicalLookup,
+      doesFileExist: this._doesFileExist,
+      emptyModulePath: this._config.resolver.emptyModulePath,
+      extraNodeModules: this._config.resolver.extraNodeModules,
+      isAssetFile: (file) => this._assetExtensions.has(path.extname(file)),
+      mainFields: this._config.resolver.resolverMainFields,
+      moduleCache: this._moduleCache,
+      moduleMap: this._moduleMap,
+      nodeModulesPaths: this._config.resolver.nodeModulesPaths,
+      preferNativePlatform: true,
+      projectRoot: this._config.projectRoot,
+      resolveAsset: (dirPath, assetName, extension) => {
+        const basePath = dirPath + path.sep + assetName;
+        const assets = [
+          basePath + extension,
+          ...this._config.resolver.assetResolutions.map((resolution) => basePath + "@" + resolution + "x" + extension)
+        ].filter((candidate) => this._hasteFS.exists(candidate));
+        return assets.length ? assets : null;
+      },
+      resolveRequest: this._config.resolver.resolveRequest,
+      sourceExts: this._config.resolver.sourceExts
+    });
+  }
+  _createModuleCache() {
+    return new ModuleCache({
+      // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+      getClosestPackage: this._getClosestPackage.bind(this)
+    });
+  }
+  getSha1(filename) {
+    const splitIndex = filename.indexOf(".zip/");
+    const containerName = splitIndex !== -1 ? filename.slice(0, splitIndex + 4) : filename;
+    const realpath = fs.realpathSync(containerName);
+    const resolvedPath = (pnpapi ? pnpapi.resolveVirtual(realpath) : realpath) ?? realpath;
+    const sha1 = this._hasteFS.getSha1(resolvedPath);
+    if (!sha1) {
+      throw new ReferenceError(
+        `SHA-1 for file ${filename} (${resolvedPath}) is not computed.
+         Potential causes:
+           1) You have symlinks in your project - watchman does not follow symlinks.
+           2) Check \`blockList\` in your metro.config.js and make sure it isn't excluding the file path.`
+      );
+    }
+    return sha1;
+  }
+  getWatcher() {
+    return this._haste;
+  }
+  end() {
+    this._haste.end();
+  }
+  /** Given a search context, return a list of file paths matching the query. */
+  matchFilesWithContext(from, context) {
+    return this._hasteFS.matchFilesWithContext(from, context);
+  }
+  resolveDependency(from, to, platform, resolverOptions, { assumeFlatNodeModules } = {
+    assumeFlatNodeModules: false
+  }) {
+    const isSensitiveToOriginFolder = (
+      // Resolution is always relative to the origin folder unless we assume a flat node_modules
+      !assumeFlatNodeModules || // Path requests are resolved relative to the origin folder
+      to.includes("/") || to === "." || to === ".." || // Preserve standard assumptions under node_modules
+      from.includes(path.sep + "node_modules" + path.sep)
+    );
+    const resolverOptionsKey = JSON.stringify(resolverOptions.customResolverOptions ?? {}, canonicalize) ?? "";
+    const originKey = isSensitiveToOriginFolder ? path.dirname(from) : "";
+    const targetKey = to;
+    const platformKey = platform ?? NULL_PLATFORM;
+    const mapByResolverOptions = this._resolutionCache;
+    const mapByOrigin = getOrCreateMap(mapByResolverOptions, resolverOptionsKey);
+    const mapByTarget = getOrCreateMap(mapByOrigin, originKey);
+    const mapByPlatform = getOrCreateMap(mapByTarget, targetKey);
+    let modulePath = mapByPlatform.get(platformKey);
+    if (!modulePath) {
+      try {
+        modulePath = this._moduleResolver.resolveDependency(
+          this._moduleCache.getModule(from),
+          to,
+          true,
+          platform,
+          resolverOptions
+        ).path;
+      } catch (error) {
+        if (error instanceof DuplicateHasteCandidatesError) {
+          throw new AmbiguousModuleResolutionError(from, error);
+        }
+        if (error instanceof InvalidPackageError) {
+          throw new PackageResolutionError({
+            packageError: error,
+            originModulePath: from,
+            targetModuleName: to
+          });
+        }
+        throw error;
+      }
+    }
+    mapByPlatform.set(platformKey, modulePath);
+    return modulePath;
+  }
+  _doesFileExist = (filePath) => {
+    return this._hasteFS.exists(filePath);
+  };
+  getHasteName(filePath) {
+    const hasteName = this._hasteFS.getModuleName(filePath);
+    if (hasteName) {
+      return hasteName;
+    }
+    return path.relative(this._config.projectRoot, filePath);
+  }
+  getDependencies(filePath) {
+    return nullthrows(this._hasteFS.getDependencies(filePath));
+  }
+}
+module.exports = DependencyGraph;

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

@@ -0,0 +1,21 @@
+"use strict";
+const isAbsolutePath = require("absolute-path");
+class Module {
+  path;
+  _moduleCache;
+  _sourceCode;
+  // $FlowFixMe[missing-local-annot]
+  constructor(file, moduleCache) {
+    if (!isAbsolutePath(file)) {
+      throw new Error("Expected file to be absolute path but got " + file);
+    }
+    this.path = file;
+    this._moduleCache = moduleCache;
+  }
+  getPackage() {
+    return this._moduleCache.getPackageForModule(this);
+  }
+  invalidate() {
+  }
+}
+module.exports = Module;

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

@@ -0,0 +1,81 @@
+"use strict";
+const Module = require("./Module");
+const Package = require("./Package");
+class ModuleCache {
+  _getClosestPackage;
+  _moduleCache;
+  _packageCache;
+  // Cache for "closest package.json" queries by module path.
+  _packagePathByModulePath;
+  // The inverse of _packagePathByModulePath.
+  _modulePathsByPackagePath;
+  constructor(options) {
+    this._getClosestPackage = options.getClosestPackage;
+    this._moduleCache = /* @__PURE__ */ Object.create(null);
+    this._packageCache = /* @__PURE__ */ Object.create(null);
+    this._packagePathByModulePath = /* @__PURE__ */ Object.create(null);
+    this._modulePathsByPackagePath = /* @__PURE__ */ Object.create(null);
+  }
+  getModule(filePath) {
+    if (!this._moduleCache[filePath]) {
+      this._moduleCache[filePath] = new Module(filePath, this);
+    }
+    return this._moduleCache[filePath];
+  }
+  getPackage(filePath) {
+    if (!this._packageCache[filePath]) {
+      this._packageCache[filePath] = new Package({
+        file: filePath
+      });
+    }
+    return this._packageCache[filePath];
+  }
+  getPackageForModule(module2) {
+    return this.getPackageOf(module2.path);
+  }
+  getPackageOf(modulePath) {
+    let packagePath = this._packagePathByModulePath[modulePath];
+    if (packagePath && this._packageCache[packagePath]) {
+      return this._packageCache[packagePath];
+    }
+    packagePath = this._getClosestPackage(modulePath);
+    if (!packagePath) {
+      return null;
+    }
+    this._packagePathByModulePath[modulePath] = packagePath;
+    const modulePaths = this._modulePathsByPackagePath[packagePath] ?? /* @__PURE__ */ new Set();
+    modulePaths.add(modulePath);
+    this._modulePathsByPackagePath[packagePath] = modulePaths;
+    return this.getPackage(packagePath);
+  }
+  processFileChange(type, filePath) {
+    if (this._moduleCache[filePath]) {
+      this._moduleCache[filePath].invalidate();
+      delete this._moduleCache[filePath];
+    }
+    if (this._packageCache[filePath]) {
+      this._packageCache[filePath].invalidate();
+      delete this._packageCache[filePath];
+    }
+    if (this._packagePathByModulePath[filePath]) {
+      const packagePath = this._packagePathByModulePath[filePath];
+      delete this._packagePathByModulePath[filePath];
+      const modulePaths = this._modulePathsByPackagePath[packagePath];
+      if (modulePaths) {
+        modulePaths.delete(filePath);
+        if (modulePaths.size === 0) {
+          delete this._modulePathsByPackagePath[packagePath];
+        }
+      }
+    }
+    if (this._modulePathsByPackagePath[filePath]) {
+      const modulePaths = this._modulePathsByPackagePath[filePath];
+      for (const modulePath of modulePaths) {
+        delete this._packagePathByModulePath[modulePath];
+      }
+      modulePaths.clear();
+      delete this._modulePathsByPackagePath[filePath];
+    }
+  }
+}
+module.exports = ModuleCache;

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

@@ -0,0 +1,98 @@
+"use strict";
+const fs = require("fs");
+const path = require("path");
+class Package {
+  path;
+  _root;
+  _content;
+  constructor({ file }) {
+    this.path = path.resolve(file);
+    this._root = path.dirname(this.path);
+    this._content = null;
+  }
+  /**
+   * The `browser` field and replacement behavior is specified in
+   * https://github.com/defunctzombie/package-browser-field-spec.
+   */
+  getMain(mainFields) {
+    const json = this.read();
+    let main;
+    for (const name of mainFields) {
+      if (typeof json[name] === "string") {
+        main = json[name];
+        break;
+      }
+    }
+    if (!main) {
+      main = "index";
+    }
+    const replacements = getReplacements(json, mainFields);
+    if (replacements) {
+      const variants = [main];
+      if (main.slice(0, 2) === "./") {
+        variants.push(main.slice(2));
+      } else {
+        variants.push("./" + main);
+      }
+      for (const variant of variants) {
+        const winner = replacements[variant] || replacements[variant + ".js"] || replacements[variant + ".json"] || replacements[variant.replace(/(\.js|\.json)$/, "")];
+        if (winner) {
+          main = winner;
+          break;
+        }
+      }
+    }
+    return path.join(this._root, main);
+  }
+  invalidate() {
+    this._content = null;
+  }
+  redirectRequire(name, mainFields) {
+    const json = this.read();
+    const replacements = getReplacements(json, mainFields);
+    if (!replacements) {
+      return name;
+    }
+    if (!name.startsWith(".") && !path.isAbsolute(name)) {
+      const replacement = replacements[name];
+      return replacement === false ? false : replacement || name;
+    }
+    let relPath = "./" + path.relative(this._root, path.resolve(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;
+  }
+  read() {
+    if (this._content == null) {
+      this._content = JSON.parse(fs.readFileSync(this.path, "utf8"));
+    }
+    return this._content;
+  }
+}
+function getReplacements(pkg, mainFields) {
+  const replacements = mainFields.map((name) => {
+    if (!pkg[name] || typeof pkg[name] === "string") {
+      return null;
+    }
+    return pkg[name];
+  }).filter(Boolean);
+  if (!replacements.length) {
+    return null;
+  }
+  return Object.assign({}, ...replacements.reverse());
+}
+module.exports = Package;

package/dist/vendors/metro/src/node-haste/lib/AssetPaths.js

@@ -0,0 +1,41 @@
+"use strict";
+const parsePlatformFilePath = require("./parsePlatformFilePath");
+const path = require("path");
+const ASSET_BASE_NAME_RE = /(.+?)(@([\d.]+)x)?$/;
+function parseBaseName(baseName) {
+  const match = baseName.match(ASSET_BASE_NAME_RE);
+  if (!match) {
+    throw new Error(`invalid asset name: \`${baseName}'`);
+  }
+  const rootName = match[1];
+  if (match[3] != null) {
+    const resolution = parseFloat(match[3]);
+    if (!Number.isNaN(resolution)) {
+      return { rootName, resolution };
+    }
+  }
+  return { rootName, resolution: 1 };
+}
+function tryParse(filePath, platforms) {
+  const result = parsePlatformFilePath(filePath, platforms);
+  const { dirPath, baseName, platform, extension } = result;
+  if (extension == null) {
+    return null;
+  }
+  const { rootName, resolution } = parseBaseName(baseName);
+  return {
+    assetName: path.join(dirPath, `${rootName}.${extension}`),
+    name: rootName,
+    platform,
+    resolution,
+    type: extension
+  };
+}
+function parse(filePath, platforms) {
+  const result = tryParse(filePath, platforms);
+  if (result == null) {
+    throw new Error("invalid asset file path: `${filePath}");
+  }
+  return result;
+}
+module.exports = { parse, tryParse };

package/dist/vendors/metro/src/node-haste/lib/parsePlatformFilePath.js

@@ -0,0 +1,19 @@
+"use strict";
+const path = require("path");
+const PATH_RE = /^(.+?)(\.([^.]+))?\.([^.]+)$/;
+function parsePlatformFilePath(filePath, platforms) {
+  const dirPath = path.dirname(filePath);
+  const fileName = path.basename(filePath);
+  const match = fileName.match(PATH_RE);
+  if (!match) {
+    return { dirPath, baseName: fileName, platform: null, extension: null };
+  }
+  const extension = match[4] || null;
+  const platform = match[3] || null;
+  if (platform == null || platforms.has(platform)) {
+    return { dirPath, baseName: match[1], platform, extension };
+  }
+  const baseName = `${match[1]}.${platform}`;
+  return { dirPath, baseName, platform: null, extension };
+}
+module.exports = parsePlatformFilePath;

package/dist/vendors/metro/src/shared/output/RamBundle/as-assets.js

@@ -0,0 +1,61 @@
+"use strict";
+const relativizeSourceMapInline = require("../../../lib/relativizeSourceMap");
+const writeFile = require("../writeFile");
+const buildSourcemapWithMetadata = require("./buildSourcemapWithMetadata");
+const MAGIC_RAM_BUNDLE_NUMBER = require("./magic-number");
+const { joinModules } = require("./util");
+const writeSourceMap = require("./write-sourcemap");
+const fsPromises = require("fs").promises;
+const path = require("path");
+const MAGIC_RAM_BUNDLE_FILENAME = "UNBUNDLE";
+const MODULES_DIR = "js-modules";
+function saveAsAssets(bundle, options, log) {
+  const { bundleOutput, bundleEncoding: encoding, sourcemapOutput, sourcemapSourcesRoot } = options;
+  log("start");
+  const { startupModules, lazyModules } = bundle;
+  log("finish");
+  const startupCode = joinModules(startupModules);
+  log("Writing bundle output to:", bundleOutput);
+  const modulesDir = path.join(path.dirname(bundleOutput), MODULES_DIR);
+  const writeUnbundle = createDir(modulesDir).then(
+    // create the modules directory first
+    () => Promise.all([
+      writeModules(lazyModules, modulesDir, encoding),
+      writeFile(bundleOutput, startupCode, encoding),
+      writeMagicFlagFile(modulesDir)
+    ])
+  );
+  writeUnbundle.then(() => log("Done writing unbundle output"));
+  if (sourcemapOutput) {
+    const sourceMap = buildSourcemapWithMetadata({
+      fixWrapperOffset: true,
+      lazyModules: lazyModules.concat(),
+      moduleGroups: null,
+      startupModules: startupModules.concat()
+    });
+    if (sourcemapSourcesRoot !== void 0) {
+      relativizeSourceMapInline(sourceMap, sourcemapSourcesRoot);
+    }
+    const wroteSourceMap = writeSourceMap(sourcemapOutput, JSON.stringify(sourceMap), log);
+    return Promise.all([writeUnbundle, wroteSourceMap]);
+  } else {
+    return writeUnbundle;
+  }
+}
+function createDir(dirName) {
+  return fsPromises.mkdir(dirName, { recursive: true });
+}
+function writeModuleFile(module2, modulesDir, encoding) {
+  const { code, id } = module2;
+  return writeFile(path.join(modulesDir, id + ".js"), code, encoding);
+}
+function writeModules(modules, modulesDir, encoding) {
+  const writeFiles = modules.map((module2) => writeModuleFile(module2, modulesDir, encoding));
+  return Promise.all(writeFiles);
+}
+function writeMagicFlagFile(outputDir) {
+  const buffer = Buffer.alloc(4);
+  buffer.writeUInt32LE(MAGIC_RAM_BUNDLE_NUMBER, 0);
+  return writeFile(path.join(outputDir, MAGIC_RAM_BUNDLE_FILENAME), buffer);
+}
+module.exports = saveAsAssets;

package/dist/vendors/metro/src/shared/output/RamBundle/as-indexed-file.js

@@ -0,0 +1,115 @@
+"use strict";
+const relativizeSourceMapInline = require("../../../lib/relativizeSourceMap");
+const buildSourcemapWithMetadata = require("./buildSourcemapWithMetadata");
+const MAGIC_UNBUNDLE_FILE_HEADER = require("./magic-number");
+const { joinModules } = require("./util");
+const writeSourceMap = require("./write-sourcemap");
+const fs = require("fs");
+const SIZEOF_UINT32 = 4;
+function saveAsIndexedFile(bundle, options, log) {
+  const { bundleOutput, bundleEncoding: encoding, sourcemapOutput, sourcemapSourcesRoot } = options;
+  log("start");
+  const { startupModules, lazyModules, groups } = bundle;
+  log("finish");
+  const moduleGroups = createModuleGroups(groups, lazyModules);
+  const startupCode = joinModules(startupModules);
+  log("Writing unbundle output to:", bundleOutput);
+  const writeUnbundle = writeBuffers(
+    fs.createWriteStream(bundleOutput),
+    buildTableAndContents(startupCode, lazyModules, moduleGroups, encoding)
+  ).then(() => log("Done writing unbundle output"));
+  if (sourcemapOutput) {
+    const sourceMap = buildSourcemapWithMetadata({
+      startupModules: startupModules.concat(),
+      lazyModules: lazyModules.concat(),
+      moduleGroups,
+      fixWrapperOffset: true
+    });
+    if (sourcemapSourcesRoot !== void 0) {
+      relativizeSourceMapInline(sourceMap, sourcemapSourcesRoot);
+    }
+    const wroteSourceMap = writeSourceMap(sourcemapOutput, JSON.stringify(sourceMap), log);
+    return Promise.all([writeUnbundle, wroteSourceMap]);
+  } else {
+    return writeUnbundle;
+  }
+}
+const fileHeader = Buffer.alloc(4);
+fileHeader.writeUInt32LE(MAGIC_UNBUNDLE_FILE_HEADER, 0);
+const nullByteBuffer = Buffer.alloc(1).fill(0);
+function writeBuffers(stream, buffers) {
+  buffers.forEach((buffer) => stream.write(buffer));
+  return new Promise((resolve, reject) => {
+    stream.on("error", reject);
+    stream.on("finish", () => resolve());
+    stream.end();
+  });
+}
+function nullTerminatedBuffer(contents, encoding) {
+  return Buffer.concat([Buffer.from(contents, encoding), nullByteBuffer]);
+}
+function moduleToBuffer(id, code, encoding) {
+  return {
+    id,
+    buffer: nullTerminatedBuffer(code, encoding)
+  };
+}
+function entryOffset(n) {
+  return (2 + n * 2) * SIZEOF_UINT32;
+}
+function buildModuleTable(startupCode, moduleBuffers, moduleGroups) {
+  const moduleIds = [...moduleGroups.modulesById.keys()];
+  const maxId = moduleIds.reduce((max, id) => Math.max(max, id));
+  const numEntries = maxId + 1;
+  const table = Buffer.alloc(entryOffset(numEntries)).fill(0);
+  table.writeUInt32LE(numEntries, 0);
+  table.writeUInt32LE(startupCode.length, SIZEOF_UINT32);
+  let codeOffset = startupCode.length;
+  moduleBuffers.forEach(({ id, buffer }) => {
+    const group = moduleGroups.groups.get(id);
+    const idsInGroup = group ? [id].concat(Array.from(group)) : [id];
+    idsInGroup.forEach((moduleId) => {
+      const offset = entryOffset(moduleId);
+      table.writeUInt32LE(codeOffset, offset);
+      table.writeUInt32LE(buffer.length, offset + SIZEOF_UINT32);
+    });
+    codeOffset += buffer.length;
+  });
+  return table;
+}
+function groupCode(rootCode, moduleGroup, modulesById) {
+  if (!moduleGroup || !moduleGroup.size) {
+    return rootCode;
+  }
+  const code = [rootCode];
+  for (const id of moduleGroup) {
+    code.push((modulesById.get(id) || { code: "" }).code);
+  }
+  return code.join("\n");
+}
+function buildModuleBuffers(modules, moduleGroups, encoding) {
+  return modules.filter((m) => !moduleGroups.modulesInGroups.has(m.id)).map(
+    ({ id, code }) => moduleToBuffer(id, groupCode(code, moduleGroups.groups.get(id), moduleGroups.modulesById), encoding)
+  );
+}
+function buildTableAndContents(startupCode, modules, moduleGroups, encoding) {
+  const startupCodeBuffer = nullTerminatedBuffer(startupCode, encoding);
+  const moduleBuffers = buildModuleBuffers(modules, moduleGroups, encoding);
+  const table = buildModuleTable(startupCodeBuffer, moduleBuffers, moduleGroups);
+  return [fileHeader, table, startupCodeBuffer].concat(moduleBuffers.map(({ buffer }) => buffer));
+}
+function createModuleGroups(groups, modules) {
+  return {
+    groups,
+    modulesById: new Map(modules.map((m) => [m.id, m])),
+    modulesInGroups: new Set(concat(groups.values()))
+  };
+}
+function* concat(iterators) {
+  for (const it of iterators) {
+    yield* it;
+  }
+}
+exports.save = saveAsIndexedFile;
+exports.buildTableAndContents = buildTableAndContents;
+exports.createModuleGroups = createModuleGroups;

package/dist/vendors/metro/src/shared/output/RamBundle/buildSourcemapWithMetadata.js

@@ -0,0 +1,23 @@
+"use strict";
+const { combineSourceMaps, combineSourceMapsAddingOffsets, joinModules } = require("./util");
+module.exports = ({ fixWrapperOffset, lazyModules, moduleGroups, startupModules }) => {
+  const options = fixWrapperOffset ? { fixWrapperOffset: true } : void 0;
+  const startupModule = {
+    code: joinModules(startupModules),
+    id: Number.MIN_SAFE_INTEGER,
+    map: combineSourceMaps(startupModules, void 0, options),
+    sourcePath: ""
+  };
+  const module_paths = [];
+  startupModules.forEach((m) => {
+    module_paths[m.id] = m.sourcePath;
+  });
+  lazyModules.forEach((m) => {
+    module_paths[m.id] = m.sourcePath;
+  });
+  const map = combineSourceMapsAddingOffsets([startupModule].concat(lazyModules), module_paths, moduleGroups, options);
+  if (map.x_facebook_offsets != null) {
+    delete map.x_facebook_offsets[Number.MIN_SAFE_INTEGER];
+  }
+  return map;
+};

package/dist/vendors/metro/src/shared/output/RamBundle/magic-number.js

@@ -0,0 +1,2 @@
+"use strict";
+module.exports = 4211855845;