@granite-js/mpack 0.0.0-dev-20250725013859

package/dist/logger/index.js

@@ -0,0 +1,31 @@
+"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 logger_exports = {};
+__export(logger_exports, {
+  clientLogger: () => import_clientLogger.clientLogger,
+  logger: () => import_Logger.logger
+});
+module.exports = __toCommonJS(logger_exports);
+var import_Logger = require("./Logger");
+var import_clientLogger = require("./clientLogger");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clientLogger,
+  logger
+});

package/dist/metro/assetRegistry.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @see https://github.com/facebook/react-native/blob/v0.72.6/packages/assets/registry.js#L13-L24
+ */
+interface Asset {
+    httpServerLocation: string;
+    hash: string;
+    name: string;
+    type: string;
+}
+declare function registerAsset(asset: Asset): void;
+declare function noop(): void;
+export { registerAsset, noop as getAssetByID };

package/dist/metro/assetRegistry.js

@@ -0,0 +1,57 @@
+"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 assetRegistry_exports = {};
+__export(assetRegistry_exports, {
+  getAssetByID: () => noop,
+  registerAsset: () => registerAsset
+});
+module.exports = __toCommonJS(assetRegistry_exports);
+const IGNORE_PATH_PATTERN = [/react-native\/Libraries\/LogBox\/UI/, /@react-navigation\/elements/];
+const assets = /* @__PURE__ */ new Set();
+function registerAsset(asset) {
+  const key = getUniqueKey(asset);
+  if (assets.has(key)) {
+    return;
+  }
+  assets.add(key);
+  warnUnableToUseLocalResources(asset);
+}
+function warnUnableToUseLocalResources(asset) {
+  const localPath = asset.httpServerLocation.replace(/^\/assets\//, "");
+  const fileName = `${asset.name}.${asset.type}`;
+  const shouldIgnore = IGNORE_PATH_PATTERN.some((pattern) => pattern.test(localPath));
+  if (__DEV__ && !shouldIgnore) {
+    console.warn(
+      [
+        "(DEV) \uB85C\uCEEC \uB9AC\uC18C\uC2A4\uB294 \uC9C0\uC6D0\uB418\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4. URI \uBC29\uC2DD\uC758 \uC6D0\uACA9 \uB9AC\uC18C\uC2A4\uB97C \uC0AC\uC6A9\uD574\uC8FC\uC138\uC694.",
+        `Resource: ${localPath}/${fileName}`
+      ].join("\n")
+    );
+  }
+}
+function getUniqueKey(asset) {
+  return `${asset.name}#${asset.hash}`;
+}
+function noop() {
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getAssetByID,
+  registerAsset
+});

package/dist/metro/enhancedResolver.d.ts

@@ -0,0 +1,7 @@
+interface CustomResolutionContext {
+    sourceExts: string[];
+    originModulePath: string;
+    preferNativePlatform?: boolean;
+}
+export declare function createResolver(rootPath: string): (context: CustomResolutionContext, request: string, platform: string | null) => any;
+export {};

package/dist/metro/enhancedResolver.js

