@granite-js/mpack 0.0.1

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

@@ -0,0 +1,14 @@
+"use strict";
+function createModuleIdFactory() {
+  const fileToIdMap = /* @__PURE__ */ new Map();
+  let nextId = 0;
+  return (path) => {
+    let id = fileToIdMap.get(path);
+    if (typeof id !== "number") {
+      id = nextId++;
+      fileToIdMap.set(path, id);
+    }
+    return id;
+  };
+}
+module.exports = createModuleIdFactory;

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

@@ -0,0 +1,54 @@
+"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_ws = __toESM(require("ws"));
+module.exports = function createWebsocketServer({ websocketServer }) {
+  const wss = new import_ws.default.Server({
+    noServer: true
+  });
+  wss.on("connection", async (ws2, req) => {
+    let connected = true;
+    const url = req.url;
+    const sendFn = (...args) => {
+      if (connected) {
+        ws2.send(...args);
+      }
+    };
+    const client = await websocketServer.onClientConnect(url, sendFn);
+    if (client == null) {
+      ws2.close();
+      return;
+    }
+    ws2.on("error", (e) => {
+      websocketServer.onClientError && websocketServer.onClientError(client, e);
+    });
+    ws2.on("close", () => {
+      websocketServer.onClientDisconnect && websocketServer.onClientDisconnect(client);
+      connected = false;
+    });
+    ws2.on("message", (message) => {
+      websocketServer.onClientMessage && websocketServer.onClientMessage(client, message, sendFn);
+    });
+  });
+  return wss;
+};

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

@@ -0,0 +1,33 @@
+"use strict";
+function debounceAsyncQueue(fn, delay) {
+  let timeout;
+  let waiting = false;
+  let executing = false;
+  let callbacks = [];
+  async function execute() {
+    const currentCallbacks = callbacks;
+    callbacks = [];
+    executing = true;
+    const res = await fn();
+    currentCallbacks.forEach((c) => c(res));
+    executing = false;
+    if (callbacks.length > 0) {
+      await execute();
+    }
+  }
+  return () => new Promise((resolve, reject) => {
+    callbacks.push(resolve);
+    if (!executing) {
+      if (waiting) {
+        clearTimeout(timeout);
+      } else {
+        waiting = true;
+      }
+      timeout = setTimeout(async () => {
+        waiting = false;
+        await execute();
+      }, delay);
+    }
+  });
+}
+module.exports = debounceAsyncQueue;

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

