@granite-js/mpack 0.0.1

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

@@ -0,0 +1,127 @@
+"use strict";
+var import_metro_file_map = require("metro-file-map");
+const { ModuleResolver } = require("../../node-haste/DependencyGraph/ModuleResolution");
+const parsePlatformFilePath = require("../../node-haste/lib/parsePlatformFilePath");
+const HasteFS = require("./HasteFS");
+const Module = require("./Module");
+const ModuleCache = require("./ModuleCache");
+const defaults = require("../../../../metro-config/src/defaults/defaults");
+const path = require("path");
+const NATIVE_PLATFORM = "native";
+const GENERIC_PLATFORM = "g";
+const PACKAGE_JSON = path.sep + "package.json";
+const NULL_MODULE = {
+  path: "/",
+  getPackage() {
+  },
+  isHaste() {
+    throw new Error("not implemented");
+  },
+  getName() {
+    throw new Error("not implemented");
+  }
+};
+const NODE_MODULES = path.sep + "node_modules" + path.sep;
+const isNodeModules = (file) => file.includes(NODE_MODULES);
+const createModuleMap = ({ files, moduleCache, sourceExts, additionalExts, platforms }) => {
+  const platformSet = new Set((platforms ?? defaults.platforms).concat([NATIVE_PLATFORM]));
+  const map = /* @__PURE__ */ new Map();
+  files.forEach((filePath) => {
+    if (isNodeModules(filePath)) {
+      return;
+    }
+    let id;
+    let module2;
+    const fileExt = path.extname(filePath).substr(1);
+    if (filePath.endsWith(PACKAGE_JSON)) {
+      module2 = moduleCache.getPackage(filePath);
+      id = module2.data.name;
+    } else if (sourceExts.has(fileExt) || additionalExts.has(fileExt)) {
+      module2 = moduleCache.getModule(filePath);
+      id = module2.name;
+    }
+    if (!(id && module2 && module2.isHaste())) {
+      return;
+    }
+    const mapModule = map.get(id) || /* @__PURE__ */ Object.create(null);
+    const platform = parsePlatformFilePath(filePath, platformSet).platform || GENERIC_PLATFORM;
+    const existingModule = mapModule[platform];
+    mapModule[platform] = [filePath, module2.type === "Package" ? 1 : 0];
+    if (existingModule && existingModule[0] !== filePath) {
+      throw new Error(
+        [
+          "@providesModule naming collision:",
+          `  Duplicate module name: \`${id}\``,
+          `  Paths: \`${filePath}\` collides with \`${existingModule[0]}\``,
+          "",
+          "This error is caused by a @providesModule declaration with the same name across two different files."
+        ].join("\n")
+      );
+    }
+    map.set(id, mapModule);
+  });
+  return map;
+};
+exports.createResolveFn = function(options) {
+  const {
+    assetExts,
+    assetResolutions,
+    extraNodeModules,
+    transformedFiles,
+    sourceExts,
+    additionalExts,
+    platform,
+    platforms
+  } = options;
+  const files = Object.keys(transformedFiles);
+  function getTransformedFile(path2) {
+    const result = transformedFiles[path2];
+    if (!result) {
+      throw new Error(`"${path2} does not exist`);
+    }
+    return result;
+  }
+  const hasteFS = new HasteFS(files);
+  const moduleCache = new ModuleCache((filePath) => hasteFS.closest(filePath, "package.json"), getTransformedFile);
+  const assetExtensions = new Set(assetExts.map((asset) => "." + asset));
+  const isAssetFile = (file) => assetExtensions.has(path.extname(file));
+  const moduleResolver = new ModuleResolver({
+    dirExists: (filePath) => hasteFS.dirExists(filePath),
+    disableHierarchicalLookup: options.disableHierarchicalLookup,
+    doesFileExist: (filePath) => hasteFS.exists(filePath),
+    emptyModulePath: options.emptyModulePath,
+    extraNodeModules,
+    isAssetFile,
+    mainFields: options.mainFields,
+    moduleCache,
+    moduleMap: new import_metro_file_map.ModuleMap({
+      duplicates: /* @__PURE__ */ new Map(),
+      map: createModuleMap({
+        files,
+        moduleCache,
+        sourceExts: new Set(sourceExts),
+        additionalExts: new Set(additionalExts),
+        platforms
+      }),
+      mocks: /* @__PURE__ */ new Map(),
+      rootDir: ""
+    }),
+    nodeModulesPaths: options.nodeModulesPaths,
+    preferNativePlatform: true,
+    projectRoot: "",
+    resolveAsset: (dirPath, assetName, extension) => {
+      const basePath = dirPath + path.sep + assetName;
+      const assets = [
+        basePath + extension,
+        ...assetResolutions.map((resolution) => basePath + "@" + resolution + "x" + extension)
+      ].filter((candidate) => hasteFS.exists(candidate));
+      return assets.length ? assets : null;
+    },
+    resolveRequest: options.resolveRequest,
+    sourceExts
+  });
+  return (id, sourcePath) => {
+    const from = sourcePath != null ? new Module(sourcePath, moduleCache, getTransformedFile(sourcePath)) : NULL_MODULE;
+    return moduleResolver.resolveDependency(from, id, true, platform, options.resolverOptions).path;
+  };
+};