@@ -0,0 +1,127 @@
+"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 enhancedResolver_exports = {};
+__export(enhancedResolver_exports, {
+  createResolver: () => createResolver
+});
+module.exports = __toCommonJS(enhancedResolver_exports);
+var import_module = __toESM(require("module"));
+var import_path = __toESM(require("path"));
+var import_enhanced_resolve = __toESM(require("enhanced-resolve"));
+var import_constants = require("../constants");
+const SINGLETON_MODULES = ["@babel/runtime"];
+const NATIVE_MODULES = ["react-native", "react"];
+const SUPPORTED_BUILTIN_FALLBACKS = {
+  http: "stream-http",
+  https: "https-browserify",
+  zlib: "browserify-zlib",
+  url: "url",
+  util: "util",
+  path: "path-browserify",
+  buffer: "buffer",
+  stream: "stream-browserify",
+  assert: "assert",
+  events: "events"
+};
+const builtinModules = new Set(import_module.default.builtinModules);
+const resolvers = /* @__PURE__ */ new Map();
+function createResolver(rootPath) {
+  function createResolverImpl(context, platform, rootPath2) {
+    const baseExtensions = context.sourceExts.map((extension) => `.${extension}`);
+    let finalExtensions = [...baseExtensions];
+    if (context.preferNativePlatform) {
+      finalExtensions = [...baseExtensions.map((extension) => `.native${extension}`), ...finalExtensions];
+    }
+    if (platform) {
+      finalExtensions = [...baseExtensions.map((extension) => `.${platform}${extension}`), ...finalExtensions];
+    }
+    const resolver = import_enhanced_resolve.default.create.sync({
+      extensions: finalExtensions,
+      mainFields: import_constants.RESOLVER_MAIN_FIELDS,
+      mainFiles: ["index"],
+      conditionNames: [...import_constants.RESOLVER_EXPORTS_MAP_CONDITIONS, "require", "node", "default"],
+      modules: ["node_modules", import_path.default.join(rootPath2, "src")]
+    });
+    function resolve(context2, request) {
+      for (const nativeModule of NATIVE_MODULES) {
+        if (request === nativeModule) {
+          return {
+            type: "sourceFile",
+            filePath: resolver({}, rootPath2, request)
+          };
+        }
+      }
+      for (const singletonModule of SINGLETON_MODULES) {
+        if (request.startsWith(singletonModule)) {
+          return {
+            type: "sourceFile",
+            filePath: resolver({}, rootPath2, request)
+          };
+        }
+      }
+      if (builtinModules.has(request)) {
+        if (request in SUPPORTED_BUILTIN_FALLBACKS) {
+          const source = SUPPORTED_BUILTIN_FALLBACKS[request];
+          return {
+            type: "sourceFile",
+            filePath: require.resolve(`${source}/`)
+          };
+        }
+        request = `${request}/`;
+      }
+      try {
+        const resolveResult = resolver({}, import_path.default.dirname(context2.originModulePath), request);
+        return {
+          type: "sourceFile",
+          filePath: resolveResult
+        };
+      } catch (error) {
+        const typedError = error;
+        if ("code" in typedError && typedError.code !== "QUALIFIED_PATH_RESOLUTION_FAILED") {
+          typedError.message = `"${context2.originModulePath}"\uC5D0\uC11C "${request}"\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC5C8\uC2B5\uB2C8\uB2E4.
+${typedError.message}`;
+        }
+        throw typedError;
+      }
+    }
+    return resolve;
+  }
+  return function resolve(context, request, platform) {
+    let resolver = resolvers.get(platform);
+    if (resolver == null) {
+      resolver = createResolverImpl(context, platform, rootPath);
+      resolvers.set(platform, resolver);
+    }
+    return resolver(context, request, platform);
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createResolver
+});

package/dist/metro/getMetroConfig.d.ts

@@ -0,0 +1,27 @@
+import type * as babel from '@babel/core';
+import type { MetroConfig } from './types';
+export interface GetMetroConfig {
+    rootPath: string;
+}
+export interface AdditionalMetroConfig extends MetroConfig {
+    /**
+     * Partial support for some options only
+     *
+     * - `getPolyfills`
+     */
+    serializer?: MetroConfig['serializer'];
+    /**
+     * Partial support for some options only
+     *
+     * - `blockList`
+     */
+    resolver?: MetroConfig['resolver'];
+    reporter?: MetroConfig['reporter'];
+    /**
+     * Script paths to be executed before the main module is run
+     */
+    prelude?: string[];
+    babelConfig?: babel.TransformOptions;
+    transformSync?: (id: string, code: string) => string;
+}
+export declare function getMetroConfig({ rootPath }: GetMetroConfig, additionalConfig?: AdditionalMetroConfig): Promise<any>;

package/dist/metro/getMetroConfig.js