@@ -0,0 +1,76 @@
+"use strict";
+const GraphNotFoundError = require("../IncrementalBundler/GraphNotFoundError");
+const ResourceNotFoundError = require("../IncrementalBundler/ResourceNotFoundError");
+const RevisionNotFoundError = require("../IncrementalBundler/RevisionNotFoundError");
+const { UnableToResolveError } = require("../node-haste/DependencyGraph/ModuleResolution");
+const { codeFrameColumns } = require("@babel/code-frame");
+const ErrorStackParser = require("error-stack-parser");
+const fs = require("fs");
+const { AmbiguousModuleResolutionError } = require("../../../metro-core/src");
+const serializeError = require("serialize-error");
+function formatBundlingError(error) {
+  if (error instanceof AmbiguousModuleResolutionError) {
+    const he = error.hasteError;
+    const message = `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("\n\n");
+    return {
+      type: "AmbiguousModuleResolutionError",
+      message,
+      errors: [{ description: message }]
+    };
+  }
+  if (error instanceof UnableToResolveError || error instanceof Error && (error.type === "TransformError" || error.type === "NotFoundError")) {
+    error.errors = [
+      {
+        description: error.message,
+        filename: error.filename,
+        lineNumber: error.lineNumber
+      }
+    ];
+    return serializeError(error);
+  } else if (error instanceof ResourceNotFoundError) {
+    return {
+      type: "ResourceNotFoundError",
+      errors: [],
+      message: error.message
+    };
+  } else if (error instanceof GraphNotFoundError) {
+    return {
+      type: "GraphNotFoundError",
+      errors: [],
+      message: error.message
+    };
+  } else if (error instanceof RevisionNotFoundError) {
+    return {
+      type: "RevisionNotFoundError",
+      errors: [],
+      message: error.message
+    };
+  } else {
+    const stack = ErrorStackParser.parse(error);
+    const fileName = stack[0].fileName;
+    const column = stack[0].columnNumber;
+    const line = stack[0].lineNumber;
+    let codeFrame = "";
+    try {
+      codeFrame = codeFrameColumns(
+        // If the error was thrown in a node.js builtin module, this call will fail and mask the real error.
+        fs.readFileSync(fileName, "utf8"),
+        {
+          start: { column, line }
+        },
+        { forceColor: true }
+      );
+    } catch {
+    }
+    return {
+      type: "InternalError",
+      errors: [],
+      message: `Metro has encountered an error: ${error.message}: ${fileName} (${line}:${column})
+
+${codeFrame}`
+    };
+  }
+}
+module.exports = formatBundlingError;

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

@@ -0,0 +1,131 @@
+"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_CountingSet = __toESM(require("./CountingSet"));
+const getInlineSourceMappingURL = require("../DeltaBundler/Serializers/helpers/getInlineSourceMappingURL");
+const sourceMapString = require("../DeltaBundler/Serializers/sourceMapString");
+const countLines = require("./countLines");
+const nullthrows = require("nullthrows");
+const path = require("path");
+function getAppendScripts(entryPoint, modules, importBundleNames, options) {
+  const output = [];
+  if (importBundleNames.size) {
+    const importBundleNamesObject = /* @__PURE__ */ Object.create(null);
+    importBundleNames.forEach((absolutePath) => {
+      const bundlePath = path.relative(options.serverRoot, absolutePath);
+      importBundleNamesObject[options.createModuleId(absolutePath)] = bundlePath.slice(
+        0,
+        -path.extname(bundlePath).length
+      );
+    });
+    const code = `(function(){var $$=${options.getRunModuleStatement(
+      options.createModuleId(options.asyncRequireModulePath)
+    )}$$.addImportBundleNames(${String(JSON.stringify(importBundleNamesObject))})})();`;
+    output.push({
+      path: "$$importBundleNames",
+      dependencies: /* @__PURE__ */ new Map(),
+      getSource: () => Buffer.from(""),
+      inverseDependencies: new import_CountingSet.default(),
+      output: [
+        {
+          type: "js/script/virtual",
+          data: {
+            code,
+            lineCount: countLines(code),
+            map: []
+          }
+        }
+      ]
+    });
+  }
+  if (options.runModule) {
+    const paths = [...options.runBeforeMainModule, entryPoint];
+    for (const path2 of paths) {
+      if (modules.some((module2) => module2.path === path2)) {
+        const code = options.getRunModuleStatement(options.createModuleId(path2));
+        output.push({
+          path: `require-${path2}`,
+          dependencies: /* @__PURE__ */ new Map(),
+          getSource: () => Buffer.from(""),
+          inverseDependencies: new import_CountingSet.default(),
+          output: [
+            {
+              type: "js/script/virtual",
+              data: {
+                code,
+                lineCount: countLines(code),
+                map: []
+              }
+            }
+          ]
+        });
+      }
+    }
+  }
+  if (options.inlineSourceMap || options.sourceMapUrl) {
+    const sourceMappingURL = options.inlineSourceMap ? getInlineSourceMappingURL(
+      sourceMapString(modules, {
+        processModuleFilter: () => true,
+        excludeSource: false
+      })
+    ) : nullthrows(options.sourceMapUrl);
+    const code = `//# sourceMappingURL=${sourceMappingURL}`;
+    output.push({
+      path: "source-map",
+      dependencies: /* @__PURE__ */ new Map(),
+      getSource: () => Buffer.from(""),
+      inverseDependencies: new import_CountingSet.default(),
+      output: [
+        {
+          type: "js/script/virtual",
+          data: {
+            code,
+            lineCount: countLines(code),
+            map: []
+          }
+        }
+      ]
+    });
+  }
+  if (options.sourceUrl) {
+    const code = `//# sourceURL=${options.sourceUrl}`;
+    output.push({
+      path: "source-url",
+      dependencies: /* @__PURE__ */ new Map(),
+      getSource: () => Buffer.from(""),
+      inverseDependencies: new import_CountingSet.default(),
+      output: [
+        {
+          type: "js/script/virtual",
+          data: {
+            code,
+            lineCount: countLines(code),
+            map: []
+          }
+        }
+      ]
+    });
+  }
+  return output;
+}
+module.exports = getAppendScripts;

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

@@ -0,0 +1,27 @@
+"use strict";
+const canonicalize = require("../../../metro-core/src/canonicalize");
+function getGraphId(entryFile, options, { shallow, experimentalImportBundleSupport, unstable_allowRequireContext, resolverOptions }) {
+  return JSON.stringify(
+    {
+      entryFile,
+      options: {
+        customResolverOptions: resolverOptions.customResolverOptions ?? {},
+        customTransformOptions: options.customTransformOptions ?? null,
+        dev: options.dev,
+        experimentalImportSupport: options.experimentalImportSupport || false,
+        hot: options.hot,
+        minify: options.minify,
+        unstable_disableES6Transforms: options.unstable_disableES6Transforms,
+        platform: options.platform != null ? options.platform : null,
+        runtimeBytecodeVersion: options.runtimeBytecodeVersion,
+        type: options.type,
+        experimentalImportBundleSupport,
+        unstable_allowRequireContext,
+        shallow,
+        unstable_transformProfile: options.unstable_transformProfile || "default"
+      }
+    },
+    canonicalize
+  );
+}
+module.exports = getGraphId;

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