package/dist/vendors/metro/src/ModuleGraph/output/indexed-ram-bundle.js

@@ -0,0 +1,71 @@
+"use strict";
+const { createRamBundleGroups } = require("../../Bundler/util");
+const { buildTableAndContents, createModuleGroups } = require("../../shared/output/RamBundle/as-indexed-file");
+const buildSourcemapWithMetadata = require("../../shared/output/RamBundle/buildSourcemapWithMetadata.js");
+const { getModuleCodeAndMap, partition, toModuleTransport } = require("./util");
+const invariant = require("invariant");
+function asIndexedRamBundle({
+  dependencyMapReservedName,
+  filename,
+  globalPrefix,
+  idsForPath,
+  modules,
+  preloadedModules,
+  ramGroupHeads,
+  requireCalls
+}) {
+  const idForPath = (x) => idsForPath(x).moduleId;
+  const [startup, deferred] = partition(modules, preloadedModules);
+  const startupModules = [...startup, ...requireCalls];
+  const deferredModules = deferred.map(
+    (m) => toModuleTransport(m, idsForPath, { dependencyMapReservedName, globalPrefix })
+  );
+  for (const m of deferredModules) {
+    invariant(
+      m.id >= 0,
+      `A script (non-module) cannot be part of the deferred modules of a RAM bundle (\`${m.sourcePath}\`, id=${m.id})`
+    );
+  }
+  const ramGroups = createRamBundleGroups(ramGroupHeads || [], deferredModules, subtree);
+  const moduleGroups = createModuleGroups(ramGroups, deferredModules);
+  const tableAndContents = buildTableAndContents(
+    startupModules.map(
+      (m) => getModuleCodeAndMap(m, idForPath, {
+        dependencyMapReservedName,
+        enableIDInlining: true,
+        globalPrefix
+      }).moduleCode
+    ).join("\n"),
+    deferredModules,
+    moduleGroups,
+    "utf8"
+  );
+  return {
+    code: Buffer.concat(tableAndContents),
+    map: buildSourcemapWithMetadata({
+      fixWrapperOffset: false,
+      lazyModules: deferredModules,
+      moduleGroups,
+      startupModules: startupModules.map(
+        (m) => toModuleTransport(m, idsForPath, {
+          dependencyMapReservedName,
+          globalPrefix
+        })
+      )
+    })
+  };
+}
+function* subtree(moduleTransport, moduleTransportsByPath, seen = /* @__PURE__ */ new Set()) {
+  seen.add(moduleTransport.id);
+  for (const { path } of moduleTransport.dependencies) {
+    const dependency = moduleTransportsByPath.get(path);
+    if (dependency && !seen.has(dependency.id)) {
+      yield dependency.id;
+      yield* subtree(dependency, moduleTransportsByPath, seen);
+    }
+  }
+}
+function createBuilder(preloadedModules, ramGroupHeads) {
+  return (x) => asIndexedRamBundle({ ...x, preloadedModules, ramGroupHeads });
+}
+exports.createBuilder = createBuilder;

