@granite-js/mpack 0.0.1

package/dist/vendors/metro/src/lib/CountingSet.js

@@ -0,0 +1,98 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var CountingSet_exports = {};
+__export(CountingSet_exports, {
+  default: () => CountingSet
+});
+module.exports = __toCommonJS(CountingSet_exports);
+class CountingSet {
+  #map = /* @__PURE__ */ new Map();
+  constructor(items) {
+    if (items) {
+      if (items instanceof CountingSet) {
+        this.#map = new Map(items.#map);
+      } else {
+        for (const item of items) {
+          this.add(item);
+        }
+      }
+    }
+  }
+  has(item) {
+    return this.#map.has(item);
+  }
+  add(item) {
+    const newCount = this.count(item) + 1;
+    this.#map.set(item, newCount);
+  }
+  delete(item) {
+    const newCount = this.count(item) - 1;
+    if (newCount <= 0) {
+      this.#map.delete(item);
+    } else {
+      this.#map.set(item, newCount);
+    }
+  }
+  keys() {
+    return this.#map.keys();
+  }
+  values() {
+    return this.#map.keys();
+  }
+  *entries() {
+    for (const item of this) {
+      yield [item, item];
+    }
+  }
+  // Iterate over unique entries
+  // $FlowIssue[unsupported-syntax]
+  [Symbol.iterator]() {
+    return this.values();
+  }
+  /*::
+  // For Flow's benefit
+  @@iterator(): Iterator<T> {
+    return this.values();
+  }
+  */
+  // Number of unique entries
+  // $FlowIssue[unsafe-getters-setters]
+  get size() {
+    return this.#map.size;
+  }
+  count(item) {
+    return this.#map.get(item) ?? 0;
+  }
+  clear() {
+    this.#map.clear();
+  }
+  forEach(callbackFn, thisArg) {
+    for (const item of this) {
+      callbackFn.call(thisArg, item, item, this);
+    }
+  }
+  // For Jest purposes. Ideally a custom serializer would be enough, but in
+  // practice there is hardcoded magic for Set in toEqual (etc) that we cannot
+  // extend to custom collection classes. Instead let's assume values are
+  // sortable ( = strings) and make this look like an array with some stable
+  // order.
+  toJSON() {
+    return [...this].sort();
+  }
+}

package/dist/vendors/metro/src/lib/JsonReporter.js

@@ -0,0 +1,21 @@
+"use strict";
+class JsonReporter {
+  _stream;
+  constructor(stream) {
+    this._stream = stream;
+  }
+  /**
+   * There is a special case for errors because they have non-enumerable fields.
+   * (Perhaps we should switch in favor of plain object?)
+   */
+  update(event) {
+    if (Object.prototype.toString.call(event.error) === "[object Error]") {
+      event = Object.assign(event, {
+        message: event.error.message,
+        stack: event.error.stack
+      });
+    }
+    this._stream.write(JSON.stringify(event) + "\n");
+  }
+}
+module.exports = JsonReporter;

package/dist/vendors/metro/src/lib/RamBundleParser.js

@@ -0,0 +1,36 @@
+"use strict";
+const MAGIC_NUMBER = require("../shared/output/RamBundle/magic-number");
+const SIZEOF_UINT32 = 4;
+const HEADER_SIZE = 3;
+class RamBundleParser {
+  _buffer;
+  _numModules;
+  _startupCodeLength;
+  _startOffset;
+  // $FlowFixMe[missing-local-annot]
+  constructor(buffer) {
+    this._buffer = buffer;
+    if (this._readPosition(0) !== MAGIC_NUMBER) {
+      throw new Error("File is not a RAM bundle file");
+    }
+    this._numModules = this._readPosition(1);
+    this._startupCodeLength = this._readPosition(2);
+    this._startOffset = (HEADER_SIZE + this._numModules * 2) * SIZEOF_UINT32;
+  }
+  _readPosition(pos) {
+    return this._buffer.readUInt32LE(pos * SIZEOF_UINT32);
+  }
+  getStartupCode() {
+    const start = this._startOffset;
+    const end = start + this._startupCodeLength - 1;
+    return this._buffer.toString("utf8", start, end);
+  }
+  getModule(id) {
+    const moduleOffset = this._readPosition(HEADER_SIZE + id * 2);
+    const moduleLength = this._readPosition(HEADER_SIZE + id * 2 + 1);
+    const start = this._startOffset + moduleOffset;
+    const end = start + moduleLength - 1;
+    return this._buffer.toString("utf8", start, end);
+  }
+}
+module.exports = RamBundleParser;