@@ -0,0 +1,6 @@
+"use strict";
+const os = require("os");
+module.exports = (workers) => {
+  const cores = os.cpus().length;
+  return typeof workers === "number" && Number.isInteger(workers) ? Math.min(cores, workers > 0 ? workers : 1) : Math.max(1, Math.ceil(cores * (0.5 + 0.5 * Math.exp(-cores * 0.07)) - 1));
+};

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

@@ -0,0 +1,32 @@
+"use strict";
+function getPreludeCode({ extraVars, isDev, globalPrefix, requireCycleIgnorePatterns }) {
+  const vars = [
+    // Ensure these variable names match the ones referenced in metro-runtime
+    // require.js
+    "__BUNDLE_START_TIME__=this.nativePerformanceNow?nativePerformanceNow():Date.now()",
+    `__DEV__=${String(isDev)}`,
+    ...formatExtraVars(extraVars),
+    "process=this.process||{}",
+    `__METRO_GLOBAL_PREFIX__='${globalPrefix}'`
+  ];
+  if (isDev) {
+    vars.push(
+      `${globalPrefix}__requireCycleIgnorePatterns=[${requireCycleIgnorePatterns.map((regex) => regex.toString()).join(",")}]`
+    );
+  }
+  return `var ${vars.join(",")};${processEnv(isDev ? "development" : "production")}`;
+}
+const excluded = /* @__PURE__ */ new Set(["__BUNDLE_START_TIME__", "__DEV__", "process"]);
+function formatExtraVars(extraVars) {
+  const assignments = [];
+  for (const key in extraVars) {
+    if (extraVars.hasOwnProperty(key) && !excluded.has(key)) {
+      assignments.push(`${key}=${JSON.stringify(extraVars[key])}`);
+    }
+  }
+  return assignments;
+}
+function processEnv(nodeEnv) {
+  return `process.env=process.env||{};process.env.NODE_ENV=process.env.NODE_ENV||${JSON.stringify(nodeEnv)};`;
+}
+module.exports = getPreludeCode;

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

@@ -0,0 +1,93 @@
+"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_CountingSet = __toESM(require("./CountingSet"));
+const countLines = require("./countLines");
+const getPreludeCode = require("./getPreludeCode");
+const transformHelpers = require("./transformHelpers");
+const defaults = require("../../../metro-config/src/defaults/defaults");
+async function getPrependedScripts(config, options, resolverOptions, bundler, deltaBundler) {
+  const polyfillModuleNames = config.serializer.getPolyfills({
+    platform: options.platform
+  }).concat(config.serializer.polyfillModuleNames);
+  const transformOptions = {
+    ...options,
+    type: "script"
+  };
+  const dependencies = await deltaBundler.getDependencies([defaults.moduleSystem, ...polyfillModuleNames], {
+    resolve: await transformHelpers.getResolveDependencyFn(bundler, options.platform, resolverOptions),
+    transform: await transformHelpers.getTransformFn(
+      [defaults.moduleSystem, ...polyfillModuleNames],
+      bundler,
+      deltaBundler,
+      config,
+      transformOptions,
+      resolverOptions
+    ),
+    unstable_allowRequireContext: config.transformer.unstable_allowRequireContext,
+    transformOptions,
+    onProgress: null,
+    experimentalImportBundleSupport: config.transformer.experimentalImportBundleSupport,
+    shallow: false
+  });
+  return [
+    _getPrelude({
+      dev: options.dev,
+      globalPrefix: config.transformer.globalPrefix,
+      requireCycleIgnorePatterns: config.resolver.requireCycleIgnorePatterns
+    }),
+    ...dependencies.values()
+  ];
+}
+function _getPrelude({ dev, globalPrefix, requireCycleIgnorePatterns }) {
+  const { compile } = require("metro-hermes-compiler");
+  const code = getPreludeCode({
+    isDev: dev,
+    globalPrefix,
+    requireCycleIgnorePatterns
+  });
+  const name = "__prelude__";
+  return {
+    dependencies: /* @__PURE__ */ new Map(),
+    getSource: () => Buffer.from(code),
+    inverseDependencies: new import_CountingSet.default(),
+    path: name,
+    output: [
+      {
+        type: "js/script/virtual",
+        data: {
+          code,
+          lineCount: countLines(code),
+          map: []
+        }
+      },
+      {
+        type: "bytecode/script/virtual",
+        data: {
+          bytecode: compile(code, { sourceURL: "__prelude__.virtual.js" }).bytecode
+        }
+      }
+    ]
+  };
+}
+module.exports = getPrependedScripts;

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