package/dist/vendors/metro/src/ModuleGraph/output/multiple-files-ram-bundle.js

@@ -0,0 +1,53 @@
+"use strict";
+const buildSourcemapWithMetadata = require("../../shared/output/RamBundle/buildSourcemapWithMetadata.js");
+const MAGIC_UNBUNDLE_NUMBER = require("../../shared/output/RamBundle/magic-number");
+const { getModuleCodeAndMap, partition, toModuleTransport } = require("./util");
+const path = require("path");
+const MAGIC_UNBUNDLE_FILENAME = "UNBUNDLE";
+const JS_MODULES = "js-modules";
+function asMultipleFilesRamBundle({
+  dependencyMapReservedName,
+  filename,
+  globalPrefix,
+  idsForPath,
+  modules,
+  requireCalls,
+  preloadedModules
+}) {
+  const idForPath = (x) => idsForPath(x).moduleId;
+  const [startup, deferred] = partition(modules, preloadedModules);
+  const startupModules = [...startup, ...requireCalls];
+  const deferredModules = deferred.map(
+    (m) => toModuleTransport(m, idsForPath, { dependencyMapReservedName, globalPrefix })
+  );
+  const magicFileContents = Buffer.alloc(4);
+  const code = startupModules.map(
+    (m) => getModuleCodeAndMap(m, idForPath, {
+      dependencyMapReservedName,
+      enableIDInlining: true,
+      globalPrefix
+    }).moduleCode
+  ).join("\n");
+  const extraFiles = /* @__PURE__ */ new Map();
+  deferredModules.forEach((deferredModule) => {
+    extraFiles.set(path.join(JS_MODULES, deferredModule.id + ".js"), deferredModule.code);
+  });
+  magicFileContents.writeUInt32LE(MAGIC_UNBUNDLE_NUMBER, 0);
+  extraFiles.set(path.join(JS_MODULES, MAGIC_UNBUNDLE_FILENAME), magicFileContents);
+  const map = buildSourcemapWithMetadata({
+    fixWrapperOffset: false,
+    lazyModules: deferredModules,
+    moduleGroups: null,
+    startupModules: startupModules.map(
+      (m) => toModuleTransport(m, idsForPath, {
+        dependencyMapReservedName,
+        globalPrefix
+      })
+    )
+  });
+  return { code, extraFiles, map };
+}
+function createBuilder(preloadedModules, ramGroupHeads) {
+  return (x) => asMultipleFilesRamBundle({ ...x, preloadedModules, ramGroupHeads });
+}
+exports.createBuilder = createBuilder;

package/dist/vendors/metro/src/ModuleGraph/output/plain-bundle.js

@@ -0,0 +1,36 @@
+"use strict";
+const meta = require("../../shared/output/meta");
+const { concat, getModuleCodeAndMap } = require("./util");
+const { BundleBuilder } = require("metro-source-map");
+function asPlainBundle({
+  dependencyMapReservedName,
+  filename,
+  globalPrefix,
+  idsForPath,
+  modules,
+  requireCalls,
+  sourceMapPath,
+  enableIDInlining
+}) {
+  const builder = new BundleBuilder(filename);
+  const modIdForPath = (x) => idsForPath(x).moduleId;
+  for (const module2 of concat(modules, requireCalls)) {
+    const { moduleCode, moduleMap } = getModuleCodeAndMap(module2, modIdForPath, {
+      dependencyMapReservedName,
+      enableIDInlining,
+      globalPrefix
+    });
+    builder.append(moduleCode + "\n", moduleMap);
+  }
+  if (sourceMapPath) {
+    builder.append(`//# sourceMappingURL=${sourceMapPath}`);
+  }
+  const code = builder.getCode();
+  const map = builder.getMap();
+  return {
+    code,
+    extraFiles: [[`${filename}.meta`, meta(code)]],
+    map
+  };
+}
+module.exports = asPlainBundle;

package/dist/vendors/metro/src/ModuleGraph/output/reverse-dependency-map-references.js