package/dist/vendors/metro/src/lib/TerminalReporter.d.ts

@@ -0,0 +1,18 @@
+type Terminal = any;
+type ReportableEvent = any;
+type TerminalReportableEvent =
+  | ReportableEvent
+  | {
+      buildID: string;
+      type: 'bundle_transform_progressed_throttled';
+      transformedFileCount: number;
+      totalFileCount: number;
+    };
+
+declare class TerminalReporter {
+  readonly terminal: Terminal;
+  constructor(terminal: Terminal);
+  update(event: TerminalReportableEvent): void;
+}
+
+export default TerminalReporter;

package/dist/vendors/metro/src/lib/TerminalReporter.js

@@ -0,0 +1,258 @@
+"use strict";
+const logToConsole = require("./logToConsole");
+const reporting = require("./reporting");
+const chalk = require("chalk");
+const throttle = require("lodash.throttle");
+const { AmbiguousModuleResolutionError } = require("../../../metro-core/src");
+const path = require("path");
+const debug = require("debug")("metro");
+const GLOBAL_CACHE_DISABLED_MESSAGE_FORMAT = "The global cache is now disabled because %s";
+const DARK_BLOCK_CHAR = "\u2593";
+const LIGHT_BLOCK_CHAR = "\u2591";
+const MAX_PROGRESS_BAR_CHAR_WIDTH = 16;
+class TerminalReporter {
+  /**
+   * The bundle builds for which we are actively maintaining the status on the
+   * terminal, ie. showing a progress bar. There can be several bundles being
+   * built at the same time.
+   */
+  _activeBundles;
+  _scheduleUpdateBundleProgress;
+  terminal;
+  constructor(terminal) {
+    this._activeBundles = /* @__PURE__ */ new Map();
+    this._scheduleUpdateBundleProgress = throttle((data) => {
+      this.update({ ...data, type: "bundle_transform_progressed_throttled" });
+    }, 100);
+    this.terminal = terminal;
+  }
+  /**
+   * Construct a message that represents the progress of a
+   * single bundle build, for example:
+   *
+   *     BUNDLE path/to/bundle.js ▓▓▓▓▓░░░░░░░░░░░ 36.6% (4790/7922)
+   */
+  _getBundleStatusMessage({ bundleDetails: { entryFile, bundleType, runtimeBytecodeVersion }, transformedFileCount, totalFileCount, ratio }, phase) {
+    if (runtimeBytecodeVersion) {
+      bundleType = "bytecodebundle";
+    }
+    const localPath = path.relative(".", entryFile);
+    const filledBar = Math.floor(ratio * MAX_PROGRESS_BAR_CHAR_WIDTH);
+    const bundleTypeColor = phase === "done" ? chalk.green : phase === "failed" ? chalk.red : chalk.yellow;
+    const progress = phase === "in_progress" ? chalk.green.bgGreen(DARK_BLOCK_CHAR.repeat(filledBar)) + chalk.bgWhite.white(LIGHT_BLOCK_CHAR.repeat(MAX_PROGRESS_BAR_CHAR_WIDTH - filledBar)) + chalk.bold(` ${(100 * ratio).toFixed(1)}% `) + chalk.dim(`(${transformedFileCount}/${totalFileCount})`) : "";
+    return bundleTypeColor.inverse.bold(` ${bundleType.toUpperCase()} `) + chalk.reset.dim(` ${path.dirname(localPath)}/`) + chalk.bold(path.basename(localPath)) + " " + progress + "\n";
+  }
+  _logCacheDisabled(reason) {
+    const format = GLOBAL_CACHE_DISABLED_MESSAGE_FORMAT;
+    switch (reason) {
+      case "too_many_errors":
+        reporting.logWarning(this.terminal, format, "it has been failing too many times.");
+        break;
+      case "too_many_misses":
+        reporting.logWarning(this.terminal, format, "it has been missing too many consecutive keys.");
+        break;
+    }
+  }
+  _logBundleBuildDone(buildID) {
+    const progress = this._activeBundles.get(buildID);
+    if (progress != null) {
+      const msg = this._getBundleStatusMessage(
+        {
+          ...progress,
+          ratio: 1,
+          transformedFileCount: progress.totalFileCount
+        },
+        "done"
+      );
+      this.terminal.log(msg);
+      this._activeBundles.delete(buildID);
+    }
+  }
+  _logBundleBuildFailed(buildID) {
+    const progress = this._activeBundles.get(buildID);
+    if (progress != null) {
+      const msg = this._getBundleStatusMessage(progress, "failed");
+      this.terminal.log(msg);
+    }
+  }
+  _logInitializing(port, hasReducedPerformance) {
+  }
+  _logInitializingFailed(port, error) {
+    if (error.code === "EADDRINUSE") {
+      this.terminal.log(chalk.bgRed.bold(" ERROR "), chalk.red("Metro can't listen on port", chalk.bold(String(port))));
+      this.terminal.log("Most likely another process is already using this port");
+      this.terminal.log("Run the following command to find out which process:");
+      this.terminal.log("\n  ", chalk.bold("lsof -i :" + port), "\n");
+      this.terminal.log("Then, you can either shut down the other process:");
+      this.terminal.log("\n  ", chalk.bold("kill -9 <PID>"), "\n");
+      this.terminal.log("or run Metro on different port.");
+    } else {
+      this.terminal.log(chalk.bgRed.bold(" ERROR "), chalk.red(error.message));
+      const errorAttributes = JSON.stringify(error);
+      if (errorAttributes !== "{}") {
+        this.terminal.log(chalk.red(errorAttributes));
+      }
+      this.terminal.log(chalk.red(error.stack));
+    }
+  }
+  /**
+   * This function is only concerned with logging and should not do state
+   * or terminal status updates.
+   */
+  _log(event) {
+    switch (event.type) {
+      case "initialize_started":
+        this._logInitializing(event.port, event.hasReducedPerformance);
+        break;
+      case "initialize_failed":
+        this._logInitializingFailed(event.port, event.error);
+        break;
+      case "bundle_build_done":
+        this._logBundleBuildDone(event.buildID);
+        break;
+      case "bundle_build_failed":
+        this._logBundleBuildFailed(event.buildID);
+        break;
+      case "bundling_error":
+        this._logBundlingError(event.error);
+        break;
+      case "global_cache_disabled":
+        this._logCacheDisabled(event.reason);
+        break;
+      case "transform_cache_reset":
+        debug("the transform cache was reset.");
+        break;
+      case "worker_stdout_chunk":
+        this._logWorkerChunk("stdout", event.chunk);
+        break;
+      case "worker_stderr_chunk":
+        this._logWorkerChunk("stderr", event.chunk);
+        break;
+      case "hmr_client_error":
+        this._logHmrClientError(event.error);
+        break;
+      case "client_log":
+        logToConsole(this.terminal, event.level, event.mode, ...event.data);
+        break;
+      case "dep_graph_loading":
+        if (event.hasReducedPerformance) {
+          this.terminal.log(
+            chalk.red(
+              "Metro is operating with reduced performance.\nPlease fix the problem above and restart Metro.\n\n"
+            )
+          );
+        }
+        break;
+    }
+  }
+  /**
+   * We do not want to log the whole stacktrace for bundling error, because
+   * these are operational errors, not programming errors, and the stacktrace
+   * is not actionable to end users.
+   */
+  _logBundlingError(error) {
+    if (error instanceof AmbiguousModuleResolutionError) {
+      const he = error.hasteError;
+      const message2 = `ambiguous resolution: module \`${error.fromModulePath}\` tries to require \`${he.hasteName}\`, but there are several files providing this module. You can delete or fix them: 
+
+` + Object.keys(he.duplicatesSet).sort().map((dupFilePath) => `  * \`${dupFilePath}\`
+`).join("");
+      reporting.logError(this.terminal, message2);
+      return;
+    }
+    let { message } = error;
+    if (!(error instanceof SyntaxError)) {
+      if (error.snippet == null && error.stack != null) {
+        message = error.stack;
+      }
+    }
+    if (error.filename && !message.includes(error.filename)) {
+      message += ` [${error.filename}]`;
+    }
+    if (error.snippet != null) {
+      message += "\n" + error.snippet;
+    }
+    reporting.logError(this.terminal, message);
+  }
+  _logWorkerChunk(origin, chunk) {
+    const lines = chunk.split("\n");
+    if (lines.length >= 1 && lines[lines.length - 1] === "") {
+      lines.splice(lines.length - 1, 1);
+    }
+    lines.forEach((line) => {
+      this.terminal.log(`transform[${origin}]: ${line}`);
+    });
+  }
+  /**
+   * We use Math.pow(ratio, 2) to as a conservative measure of progress because
+   * we know the `totalCount` is going to progressively increase as well. We
+   * also prevent the ratio from going backwards.
+   */
+  _updateBundleProgress({ buildID, transformedFileCount, totalFileCount }) {
+    const currentProgress = this._activeBundles.get(buildID);
+    if (currentProgress == null) {
+      return;
+    }
+    const rawRatio = transformedFileCount / totalFileCount;
+    const conservativeRatio = Math.pow(rawRatio, 2);
+    const ratio = Math.max(conservativeRatio, currentProgress.ratio);
+    Object.assign(currentProgress, {
+      ratio,
+      transformedFileCount,
+      totalFileCount
+    });
+  }
+  /**
+   * This function is exclusively concerned with updating the internal state.
+   * No logging or status updates should be done at this point.
+   */
+  _updateState(event) {
+    switch (event.type) {
+      case "bundle_build_done":
+      case "bundle_build_failed":
+        this._activeBundles.delete(event.buildID);
+        break;
+      case "bundle_build_started":
+        const bundleProgress = {
+          bundleDetails: event.bundleDetails,
+          transformedFileCount: 0,
+          totalFileCount: 1,
+          ratio: 0
+        };
+        this._activeBundles.set(event.buildID, bundleProgress);
+        break;
+      case "bundle_transform_progressed_throttled":
+        this._updateBundleProgress(event);
+        break;
+    }
+  }
+  /**
+   * Return a status message that is always consistent with the current state
+   * of the application. Having this single function ensures we don't have
+   * different callsites overriding each other status messages.
+   */
+  _getStatusMessage() {
+    return Array.from(this._activeBundles.entries()).map(([_, progress]) => this._getBundleStatusMessage(progress, "in_progress")).filter((str) => str != null).join("\n");
+  }
+  _logHmrClientError(e) {
+    reporting.logError(
+      this.terminal,
+      "A WebSocket client got a connection error. Please reload your device to get HMR working again: %s",
+      e
+    );
+  }
+  /**
+   * Single entry point for reporting events. That allows us to implement the
+   * corresponding JSON reporter easily and have a consistent repor∏ting.
+   */
+  update(event) {
+    if (event.type === "bundle_transform_progressed") {
+      this._scheduleUpdateBundleProgress(event);
+      return;
+    }
+    this._log(event);
+    this._updateState(event);
+    this.terminal.status(this._getStatusMessage());
+  }
+}
+module.exports = TerminalReporter;

