@granite-js/mpack 0.0.1

package/dist/vendors/metro/src/Bundler/util.js

@@ -0,0 +1,131 @@
+"use strict";
+const babylon = require("@babel/parser");
+const template = require("@babel/template").default;
+const babelTypes = require("@babel/types");
+const nullthrows = require("nullthrows");
+const assetPropertyBlockList = /* @__PURE__ */ new Set(["files", "fileSystemLocation", "path"]);
+function generateAssetCodeFileAst(assetRegistryPath, assetDescriptor) {
+  const properDescriptor = filterObject(assetDescriptor, assetPropertyBlockList);
+  const descriptorAst = babylon.parseExpression(JSON.stringify(properDescriptor));
+  const t = babelTypes;
+  const buildRequire = template.statement(`
+    module.exports = require(ASSET_REGISTRY_PATH).registerAsset(DESCRIPTOR_AST)
+  `);
+  return t.file(
+    t.program([
+      buildRequire({
+        ASSET_REGISTRY_PATH: t.stringLiteral(assetRegistryPath),
+        DESCRIPTOR_AST: descriptorAst
+      })
+    ])
+  );
+}
+function generateRemoteAssetCodeFileAst(assetUtilsPath, assetDescriptor, remoteServer, remoteFileMap) {
+  const t = babelTypes;
+  const file = remoteFileMap[assetDescriptor.fileSystemLocation];
+  const descriptor = file && file[assetDescriptor.name];
+  const data = {};
+  if (!descriptor) {
+    return null;
+  }
+  for (const scale in descriptor) {
+    data[+scale] = descriptor[+scale].handle;
+  }
+  const astData = babylon.parseExpression(JSON.stringify(data));
+  const URI = t.stringLiteral(remoteServer);
+  const WIDTH = t.numericLiteral(nullthrows(assetDescriptor.width));
+  const HEIGHT = t.numericLiteral(nullthrows(assetDescriptor.height));
+  const buildRequire = template.program(`
+    const {pickScale, getUrlCacheBreaker}= require(ASSET_UTILS_PATH);
+    module.exports = {
+      "width": WIDTH,
+      "height": HEIGHT,
+      "uri": URI + OBJECT_AST[pickScale(SCALE_ARRAY)] + getUrlCacheBreaker()
+    };
+  `);
+  return t.file(
+    buildRequire({
+      WIDTH,
+      HEIGHT,
+      URI,
+      OBJECT_AST: astData,
+      ASSET_UTILS_PATH: t.stringLiteral(assetUtilsPath),
+      SCALE_ARRAY: t.arrayExpression(
+        Object.keys(descriptor).map(Number).sort((a, b) => a - b).map((scale) => t.numericLiteral(scale))
+      )
+    })
+  );
+}
+function isAssetTypeAnImage(type) {
+  return ["png", "jpg", "jpeg", "bmp", "gif", "webp", "psd", "svg", "tiff"].indexOf(type) !== -1;
+}
+function filterObject(object, blockList) {
+  const copied = { ...object };
+  for (const key of blockList) {
+    delete copied[key];
+  }
+  return copied;
+}
+function createRamBundleGroups(ramGroups, groupableModules, subtree) {
+  const byPath = /* @__PURE__ */ new Map();
+  const byId = /* @__PURE__ */ new Map();
+  groupableModules.forEach((m) => {
+    byPath.set(m.sourcePath, m);
+    byId.set(m.id, m.sourcePath);
+  });
+  const result = new Map(
+    ramGroups.map((modulePath) => {
+      const root = byPath.get(modulePath);
+      if (root == null) {
+        throw Error(`Group root ${modulePath} is not part of the bundle`);
+      }
+      return [
+        root.id,
+        // `subtree` yields the IDs of all transitive dependencies of a module
+        new Set(subtree(root, byPath))
+      ];
+    })
+  );
+  if (ramGroups.length > 1) {
+    const all = new ArrayMap();
+    for (const [parent, children] of result) {
+      for (const module2 of children) {
+        all.get(module2).push(parent);
+      }
+    }
+    const doubles = filter(all, ([, parents]) => parents.length > 1);
+    for (const [moduleId, parents] of doubles) {
+      const parentNames = parents.map(byId.get, byId);
+      const lastName = parentNames.pop();
+      throw new Error(
+        `Module ${byId.get(moduleId) || moduleId} belongs to groups ${parentNames.join(", ")}, and ${String(
+          lastName
+        )}. Ensure that each module is only part of one group.`
+      );
+    }
+  }
+  return result;
+}
+function* filter(iterator, predicate) {
+  for (const value of iterator) {
+    if (predicate(value)) {
+      yield value;
+    }
+  }
+}
+class ArrayMap extends Map {
+  get(key) {
+    let array = super.get(key);
+    if (!array) {
+      array = [];
+      this.set(key, array);
+    }
+    return array;
+  }
+}
+module.exports = {
+  createRamBundleGroups,
+  generateAssetCodeFileAst,
+  generateRemoteAssetCodeFileAst,
+  isAssetTypeAnImage
+};