@@ -0,0 +1,46 @@
+"use strict";
+const chalk = require("chalk");
+const util = require("util");
+const groupStack = [];
+let collapsedGuardTimer;
+module.exports = (terminal, level, mode, ...data) => {
+  const logFunction = console[level] && level !== "trace" ? level : "log";
+  const color = level === "error" ? chalk.inverse.red : level === "warn" ? chalk.inverse.yellow : chalk.inverse.white;
+  if (level === "group") {
+    groupStack.push(level);
+  } else if (level === "groupCollapsed") {
+    groupStack.push(level);
+    clearTimeout(collapsedGuardTimer);
+    collapsedGuardTimer = setTimeout(() => {
+      if (groupStack.includes("groupCollapsed")) {
+        terminal.log(
+          chalk.inverse.yellow.bold(" WARN "),
+          "Expected `console.groupEnd` to be called after `console.groupCollapsed`."
+        );
+        groupStack.length = 0;
+      }
+    }, 3e3);
+    return;
+  } else if (level === "groupEnd") {
+    groupStack.pop();
+    if (!groupStack.length) {
+      clearTimeout(collapsedGuardTimer);
+    }
+    return;
+  }
+  if (!groupStack.includes("groupCollapsed")) {
+    const lastItem = data[data.length - 1];
+    if (typeof lastItem === "string") {
+      data[data.length - 1] = lastItem.trimEnd();
+    }
+    const modePrefix = !mode || mode == "BRIDGE" ? "" : `(${mode.toUpperCase()}) `;
+    terminal.log(
+      color.bold(` ${modePrefix}${logFunction.toUpperCase()} `) + "".padEnd(groupStack.length * 2, " "),
+      // `util.format` actually accepts any arguments.
+      // If the first argument is a string, it tries to format it.
+      // Otherwise, it just concatenates all arguments.
+      // $FlowIssue[incompatible-call] util.format expected the first argument to be a string
+      util.format(...data)
+    );
+  }
+};

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

@@ -0,0 +1,13 @@
+"use strict";
+const nullthrows = require("nullthrows");
+const PREFIX = "resolver.";
+module.exports = function parseCustomResolverOptions(urlObj) {
+  const customResolverOptions = /* @__PURE__ */ Object.create(null);
+  const query = nullthrows(urlObj.query);
+  Object.keys(query).forEach((key) => {
+    if (key.startsWith(PREFIX)) {
+      customResolverOptions[key.substr(PREFIX.length)] = query[key];
+    }
+  });
+  return customResolverOptions;
+};

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

@@ -0,0 +1,13 @@
+"use strict";
+const nullthrows = require("nullthrows");
+const PREFIX = "transform.";
+module.exports = function parseCustomTransformOptions(urlObj) {
+  const customTransformOptions = /* @__PURE__ */ Object.create(null);
+  const query = nullthrows(urlObj.query);
+  Object.keys(query).forEach((key) => {
+    if (key.startsWith(PREFIX)) {
+      customTransformOptions[key.substr(PREFIX.length)] = query[key];
+    }
+  });
+  return customTransformOptions;
+};

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