package/dist/vendors/metro/src/lib/bundleToBytecode.js

@@ -0,0 +1,40 @@
+"use strict";
+const MAGIC_NUMBER = 4293379011;
+function getFileHeader(moduleCount) {
+  const buffer = Buffer.alloc(8);
+  buffer.writeUInt32LE(MAGIC_NUMBER, 0);
+  buffer.writeUInt32LE(moduleCount, 4);
+  return buffer;
+}
+function addModuleHeader(buffer) {
+  const { getFileLength } = require("metro-hermes-compiler");
+  const fileLength = getFileLength(buffer, 0);
+  const header = Buffer.alloc(4);
+  header.writeUInt32LE(fileLength, 0);
+  return [header, buffer];
+}
+function bundleToBytecode(bundle) {
+  const buffers = [];
+  if (bundle.pre.length) {
+    buffers.push(...bundle.pre);
+  }
+  const modules = [];
+  const sortedModules = bundle.modules.slice().sort((a, b) => a[0] - b[0]);
+  for (const [id, bytecodeBundle] of sortedModules) {
+    buffers.push(...bytecodeBundle);
+    modules.push([id, bytecodeBundle[bytecodeBundle.length - 1].length]);
+  }
+  if (bundle.post.length) {
+    buffers.push(...bundle.post);
+  }
+  return {
+    bytecode: Buffer.concat([getFileHeader(buffers.length), ...buffers.flatMap(addModuleHeader)]),
+    metadata: {
+      pre: bundle.pre ? bundle.pre.length : 0,
+      post: bundle.post.length,
+      modules
+    }
+  };
+}
+module.exports = bundleToBytecode;
+module.exports.MAGIC_NUMBER = MAGIC_NUMBER;