package/dist/vendors/metro/src/Bundler.js

@@ -0,0 +1,43 @@
+"use strict";
+const Transformer = require("./DeltaBundler/Transformer");
+const DependencyGraph = require("./node-haste/DependencyGraph");
+class Bundler {
+  _depGraph;
+  _readyPromise;
+  _transformer;
+  constructor(config, options) {
+    this._depGraph = new DependencyGraph(config, options);
+    this._readyPromise = this._depGraph.ready().then(() => {
+      config.reporter.update({ type: "transformer_load_started" });
+      this._transformer = new Transformer(config, (...args) => this._depGraph.getSha1(...args));
+      config.reporter.update({ type: "transformer_load_done" });
+    }).catch((error) => {
+      console.error("Failed to construct transformer: ", error);
+      config.reporter.update({
+        type: "transformer_load_failed",
+        error
+      });
+    });
+  }
+  getWatcher() {
+    return this._depGraph.getWatcher();
+  }
+  async end() {
+    await this._depGraph.ready();
+    this._transformer.end();
+    this._depGraph.end();
+  }
+  async getDependencyGraph() {
+    await this._depGraph.ready();
+    return this._depGraph;
+  }
+  async transformFile(filePath, transformOptions, fileBuffer) {
+    await this._depGraph.ready();
+    return this._transformer.transformFile(filePath, transformOptions, fileBuffer);
+  }
+  // Waits for the bundler to become ready.
+  async ready() {
+    await this._readyPromise;
+  }
+}
+module.exports = Bundler;

package/dist/vendors/metro/src/DeltaBundler/DeltaCalculator.js

