@granite-js/mpack 0.0.0-dev-20250725013859

package/dist/types/schemas/buildConfigSchema.d.ts

@@ -0,0 +1,131 @@
+import z from 'zod';
+import type { AliasConfig, ProtocolConfig } from '../BuildConfig';
+export declare const esbuildConfigSchema: z.ZodType<(import("esbuild").BuildOptions & {
+    prelude?: string[];
+}) | undefined, z.ZodTypeDef, (import("esbuild").BuildOptions & {
+    prelude?: string[];
+}) | undefined>;
+export declare const babelConfigSchema: z.ZodObject<{
+    configFile: z.ZodOptional<z.ZodString>;
+    presets: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+    conditions: z.ZodOptional<z.ZodArray<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodBoolean>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    plugins?: any[] | undefined;
+    configFile?: string | undefined;
+    conditions?: ((...args: unknown[]) => boolean)[] | undefined;
+    presets?: any[] | undefined;
+}, {
+    plugins?: any[] | undefined;
+    configFile?: string | undefined;
+    conditions?: ((...args: unknown[]) => boolean)[] | undefined;
+    presets?: any[] | undefined;
+}>;
+export declare const swcConfigSchema: z.ZodObject<{
+    plugins: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+}, "strip", z.ZodTypeAny, {
+    plugins?: any[] | undefined;
+}, {
+    plugins?: any[] | undefined;
+}>;
+export declare const resolverConfigSchema: z.ZodObject<{
+    alias: z.ZodOptional<z.ZodArray<z.ZodType<AliasConfig, z.ZodTypeDef, AliasConfig>, "many">>;
+    protocols: z.ZodOptional<z.ZodType<ProtocolConfig, z.ZodTypeDef, ProtocolConfig>>;
+}, "strip", z.ZodTypeAny, {
+    alias?: AliasConfig[] | undefined;
+    protocols?: ProtocolConfig | undefined;
+}, {
+    alias?: AliasConfig[] | undefined;
+    protocols?: ProtocolConfig | undefined;
+}>;
+export declare const buildConfigSchema: z.ZodObject<{
+    platform: z.ZodEnum<["ios", "android"]>;
+    entry: z.ZodString;
+    outfile: z.ZodString;
+    resolver: z.ZodOptional<z.ZodObject<{
+        alias: z.ZodOptional<z.ZodArray<z.ZodType<AliasConfig, z.ZodTypeDef, AliasConfig>, "many">>;
+        protocols: z.ZodOptional<z.ZodType<ProtocolConfig, z.ZodTypeDef, ProtocolConfig>>;
+    }, "strip", z.ZodTypeAny, {
+        alias?: AliasConfig[] | undefined;
+        protocols?: ProtocolConfig | undefined;
+    }, {
+        alias?: AliasConfig[] | undefined;
+        protocols?: ProtocolConfig | undefined;
+    }>>;
+    esbuild: z.ZodOptional<z.ZodType<(import("esbuild").BuildOptions & {
+        prelude?: string[];
+    }) | undefined, z.ZodTypeDef, (import("esbuild").BuildOptions & {
+        prelude?: string[];
+    }) | undefined>>;
+    babel: z.ZodOptional<z.ZodObject<{
+        configFile: z.ZodOptional<z.ZodString>;
+        presets: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+        plugins: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+        conditions: z.ZodOptional<z.ZodArray<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodBoolean>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        plugins?: any[] | undefined;
+        configFile?: string | undefined;
+        conditions?: ((...args: unknown[]) => boolean)[] | undefined;
+        presets?: any[] | undefined;
+    }, {
+        plugins?: any[] | undefined;
+        configFile?: string | undefined;
+        conditions?: ((...args: unknown[]) => boolean)[] | undefined;
+        presets?: any[] | undefined;
+    }>>;
+    swc: z.ZodOptional<z.ZodObject<{
+        plugins: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        plugins?: any[] | undefined;
+    }, {
+        plugins?: any[] | undefined;
+    }>>;
+    extra: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    outfile: string;
+    platform: "ios" | "android";
+    entry: string;
+    extra?: any;
+    resolver?: {
+        alias?: AliasConfig[] | undefined;
+        protocols?: ProtocolConfig | undefined;
+    } | undefined;
+    esbuild?: (import("esbuild").BuildOptions & {
+        prelude?: string[];
+    }) | undefined;
+    babel?: {
+        plugins?: any[] | undefined;
+        configFile?: string | undefined;
+        conditions?: ((...args: unknown[]) => boolean)[] | undefined;
+        presets?: any[] | undefined;
+    } | undefined;
+    swc?: {
+        plugins?: any[] | undefined;
+    } | undefined;
+}, {
+    outfile: string;
+    platform: "ios" | "android";
+    entry: string;
+    extra?: any;
+    resolver?: {
+        alias?: AliasConfig[] | undefined;
+        protocols?: ProtocolConfig | undefined;
+    } | undefined;
+    esbuild?: (import("esbuild").BuildOptions & {
+        prelude?: string[];
+    }) | undefined;
+    babel?: {
+        plugins?: any[] | undefined;
+        configFile?: string | undefined;
+        conditions?: ((...args: unknown[]) => boolean)[] | undefined;
+        presets?: any[] | undefined;
+    } | undefined;
+    swc?: {
+        plugins?: any[] | undefined;
+    } | undefined;
+}>;
+export type EsbuildConfig = z.infer<typeof esbuildConfigSchema>;
+export type BabelConfig = z.infer<typeof babelConfigSchema>;
+export type SwcConfig = z.infer<typeof swcConfigSchema>;
+export type ResolverConfig = z.infer<typeof resolverConfigSchema>;
+export type RawBuildConfig = z.infer<typeof buildConfigSchema>;

