@granite-js/mpack 0.0.1

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

@@ -0,0 +1,3 @@
+import z from 'zod';
+import { ServicesConfig } from '../ServicesConfig';
+export declare const servicesConfigSchema: z.ZodType<ServicesConfig>;

package/dist/types/schemas/servicesConfigSchema.js

@@ -0,0 +1,48 @@
+"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 servicesConfigSchema_exports = {};
+__export(servicesConfigSchema_exports, {
+  servicesConfigSchema: () => servicesConfigSchema
+});
+module.exports = __toCommonJS(servicesConfigSchema_exports);
+var import_zod = __toESM(require("zod"));
+const servicesConfigSchema = import_zod.default.object({
+  sentry: import_zod.default.object({
+    enabled: import_zod.default.boolean().optional().default(true),
+    authToken: import_zod.default.string().optional(),
+    org: import_zod.default.string().optional(),
+    project: import_zod.default.string().optional(),
+    release: import_zod.default.any().optional(),
+    sourcemap: import_zod.default.any().optional()
+  }).optional()
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  servicesConfigSchema
+});

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

@@ -0,0 +1,3 @@
+import z from 'zod';
+import type { TaskConfig } from '../TaskConfig';
+export declare const taskConfigSchema: z.ZodType<TaskConfig>;

package/dist/types/schemas/taskConfigSchema.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 taskConfigSchema_exports = {};
+__export(taskConfigSchema_exports, {
+  taskConfigSchema: () => taskConfigSchema
+});
+module.exports = __toCommonJS(taskConfigSchema_exports);
+var import_zod = __toESM(require("zod"));
+var import_buildConfigSchema = require("./buildConfigSchema");
+const taskConfigSchema = import_zod.default.object({
+  tag: import_zod.default.string(),
+  presets: import_zod.default.array(import_zod.default.any()).optional(),
+  extra: import_zod.default.any().optional(),
+  build: import_buildConfigSchema.buildConfigSchema
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  taskConfigSchema
+});

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,41 @@
+"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.appName,
+      bundleConfig.rootDir,
+      bundleConfig.dev,
+      bundleConfig.services,
+      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/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/loadConfig.d.ts

@@ -0,0 +1,2 @@
+import type { BundlerConfig } from '../types';
+export declare function loadConfig({ rootDir }: Pick<BundlerConfig, 'rootDir'>): Promise<import("..").Config | null>;

package/dist/utils/loadConfig.js

@@ -0,0 +1,37 @@
+"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 loadConfig_exports = {};
+__export(loadConfig_exports, {
+  loadConfig: () => loadConfig
+});
+module.exports = __toCommonJS(loadConfig_exports);
+var import_cosmiconfig = require("cosmiconfig");
+var import_schemas = require("../types/schemas");
+async function loadConfig({ rootDir }) {
+  const explorer = await (0, import_cosmiconfig.cosmiconfig)("mpack");
+  const result = await explorer.search(rootDir);
+  if (result == null) {
+    return null;
+  }
+  return import_schemas.configSchema.parse(result.config);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loadConfig
+});

package/dist/utils/loadPresets.d.ts

@@ -0,0 +1,2 @@
+import type { PresetContext, TaskConfig } from '../types';
+export declare function loadPresets(task: TaskConfig, context: PresetContext): Promise<TaskConfig>;

package/dist/utils/loadPresets.js

@@ -0,0 +1,40 @@
+"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 loadPresets_exports = {};
+__export(loadPresets_exports, {
+  loadPresets: () => loadPresets
+});
+module.exports = __toCommonJS(loadPresets_exports);
+var import_es_toolkit = require("es-toolkit");
+var import_mergeBuildConfigs = require("./mergeBuildConfigs");
+async function loadPresets(task, context) {
+  let buildConfig = task.build;
+  if (Array.isArray(task.presets) && task.presets.length > 0) {
+    const [baseConfig, ...configs] = [
+      ...await Promise.all(task.presets.map(async (preset) => Promise.resolve(preset(context)))),
+      task.build
+    ].filter(import_es_toolkit.isNotNil);
+    buildConfig = (0, import_mergeBuildConfigs.mergeBuildConfigs)({ ...buildConfig, ...baseConfig }, ...configs);
+  }
+  return { ...(0, import_es_toolkit.omit)(task, ["presets"]), build: buildConfig };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loadPresets
+});

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/mergeBanners.d.ts

@@ -0,0 +1,6 @@
+import { BuildOptions } from 'esbuild';
+type Banner = {
+    [type: string]: string | false;
+};
+export declare function mergeBanners(baseBanner: Banner, overrideBanner: Banner): BuildOptions["banner"];
+export {};

package/dist/utils/mergeBanners.js

@@ -0,0 +1,35 @@
+"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 mergeBanners_exports = {};
+__export(mergeBanners_exports, {
+  mergeBanners: () => mergeBanners
+});
+module.exports = __toCommonJS(mergeBanners_exports);
+function mergeBanners(baseBanner, overrideBanner) {
+  const result = { ...baseBanner };
+  for (const [key, value] of Object.entries(overrideBanner)) {
+    result[key] = `${result[key] ?? ""}
+${value}`;
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mergeBanners
+});

package/dist/utils/mergeBuildConfigs.d.ts

@@ -0,0 +1,2 @@
+import type { BuildConfig } from '../types';
+export declare function mergeBuildConfigs(baseConfig: BuildConfig, ...otherConfigs: Partial<BuildConfig>[]): BuildConfig;