package/dist/vendors/metro/src/lib/bundleToString.js

@@ -0,0 +1,22 @@
+"use strict";
+function bundleToString(bundle) {
+  let code = bundle.pre.length > 0 ? bundle.pre + "\n" : "";
+  const modules = [];
+  const sortedModules = bundle.modules.slice().sort((a, b) => a[0] - b[0]);
+  for (const [id, moduleCode] of sortedModules) {
+    if (moduleCode.length > 0) {
+      code += moduleCode + "\n";
+    }
+    modules.push([id, moduleCode.length]);
+  }
+  if (bundle.post.length > 0) {
+    code += bundle.post;
+  } else {
+    code = code.slice(0, -1);
+  }
+  return {
+    code,
+    metadata: { pre: bundle.pre.length, post: bundle.post.length, modules }
+  };
+}
+module.exports = bundleToString;

package/dist/vendors/metro/src/lib/contextModule.js

@@ -0,0 +1,73 @@
+"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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var contextModule_exports = {};
+__export(contextModule_exports, {
+  deriveAbsolutePathFromContext: () => deriveAbsolutePathFromContext,
+  fileMatchesContext: () => fileMatchesContext
+});
+module.exports = __toCommonJS(contextModule_exports);
+var import_crypto = __toESM(require("crypto"));
+var import_path = __toESM(require("path"));
+var import_nullthrows = __toESM(require("nullthrows"));
+function toHash(value) {
+  return import_crypto.default.createHash("sha1").update(value).digest("hex");
+}
+function deriveAbsolutePathFromContext(from, context) {
+  const filePath = from.endsWith(import_path.default.sep) ? from.slice(0, -1) : from;
+  return filePath + "?ctx=" + toHash(
+    [
+      context.mode,
+      context.recursive ? "recursive" : "",
+      new RegExp(context.filter.pattern, context.filter.flags).toString()
+    ].filter(Boolean).join(" ")
+  );
+}
+function fileMatchesContext(testPath, context) {
+  const filePath = import_path.default.relative((0, import_nullthrows.default)(context.from), testPath);
+  const filter = context.filter;
+  if (
+    // Ignore everything outside of the provided `root`.
+    !(filePath && !filePath.startsWith("..")) || // Prevent searching in child directories during a non-recursive search.
+    !context.recursive && filePath.includes(import_path.default.sep) || // Test against the filter.
+    !filter.test(
+      // NOTE(EvanBacon): Ensure files start with `./` for matching purposes
+      // this ensures packages work across Metro and Webpack (ex: Storybook for React DOM / React Native).
+      // `a/b.js` -> `./a/b.js`
+      "./" + filePath.replace(/\\/g, "/")
+    )
+  ) {
+    return false;
+  }
+  return true;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deriveAbsolutePathFromContext,
+  fileMatchesContext
+});