package/dist/types/schemas/buildConfigSchema.js

@@ -0,0 +1,70 @@
+"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 buildConfigSchema_exports = {};
+__export(buildConfigSchema_exports, {
+  babelConfigSchema: () => babelConfigSchema,
+  buildConfigSchema: () => buildConfigSchema,
+  esbuildConfigSchema: () => esbuildConfigSchema,
+  resolverConfigSchema: () => resolverConfigSchema,
+  swcConfigSchema: () => swcConfigSchema
+});
+module.exports = __toCommonJS(buildConfigSchema_exports);
+var import_zod = __toESM(require("zod"));
+const esbuildConfigSchema = import_zod.default.custom();
+const babelConfigSchema = import_zod.default.object({
+  configFile: import_zod.default.string().optional(),
+  presets: import_zod.default.array(import_zod.default.any()).optional(),
+  plugins: import_zod.default.array(import_zod.default.any()).optional(),
+  conditions: import_zod.default.array(import_zod.default.function().returns(import_zod.default.boolean())).optional()
+});
+const swcConfigSchema = import_zod.default.object({
+  plugins: import_zod.default.array(import_zod.default.any()).optional()
+});
+const resolverConfigSchema = import_zod.default.object({
+  alias: import_zod.default.array(import_zod.default.custom()).optional(),
+  protocols: import_zod.default.custom().optional()
+});
+const buildConfigSchema = import_zod.default.object({
+  platform: import_zod.default.enum(["ios", "android"]),
+  entry: import_zod.default.string(),
+  outfile: import_zod.default.string(),
+  resolver: resolverConfigSchema.optional(),
+  esbuild: esbuildConfigSchema.optional(),
+  babel: babelConfigSchema.optional(),
+  swc: swcConfigSchema.optional(),
+  extra: import_zod.default.any().optional()
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  babelConfigSchema,
+  buildConfigSchema,
+  esbuildConfigSchema,
+  resolverConfigSchema,
+  swcConfigSchema
+});

package/dist/types/schemas/index.d.ts

@@ -0,0 +1 @@
+export * from './buildConfigSchema';

package/dist/types/schemas/index.js

@@ -0,0 +1,22 @@
+"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 schemas_exports = {};
+module.exports = __toCommonJS(schemas_exports);
+__reExport(schemas_exports, require("./buildConfigSchema"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./buildConfigSchema")
+});

package/dist/utils/cleanupOutputDirectory.d.ts