@@ -0,0 +1,53 @@
+"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_invariant = __toESM(require("invariant"));
+var import_nullthrows = __toESM(require("nullthrows"));
+function reverseDependencyMapReferences({ types: t }) {
+  return {
+    visitor: {
+      CallExpression(path, state) {
+        const { node } = path;
+        if (node.callee.name === `${state.opts.globalPrefix}__d`) {
+          const lastArg = node.arguments[0].params.slice(-1)[0];
+          const depMapName = lastArg && lastArg.name;
+          if (depMapName == null) {
+            return;
+          }
+          const body = path.get("arguments.0.body");
+          (0, import_invariant.default)(!Array.isArray(body), "meetro: Expected `body` to be a single path.");
+          const scope = body.scope;
+          const binding = (0, import_nullthrows.default)(scope.getBinding(depMapName));
+          binding.referencePaths.forEach(({ parentPath }) => {
+            const memberNode = parentPath?.node;
+            if (memberNode != null && memberNode.type === "MemberExpression" && memberNode.property.type === "NumericLiteral") {
+              const numericLiteral = t.numericLiteral(state.opts.dependencyIds[memberNode.property.value]);
+              (0, import_nullthrows.default)(parentPath).replaceWith(numericLiteral);
+            }
+          });
+        }
+      }
+    }
+  };
+}
+module.exports = reverseDependencyMapReferences;

package/dist/vendors/metro/src/ModuleGraph/output/util.js