@@ -0,0 +1,137 @@
+"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 getMetroConfig_exports = {};
+__export(getMetroConfig_exports, {
+  getMetroConfig: () => getMetroConfig
+});
+module.exports = __toCommonJS(getMetroConfig_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@granite-js/utils");
+var import_enhancedResolver = require("./enhancedResolver");
+var import_getMonorepoRoot = require("./getMonorepoRoot");
+var import_constants = require("../constants");
+var import_defaults = require("../vendors/metro-config/src/defaults");
+var import_exclusionList = __toESM(require("../vendors/metro-config/src/defaults/exclusionList"));
+var import_loadConfig = require("../vendors/metro-config/src/loadConfig");
+const INTERNAL_CALLSITES_REGEX = new RegExp(
+  [
+    "/Libraries/Renderer/implementations/.+\\.js$",
+    "/Libraries/BatchedBridge/MessageQueue\\.js$",
+    "/Libraries/YellowBox/.+\\.js$",
+    "/Libraries/LogBox/.+\\.js$",
+    "/Libraries/Core/Timers/.+\\.js$",
+    "/Libraries/WebSocket/.+\\.js$",
+    "/Libraries/vendor/.+\\.js$",
+    "/node_modules/react-devtools-core/.+\\.js$",
+    "/node_modules/react-refresh/.+\\.js$",
+    "/node_modules/scheduler/.+\\.js$",
+    "/node_modules/event-target-shim/.+\\.js$",
+    "/node_modules/invariant/.+\\.js$",
+    "/node_modules/react-native/index.js$",
+    "/metro-runtime/.+\\.js$",
+    "^\\[native code\\]$"
+  ].join("|")
+);
+async function getMetroConfig({ rootPath }, additionalConfig) {
+  const defaultConfig = (0, import_defaults.getDefaultValues)(rootPath);
+  const reactNativePath = import_path.default.dirname(resolveFromRoot("react-native/package.json", rootPath));
+  const resolvedRootPath = await (0, import_getMonorepoRoot.getMonorepoRoot)(rootPath);
+  const packageRootPath = await (0, import_utils.getPackageRoot)();
+  return (0, import_loadConfig.mergeConfig)(defaultConfig, {
+    watchFolders: [resolvedRootPath, packageRootPath],
+    transformerPath: resolveVendors("metro-transform-worker/src"),
+    transformer: {
+      allowOptionalDependencies: true,
+      assetRegistryPath: import_path.default.resolve(__dirname, "assetRegistry.js"),
+      workerPath: resolveVendors("metro/src/DeltaBundler/Worker"),
+      getTransformOptions: async () => ({
+        transform: {
+          experimentalImportSupport: false,
+          inlineRequires: false
+        }
+      }),
+      babelTransformerPath: require.resolve("metro-react-native-babel-transformer"),
+      asyncRequireModulePath: require.resolve("metro-runtime/src/modules/asyncRequire"),
+      unstable_collectDependenciesPath: resolveVendors("metro/src/ModuleGraph/worker/collectDependencies"),
+      unstable_allowRequireContext: true,
+      /**
+       * @see [WorkerFarm.js](../vendors/metro/src/DeltaBundler/WorkerFarm.js)
+       */
+      INTERNAL__transformSync: additionalConfig?.transformSync,
+      /**
+       * @see [index.js](../vendors/metro-transform-worker/src/index.js)
+       */
+      INTERNAL__babelConfig: additionalConfig?.babelConfig
+    },
+    resolver: {
+      // metro
+      platforms: ["android", "ios"],
+      useWatchman: false,
+      resolveRequest: (0, import_enhancedResolver.createResolver)(rootPath),
+      // metro-file-map
+      sourceExts: [...import_constants.SOURCE_EXTENSIONS.map((extension) => extension.replace(/^\.?/, "")), "cjs", "mjs"],
+      blockList: (0, import_exclusionList.default)(
+        additionalConfig?.resolver?.blockList ? asArray(additionalConfig.resolver.blockList) : []
+      )
+    },
+    serializer: {
+      getModulesRunBeforeMainModule: () => [resolveFromRoot("react-native/Libraries/Core/InitializeCore", rootPath)],
+      getPolyfills: () => [
+        ...require(import_path.default.join(reactNativePath, "rn-get-polyfills"))(),
+        ...additionalConfig?.serializer?.getPolyfills?.() ?? [],
+        ...additionalConfig?.prelude ?? []
+      ]
+    },
+    symbolicator: {
+      customizeFrame: (frame) => {
+        const collapse = Boolean(frame.file && INTERNAL_CALLSITES_REGEX.test(frame.file));
+        return { collapse };
+      }
+    },
+    server: {
+      port: import_constants.DEV_SERVER_DEFAULT_PORT
+    },
+    reporter: additionalConfig?.reporter,
+    ...process.env.METRO_RESET_CACHE !== "false" ? { resetCache: true } : {}
+  });
+}
+function resolveFromRoot(source, rootPath) {
+  return require.resolve(source, { paths: [rootPath] });
+}
+function resolveVendors(source) {
+  const vendorsBase = import_path.default.resolve(__dirname, "../vendors");
+  return require.resolve(import_path.default.join(vendorsBase, source));
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getMetroConfig
+});