@@ -0,0 +1 @@
+export declare function cleanupOutputDirectory(directories: string[]): Promise<[Promise<void>[]]>;

package/dist/utils/cleanupOutputDirectory.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 __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 cleanupOutputDirectory_exports = {};
+__export(cleanupOutputDirectory_exports, {
+  cleanupOutputDirectory: () => cleanupOutputDirectory
+});
+module.exports = __toCommonJS(cleanupOutputDirectory_exports);
+var fs = __toESM(require("fs/promises"));
+var import_logger = require("../logger");
+async function removeDir(dirPath) {
+  try {
+    await fs.access(dirPath);
+    await fs.rm(dirPath, { recursive: true, force: true });
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+}
+function cleanupOutputDirectory(directories) {
+  import_logger.logger.info(`\u{1F9F9} \uBE4C\uB4DC \uD3F4\uB354\uB97C \uC815\uB9AC\uD569\uB2C8\uB2E4...`);
+  return Promise.all([directories.map(removeDir)]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cleanupOutputDirectory
+});

package/dist/utils/defineStepName.d.ts

@@ -0,0 +1,2 @@
+import type { AsyncTransformStep } from '../transformer/TransformPipeline';
+export declare function defineStepName(step: AsyncTransformStep, name: string): void;

package/dist/utils/defineStepName.js

@@ -0,0 +1,30 @@
+"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 defineStepName_exports = {};
+__export(defineStepName_exports, {
+  defineStepName: () => defineStepName
+});
+module.exports = __toCommonJS(defineStepName_exports);
+function defineStepName(step, name) {
+  Object.defineProperty(step, "name", { value: name });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defineStepName
+});

package/dist/utils/esbuildUtils.d.ts

@@ -0,0 +1 @@
+export declare const normalizePath: (path: string) => string;

package/dist/utils/esbuildUtils.js

@@ -0,0 +1,45 @@
+"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 esbuildUtils_exports = {};
+__export(esbuildUtils_exports, {
+  normalizePath: () => normalizePath
+});
+module.exports = __toCommonJS(esbuildUtils_exports);
+var import_os = __toESM(require("os"));
+const win32Impl = {
+  normalizePath: (path) => path.replace(/\\/g, "/")
+};
+const posixImpl = {
+  normalizePath: (path) => path
+};
+const { normalizePath } = import_os.default.type() === "Windows_NT" ? win32Impl : posixImpl;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  normalizePath
+});

package/dist/utils/getBundleName.d.ts

@@ -0,0 +1 @@
+export declare function getBundleName(name: string): `${string}.bundle`;

package/dist/utils/getBundleName.js

@@ -0,0 +1,30 @@
+"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 getBundleName_exports = {};
+__export(getBundleName_exports, {
+  getBundleName: () => getBundleName
+});
+module.exports = __toCommonJS(getBundleName_exports);
+function getBundleName(name) {
+  return `${name}.bundle`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getBundleName
+});

package/dist/utils/getBundleOutputs.d.ts

@@ -0,0 +1,5 @@
+import * as esbuild from 'esbuild';
+export declare function getBundleOutputs(outputFile: string, buildResult: esbuild.BuildResult): {
+    source: esbuild.OutputFile | undefined;
+    sourcemap: esbuild.OutputFile | undefined;
+};

package/dist/utils/getBundleOutputs.js

@@ -0,0 +1,49 @@
+"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 getBundleOutputs_exports = {};
+__export(getBundleOutputs_exports, {
+  getBundleOutputs: () => getBundleOutputs
+});
+module.exports = __toCommonJS(getBundleOutputs_exports);
+var path = __toESM(require("path"));
+var import_getSourcemapName = require("./getSourcemapName");
+function getBundleOutputs(outputFile, buildResult) {
+  const filename = path.basename(outputFile);
+  const outputFiles = buildResult.outputFiles;
+  const source = findOutputFile(filename, outputFiles);
+  const sourcemap = findOutputFile((0, import_getSourcemapName.getSourcemapName)(filename), outputFiles);
+  return { source, sourcemap };
+}
+function findOutputFile(targetFile, outputFiles) {
+  return outputFiles?.find((outfile) => outfile.path.endsWith(targetFile));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getBundleOutputs
+});