@@ -0,0 +1,50 @@
+"use strict";
+const parsePlatformFilePath = require("../node-haste/lib/parsePlatformFilePath");
+const parseCustomResolverOptions = require("./parseCustomResolverOptions");
+const parseCustomTransformOptions = require("./parseCustomTransformOptions");
+const nullthrows = require("nullthrows");
+const path = require("path");
+const url = require("url");
+const getBoolean = (query, opt, defaultValue) => query[opt] == null ? defaultValue : query[opt] === "true" || query[opt] === "1";
+const getNumber = (query, opt, defaultValue) => {
+  const number = parseInt(query[opt], 10);
+  return Number.isNaN(number) ? defaultValue : number;
+};
+const getBundleType = (bundleType) => bundleType === "map" ? bundleType : "bundle";
+const getTransformProfile = (transformProfile) => transformProfile === "hermes-stable" || transformProfile === "hermes-canary" ? transformProfile : "default";
+module.exports = function parseOptionsFromUrl(requestUrl, platforms, bytecodeVersion) {
+  const parsedURL = nullthrows(url.parse(requestUrl, true));
+  const query = nullthrows(parsedURL.query);
+  const pathname = query.bundleEntry || (parsedURL.pathname != null ? decodeURIComponent(parsedURL.pathname) : "");
+  const platform = query.platform || parsePlatformFilePath(pathname, platforms).platform;
+  const bundleType = getBundleType(path.extname(pathname).substr(1));
+  const runtimeBytecodeVersion = getNumber(query, "runtimeBytecodeVersion", null);
+  return {
+    bundleType,
+    runtimeBytecodeVersion: bytecodeVersion === runtimeBytecodeVersion ? bytecodeVersion : null,
+    customResolverOptions: parseCustomResolverOptions(parsedURL),
+    customTransformOptions: parseCustomTransformOptions(parsedURL),
+    dev: getBoolean(query, "dev", true),
+    entryFile: pathname.replace(/^(?:\.?\/)?/, "./").replace(/\.[^/.]+$/, ""),
+    excludeSource: getBoolean(query, "excludeSource", false),
+    hot: true,
+    inlineSourceMap: getBoolean(query, "inlineSourceMap", false),
+    minify: getBoolean(query, "minify", false),
+    modulesOnly: getBoolean(query, "modulesOnly", false),
+    onProgress: null,
+    platform,
+    runModule: getBoolean(query, "runModule", true),
+    shallow: getBoolean(query, "shallow", false),
+    sourceMapUrl: url.format({
+      ...parsedURL,
+      // The Chrome Debugger loads bundles via Blob urls, whose
+      // protocol is blob:http. This breaks loading source maps through
+      // protocol-relative URLs, which is why we must force the HTTP protocol
+      // when loading the bundle for either Android or iOS.
+      protocol: platform != null && platform.match(/^(android|ios)$/) ? "http" : "",
+      pathname: pathname.replace(/\.(bundle|delta)$/, ".map")
+    }),
+    sourceUrl: requestUrl,
+    unstable_transformProfile: getTransformProfile(query.unstable_transformProfile)
+  };
+};

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

@@ -0,0 +1,14 @@
+"use strict";
+const path = require("path");
+function relativizeSourceMapInline(sourceMap, sourcesRoot) {
+  if (sourceMap.mappings === void 0) {
+    for (let i = 0; i < sourceMap.sections.length; i++) {
+      relativizeSourceMapInline(sourceMap.sections[i].map, sourcesRoot);
+    }
+  } else {
+    for (let i = 0; i < sourceMap.sources.length; i++) {
+      sourceMap.sources[i] = path.relative(sourcesRoot, sourceMap.sources[i]);
+    }
+  }
+}
+module.exports = relativizeSourceMapInline;

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

@@ -0,0 +1,26 @@
+"use strict";
+const chalk = require("chalk");
+const stripAnsi = require("strip-ansi");
+const util = require("util");
+function logWarning(terminal, format, ...args) {
+  const str = util.format(format, ...args);
+  terminal.log("%s: %s", chalk.yellow("warning"), str);
+}
+function logError(terminal, format, ...args) {
+  terminal.log(
+    "%s: %s",
+    chalk.red("error"),
+    // Syntax errors may have colors applied for displaying code frames
+    // in various places outside of where Metro is currently running.
+    // If the current terminal does not support color, we'll strip the colors
+    // here.
+    util.format(chalk.supportsColor ? format : stripAnsi(format), ...args)
+  );
+}
+const nullReporter = { update() {
+} };
+module.exports = {
+  logWarning,
+  logError,
+  nullReporter
+};

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

@@ -0,0 +1,32 @@
+"use strict";
+function splitBundleOptions(options) {
+  return {
+    entryFile: options.entryFile,
+    resolverOptions: {
+      customResolverOptions: options.customResolverOptions
+    },
+    transformOptions: {
+      customTransformOptions: options.customTransformOptions,
+      dev: options.dev,
+      hot: options.hot,
+      minify: options.minify,
+      platform: options.platform,
+      runtimeBytecodeVersion: options.runtimeBytecodeVersion,
+      type: "module",
+      unstable_transformProfile: options.unstable_transformProfile
+    },
+    serializerOptions: {
+      excludeSource: options.excludeSource,
+      inlineSourceMap: options.inlineSourceMap,
+      modulesOnly: options.modulesOnly,
+      runModule: options.runModule,
+      sourceMapUrl: options.sourceMapUrl,
+      sourceUrl: options.sourceUrl
+    },
+    graphOptions: {
+      shallow: options.shallow
+    },
+    onProgress: options.onProgress
+  };
+}
+module.exports = splitBundleOptions;