@@ -0,0 +1,168 @@
+"use strict";
+const virtualModule = require("../module").virtual;
+const generate = require("../worker/generate");
+const mergeSourceMaps = require("../worker/mergeSourceMaps");
+const reverseDependencyMapReferences = require("./reverse-dependency-map-references");
+const { parseSync, transformFromAstSync } = require("@babel/core");
+const { passthroughSyntaxPlugins } = require("metro-react-native-babel-preset");
+const { addParamsToDefineCall } = require("metro-transform-plugins");
+const nullthrows = require("nullthrows");
+function addModuleIdsToModuleWrapper(module2, idForPath) {
+  const { dependencies, file } = module2;
+  const { code } = file;
+  const fileId = idForPath(file);
+  const paramsToAdd = [fileId];
+  if (dependencies.length) {
+    paramsToAdd.push(dependencies.map(idForPath));
+  }
+  return addParamsToDefineCall(code, ...paramsToAdd);
+}
+exports.addModuleIdsToModuleWrapper = addModuleIdsToModuleWrapper;
+function isTypeScriptSource(fileName) {
+  return !!fileName && fileName.endsWith(".ts");
+}
+function isTSXSource(fileName) {
+  return !!fileName && fileName.endsWith(".tsx");
+}
+function inlineModuleIds(module2, idForPath, { dependencyMapReservedName, globalPrefix, ignoreMissingDependencyMapReference = false, hermesParser = false }) {
+  const { dependencies, file } = module2;
+  const { code, map, path } = file;
+  const fileId = idForPath(file);
+  const dependencyIds = dependencies.map(idForPath);
+  if (!dependencyIds.length) {
+    return { fileId, moduleCode: code, moduleMap: map };
+  }
+  if (dependencyMapReservedName != null) {
+    if (!code.includes(dependencyMapReservedName)) {
+      if (ignoreMissingDependencyMapReference) {
+        return { fileId, moduleCode: code, moduleMap: map };
+      }
+      throw new Error(
+        `Module has dependencies but does not use the preconfigured dependency map name '${dependencyMapReservedName}': ${file.path}
+This is an internal error in Metro.`
+      );
+    }
+    const WS = "[	 ]*";
+    const depMapReferenceRegex = new RegExp(
+      escapeRegex(dependencyMapReservedName) + `${WS}\\[${WS}([0-9]+)${WS}\\]`,
+      "g"
+    );
+    const inlinedCode = code.replace(depMapReferenceRegex, (match, depIndex) => {
+      const idStr = dependencyIds[Number.parseInt(depIndex, 10)].toString();
+      if (idStr.length > match.length) {
+        throw new Error(
+          `Module ID doesn't fit in available space; add ${idStr.length - match.length} more characters to 'dependencyMapReservedName'.`
+        );
+      }
+      return idStr.padEnd(match.length);
+    });
+    return {
+      fileId,
+      moduleCode: inlinedCode,
+      moduleMap: map
+    };
+  }
+  const babelConfig = {
+    ast: true,
+    babelrc: false,
+    browserslistConfigFile: false,
+    code: false,
+    configFile: false,
+    plugins: [...passthroughSyntaxPlugins, [reverseDependencyMapReferences, { dependencyIds, globalPrefix }]]
+  };
+  const sourceAst = isTypeScriptSource(path) || isTSXSource(path) || !hermesParser ? parseSync(code, babelConfig) : require("hermes-parser").parse(code, {
+    babel: true,
+    // $FlowFixMe[prop-missing]
+    sourceType: babelConfig.sourceType
+  });
+  const ast = nullthrows(transformFromAstSync(sourceAst, code, babelConfig).ast);
+  const { code: generatedCode, map: generatedMap } = generate(ast, path, "");
+  return {
+    fileId,
+    moduleCode: generatedCode,
+    moduleMap: map && generatedMap && mergeSourceMaps(path, map, generatedMap)
+  };
+}
+function inlineModuleIdsAndAddParamsToDefineCall(module2, idForPath, options) {
+  const { fileId, moduleCode, moduleMap } = inlineModuleIds(module2, idForPath, options);
+  return { moduleCode: addParamsToDefineCall(moduleCode, fileId), moduleMap };
+}
+exports.inlineModuleIds = inlineModuleIds;
+exports.inlineModuleIdsAndAddParamsToDefineCall = inlineModuleIdsAndAddParamsToDefineCall;
+function escapeRegex(str) {
+  return str.replace(/([.?*+^$[\]\\(){}|-])/g, "\\$1");
+}
+function getModuleCodeAndMap(module2, idForPath, options) {
+  const { file } = module2;
+  let moduleCode, moduleMap;
+  if (file.type !== "module") {
+    moduleCode = file.code;
+    moduleMap = file.map;
+  } else if (!options.enableIDInlining) {
+    moduleCode = addModuleIdsToModuleWrapper(module2, idForPath);
+    moduleMap = file.map;
+  } else {
+    ({ moduleCode, moduleMap } = inlineModuleIdsAndAddParamsToDefineCall(module2, idForPath, {
+      dependencyMapReservedName: options.dependencyMapReservedName,
+      globalPrefix: options.globalPrefix
+    }));
+  }
+  if (moduleMap && moduleMap.sources) {
+    const x_facebook_sources = [];
+    if (moduleMap.sources.length >= 1) {
+      x_facebook_sources.push([module2.file.functionMap]);
+    }
+    moduleMap = { ...moduleMap, x_facebook_sources };
+  }
+  return { moduleCode, moduleMap };
+}
+exports.getModuleCodeAndMap = getModuleCodeAndMap;
+exports.concat = function* concat(...iterables) {
+  for (const it of iterables) {
+    yield* it;
+  }
+};
+exports.createIdForPathFn = () => {
+  const seen = /* @__PURE__ */ new Map();
+  let next = 0;
+  return ({ path }) => {
+    let id = seen.get(path);
+    if (id == null) {
+      id = next++;
+      seen.set(path, id);
+    }
+    return id;
+  };
+};
+exports.requireCallsTo = function* (modules, idForPath, getRunModuleStatement) {
+  for (const module2 of modules) {
+    const id = idForPath(module2.file);
+    yield virtualModule(getRunModuleStatement(id), `/<generated>/require-${id}.js`);
+  }
+};
+exports.partition = (modules, preloadedModules) => {
+  const startup = [];
+  const deferred = [];
+  for (const module2 of modules) {
+    (preloadedModules.has(module2.file.path) ? startup : deferred).push(module2);
+  }
+  return [startup, deferred];
+};
+function toModuleTransport(module2, idsForPath, { dependencyMapReservedName, globalPrefix }) {
+  const { dependencies, file } = module2;
+  const { moduleCode, moduleMap } = getModuleCodeAndMap(module2, (x) => idsForPath(x).moduleId, {
+    dependencyMapReservedName,
+    enableIDInlining: true,
+    globalPrefix
+  });
+  return {
+    code: moduleCode,
+    dependencies,
+    // ID is required but we provide an invalid one for "script"s.
+    id: file.type === "module" ? nullthrows(idsForPath(file).localId) : -1,
+    map: moduleMap,
+    name: file.path,
+    sourcePath: file.path
+  };
+}
+exports.toModuleTransport = toModuleTransport;