package/dist/utils/getId.d.ts

@@ -0,0 +1,2 @@
+import type { BundlerConfig, INTERNAL__Id } from '../types';
+export declare function getId(bundleConfig: BundlerConfig): INTERNAL__Id;

package/dist/utils/getId.js

@@ -0,0 +1,34 @@
+"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 getId_exports = {};
+__export(getId_exports, {
+  getId: () => getId
+});
+module.exports = __toCommonJS(getId_exports);
+var import_md5 = require("./md5");
+var import_constants = require("../constants");
+function getId(bundleConfig) {
+  return (0, import_md5.md5)(
+    JSON.stringify([import_constants.VERSION, bundleConfig.rootDir, bundleConfig.dev, bundleConfig.buildConfig])
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getId
+});

package/dist/utils/getSourcemapName.d.ts

@@ -0,0 +1 @@
+export declare function getSourcemapName(bundleFile: string): string;

package/dist/utils/getSourcemapName.js

@@ -0,0 +1,30 @@
+"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 getSourcemapName_exports = {};
+__export(getSourcemapName_exports, {
+  getSourcemapName: () => getSourcemapName
+});
+module.exports = __toCommonJS(getSourcemapName_exports);
+function getSourcemapName(bundleFile) {
+  return `${bundleFile}.map`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getSourcemapName
+});

package/dist/utils/index.d.ts

@@ -0,0 +1,7 @@
+export * from './mergeBuildConfigs';
+export * from './mergeEsbuild';
+export * from './mergeSwc';
+export * from './mergeTransformer';
+export * from './mergeBabel';
+export * from './mergeResolver';
+export * from './mergeExtra';

package/dist/utils/index.js

@@ -0,0 +1,34 @@
+"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 utils_exports = {};
+module.exports = __toCommonJS(utils_exports);
+__reExport(utils_exports, require("./mergeBuildConfigs"), module.exports);
+__reExport(utils_exports, require("./mergeEsbuild"), module.exports);
+__reExport(utils_exports, require("./mergeSwc"), module.exports);
+__reExport(utils_exports, require("./mergeTransformer"), module.exports);
+__reExport(utils_exports, require("./mergeBabel"), module.exports);
+__reExport(utils_exports, require("./mergeResolver"), module.exports);
+__reExport(utils_exports, require("./mergeExtra"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./mergeBuildConfigs"),
+  ...require("./mergeEsbuild"),
+  ...require("./mergeSwc"),
+  ...require("./mergeTransformer"),
+  ...require("./mergeBabel"),
+  ...require("./mergeResolver"),
+  ...require("./mergeExtra")
+});

package/dist/utils/isDebugMode.d.ts

@@ -0,0 +1 @@
+export declare function isDebugMode(scope: string): boolean;

package/dist/utils/isDebugMode.js

@@ -0,0 +1,30 @@
+"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 isDebugMode_exports = {};
+__export(isDebugMode_exports, {
+  isDebugMode: () => isDebugMode
+});
+module.exports = __toCommonJS(isDebugMode_exports);
+function isDebugMode(scope) {
+  return process.env.DEBUG === "*" || process.env.DEBUG === scope;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isDebugMode
+});

package/dist/utils/md5.d.ts

@@ -0,0 +1 @@
+export declare function md5(...args: Array<string | number>): string;

package/dist/utils/md5.js

@@ -0,0 +1,41 @@
+"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 md5_exports = {};
+__export(md5_exports, {
+  md5: () => md5
+});
+module.exports = __toCommonJS(md5_exports);
+var crypto = __toESM(require("crypto"));
+function md5(...args) {
+  return crypto.createHash("md5").update(args.join("")).digest("hex");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  md5
+});

package/dist/utils/mergeBabel.d.ts

@@ -0,0 +1,2 @@
+import type { BuildConfig } from '../types';
+export declare function mergeBabel(source: BuildConfig['babel'], target: BuildConfig['babel']): BuildConfig['babel'];