@granite-js/mpack 0.0.0-dev-20250725013859

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;

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;