@storm-software/esbuild 0.34.0 → 0.34.2

package/dist/chunk-M3AOQRGN.cjs

@@ -0,0 +1,2939 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard2(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 _interopRequireDefault2(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce2(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain2(ops) { let lastAccessLHS = undefined; 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 undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkTH2QFJHIcjs = require('./chunk-TH2QFJHI.cjs');
+
+
+
+
+
+
+
+var _chunkTDBBRZTCcjs = require('./chunk-TDBBRZTC.cjs');
+
+
+var _chunkBNPCRQK4cjs = require('./chunk-BNPCRQK4.cjs');
+
+
+
+
+
+
+
+
+var _chunkGJHRTQAScjs = require('./chunk-GJHRTQAS.cjs');
+
+
+var _chunkVPTKC3UKcjs = require('./chunk-VPTKC3UK.cjs');
+
+
+
+
+
+var _chunkB4CUDMY2cjs = require('./chunk-B4CUDMY2.cjs');
+
+// ../../node_modules/.pnpm/tsup@8.4.0_patch_hash=6f5ec3d4990820b9e30a2e3135e1e171cde70966824e3b0ca9c0d2f02fc93f24__c75bd232a33dcb63ad2eb667808a0247/node_modules/tsup/dist/chunk-BYH4XDRH.js
+var require_chunk_BYH4XDRH = _chunkB4CUDMY2cjs.__commonJS.call(void 0, {
+  "../../node_modules/.pnpm/tsup@8.4.0_patch_hash=6f5ec3d4990820b9e30a2e3135e1e171cde70966824e3b0ca9c0d2f02fc93f24__c75bd232a33dcb63ad2eb667808a0247/node_modules/tsup/dist/chunk-BYH4XDRH.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    var version = "8.4.0";
+    exports.version = version;
+  }
+});
+
+// ../../node_modules/.pnpm/tsup@8.4.0_patch_hash=6f5ec3d4990820b9e30a2e3135e1e171cde70966824e3b0ca9c0d2f02fc93f24__c75bd232a33dcb63ad2eb667808a0247/node_modules/tsup/dist/chunk-TWFEYLU4.js
+var require_chunk_TWFEYLU4 = _chunkB4CUDMY2cjs.__commonJS.call(void 0, {
+  "../../node_modules/.pnpm/tsup@8.4.0_patch_hash=6f5ec3d4990820b9e30a2e3135e1e171cde70966824e3b0ca9c0d2f02fc93f24__c75bd232a33dcb63ad2eb667808a0247/node_modules/tsup/dist/chunk-TWFEYLU4.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : {
+        default: obj
+      };
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, _interopRequireDefault, "_interopRequireDefault");
+    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;
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, _optionalChain, "_optionalChain");
+    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 __require2 = /* @__PURE__ */ ((x) => typeof _chunkB4CUDMY2cjs.__require !== "undefined" ? _chunkB4CUDMY2cjs.__require : typeof Proxy !== "undefined" ? new Proxy(x, {
+      get: /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, (a, b) => (typeof _chunkB4CUDMY2cjs.__require !== "undefined" ? _chunkB4CUDMY2cjs.__require : a)[b], "get")
+    }) : x)(function(x) {
+      if (typeof _chunkB4CUDMY2cjs.__require !== "undefined") return _chunkB4CUDMY2cjs.__require.apply(this, arguments);
+      throw Error('Dynamic require of "' + x + '" is not supported');
+    });
+    var __commonJS2 = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, (cb, mod) => /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, function __require22() {
+      return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = {
+        exports: {}
+      }).exports, mod), mod.exports;
+    }, "__require2"), "__commonJS");
+    var __copyProps = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, (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: /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, () => from[key], "get"),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+      }
+      return to;
+    }, "__copyProps");
+    var __toESM2 = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, (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
+    )), "__toESM");
+    var _fs = _chunkB4CUDMY2cjs.__require.call(void 0, "fs");
+    var _fs2 = _interopRequireDefault(_fs);
+    var _path = _chunkB4CUDMY2cjs.__require.call(void 0, "path");
+    var _path2 = _interopRequireDefault(_path);
+    var _resolvefrom = _chunkB4CUDMY2cjs.__require.call(void 0, "resolve-from");
+    var _resolvefrom2 = _interopRequireDefault(_resolvefrom);
+    var singleComment = Symbol("singleComment");
+    var multiComment = Symbol("multiComment");
+    var stripWithoutWhitespace = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, () => "", "stripWithoutWhitespace");
+    var stripWithWhitespace = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, (string, start, end) => string.slice(start, end).replace(/\S/g, " "), "stripWithWhitespace");
+    var isEscaped = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, (jsonString, quotePosition) => {
+      let index = quotePosition - 1;
+      let backslashCount = 0;
+      while (jsonString[index] === "\\") {
+        index -= 1;
+        backslashCount += 1;
+      }
+      return Boolean(backslashCount % 2);
+    }, "isEscaped");
+    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));
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, stripJsonComments, "stripJsonComments");
+    var _tinyglobby = _chunkB4CUDMY2cjs.__require.call(void 0, "tinyglobby");
+    function getPostcss() {
+      return localRequire("postcss");
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, getPostcss, "getPostcss");
+    function getApiExtractor() {
+      return localRequire("@microsoft/api-extractor");
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, getApiExtractor, "getApiExtractor");
+    function localRequire(moduleName) {
+      const p = _resolvefrom2.default.silent(process.cwd(), moduleName);
+      return p && __require2(p);
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, localRequire, "localRequire");
+    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));
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, removeFiles, "removeFiles");
+    function debouncePromise(fn, delay, onError) {
+      let timeout;
+      let promiseInFly;
+      let callbackPending;
+      return /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, function debounced(...args) {
+        if (promiseInFly) {
+          callbackPending = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, () => {
+            debounced(...args);
+            callbackPending = void 0;
+          }, "callbackPending");
+        } else {
+          if (timeout != null) clearTimeout(timeout);
+          timeout = setTimeout(() => {
+            timeout = void 0;
+            promiseInFly = fn(...args).catch(onError).finally(() => {
+              promiseInFly = void 0;
+              if (callbackPending) callbackPending();
+            });
+          }, delay);
+        }
+      }, "debounced");
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, debouncePromise, "debouncePromise");
+    function slash(path2) {
+      const isExtendedLengthPath = path2.startsWith("\\\\?\\");
+      if (isExtendedLengthPath) {
+        return path2;
+      }
+      return path2.replace(/\\/g, "/");
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, slash, "slash");
+    function truthy(value) {
+      return Boolean(value);
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, truthy, "truthy");
+    function jsoncParse(data) {
+      try {
+        return new Function(`return ${stripJsonComments(data).trim()}`)();
+      } catch (e2) {
+        return {};
+      }
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, jsoncParse, "jsoncParse");
+    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
+      };
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, defaultOutExtension, "defaultOutExtension");
+    function ensureTempDeclarationDir(options2) {
+      const cwd = _optionalChain2([options2, 'access', _40 => _40.workspaceConfig, 'optionalAccess', _41 => _41.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;
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, ensureTempDeclarationDir, "ensureTempDeclarationDir");
+    var toObjectEntry = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, (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
+        };
+      }, {});
+    }, "toObjectEntry");
+    var findLowestCommonAncestor = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, (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("/");
+    }, "findLowestCommonAncestor");
+    function toAbsolutePath(p, cwd) {
+      if (_path2.default.isAbsolute(p)) {
+        return p;
+      }
+      return slash(_path2.default.normalize(_path2.default.join(cwd || process.cwd(), p)));
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, toAbsolutePath, "toAbsolutePath");
+    function writeFileSync(filePath, content) {
+      _fs2.default.mkdirSync(_path2.default.dirname(filePath), {
+        recursive: true
+      });
+      _fs2.default.writeFileSync(filePath, content);
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, writeFileSync, "writeFileSync");
+    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 "";
+        }
+      });
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, replaceDtsWithJsExtensions, "replaceDtsWithJsExtensions");
+    var convertArrayEntriesToObjectEntries = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, (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;
+    }, "convertArrayEntriesToObjectEntries");
+    var resolveEntryPaths = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, async (entryPaths) => {
+      const resolvedEntryPaths = typeof entryPaths === "string" || Array.isArray(entryPaths) ? convertArrayEntriesToObjectEntries(await _tinyglobby.glob.call(void 0, entryPaths)) : entryPaths;
+      return resolvedEntryPaths;
+    }, "resolveEntryPaths");
+    var resolveExperimentalDtsConfig = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, 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;
+    }, "resolveExperimentalDtsConfig");
+    var resolveInitialExperimentalDtsConfig = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, 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)
+      };
+    }, "resolveInitialExperimentalDtsConfig");
+    exports.__require = __require2;
+    exports.__commonJS = __commonJS2;
+    exports.__toESM = __toESM2;
+    exports.getPostcss = getPostcss;
+    exports.getApiExtractor = getApiExtractor;
+    exports.localRequire = localRequire;
+    exports.removeFiles = removeFiles;
+    exports.debouncePromise = debouncePromise;
+    exports.slash = slash;
+    exports.truthy = truthy;
+    exports.jsoncParse = jsoncParse;
+    exports.defaultOutExtension = defaultOutExtension;
+    exports.ensureTempDeclarationDir = ensureTempDeclarationDir;
+    exports.toObjectEntry = toObjectEntry;
+    exports.toAbsolutePath = toAbsolutePath;
+    exports.writeFileSync = writeFileSync;
+    exports.replaceDtsWithJsExtensions = replaceDtsWithJsExtensions;
+    exports.resolveExperimentalDtsConfig = resolveExperimentalDtsConfig;
+    exports.resolveInitialExperimentalDtsConfig = resolveInitialExperimentalDtsConfig;
+  }
+});
+
+// ../../node_modules/.pnpm/tsup@8.4.0_patch_hash=6f5ec3d4990820b9e30a2e3135e1e171cde70966824e3b0ca9c0d2f02fc93f24__c75bd232a33dcb63ad2eb667808a0247/node_modules/tsup/dist/chunk-VGC3FXLU.js
+var require_chunk_VGC3FXLU = _chunkB4CUDMY2cjs.__commonJS.call(void 0, {
+  "../../node_modules/.pnpm/tsup@8.4.0_patch_hash=6f5ec3d4990820b9e30a2e3135e1e171cde70966824e3b0ca9c0d2f02fc93f24__c75bd232a33dcb63ad2eb667808a0247/node_modules/tsup/dist/chunk-VGC3FXLU.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : {
+        default: obj
+      };
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, _interopRequireDefault, "_interopRequireDefault");
+    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;
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, _optionalChain, "_optionalChain");
+    var _chunkTWFEYLU4js = require_chunk_TWFEYLU4();
+    var _fs = _chunkB4CUDMY2cjs.__require.call(void 0, "fs");
+    var _fs2 = _interopRequireDefault(_fs);
+    var _path = _chunkB4CUDMY2cjs.__require.call(void 0, "path");
+    var _path2 = _interopRequireDefault(_path);
+    var _joycon = _chunkB4CUDMY2cjs.__require.call(void 0, "joycon");
+    var _joycon2 = _interopRequireDefault(_joycon);
+    var _bundlerequire = _chunkB4CUDMY2cjs.__require.call(void 0, "bundle-require");
+    var joycon = new (0, _joycon2.default)();
+    var loadJson = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, 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(_optionalChain2([options2, 'access', _42 => _42.workspaceConfig, 'optionalAccess', _43 => _43.workspaceRoot]) || process.cwd(), filepath)}: ${error.message}`);
+        } else {
+          throw error;
+        }
+      }
+    }, "loadJson");
+    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 {};
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, loadTsupConfig, "loadTsupConfig");
+    async function loadPkg(cwd, clearCache = false) {
+      if (clearCache) {
+        joycon.clearCache();
+      }
+      const { data } = await joycon.load([
+        "package.json"
+      ], cwd, _path2.default.dirname(cwd));
+      return data || {};
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, loadPkg, "loadPkg");
+    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;
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, getProductionDeps, "getProductionDeps");
+    async function getAllDepsHash(cwd) {
+      const data = await loadPkg(cwd, true);
+      return JSON.stringify({
+        ...data.dependencies,
+        ...data.peerDependencies,
+        ...data.devDependencies
+      });
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, getAllDepsHash, "getAllDepsHash");
+    var _util = _chunkB4CUDMY2cjs.__require.call(void 0, "util");
+    var _util2 = _interopRequireDefault(_util);
+    var _worker_threads = _chunkB4CUDMY2cjs.__require.call(void 0, "worker_threads");
+    var _picocolors = _chunkB4CUDMY2cjs.__require.call(void 0, "picocolors");
+    var _picocolors2 = _interopRequireDefault(_picocolors);
+    var colorize = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, (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);
+    }, "colorize");
+    var makeLabel = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, (name, input, type) => {
+      return [
+        name && `${_picocolors2.default.dim("[")}${name.toUpperCase()}${_picocolors2.default.dim("]")}`,
+        colorize(type, input.toUpperCase())
+      ].filter(Boolean).join(" ");
+    }, "makeLabel");
+    var silent = false;
+    function setSilent(isSilent) {
+      silent = !!isSilent;
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, setSilent, "setSilent");
+    function getSilent() {
+      return silent;
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, getSilent, "getSilent");
+    var createLogger = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, (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);
+          }
+        }
+      };
+    }, "createLogger");
+    var prettyBytes = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, (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]}`;
+    }, "prettyBytes");
+    var getLengthOfLongestString = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, (strings) => {
+      return strings.reduce((max, str) => {
+        return Math.max(max, str.length);
+      }, 0);
+    }, "getLengthOfLongestString");
+    var padRight = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, (str, maxLength) => {
+      return str + " ".repeat(maxLength - str.length);
+    }, "padRight");
+    var reportSize = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, (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]))}`);
+      }
+    }, "reportSize");
+    exports.loadTsupConfig = loadTsupConfig;
+    exports.loadPkg = loadPkg;
+    exports.getProductionDeps = getProductionDeps;
+    exports.getAllDepsHash = getAllDepsHash;
+    exports.setSilent = setSilent;
+    exports.getSilent = getSilent;
+    exports.createLogger = createLogger;
+    exports.reportSize = reportSize;
+  }
+});
+
+// ../../node_modules/.pnpm/tsup@8.4.0_patch_hash=6f5ec3d4990820b9e30a2e3135e1e171cde70966824e3b0ca9c0d2f02fc93f24__c75bd232a33dcb63ad2eb667808a0247/node_modules/tsup/dist/chunk-JZ25TPTY.js
+var require_chunk_JZ25TPTY = _chunkB4CUDMY2cjs.__commonJS.call(void 0, {
+  "../../node_modules/.pnpm/tsup@8.4.0_patch_hash=6f5ec3d4990820b9e30a2e3135e1e171cde70966824e3b0ca9c0d2f02fc93f24__c75bd232a33dcb63ad2eb667808a0247/node_modules/tsup/dist/chunk-JZ25TPTY.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : {
+        default: obj
+      };
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, _interopRequireDefault, "_interopRequireDefault");
+    var _worker_threads = _chunkB4CUDMY2cjs.__require.call(void 0, "worker_threads");
+    var _picocolors = _chunkB4CUDMY2cjs.__require.call(void 0, "picocolors");
+    var _picocolors2 = _interopRequireDefault(_picocolors);
+    var PrettyError = class extends Error {
+      static {
+        _chunkB4CUDMY2cjs.__name.call(void 0, this, "PrettyError");
+      }
+      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");
+      }
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, handleError, "handleError");
+    exports.PrettyError = PrettyError;
+    exports.handleError = handleError;
+  }
+});
+
+// ../../node_modules/.pnpm/tsup@8.4.0_patch_hash=6f5ec3d4990820b9e30a2e3135e1e171cde70966824e3b0ca9c0d2f02fc93f24__c75bd232a33dcb63ad2eb667808a0247/node_modules/tsup/dist/index.js
+var require_dist = _chunkB4CUDMY2cjs.__commonJS.call(void 0, {
+  "../../node_modules/.pnpm/tsup@8.4.0_patch_hash=6f5ec3d4990820b9e30a2e3135e1e171cde70966824e3b0ca9c0d2f02fc93f24__c75bd232a33dcb63ad2eb667808a0247/node_modules/tsup/dist/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__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;
+      }
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, _interopRequireWildcard, "_interopRequireWildcard");
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : {
+        default: obj
+      };
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, _interopRequireDefault, "_interopRequireDefault");
+    function _nullishCoalesce(lhs, rhsFn) {
+      if (lhs != null) {
+        return lhs;
+      } else {
+        return rhsFn();
+      }
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, _nullishCoalesce, "_nullishCoalesce");
+    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;
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, _optionalChain, "_optionalChain");
+    var _class;
+    var _chunkBYH4XDRHjs = require_chunk_BYH4XDRH();
+    var _chunkVGC3FXLUjs = require_chunk_VGC3FXLU();
+    var _chunkJZ25TPTYjs = require_chunk_JZ25TPTY();
+    var _chunkTWFEYLU4js = require_chunk_TWFEYLU4();
+    var _path = _chunkB4CUDMY2cjs.__require.call(void 0, "path");
+    var _path2 = _interopRequireDefault(_path);
+    var _fs = _chunkB4CUDMY2cjs.__require.call(void 0, "fs");
+    var _fs2 = _interopRequireDefault(_fs);
+    var _worker_threads = _chunkB4CUDMY2cjs.__require.call(void 0, "worker_threads");
+    var _bundlerequire = _chunkB4CUDMY2cjs.__require.call(void 0, "bundle-require");
+    var _tinyexec = _chunkB4CUDMY2cjs.__require.call(void 0, "tinyexec");
+    var _tinyglobby = _chunkB4CUDMY2cjs.__require.call(void 0, "tinyglobby");
+    var _treekill = _chunkB4CUDMY2cjs.__require.call(void 0, "tree-kill");
+    var _treekill2 = _interopRequireDefault(_treekill);
+    var _esbuild = _chunkB4CUDMY2cjs.__require.call(void 0, "esbuild");
+    var _consola = _chunkB4CUDMY2cjs.__require.call(void 0, "consola");
+    var _consola2 = _interopRequireDefault(_consola);
+    var nodeProtocolPlugin = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, () => {
+      const nodeProtocol = "node:";
+      return {
+        name: "node-protocol-plugin",
+        setup({ onResolve }) {
+          onResolve({
+            filter: /^node:/
+          }, ({ path: path12 }) => ({
+            path: path12.slice(nodeProtocol.length),
+            external: true
+          }));
+        }
+      };
+    }, "nodeProtocolPlugin");
+    var NON_NODE_MODULE_RE = /^[A-Z]:[/\\]|^\.{0,2}\/|^\.{1,2}$/;
+    var externalPlugin = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, ({ 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
+                };
+              }
+            });
+          }
+        }
+      };
+    }, "externalPlugin");
+    var postcssPlugin = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, ({ options: options1, css, inject, cssLoader }) => {
+      return {
+        name: "postcss",
+        setup(build22) {
+          let configCache;
+          const getPostcssConfig = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, async () => {
+            const loadConfig = _chunkTWFEYLU4js.__require.call(void 0, "postcss-load-config");
+            if (configCache) {
+              return configCache;
+            }
+            try {
+              const result = await loadConfig({}, _optionalChain2([options1, 'access', _44 => _44.workspaceConfig, 'optionalAccess', _45 => _45.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;
+            }
+          }, "getPostcssConfig");
+          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: options12 } = 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, {
+                  ...options12,
+                  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")
+            };
+          });
+        }
+      };
+    }, "postcssPlugin");
+    var useSvelteCssExtension = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, (p) => p.replace(/\.svelte$/, ".svelte.css"), "useSvelteCssExtension");
+    var sveltePlugin = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, ({ css, options: options1 }) => {
+      return {
+        name: "svelte",
+        setup(build22) {
+          let svelte;
+          let sveltePreprocessor;
+          build22.onResolve({
+            filter: /\.svelte\.css$/
+          }, (args) => {
+            return {
+              path: _path2.default.relative(_optionalChain2([options1, 'access', _46 => _46.workspaceConfig, 'optionalAccess', _47 => _47.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 = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, ({ 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
+              };
+            }, "convertMessage");
+            const source = await _fs2.default.promises.readFile(args.path, "utf8");
+            const filename = _path2.default.relative(_optionalChain2([options1, 'access', _48 => _48.workspaceConfig, 'optionalAccess', _49 => _49.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)
+                ]
+              };
+            }
+          });
+        }
+      };
+    }, "sveltePlugin");
+    var swcPlugin = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, ({ logger: logger3 }) => {
+      return {
+        name: "swc",
+        setup(build22) {
+          const swc = _chunkTWFEYLU4js.localRequire.call(void 0, "@swc/core");
+          if (!swc) {
+            logger3.warn(build22.initialOptions.format, `You have emitDecoratorMetadata enabled but @swc/core was not installed, skipping swc plugin`);
+            return;
+          }
+          build22.initialOptions.keepNames = true;
+          build22.onLoad({
+            filter: /\.[jt]sx?$/
+          }, async (args) => {
+            const isTs = /\.tsx?$/.test(args.path);
+            const jsc = {
+              parser: {
+                syntax: isTs ? "typescript" : "ecmascript",
+                decorators: true
+              },
+              transform: {
+                legacyDecorator: true,
+                decoratorMetadata: true
+              },
+              keepClassNames: true,
+              target: "es2022"
+            };
+            const result = await swc.transformFile(args.path, {
+              jsc,
+              sourceMaps: true,
+              configFile: false,
+              swcrc: false
+            });
+            let code = result.code;
+            if (result.map) {
+              const map = JSON.parse(result.map);
+              map.sources = map.sources.map((source) => {
+                return _path2.default.isAbsolute(source) ? _path2.default.relative(_path2.default.dirname(args.path), source) : source;
+              });
+              code += `//# sourceMappingURL=data:application/json;base64,${Buffer.from(JSON.stringify(map)).toString("base64")}`;
+            }
+            return {
+              contents: code
+            };
+          });
+        }
+      };
+    }, "swcPlugin");
+    var nativeNodeModulesPlugin = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, () => {
+      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";
+        }
+      };
+    }, "nativeNodeModulesPlugin");
+    var getOutputExtensionMap = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, (options1, format, pkgType) => {
+      const outExtension = options1.outExtension || _chunkTWFEYLU4js.defaultOutExtension;
+      const defaultExtension = _chunkTWFEYLU4js.defaultOutExtension.call(void 0, {
+        format,
+        pkgType
+      });
+      const extension = outExtension({
+        options: options1,
+        format,
+        pkgType
+      });
+      return {
+        ".js": extension.js || defaultExtension.js
+      };
+    }, "getOutputExtensionMap");
+    var generateExternal = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, 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(_optionalChain2([options, 'access', _50 => _50.workspaceConfig, 'optionalAccess', _51 => _51.workspaceRoot]) || process.cwd(), item));
+        const deps = await _chunkVGC3FXLUjs.getProductionDeps.call(void 0, pkgPath);
+        result.push(...deps);
+      }
+      return result;
+    }, "generateExternal");
+    async function runEsbuild(options1, { format, css, logger: logger3, buildDependencies, pluginContainer }) {
+      const pkg = await _chunkVGC3FXLUjs.loadPkg.call(void 0, _optionalChain2([options1, 'access', _52 => _52.workspaceConfig, 'optionalAccess', _53 => _53.workspaceRoot]) || process.cwd());
+      const deps = await _chunkVGC3FXLUjs.getProductionDeps.call(void 0, _optionalChain2([options1, 'access', _54 => _54.workspaceConfig, 'optionalAccess', _55 => _55.workspaceRoot]) || process.cwd());
+      const external = [
+        // Exclude dependencies, e.g. `lodash`, `lodash/get`
+        ...deps.map((dep) => new RegExp(`^${dep}($|\\/|\\\\)`)),
+        ...await generateExternal(options1.external || [])
+      ];
+      const outDir = options1.outDir;
+      const outExtension = getOutputExtensionMap(options1, format, pkg.type);
+      const env = {
+        ...options1.env
+      };
+      if (options1.replaceNodeEnv) {
+        env.NODE_ENV = options1.minify || options1.minifyWhitespace ? "production" : "development";
+      }
+      logger3.info(format, "Build start");
+      const startTime = Date.now();
+      let result;
+      const splitting = format === "iife" ? false : typeof options1.splitting === "boolean" ? options1.splitting : format === "esm";
+      const platform = options1.platform || "node";
+      const loader = options1.loader || {};
+      const injectShims = options1.shims;
+      pluginContainer.setContext({
+        format,
+        splitting,
+        options: options1,
+        logger: logger3
+      });
+      await pluginContainer.buildStarted();
+      const esbuildPlugins = [
+        format === "cjs" && options1.removeNodeProtocol && nodeProtocolPlugin(),
+        {
+          name: "modify-options",
+          setup(build22) {
+            pluginContainer.modifyEsbuildOptions(build22.initialOptions);
+            if (options1.esbuildOptions) {
+              options1.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: options1.noExternal,
+          skipNodeModulesBundle: options1.skipNodeModulesBundle,
+          tsconfigResolvePaths: options1.tsconfigResolvePaths
+        }),
+        options1.tsconfigDecoratorMetadata && swcPlugin({
+          logger: logger3
+        }),
+        nativeNodeModulesPlugin(),
+        postcssPlugin({
+          options: options1,
+          css,
+          inject: options1.injectStyle,
+          cssLoader: loader[".css"]
+        }),
+        sveltePlugin({
+          css,
+          options: options1
+        }),
+        ...options1.esbuildPlugins || []
+      ];
+      const banner = typeof options1.banner === "function" ? options1.banner({
+        format
+      }) : options1.banner;
+      const footer = typeof options1.footer === "function" ? options1.footer({
+        format
+      }) : options1.footer;
+      try {
+        result = await _esbuild.build.call(void 0, {
+          entryPoints: options1.entry,
+          format: format === "cjs" && splitting || options1.treeshake ? "esm" : format,
+          bundle: typeof options1.bundle === "undefined" ? true : options1.bundle,
+          platform,
+          globalName: options1.globalName,
+          jsxFactory: options1.jsxFactory,
+          jsxFragment: options1.jsxFragment,
+          sourcemap: options1.sourcemap ? "external" : false,
+          target: options1.target,
+          banner,
+          footer,
+          tsconfig: options1.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"
+            } : {},
+            ...options1.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") : "",
+            ...options1.inject || []
+          ].filter(Boolean),
+          outdir: options1.legacyOutput && format !== "cjs" ? _path2.default.join(outDir, format) : outDir,
+          outExtension: options1.legacyOutput ? void 0 : outExtension,
+          write: false,
+          splitting,
+          logLevel: "error",
+          minify: options1.minify === "terser" ? false : options1.minify,
+          minifyWhitespace: options1.minifyWhitespace,
+          minifyIdentifiers: options1.minifyIdentifiers,
+          minifySyntax: options1.minifySyntax,
+          keepNames: options1.keepNames,
+          pure: typeof options1.pure === "string" ? [
+            options1.pure
+          ] : options1.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: options1,
+          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 (options1.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");
+        }
+      }
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, runEsbuild, "runEsbuild");
+    var shebang = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, () => {
+      return {
+        name: "shebang",
+        renderChunk(_, info) {
+          if (info.type === "chunk" && /\.(cjs|js|mjs)$/.test(info.path) && info.code.startsWith("#!")) {
+            info.mode = 493;
+          }
+        }
+      };
+    }, "shebang");
+    var cjsSplitting = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, () => {
+      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(_chunkB4CUDMY2cjs.__require.call(void 0, "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
+          };
+        }
+      };
+    }, "cjsSplitting");
+    var _sourcemap = _chunkB4CUDMY2cjs.__require.call(void 0, "source-map");
+    var outputFile = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, async (filepath, data, options1) => {
+      await _fs2.default.promises.mkdir(_path2.default.dirname(filepath), {
+        recursive: true
+      });
+      await _fs2.default.promises.writeFile(filepath, data, options1);
+    }, "outputFile");
+    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);
+        }
+      }
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, copyDirSync, "copyDirSync");
+    var parseSourceMap = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, (map) => {
+      return typeof map === "string" ? JSON.parse(map) : map;
+    }, "parseSourceMap");
+    var isJS = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, (path12) => /\.(js|mjs|cjs)$/.test(path12), "isJS");
+    var isCSS = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, (path12) => /\.css$/.test(path12), "isCSS");
+    var PluginContainer = class {
+      static {
+        _chunkB4CUDMY2cjs.__name.call(void 0, this, "PluginContainer");
+      }
+      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(options1) {
+        for (const plugin of this.plugins) {
+          if (plugin.esbuildOptions) {
+            plugin.esbuildOptions.call(this.getContext(), options1);
+          }
+        }
+      }
+      async buildStarted() {
+        for (const plugin of this.plugins) {
+          if (plugin.buildStart) {
+            await plugin.buildStart.call(this.getContext());
+          }
+        }
+      }
+      async buildFinished({ options: options1, 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(_optionalChain2([options1, 'access', _56 => _56.workspaceConfig, 'optionalAccess', _57 => _57.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) {
+                  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();
+                }
+              }
+            }
+          }
+          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(_optionalChain2([options1, 'access', _58 => _58.workspaceConfig, 'optionalAccess', _59 => _59.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(_optionalChain2([options1, 'access', _60 => _60.workspaceConfig, 'optionalAccess', _61 => _61.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 = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, (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}`;
+    }, "getSourcemapComment");
+    var TARGETS = [
+      "es5",
+      "es3"
+    ];
+    var swcTarget = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, () => {
+      let enabled = false;
+      let target;
+      return {
+        name: "swc-target",
+        esbuildOptions(options1) {
+          if (typeof options1.target === "string" && TARGETS.includes(options1.target)) {
+            target = options1.target;
+            options1.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
+          };
+        }
+      };
+    }, "swcTarget");
+    var sizeReporter = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, () => {
+      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
+            };
+          }, {}));
+        }
+      };
+    }, "sizeReporter");
+    var _rollup = _chunkB4CUDMY2cjs.__require.call(void 0, "rollup");
+    var treeShakingPlugin = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, ({ 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
+              };
+            }
+          }
+        }
+      };
+    }, "treeShakingPlugin");
+    var copyPublicDir = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, (publicDir, outDir) => {
+      if (!publicDir) return;
+      copyDirSync(_path2.default.resolve(publicDir === true ? "public" : publicDir), outDir);
+    }, "copyPublicDir");
+    var isInPublicDir = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, (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}/`);
+    }, "isInPublicDir");
+    var terserPlugin = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, ({ 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
+          };
+        }
+      };
+    }, "terserPlugin");
+    var _typescript = _chunkB4CUDMY2cjs.__require.call(void 0, "typescript");
+    var _typescript2 = _interopRequireDefault(_typescript);
+    var logger = _chunkVGC3FXLUjs.createLogger.call(void 0);
+    var AliasPool = (_class = class {
+      static {
+        _chunkB4CUDMY2cjs.__name.call(void 0, this, "_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 exports1 = [];
+        const exportSymbols = checker.getExportsOfModule(moduleSymbol);
+        exportSymbols.forEach((symbol) => {
+          const name = symbol.getName();
+          exports1.push({
+            kind: "named",
+            sourceFileName,
+            destFileName,
+            name,
+            alias: assignAlias(name),
+            isTypeOnly: false
+          });
+        });
+        return exports1;
+      }
+      _chunkB4CUDMY2cjs.__name.call(void 0, extractExports, "extractExports");
+      return program.getRootFileNames().flatMap(extractExports);
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, getExports, "getExports");
+    function emitDtsFiles(program, host) {
+      const fileMapping = /* @__PURE__ */ new Map();
+      const writeFile = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, (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);
+      }, "writeFile");
+      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;
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, emitDtsFiles, "emitDtsFiles");
+    function emit(compilerOptions, tsconfig, _options) {
+      const cwd = _optionalChain2([_options, 'access', _62 => _62.workspaceConfig, 'optionalAccess', _63 => _63.workspaceRoot]) || process.cwd();
+      let rawTsconfig = _bundlerequire.loadTsConfig.call(void 0, cwd, tsconfig);
+      if (!rawTsconfig) {
+        rawTsconfig = _bundlerequire.loadTsConfig.call(void 0, process.cwd(), tsconfig);
+        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 options1 = parsedTsconfig.options;
+      const host = _typescript2.default.createCompilerHost(options1);
+      const program = _typescript2.default.createProgram(parsedTsconfig.fileNames, options1, host);
+      const fileMapping = emitDtsFiles(program, host);
+      return getExports(program, fileMapping);
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, emit, "emit");
+    function runTypeScriptCompiler(options1) {
+      try {
+        const start = Date.now();
+        const getDuration = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, () => {
+          return `${Math.floor(Date.now() - start)}ms`;
+        }, "getDuration");
+        logger.info("tsc", "Build start");
+        const dtsOptions = options1.experimentalDts;
+        const exports1 = emit(dtsOptions.compilerOptions, options1.tsconfig, options1);
+        logger.success("tsc", `\u26A1\uFE0F Build success in ${getDuration()}`);
+        return exports1;
+      } catch (error) {
+        _chunkJZ25TPTYjs.handleError.call(void 0, error);
+        logger.error("tsc", "Build error");
+      }
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, runTypeScriptCompiler, "runTypeScriptCompiler");
+    function formatAggregationExports(exports1, declarationDirPath) {
+      const lines = exports1.map((declaration) => formatAggregationExport(declaration, declarationDirPath)).filter(_chunkTWFEYLU4js.truthy);
+      if (lines.length === 0) {
+        lines.push("export {};");
+      }
+      return `${lines.join("\n")}
+`;
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, formatAggregationExports, "formatAggregationExports");
+    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");
+      }
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, formatAggregationExport, "formatAggregationExport");
+    function formatDistributionExports(exports1, 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 = exports1.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")}
+`;
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, formatDistributionExports, "formatDistributionExports");
+    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 "";
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, formatDistributionExport, "formatDistributionExport");
+    var logger2 = _chunkVGC3FXLUjs.createLogger.call(void 0);
+    function rollupDtsFile(inputFilePath, outputFilePath, tsconfigFilePath, options1) {
+      const cwd = _optionalChain2([options1, 'access', _64 => _64.workspaceConfig, 'optionalAccess', _65 => _65.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}`);
+      }
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, rollupDtsFile, "rollupDtsFile");
+    async function rollupDtsFiles(options1, exports1, format) {
+      if (!options1.experimentalDts || !_optionalChain([
+        options1,
+        "access",
+        (_18) => _18.experimentalDts,
+        "optionalAccess",
+        (_19) => _19.entry
+      ])) {
+        return;
+      }
+      const declarationDir = _chunkTWFEYLU4js.ensureTempDeclarationDir.call(void 0, options1);
+      const outDir = options1.outDir || "dist";
+      const pkg = await _chunkVGC3FXLUjs.loadPkg.call(void 0, _optionalChain2([options1, 'access', _66 => _66.workspaceConfig, 'optionalAccess', _67 => _67.workspaceRoot]) || process.cwd());
+      const dtsExtension = _chunkTWFEYLU4js.defaultOutExtension.call(void 0, {
+        format,
+        pkgType: pkg.type
+      }).dts;
+      const tsconfig = options1.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(exports1, declarationDir, options1));
+      rollupDtsFile(dtsInputFilePath, dtsOutputFilePath, tsconfig, options1);
+      for (let [out, sourceFileName] of Object.entries(options1.experimentalDts.entry)) {
+        sourceFileName = _chunkTWFEYLU4js.toAbsolutePath.call(void 0, sourceFileName);
+        const outFileName = _path2.default.join(outDir, out + dtsExtension);
+        const currentExports = exports1.filter((declaration) => declaration.sourceFileName === sourceFileName);
+        _chunkTWFEYLU4js.writeFileSync.call(void 0, outFileName, formatDistributionExports(currentExports, outFileName, dtsOutputFilePath));
+      }
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, rollupDtsFiles, "rollupDtsFiles");
+    async function cleanDtsFiles(options1) {
+      if (options1.clean) {
+        await _chunkTWFEYLU4js.removeFiles.call(void 0, [
+          "**/*.d.{ts,mts,cts}"
+        ], options1.outDir);
+      }
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, cleanDtsFiles, "cleanDtsFiles");
+    async function runDtsRollup(options1, exports1) {
+      try {
+        const start = Date.now();
+        const getDuration = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, () => {
+          return `${Math.floor(Date.now() - start)}ms`;
+        }, "getDuration");
+        logger2.info("dts", "Build start");
+        if (!exports1) {
+          throw new Error("Unexpected internal error: dts exports is not define");
+        }
+        await cleanDtsFiles(options1);
+        for (const format of options1.format) {
+          await rollupDtsFiles(options1, exports1, format);
+        }
+        logger2.success("dts", `\u26A1\uFE0F Build success in ${getDuration()}`);
+      } catch (error) {
+        _chunkJZ25TPTYjs.handleError.call(void 0, error);
+        logger2.error("dts", "Build error");
+      }
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, runDtsRollup, "runDtsRollup");
+    var cjsInterop = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, () => {
+      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
+          };
+        }
+      };
+    }, "cjsInterop");
+    var defineConfig = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, (options1) => options1, "defineConfig");
+    var isTaskkillCmdProcessNotFoundError = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, (err) => {
+      return process.platform === "win32" && "cmd" in err && "code" in err && typeof err.cmd === "string" && err.cmd.startsWith("taskkill") && err.code === 128;
+    }, "isTaskkillCmdProcessNotFoundError");
+    var killProcess = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, ({ pid, signal }) => new Promise((resolve, reject) => {
+      _treekill2.default.call(void 0, pid, signal, (err) => {
+        if (err && !isTaskkillCmdProcessNotFoundError(err)) return reject(err);
+        resolve();
+      });
+    }), "killProcess");
+    var normalizeOptions = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, async (logger3, optionsFromConfigFile, optionsOverride) => {
+      const _options = {
+        ...optionsFromConfigFile,
+        ...optionsOverride
+      };
+      const options1 = {
+        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 (!options1.workspaceConfig) options1.workspaceConfig = {};
+      if (!options1.workspaceConfig.workspaceRoot) options1.workspaceConfig.workspaceRoot = process.cwd();
+      _chunkVGC3FXLUjs.setSilent.call(void 0, options1.silent);
+      const entry = options1.entry || options1.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)) {
+        options1.entry = await _tinyglobby.glob.call(void 0, entry);
+        if (!options1.entry || options1.entry.length === 0) {
+          throw new (0, _chunkJZ25TPTYjs.PrettyError)(`Cannot find ${entry}`);
+        } else {
+          logger3.info("CLI", `Building entry: ${options1.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}`);
+          }
+        });
+        options1.entry = entry;
+        logger3.info("CLI", `Building entry: ${JSON.stringify(entry)}`);
+      }
+      const tsconfig = _bundlerequire.loadTsConfig.call(void 0, _optionalChain2([options1, 'access', _68 => _68.workspaceConfig, 'optionalAccess', _69 => _69.workspaceRoot]) || process.cwd(), options1.tsconfig);
+      if (tsconfig) {
+        logger3.info("CLI", `Using tsconfig: ${_path2.default.relative(_optionalChain2([options1, 'access', _70 => _70.workspaceConfig, 'optionalAccess', _71 => _71.workspaceRoot]) || process.cwd(), tsconfig.path)}`);
+        options1.tsconfig = tsconfig.path;
+        options1.tsconfigResolvePaths = _optionalChain([
+          tsconfig,
+          "access",
+          (_22) => _22.data,
+          "optionalAccess",
+          (_23) => _23.compilerOptions,
+          "optionalAccess",
+          (_24) => _24.paths
+        ]) || {};
+        options1.tsconfigDecoratorMetadata = _optionalChain([
+          tsconfig,
+          "access",
+          (_25) => _25.data,
+          "optionalAccess",
+          (_26) => _26.compilerOptions,
+          "optionalAccess",
+          (_27) => _27.emitDecoratorMetadata
+        ]);
+        if (options1.dts) {
+          options1.dts.compilerOptions = {
+            ...tsconfig.data.compilerOptions || {},
+            ...options1.dts.compilerOptions || {}
+          };
+        }
+        if (options1.experimentalDts) {
+          options1.experimentalDts = await _chunkTWFEYLU4js.resolveExperimentalDtsConfig.call(void 0, options1, tsconfig);
+        }
+        if (!options1.target) {
+          options1.target = _optionalChain([
+            tsconfig,
+            "access",
+            (_28) => _28.data,
+            "optionalAccess",
+            (_29) => _29.compilerOptions,
+            "optionalAccess",
+            (_30) => _30.target,
+            "optionalAccess",
+            (_31) => _31.toLowerCase,
+            "call",
+            (_32) => _32()
+          ]);
+        }
+      } else if (options1.tsconfig) {
+        throw new (0, _chunkJZ25TPTYjs.PrettyError)(`Cannot find tsconfig: ${options1.tsconfig}`);
+      }
+      if (!options1.target) {
+        options1.target = "node16";
+      }
+      return options1;
+    }, "normalizeOptions");
+    async function build3(_options) {
+      const config = _options.config === false ? {} : await _chunkVGC3FXLUjs.loadTsupConfig.call(void 0, _optionalChain2([_options, 'access', _72 => _72.workspaceConfig, 'optionalAccess', _73 => _73.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 options1 = await normalizeOptions(logger3, item, _options);
+        logger3.info("CLI", `tsup v${_chunkBYH4XDRHjs.version}`);
+        if (config.path) {
+          logger3.info("CLI", `Using tsup config: ${config.path}`);
+        }
+        if (options1.watch) {
+          logger3.info("CLI", "Running in watch mode");
+        }
+        const experimentalDtsTask = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, async () => {
+          if (!options1.dts && options1.experimentalDts) {
+            const exports1 = runTypeScriptCompiler(options1);
+            await runDtsRollup(options1, exports1);
+          }
+        }, "experimentalDtsTask");
+        const dtsTask = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, async () => {
+          if (options1.dts && options1.experimentalDts) {
+            throw new Error("You can't use both `dts` and `experimentalDts` at the same time");
+          }
+          await experimentalDtsTask();
+          if (options1.dts) {
+            await new Promise((resolve, reject) => {
+              const worker = new (0, _worker_threads.Worker)(_path2.default.join(__dirname, "./rollup.js"));
+              const terminateWorker = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, () => {
+                if (options1.watch) return;
+                worker.terminate();
+              }, "terminateWorker");
+              worker.postMessage({
+                configName: _optionalChain([
+                  item,
+                  "optionalAccess",
+                  (_34) => _34.name
+                ]),
+                options: {
+                  ...options1,
+                  // functions cannot be cloned
+                  injectStyle: typeof options1.injectStyle === "function" ? void 0 : options1.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);
+                  }
+                }
+              });
+            });
+          }
+        }, "dtsTask");
+        const mainTasks = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, async () => {
+          if (!_optionalChain([
+            options1,
+            "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, _optionalChain2([options1, 'access', _74 => _74.workspaceConfig, 'optionalAccess', _75 => _75.workspaceRoot]) || process.cwd());
+            const doOnSuccessCleanup = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, async () => {
+              if (onSuccessProcess) {
+                await killProcess({
+                  pid: onSuccessProcess.pid,
+                  signal: options1.killSignal || "SIGTERM"
+                });
+              } else if (onSuccessCleanup) {
+                await onSuccessCleanup();
+              }
+              onSuccessProcess = void 0;
+              onSuccessCleanup = void 0;
+            }, "doOnSuccessCleanup");
+            const debouncedBuildAll = _chunkTWFEYLU4js.debouncePromise.call(void 0, () => {
+              return buildAll();
+            }, 100, _chunkJZ25TPTYjs.handleError);
+            const buildAll = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, async () => {
+              await doOnSuccessCleanup();
+              const previousBuildDependencies = new Set(buildDependencies);
+              buildDependencies.clear();
+              if (options1.clean) {
+                const extraPatterns = Array.isArray(options1.clean) ? options1.clean : [];
+                if (options1.dts || options1.experimentalDts) {
+                  extraPatterns.unshift("!**/*.d.{ts,cts,mts}");
+                }
+                await _chunkTWFEYLU4js.removeFiles.call(void 0, [
+                  "**/*",
+                  ...extraPatterns
+                ], options1.outDir);
+                logger3.info("CLI", "Cleaning output folder");
+              }
+              const css = /* @__PURE__ */ new Map();
+              await Promise.all([
+                ...options1.format.map(async (format, index) => {
+                  const pluginContainer = new PluginContainer([
+                    shebang(),
+                    ...options1.plugins || [],
+                    treeShakingPlugin({
+                      treeshake: options1.treeshake,
+                      name: options1.globalName,
+                      silent: options1.silent
+                    }),
+                    cjsSplitting(),
+                    cjsInterop(),
+                    swcTarget(),
+                    sizeReporter(),
+                    terserPlugin({
+                      minifyOptions: options1.minify,
+                      format,
+                      terserOptions: options1.terserOptions,
+                      globalName: options1.globalName,
+                      logger: logger3
+                    })
+                  ]);
+                  await runEsbuild(options1, {
+                    pluginContainer,
+                    format,
+                    css: index === 0 || options1.injectStyle ? css : void 0,
+                    logger: logger3,
+                    buildDependencies
+                  }).catch((error) => {
+                    previousBuildDependencies.forEach((v) => buildDependencies.add(v));
+                    throw error;
+                  });
+                })
+              ]);
+              if (options1.onSuccess) {
+                if (typeof options1.onSuccess === "function") {
+                  onSuccessCleanup = await options1.onSuccess();
+                } else {
+                  onSuccessProcess = _tinyexec.exec.call(void 0, options1.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;
+                      }
+                    })
+                  ]);
+                }
+              }
+            }, "buildAll");
+            const startWatcher = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, async () => {
+              if (!options1.watch) return;
+              const { watch: watch2 } = await Promise.resolve().then(() => _interopRequireWildcard(_chunkB4CUDMY2cjs.__require.call(void 0, "chokidar")));
+              const customIgnores = options1.ignoreWatch ? Array.isArray(options1.ignoreWatch) ? options1.ignoreWatch : [
+                options1.ignoreWatch
+              ] : [];
+              const ignored = [
+                "**/{.git,node_modules}/**",
+                options1.outDir,
+                ...customIgnores
+              ];
+              const watchPaths = typeof options1.watch === "boolean" ? "." : Array.isArray(options1.watch) ? options1.watch.filter((path12) => typeof path12 === "string") : options1.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 = watch2(await _tinyglobby.glob.call(void 0, watchPaths), {
+                ignoreInitial: true,
+                ignorePermissionErrors: true,
+                ignored: /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, (p) => _tinyglobby.globSync.call(void 0, p, {
+                  ignore: ignored
+                }).length === 0, "ignored")
+              });
+              watcher.on("all", async (type, file) => {
+                file = _chunkTWFEYLU4js.slash.call(void 0, file);
+                if (options1.publicDir && isInPublicDir(options1.publicDir, file)) {
+                  logger3.info("CLI", `Change in public dir: ${file}`);
+                  copyPublicDir(options1.publicDir, options1.outDir);
+                  return;
+                }
+                let shouldSkipChange = false;
+                if (options1.watch === true) {
+                  if (file === "package.json" && !buildDependencies.has(file)) {
+                    const currentHash = await _chunkVGC3FXLUjs.getAllDepsHash.call(void 0, _optionalChain2([options1, 'access', _76 => _76.workspaceConfig, 'optionalAccess', _77 => _77.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();
+              });
+            }, "startWatcher");
+            logger3.info("CLI", `Target: ${options1.target}`);
+            await buildAll();
+            copyPublicDir(options1.publicDir, options1.outDir);
+            startWatcher();
+          }
+        }, "mainTasks");
+        await Promise.all([
+          dtsTask(),
+          mainTasks()
+        ]);
+      }));
+    }
+    _chunkB4CUDMY2cjs.__name.call(void 0, build3, "build");
+    exports.build = build3;
+    exports.defineConfig = defineConfig;
+  }
+});
+
+// src/build.ts
+var _devkit = require('@nx/devkit');
+var import_tsup = _chunkB4CUDMY2cjs.__toESM.call(void 0, require_dist(), 1);
+var _chokidar = require('chokidar');
+var _defu = require('defu'); var _defu2 = _interopRequireDefault2(_defu);
+var _estoolkit = require('es-toolkit');
+var _esbuild2 = require('esbuild'); var esbuild = _interopRequireWildcard2(_esbuild2);
+var _globby = require('globby');
+var _fs3 = require('fs');
+var _promises = require('fs/promises'); var _promises2 = _interopRequireDefault2(_promises);
+var _findworkspaceroot = require('nx/src/utils/find-workspace-root');
+
+// src/utilities/helpers.ts
+function handleSync(fn) {
+  try {
+    return fn();
+  } catch (error_) {
+    return error_;
+  }
+}
+_chunkB4CUDMY2cjs.__name.call(void 0, handleSync, "handleSync");
+async function handleAsync(fn) {
+  try {
+    return await fn();
+  } catch (error_) {
+    return error_;
+  }
+}
+_chunkB4CUDMY2cjs.__name.call(void 0, handleAsync, "handleAsync");
+var handle = handleSync;
+handle.async = handleAsync;
+var skip = Symbol("skip");
+function transduceSync(list, transformer) {
+  const transduced = [];
+  for (const [i, element_] of list.entries()) {
+    const transformed = transformer(element_, i);
+    if (transformed !== skip) {
+      transduced[transduced.length] = transformed;
+    }
+  }
+  return transduced;
+}
+_chunkB4CUDMY2cjs.__name.call(void 0, transduceSync, "transduceSync");
+async function transduceAsync(list, transformer) {
+  const transduced = [];
+  await Promise.all(list.entries().map(async ([i, element_]) => {
+    const transformed = await transformer(element_, i);
+    if (transformed !== skip) {
+      transduced[transduced.length] = transformed;
+    }
+  }));
+  return transduced;
+}
+_chunkB4CUDMY2cjs.__name.call(void 0, transduceAsync, "transduceAsync");
+var Filter = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, (filter) => (item) => {
+  return filter(item) ? item : skip;
+}, "Filter");
+var Mapper = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, (mapper) => (item) => {
+  return mapper(item);
+}, "Mapper");
+var transduce = transduceSync;
+transduce.async = transduceAsync;
+function pipeSync(fn, ...fns) {
+  return (...args) => {
+    let result = fn(...args);
+    for (let i = 0; result !== skip && i < fns.length; ++i) {
+      result = _optionalChain2([fns, 'access', _78 => _78[i], 'optionalCall', _79 => _79(result)]);
+    }
+    return result;
+  };
+}
+_chunkB4CUDMY2cjs.__name.call(void 0, pipeSync, "pipeSync");
+function pipeAsync(fn, ...fns) {
+  return async (...args) => {
+    let result = await fn(...args);
+    for (let i = 0; result !== skip && i < fns.length; ++i) {
+      result = await _optionalChain2([fns, 'access', _80 => _80[i], 'optionalCall', _81 => _81(result)]);
+    }
+    return result;
+  };
+}
+_chunkB4CUDMY2cjs.__name.call(void 0, pipeAsync, "pipeAsync");
+var pipe = pipeSync;
+pipe.async = pipeAsync;
+
+// src/build.ts
+async function resolveContext(userOptions) {
+  const projectRoot = userOptions.projectRoot;
+  const workspaceRoot = _findworkspaceroot.findWorkspaceRoot.call(void 0, projectRoot);
+  if (!workspaceRoot) {
+    throw new Error("Cannot find Nx workspace root");
+  }
+  const workspaceConfig = await _chunkTDBBRZTCcjs.getWorkspaceConfig.call(void 0, true, {
+    workspaceRoot: workspaceRoot.dir
+  });
+  _chunkGJHRTQAScjs.writeDebug.call(void 0, "  \u2699\uFE0F   Resolving build options", workspaceConfig);
+  const stopwatch = _chunkGJHRTQAScjs.getStopwatch.call(void 0, "Build options resolution");
+  const projectGraph = await _devkit.createProjectGraphAsync.call(void 0, {
+    exitOnError: true
+  });
+  const projectJsonPath = _chunkVPTKC3UKcjs.joinPaths.call(void 0, workspaceRoot.dir, projectRoot, "project.json");
+  if (!_fs3.existsSync.call(void 0, projectJsonPath)) {
+    throw new Error("Cannot find project.json configuration");
+  }
+  const projectJsonFile = await _promises2.default.readFile(projectJsonPath, "utf8");
+  const projectJson = JSON.parse(projectJsonFile);
+  const projectName = projectJson.name || userOptions.name;
+  const projectConfigurations = _devkit.readProjectsConfigurationFromProjectGraph.call(void 0, projectGraph);
+  if (!_optionalChain2([projectConfigurations, 'optionalAccess', _82 => _82.projects, 'optionalAccess', _83 => _83[projectName]])) {
+    throw new Error("The Build process failed because the project does not have a valid configuration in the project.json file. Check if the file exists in the root of the project.");
+  }
+  const options2 = _defu2.default.call(void 0, userOptions, _chunkTDBBRZTCcjs.DEFAULT_BUILD_OPTIONS);
+  options2.name ??= projectName;
+  const packageJsonPath = _chunkVPTKC3UKcjs.joinPaths.call(void 0, workspaceRoot.dir, options2.projectRoot, "package.json");
+  if (!_fs3.existsSync.call(void 0, packageJsonPath)) {
+    throw new Error("Cannot find package.json configuration");
+  }
+  const env = _chunkTDBBRZTCcjs.getEnv.call(void 0, "esbuild", options2);
+  const define = _defu2.default.call(void 0, _nullishCoalesce2(options2.define, () => ( {})), _nullishCoalesce2(env, () => ( {})));
+  const resolvedOptions = {
+    ...options2,
+    tsconfig: _chunkVPTKC3UKcjs.joinPaths.call(void 0, projectRoot, userOptions.tsconfig ? userOptions.tsconfig.replace(projectRoot, "") : "tsconfig.json"),
+    metafile: userOptions.mode === "development",
+    clean: false,
+    env,
+    define: {
+      STORM_FORMAT: JSON.stringify(options2.format),
+      ...Object.keys(define).filter((key) => define[key] !== void 0).reduce((res, key) => {
+        const value = JSON.stringify(define[key]);
+        const safeKey = key.replaceAll("(", "").replaceAll(")", "");
+        return {
+          ...res,
+          [`process.env.${safeKey}`]: value,
+          [`import.meta.env.${safeKey}`]: value
+        };
+      }, {})
+    }
+  };
+  stopwatch();
+  return {
+    options: resolvedOptions,
+    clean: userOptions.clean !== false,
+    workspaceConfig,
+    projectConfigurations,
+    projectName,
+    projectGraph,
+    sourceRoot: resolvedOptions.sourceRoot || projectJson.sourceRoot || _chunkVPTKC3UKcjs.joinPaths.call(void 0, resolvedOptions.projectRoot, "src"),
+    outputPath: resolvedOptions.outputPath || _chunkVPTKC3UKcjs.joinPaths.call(void 0, workspaceConfig.workspaceRoot, "dist", resolvedOptions.projectRoot),
+    minify: resolvedOptions.minify || resolvedOptions.mode === "production"
+  };
+}
+_chunkB4CUDMY2cjs.__name.call(void 0, resolveContext, "resolveContext");
+async function generatePackageJson(context) {
+  if (context.options.generatePackageJson !== false && _fs3.existsSync.call(void 0, _chunkVPTKC3UKcjs.joinPaths.call(void 0, context.options.projectRoot, "package.json"))) {
+    _chunkGJHRTQAScjs.writeDebug.call(void 0, "  \u270D\uFE0F   Writing package.json file", context.workspaceConfig);
+    const stopwatch = _chunkGJHRTQAScjs.getStopwatch.call(void 0, "Write package.json file");
+    const packageJsonPath = _chunkVPTKC3UKcjs.joinPaths.call(void 0, context.options.projectRoot, "project.json");
+    if (!_fs3.existsSync.call(void 0, packageJsonPath)) {
+      throw new Error("Cannot find package.json configuration");
+    }
+    const packageJsonFile = await _promises2.default.readFile(_chunkVPTKC3UKcjs.joinPaths.call(void 0, context.workspaceConfig.workspaceRoot, context.options.projectRoot, "package.json"), "utf8");
+    let packageJson = JSON.parse(packageJsonFile);
+    if (!packageJson) {
+      throw new Error("Cannot find package.json configuration file");
+    }
+    packageJson = await _chunkTDBBRZTCcjs.addPackageDependencies.call(void 0, context.workspaceConfig.workspaceRoot, context.options.projectRoot, context.projectName, packageJson);
+    packageJson = await _chunkTDBBRZTCcjs.addWorkspacePackageJsonFields.call(void 0, context.workspaceConfig, context.options.projectRoot, context.sourceRoot, context.projectName, false, packageJson);
+    if (context.options.entry) {
+      packageJson.exports ??= {};
+      packageJson.exports["./package.json"] ??= "./package.json";
+      const entryPoints = Array.isArray(context.options.entry) ? context.options.entry : Object.keys(context.options.entry);
+      if (entryPoints.length > 0) {
+        const defaultEntry = entryPoints.includes("index") ? `.${context.options.distDir ? `/${context.options.distDir}` : ""}/index` : `.${context.options.distDir ? `/${context.options.distDir}` : ""}/${entryPoints[0]}`;
+        const isEsm = Array.isArray(context.options.format) ? context.options.format.includes("esm") : context.options.format === "esm";
+        const isCjs = Array.isArray(context.options.format) ? context.options.format.includes("cjs") : context.options.format === "cjs";
+        const isDts = context.options.dts || context.options.experimentalDts;
+        packageJson.exports["."] ??= `${defaultEntry}.${isEsm ? "mjs" : isCjs ? "cjs" : "js"}`;
+        for (const entryPoint of entryPoints) {
+          packageJson.exports[`./${entryPoint}`] ??= {};
+          if (isEsm) {
+            if (isDts) {
+              packageJson.exports[`./${entryPoint}`].import = {
+                types: `./dist/${entryPoint}.d.mts`,
+                default: `./dist/${entryPoint}.mjs`
+              };
+            } else {
+              packageJson.exports[`./${entryPoint}`].import = `./dist/${entryPoint}.mjs`;
+            }
+            if (isDts) {
+              packageJson.exports[`./${entryPoint}`].default = {
+                types: `./dist/${entryPoint}.d.mts`,
+                default: `./dist/${entryPoint}.mjs`
+              };
+            } else {
+              packageJson.exports[`./${entryPoint}`].default = `./dist/${entryPoint}.mjs`;
+            }
+          }
+          if (isCjs) {
+            if (isDts) {
+              packageJson.exports[`./${entryPoint}`].require = {
+                types: `./dist/${entryPoint}.d.cts`,
+                default: `./dist/${entryPoint}.cjs`
+              };
+            } else {
+              packageJson.exports[`./${entryPoint}`].require = `./dist/${entryPoint}.cjs`;
+            }
+            if (!isEsm) {
+              if (isDts) {
+                packageJson.exports[`./${entryPoint}`].default = {
+                  types: `./dist/${entryPoint}.d.cts`,
+                  default: `./dist/${entryPoint}.cjs`
+                };
+              } else {
+                packageJson.exports[`./${entryPoint}`].default = `./dist/${entryPoint}.cjs`;
+              }
+            }
+          }
+          if (!isEsm && !isCjs) {
+            if (isDts) {
+              packageJson.exports[`./${entryPoint}`].default = {
+                types: `./dist/${entryPoint}.d.ts`,
+                default: `./dist/${entryPoint}.js`
+              };
+            } else {
+              packageJson.exports[`./${entryPoint}`].default = `./dist/${entryPoint}.js`;
+            }
+          }
+        }
+        if (isEsm) {
+          packageJson.module = `${defaultEntry}.mjs`;
+        } else {
+          packageJson.main = `${defaultEntry}.cjs`;
+        }
+        if (isDts) {
+          packageJson.types = `${defaultEntry}.d.${isEsm ? "mts" : isCjs ? "cts" : "ts"}`;
+        }
+        packageJson.exports = Object.keys(packageJson.exports).reduce((ret, key) => {
+          if (key.endsWith("/index") && !ret[key.replace("/index", "")]) {
+            ret[key.replace("/index", "")] = packageJson.exports[key];
+          }
+          return ret;
+        }, packageJson.exports);
+      }
+    }
+    await _devkit.writeJsonFile.call(void 0, _chunkVPTKC3UKcjs.joinPaths.call(void 0, context.outputPath, "package.json"), packageJson);
+    stopwatch();
+  }
+  return context;
+}
+_chunkB4CUDMY2cjs.__name.call(void 0, generatePackageJson, "generatePackageJson");
+async function executeTsup(context) {
+  _chunkGJHRTQAScjs.writeDebug.call(void 0, `  \u{1F680}  Running ${context.options.name} build`, context.workspaceConfig);
+  const stopwatch = _chunkGJHRTQAScjs.getStopwatch.call(void 0, `${context.options.name} build`);
+  await (0, import_tsup.build)({
+    ...context.options,
+    outDir: context.options.distDir ? _chunkVPTKC3UKcjs.joinPaths.call(void 0, context.outputPath, context.options.distDir) : context.outputPath,
+    workspaceConfig: context.workspaceConfig
+  });
+  stopwatch();
+  return context;
+}
+_chunkB4CUDMY2cjs.__name.call(void 0, executeTsup, "executeTsup");
+async function copyBuildAssets(context) {
+  if (_optionalChain2([context, 'access', _84 => _84.result, 'optionalAccess', _85 => _85.errors, 'access', _86 => _86.length]) === 0) {
+    _chunkGJHRTQAScjs.writeDebug.call(void 0, `  \u{1F4CB}  Copying asset files to output directory: ${context.outputPath}`, context.workspaceConfig);
+    const stopwatch = _chunkGJHRTQAScjs.getStopwatch.call(void 0, `${context.options.name} asset copy`);
+    await _chunkTDBBRZTCcjs.copyAssets.call(void 0, context.workspaceConfig, _nullishCoalesce2(context.options.assets, () => ( [])), context.outputPath, context.options.projectRoot, context.sourceRoot, true, false);
+    stopwatch();
+  }
+  return context;
+}
+_chunkB4CUDMY2cjs.__name.call(void 0, copyBuildAssets, "copyBuildAssets");
+async function reportResults(context) {
+  if (_optionalChain2([context, 'access', _87 => _87.result, 'optionalAccess', _88 => _88.errors, 'access', _89 => _89.length]) === 0) {
+    if (context.result.warnings.length > 0) {
+      _chunkGJHRTQAScjs.writeWarning.call(void 0, `  \u{1F6A7}  The following warnings occurred during the build: ${context.result.warnings.map((warning) => warning.text).join("\n")}`, context.workspaceConfig);
+    }
+    _chunkGJHRTQAScjs.writeSuccess.call(void 0, `  \u{1F4E6}  The ${context.options.name} build completed successfully`, context.workspaceConfig);
+  } else if (_optionalChain2([context, 'access', _90 => _90.result, 'optionalAccess', _91 => _91.errors]) && _optionalChain2([context, 'access', _92 => _92.result, 'optionalAccess', _93 => _93.errors, 'access', _94 => _94.length]) > 0) {
+    _chunkGJHRTQAScjs.writeError.call(void 0, `  \u274C  The ${context.options.name} build failed with the following errors: ${context.result.errors.map((error) => error.text).join("\n")}`, context.workspaceConfig);
+    throw new Error(`The ${context.options.name} build failed with the following errors: ${context.result.errors.map((error) => error.text).join("\n")}`);
+  }
+}
+_chunkB4CUDMY2cjs.__name.call(void 0, reportResults, "reportResults");
+async function dependencyCheck(options2) {
+  if (process.env.DEV === "true") {
+    return void 0;
+  }
+  if (process.env.CI && !process.env.BUILDKITE) {
+    return void 0;
+  }
+  const buildPromise = esbuild.build({
+    entryPoints: _globby.globbySync.call(void 0, "**/*.{j,t}s", {
+      // We don't check dependencies in ecosystem tests because tests are isolated from the build.
+      ignore: [
+        "./src/__tests__/**/*",
+        "./tests/e2e/**/*",
+        "./dist/**/*"
+      ],
+      gitignore: true
+    }),
+    logLevel: "silent",
+    bundle: true,
+    write: false,
+    outdir: "out",
+    plugins: [
+      _chunkBNPCRQK4cjs.depsCheckPlugin.call(void 0, options2.bundle)
+    ]
+  });
+  await buildPromise.catch(() => {
+  });
+  return void 0;
+}
+_chunkB4CUDMY2cjs.__name.call(void 0, dependencyCheck, "dependencyCheck");
+async function cleanOutputPath(context) {
+  if (context.clean !== false && context.outputPath) {
+    _chunkGJHRTQAScjs.writeDebug.call(void 0, ` \u{1F9F9}  Cleaning ${context.options.name} output path: ${context.outputPath}`, context.workspaceConfig);
+    const stopwatch = _chunkGJHRTQAScjs.getStopwatch.call(void 0, `${context.options.name} output clean`);
+    await _chunkTH2QFJHIcjs.cleanDirectories.call(void 0, context.outputPath);
+    stopwatch();
+  }
+  return context;
+}
+_chunkB4CUDMY2cjs.__name.call(void 0, cleanOutputPath, "cleanOutputPath");
+async function build2(options2) {
+  _chunkGJHRTQAScjs.writeDebug.call(void 0, `  \u26A1   Executing Storm ESBuild pipeline`);
+  const stopwatch = _chunkGJHRTQAScjs.getStopwatch.call(void 0, "ESBuild pipeline");
+  try {
+    const opts = Array.isArray(options2) ? options2 : [
+      options2
+    ];
+    if (opts.length === 0) {
+      throw new Error("No build options were provided");
+    }
+    const context = await resolveContext(options2);
+    await cleanOutputPath(context);
+    await Promise.all([
+      dependencyCheck(context.options),
+      generatePackageJson(context),
+      copyBuildAssets(context),
+      executeTsup(context)
+    ]);
+    await reportResults(context);
+    _chunkGJHRTQAScjs.writeSuccess.call(void 0, "  \u{1F3C1}  ESBuild pipeline build completed successfully");
+  } catch (error) {
+    _chunkGJHRTQAScjs.writeFatal.call(void 0, "Fatal errors that the build process could not recover from have occured. The build process has been terminated.");
+    throw error;
+  } finally {
+    stopwatch();
+  }
+}
+_chunkB4CUDMY2cjs.__name.call(void 0, build2, "build");
+var watch = /* @__PURE__ */ _chunkB4CUDMY2cjs.__name.call(void 0, (context, options2) => {
+  if (!options2.watch) {
+    return context;
+  }
+  const config = {
+    ignoreInitial: true,
+    useFsEvents: true,
+    ignored: [
+      "./src/__tests__/**/*",
+      "./package.json"
+    ]
+  };
+  const changeWatcher = _chokidar.watch.call(void 0, [
+    "./src/**/*"
+  ], config);
+  const fastRebuild = _estoolkit.debounce.call(void 0, async () => {
+    const timeBefore = Date.now();
+    const rebuildResult = await handle.async(() => {
+      return context.rebuild();
+    });
+    if (rebuildResult instanceof Error) {
+      _chunkGJHRTQAScjs.writeError.call(void 0, rebuildResult.message);
+    }
+    _chunkGJHRTQAScjs.writeTrace.call(void 0, `${Date.now() - timeBefore}ms [${_nullishCoalesce2(options2.name, () => ( ""))}]`);
+  }, 10);
+  changeWatcher.on("change", fastRebuild);
+  return void 0;
+}, "watch");
+
+
+
+
+
+
+
+
+
+
+exports.handle = handle; exports.skip = skip; exports.Filter = Filter; exports.Mapper = Mapper; exports.transduce = transduce; exports.pipe = pipe; exports.build = build2; exports.watch = watch;