@storm-software/tsup 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2996 @@
+"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 __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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);
+
+// ../../node_modules/.pnpm/tsup@8.4.0_patch_hash=751a554d775c3572381af4e7e5fa22eeda6dd6856012fb1cf521d6806eb2dc74__27cd8c2707e42da8a6ff3e707ec47ae0/node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "../../node_modules/.pnpm/tsup@8.4.0_patch_hash=751a554d775c3572381af4e7e5fa22eeda6dd6856012fb1cf521d6806eb2dc74__27cd8c2707e42da8a6ff3e707ec47ae0/node_modules/tsup/assets/cjs_shims.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/.pnpm/tsup@8.4.0_patch_hash=751a554d775c3572381af4e7e5fa22eeda6dd6856012fb1cf521d6806eb2dc74__27cd8c2707e42da8a6ff3e707ec47ae0/node_modules/tsup/dist/chunk-BYH4XDRH.js
+var require_chunk_BYH4XDRH = __commonJS({
+  "../../node_modules/.pnpm/tsup@8.4.0_patch_hash=751a554d775c3572381af4e7e5fa22eeda6dd6856012fb1cf521d6806eb2dc74__27cd8c2707e42da8a6ff3e707ec47ae0/node_modules/tsup/dist/chunk-BYH4XDRH.js"(exports2) {
+    "use strict";
+    init_cjs_shims();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var version = "8.4.0";
+    exports2.version = version;
+  }
+});
+
+// ../../node_modules/.pnpm/tsup@8.4.0_patch_hash=751a554d775c3572381af4e7e5fa22eeda6dd6856012fb1cf521d6806eb2dc74__27cd8c2707e42da8a6ff3e707ec47ae0/node_modules/tsup/dist/chunk-TWFEYLU4.js
+var require_chunk_TWFEYLU4 = __commonJS({
+  "../../node_modules/.pnpm/tsup@8.4.0_patch_hash=751a554d775c3572381af4e7e5fa22eeda6dd6856012fb1cf521d6806eb2dc74__27cd8c2707e42da8a6ff3e707ec47ae0/node_modules/tsup/dist/chunk-TWFEYLU4.js"(exports2) {
+    "use strict";
+    init_cjs_shims();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    function _optionalChain(ops) {
+      let lastAccessLHS = void 0;
+      let value = ops[0];
+      let i = 1;
+      while (i < ops.length) {
+        const op = ops[i];
+        const fn = ops[i + 1];
+        i += 2;
+        if ((op === "optionalAccess" || op === "optionalCall") && value == null) {
+          return void 0;
+        }
+        if (op === "access" || op === "optionalAccess") {
+          lastAccessLHS = value;
+          value = fn(value);
+        } else if (op === "call" || op === "optionalCall") {
+          value = fn((...args) => value.call(lastAccessLHS, ...args));
+          lastAccessLHS = void 0;
+        }
+      }
+      return value;
+    }
+    var __create2 = Object.create;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+      get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+    }) : x)(function(x) {
+      if (typeof require !== "undefined") return require.apply(this, arguments);
+      throw Error('Dynamic require of "' + x + '" is not supported');
+    });
+    var __commonJS2 = (cb, mod) => function __require2() {
+      return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // 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 ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var _fs = require("fs");
+    var _fs2 = _interopRequireDefault(_fs);
+    var _path = require("path");
+    var _path2 = _interopRequireDefault(_path);
+    var _resolvefrom = require("resolve-from");
+    var _resolvefrom2 = _interopRequireDefault(_resolvefrom);
+    var singleComment = Symbol("singleComment");
+    var multiComment = Symbol("multiComment");
+    var stripWithoutWhitespace = () => "";
+    var stripWithWhitespace = (string, start, end) => string.slice(start, end).replace(/\S/g, " ");
+    var isEscaped = (jsonString, quotePosition) => {
+      let index = quotePosition - 1;
+      let backslashCount = 0;
+      while (jsonString[index] === "\\") {
+        index -= 1;
+        backslashCount += 1;
+      }
+      return Boolean(backslashCount % 2);
+    };
+    function stripJsonComments(jsonString, { whitespace = true, trailingCommas = false } = {}) {
+      if (typeof jsonString !== "string") {
+        throw new TypeError(`Expected argument \`jsonString\` to be a \`string\`, got \`${typeof jsonString}\``);
+      }
+      const strip = whitespace ? stripWithWhitespace : stripWithoutWhitespace;
+      let isInsideString = false;
+      let isInsideComment = false;
+      let offset = 0;
+      let buffer = "";
+      let result = "";
+      let commaIndex = -1;
+      for (let index = 0; index < jsonString.length; index++) {
+        const currentCharacter = jsonString[index];
+        const nextCharacter = jsonString[index + 1];
+        if (!isInsideComment && currentCharacter === '"') {
+          const escaped = isEscaped(jsonString, index);
+          if (!escaped) {
+            isInsideString = !isInsideString;
+          }
+        }
+        if (isInsideString) {
+          continue;
+        }
+        if (!isInsideComment && currentCharacter + nextCharacter === "//") {
+          buffer += jsonString.slice(offset, index);
+          offset = index;
+          isInsideComment = singleComment;
+          index++;
+        } else if (isInsideComment === singleComment && currentCharacter + nextCharacter === "\r\n") {
+          index++;
+          isInsideComment = false;
+          buffer += strip(jsonString, offset, index);
+          offset = index;
+          continue;
+        } else if (isInsideComment === singleComment && currentCharacter === "\n") {
+          isInsideComment = false;
+          buffer += strip(jsonString, offset, index);
+          offset = index;
+        } else if (!isInsideComment && currentCharacter + nextCharacter === "/*") {
+          buffer += jsonString.slice(offset, index);
+          offset = index;
+          isInsideComment = multiComment;
+          index++;
+          continue;
+        } else if (isInsideComment === multiComment && currentCharacter + nextCharacter === "*/") {
+          index++;
+          isInsideComment = false;
+          buffer += strip(jsonString, offset, index + 1);
+          offset = index + 1;
+          continue;
+        } else if (trailingCommas && !isInsideComment) {
+          if (commaIndex !== -1) {
+            if (currentCharacter === "}" || currentCharacter === "]") {
+              buffer += jsonString.slice(offset, index);
+              result += strip(buffer, 0, 1) + buffer.slice(1);
+              buffer = "";
+              offset = index;
+              commaIndex = -1;
+            } else if (currentCharacter !== " " && currentCharacter !== "	" && currentCharacter !== "\r" && currentCharacter !== "\n") {
+              buffer += jsonString.slice(offset, index);
+              offset = index;
+              commaIndex = -1;
+            }
+          } else if (currentCharacter === ",") {
+            result += buffer + jsonString.slice(offset, index);
+            buffer = "";
+            offset = index;
+            commaIndex = index;
+          }
+        }
+      }
+      return result + buffer + (isInsideComment ? strip(jsonString.slice(offset)) : jsonString.slice(offset));
+    }
+    var _tinyglobby = require("tinyglobby");
+    function getPostcss() {
+      return localRequire("postcss");
+    }
+    function getApiExtractor() {
+      return localRequire("@microsoft/api-extractor");
+    }
+    function localRequire(moduleName) {
+      const p = _resolvefrom2.default.silent(process.cwd(), moduleName);
+      return p && __require(p);
+    }
+    async function removeFiles(patterns, dir) {
+      const files = await _tinyglobby.glob.call(void 0, patterns, {
+        cwd: dir,
+        absolute: true
+      });
+      files.forEach((file) => _fs2.default.existsSync(file) && _fs2.default.unlinkSync(file));
+    }
+    function debouncePromise(fn, delay, onError) {
+      let timeout;
+      let promiseInFly;
+      let callbackPending;
+      return function debounced(...args) {
+        if (promiseInFly) {
+          callbackPending = () => {
+            debounced(...args);
+            callbackPending = void 0;
+          };
+        } else {
+          if (timeout != null) clearTimeout(timeout);
+          timeout = setTimeout(() => {
+            timeout = void 0;
+            promiseInFly = fn(...args).catch(onError).finally(() => {
+              promiseInFly = void 0;
+              if (callbackPending) callbackPending();
+            });
+          }, delay);
+        }
+      };
+    }
+    function slash(path2) {
+      const isExtendedLengthPath = path2.startsWith("\\\\?\\");
+      if (isExtendedLengthPath) {
+        return path2;
+      }
+      return path2.replace(/\\/g, "/");
+    }
+    function truthy(value) {
+      return Boolean(value);
+    }
+    function jsoncParse(data) {
+      try {
+        return new Function(`return ${stripJsonComments(data).trim()}`)();
+      } catch (e2) {
+        return {};
+      }
+    }
+    function defaultOutExtension({
+      format,
+      pkgType
+    }) {
+      let jsExtension = ".js";
+      let dtsExtension = ".d.ts";
+      const isModule = pkgType === "module";
+      if (isModule && format === "cjs") {
+        jsExtension = ".cjs";
+        dtsExtension = ".d.cts";
+      }
+      if (!isModule && format === "esm") {
+        jsExtension = ".mjs";
+        dtsExtension = ".d.mts";
+      }
+      if (format === "iife") {
+        jsExtension = ".global.js";
+      }
+      return {
+        js: jsExtension,
+        dts: dtsExtension
+      };
+    }
+    function ensureTempDeclarationDir(options2) {
+      const cwd = options2.workspaceConfig?.workspaceRoot || process.cwd();
+      const dirPath = _path2.default.join(cwd, ".tsup", "declaration");
+      if (_fs2.default.existsSync(dirPath)) {
+        return dirPath;
+      }
+      _fs2.default.mkdirSync(dirPath, { recursive: true });
+      const gitIgnorePath = _path2.default.join(cwd, ".tsup", ".gitignore");
+      writeFileSync(gitIgnorePath, "**/*\n");
+      return dirPath;
+    }
+    var toObjectEntry = (entry) => {
+      if (typeof entry === "string") {
+        entry = [entry];
+      }
+      if (!Array.isArray(entry)) {
+        return entry;
+      }
+      entry = entry.map((e) => e.replace(/\\/g, "/"));
+      const ancestor = findLowestCommonAncestor(entry);
+      return entry.reduce(
+        (result, item) => {
+          const key = item.replace(ancestor, "").replace(/^\//, "").replace(/\.[a-z]+$/, "");
+          return {
+            ...result,
+            [key]: item
+          };
+        },
+        {}
+      );
+    };
+    var findLowestCommonAncestor = (filepaths) => {
+      if (filepaths.length <= 1) return "";
+      const [first, ...rest] = filepaths;
+      let ancestor = first.split("/");
+      for (const filepath of rest) {
+        const directories = filepath.split("/", ancestor.length);
+        let index = 0;
+        for (const directory of directories) {
+          if (directory === ancestor[index]) {
+            index += 1;
+          } else {
+            ancestor = ancestor.slice(0, index);
+            break;
+          }
+        }
+        ancestor = ancestor.slice(0, index);
+      }
+      return ancestor.length <= 1 && ancestor[0] === "" ? `/${ancestor[0]}` : ancestor.join("/");
+    };
+    function toAbsolutePath(p, cwd) {
+      if (_path2.default.isAbsolute(p)) {
+        return p;
+      }
+      return slash(_path2.default.normalize(_path2.default.join(cwd || process.cwd(), p)));
+    }
+    function writeFileSync(filePath, content) {
+      _fs2.default.mkdirSync(_path2.default.dirname(filePath), { recursive: true });
+      _fs2.default.writeFileSync(filePath, content);
+    }
+    function replaceDtsWithJsExtensions(dtsFilePath) {
+      return dtsFilePath.replace(
+        /\.d\.(ts|mts|cts)$/,
+        (_, fileExtension) => {
+          switch (fileExtension) {
+            case "ts":
+              return ".js";
+            case "mts":
+              return ".mjs";
+            case "cts":
+              return ".cjs";
+            default:
+              return "";
+          }
+        }
+      );
+    }
+    var convertArrayEntriesToObjectEntries = (arrayOfEntries) => {
+      const objectEntries = Object.fromEntries(
+        arrayOfEntries.map(
+          (entry) => [
+            _path2.default.posix.join(
+              ...entry.split(_path2.default.posix.sep).slice(1, -1).concat(_path2.default.parse(entry).name)
+            ),
+            entry
+          ]
+        )
+      );
+      return objectEntries;
+    };
+    var resolveEntryPaths = async (entryPaths) => {
+      const resolvedEntryPaths = typeof entryPaths === "string" || Array.isArray(entryPaths) ? convertArrayEntriesToObjectEntries(await _tinyglobby.glob.call(void 0, entryPaths)) : entryPaths;
+      return resolvedEntryPaths;
+    };
+    var resolveExperimentalDtsConfig = async (options2, tsconfig) => {
+      const resolvedEntryPaths = await resolveEntryPaths(
+        _optionalChain([options2, "access", (_2) => _2.experimentalDts, "optionalAccess", (_3) => _3.entry]) || options2.entry
+      );
+      const experimentalDtsObjectEntry = Object.keys(resolvedEntryPaths).length === 0 ? Array.isArray(options2.entry) ? convertArrayEntriesToObjectEntries(options2.entry) : options2.entry : resolvedEntryPaths;
+      const normalizedExperimentalDtsConfig = {
+        compilerOptions: {
+          ...tsconfig.data.compilerOptions || {},
+          ..._optionalChain([options2, "access", (_4) => _4.experimentalDts, "optionalAccess", (_5) => _5.compilerOptions]) || {}
+        },
+        entry: experimentalDtsObjectEntry
+      };
+      return normalizedExperimentalDtsConfig;
+    };
+    var resolveInitialExperimentalDtsConfig = async (experimentalDts) => {
+      if (experimentalDts == null) {
+        return;
+      }
+      if (typeof experimentalDts === "boolean")
+        return experimentalDts ? { entry: {} } : void 0;
+      if (typeof experimentalDts === "string") {
+        return {
+          entry: convertArrayEntriesToObjectEntries(await _tinyglobby.glob.call(void 0, experimentalDts))
+        };
+      }
+      return {
+        ...experimentalDts,
+        entry: _optionalChain([experimentalDts, "optionalAccess", (_6) => _6.entry]) == null ? {} : await resolveEntryPaths(experimentalDts.entry)
+      };
+    };
+    exports2.__require = __require;
+    exports2.__commonJS = __commonJS2;
+    exports2.__toESM = __toESM2;
+    exports2.getPostcss = getPostcss;
+    exports2.getApiExtractor = getApiExtractor;
+    exports2.localRequire = localRequire;
+    exports2.removeFiles = removeFiles;
+    exports2.debouncePromise = debouncePromise;
+    exports2.slash = slash;
+    exports2.truthy = truthy;
+    exports2.jsoncParse = jsoncParse;
+    exports2.defaultOutExtension = defaultOutExtension;
+    exports2.ensureTempDeclarationDir = ensureTempDeclarationDir;
+    exports2.toObjectEntry = toObjectEntry;
+    exports2.toAbsolutePath = toAbsolutePath;
+    exports2.writeFileSync = writeFileSync;
+    exports2.replaceDtsWithJsExtensions = replaceDtsWithJsExtensions;
+    exports2.resolveExperimentalDtsConfig = resolveExperimentalDtsConfig;
+    exports2.resolveInitialExperimentalDtsConfig = resolveInitialExperimentalDtsConfig;
+  }
+});
+
+// ../../node_modules/.pnpm/tsup@8.4.0_patch_hash=751a554d775c3572381af4e7e5fa22eeda6dd6856012fb1cf521d6806eb2dc74__27cd8c2707e42da8a6ff3e707ec47ae0/node_modules/tsup/dist/chunk-VGC3FXLU.js
+var require_chunk_VGC3FXLU = __commonJS({
+  "../../node_modules/.pnpm/tsup@8.4.0_patch_hash=751a554d775c3572381af4e7e5fa22eeda6dd6856012fb1cf521d6806eb2dc74__27cd8c2707e42da8a6ff3e707ec47ae0/node_modules/tsup/dist/chunk-VGC3FXLU.js"(exports2) {
+    "use strict";
+    init_cjs_shims();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    function _optionalChain(ops) {
+      let lastAccessLHS = void 0;
+      let value = ops[0];
+      let i = 1;
+      while (i < ops.length) {
+        const op = ops[i];
+        const fn = ops[i + 1];
+        i += 2;
+        if ((op === "optionalAccess" || op === "optionalCall") && value == null) {
+          return void 0;
+        }
+        if (op === "access" || op === "optionalAccess") {
+          lastAccessLHS = value;
+          value = fn(value);
+        } else if (op === "call" || op === "optionalCall") {
+          value = fn((...args) => value.call(lastAccessLHS, ...args));
+          lastAccessLHS = void 0;
+        }
+      }
+      return value;
+    }
+    var _chunkTWFEYLU4js = require_chunk_TWFEYLU4();
+    var _fs = require("fs");
+    var _fs2 = _interopRequireDefault(_fs);
+    var _path = require("path");
+    var _path2 = _interopRequireDefault(_path);
+    var _joycon = require("joycon");
+    var _joycon2 = _interopRequireDefault(_joycon);
+    var _bundlerequire = require("bundle-require");
+    var joycon = new (0, _joycon2.default)();
+    var loadJson = async (filepath, options2) => {
+      try {
+        return _chunkTWFEYLU4js.jsoncParse.call(void 0, await _fs2.default.promises.readFile(filepath, "utf8"));
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new Error(
+            `Failed to parse ${_path2.default.relative(options2.workspaceConfig?.workspaceRoot || process.cwd(), filepath)}: ${error.message}`
+          );
+        } else {
+          throw error;
+        }
+      }
+    };
+    var jsonLoader = {
+      test: /\.json$/,
+      load(filepath) {
+        return loadJson(filepath);
+      }
+    };
+    joycon.addLoader(jsonLoader);
+    async function loadTsupConfig(cwd, configFile) {
+      const configJoycon = new (0, _joycon2.default)();
+      const configPath = await configJoycon.resolve({
+        files: configFile ? [configFile] : [
+          "tsup.config.ts",
+          "tsup.config.cts",
+          "tsup.config.mts",
+          "tsup.config.js",
+          "tsup.config.cjs",
+          "tsup.config.mjs",
+          "tsup.config.json",
+          "package.json"
+        ],
+        cwd,
+        stopDir: _path2.default.parse(cwd).root,
+        packageKey: "tsup"
+      });
+      if (configPath) {
+        if (configPath.endsWith(".json")) {
+          let data = await loadJson(configPath);
+          if (configPath.endsWith("package.json")) {
+            data = data.tsup;
+          }
+          if (data) {
+            return { path: configPath, data };
+          }
+          return {};
+        }
+        const config = await _bundlerequire.bundleRequire.call(void 0, {
+          filepath: configPath
+        });
+        return {
+          path: configPath,
+          data: config.mod.tsup || config.mod.default || config.mod
+        };
+      }
+      return {};
+    }
+    async function loadPkg(cwd, clearCache = false) {
+      if (clearCache) {
+        joycon.clearCache();
+      }
+      const { data } = await joycon.load(["package.json"], cwd, _path2.default.dirname(cwd));
+      return data || {};
+    }
+    async function getProductionDeps(cwd, clearCache = false) {
+      const data = await loadPkg(cwd, clearCache);
+      const deps = Array.from(
+        /* @__PURE__ */ new Set([
+          ...Object.keys(data.dependencies || {}),
+          ...Object.keys(data.peerDependencies || {})
+        ])
+      );
+      return deps;
+    }
+    async function getAllDepsHash(cwd) {
+      const data = await loadPkg(cwd, true);
+      return JSON.stringify({
+        ...data.dependencies,
+        ...data.peerDependencies,
+        ...data.devDependencies
+      });
+    }
+    var _util = require("util");
+    var _util2 = _interopRequireDefault(_util);
+    var _worker_threads = require("worker_threads");
+    var _picocolors = require("picocolors");
+    var _picocolors2 = _interopRequireDefault(_picocolors);
+    var colorize = (type, data, onlyImportant = false) => {
+      if (onlyImportant && (type === "info" || type === "success")) return data;
+      const color = type === "info" ? "blue" : type === "error" ? "red" : type === "warn" ? "yellow" : "green";
+      return _picocolors2.default[color](data);
+    };
+    var makeLabel = (name, input, type) => {
+      return [
+        name && `${_picocolors2.default.dim("[")}${name.toUpperCase()}${_picocolors2.default.dim("]")}`,
+        colorize(type, input.toUpperCase())
+      ].filter(Boolean).join(" ");
+    };
+    var silent = false;
+    function setSilent(isSilent) {
+      silent = !!isSilent;
+    }
+    function getSilent() {
+      return silent;
+    }
+    var createLogger = (name) => {
+      return {
+        setName(_name) {
+          name = _name;
+        },
+        success(label, ...args) {
+          return this.log(label, "success", ...args);
+        },
+        info(label, ...args) {
+          return this.log(label, "info", ...args);
+        },
+        error(label, ...args) {
+          return this.log(label, "error", ...args);
+        },
+        warn(label, ...args) {
+          return this.log(label, "warn", ...args);
+        },
+        log(label, type, ...data) {
+          const args = [
+            makeLabel(name, label, type),
+            ...data.map((item) => colorize(type, item, true))
+          ];
+          switch (type) {
+            case "error": {
+              if (!_worker_threads.isMainThread) {
+                _optionalChain([_worker_threads.parentPort, "optionalAccess", (_) => _.postMessage, "call", (_2) => _2({
+                  type: "error",
+                  text: _util2.default.format(...args)
+                })]);
+                return;
+              }
+              return console.error(...args);
+            }
+            default:
+              if (silent) return;
+              if (!_worker_threads.isMainThread) {
+                _optionalChain([_worker_threads.parentPort, "optionalAccess", (_3) => _3.postMessage, "call", (_4) => _4({
+                  type: "log",
+                  text: _util2.default.format(...args)
+                })]);
+                return;
+              }
+              console.log(...args);
+          }
+        }
+      };
+    };
+    var prettyBytes = (bytes) => {
+      if (bytes === 0) return "0 B";
+      const unit = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+      const exp = Math.floor(Math.log(bytes) / Math.log(1024));
+      return `${(bytes / 1024 ** exp).toFixed(2)} ${unit[exp]}`;
+    };
+    var getLengthOfLongestString = (strings) => {
+      return strings.reduce((max, str) => {
+        return Math.max(max, str.length);
+      }, 0);
+    };
+    var padRight = (str, maxLength) => {
+      return str + " ".repeat(maxLength - str.length);
+    };
+    var reportSize = (logger, format, files) => {
+      const filenames = Object.keys(files);
+      const maxLength = getLengthOfLongestString(filenames) + 1;
+      for (const name of filenames) {
+        logger.success(
+          format,
+          `${_picocolors2.default.bold(padRight(name, maxLength))}${_picocolors2.default.green(
+            prettyBytes(files[name])
+          )}`
+        );
+      }
+    };
+    exports2.loadTsupConfig = loadTsupConfig;
+    exports2.loadPkg = loadPkg;
+    exports2.getProductionDeps = getProductionDeps;
+    exports2.getAllDepsHash = getAllDepsHash;
+    exports2.setSilent = setSilent;
+    exports2.getSilent = getSilent;
+    exports2.createLogger = createLogger;
+    exports2.reportSize = reportSize;
+  }
+});
+
+// ../../node_modules/.pnpm/tsup@8.4.0_patch_hash=751a554d775c3572381af4e7e5fa22eeda6dd6856012fb1cf521d6806eb2dc74__27cd8c2707e42da8a6ff3e707ec47ae0/node_modules/tsup/dist/chunk-JZ25TPTY.js
+var require_chunk_JZ25TPTY = __commonJS({
+  "../../node_modules/.pnpm/tsup@8.4.0_patch_hash=751a554d775c3572381af4e7e5fa22eeda6dd6856012fb1cf521d6806eb2dc74__27cd8c2707e42da8a6ff3e707ec47ae0/node_modules/tsup/dist/chunk-JZ25TPTY.js"(exports2) {
+    "use strict";
+    init_cjs_shims();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    var _worker_threads = require("worker_threads");
+    var _picocolors = require("picocolors");
+    var _picocolors2 = _interopRequireDefault(_picocolors);
+    var PrettyError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = this.constructor.name;
+        if (typeof Error.captureStackTrace === "function") {
+          Error.captureStackTrace(this, this.constructor);
+        } else {
+          this.stack = new Error(message).stack;
+        }
+      }
+    };
+    function handleError(error) {
+      if (error.loc) {
+        console.error(
+          _picocolors2.default.bold(
+            _picocolors2.default.red(
+              `Error parsing: ${error.loc.file}:${error.loc.line}:${error.loc.column}`
+            )
+          )
+        );
+      }
+      if (error.frame) {
+        console.error(_picocolors2.default.red(error.message));
+        console.error(_picocolors2.default.dim(error.frame));
+      } else if (error instanceof PrettyError) {
+        console.error(_picocolors2.default.red(error.message));
+      } else {
+        console.error(_picocolors2.default.red(error.stack));
+      }
+      process.exitCode = 1;
+      if (!_worker_threads.isMainThread && _worker_threads.parentPort) {
+        _worker_threads.parentPort.postMessage("error");
+      }
+    }
+    exports2.PrettyError = PrettyError;
+    exports2.handleError = handleError;
+  }
+});
+
+// ../../node_modules/.pnpm/tsup@8.4.0_patch_hash=751a554d775c3572381af4e7e5fa22eeda6dd6856012fb1cf521d6806eb2dc74__27cd8c2707e42da8a6ff3e707ec47ae0/node_modules/tsup/dist/commonjs-plugin.js
+var require_commonjs_plugin = __commonJS({
+  "../../node_modules/.pnpm/tsup@8.4.0_patch_hash=751a554d775c3572381af4e7e5fa22eeda6dd6856012fb1cf521d6806eb2dc74__27cd8c2707e42da8a6ff3e707ec47ae0/node_modules/tsup/dist/commonjs-plugin.js"(exports2, module2) {
+    "use strict";
+    init_cjs_shims();
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports2 = {};
+    __export2(index_exports2, {
+      commonjs: () => commonjs,
+      default: () => index_default
+    });
+    module2.exports = __toCommonJS2(index_exports2);
+    var import_fs = require("fs");
+    function isNewLine(code) {
+      return code === 10 || code === 13 || code === 8232 || code === 8233;
+    }
+    function codePointToString(ch) {
+      if (ch <= 65535) return String.fromCharCode(ch);
+      ch -= 65536;
+      return String.fromCharCode((ch >> 10) + 55296, (ch & 1023) + 56320);
+    }
+    var Lexer = class {
+      input = "";
+      pos = 0;
+      readString(input, pos) {
+        if (pos >= input.length) return null;
+        this.input = input;
+        this.pos = pos;
+        const quote = this.input.charCodeAt(pos);
+        if (!(quote === 34 || quote === 39)) return null;
+        let out = "";
+        let chunkStart = ++this.pos;
+        while (true) {
+          if (this.pos >= this.input.length) return null;
+          let ch = this.input.charCodeAt(this.pos);
+          if (ch === quote) break;
+          if (ch === 92) {
+            out += this.input.slice(chunkStart, this.pos);
+            const escaped = this.readEscapedChar();
+            if (escaped === null) return null;
+            out += escaped;
+            chunkStart = this.pos;
+          } else {
+            if (isNewLine(ch)) return null;
+            ++this.pos;
+          }
+        }
+        out += this.input.slice(chunkStart, this.pos++);
+        return out;
+      }
+      readEscapedChar() {
+        let ch = this.input.charCodeAt(++this.pos);
+        let code;
+        ++this.pos;
+        switch (ch) {
+          case 110:
+            return "\n";
+          case 114:
+            return "\r";
+          case 120:
+            code = this.readHexChar(2);
+            if (code === null) return null;
+            return String.fromCharCode(code);
+          case 117:
+            code = this.readCodePoint();
+            if (code === null) return null;
+            return codePointToString(code);
+          case 116:
+            return "	";
+          case 98:
+            return "\b";
+          case 118:
+            return "\v";
+          case 102:
+            return "\f";
+          case 13:
+            if (this.input.charCodeAt(this.pos) === 10) {
+              ++this.pos;
+            }
+          case 10:
+            return "";
+          case 56:
+          case 57:
+            return null;
+          default:
+            if (ch >= 48 && ch <= 55) {
+              let match = this.input.slice(this.pos - 1, this.pos + 2).match(/^[0-7]+/);
+              if (match === null) return null;
+              let octalStr = match[0];
+              let octal = parseInt(octalStr, 8);
+              if (octal > 255) {
+                octalStr = octalStr.slice(0, -1);
+                octal = parseInt(octalStr, 8);
+              }
+              this.pos += octalStr.length - 1;
+              ch = this.input.charCodeAt(this.pos);
+              if (octalStr !== "0" || ch === 56 || ch === 57) return null;
+              return String.fromCharCode(octal);
+            }
+            if (isNewLine(ch)) return "";
+            return String.fromCharCode(ch);
+        }
+      }
+      readInt(radix, len) {
+        let start = this.pos;
+        let total = 0;
+        for (let i = 0; i < len; ++i, ++this.pos) {
+          let code = this.input.charCodeAt(this.pos);
+          let val;
+          if (code >= 97) {
+            val = code - 97 + 10;
+          } else if (code >= 65) {
+            val = code - 65 + 10;
+          } else if (code >= 48 && code <= 57) {
+            val = code - 48;
+          } else {
+            val = Infinity;
+          }
+          if (val >= radix) break;
+          total = total * radix + val;
+        }
+        if (this.pos === start || len != null && this.pos - start !== len) return null;
+        return total;
+      }
+      readHexChar(len) {
+        return this.readInt(16, len);
+      }
+      readCodePoint() {
+        let ch = this.input.charCodeAt(this.pos);
+        let code;
+        if (ch === 123) {
+          ++this.pos;
+          code = this.readHexChar(this.input.indexOf("}", this.pos) - this.pos);
+          ++this.pos;
+          if (code && code > 1114111) return null;
+        } else {
+          code = this.readHexChar(4);
+        }
+        return code;
+      }
+    };
+    function orderedUniq(array) {
+      let ret = [], visited = /* @__PURE__ */ new Set();
+      for (let val of array) if (!visited.has(val)) visited.add(val), ret.push(val);
+      return ret;
+    }
+    function cachedReduce(array, reducer, s) {
+      let cache = [s], cacheLen = 1, last = s;
+      return (len) => {
+        while (cacheLen <= len) cacheLen = cache.push(last = reducer(last, array[cacheLen - 1]));
+        return cache[len];
+      };
+    }
+    var reservedWords = "break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public";
+    var builtin = "arguments Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl";
+    var forbiddenIdentifiers = new Set(`${reservedWords} ${builtin}`.split(" "));
+    forbiddenIdentifiers.add("");
+    var makeLegalIdentifier = function makeLegalIdentifier2(str) {
+      let identifier = str.replace(/-(\w)/g, (_, letter) => letter.toUpperCase()).replace(/[^$_a-zA-Z0-9]/g, "_");
+      if (/\d/.test(identifier[0]) || forbiddenIdentifiers.has(identifier)) {
+        identifier = `_${identifier}`;
+      }
+      return identifier || "_";
+    };
+    function prepend(code, prefix) {
+      if (code.startsWith("#!")) {
+        const i = code.indexOf("\n") + 1;
+        return code.slice(0, i) + prefix + code.slice(i);
+      }
+      return prefix + code;
+    }
+    function commonjs({
+      filter = /\.c?js$/,
+      transform = false,
+      transformConfig,
+      requireReturnsDefault = false,
+      ignore
+    } = {}) {
+      const init_cjs_module_lexer = transform ? import("cjs-module-lexer") : void 0;
+      const use_default_export = typeof requireReturnsDefault === "function" ? requireReturnsDefault : (_path) => requireReturnsDefault;
+      const is_ignored = typeof ignore === "function" ? ignore : Array.isArray(ignore) ? (path) => ignore.includes(path) : () => false;
+      return {
+        name: "commonjs",
+        setup({ onLoad, esbuild }) {
+          let esbuild_shim;
+          const require_esbuild = () => esbuild || (esbuild_shim || (esbuild_shim = require("esbuild")));
+          const read = import_fs.promises.readFile;
+          const lexer = new Lexer();
+          onLoad({ filter }, async (args) => {
+            let parseCJS;
+            if (init_cjs_module_lexer) {
+              const { init, parse } = await init_cjs_module_lexer;
+              await init();
+              parseCJS = parse;
+            }
+            let contents;
+            try {
+              contents = await read(args.path, "utf8");
+            } catch {
+              return null;
+            }
+            const willTransform = transform === true || typeof transform === "function" && transform(args.path);
+            let cjsExports;
+            if (parseCJS && willTransform) {
+              let sourcemapIndex = contents.lastIndexOf("//# sourceMappingURL=");
+              let sourcemap;
+              if (sourcemapIndex !== -1) {
+                sourcemap = contents.slice(sourcemapIndex);
+                let sourcemapEnd = sourcemap.indexOf("\n");
+                if (sourcemapEnd !== -1 && sourcemap.slice(sourcemapEnd + 1).trimStart().length > 0) {
+                  sourcemap = void 0;
+                } else {
+                  contents = contents.slice(0, sourcemapIndex);
+                }
+              }
+              cjsExports = parseCJS(contents);
+              let { behavior, exports: exports22, sideEffects } = typeof willTransform === "object" ? willTransform : {};
+              behavior ?? (behavior = (transformConfig == null ? void 0 : transformConfig.behavior) ?? "node");
+              exports22 = orderedUniq(cjsExports.exports.concat(exports22 ?? []));
+              sideEffects ?? (sideEffects = (transformConfig == null ? void 0 : transformConfig.sideEffects) ?? true);
+              let exportDefault = behavior === "node" ? "export default exports;" : "export default exports.__esModule ? exports.default : exports;";
+              let exportsMap = exports22.map((e) => [e, makeLegalIdentifier(e)]);
+              if (exportsMap.some(([e]) => e === "default")) {
+                if (behavior === "node") {
+                  exportsMap = exportsMap.filter(([e]) => e !== "default");
+                } else {
+                  exportDefault = "";
+                }
+              }
+              let reexports = cjsExports.reexports.map((e) => `export * from ${JSON.stringify(e)};`).join("");
+              let transformed;
+              if (sideEffects === false) {
+                transformed = [
+                  // make sure we don't manipulate the first line so that sourcemap is fine
+                  reexports + "var mod, exports = /* @__PURE__ */ ((exports, module) => {" + contents,
+                  "return module.exports})((mod = { exports: {} }).exports, mod); " + exportDefault
+                ];
+                if (exportsMap.length > 0) {
+                  for (const [e, name] of exportsMap) {
+                    transformed.push(`var ${name} = /* @__PURE__ */ (() => exports[${JSON.stringify(e)}])();`);
+                  }
+                  transformed.push(
+                    `export { ${exportsMap.map(([e, name]) => e === name ? e : `${name} as ${JSON.stringify(e)}`).join(", ")} };`
+                  );
+                }
+              } else {
+                transformed = [
+                  reexports + "var exports = {}, module = { exports }; {" + contents,
+                  "}; exports = module.exports; " + exportDefault
+                ];
+                if (exportsMap.length > 0) {
+                  transformed.push(
+                    `var { ${exportsMap.map(([e, name]) => e === name ? e : `${JSON.stringify(e)}: ${name}`).join(", ")} } = exports;`,
+                    `export { ${exportsMap.map(([e, name]) => e === name ? e : `${name} as ${JSON.stringify(e)}`).join(", ")} };`
+                  );
+                }
+              }
+              contents = transformed.join("\n") + (sourcemap ? "\n" + sourcemap : "");
+            }
+            function makeName(path) {
+              let name = `__import_${makeLegalIdentifier(path)}`;
+              if (contents.includes(name)) {
+                let suffix = 2;
+                while (contents.includes(`${name}${suffix}`)) suffix++;
+                name = `${name}${suffix}`;
+              }
+              return name;
+            }
+            let warnings;
+            try {
+              ({ warnings } = await require_esbuild().transform(contents, { format: "esm", logLevel: "silent" }));
+            } catch (err) {
+              ({ warnings } = err);
+            }
+            let lines = contents.split("\n");
+            let getOffset = cachedReduce(lines, (a, b) => a + 1 + b.length, 0);
+            if (warnings && (warnings = warnings.filter((e) => e.text.includes('"require" to "esm"'))).length) {
+              let edits = [];
+              let imports = [];
+              for (const { location } of warnings) {
+                if (location === null) continue;
+                const { line, lineText, column, length } = location;
+                const leftBrace = column + length + 1;
+                const path = lexer.readString(lineText, leftBrace);
+                if (path === null || is_ignored(path)) continue;
+                const rightBrace = lineText.indexOf(")", leftBrace + 2 + path.length) + 1;
+                let name = makeName(path);
+                let import_statement;
+                if (use_default_export(path)) {
+                  import_statement = `import ${name} from ${JSON.stringify(path)};`;
+                } else {
+                  import_statement = `import * as ${name} from ${JSON.stringify(path)};`;
+                }
+                let offset2 = getOffset(line - 1);
+                edits.push([offset2 + column, offset2 + rightBrace, name]);
+                imports.push(import_statement);
+              }
+              if (imports.length === 0) return null;
+              imports = orderedUniq(imports);
+              let offset = 0;
+              for (const [start, end, name] of edits) {
+                contents = contents.slice(0, start + offset) + name + contents.slice(end + offset);
+                offset += name.length - (end - start);
+              }
+              contents = prepend(contents, [...imports, cjsExports ? "exports;" : ""].join(""));
+              return { contents };
+            }
+          });
+        }
+      };
+    }
+    var index_default = commonjs;
+  }
+});
+
+// ../../node_modules/.pnpm/tsup@8.4.0_patch_hash=751a554d775c3572381af4e7e5fa22eeda6dd6856012fb1cf521d6806eb2dc74__27cd8c2707e42da8a6ff3e707ec47ae0/node_modules/tsup/dist/index.js
+var require_dist = __commonJS({
+  "../../node_modules/.pnpm/tsup@8.4.0_patch_hash=751a554d775c3572381af4e7e5fa22eeda6dd6856012fb1cf521d6806eb2dc74__27cd8c2707e42da8a6ff3e707ec47ae0/node_modules/tsup/dist/index.js"(exports2) {
+    "use strict";
+    init_cjs_shims();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    function _interopRequireWildcard(obj) {
+      if (obj && obj.__esModule) {
+        return obj;
+      } else {
+        var newObj = {};
+        if (obj != null) {
+          for (var key in obj) {
+            if (Object.prototype.hasOwnProperty.call(obj, key)) {
+              newObj[key] = obj[key];
+            }
+          }
+        }
+        newObj.default = obj;
+        return newObj;
+      }
+    }
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    function _nullishCoalesce(lhs, rhsFn) {
+      if (lhs != null) {
+        return lhs;
+      } else {
+        return rhsFn();
+      }
+    }
+    function _optionalChain(ops) {
+      let lastAccessLHS = void 0;
+      let value = ops[0];
+      let i = 1;
+      while (i < ops.length) {
+        const op = ops[i];
+        const fn = ops[i + 1];
+        i += 2;
+        if ((op === "optionalAccess" || op === "optionalCall") && value == null) {
+          return void 0;
+        }
+        if (op === "access" || op === "optionalAccess") {
+          lastAccessLHS = value;
+          value = fn(value);
+        } else if (op === "call" || op === "optionalCall") {
+          value = fn((...args) => value.call(lastAccessLHS, ...args));
+          lastAccessLHS = void 0;
+        }
+      }
+      return value;
+    }
+    var _class;
+    var _chunkBYH4XDRHjs = require_chunk_BYH4XDRH();
+    var _chunkVGC3FXLUjs = require_chunk_VGC3FXLU();
+    var _chunkJZ25TPTYjs = require_chunk_JZ25TPTY();
+    var _chunkTWFEYLU4js = require_chunk_TWFEYLU4();
+    var _commonjsPluginjs = require_commonjs_plugin();
+    var _path = require("path");
+    var _path2 = _interopRequireDefault(_path);
+    var _fs = require("fs");
+    var _fs2 = _interopRequireDefault(_fs);
+    var _worker_threads = require("worker_threads");
+    var _bundlerequire = require("bundle-require");
+    var _tinyexec = require("tinyexec");
+    var _tinyglobby = require("tinyglobby");
+    var _treekill = require("tree-kill");
+    var _treekill2 = _interopRequireDefault(_treekill);
+    var _esbuild = require("esbuild");
+    var _consola = require("consola");
+    var _consola2 = _interopRequireDefault(_consola);
+    var nodeProtocolPlugin = () => {
+      const nodeProtocol = "node:";
+      return {
+        name: "node-protocol-plugin",
+        setup({ onResolve }) {
+          onResolve(
+            {
+              filter: /^node:/
+            },
+            ({ path: path12 }) => ({
+              path: path12.slice(nodeProtocol.length),
+              external: true
+            })
+          );
+        }
+      };
+    };
+    var NON_NODE_MODULE_RE = /^[A-Z]:[/\\]|^\.{0,2}\/|^\.{1,2}$/;
+    var externalPlugin = ({
+      external,
+      noExternal,
+      skipNodeModulesBundle,
+      tsconfigResolvePaths
+    }) => {
+      return {
+        name: `external`,
+        setup(build22) {
+          if (skipNodeModulesBundle) {
+            const resolvePatterns = _bundlerequire.tsconfigPathsToRegExp.call(
+              void 0,
+              tsconfigResolvePaths || {}
+            );
+            build22.onResolve({ filter: /.*/ }, (args) => {
+              if (_bundlerequire.match.call(void 0, args.path, resolvePatterns)) {
+                return;
+              }
+              if (_bundlerequire.match.call(void 0, args.path, noExternal)) {
+                return;
+              }
+              if (_bundlerequire.match.call(void 0, args.path, external)) {
+                return { external: true };
+              }
+              if (!NON_NODE_MODULE_RE.test(args.path)) {
+                return {
+                  path: args.path,
+                  external: true
+                };
+              }
+            });
+          } else {
+            build22.onResolve({ filter: /.*/ }, (args) => {
+              if (_bundlerequire.match.call(void 0, args.path, noExternal)) {
+                return;
+              }
+              if (_bundlerequire.match.call(void 0, args.path, external)) {
+                return { external: true };
+              }
+            });
+          }
+        }
+      };
+    };
+    var postcssPlugin = ({
+      options: options2,
+      css,
+      inject,
+      cssLoader
+    }) => {
+      return {
+        name: "postcss",
+        setup(build22) {
+          let configCache;
+          const getPostcssConfig = async () => {
+            const loadConfig = _chunkTWFEYLU4js.__require.call(void 0, "postcss-load-config");
+            if (configCache) {
+              return configCache;
+            }
+            try {
+              const result = await loadConfig({}, options2.workspaceConfig?.workspaceRoot || process.cwd());
+              configCache = result;
+              return result;
+            } catch (error) {
+              if (error.message.includes("No PostCSS Config found in")) {
+                const result = { plugins: [], options: {} };
+                return result;
+              }
+              throw error;
+            }
+          };
+          build22.onResolve({ filter: /^#style-inject$/ }, () => {
+            return { path: "#style-inject", namespace: "#style-inject" };
+          });
+          build22.onLoad(
+            { filter: /^#style-inject$/, namespace: "#style-inject" },
+            () => {
+              return {
+                // Taken from https://github.com/egoist/style-inject/blob/master/src/index.js (MIT)
+                contents: `
+          export default function styleInject(css, { insertAt } = {}) {
+            if (!css || typeof document === 'undefined') return
+
+            const head = document.head || document.getElementsByTagName('head')[0]
+            const style = document.createElement('style')
+            style.type = 'text/css'
+
+            if (insertAt === 'top') {
+              if (head.firstChild) {
+                head.insertBefore(style, head.firstChild)
+              } else {
+                head.appendChild(style)
+              }
+            } else {
+              head.appendChild(style)
+            }
+
+            if (style.styleSheet) {
+              style.styleSheet.cssText = css
+            } else {
+              style.appendChild(document.createTextNode(css))
+            }
+          }
+          `,
+                loader: "js"
+              };
+            }
+          );
+          build22.onLoad({ filter: /\.css$/ }, async (args) => {
+            let contents;
+            if (css && args.path.endsWith(".svelte.css")) {
+              contents = css.get(args.path);
+            } else {
+              contents = await _fs2.default.promises.readFile(args.path, "utf8");
+            }
+            const { plugins, options: options3 } = await getPostcssConfig();
+            if (plugins && plugins.length > 0) {
+              const postcss = _chunkTWFEYLU4js.getPostcss.call(void 0);
+              if (!postcss) {
+                return {
+                  errors: [
+                    {
+                      text: `postcss is not installed`
+                    }
+                  ]
+                };
+              }
+              const result = await _optionalChain([postcss, "optionalAccess", (_2) => _2.default, "call", (_3) => _3(plugins), "access", (_4) => _4.process, "call", (_5) => _5(contents, { ...options3, from: args.path })]);
+              contents = result.css;
+            }
+            if (inject) {
+              contents = (await _esbuild.transform.call(void 0, contents, {
+                minify: build22.initialOptions.minify,
+                minifyIdentifiers: build22.initialOptions.minifyIdentifiers,
+                minifySyntax: build22.initialOptions.minifySyntax,
+                minifyWhitespace: build22.initialOptions.minifyWhitespace,
+                logLevel: build22.initialOptions.logLevel,
+                loader: "css"
+              })).code;
+              contents = typeof inject === "function" ? await inject(JSON.stringify(contents), args.path) : `import styleInject from '#style-inject';styleInject(${JSON.stringify(
+                contents
+              )})`;
+              return {
+                contents,
+                loader: "js"
+              };
+            }
+            return {
+              contents,
+              loader: _nullishCoalesce(cssLoader, () => "css")
+            };
+          });
+        }
+      };
+    };
+    var useSvelteCssExtension = (p) => p.replace(/\.svelte$/, ".svelte.css");
+    var sveltePlugin = ({
+      css,
+      options: options2
+    }) => {
+      return {
+        name: "svelte",
+        setup(build22) {
+          let svelte;
+          let sveltePreprocessor;
+          build22.onResolve({ filter: /\.svelte\.css$/ }, (args) => {
+            return {
+              path: _path2.default.relative(
+                options2.workspaceConfig?.workspaceRoot || process.cwd(),
+                _path2.default.join(args.resolveDir, args.path)
+              ),
+              namespace: "svelte-css"
+            };
+          });
+          build22.onLoad({ filter: /\.svelte$/ }, async (args) => {
+            svelte = svelte || _chunkTWFEYLU4js.localRequire.call(void 0, "svelte/compiler");
+            sveltePreprocessor = sveltePreprocessor || _chunkTWFEYLU4js.localRequire.call(void 0, "svelte-preprocess");
+            if (!svelte) {
+              return {
+                errors: [{ text: `You need to install "svelte" in your project` }]
+              };
+            }
+            const convertMessage = ({ message, start, end }) => {
+              let location;
+              if (start && end) {
+                const lineText = source.split(/\r\n|\r|\n/g)[start.line - 1];
+                const lineEnd = start.line === end.line ? end.column : lineText.length;
+                location = {
+                  file: filename,
+                  line: start.line,
+                  column: start.column,
+                  length: lineEnd - start.column,
+                  lineText
+                };
+              }
+              return { text: message, location };
+            };
+            const source = await _fs2.default.promises.readFile(args.path, "utf8");
+            const filename = _path2.default.relative(options2.workspaceConfig?.workspaceRoot || process.cwd(), args.path);
+            try {
+              const preprocess = await svelte.preprocess(
+                source,
+                sveltePreprocessor ? sveltePreprocessor({
+                  sourceMap: true,
+                  typescript: {
+                    compilerOptions: {
+                      verbatimModuleSyntax: true
+                    }
+                  }
+                }) : {
+                  async script({ content, attributes }) {
+                    if (attributes.lang !== "ts") return { code: content };
+                    const { code, map } = await _esbuild.transform.call(void 0, content, {
+                      sourcefile: args.path,
+                      loader: "ts",
+                      sourcemap: true,
+                      tsconfigRaw: {
+                        compilerOptions: {
+                          verbatimModuleSyntax: true
+                        }
+                      },
+                      logLevel: build22.initialOptions.logLevel
+                    });
+                    return {
+                      code,
+                      map
+                    };
+                  }
+                },
+                {
+                  filename: args.path
+                }
+              );
+              const result = svelte.compile(preprocess.code, {
+                filename,
+                css: "external"
+              });
+              let contents = result.js.code;
+              if (css && result.css && result.css.code) {
+                const cssPath = useSvelteCssExtension(filename);
+                css.set(cssPath, result.css.code);
+                contents = `import '${useSvelteCssExtension(_path2.default.basename(args.path))}';${contents}`;
+              }
+              return { contents, warnings: result.warnings.map(convertMessage) };
+            } catch (error) {
+              return { errors: [convertMessage(error)] };
+            }
+          });
+        }
+      };
+    };
+    var nativeNodeModulesPlugin = () => {
+      return {
+        name: "native-node-modules",
+        setup(build22) {
+          build22.onResolve({ filter: /\.node$/, namespace: "file" }, (args) => {
+            const resolvedId = _chunkTWFEYLU4js.__require.resolve(args.path, {
+              paths: [args.resolveDir]
+            });
+            if (resolvedId.endsWith(".node")) {
+              return {
+                path: resolvedId,
+                namespace: "node-file"
+              };
+            }
+            return {
+              path: resolvedId
+            };
+          });
+          build22.onLoad({ filter: /.*/, namespace: "node-file" }, (args) => {
+            return {
+              contents: `
+            import path from ${JSON.stringify(args.path)}
+            try { module.exports = require(path) }
+            catch {}
+          `,
+              resolveDir: _path2.default.dirname(args.path)
+            };
+          });
+          build22.onResolve(
+            { filter: /\.node$/, namespace: "node-file" },
+            (args) => ({
+              path: args.path,
+              namespace: "file"
+            })
+          );
+          const opts = build22.initialOptions;
+          opts.loader = opts.loader || {};
+          opts.loader[".node"] = "file";
+        }
+      };
+    };
+    var getOutputExtensionMap = (options2, format, pkgType) => {
+      const outExtension = options2.outExtension || _chunkTWFEYLU4js.defaultOutExtension;
+      const defaultExtension = _chunkTWFEYLU4js.defaultOutExtension.call(void 0, { format, pkgType });
+      const extension = outExtension({ options: options2, format, pkgType });
+      return {
+        ".js": extension.js || defaultExtension.js
+      };
+    };
+    var generateExternal = async (external) => {
+      const result = [];
+      for (const item of external) {
+        if (typeof item !== "string" || !item.endsWith("package.json")) {
+          result.push(item);
+          continue;
+        }
+        const pkgPath = _path2.default.isAbsolute(item) ? _path2.default.dirname(item) : _path2.default.dirname(_path2.default.resolve(options.workspaceConfig?.workspaceRoot || process.cwd(), item));
+        const deps = await _chunkVGC3FXLUjs.getProductionDeps.call(void 0, pkgPath);
+        result.push(...deps);
+      }
+      return result;
+    };
+    async function runEsbuild(options2, {
+      format,
+      css,
+      logger: logger3,
+      buildDependencies,
+      pluginContainer
+    }) {
+      const pkg = await _chunkVGC3FXLUjs.loadPkg.call(void 0, options2.workspaceConfig?.workspaceRoot || process.cwd());
+      const deps = await _chunkVGC3FXLUjs.getProductionDeps.call(void 0, options2.workspaceConfig?.workspaceRoot || process.cwd());
+      const external = [
+        // Exclude dependencies, e.g. `lodash`, `lodash/get`
+        ...deps.map((dep) => new RegExp(`^${dep}($|\\/|\\\\)`)),
+        ...await generateExternal(options2.external || [])
+      ];
+      const outDir = options2.outDir;
+      const outExtension = getOutputExtensionMap(options2, format, pkg.type);
+      const env = {
+        ...options2.env
+      };
+      if (options2.replaceNodeEnv) {
+        env.NODE_ENV = options2.minify || options2.minifyWhitespace ? "production" : "development";
+      }
+      logger3.info(format, "Build start");
+      const startTime = Date.now();
+      let result;
+      const splitting = format === "iife" ? false : typeof options2.splitting === "boolean" ? options2.splitting : format === "esm";
+      const platform = options2.platform || "node";
+      const loader = options2.loader || {};
+      const injectShims = options2.shims;
+      const bundle = typeof options2.bundle === "undefined" ? true : options2.bundle;
+      pluginContainer.setContext({
+        format,
+        splitting,
+        options: options2,
+        logger: logger3
+      });
+      await pluginContainer.buildStarted();
+      const esbuildPlugins = [
+        format === "cjs" && options2.removeNodeProtocol && nodeProtocolPlugin(),
+        format === "esm" && bundle && _commonjsPluginjs.commonjs.call(void 0),
+        {
+          name: "modify-options",
+          setup(build22) {
+            pluginContainer.modifyEsbuildOptions(build22.initialOptions);
+            if (options2.esbuildOptions) {
+              options2.esbuildOptions(build22.initialOptions, { format });
+            }
+          }
+        },
+        // esbuild's `external` option doesn't support RegExp
+        // So here we use a custom plugin to implement it
+        format !== "iife" && externalPlugin({
+          external,
+          noExternal: options2.noExternal,
+          skipNodeModulesBundle: options2.skipNodeModulesBundle,
+          tsconfigResolvePaths: options2.tsconfigResolvePaths
+        }),
+        // options.tsconfigDecoratorMetadata && swcPlugin({ logger: logger3 }),
+        nativeNodeModulesPlugin(),
+        postcssPlugin({
+          options: options2,
+          css,
+          inject: options2.injectStyle,
+          cssLoader: loader[".css"]
+        }),
+        sveltePlugin({ css, options: options2 }),
+        ...options2.esbuildPlugins || []
+      ];
+      const banner = typeof options2.banner === "function" ? options2.banner({ format }) : options2.banner;
+      const footer = typeof options2.footer === "function" ? options2.footer({ format }) : options2.footer;
+      try {
+        result = await _esbuild.build.call(void 0, {
+          entryPoints: options2.entry,
+          format: format === "cjs" && splitting || options2.treeshake ? "esm" : format,
+          bundle,
+          platform,
+          globalName: options2.globalName,
+          jsxFactory: options2.jsxFactory,
+          jsxFragment: options2.jsxFragment,
+          sourcemap: options2.sourcemap ? "external" : false,
+          target: options2.target,
+          banner,
+          footer,
+          tsconfig: options2.tsconfig,
+          loader: {
+            ".aac": "file",
+            ".css": "file",
+            ".eot": "file",
+            ".flac": "file",
+            ".gif": "file",
+            ".jpeg": "file",
+            ".jpg": "file",
+            ".mp3": "file",
+            ".mp4": "file",
+            ".ogg": "file",
+            ".otf": "file",
+            ".png": "file",
+            ".svg": "file",
+            ".ttf": "file",
+            ".wav": "file",
+            ".webm": "file",
+            ".webp": "file",
+            ".woff": "file",
+            ".woff2": "file",
+            ...loader
+          },
+          mainFields: platform === "node" ? ["module", "main"] : ["browser", "module", "main"],
+          plugins: esbuildPlugins.filter(_chunkTWFEYLU4js.truthy),
+          define: {
+            TSUP_FORMAT: JSON.stringify(format),
+            ...format === "cjs" && injectShims ? {
+              "import.meta.url": "importMetaUrl"
+            } : {},
+            ...options2.define,
+            ...Object.keys(env).reduce((res, key) => {
+              const value = JSON.stringify(env[key]);
+              return {
+                ...res,
+                [`process.env.${key}`]: value,
+                [`import.meta.env.${key}`]: value
+              };
+            }, {})
+          },
+          inject: [
+            format === "cjs" && injectShims ? _path2.default.join(__dirname, "../assets/cjs_shims.js") : "",
+            format === "esm" && injectShims && platform === "node" ? _path2.default.join(__dirname, "../assets/esm_shims.js") : "",
+            ...options2.inject || []
+          ].filter(Boolean),
+          outdir: options2.legacyOutput && format !== "cjs" ? _path2.default.join(outDir, format) : outDir,
+          outExtension: options2.legacyOutput ? void 0 : outExtension,
+          write: false,
+          splitting,
+          logLevel: "error",
+          minify: options2.minify === "terser" ? false : options2.minify,
+          minifyWhitespace: options2.minifyWhitespace,
+          minifyIdentifiers: options2.minifyIdentifiers,
+          minifySyntax: options2.minifySyntax,
+          keepNames: options2.keepNames,
+          pure: typeof options2.pure === "string" ? [options2.pure] : options2.pure,
+          metafile: true
+        });
+      } catch (error) {
+        logger3.error(format, "Build failed");
+        throw error;
+      }
+      if (result && result.warnings && !_chunkVGC3FXLUjs.getSilent.call(void 0)) {
+        const messages = result.warnings.filter((warning) => {
+          if (warning.text.includes(
+            `This call to "require" will not be bundled because`
+          ) || warning.text.includes(`Indirect calls to "require" will not be bundled`))
+            return false;
+          return true;
+        });
+        const formatted = await _esbuild.formatMessages.call(void 0, messages, {
+          kind: "warning",
+          color: true
+        });
+        formatted.forEach((message) => {
+          _consola2.default.warn(message);
+        });
+      }
+      if (result && result.outputFiles) {
+        await pluginContainer.buildFinished({
+          options: options2,
+          outputFiles: result.outputFiles,
+          metafile: result.metafile
+        });
+        const timeInMs = Date.now() - startTime;
+        logger3.success(format, `\u26A1\uFE0F Build success in ${Math.floor(timeInMs)}ms`);
+      }
+      if (result.metafile) {
+        for (const file of Object.keys(result.metafile.inputs)) {
+          buildDependencies.add(file);
+        }
+        if (options2.metafile) {
+          const outPath = _path2.default.resolve(outDir, `metafile-${format}.json`);
+          await _fs2.default.promises.mkdir(_path2.default.dirname(outPath), { recursive: true });
+          await _fs2.default.promises.writeFile(
+            outPath,
+            JSON.stringify(result.metafile),
+            "utf8"
+          );
+        }
+      }
+    }
+    var shebang = () => {
+      return {
+        name: "shebang",
+        renderChunk(_, info) {
+          if (info.type === "chunk" && /\.(cjs|js|mjs)$/.test(info.path) && info.code.startsWith("#!")) {
+            info.mode = 493;
+          }
+        }
+      };
+    };
+    var cjsSplitting = () => {
+      return {
+        name: "cjs-splitting",
+        async renderChunk(code, info) {
+          if (!this.splitting || this.options.treeshake || // <-- handled by rollup
+          this.format !== "cjs" || info.type !== "chunk" || !/\.(js|cjs)$/.test(info.path)) {
+            return;
+          }
+          const { transform: transform3 } = await Promise.resolve().then(() => _interopRequireWildcard(require("sucrase")));
+          const result = transform3(code, {
+            filePath: info.path,
+            transforms: ["imports"],
+            sourceMapOptions: this.options.sourcemap ? {
+              compiledFilename: info.path
+            } : void 0
+          });
+          return {
+            code: result.code,
+            map: result.sourceMap
+          };
+        }
+      };
+    };
+    var _sourcemap = require("source-map");
+    var outputFile = async (filepath, data, options2) => {
+      await _fs2.default.promises.mkdir(_path2.default.dirname(filepath), { recursive: true });
+      await _fs2.default.promises.writeFile(filepath, data, options2);
+    };
+    function copyDirSync(srcDir, destDir) {
+      if (!_fs2.default.existsSync(srcDir)) return;
+      _fs2.default.mkdirSync(destDir, { recursive: true });
+      for (const file of _fs2.default.readdirSync(srcDir)) {
+        const srcFile = _path2.default.resolve(srcDir, file);
+        if (srcFile === destDir) {
+          continue;
+        }
+        const destFile = _path2.default.resolve(destDir, file);
+        const stat = _fs2.default.statSync(srcFile);
+        if (stat.isDirectory()) {
+          copyDirSync(srcFile, destFile);
+        } else {
+          _fs2.default.copyFileSync(srcFile, destFile);
+        }
+      }
+    }
+    var parseSourceMap = (map) => {
+      return typeof map === "string" ? JSON.parse(map) : map;
+    };
+    var isJS = (path12) => /\.(js|mjs|cjs)$/.test(path12);
+    var isCSS = (path12) => /\.css$/.test(path12);
+    var PluginContainer = class {
+      constructor(plugins) {
+        this.plugins = plugins;
+      }
+      setContext(context) {
+        this.context = context;
+      }
+      getContext() {
+        if (!this.context) throw new Error(`Plugin context is not set`);
+        return this.context;
+      }
+      modifyEsbuildOptions(options2) {
+        for (const plugin of this.plugins) {
+          if (plugin.esbuildOptions) {
+            plugin.esbuildOptions.call(this.getContext(), options2);
+          }
+        }
+      }
+      async buildStarted() {
+        for (const plugin of this.plugins) {
+          if (plugin.buildStart) {
+            await plugin.buildStart.call(this.getContext());
+          }
+        }
+      }
+      async buildFinished({
+        options: options2,
+        outputFiles,
+        metafile
+      }) {
+        const files = outputFiles.filter((file) => !file.path.endsWith(".map")).map((file) => {
+          if (isJS(file.path) || isCSS(file.path)) {
+            const relativePath = _chunkTWFEYLU4js.slash.call(void 0, _path2.default.relative(options2.workspaceConfig?.workspaceRoot || process.cwd(), file.path));
+            const meta = _optionalChain([metafile, "optionalAccess", (_6) => _6.outputs, "access", (_7) => _7[relativePath]]);
+            return {
+              type: "chunk",
+              path: file.path,
+              code: file.text,
+              map: _optionalChain([outputFiles, "access", (_8) => _8.find, "call", (_9) => _9((f) => f.path === `${file.path}.map`), "optionalAccess", (_10) => _10.text]),
+              entryPoint: _optionalChain([meta, "optionalAccess", (_11) => _11.entryPoint]),
+              exports: _optionalChain([meta, "optionalAccess", (_12) => _12.exports]),
+              imports: _optionalChain([meta, "optionalAccess", (_13) => _13.imports])
+            };
+          } else {
+            return { type: "asset", path: file.path, contents: file.contents };
+          }
+        });
+        const writtenFiles = [];
+        await Promise.all(
+          files.map(async (info) => {
+            for (const plugin of this.plugins) {
+              if (info.type === "chunk" && plugin.renderChunk) {
+                const result = await plugin.renderChunk.call(
+                  this.getContext(),
+                  info.code,
+                  info
+                );
+                if (result) {
+                  info.code = result.code;
+                  if (result.map) {
+                    try {
+                      const originalConsumer = await new (0, _sourcemap.SourceMapConsumer)(
+                        parseSourceMap(info.map)
+                      );
+                      const newConsumer = await new (0, _sourcemap.SourceMapConsumer)(
+                        parseSourceMap(result.map)
+                      );
+                      const generator = _sourcemap.SourceMapGenerator.fromSourceMap(newConsumer);
+                      generator.applySourceMap(originalConsumer, info.path);
+                      info.map = generator.toJSON();
+                      originalConsumer.destroy();
+                      newConsumer.destroy();
+                    } catch (error) {
+                      console.warn(
+                        `Failed to parse sourcemap for ${info.path}: ${error.message}`
+                      );
+                    }
+                  }
+                }
+              }
+            }
+            const inlineSourceMap = this.context.options.sourcemap === "inline";
+            const contents = info.type === "chunk" ? info.code + getSourcemapComment(
+              inlineSourceMap,
+              info.map,
+              info.path,
+              isCSS(info.path)
+            ) : info.contents;
+            await outputFile(info.path, contents, {
+              mode: info.type === "chunk" ? info.mode : void 0
+            });
+            writtenFiles.push({
+              get name() {
+                return _path2.default.relative(options2.workspaceConfig?.workspaceRoot || process.cwd(), info.path);
+              },
+              get size() {
+                return contents.length;
+              }
+            });
+            if (info.type === "chunk" && info.map && !inlineSourceMap) {
+              const map = typeof info.map === "string" ? JSON.parse(info.map) : info.map;
+              const outPath = `${info.path}.map`;
+              const contents2 = JSON.stringify(map);
+              await outputFile(outPath, contents2);
+              writtenFiles.push({
+                get name() {
+                  return _path2.default.relative(options2.workspaceConfig?.workspaceRoot || process.cwd(), outPath);
+                },
+                get size() {
+                  return contents2.length;
+                }
+              });
+            }
+          })
+        );
+        for (const plugin of this.plugins) {
+          if (plugin.buildEnd) {
+            await plugin.buildEnd.call(this.getContext(), { writtenFiles });
+          }
+        }
+      }
+    };
+    var getSourcemapComment = (inline, map, filepath, isCssFile) => {
+      if (!map) return "";
+      const prefix = isCssFile ? "/*" : "//";
+      const suffix = isCssFile ? " */" : "";
+      const url = inline ? `data:application/json;base64,${Buffer.from(
+        typeof map === "string" ? map : JSON.stringify(map)
+      ).toString("base64")}` : `${_path2.default.basename(filepath)}.map`;
+      return `${prefix}# sourceMappingURL=${url}${suffix}`;
+    };
+    var TARGETS = ["es5", "es3"];
+    var swcTarget = () => {
+      let enabled = false;
+      let target;
+      return {
+        name: "swc-target",
+        esbuildOptions(options2) {
+          if (typeof options2.target === "string" && TARGETS.includes(options2.target)) {
+            target = options2.target;
+            options2.target = "es2020";
+            enabled = true;
+          }
+        },
+        async renderChunk(code, info) {
+          if (!enabled || !/\.(cjs|mjs|js)$/.test(info.path)) {
+            return;
+          }
+          const swc = _chunkTWFEYLU4js.localRequire.call(void 0, "@swc/core");
+          if (!swc) {
+            throw new (0, _chunkJZ25TPTYjs.PrettyError)(
+              `@swc/core is required for ${target} target. Please install it with \`npm install @swc/core -D\``
+            );
+          }
+          const result = await swc.transform(code, {
+            filename: info.path,
+            sourceMaps: this.options.sourcemap,
+            minify: Boolean(this.options.minify),
+            jsc: {
+              target,
+              parser: {
+                syntax: "ecmascript"
+              },
+              minify: this.options.minify === true ? {
+                compress: false,
+                mangle: {
+                  reserved: this.options.globalName ? [this.options.globalName] : []
+                }
+              } : void 0
+            },
+            module: {
+              type: this.format === "cjs" ? "commonjs" : "es6"
+            }
+          });
+          return {
+            code: result.code,
+            map: result.map
+          };
+        }
+      };
+    };
+    var sizeReporter = () => {
+      return {
+        name: "size-reporter",
+        buildEnd({ writtenFiles }) {
+          _chunkVGC3FXLUjs.reportSize.call(
+            void 0,
+            this.logger,
+            this.format,
+            writtenFiles.reduce((res, file) => {
+              return {
+                ...res,
+                [file.name]: file.size
+              };
+            }, {})
+          );
+        }
+      };
+    };
+    var _rollup = require("rollup");
+    var treeShakingPlugin = ({
+      treeshake,
+      name,
+      silent
+    }) => {
+      return {
+        name: "tree-shaking",
+        async renderChunk(code, info) {
+          if (!treeshake || !/\.(cjs|js|mjs)$/.test(info.path)) return;
+          const bundle = await _rollup.rollup.call(void 0, {
+            input: [info.path],
+            plugins: [
+              {
+                name: "tsup",
+                resolveId(source) {
+                  if (source === info.path) return source;
+                  return false;
+                },
+                load(id) {
+                  if (id === info.path) return { code, map: info.map };
+                }
+              }
+            ],
+            treeshake,
+            makeAbsoluteExternalsRelative: false,
+            preserveEntrySignatures: "exports-only",
+            onwarn: silent ? () => {
+            } : void 0
+          });
+          const result = await bundle.generate({
+            interop: "auto",
+            format: this.format,
+            file: info.path,
+            sourcemap: !!this.options.sourcemap,
+            compact: !!this.options.minify,
+            name
+          });
+          for (const file of result.output) {
+            if (file.type === "chunk" && file.fileName === _path2.default.basename(info.path)) {
+              return {
+                code: file.code,
+                map: file.map
+              };
+            }
+          }
+        }
+      };
+    };
+    var copyPublicDir = (publicDir, outDir) => {
+      if (!publicDir) return;
+      copyDirSync(_path2.default.resolve(publicDir === true ? "public" : publicDir), outDir);
+    };
+    var isInPublicDir = (publicDir, filePath) => {
+      if (!publicDir) return false;
+      const publicPath = _chunkTWFEYLU4js.slash.call(
+        void 0,
+        _path2.default.resolve(publicDir === true ? "public" : publicDir)
+      );
+      return _chunkTWFEYLU4js.slash.call(void 0, _path2.default.resolve(filePath)).startsWith(`${publicPath}/`);
+    };
+    var terserPlugin = ({
+      minifyOptions,
+      format,
+      terserOptions = {},
+      globalName,
+      logger: logger3
+    }) => {
+      return {
+        name: "terser",
+        async renderChunk(code, info) {
+          if (minifyOptions !== "terser" || !/\.(cjs|js|mjs)$/.test(info.path))
+            return;
+          const terser = _chunkTWFEYLU4js.localRequire.call(void 0, "terser");
+          if (!terser) {
+            throw new (0, _chunkJZ25TPTYjs.PrettyError)(
+              "terser is required for terser minification. Please install it with `npm install terser -D`"
+            );
+          }
+          const { minify } = terser;
+          const defaultOptions = {};
+          if (format === "esm") {
+            defaultOptions.module = true;
+          } else if (!(format === "iife" && globalName !== void 0)) {
+            defaultOptions.toplevel = true;
+          }
+          try {
+            const minifiedOutput = await minify(
+              { [info.path]: code },
+              { ...defaultOptions, ...terserOptions }
+            );
+            logger3.info("TERSER", "Minifying with Terser");
+            if (!minifiedOutput.code) {
+              logger3.error("TERSER", "Failed to minify with terser");
+            }
+            logger3.success("TERSER", "Terser Minification success");
+            return { code: minifiedOutput.code, map: minifiedOutput.map };
+          } catch (error) {
+            logger3.error("TERSER", "Failed to minify with terser");
+            logger3.error("TERSER", error);
+          }
+          return { code, map: info.map };
+        }
+      };
+    };
+    var _typescript = require("typescript");
+    var _typescript2 = _interopRequireDefault(_typescript);
+    var logger = _chunkVGC3FXLUjs.createLogger.call(void 0);
+    var AliasPool = (_class = class {
+      constructor() {
+        _class.prototype.__init.call(this);
+      }
+      __init() {
+        this.seen = /* @__PURE__ */ new Set();
+      }
+      assign(name) {
+        let suffix = 0;
+        let alias = name === "default" ? "default_alias" : name;
+        while (this.seen.has(alias)) {
+          alias = `${name}_alias_${++suffix}`;
+          if (suffix >= 1e3) {
+            throw new Error(
+              "Alias generation exceeded limit. Possible infinite loop detected."
+            );
+          }
+        }
+        this.seen.add(alias);
+        return alias;
+      }
+    }, _class);
+    function getExports(program, fileMapping) {
+      const checker = program.getTypeChecker();
+      const aliasPool = new AliasPool();
+      const assignAlias = aliasPool.assign.bind(aliasPool);
+      function extractExports(sourceFileName) {
+        const cwd = program.getCurrentDirectory();
+        sourceFileName = _chunkTWFEYLU4js.toAbsolutePath.call(void 0, sourceFileName, cwd);
+        const sourceFile = program.getSourceFile(sourceFileName);
+        if (!sourceFile) {
+          return [];
+        }
+        const destFileName = fileMapping.get(sourceFileName);
+        if (!destFileName) {
+          return [];
+        }
+        const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
+        if (!moduleSymbol) {
+          return [];
+        }
+        const exports3 = [];
+        const exportSymbols = checker.getExportsOfModule(moduleSymbol);
+        exportSymbols.forEach((symbol) => {
+          const name = symbol.getName();
+          exports3.push({
+            kind: "named",
+            sourceFileName,
+            destFileName,
+            name,
+            alias: assignAlias(name),
+            isTypeOnly: false
+          });
+        });
+        return exports3;
+      }
+      return program.getRootFileNames().flatMap(extractExports);
+    }
+    function emitDtsFiles(program, host) {
+      const fileMapping = /* @__PURE__ */ new Map();
+      const writeFile = (fileName, text, writeByteOrderMark, onError, sourceFiles, data) => {
+        const sourceFile = _optionalChain([sourceFiles, "optionalAccess", (_14) => _14[0]]);
+        const sourceFileName = _optionalChain([sourceFile, "optionalAccess", (_15) => _15.fileName]);
+        if (sourceFileName && !fileName.endsWith(".map")) {
+          const cwd = program.getCurrentDirectory();
+          fileMapping.set(
+            _chunkTWFEYLU4js.toAbsolutePath.call(void 0, sourceFileName, cwd),
+            _chunkTWFEYLU4js.toAbsolutePath.call(void 0, fileName, cwd)
+          );
+        }
+        return host.writeFile(
+          fileName,
+          text,
+          writeByteOrderMark,
+          onError,
+          sourceFiles,
+          data
+        );
+      };
+      const emitResult = program.emit(void 0, writeFile, void 0, true);
+      const diagnostics = _typescript2.default.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
+      const diagnosticMessages = [];
+      diagnostics.forEach((diagnostic) => {
+        if (diagnostic.file) {
+          const { line, character } = _typescript2.default.getLineAndCharacterOfPosition(
+            diagnostic.file,
+            diagnostic.start
+          );
+          const message = _typescript2.default.flattenDiagnosticMessageText(
+            diagnostic.messageText,
+            "\n"
+          );
+          diagnosticMessages.push(
+            `${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`
+          );
+        } else {
+          const message = _typescript2.default.flattenDiagnosticMessageText(
+            diagnostic.messageText,
+            "\n"
+          );
+          diagnosticMessages.push(message);
+        }
+      });
+      const diagnosticMessage = diagnosticMessages.join("\n");
+      if (diagnosticMessage) {
+        logger.error(
+          "TSC",
+          `Failed to emit declaration files.
+
+${diagnosticMessage}`
+        );
+        throw new Error("TypeScript compilation failed");
+      }
+      return fileMapping;
+    }
+    function emit(compilerOptions, tsconfig, _options) {
+      const cwd = _options.workspaceConfig?.workspaceRoot || process.cwd();
+      let rawTsconfig = _bundlerequire.loadTsConfig.call(void 0, cwd, tsconfig.replace(cwd, ""));
+      if (!rawTsconfig) {
+        rawTsconfig = _bundlerequire.loadTsConfig.call(void 0, process.cwd(), tsconfig.replace(cwd, ""));
+        if (!rawTsconfig) {
+          throw new Error(`Unable to find ${tsconfig || "tsconfig.json"} in ${cwd}`);
+        }
+      }
+      const declarationDir = _chunkTWFEYLU4js.ensureTempDeclarationDir.call(void 0, _options);
+      const parsedTsconfig = _typescript2.default.parseJsonConfigFileContent(
+        {
+          ...rawTsconfig.data,
+          compilerOptions: {
+            ..._optionalChain([rawTsconfig, "access", (_16) => _16.data, "optionalAccess", (_17) => _17.compilerOptions]),
+            ...compilerOptions,
+            // Enable declaration emit and disable javascript emit
+            noEmit: false,
+            declaration: true,
+            declarationMap: true,
+            declarationDir,
+            emitDeclarationOnly: true
+          }
+        },
+        _typescript2.default.sys,
+        tsconfig ? _path.dirname.call(void 0, tsconfig) : "./"
+      );
+      const options2 = parsedTsconfig.options;
+      const host = _typescript2.default.createCompilerHost(options2);
+      const program = _typescript2.default.createProgram(
+        parsedTsconfig.fileNames,
+        options2,
+        host
+      );
+      const fileMapping = emitDtsFiles(program, host);
+      return getExports(program, fileMapping);
+    }
+    function runTypeScriptCompiler(options2) {
+      try {
+        const start = Date.now();
+        const getDuration = () => {
+          return `${Math.floor(Date.now() - start)}ms`;
+        };
+        logger.info("tsc", "Build start");
+        const dtsOptions = options2.experimentalDts;
+        const exports3 = emit(dtsOptions.compilerOptions, options2.tsconfig, options2);
+        logger.success("tsc", `\u26A1\uFE0F Build success in ${getDuration()}`);
+        return exports3;
+      } catch (error) {
+        _chunkJZ25TPTYjs.handleError.call(void 0, error);
+        logger.error("tsc", "Build error");
+      }
+    }
+    function formatAggregationExports(exports3, declarationDirPath) {
+      const lines = exports3.map(
+        (declaration) => formatAggregationExport(declaration, declarationDirPath)
+      ).filter(_chunkTWFEYLU4js.truthy);
+      if (lines.length === 0) {
+        lines.push("export {};");
+      }
+      return `${lines.join("\n")}
+`;
+    }
+    function formatAggregationExport(declaration, declarationDirPath) {
+      const dest = _chunkTWFEYLU4js.replaceDtsWithJsExtensions.call(
+        void 0,
+        `./${_path2.default.posix.normalize(
+          _chunkTWFEYLU4js.slash.call(void 0, _path2.default.relative(declarationDirPath, declaration.destFileName))
+        )}`
+      );
+      if (declaration.kind === "module") {
+        return "";
+      } else if (declaration.kind === "named") {
+        return [
+          "export",
+          declaration.isTypeOnly ? "type" : "",
+          "{",
+          declaration.name,
+          declaration.name === declaration.alias ? "" : `as ${declaration.alias}`,
+          "} from",
+          `'${dest}';`
+        ].filter(_chunkTWFEYLU4js.truthy).join(" ");
+      } else {
+        throw new Error("Unknown declaration");
+      }
+    }
+    function formatDistributionExports(exports3, fromFilePath, toFilePath) {
+      let importPath = _chunkTWFEYLU4js.replaceDtsWithJsExtensions.call(
+        void 0,
+        _path2.default.posix.relative(
+          _path2.default.posix.dirname(_path2.default.posix.normalize(_chunkTWFEYLU4js.slash.call(void 0, fromFilePath))),
+          _path2.default.posix.normalize(_chunkTWFEYLU4js.slash.call(void 0, toFilePath))
+        )
+      );
+      if (!/^\.+\//.test(importPath)) {
+        importPath = `./${importPath}`;
+      }
+      const seen = {
+        named: /* @__PURE__ */ new Set(),
+        module: /* @__PURE__ */ new Set()
+      };
+      const lines = exports3.filter((declaration) => {
+        if (declaration.kind === "module") {
+          if (seen.module.has(declaration.moduleName)) {
+            return false;
+          }
+          seen.module.add(declaration.moduleName);
+          return true;
+        } else if (declaration.kind === "named") {
+          if (seen.named.has(declaration.name)) {
+            return false;
+          }
+          seen.named.add(declaration.name);
+          return true;
+        } else {
+          return false;
+        }
+      }).map((declaration) => formatDistributionExport(declaration, importPath)).filter(_chunkTWFEYLU4js.truthy);
+      if (lines.length === 0) {
+        lines.push("export {};");
+      }
+      return `${lines.join("\n")}
+`;
+    }
+    function formatDistributionExport(declaration, dest) {
+      if (declaration.kind === "named") {
+        return [
+          "export",
+          declaration.isTypeOnly ? "type" : "",
+          "{",
+          declaration.alias,
+          declaration.name === declaration.alias ? "" : `as ${declaration.name}`,
+          "} from",
+          `'${dest}';`
+        ].filter(_chunkTWFEYLU4js.truthy).join(" ");
+      } else if (declaration.kind === "module") {
+        return `export * from '${declaration.moduleName}';`;
+      }
+      return "";
+    }
+    var logger2 = _chunkVGC3FXLUjs.createLogger.call(void 0);
+    function rollupDtsFile(inputFilePath, outputFilePath, tsconfigFilePath, options2) {
+      const cwd = options2.workspaceConfig?.workspaceRoot || process.cwd();
+      const packageJsonFullPath = _path2.default.join(cwd, "package.json");
+      const configObject = {
+        mainEntryPointFilePath: inputFilePath,
+        apiReport: {
+          enabled: false,
+          // `reportFileName` is not been used. It's just to fit the requirement of API Extractor.
+          reportFileName: "tsup-report.api.md"
+        },
+        docModel: { enabled: false },
+        dtsRollup: {
+          enabled: true,
+          untrimmedFilePath: outputFilePath
+        },
+        tsdocMetadata: { enabled: false },
+        compiler: {
+          tsconfigFilePath
+        },
+        projectFolder: cwd,
+        newlineKind: "lf"
+      };
+      const prepareOptions = {
+        configObject,
+        configObjectFullPath: void 0,
+        packageJsonFullPath
+      };
+      const imported = _chunkTWFEYLU4js.getApiExtractor.call(void 0);
+      if (!imported) {
+        throw new Error(
+          `@microsoft/api-extractor is not installed. Please install it first.`
+        );
+      }
+      const { ExtractorConfig, Extractor } = imported;
+      const extractorConfig = ExtractorConfig.prepare(prepareOptions);
+      const extractorResult = Extractor.invoke(extractorConfig, {
+        // Equivalent to the "--local" command-line parameter
+        localBuild: true,
+        // Equivalent to the "--verbose" command-line parameter
+        showVerboseMessages: true
+      });
+      if (!extractorResult.succeeded) {
+        throw new Error(
+          `API Extractor completed with ${extractorResult.errorCount} errors and ${extractorResult.warningCount} warnings when processing ${inputFilePath}`
+        );
+      }
+    }
+    async function rollupDtsFiles(options2, exports3, format) {
+      if (!options2.experimentalDts || !_optionalChain([options2, "access", (_18) => _18.experimentalDts, "optionalAccess", (_19) => _19.entry])) {
+        return;
+      }
+      const declarationDir = _chunkTWFEYLU4js.ensureTempDeclarationDir.call(void 0, options2);
+      const outDir = options2.outDir || "dist";
+      const pkg = await _chunkVGC3FXLUjs.loadPkg.call(void 0, options2.workspaceConfig?.workspaceRoot || process.cwd());
+      const dtsExtension = _chunkTWFEYLU4js.defaultOutExtension.call(void 0, { format, pkgType: pkg.type }).dts;
+      const tsconfig = options2.tsconfig || "tsconfig.json";
+      let dtsInputFilePath = _path2.default.join(
+        declarationDir,
+        `_tsup-dts-aggregation${dtsExtension}`
+      );
+      dtsInputFilePath = dtsInputFilePath.replace(/\.d\.mts$/, ".dmts.d.ts").replace(/\.d\.cts$/, ".dcts.d.ts");
+      const dtsOutputFilePath = _path2.default.join(outDir, `_tsup-dts-rollup${dtsExtension}`);
+      _chunkTWFEYLU4js.writeFileSync.call(
+        void 0,
+        dtsInputFilePath,
+        formatAggregationExports(exports3, declarationDir, options2)
+      );
+      rollupDtsFile(dtsInputFilePath, dtsOutputFilePath, tsconfig, options2);
+      for (let [out, sourceFileName] of Object.entries(
+        options2.experimentalDts.entry
+      )) {
+        sourceFileName = _chunkTWFEYLU4js.toAbsolutePath.call(void 0, sourceFileName);
+        const outFileName = _path2.default.join(outDir, out + dtsExtension);
+        const currentExports = exports3.filter(
+          (declaration) => declaration.sourceFileName === sourceFileName
+        );
+        _chunkTWFEYLU4js.writeFileSync.call(
+          void 0,
+          outFileName,
+          formatDistributionExports(currentExports, outFileName, dtsOutputFilePath)
+        );
+      }
+    }
+    async function cleanDtsFiles(options2) {
+      if (options2.clean) {
+        await _chunkTWFEYLU4js.removeFiles.call(void 0, ["**/*.d.{ts,mts,cts}"], options2.outDir);
+      }
+    }
+    async function runDtsRollup(options2, exports3) {
+      try {
+        const start = Date.now();
+        const getDuration = () => {
+          return `${Math.floor(Date.now() - start)}ms`;
+        };
+        logger2.info("dts", "Build start");
+        if (!exports3) {
+          throw new Error("Unexpected internal error: dts exports is not define");
+        }
+        await cleanDtsFiles(options2);
+        for (const format of options2.format) {
+          await rollupDtsFiles(options2, exports3, format);
+        }
+        logger2.success("dts", `\u26A1\uFE0F Build success in ${getDuration()}`);
+      } catch (error) {
+        _chunkJZ25TPTYjs.handleError.call(void 0, error);
+        logger2.error("dts", "Build error");
+      }
+    }
+    var cjsInterop = () => {
+      return {
+        name: "cjs-interop",
+        renderChunk(code, info) {
+          if (!this.options.cjsInterop || this.format !== "cjs" || info.type !== "chunk" || !/\.(js|cjs)$/.test(info.path) || !info.entryPoint || _optionalChain([info, "access", (_20) => _20.exports, "optionalAccess", (_21) => _21.length]) !== 1 || info.exports[0] !== "default") {
+            return;
+          }
+          return {
+            code: `${code}
+module.exports = exports.default;
+`,
+            map: info.map
+          };
+        }
+      };
+    };
+    var defineConfig = (options2) => options2;
+    var isTaskkillCmdProcessNotFoundError = (err) => {
+      return process.platform === "win32" && "cmd" in err && "code" in err && typeof err.cmd === "string" && err.cmd.startsWith("taskkill") && err.code === 128;
+    };
+    var killProcess = ({ pid, signal }) => new Promise((resolve, reject) => {
+      _treekill2.default.call(void 0, pid, signal, (err) => {
+        if (err && !isTaskkillCmdProcessNotFoundError(err)) return reject(err);
+        resolve();
+      });
+    });
+    var normalizeOptions = async (logger3, optionsFromConfigFile, optionsOverride) => {
+      const _options = {
+        ...optionsFromConfigFile,
+        ...optionsOverride
+      };
+      const options2 = {
+        outDir: "dist",
+        removeNodeProtocol: true,
+        ..._options,
+        format: typeof _options.format === "string" ? [_options.format] : _options.format || ["cjs"],
+        dts: typeof _options.dts === "boolean" ? _options.dts ? {} : void 0 : typeof _options.dts === "string" ? { entry: _options.dts } : _options.dts,
+        experimentalDts: await _chunkTWFEYLU4js.resolveInitialExperimentalDtsConfig.call(
+          void 0,
+          _options.experimentalDts
+        )
+      };
+      if (!options2.workspaceConfig)
+        options2.workspaceConfig = {};
+      if (!options2.workspaceConfig.workspaceRoot)
+        options2.workspaceConfig.workspaceRoot = process.cwd();
+      _chunkVGC3FXLUjs.setSilent.call(void 0, options2.silent);
+      const entry = options2.entry || options2.entryPoints;
+      if (!entry || Object.keys(entry).length === 0) {
+        throw new (0, _chunkJZ25TPTYjs.PrettyError)(`No input files, try "tsup <your-file>" instead`);
+      }
+      if (Array.isArray(entry)) {
+        options2.entry = await _tinyglobby.glob.call(void 0, entry);
+        if (!options2.entry || options2.entry.length === 0) {
+          throw new (0, _chunkJZ25TPTYjs.PrettyError)(`Cannot find ${entry}`);
+        } else {
+          logger3.info("CLI", `Building entry: ${options2.entry.join(", ")}`);
+        }
+      } else {
+        Object.keys(entry).forEach((alias) => {
+          const filename = entry[alias];
+          if (!_fs2.default.existsSync(filename)) {
+            throw new (0, _chunkJZ25TPTYjs.PrettyError)(`Cannot find ${alias}: ${filename}`);
+          }
+        });
+        options2.entry = entry;
+        logger3.info("CLI", `Building entry: ${JSON.stringify(entry)}`);
+      }
+      const tsconfig = _bundlerequire.loadTsConfig.call(void 0, options2.workspaceConfig?.workspaceRoot || process.cwd(), options2.tsconfig);
+      if (tsconfig) {
+        logger3.info(
+          "CLI",
+          `Using tsconfig: ${_path2.default.relative(options2.workspaceConfig?.workspaceRoot || process.cwd(), tsconfig.path)}`
+        );
+        options2.tsconfig = tsconfig.path;
+        options2.tsconfigResolvePaths = _optionalChain([tsconfig, "access", (_22) => _22.data, "optionalAccess", (_23) => _23.compilerOptions, "optionalAccess", (_24) => _24.paths]) || {};
+        options2.tsconfigDecoratorMetadata = _optionalChain([tsconfig, "access", (_25) => _25.data, "optionalAccess", (_26) => _26.compilerOptions, "optionalAccess", (_27) => _27.emitDecoratorMetadata]);
+        if (options2.dts) {
+          options2.dts.compilerOptions = {
+            ...tsconfig.data.compilerOptions || {},
+            ...options2.dts.compilerOptions || {}
+          };
+        }
+        if (options2.experimentalDts) {
+          options2.experimentalDts = await _chunkTWFEYLU4js.resolveExperimentalDtsConfig.call(
+            void 0,
+            options2,
+            tsconfig
+          );
+        }
+        if (!options2.target) {
+          options2.target = _optionalChain([tsconfig, "access", (_28) => _28.data, "optionalAccess", (_29) => _29.compilerOptions, "optionalAccess", (_30) => _30.target, "optionalAccess", (_31) => _31.toLowerCase, "call", (_32) => _32()]);
+        }
+      } else if (options2.tsconfig) {
+        throw new (0, _chunkJZ25TPTYjs.PrettyError)(`Cannot find tsconfig: ${options2.tsconfig}`);
+      }
+      if (!options2.target) {
+        options2.target = "node16";
+      }
+      return options2;
+    };
+    async function build2(_options) {
+      const config = _options.config === false ? {} : await _chunkVGC3FXLUjs.loadTsupConfig.call(
+        void 0,
+        _options.workspaceConfig?.workspaceRoot || process.cwd(),
+        _options.config === true ? void 0 : _options.config
+      );
+      const configData = typeof config.data === "function" ? await config.data(_options) : config.data;
+      await Promise.all(
+        [...Array.isArray(configData) ? configData : [configData]].map(
+          async (item) => {
+            const logger3 = _chunkVGC3FXLUjs.createLogger.call(void 0, _optionalChain([item, "optionalAccess", (_33) => _33.name]));
+            const options2 = await normalizeOptions(logger3, item, _options);
+            logger3.info("CLI", `tsup v${_chunkBYH4XDRHjs.version}`);
+            if (config.path) {
+              logger3.info("CLI", `Using tsup config: ${config.path}`);
+            }
+            if (options2.watch) {
+              logger3.info("CLI", "Running in watch mode");
+            }
+            const experimentalDtsTask = async () => {
+              if (!options2.dts && options2.experimentalDts) {
+                const exports3 = runTypeScriptCompiler(options2);
+                await runDtsRollup(options2, exports3);
+              }
+            };
+            const dtsTask = async () => {
+              if (options2.dts && options2.experimentalDts) {
+                throw new Error(
+                  "You can't use both `dts` and `experimentalDts` at the same time"
+                );
+              }
+              await experimentalDtsTask();
+              if (options2.dts) {
+                await new Promise((resolve, reject) => {
+                  let workerPath = _path2.default.join(__dirname, "./rollup.cjs");
+                  if (!_fs2.default.existsSync(workerPath)) {
+                    workerPath = _path2.default.join(__dirname, "./rollup.js");
+                  }
+                  const worker = new (0, _worker_threads.Worker)(workerPath);
+                  const terminateWorker = () => {
+                    if (options2.watch) return;
+                    worker.terminate();
+                  };
+                  worker.postMessage({
+                    configName: _optionalChain([item, "optionalAccess", (_34) => _34.name]),
+                    options: {
+                      ...options2,
+                      // functions cannot be cloned
+                      injectStyle: typeof options2.injectStyle === "function" ? void 0 : options2.injectStyle,
+                      banner: void 0,
+                      footer: void 0,
+                      esbuildPlugins: void 0,
+                      esbuildOptions: void 0,
+                      plugins: void 0,
+                      treeshake: void 0,
+                      onSuccess: void 0,
+                      outExtension: void 0
+                    }
+                  });
+                  worker.on("message", (data) => {
+                    if (data === "error") {
+                      terminateWorker();
+                      reject(new Error("error occurred in dts build"));
+                    } else if (data === "success") {
+                      terminateWorker();
+                      resolve();
+                    } else {
+                      const { type, text } = data;
+                      if (type === "log") {
+                        console.log(text);
+                      } else if (type === "error") {
+                        console.error(text);
+                      }
+                    }
+                  });
+                });
+              }
+            };
+            const mainTasks = async () => {
+              if (!_optionalChain([options2, "access", (_35) => _35.dts, "optionalAccess", (_36) => _36.only])) {
+                let onSuccessProcess;
+                let onSuccessCleanup;
+                const buildDependencies = /* @__PURE__ */ new Set();
+                let depsHash = await _chunkVGC3FXLUjs.getAllDepsHash.call(void 0, options2.workspaceConfig?.workspaceRoot || process.cwd());
+                const doOnSuccessCleanup = async () => {
+                  if (onSuccessProcess) {
+                    await killProcess({
+                      pid: onSuccessProcess.pid,
+                      signal: options2.killSignal || "SIGTERM"
+                    });
+                  } else if (onSuccessCleanup) {
+                    await onSuccessCleanup();
+                  }
+                  onSuccessProcess = void 0;
+                  onSuccessCleanup = void 0;
+                };
+                const debouncedBuildAll = _chunkTWFEYLU4js.debouncePromise.call(
+                  void 0,
+                  () => {
+                    return buildAll();
+                  },
+                  100,
+                  _chunkJZ25TPTYjs.handleError
+                );
+                const buildAll = async () => {
+                  await doOnSuccessCleanup();
+                  const previousBuildDependencies = new Set(buildDependencies);
+                  buildDependencies.clear();
+                  if (options2.clean) {
+                    const extraPatterns = Array.isArray(options2.clean) ? options2.clean : [];
+                    if (options2.dts || options2.experimentalDts) {
+                      extraPatterns.unshift("!**/*.d.{ts,cts,mts}");
+                    }
+                    await _chunkTWFEYLU4js.removeFiles.call(void 0, ["**/*", ...extraPatterns], options2.outDir);
+                    logger3.info("CLI", "Cleaning output folder");
+                  }
+                  const css = /* @__PURE__ */ new Map();
+                  await Promise.all([
+                    ...options2.format.map(async (format, index) => {
+                      const pluginContainer = new PluginContainer([
+                        shebang(),
+                        ...options2.plugins || [],
+                        treeShakingPlugin({
+                          treeshake: options2.treeshake,
+                          name: options2.globalName,
+                          silent: options2.silent
+                        }),
+                        cjsSplitting(),
+                        cjsInterop(),
+                        swcTarget(),
+                        sizeReporter(),
+                        terserPlugin({
+                          minifyOptions: options2.minify,
+                          format,
+                          terserOptions: options2.terserOptions,
+                          globalName: options2.globalName,
+                          logger: logger3
+                        })
+                      ]);
+                      await runEsbuild(options2, {
+                        pluginContainer,
+                        format,
+                        css: index === 0 || options2.injectStyle ? css : void 0,
+                        logger: logger3,
+                        buildDependencies
+                      }).catch((error) => {
+                        previousBuildDependencies.forEach(
+                          (v) => buildDependencies.add(v)
+                        );
+                        throw error;
+                      });
+                    })
+                  ]);
+                  if (options2.onSuccess) {
+                    if (typeof options2.onSuccess === "function") {
+                      onSuccessCleanup = await options2.onSuccess();
+                    } else {
+                      onSuccessProcess = _tinyexec.exec.call(void 0, options2.onSuccess, [], {
+                        nodeOptions: { shell: true, stdio: "inherit" }
+                      });
+                      _optionalChain([onSuccessProcess, "access", (_37) => _37.process, "optionalAccess", (_38) => _38.on, "call", (_39) => _39("exit", (code) => {
+                        if (code && code !== 0) {
+                          process.exitCode = code;
+                        }
+                      })]);
+                    }
+                  }
+                };
+                const startWatcher = async () => {
+                  if (!options2.watch) return;
+                  const { watch } = await Promise.resolve().then(() => _interopRequireWildcard(require("chokidar")));
+                  const customIgnores = options2.ignoreWatch ? Array.isArray(options2.ignoreWatch) ? options2.ignoreWatch : [options2.ignoreWatch] : [];
+                  const ignored = [
+                    "**/{.git,node_modules}/**",
+                    options2.outDir,
+                    ...customIgnores
+                  ];
+                  const watchPaths = typeof options2.watch === "boolean" ? "." : Array.isArray(options2.watch) ? options2.watch.filter((path12) => typeof path12 === "string") : options2.watch;
+                  logger3.info(
+                    "CLI",
+                    `Watching for changes in ${Array.isArray(watchPaths) ? watchPaths.map((v) => `"${v}"`).join(" | ") : `"${watchPaths}"`}`
+                  );
+                  logger3.info(
+                    "CLI",
+                    `Ignoring changes in ${ignored.map((v) => `"${v}"`).join(" | ")}`
+                  );
+                  const watcher = watch(await _tinyglobby.glob.call(void 0, watchPaths), {
+                    ignoreInitial: true,
+                    ignorePermissionErrors: true,
+                    ignored: (p) => _tinyglobby.globSync.call(void 0, p, { ignore: ignored }).length === 0
+                  });
+                  watcher.on("all", async (type, file) => {
+                    file = _chunkTWFEYLU4js.slash.call(void 0, file);
+                    if (options2.publicDir && isInPublicDir(options2.publicDir, file)) {
+                      logger3.info("CLI", `Change in public dir: ${file}`);
+                      copyPublicDir(options2.publicDir, options2.outDir);
+                      return;
+                    }
+                    let shouldSkipChange = false;
+                    if (options2.watch === true) {
+                      if (file === "package.json" && !buildDependencies.has(file)) {
+                        const currentHash = await _chunkVGC3FXLUjs.getAllDepsHash.call(void 0, options2.workspaceConfig?.workspaceRoot || process.cwd());
+                        shouldSkipChange = currentHash === depsHash;
+                        depsHash = currentHash;
+                      } else if (!buildDependencies.has(file)) {
+                        shouldSkipChange = true;
+                      }
+                    }
+                    if (shouldSkipChange) {
+                      return;
+                    }
+                    logger3.info("CLI", `Change detected: ${type} ${file}`);
+                    debouncedBuildAll();
+                  });
+                };
+                logger3.info("CLI", `Target: ${options2.target}`);
+                await buildAll();
+                copyPublicDir(options2.publicDir, options2.outDir);
+                startWatcher();
+              }
+            };
+            await Promise.all([dtsTask(), mainTasks()]);
+          }
+        )
+      );
+    }
+    exports2.build = build2;
+    exports2.defineConfig = defineConfig;
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  build: () => build
+});
+module.exports = __toCommonJS(index_exports);
+init_cjs_shims();
+
+// ../config-tools/dist/logger/console.js
+init_cjs_shims();
+
+// ../config-tools/dist/chunk-7L77OWOV.js
+init_cjs_shims();
+
+// ../config-tools/dist/chunk-LA3S35UI.js
+init_cjs_shims();
+var DEFAULT_COLOR_CONFIG = {
+  light: {
+    background: "#fafafa",
+    foreground: "#1d1e22",
+    brand: "#1fb2a6",
+    alternate: "#db2777",
+    help: "#5C4EE5",
+    success: "#087f5b",
+    info: "#0550ae",
+    warning: "#e3b341",
+    danger: "#D8314A",
+    fatal: "#51070f",
+    link: "#3fa6ff",
+    positive: "#22c55e",
+    negative: "#dc2626",
+    gradient: ["#1fb2a6", "#db2777", "#5C4EE5"]
+  },
+  dark: {
+    background: "#1d1e22",
+    foreground: "#cbd5e1",
+    brand: "#2dd4bf",
+    alternate: "#db2777",
+    help: "#818cf8",
+    success: "#10b981",
+    info: "#58a6ff",
+    warning: "#f3d371",
+    danger: "#D8314A",
+    fatal: "#a40e26",
+    link: "#3fa6ff",
+    positive: "#22c55e",
+    negative: "#dc2626",
+    gradient: ["#1fb2a6", "#db2777", "#818cf8"]
+  }
+};
+
+// ../config-tools/dist/chunk-HVVJHTFS.js
+init_cjs_shims();
+var import_chalk = __toESM(require("chalk"), 1);
+var chalkDefault = {
+  hex: (_) => (message) => message,
+  bgHex: (_) => ({
+    whiteBright: (message) => message,
+    white: (message) => message
+  }),
+  white: (message) => message,
+  whiteBright: (message) => message,
+  gray: (message) => message,
+  bold: {
+    hex: (_) => (message) => message,
+    bgHex: (_) => ({
+      whiteBright: (message) => message,
+      white: (message) => message
+    }),
+    whiteBright: (message) => message,
+    white: (message) => message
+  },
+  dim: {
+    hex: (_) => (message) => message,
+    gray: (message) => message
+  }
+};
+var getChalk = () => {
+  let _chalk = import_chalk.default;
+  if (!_chalk?.hex || !_chalk?.bold?.hex || !_chalk?.bgHex || !_chalk?.whiteBright || !_chalk?.white) {
+    _chalk = chalkDefault;
+  }
+  return _chalk;
+};
+
+// ../config-tools/dist/chunk-LM2UMGYA.js
+init_cjs_shims();
+
+// ../config-tools/dist/chunk-G2MK47WL.js
+init_cjs_shims();
+function isUnicodeSupported() {
+  if (process.platform !== "win32") {
+    return process.env.TERM !== "linux";
+  }
+  return Boolean(process.env.WT_SESSION) || // Windows Terminal
+  Boolean(process.env.TERMINUS_SUBLIME) || // Terminus (<0.2.27)
+  process.env.ConEmuTask === "{cmd::Cmder}" || // ConEmu and cmder
+  process.env.TERM_PROGRAM === "Terminus-Sublime" || process.env.TERM_PROGRAM === "vscode" || process.env.TERM === "xterm-256color" || process.env.TERM === "alacritty" || process.env.TERM === "rxvt-unicode" || process.env.TERM === "rxvt-unicode-256color" || process.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+
+// ../config-tools/dist/chunk-POXTJ6GF.js
+init_cjs_shims();
+var LogLevel = {
+  SILENT: 0,
+  FATAL: 10,
+  ERROR: 20,
+  WARN: 30,
+  SUCCESS: 35,
+  INFO: 40,
+  DEBUG: 60,
+  TRACE: 70,
+  ALL: 100
+};
+var LogLevelLabel = {
+  SILENT: "silent",
+  FATAL: "fatal",
+  ERROR: "error",
+  WARN: "warn",
+  SUCCESS: "success",
+  INFO: "info",
+  DEBUG: "debug",
+  TRACE: "trace",
+  ALL: "all"
+};
+
+// ../config-tools/dist/chunk-LM2UMGYA.js
+var useIcon = (c, fallback) => isUnicodeSupported() ? c : fallback;
+var CONSOLE_ICONS = {
+  [LogLevelLabel.ERROR]: useIcon("\u2718", "\xD7"),
+  [LogLevelLabel.FATAL]: useIcon("\u{1F480}", "\xD7"),
+  [LogLevelLabel.WARN]: useIcon("\u26A0", "\u203C"),
+  [LogLevelLabel.INFO]: useIcon("\u2139", "i"),
+  [LogLevelLabel.SUCCESS]: useIcon("\u2714", "\u221A"),
+  [LogLevelLabel.DEBUG]: useIcon("\u{1F6E0}", "D"),
+  [LogLevelLabel.TRACE]: useIcon("\u{1F6E0}", "T"),
+  [LogLevelLabel.ALL]: useIcon("\u2709", "\u2192")
+};
+
+// ../config-tools/dist/chunk-CZ4IE2QN.js
+init_cjs_shims();
+var formatTimestamp = (date = /* @__PURE__ */ new Date()) => {
+  return `${date.toLocaleDateString()} ${date.toLocaleTimeString()}`;
+};
+
+// ../config-tools/dist/chunk-K4CDYUQR.js
+init_cjs_shims();
+var getLogLevel = (label) => {
+  switch (label) {
+    case "all":
+      return LogLevel.ALL;
+    case "trace":
+      return LogLevel.TRACE;
+    case "debug":
+      return LogLevel.DEBUG;
+    case "info":
+      return LogLevel.INFO;
+    case "warn":
+      return LogLevel.WARN;
+    case "error":
+      return LogLevel.ERROR;
+    case "fatal":
+      return LogLevel.FATAL;
+    case "silent":
+      return LogLevel.SILENT;
+    default:
+      return LogLevel.INFO;
+  }
+};
+
+// ../config-tools/dist/chunk-7L77OWOV.js
+var getLogFn = (logLevel = LogLevel.INFO, config = {}, _chalk = getChalk()) => {
+  const colors = !config.colors?.dark && !config.colors?.["base"] && !config.colors?.["base"]?.dark ? DEFAULT_COLOR_CONFIG : config.colors?.dark && typeof config.colors.dark === "string" ? config.colors : config.colors?.["base"]?.dark && typeof config.colors["base"].dark === "string" ? config.colors["base"].dark : config.colors?.["base"] ? config.colors?.["base"] : DEFAULT_COLOR_CONFIG;
+  const configLogLevel = config.logLevel || process.env.STORM_LOG_LEVEL || LogLevelLabel.INFO;
+  if (logLevel > getLogLevel(configLogLevel) || logLevel <= LogLevel.SILENT || getLogLevel(configLogLevel) <= LogLevel.SILENT) {
+    return (_) => {
+    };
+  }
+  if (typeof logLevel === "number" && LogLevel.FATAL >= logLevel) {
+    return (message) => {
+      console.error(
+        `
+${_chalk.gray(formatTimestamp())} ${_chalk.hex(colors.fatal ?? DEFAULT_COLOR_CONFIG.dark.fatal)(`[${CONSOLE_ICONS[LogLevelLabel.FATAL]} Fatal] `)}${_chalk.bold.whiteBright(formatLogMessage(message))}
+`
+      );
+    };
+  }
+  if (typeof logLevel === "number" && LogLevel.ERROR >= logLevel) {
+    return (message) => {
+      console.error(
+        `
+${_chalk.gray(formatTimestamp())} ${_chalk.hex(colors.danger ?? DEFAULT_COLOR_CONFIG.dark.danger)(`[${CONSOLE_ICONS[LogLevelLabel.ERROR]} Error] `)}${_chalk.bold.whiteBright(formatLogMessage(message))}
+`
+      );
+    };
+  }
+  if (typeof logLevel === "number" && LogLevel.WARN >= logLevel) {
+    return (message) => {
+      console.warn(
+        `
+${_chalk.gray(formatTimestamp())} ${_chalk.hex(colors.warning ?? DEFAULT_COLOR_CONFIG.dark.warning)(`[${CONSOLE_ICONS[LogLevelLabel.WARN]} Warn] `)}${_chalk.bold.whiteBright(formatLogMessage(message))}
+`
+      );
+    };
+  }
+  if (typeof logLevel === "number" && LogLevel.SUCCESS >= logLevel) {
+    return (message) => {
+      console.info(
+        `
+${_chalk.gray(formatTimestamp())} ${_chalk.hex(colors.success ?? DEFAULT_COLOR_CONFIG.dark.success)(`[${CONSOLE_ICONS[LogLevelLabel.SUCCESS]} Success] `)}${_chalk.bold.whiteBright(formatLogMessage(message))}
+`
+      );
+    };
+  }
+  if (typeof logLevel === "number" && LogLevel.INFO >= logLevel) {
+    return (message) => {
+      console.info(
+        `
+${_chalk.gray(formatTimestamp())} ${_chalk.hex(colors.info ?? DEFAULT_COLOR_CONFIG.dark.info)(`[${CONSOLE_ICONS[LogLevelLabel.INFO]} Info] `)}${_chalk.bold.whiteBright(formatLogMessage(message))}
+`
+      );
+    };
+  }
+  if (typeof logLevel === "number" && LogLevel.DEBUG >= logLevel) {
+    return (message) => {
+      console.debug(
+        `
+${_chalk.gray(formatTimestamp())} ${_chalk.hex(colors.info ?? DEFAULT_COLOR_CONFIG.dark.info)(`[${CONSOLE_ICONS[LogLevelLabel.DEBUG]} Debug] `)}${_chalk.bold.whiteBright(formatLogMessage(message))}
+`
+      );
+    };
+  }
+  if (typeof logLevel === "number" && LogLevel.TRACE >= logLevel) {
+    return (message) => {
+      console.debug(
+        `
+${_chalk.gray(formatTimestamp())} ${_chalk.hex(colors.info ?? DEFAULT_COLOR_CONFIG.dark.info)(`[${CONSOLE_ICONS[LogLevelLabel.TRACE]} Trace] `)}${_chalk.bold.whiteBright(formatLogMessage(message))}
+`
+      );
+    };
+  }
+  return (message) => {
+    console.log(
+      `
+${_chalk.gray(formatTimestamp())} ${_chalk.hex(colors.brand ?? DEFAULT_COLOR_CONFIG.dark.brand)(`[${CONSOLE_ICONS[LogLevelLabel.ALL]} System] `)}${_chalk.bold.whiteBright(formatLogMessage(message))}
+`
+    );
+  };
+};
+var writeDebug = (message, config) => getLogFn(LogLevel.DEBUG, config)(message);
+var getStopwatch = (name) => {
+  const start = process.hrtime();
+  return () => {
+    const end = process.hrtime(start);
+    console.info(
+      `
+>  \u23F1\uFE0F  The${name ? ` ${name}` : ""} process took ${Math.round(
+        end[0] * 1e3 + end[1] / 1e6
+      )}ms to complete
+`
+    );
+  };
+};
+var MAX_DEPTH = 4;
+var formatLogMessage = (message, options2 = {}, depth = 0) => {
+  if (depth > MAX_DEPTH) {
+    return "<max depth>";
+  }
+  const prefix = options2.prefix ?? "-";
+  const skip = options2.skip ?? [];
+  return typeof message === "undefined" || message === null || !message && typeof message !== "boolean" ? "<none>" : typeof message === "string" ? message : Array.isArray(message) ? `
+${message.map((item, index) => ` ${prefix}> #${index} = ${formatLogMessage(item, { prefix: `${prefix}-`, skip }, depth + 1)}`).join("\n")}` : typeof message === "object" ? `
+${Object.keys(message).filter((key) => !skip.includes(key)).map(
+    (key) => ` ${prefix}> ${key} = ${_isFunction(message[key]) ? "<function>" : typeof message[key] === "object" ? formatLogMessage(
+      message[key],
+      { prefix: `${prefix}-`, skip },
+      depth + 1
+    ) : message[key]}`
+  ).join("\n")}` : message;
+};
+var _isFunction = (value) => {
+  try {
+    return value instanceof Function || typeof value === "function" || !!(value?.constructor && value?.call && value?.apply);
+  } catch {
+    return false;
+  }
+};
+
+// src/index.ts
+var import_tsup = __toESM(require_dist(), 1);
+async function build(options2) {
+  writeDebug(
+    `  \u{1F680}  Running ${options2.name || "tsup"} build`,
+    options2.workspaceConfig
+  );
+  const stopwatch = getStopwatch(`${options2.name || "tsup"} build`);
+  await (0, import_tsup.build)(options2);
+  stopwatch();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  build
+});