@@ -0,0 +1,176 @@
+"use strict";
+var import_graphOperations = require("./graphOperations");
+const { EventEmitter } = require("events");
+class DeltaCalculator extends EventEmitter {
+  _changeEventSource;
+  _options;
+  _currentBuildPromise;
+  _deletedFiles = /* @__PURE__ */ new Set();
+  _modifiedFiles = /* @__PURE__ */ new Set();
+  _addedFiles = /* @__PURE__ */ new Set();
+  _graph;
+  constructor(entryPoints, changeEventSource, options) {
+    super();
+    this._options = options;
+    this._changeEventSource = changeEventSource;
+    this._graph = (0, import_graphOperations.createGraph)({
+      entryPoints,
+      transformOptions: this._options.transformOptions
+    });
+    this._changeEventSource.on("change", this._handleMultipleFileChanges);
+  }
+  /**
+   * Stops listening for file changes and clears all the caches.
+   */
+  end() {
+    this._changeEventSource.removeListener("change", this._handleMultipleFileChanges);
+    this.removeAllListeners();
+    this._graph = (0, import_graphOperations.createGraph)({
+      entryPoints: this._graph.entryPoints,
+      transformOptions: this._options.transformOptions
+    });
+    this._modifiedFiles = /* @__PURE__ */ new Set();
+    this._deletedFiles = /* @__PURE__ */ new Set();
+    this._addedFiles = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Main method to calculate the delta of modules. It returns a DeltaResult,
+   * which contain the modified/added modules and the removed modules.
+   */
+  async getDelta({ reset, shallow }) {
+    if (this._currentBuildPromise) {
+      await this._currentBuildPromise;
+    }
+    const modifiedFiles = this._modifiedFiles;
+    this._modifiedFiles = /* @__PURE__ */ new Set();
+    const deletedFiles = this._deletedFiles;
+    this._deletedFiles = /* @__PURE__ */ new Set();
+    const addedFiles = this._addedFiles;
+    this._addedFiles = /* @__PURE__ */ new Set();
+    this._currentBuildPromise = this._getChangedDependencies(modifiedFiles, deletedFiles, addedFiles);
+    let result;
+    const numDependencies = this._graph.dependencies.size;
+    try {
+      result = await this._currentBuildPromise;
+    } catch (error) {
+      modifiedFiles.forEach((file) => this._modifiedFiles.add(file));
+      deletedFiles.forEach((file) => this._deletedFiles.add(file));
+      addedFiles.forEach((file) => this._addedFiles.add(file));
+      if (this._graph.dependencies.size !== numDependencies) {
+        this._graph.dependencies = /* @__PURE__ */ new Map();
+      }
+      throw error;
+    } finally {
+      this._currentBuildPromise = null;
+    }
+    if (reset) {
+      (0, import_graphOperations.reorderGraph)(this._graph, { shallow });
+      return {
+        added: this._graph.dependencies,
+        modified: /* @__PURE__ */ new Map(),
+        deleted: /* @__PURE__ */ new Set(),
+        reset: true
+      };
+    }
+    return result;
+  }
+  /**
+   * Returns the graph with all the dependencies. Each module contains the
+   * needed information to do the traversing (dependencies, inverseDependencies)
+   * plus some metadata.
+   */
+  getGraph() {
+    return this._graph;
+  }
+  /* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
+   * LTI update could not be added via codemod */
+  _handleMultipleFileChanges = ({ eventsQueue }) => {
+    eventsQueue.forEach(this._handleFileChange);
+  };
+  /**
+   * Handles a single file change. To avoid doing any work before it's needed,
+   * the listener only stores the modified file, which will then be used later
+   * when the delta needs to be calculated.
+   */
+  _handleFileChange = ({ type, filePath }) => {
+    let state;
+    if (this._deletedFiles.has(filePath)) {
+      state = "deleted";
+    } else if (this._modifiedFiles.has(filePath)) {
+      state = "modified";
+    } else if (this._addedFiles.has(filePath)) {
+      state = "added";
+    }
+    let nextState;
+    if (type === "delete") {
+      nextState = "deleted";
+    } else if (type === "add") {
+      nextState = state === "deleted" ? "modified" : "added";
+    } else {
+      nextState = state === "added" ? "added" : "modified";
+    }
+    switch (nextState) {
+      case "deleted":
+        this._deletedFiles.add(filePath);
+        this._modifiedFiles.delete(filePath);
+        this._addedFiles.delete(filePath);
+        break;
+      case "added":
+        this._addedFiles.add(filePath);
+        this._deletedFiles.delete(filePath);
+        this._modifiedFiles.delete(filePath);
+        break;
+      case "modified":
+        this._modifiedFiles.add(filePath);
+        this._deletedFiles.delete(filePath);
+        this._addedFiles.delete(filePath);
+        break;
+      default:
+        nextState;
+    }
+    this.emit("change");
+  };
+  async _getChangedDependencies(modifiedFiles, deletedFiles, addedFiles) {
+    if (!this._graph.dependencies.size) {
+      const { added: added2 } = await (0, import_graphOperations.initialTraverseDependencies)(this._graph, this._options);
+      return {
+        added: added2,
+        modified: /* @__PURE__ */ new Map(),
+        deleted: /* @__PURE__ */ new Set(),
+        reset: true
+      };
+    }
+    deletedFiles.forEach((filePath) => {
+      const module2 = this._graph.dependencies.get(filePath);
+      if (module2) {
+        module2.inverseDependencies.forEach((path) => {
+          if (!deletedFiles.has(path)) {
+            modifiedFiles.add(path);
+          }
+        });
+      }
+    });
+    if (this._options.unstable_allowRequireContext) {
+      addedFiles.forEach((filePath) => {
+        (0, import_graphOperations.markModifiedContextModules)(this._graph, filePath, modifiedFiles);
+      });
+    }
+    const modifiedDependencies = Array.from(modifiedFiles).filter((filePath) => this._graph.dependencies.has(filePath));
+    if (modifiedDependencies.length === 0) {
+      return {
+        added: /* @__PURE__ */ new Map(),
+        modified: /* @__PURE__ */ new Map(),
+        deleted: /* @__PURE__ */ new Set(),
+        reset: false
+      };
+    }
+    const { added, modified, deleted } = await (0, import_graphOperations.traverseDependencies)(modifiedDependencies, this._graph, this._options);
+    return {
+      added,
+      modified,
+      deleted,
+      reset: false
+    };
+  }
+}
+module.exports = DeltaCalculator;

package/dist/vendors/metro/src/DeltaBundler/Serializers/baseBytecodeBundle.js

@@ -0,0 +1,61 @@
+"use strict";
+const getAppendScripts = require("../../lib/getAppendScripts");
+const { getJsOutput } = require("./helpers/js");
+const processBytecodeModules = require("./helpers/processBytecodeModules");
+function baseBytecodeBundle(entryPoint, preModules, graph, options) {
+  for (const module2 of graph.dependencies.values()) {
+    options.createModuleId(module2.path);
+  }
+  const processModulesOptions = {
+    filter: options.processModuleFilter,
+    createModuleId: options.createModuleId,
+    dev: options.dev,
+    projectRoot: options.projectRoot
+  };
+  if (options.modulesOnly) {
+    preModules = [];
+  }
+  const modules = [...graph.dependencies.values()].sort(
+    (a, b) => options.createModuleId(a.path) - options.createModuleId(b.path)
+  );
+  const { compile } = require("metro-hermes-compiler");
+  const post = processBytecodeModules(
+    getAppendScripts(entryPoint, [...preModules, ...modules], graph.importBundleNames, {
+      asyncRequireModulePath: options.asyncRequireModulePath,
+      createModuleId: options.createModuleId,
+      getRunModuleStatement: options.getRunModuleStatement,
+      inlineSourceMap: options.inlineSourceMap,
+      projectRoot: options.projectRoot,
+      runBeforeMainModule: options.runBeforeMainModule,
+      runModule: options.runModule,
+      serverRoot: options.serverRoot,
+      sourceMapUrl: options.sourceMapUrl,
+      sourceUrl: options.sourceUrl
+    }).map((module2) => {
+      return {
+        ...module2,
+        output: [
+          ...module2.output,
+          {
+            type: "bytecode/script/virtual",
+            data: {
+              bytecode: compile(getJsOutput(module2).data.code, {
+                sourceURL: module2.path
+              }).bytecode
+            }
+          }
+        ]
+      };
+    }),
+    processModulesOptions
+  ).flatMap(([module2, bytecodeBundle]) => bytecodeBundle);
+  const processedModules = processBytecodeModules([...graph.dependencies.values()], processModulesOptions).map(
+    ([module2, bytecodeBundle]) => [options.createModuleId(module2.path), bytecodeBundle]
+  );
+  return {
+    pre: processBytecodeModules(preModules, processModulesOptions).flatMap(([_, bytecodeBundle]) => bytecodeBundle),
+    post,
+    modules: processedModules
+  };
+}
+module.exports = baseBytecodeBundle;

package/dist/vendors/metro/src/DeltaBundler/Serializers/baseJSBundle.js

@@ -0,0 +1,45 @@
+"use strict";
+const getAppendScripts = require("../../lib/getAppendScripts");
+const processModules = require("./helpers/processModules");
+function baseJSBundle(entryPoint, preModules, graph, options) {
+  for (const module2 of graph.dependencies.values()) {
+    options.createModuleId(module2.path);
+  }
+  const processModulesOptions = {
+    filter: options.processModuleFilter,
+    createModuleId: options.createModuleId,
+    dev: options.dev,
+    projectRoot: options.projectRoot
+  };
+  if (options.modulesOnly) {
+    preModules = [];
+  }
+  const preCode = processModules(preModules, processModulesOptions).map(([_, code]) => code).join("\n");
+  const modules = [...graph.dependencies.values()].sort(
+    (a, b) => options.createModuleId(a.path) - options.createModuleId(b.path)
+  );
+  const postCode = processModules(
+    getAppendScripts(entryPoint, [...preModules, ...modules], graph.importBundleNames, {
+      asyncRequireModulePath: options.asyncRequireModulePath,
+      createModuleId: options.createModuleId,
+      getRunModuleStatement: options.getRunModuleStatement,
+      inlineSourceMap: options.inlineSourceMap,
+      projectRoot: options.projectRoot,
+      runBeforeMainModule: options.runBeforeMainModule,
+      runModule: options.runModule,
+      serverRoot: options.serverRoot,
+      sourceMapUrl: options.sourceMapUrl,
+      sourceUrl: options.sourceUrl
+    }),
+    processModulesOptions
+  ).map(([_, code]) => code).join("\n");
+  return {
+    pre: preCode,
+    post: postCode,
+    modules: processModules([...graph.dependencies.values()], processModulesOptions).map(([module2, code]) => [
+      options.createModuleId(module2.path),
+      code
+    ])
+  };
+}
+module.exports = baseJSBundle;

package/dist/vendors/metro/src/DeltaBundler/Serializers/getAllFiles.js

@@ -0,0 +1,30 @@
+"use strict";
+const { getAssetFiles } = require("../../Assets");
+const { getJsOutput, isJsModule } = require("./helpers/js");
+async function getAllFiles(pre, graph, options) {
+  const modules = graph.dependencies;
+  const { processModuleFilter } = options;
+  const promises = [];
+  for (const module2 of pre) {
+    if (processModuleFilter(module2)) {
+      promises.push([module2.path]);
+    }
+  }
+  for (const module2 of modules.values()) {
+    if (!isJsModule(module2) || !processModuleFilter(module2)) {
+      continue;
+    }
+    if (getJsOutput(module2).type === "js/module/asset") {
+      promises.push(getAssetFiles(module2.path, options.platform));
+    } else {
+      promises.push([module2.path]);
+    }
+  }
+  const dependencies = await Promise.all(promises);
+  const output = [];
+  for (const dependencyArray of dependencies) {
+    output.push(...dependencyArray);
+  }
+  return output;
+}
+module.exports = getAllFiles;

package/dist/vendors/metro/src/DeltaBundler/Serializers/getAssets.js

@@ -0,0 +1,23 @@
+"use strict";
+const { getAssetData } = require("../../Assets");
+const { getJsOutput, isJsModule } = require("./helpers/js");
+const path = require("path");
+async function getAssets(dependencies, options) {
+  const promises = [];
+  const { processModuleFilter } = options;
+  for (const module2 of dependencies.values()) {
+    if (isJsModule(module2) && processModuleFilter(module2) && getJsOutput(module2).type === "js/module/asset" && path.relative(options.projectRoot, module2.path) !== "package.json") {
+      promises.push(
+        getAssetData(
+          module2.path,
+          path.relative(options.projectRoot, module2.path),
+          options.assetPlugins,
+          options.platform,
+          options.publicPath
+        )
+      );
+    }
+  }
+  return await Promise.all(promises);
+}
+module.exports = getAssets;

package/dist/vendors/metro/src/DeltaBundler/Serializers/getExplodedSourceMap.js

@@ -0,0 +1,17 @@
+"use strict";
+const { getJsOutput, isJsModule } = require("./helpers/js");
+function getExplodedSourceMap(modules, options) {
+  const modulesToProcess = modules.filter(isJsModule).filter(options.processModuleFilter);
+  const result = [];
+  let firstLine1Based = 1;
+  for (const module2 of modulesToProcess) {
+    const { path } = module2;
+    const { lineCount, functionMap, map } = getJsOutput(module2).data;
+    result.push({ firstLine1Based, functionMap, path, map });
+    firstLine1Based += lineCount;
+  }
+  return result;
+}
+module.exports = {
+  getExplodedSourceMap
+};

package/dist/vendors/metro/src/DeltaBundler/Serializers/getRamBundleInfo.js

@@ -0,0 +1,87 @@
+"use strict";
+const { createRamBundleGroups } = require("../../Bundler/util");
+const getAppendScripts = require("../../lib/getAppendScripts");
+const getTransitiveDependencies = require("./helpers/getTransitiveDependencies");
+const { isJsModule, wrapModule } = require("./helpers/js");
+const { sourceMapObject } = require("./sourceMapObject");
+const nullthrows = require("nullthrows");
+const path = require("path");
+async function getRamBundleInfo(entryPoint, pre, graph, options) {
+  let modules = [...pre, ...graph.dependencies.values()];
+  modules = modules.concat(getAppendScripts(entryPoint, modules, graph.importBundleNames, options));
+  modules.forEach((module2) => options.createModuleId(module2.path));
+  const ramModules = modules.filter(isJsModule).filter(options.processModuleFilter).map((module2) => ({
+    id: options.createModuleId(module2.path),
+    code: wrapModule(module2, options),
+    map: sourceMapObject([module2], {
+      excludeSource: options.excludeSource,
+      processModuleFilter: options.processModuleFilter
+    }),
+    name: path.basename(module2.path),
+    sourcePath: module2.path,
+    source: module2.getSource().toString(),
+    type: nullthrows(module2.output.find(({ type }) => type.startsWith("js"))).type
+  }));
+  const { preloadedModules, ramGroups } = await _getRamOptions(
+    entryPoint,
+    {
+      dev: options.dev,
+      platform: options.platform
+    },
+    (filePath) => getTransitiveDependencies(filePath, graph),
+    options.getTransformOptions
+  );
+  const startupModules = [];
+  const lazyModules = [];
+  ramModules.forEach((module2) => {
+    if (preloadedModules.hasOwnProperty(module2.sourcePath)) {
+      startupModules.push(module2);
+      return;
+    }
+    if (module2.type.startsWith("js/script")) {
+      startupModules.push(module2);
+      return;
+    }
+    if (module2.type.startsWith("js/module")) {
+      lazyModules.push(module2);
+    }
+  });
+  const groups = createRamBundleGroups(ramGroups, lazyModules, (module2, dependenciesByPath) => {
+    const deps = getTransitiveDependencies(module2.sourcePath, graph);
+    const output = /* @__PURE__ */ new Set();
+    for (const dependency of deps) {
+      const module3 = dependenciesByPath.get(dependency);
+      if (module3) {
+        output.add(module3.id);
+      }
+    }
+    return output;
+  });
+  return {
+    getDependencies: (filePath) => getTransitiveDependencies(filePath, graph),
+    groups,
+    lazyModules,
+    startupModules
+  };
+}
+async function _getRamOptions(entryFile, options, getDependencies, getTransformOptions) {
+  if (getTransformOptions == null) {
+    return {
+      preloadedModules: {},
+      ramGroups: []
+    };
+  }
+  const { preloadedModules, ramGroups } = await getTransformOptions(
+    [entryFile],
+    { dev: options.dev, hot: true, platform: options.platform },
+    /* $FlowFixMe(>=0.99.0 site=react_native_fb) This comment suppresses an
+     * error found when Flow v0.99 was deployed. To see the error, delete this
+     * comment and run Flow. */
+    async (x) => Array.from(getDependencies)
+  );
+  return {
+    preloadedModules: preloadedModules || {},
+    ramGroups: ramGroups || []
+  };
+}
+module.exports = getRamBundleInfo;

package/dist/vendors/metro/src/DeltaBundler/Serializers/helpers/bytecode.js

@@ -0,0 +1,51 @@
+"use strict";
+const invariant = require("invariant");
+const path = require("path");
+function wrapModule(module2, options) {
+  const output = getBytecodeOutput(module2);
+  if (output.type.startsWith("bytecode/script")) {
+    return [output.data.bytecode];
+  }
+  const params = [
+    options.createModuleId(module2.path),
+    "[" + Array.from(module2.dependencies.values()).map((dependency) => options.createModuleId(dependency.absolutePath)).join(",") + "]"
+  ];
+  if (options.dev) {
+    params.push(JSON.stringify(path.relative(options.projectRoot, module2.path)));
+  }
+  const { compile } = require("metro-hermes-compiler");
+  const headerCode = `globalThis.$$METRO_D=[${params.join(",")}];`;
+  return [
+    compile(headerCode, {
+      sourceURL: module2.path + "-virtual.js"
+    }).bytecode,
+    output.data.bytecode
+  ];
+}
+function getBytecodeOutput(module2) {
+  const output = module2.output.filter(({ type }) => type.startsWith("bytecode/")).map(
+    (output2) => output2.data.bytecode instanceof Buffer ? output2 : (
+      // Re-create buffers after losing the Buffer instance when sending data over workers.
+      {
+        ...output2,
+        data: {
+          ...output2.data,
+          bytecode: Buffer.from(output2.data.bytecode.data)
+        }
+      }
+    )
+  );
+  invariant(
+    output.length === 1,
+    `Modules must have exactly one bytecode output, but ${module2.path} has ${output.length} bytecode outputs.`
+  );
+  return output[0];
+}
+function isBytecodeModule(module2) {
+  return module2.output.filter(({ type }) => type.startsWith("bytecode/")).length > 0;
+}
+module.exports = {
+  getBytecodeOutput,
+  isBytecodeModule,
+  wrapModule
+};

package/dist/vendors/metro/src/DeltaBundler/Serializers/helpers/getInlineSourceMappingURL.js

@@ -0,0 +1,6 @@
+"use strict";
+function getInlineSourceMappingURL(sourceMap) {
+  const base64 = Buffer.from(sourceMap).toString("base64");
+  return `data:application/json;charset=utf-8;base64,${base64}`;
+}
+module.exports = getInlineSourceMappingURL;