package/dist/metro/getMonorepoRoot.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 단일 혹은 워크스페이스 기반 프로젝트 환경에서 적절한 루트 경로를 가져오는 유틸입니다
+ */
+export declare function getMonorepoRoot(basePath: string): Promise<string>;

package/dist/metro/getMonorepoRoot.js

@@ -0,0 +1,80 @@
+"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 getMonorepoRoot_exports = {};
+__export(getMonorepoRoot_exports, {
+  getMonorepoRoot: () => getMonorepoRoot
+});
+module.exports = __toCommonJS(getMonorepoRoot_exports);
+var import_promises = __toESM(require("fs/promises"));
+var import_path = __toESM(require("path"));
+var import_pnpapi = require("./pnpapi");
+async function getMonorepoRoot(basePath) {
+  if (import_pnpapi.pnpapi) {
+    return import_pnpapi.pnpapi.getPackageInformation(import_pnpapi.pnpapi.topLevel).packageLocation ?? null;
+  }
+  let curr = basePath;
+  while (curr !== import_path.default.dirname(curr)) {
+    if (await isWorkspace(basePath)) {
+      return curr;
+    }
+    curr = import_path.default.dirname(curr);
+  }
+  return basePath;
+}
+async function safeReadPackageJson(basePath) {
+  try {
+    return JSON.parse(await import_promises.default.readFile(import_path.default.join(basePath, "package.json"), "utf-8"));
+  } catch {
+  }
+}
+async function safeAccess(path2) {
+  try {
+    await import_promises.default.access(path2, import_promises.constants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isWorkspace(basePath) {
+  const packageJson = await safeReadPackageJson(basePath);
+  const hasPackageJson = Boolean(packageJson);
+  const hasWorkspacesField = Array.isArray(packageJson?.workspaces);
+  if (hasWorkspacesField) {
+    return true;
+  }
+  const hasWorkspaceManifest = await safeAccess(import_path.default.join(basePath, "pnpm-workspace.yaml"));
+  if (hasPackageJson && hasWorkspaceManifest) {
+    return true;
+  }
+  return false;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getMonorepoRoot
+});

package/dist/metro/index.d.ts

@@ -0,0 +1,3 @@
+export * from './getMetroConfig';
+export * from './runBuild';
+export type { MetroConfig } from './types';

package/dist/metro/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var metro_exports = {};
+module.exports = __toCommonJS(metro_exports);
+__reExport(metro_exports, require("./getMetroConfig"), module.exports);
+__reExport(metro_exports, require("./runBuild"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./getMetroConfig"),
+  ...require("./runBuild")
+});

package/dist/metro/pnpapi.d.ts

@@ -0,0 +1,6 @@
+import type { getPackageInformation, topLevel } from 'pnpapi';
+export interface PnpApi {
+    getPackageInformation: typeof getPackageInformation;
+    topLevel: typeof topLevel;
+}
+export declare let pnpapi: PnpApi | undefined;

package/dist/metro/pnpapi.js

@@ -0,0 +1,32 @@
+"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 pnpapi_exports = {};
+__export(pnpapi_exports, {
+  pnpapi: () => pnpapi
+});
+module.exports = __toCommonJS(pnpapi_exports);
+let pnpapi;
+try {
+  pnpapi = require("pnpapi");
+} catch {
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pnpapi
+});

package/dist/metro/runBuild.d.ts

@@ -0,0 +1,10 @@
+import type { MetroConfig } from './types';
+export declare function runBuild({ rootPath, entry, platform, minify, out, dev, additionalConfig, }: {
+    rootPath: string;
+    entry: string;
+    platform: 'ios' | 'android';
+    minify: boolean;
+    out: string;
+    dev: boolean;
+    additionalConfig?: MetroConfig;
+}): Promise<void>;

package/dist/metro/runBuild.js

@@ -0,0 +1,57 @@
+"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 runBuild_exports = {};
+__export(runBuild_exports, {
+  runBuild: () => runBuild
+});
+module.exports = __toCommonJS(runBuild_exports);
+var import_getMetroConfig = require("./getMetroConfig");
+var import_src = __toESM(require("../vendors/metro/src"));
+async function runBuild({
+  rootPath,
+  entry,
+  platform,
+  minify,
+  out,
+  dev,
+  additionalConfig
+}) {
+  const config = await (0, import_getMetroConfig.getMetroConfig)({ rootPath }, additionalConfig);
+  await import_src.default.runBuild(config, {
+    entry,
+    platform,
+    minify,
+    out,
+    dev
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runBuild
+});