@granite-js/mpack 0.0.1

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;

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

@@ -0,0 +1,94 @@
+"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_countLines = __toESM(require("../../../lib/countLines"));
+const invariant = require("invariant");
+function lineToLineSourceMap(source, filename = "") {
+  const firstLine = "AAAA;";
+  const line = "AACA;";
+  return {
+    file: filename,
+    mappings: firstLine + Array((0, import_countLines.default)(source)).join(line),
+    sources: [filename],
+    names: [],
+    version: 3
+  };
+}
+const wrapperEnd = (wrappedCode) => wrappedCode.indexOf("{") + 1;
+const Section = (line, column, map) => ({
+  map,
+  offset: { line, column }
+});
+function combineSourceMaps(modules, moduleGroups, options) {
+  const sections = combineMaps(modules, null, moduleGroups, options);
+  return { sections, version: 3 };
+}
+function combineSourceMapsAddingOffsets(modules, x_metro_module_paths, moduleGroups, options) {
+  const x_facebook_offsets = [];
+  const sections = combineMaps(modules, x_facebook_offsets, moduleGroups, options);
+  return { sections, version: 3, x_facebook_offsets, x_metro_module_paths };
+}
+function combineMaps(modules, offsets, moduleGroups, options) {
+  const sections = [];
+  let line = 0;
+  modules.forEach((moduleTransport) => {
+    const { code, id, name } = moduleTransport;
+    let column = 0;
+    let group;
+    let groupLines = 0;
+    let { map } = moduleTransport;
+    if (moduleGroups && moduleGroups.modulesInGroups.has(id)) {
+      return;
+    }
+    if (offsets != null) {
+      group = moduleGroups && moduleGroups.groups.get(id);
+      if (group && moduleGroups) {
+        const { modulesById } = moduleGroups;
+        const otherModules = Array.from(group || []).map((moduleId) => modulesById.get(moduleId)).filter(Boolean);
+        otherModules.forEach((m) => {
+          groupLines += (0, import_countLines.default)(m.code);
+        });
+        map = combineSourceMaps([moduleTransport].concat(otherModules));
+      }
+      column = options && options.fixWrapperOffset ? wrapperEnd(code) : 0;
+    }
+    invariant(!Array.isArray(map), "Random Access Bundle source maps cannot be built from raw mappings");
+    sections.push(Section(line, column, map || lineToLineSourceMap(code, name)));
+    if (offsets != null && id != null) {
+      offsets[id] = line;
+      for (const moduleId of group || []) {
+        offsets[moduleId] = line;
+      }
+    }
+    line += (0, import_countLines.default)(code) + groupLines;
+  });
+  return sections;
+}
+const joinModules = (modules) => modules.map((m) => m.code).join("\n");
+module.exports = {
+  combineSourceMaps,
+  combineSourceMapsAddingOffsets,
+  countLines: import_countLines.default,
+  joinModules,
+  lineToLineSourceMap
+};

package/dist/vendors/metro/src/shared/output/RamBundle/write-sourcemap.js

@@ -0,0 +1,12 @@
+"use strict";
+const writeFile = require("../writeFile");
+function writeSourcemap(fileName, contents, log) {
+  if (!fileName) {
+    return Promise.resolve();
+  }
+  log("Writing sourcemap output to:", fileName);
+  const writeMap = writeFile(fileName, contents, null);
+  writeMap.then(() => log("Done writing sourcemap output"));
+  return writeMap;
+}
+module.exports = writeSourcemap;

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

@@ -0,0 +1,18 @@
+"use strict";
+const Server = require("../../Server");
+const asAssets = require("./RamBundle/as-assets");
+const asIndexedFile = require("./RamBundle/as-indexed-file").save;
+async function build(packagerClient, requestOptions) {
+  const options = {
+    ...Server.DEFAULT_BUNDLE_OPTIONS,
+    ...requestOptions,
+    bundleType: "ram"
+  };
+  return await packagerClient.getRamBundleInfo(options);
+}
+function save(bundle, options, log) {
+  return options.platform === "android" && !(options.indexedRamBundle === true) ? asAssets(bundle, options, log) : asIndexedFile(bundle, options, log);
+}
+exports.build = build;
+exports.save = save;
+exports.formatName = "bundle";