package/dist/vendors/metro/src/lib/contextModuleTemplates.js

@@ -0,0 +1,116 @@
+"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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var contextModuleTemplates_exports = {};
+__export(contextModuleTemplates_exports, {
+  getContextModuleTemplate: () => getContextModuleTemplate
+});
+module.exports = __toCommonJS(contextModuleTemplates_exports);
+var path = __toESM(require("path"));
+function createFileMap(modulePath, files, processModule) {
+  let mapString = "\n";
+  files.slice().sort().forEach((file) => {
+    let filePath = path.relative(modulePath, file);
+    if (!filePath.startsWith(".")) {
+      filePath = `.${path.sep}` + filePath;
+    }
+    const key = JSON.stringify(filePath);
+    mapString += `  ${key}: { enumerable: true, get() { return ${processModule(file)}; } },
+`;
+  });
+  return `Object.defineProperties({}, {${mapString}})`;
+}
+function getEmptyContextModuleTemplate(modulePath) {
+  return `
+function metroEmptyContext(request) {
+  let e = new Error('No modules in context');
+  e.code = 'MODULE_NOT_FOUND';
+  throw e;
+}
+
+// Return the keys that can be resolved.
+metroEmptyContext.keys = () => ([]);
+
+// Return the module identifier for a user request.
+metroEmptyContext.resolve = function metroContextResolve(request) {
+  throw new Error('Unimplemented Metro module context functionality');
+}
+
+module.exports = metroEmptyContext;`;
+}
+function getLoadableContextModuleTemplate(modulePath, files, importSyntax, getContextTemplate) {
+  return `// All of the requested modules are loaded behind enumerable getters.
+const map = ${createFileMap(modulePath, files, (moduleId) => `${importSyntax}(${JSON.stringify(moduleId)})`)};
+  
+function metroContext(request) {
+  ${getContextTemplate}
+}
+  
+// Return the keys that can be resolved.
+metroContext.keys = function metroContextKeys() {
+  return Object.keys(map);
+};
+
+// Return the module identifier for a user request.
+metroContext.resolve = function metroContextResolve(request) {
+  throw new Error('Unimplemented Metro module context functionality');
+}
+
+module.exports = metroContext;`;
+}
+function getContextModuleTemplate(mode, modulePath, files) {
+  if (!files.length) {
+    return getEmptyContextModuleTemplate(modulePath);
+  }
+  switch (mode) {
+    case "eager":
+      return getLoadableContextModuleTemplate(
+        modulePath,
+        files,
+        // NOTE(EvanBacon): It's unclear if we should use `import` or `require` here so sticking
+        // with the more stable option (`require`) for now.
+        "require",
+        [
+          "  // Here Promise.resolve().then() is used instead of new Promise() to prevent",
+          "  // uncaught exception popping up in devtools",
+          "  return Promise.resolve().then(() => map[request]);"
+        ].join("\n")
+      );
+    case "sync":
+      return getLoadableContextModuleTemplate(modulePath, files, "require", "  return map[request];");
+    case "lazy":
+    case "lazy-once":
+      return getLoadableContextModuleTemplate(modulePath, files, "import", "  return map[request];");
+    default:
+      throw new Error(`Metro context mode "${mode}" is unimplemented`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getContextModuleTemplate
+});

package/dist/vendors/metro/src/lib/countLines.js

@@ -0,0 +1,4 @@
+"use strict";
+const newline = /\r\n?|\n|\u2028|\u2029/g;
+const countLines = (string) => (string.match(newline) || []).length + 1;
+module.exports = countLines;