package/dist/vendors/metro/src/ModuleGraph/silent-console.js

@@ -0,0 +1,5 @@
+"use strict";
+const { Console } = require("console");
+const { Writable } = require("stream");
+const write = (_, __, callback) => callback();
+module.exports = new Console(new Writable({ write, writev: write }));

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

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

package/dist/vendors/metro/src/ModuleGraph/worker/JsFileWrapping.js

@@ -0,0 +1,87 @@
+"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_template = __toESM(require("@babel/template"));
+var import_traverse = __toESM(require("@babel/traverse"));
+var t = __toESM(require("@babel/types"));
+var import_invariant = __toESM(require("invariant"));
+const WRAP_NAME = "$$_REQUIRE";
+const IIFE_PARAM = import_template.default.expression(
+  "typeof globalThis !== 'undefined' ? globalThis : typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : this"
+);
+function wrapModule(fileAst, importDefaultName, importAllName, dependencyMapName, globalPrefix) {
+  const params = buildParameters(importDefaultName, importAllName, dependencyMapName);
+  const factory = functionFromProgram(fileAst.program, params);
+  const def = t.callExpression(t.identifier(`${globalPrefix}__d`), [factory]);
+  const ast = t.file(t.program([t.expressionStatement(def)]));
+  const requireName = renameRequires(ast);
+  return { ast, requireName };
+}
+function wrapPolyfill(fileAst) {
+  const factory = functionFromProgram(fileAst.program, ["global"]);
+  const iife = t.callExpression(factory, [IIFE_PARAM()]);
+  return t.file(t.program([t.expressionStatement(iife)]));
+}
+function jsonToCommonJS(source) {
+  return `module.exports = ${source};`;
+}
+function wrapJson(source, globalPrefix) {
+  const moduleFactoryParameters = buildParameters("_importDefaultUnused", "_importAllUnused", "_dependencyMapUnused");
+  return [
+    `${globalPrefix}__d(function(${moduleFactoryParameters.join(", ")}) {`,
+    `  ${jsonToCommonJS(source)}`,
+    "});"
+  ].join("\n");
+}
+function functionFromProgram(program, parameters) {
+  return t.functionExpression(
+    void 0,
+    parameters.map(makeIdentifier),
+    t.blockStatement(program.body, program.directives)
+  );
+}
+function makeIdentifier(name) {
+  return t.identifier(name);
+}
+function buildParameters(importDefaultName, importAllName, dependencyMapName) {
+  return ["global", "require", importDefaultName, importAllName, "module", "exports", dependencyMapName];
+}
+function renameRequires(ast) {
+  let newRequireName = WRAP_NAME;
+  (0, import_traverse.default)(ast, {
+    Program(path) {
+      const body = path.get("body.0.expression.arguments.0.body");
+      (0, import_invariant.default)(!Array.isArray(body), "metro: Expected `body` to be a single path.");
+      newRequireName = body.scope.generateUid(WRAP_NAME);
+      body.scope.rename("require", newRequireName);
+    }
+  });
+  return newRequireName;
+}
+module.exports = {
+  WRAP_NAME,
+  wrapJson,
+  jsonToCommonJS,
+  wrapModule,
+  wrapPolyfill
+};

package/dist/vendors/metro/src/ModuleGraph/worker/Platforms.js

@@ -0,0 +1,3 @@
+"use strict";
+const VALID_PLATFORMS = /* @__PURE__ */ new Set(["ios", "android", "web"]);
+module.exports = { VALID_PLATFORMS };