package/dist/vendors/metro/src/shared/output/bundle.flow.js

@@ -0,0 +1,42 @@
+"use strict";
+const relativizeSourceMapInline = require("../../lib/relativizeSourceMap");
+const Server = require("../../Server");
+const writeFile = require("./writeFile");
+function buildBundle(packagerClient, requestOptions) {
+  return packagerClient.build({
+    ...Server.DEFAULT_BUNDLE_OPTIONS,
+    ...requestOptions,
+    bundleType: "bundle"
+  });
+}
+function relativateSerializedMap(map, sourceMapSourcesRoot) {
+  const sourceMap = JSON.parse(map);
+  relativizeSourceMapInline(sourceMap, sourceMapSourcesRoot);
+  return JSON.stringify(sourceMap);
+}
+async function saveBundleAndMap(bundle, options, log) {
+  const { bundleOutput, bundleEncoding: encoding, sourcemapOutput, sourcemapSourcesRoot } = options;
+  const writeFns = [];
+  writeFns.push(async () => {
+    log("Writing bundle output to:", bundleOutput);
+    await writeFile(bundleOutput, bundle.code, encoding);
+    log("Done writing bundle output");
+  });
+  if (sourcemapOutput) {
+    let { map } = bundle;
+    if (sourcemapSourcesRoot !== void 0) {
+      log("start relativating source map");
+      map = relativateSerializedMap(map, sourcemapSourcesRoot);
+      log("finished relativating");
+    }
+    writeFns.push(async () => {
+      log("Writing sourcemap output to:", sourcemapOutput);
+      await writeFile(sourcemapOutput, map, null);
+      log("Done writing sourcemap output");
+    });
+  }
+  await Promise.all(writeFns.map((cb) => cb()));
+}
+exports.build = buildBundle;
+exports.save = saveBundleAndMap;
+exports.formatName = "bundle";

package/dist/vendors/metro/src/shared/output/bundle.js

@@ -0,0 +1,6 @@
+"use strict";
+try {
+  require("metro-babel-register").unstable_registerForMetroMonorepo();
+} catch {
+}
+module.exports = require("./bundle.flow");

package/dist/vendors/metro/src/shared/output/meta.js

@@ -0,0 +1,31 @@
+"use strict";
+const crypto = require("crypto");
+const isUTF8 = (encoding) => /^utf-?8$/i.test(encoding);
+const constantFor = (encoding) => /^ascii$/i.test(encoding) ? 1 : isUTF8(encoding) ? 2 : /^(?:utf-?16(?:le)?|ucs-?2)$/.test(encoding) ? 3 : 0;
+module.exports = function(code, encoding = "utf8") {
+  const buffer = asBuffer(code, encoding);
+  const hash = crypto.createHash("sha1");
+  hash.update(buffer);
+  const digest = hash.digest("buffer");
+  const signature = Buffer.alloc(digest.length + 1);
+  digest.copy(signature);
+  signature.writeUInt8(constantFor(tryAsciiPromotion(buffer, encoding)), signature.length - 1);
+  return signature;
+};
+function tryAsciiPromotion(buffer, encoding) {
+  if (!isUTF8(encoding)) {
+    return encoding;
+  }
+  for (let i = 0, n = buffer.length; i < n; i++) {
+    if (buffer[i] > 127) {
+      return encoding;
+    }
+  }
+  return "ascii";
+}
+function asBuffer(x, encoding) {
+  if (typeof x !== "string") {
+    return x;
+  }
+  return Buffer.from(x, encoding);
+}

package/dist/vendors/metro/src/shared/output/unbundle.js

@@ -0,0 +1,2 @@
+"use strict";
+module.exports = require("./RamBundle");

package/dist/vendors/metro/src/shared/output/writeFile.js

@@ -0,0 +1,6 @@
+"use strict";
+const denodeify = require("denodeify");
+const fs = require("fs");
+const throat = require("throat");
+const writeFile = throat(128, denodeify(fs.writeFile));
+module.exports = writeFile;

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

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

package/dist/vendors/metro-config/src/configTypes.flow.js

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