bun-plugin-dtsx 0.21.0

package/dist/index.js

@@ -0,0 +1,1750 @@
+// @bun
+// src/index.ts
+import process2 from "process";
+
+// node_modules/@stacksjs/dtsx/dist/index.js
+import { existsSync as Aq } from "fs";
+import { resolve as xq } from "path";
+import I1 from "process";
+import { readdir as _q, readFile as Rq } from "fs/promises";
+import { extname as Eq, join as g1 } from "path";
+import Sq from "process";
+import { readFile as gq } from "fs/promises";
+import { mkdir as kZ, rm as vZ } from "fs/promises";
+import { dirname as mZ, join as uZ, parse as hZ, relative as dZ } from "path";
+import Nq, { posix as N1 } from "path";
+var Lq = Object.create;
+var { getPrototypeOf: Pq, defineProperty: b1, getOwnPropertyNames: Tq } = Object;
+var Oq = Object.prototype.hasOwnProperty;
+var X1 = (q, Z, $) => {
+  $ = q != null ? Lq(Pq(q)) : {};
+  let J = Z || !q || !q.__esModule ? b1($, "default", { value: q, enumerable: true }) : $;
+  for (let j of Tq(q))
+    if (!Oq.call(J, j))
+      b1(J, j, { get: () => q[j], enumerable: true });
+  return J;
+};
+var _ = (q, Z) => () => (Z || q((Z = { exports: {} }).exports, Z), Z.exports);
+var f1 = _((c1) => {
+  Object.defineProperty(c1, "__esModule", { value: true });
+  c1.normalizePath = c1.convertSlashes = c1.cleanPath = undefined;
+  var D1 = import.meta.require("path");
+  function d1(q) {
+    let Z = D1.normalize(q);
+    if (Z.length > 1 && Z[Z.length - 1] === D1.sep)
+      Z = Z.substring(0, Z.length - 1);
+    return Z;
+  }
+  c1.cleanPath = d1;
+  var kq = /[\\/]/g;
+  function l1(q, Z) {
+    return q.replace(kq, Z);
+  }
+  c1.convertSlashes = l1;
+  function vq(q, Z) {
+    let { resolvePaths: $, normalizePath: J, pathSeparator: j } = Z, z = process.platform === "win32" && q.includes("/") || q.startsWith(".");
+    if ($)
+      q = D1.resolve(q);
+    if (J || z)
+      q = d1(q);
+    if (q === ".")
+      return "";
+    let U = q[q.length - 1] !== j;
+    return l1(U ? q + j : q, j);
+  }
+  c1.normalizePath = vq;
+});
+var a1 = _((r1) => {
+  Object.defineProperty(r1, "__esModule", { value: true });
+  r1.build = r1.joinDirectoryPath = r1.joinPathWithBasePath = undefined;
+  var hq = import.meta.require("path"), dq = f1();
+  function n1(q, Z) {
+    return Z + q;
+  }
+  r1.joinPathWithBasePath = n1;
+  function lq(q, Z) {
+    return function($, J) {
+      if (J.startsWith(q))
+        return J.replace(q, "") + $;
+      else
+        return dq.convertSlashes(hq.relative(q, J), Z.pathSeparator) + Z.pathSeparator + $;
+    };
+  }
+  function cq(q) {
+    return q;
+  }
+  function iq(q, Z, $) {
+    return Z + q + $;
+  }
+  r1.joinDirectoryPath = iq;
+  function nq(q, Z) {
+    let { relativePaths: $, includeBasePath: J } = Z;
+    return $ && q ? lq(q, Z) : J ? n1 : cq;
+  }
+  r1.build = nq;
+});
+var e1 = _((s1) => {
+  Object.defineProperty(s1, "__esModule", { value: true });
+  s1.build = undefined;
+  function aq(q) {
+    return function(Z, $) {
+      $.push(Z.substring(q.length) || ".");
+    };
+  }
+  function sq(q) {
+    return function(Z, $, J) {
+      let j = Z.substring(q.length) || ".";
+      if (J.every((z) => z(j, true)))
+        $.push(j);
+    };
+  }
+  var oq = (q, Z) => {
+    Z.push(q || ".");
+  }, eq = (q, Z, $) => {
+    let J = q || ".";
+    if ($.every((j) => j(J, true)))
+      Z.push(J);
+  }, tq = () => {
+  };
+  function q$(q, Z) {
+    let { includeDirs: $, filters: J, relativePaths: j } = Z;
+    if (!$)
+      return tq;
+    if (j)
+      return J && J.length ? sq(q) : aq(q);
+    return J && J.length ? eq : oq;
+  }
+  s1.build = q$;
+});
+var $0 = _((t1) => {
+  Object.defineProperty(t1, "__esModule", { value: true });
+  t1.build = undefined;
+  var $$ = (q, Z, $, J) => {
+    if (J.every((j) => j(q, false)))
+      $.files++;
+  }, Z$ = (q, Z, $, J) => {
+    if (J.every((j) => j(q, false)))
+      Z.push(q);
+  }, J$ = (q, Z, $, J) => {
+    $.files++;
+  }, j$ = (q, Z) => {
+    Z.push(q);
+  }, V$ = () => {
+  };
+  function Y$(q) {
+    let { excludeFiles: Z, filters: $, onlyCounts: J } = q;
+    if (Z)
+      return V$;
+    if ($ && $.length)
+      return J ? $$ : Z$;
+    else if (J)
+      return J$;
+    else
+      return j$;
+  }
+  t1.build = Y$;
+});
+var j0 = _((Z0) => {
+  Object.defineProperty(Z0, "__esModule", { value: true });
+  Z0.build = undefined;
+  var W$ = (q) => {
+    return q;
+  }, z$ = () => {
+    return [""].slice(0, 0);
+  };
+  function U$(q) {
+    return q.group ? z$ : W$;
+  }
+  Z0.build = U$;
+});
+var W0 = _((V0) => {
+  Object.defineProperty(V0, "__esModule", { value: true });
+  V0.build = undefined;
+  var X$ = (q, Z, $) => {
+    q.push({ directory: Z, files: $, dir: Z });
+  }, B$ = () => {
+  };
+  function Q$(q) {
+    return q.group ? X$ : B$;
+  }
+  V0.build = Q$;
+});
+var X0 = _((t) => {
+  var F$ = t && t.__importDefault || function(q) {
+    return q && q.__esModule ? q : { default: q };
+  };
+  Object.defineProperty(t, "__esModule", { value: true });
+  t.build = undefined;
+  var F1 = F$(import.meta.require("fs")), z0 = import.meta.require("path"), K$ = function(q, Z, $) {
+    let { queue: J, options: { suppressErrors: j } } = Z;
+    J.enqueue(), F1.default.realpath(q, (z, U) => {
+      if (z)
+        return J.dequeue(j ? null : z, Z);
+      F1.default.stat(U, (B, M) => {
+        if (B)
+          return J.dequeue(j ? null : B, Z);
+        if (M.isDirectory() && U0(q, U, Z))
+          return J.dequeue(null, Z);
+        $(M, U), J.dequeue(null, Z);
+      });
+    });
+  }, G$ = function(q, Z, $) {
+    let { queue: J, options: { suppressErrors: j } } = Z;
+    J.enqueue();
+    try {
+      let z = F1.default.realpathSync(q), U = F1.default.statSync(z);
+      if (U.isDirectory() && U0(q, z, Z))
+        return;
+      $(U, z);
+    } catch (z) {
+      if (!j)
+        throw z;
+    }
+  };
+  function M$(q, Z) {
+    if (!q.resolveSymlinks || q.excludeSymlinks)
+      return null;
+    return Z ? G$ : K$;
+  }
+  t.build = M$;
+  function U0(q, Z, $) {
+    if ($.options.useRealPaths)
+      return N$(Z, $);
+    let J = z0.dirname(q), j = 1;
+    while (J !== $.root && j < 2) {
+      let z = $.symlinks.get(J);
+      if (!!z && (z === Z || z.startsWith(Z) || Z.startsWith(z)))
+        j++;
+      else
+        J = z0.dirname(J);
+    }
+    return $.symlinks.set(q, Z), j > 1;
+  }
+  function N$(q, Z) {
+    return Z.visited.includes(q + Z.options.pathSeparator);
+  }
+});
+var F0 = _((B0) => {
+  Object.defineProperty(B0, "__esModule", { value: true });
+  B0.build = undefined;
+  var w$ = (q) => {
+    return q.counts;
+  }, y$ = (q) => {
+    return q.groups;
+  }, I$ = (q) => {
+    return q.paths;
+  }, D$ = (q) => {
+    return q.paths.slice(0, q.options.maxFiles);
+  }, f$ = (q, Z, $) => {
+    return K1(Z, $, q.counts, q.options.suppressErrors), null;
+  }, H$ = (q, Z, $) => {
+    return K1(Z, $, q.paths, q.options.suppressErrors), null;
+  }, C$ = (q, Z, $) => {
+    return K1(Z, $, q.paths.slice(0, q.options.maxFiles), q.options.suppressErrors), null;
+  }, L$ = (q, Z, $) => {
+    return K1(Z, $, q.groups, q.options.suppressErrors), null;
+  };
+  function K1(q, Z, $, J) {
+    if (q && !J)
+      Z(q, $);
+    else
+      Z(null, $);
+  }
+  function P$(q, Z) {
+    let { onlyCounts: $, group: J, maxFiles: j } = q;
+    if ($)
+      return Z ? w$ : f$;
+    else if (J)
+      return Z ? y$ : L$;
+    else if (j)
+      return Z ? D$ : C$;
+    else
+      return Z ? I$ : H$;
+  }
+  B0.build = P$;
+});
+var M0 = _((q1) => {
+  var T$ = q1 && q1.__importDefault || function(q) {
+    return q && q.__esModule ? q : { default: q };
+  };
+  Object.defineProperty(q1, "__esModule", { value: true });
+  q1.build = undefined;
+  var K0 = T$(import.meta.require("fs")), G0 = { withFileTypes: true }, O$ = (q, Z, $, J, j) => {
+    if (J < 0)
+      return q.queue.dequeue(null, q);
+    q.visited.push(Z), q.counts.directories++, q.queue.enqueue(), K0.default.readdir(Z || ".", G0, (z, U = []) => {
+      j(U, $, J), q.queue.dequeue(q.options.suppressErrors ? null : z, q);
+    });
+  }, _$ = (q, Z, $, J, j) => {
+    if (J < 0)
+      return;
+    q.visited.push(Z), q.counts.directories++;
+    let z = [];
+    try {
+      z = K0.default.readdirSync(Z || ".", G0);
+    } catch (U) {
+      if (!q.options.suppressErrors)
+        throw U;
+    }
+    j(z, $, J);
+  };
+  function R$(q) {
+    return q ? _$ : O$;
+  }
+  q1.build = R$;
+});
+var I0 = _((w0) => {
+  Object.defineProperty(w0, "__esModule", { value: true });
+  w0.Queue = undefined;
+
+  class N0 {
+    onQueueEmpty;
+    count = 0;
+    constructor(q) {
+      this.onQueueEmpty = q;
+    }
+    enqueue() {
+      this.count++;
+    }
+    dequeue(q, Z) {
+      if (--this.count <= 0 || q)
+        this.onQueueEmpty(q, Z);
+    }
+  }
+  w0.Queue = N0;
+});
+var C0 = _((f0) => {
+  Object.defineProperty(f0, "__esModule", { value: true });
+  f0.Counter = undefined;
+
+  class D0 {
+    _files = 0;
+    _directories = 0;
+    set files(q) {
+      this._files = q;
+    }
+    get files() {
+      return this._files;
+    }
+    set directories(q) {
+      this._directories = q;
+    }
+    get directories() {
+      return this._directories;
+    }
+    get dirs() {
+      return this._directories;
+    }
+  }
+  f0.Counter = D0;
+});
+var L1 = _((n) => {
+  var E$ = n && n.__createBinding || (Object.create ? function(q, Z, $, J) {
+    if (J === undefined)
+      J = $;
+    var j = Object.getOwnPropertyDescriptor(Z, $);
+    if (!j || ("get" in j ? !Z.__esModule : j.writable || j.configurable))
+      j = { enumerable: true, get: function() {
+        return Z[$];
+      } };
+    Object.defineProperty(q, J, j);
+  } : function(q, Z, $, J) {
+    if (J === undefined)
+      J = $;
+    q[J] = Z[$];
+  }), S$ = n && n.__setModuleDefault || (Object.create ? function(q, Z) {
+    Object.defineProperty(q, "default", { enumerable: true, value: Z });
+  } : function(q, Z) {
+    q.default = Z;
+  }), o = n && n.__importStar || function(q) {
+    if (q && q.__esModule)
+      return q;
+    var Z = {};
+    if (q != null) {
+      for (var $ in q)
+        if ($ !== "default" && Object.prototype.hasOwnProperty.call(q, $))
+          E$(Z, q, $);
+    }
+    return S$(Z, q), Z;
+  };
+  Object.defineProperty(n, "__esModule", { value: true });
+  n.Walker = undefined;
+  var L0 = import.meta.require("path"), H1 = f1(), C1 = o(a1()), A$ = o(e1()), x$ = o($0()), b$ = o(j0()), g$ = o(W0()), k$ = o(X0()), v$ = o(F0()), m$ = o(M0()), u$ = I0(), h$ = C0();
+
+  class P0 {
+    root;
+    isSynchronous;
+    state;
+    joinPath;
+    pushDirectory;
+    pushFile;
+    getArray;
+    groupFiles;
+    resolveSymlink;
+    walkDirectory;
+    callbackInvoker;
+    constructor(q, Z, $) {
+      this.isSynchronous = !$, this.callbackInvoker = v$.build(Z, this.isSynchronous), this.root = H1.normalizePath(q, Z), this.state = { root: this.root.slice(0, -1), paths: [""].slice(0, 0), groups: [], counts: new h$.Counter, options: Z, queue: new u$.Queue((J, j) => this.callbackInvoker(j, J, $)), symlinks: new Map, visited: [""].slice(0, 0) }, this.joinPath = C1.build(this.root, Z), this.pushDirectory = A$.build(this.root, Z), this.pushFile = x$.build(Z), this.getArray = b$.build(Z), this.groupFiles = g$.build(Z), this.resolveSymlink = k$.build(Z, this.isSynchronous), this.walkDirectory = m$.build(this.isSynchronous);
+    }
+    start() {
+      return this.walkDirectory(this.state, this.root, this.root, this.state.options.maxDepth, this.walk), this.isSynchronous ? this.callbackInvoker(this.state, null) : null;
+    }
+    walk = (q, Z, $) => {
+      let { paths: J, options: { filters: j, resolveSymlinks: z, excludeSymlinks: U, exclude: B, maxFiles: M, signal: K, useRealPaths: F, pathSeparator: T } } = this.state;
+      if (K && K.aborted || M && J.length > M)
+        return;
+      this.pushDirectory(Z, J, j);
+      let H = this.getArray(this.state.paths);
+      for (let P = 0;P < q.length; ++P) {
+        let N = q[P];
+        if (N.isFile() || N.isSymbolicLink() && !z && !U) {
+          let G = this.joinPath(N.name, Z);
+          this.pushFile(G, H, this.state.counts, j);
+        } else if (N.isDirectory()) {
+          let G = C1.joinDirectoryPath(N.name, Z, this.state.options.pathSeparator);
+          if (B && B(N.name, G))
+            continue;
+          this.walkDirectory(this.state, G, G, $ - 1, this.walk);
+        } else if (N.isSymbolicLink() && this.resolveSymlink) {
+          let G = C1.joinPathWithBasePath(N.name, Z);
+          this.resolveSymlink(G, this.state, (h, C) => {
+            if (h.isDirectory()) {
+              if (C = H1.normalizePath(C, this.state.options), B && B(N.name, C))
+                return;
+              this.walkDirectory(this.state, C, F ? C : G + T, $ - 1, this.walk);
+            } else {
+              C = F ? C : G;
+              let I = L0.basename(C), g = H1.normalizePath(L0.dirname(C), this.state.options);
+              C = this.joinPath(I, g), this.pushFile(C, H, this.state.counts, j);
+            }
+          });
+        }
+      }
+      this.groupFiles(this.state.groups, Z, H);
+    };
+  }
+  n.Walker = P0;
+});
+var R0 = _((O0) => {
+  Object.defineProperty(O0, "__esModule", { value: true });
+  O0.callback = O0.promise = undefined;
+  var d$ = L1();
+  function l$(q, Z) {
+    return new Promise(($, J) => {
+      T0(q, Z, (j, z) => {
+        if (j)
+          return J(j);
+        $(z);
+      });
+    });
+  }
+  O0.promise = l$;
+  function T0(q, Z, $) {
+    new d$.Walker(q, Z, $).start();
+  }
+  O0.callback = T0;
+});
+var A0 = _((E0) => {
+  Object.defineProperty(E0, "__esModule", { value: true });
+  E0.sync = undefined;
+  var i$ = L1();
+  function n$(q, Z) {
+    return new i$.Walker(q, Z).start();
+  }
+  E0.sync = n$;
+});
+var v0 = _((g0) => {
+  Object.defineProperty(g0, "__esModule", { value: true });
+  g0.APIBuilder = undefined;
+  var x0 = R0(), r$ = A0();
+
+  class b0 {
+    root;
+    options;
+    constructor(q, Z) {
+      this.root = q, this.options = Z;
+    }
+    withPromise() {
+      return x0.promise(this.root, this.options);
+    }
+    withCallback(q) {
+      x0.callback(this.root, this.options, q);
+    }
+    sync() {
+      return r$.sync(this.root, this.options);
+    }
+  }
+  g0.APIBuilder = b0;
+});
+var J1 = _((y8, u0) => {
+  var m0 = { DOT_LITERAL: "\\.", PLUS_LITERAL: "\\+", QMARK_LITERAL: "\\?", SLASH_LITERAL: "\\/", ONE_CHAR: "(?=.)", QMARK: "[^/]", END_ANCHOR: "(?:\\/|$)", DOTS_SLASH: "\\.{1,2}(?:\\/|$)", NO_DOT: "(?!\\.)", NO_DOTS: "(?!(?:^|\\/)\\.{1,2}(?:\\/|$))", NO_DOT_SLASH: "(?!\\.{0,1}(?:\\/|$))", NO_DOTS_SLASH: "(?!\\.{1,2}(?:\\/|$))", QMARK_NO_DOT: "[^.\\/]", STAR: "[^/]*?", START_ANCHOR: "(?:^|\\/)", SEP: "/" }, p$ = { ...m0, SLASH_LITERAL: "[\\\\/]", QMARK: "[^\\\\/]", STAR: "[^\\\\/]*?", DOTS_SLASH: "\\.{1,2}(?:[\\\\/]|$)", NO_DOT: "(?!\\.)", NO_DOTS: "(?!(?:^|[\\\\/])\\.{1,2}(?:[\\\\/]|$))", NO_DOT_SLASH: "(?!\\.{0,1}(?:[\\\\/]|$))", NO_DOTS_SLASH: "(?!\\.{1,2}(?:[\\\\/]|$))", QMARK_NO_DOT: "[^.\\\\/]", START_ANCHOR: "(?:^|[\\\\/])", END_ANCHOR: "(?:[\\\\/]|$)", SEP: "\\" }, a$ = { alnum: "a-zA-Z0-9", alpha: "a-zA-Z", ascii: "\\x00-\\x7F", blank: " \\t", cntrl: "\\x00-\\x1F\\x7F", digit: "0-9", graph: "\\x21-\\x7E", lower: "a-z", print: "\\x20-\\x7E ", punct: '\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~', space: " \\t\\r\\n\\v\\f", upper: "A-Z", word: "A-Za-z0-9_", xdigit: "A-Fa-f0-9" };
+  u0.exports = { MAX_LENGTH: 65536, POSIX_REGEX_SOURCE: a$, REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g, REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/, REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/, REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g, REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g, REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g, REPLACEMENTS: { "***": "*", "**/**": "**", "**/**/**": "**" }, CHAR_0: 48, CHAR_9: 57, CHAR_UPPERCASE_A: 65, CHAR_LOWERCASE_A: 97, CHAR_UPPERCASE_Z: 90, CHAR_LOWERCASE_Z: 122, CHAR_LEFT_PARENTHESES: 40, CHAR_RIGHT_PARENTHESES: 41, CHAR_ASTERISK: 42, CHAR_AMPERSAND: 38, CHAR_AT: 64, CHAR_BACKWARD_SLASH: 92, CHAR_CARRIAGE_RETURN: 13, CHAR_CIRCUMFLEX_ACCENT: 94, CHAR_COLON: 58, CHAR_COMMA: 44, CHAR_DOT: 46, CHAR_DOUBLE_QUOTE: 34, CHAR_EQUAL: 61, CHAR_EXCLAMATION_MARK: 33, CHAR_FORM_FEED: 12, CHAR_FORWARD_SLASH: 47, CHAR_GRAVE_ACCENT: 96, CHAR_HASH: 35, CHAR_HYPHEN_MINUS: 45, CHAR_LEFT_ANGLE_BRACKET: 60, CHAR_LEFT_CURLY_BRACE: 123, CHAR_LEFT_SQUARE_BRACKET: 91, CHAR_LINE_FEED: 10, CHAR_NO_BREAK_SPACE: 160, CHAR_PERCENT: 37, CHAR_PLUS: 43, CHAR_QUESTION_MARK: 63, CHAR_RIGHT_ANGLE_BRACKET: 62, CHAR_RIGHT_CURLY_BRACE: 125, CHAR_RIGHT_SQUARE_BRACKET: 93, CHAR_SEMICOLON: 59, CHAR_SINGLE_QUOTE: 39, CHAR_SPACE: 32, CHAR_TAB: 9, CHAR_UNDERSCORE: 95, CHAR_VERTICAL_LINE: 124, CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, extglobChars(q) {
+    return { "!": { type: "negate", open: "(?:(?!(?:", close: `))${q.STAR})` }, "?": { type: "qmark", open: "(?:", close: ")?" }, "+": { type: "plus", open: "(?:", close: ")+" }, "*": { type: "star", open: "(?:", close: ")*" }, "@": { type: "at", open: "(?:", close: ")" } };
+  }, globChars(q) {
+    return q === true ? p$ : m0;
+  } };
+});
+var j1 = _((qZ) => {
+  var { REGEX_BACKSLASH: s$, REGEX_REMOVE_BACKSLASH: o$, REGEX_SPECIAL_CHARS: e$, REGEX_SPECIAL_CHARS_GLOBAL: t$ } = J1();
+  qZ.isObject = (q) => q !== null && typeof q === "object" && !Array.isArray(q);
+  qZ.hasRegexChars = (q) => e$.test(q);
+  qZ.isRegexChar = (q) => q.length === 1 && qZ.hasRegexChars(q);
+  qZ.escapeRegex = (q) => q.replace(t$, "\\$1");
+  qZ.toPosixSlashes = (q) => q.replace(s$, "/");
+  qZ.isWindows = () => {
+    if (typeof navigator !== "undefined" && navigator.platform) {
+      let q = navigator.platform.toLowerCase();
+      return q === "win32" || q === "windows";
+    }
+    if (typeof process !== "undefined" && process.platform)
+      return process.platform === "win32";
+    return false;
+  };
+  qZ.removeBackslashes = (q) => {
+    return q.replace(o$, (Z) => {
+      return Z === "\\" ? "" : Z;
+    });
+  };
+  qZ.escapeLast = (q, Z, $) => {
+    let J = q.lastIndexOf(Z, $);
+    if (J === -1)
+      return q;
+    if (q[J - 1] === "\\")
+      return qZ.escapeLast(q, Z, J - 1);
+    return `${q.slice(0, J)}\\${q.slice(J)}`;
+  };
+  qZ.removePrefix = (q, Z = {}) => {
+    let $ = q;
+    if ($.startsWith("./"))
+      $ = $.slice(2), Z.prefix = "./";
+    return $;
+  };
+  qZ.wrapOutput = (q, Z = {}, $ = {}) => {
+    let J = $.contains ? "" : "^", j = $.contains ? "" : "$", z = `${J}(?:${q})${j}`;
+    if (Z.negated === true)
+      z = `(?:^(?!${z}).*$)`;
+    return z;
+  };
+  qZ.basename = (q, { windows: Z } = {}) => {
+    let $ = q.split(Z ? /[\\/]/ : "/"), J = $[$.length - 1];
+    if (J === "")
+      return $[$.length - 2];
+    return J;
+  };
+});
+var s0 = _((D8, a0) => {
+  var l0 = j1(), { CHAR_ASTERISK: P1, CHAR_AT: XZ, CHAR_BACKWARD_SLASH: V1, CHAR_COMMA: BZ, CHAR_DOT: T1, CHAR_EXCLAMATION_MARK: O1, CHAR_FORWARD_SLASH: p0, CHAR_LEFT_CURLY_BRACE: _1, CHAR_LEFT_PARENTHESES: R1, CHAR_LEFT_SQUARE_BRACKET: QZ, CHAR_PLUS: FZ, CHAR_QUESTION_MARK: c0, CHAR_RIGHT_CURLY_BRACE: KZ, CHAR_RIGHT_PARENTHESES: i0, CHAR_RIGHT_SQUARE_BRACKET: GZ } = J1(), n0 = (q) => {
+    return q === p0 || q === V1;
+  }, r0 = (q) => {
+    if (q.isPrefix !== true)
+      q.depth = q.isGlobstar ? 1 / 0 : 1;
+  }, MZ = (q, Z) => {
+    let $ = Z || {}, J = q.length - 1, j = $.parts === true || $.scanToEnd === true, z = [], U = [], B = [], M = q, K = -1, F = 0, T = 0, H = false, P = false, N = false, G = false, h = false, C = false, I = false, g = false, i = false, v = false, x = 0, m, w, y = { value: "", depth: 0, isGlob: false }, W = () => K >= J, d = () => M.charCodeAt(K + 1), b = () => {
+      return m = w, M.charCodeAt(++K);
+    };
+    while (K < J) {
+      w = b();
+      let L;
+      if (w === V1) {
+        if (I = y.backslashes = true, w = b(), w === _1)
+          C = true;
+        continue;
+      }
+      if (C === true || w === _1) {
+        x++;
+        while (W() !== true && (w = b())) {
+          if (w === V1) {
+            I = y.backslashes = true, b();
+            continue;
+          }
+          if (w === _1) {
+            x++;
+            continue;
+          }
+          if (C !== true && w === T1 && (w = b()) === T1) {
+            if (H = y.isBrace = true, N = y.isGlob = true, v = true, j === true)
+              continue;
+            break;
+          }
+          if (C !== true && w === BZ) {
+            if (H = y.isBrace = true, N = y.isGlob = true, v = true, j === true)
+              continue;
+            break;
+          }
+          if (w === KZ) {
+            if (x--, x === 0) {
+              C = false, H = y.isBrace = true, v = true;
+              break;
+            }
+          }
+        }
+        if (j === true)
+          continue;
+        break;
+      }
+      if (w === p0) {
+        if (z.push(K), U.push(y), y = { value: "", depth: 0, isGlob: false }, v === true)
+          continue;
+        if (m === T1 && K === F + 1) {
+          F += 2;
+          continue;
+        }
+        T = K + 1;
+        continue;
+      }
+      if ($.noext !== true) {
+        if ((w === FZ || w === XZ || w === P1 || w === c0 || w === O1) === true && d() === R1) {
+          if (N = y.isGlob = true, G = y.isExtglob = true, v = true, w === O1 && K === F)
+            i = true;
+          if (j === true) {
+            while (W() !== true && (w = b())) {
+              if (w === V1) {
+                I = y.backslashes = true, w = b();
+                continue;
+              }
+              if (w === i0) {
+                N = y.isGlob = true, v = true;
+                break;
+              }
+            }
+            continue;
+          }
+          break;
+        }
+      }
+      if (w === P1) {
+        if (m === P1)
+          h = y.isGlobstar = true;
+        if (N = y.isGlob = true, v = true, j === true)
+          continue;
+        break;
+      }
+      if (w === c0) {
+        if (N = y.isGlob = true, v = true, j === true)
+          continue;
+        break;
+      }
+      if (w === QZ) {
+        while (W() !== true && (L = b())) {
+          if (L === V1) {
+            I = y.backslashes = true, b();
+            continue;
+          }
+          if (L === GZ) {
+            P = y.isBracket = true, N = y.isGlob = true, v = true;
+            break;
+          }
+        }
+        if (j === true)
+          continue;
+        break;
+      }
+      if ($.nonegate !== true && w === O1 && K === F) {
+        g = y.negated = true, F++;
+        continue;
+      }
+      if ($.noparen !== true && w === R1) {
+        if (N = y.isGlob = true, j === true) {
+          while (W() !== true && (w = b())) {
+            if (w === R1) {
+              I = y.backslashes = true, w = b();
+              continue;
+            }
+            if (w === i0) {
+              v = true;
+              break;
+            }
+          }
+          continue;
+        }
+        break;
+      }
+      if (N === true) {
+        if (v = true, j === true)
+          continue;
+        break;
+      }
+    }
+    if ($.noext === true)
+      G = false, N = false;
+    let S = M, V = "", Y = "";
+    if (F > 0)
+      V = M.slice(0, F), M = M.slice(F), T -= F;
+    if (S && N === true && T > 0)
+      S = M.slice(0, T), Y = M.slice(T);
+    else if (N === true)
+      S = "", Y = M;
+    else
+      S = M;
+    if (S && S !== "" && S !== "/" && S !== M) {
+      if (n0(S.charCodeAt(S.length - 1)))
+        S = S.slice(0, -1);
+    }
+    if ($.unescape === true) {
+      if (Y)
+        Y = l0.removeBackslashes(Y);
+      if (S && I === true)
+        S = l0.removeBackslashes(S);
+    }
+    let l = { prefix: V, input: q, start: F, base: S, glob: Y, isBrace: H, isBracket: P, isGlob: N, isExtglob: G, isGlobstar: h, negated: g, negatedExtglob: i };
+    if ($.tokens === true) {
+      if (l.maxDepth = 0, !n0(w))
+        U.push(y);
+      l.tokens = U;
+    }
+    if ($.parts === true || $.tokens === true) {
+      let L;
+      for (let R = 0;R < z.length; R++) {
+        let p = L ? L + 1 : F, c = z[R], s = q.slice(p, c);
+        if ($.tokens) {
+          if (R === 0 && F !== 0)
+            U[R].isPrefix = true, U[R].value = V;
+          else
+            U[R].value = s;
+          r0(U[R]), l.maxDepth += U[R].depth;
+        }
+        if (R !== 0 || s !== "")
+          B.push(s);
+        L = c;
+      }
+      if (L && L + 1 < q.length) {
+        let R = q.slice(L + 1);
+        if (B.push(R), $.tokens)
+          U[U.length - 1].value = R, r0(U[U.length - 1]), l.maxDepth += U[U.length - 1].depth;
+      }
+      l.slashes = z, l.parts = B;
+    }
+    return l;
+  };
+  a0.exports = MZ;
+});
+var t0 = _((f8, e0) => {
+  var G1 = J1(), r = j1(), { MAX_LENGTH: M1, POSIX_REGEX_SOURCE: NZ, REGEX_NON_SPECIAL_CHARS: wZ, REGEX_SPECIAL_CHARS_BACKREF: yZ, REPLACEMENTS: o0 } = G1, IZ = (q, Z) => {
+    if (typeof Z.expandRange === "function")
+      return Z.expandRange(...q, Z);
+    q.sort();
+    let $ = `[${q.join("-")}]`;
+    try {
+      new RegExp($);
+    } catch (J) {
+      return q.map((j) => r.escapeRegex(j)).join("..");
+    }
+    return $;
+  }, $1 = (q, Z) => {
+    return `Missing ${q}: "${Z}" - use "\\\\${Z}" to match literal characters`;
+  }, E1 = (q, Z) => {
+    if (typeof q !== "string")
+      throw new TypeError("Expected a string");
+    q = o0[q] || q;
+    let $ = { ...Z }, J = typeof $.maxLength === "number" ? Math.min(M1, $.maxLength) : M1, j = q.length;
+    if (j > J)
+      throw new SyntaxError(`Input length: ${j}, exceeds maximum allowed length: ${J}`);
+    let z = { type: "bos", value: "", output: $.prepend || "" }, U = [z], B = $.capture ? "" : "?:", M = G1.globChars($.windows), K = G1.extglobChars(M), { DOT_LITERAL: F, PLUS_LITERAL: T, SLASH_LITERAL: H, ONE_CHAR: P, DOTS_SLASH: N, NO_DOT: G, NO_DOT_SLASH: h, NO_DOTS_SLASH: C, QMARK: I, QMARK_NO_DOT: g, STAR: i, START_ANCHOR: v } = M, x = (Q) => {
+      return `(${B}(?:(?!${v}${Q.dot ? N : F}).)*?)`;
+    }, m = $.dot ? "" : G, w = $.dot ? I : g, y = $.bash === true ? x($) : i;
+    if ($.capture)
+      y = `(${y})`;
+    if (typeof $.noext === "boolean")
+      $.noextglob = $.noext;
+    let W = { input: q, index: -1, start: 0, dot: $.dot === true, consumed: "", output: "", prefix: "", backtrack: false, negated: false, brackets: 0, braces: 0, parens: 0, quotes: 0, globstar: false, tokens: U };
+    q = r.removePrefix(q, W), j = q.length;
+    let d = [], b = [], S = [], V = z, Y, l = () => W.index === j - 1, L = W.peek = (Q = 1) => q[W.index + Q], R = W.advance = () => q[++W.index] || "", p = () => q.slice(W.index + 1), c = (Q = "", O = 0) => {
+      W.consumed += Q, W.index += O;
+    }, s = (Q) => {
+      W.output += Q.output != null ? Q.output : Q.value, c(Q.value);
+    }, Hq = () => {
+      let Q = 1;
+      while (L() === "!" && (L(2) !== "(" || L(3) === "?"))
+        R(), W.start++, Q++;
+      if (Q % 2 === 0)
+        return false;
+      return W.negated = true, W.start++, true;
+    }, W1 = (Q) => {
+      W[Q]++, S.push(Q);
+    }, e = (Q) => {
+      W[Q]--, S.pop();
+    }, f = (Q) => {
+      if (V.type === "globstar") {
+        let O = W.braces > 0 && (Q.type === "comma" || Q.type === "brace"), X = Q.extglob === true || d.length && (Q.type === "pipe" || Q.type === "paren");
+        if (Q.type !== "slash" && Q.type !== "paren" && !O && !X)
+          W.output = W.output.slice(0, -V.output.length), V.type = "star", V.value = "*", V.output = y, W.output += V.output;
+      }
+      if (d.length && Q.type !== "paren")
+        d[d.length - 1].inner += Q.value;
+      if (Q.value || Q.output)
+        s(Q);
+      if (V && V.type === "text" && Q.type === "text") {
+        V.output = (V.output || V.value) + Q.value, V.value += Q.value;
+        return;
+      }
+      Q.prev = V, U.push(Q), V = Q;
+    }, z1 = (Q, O) => {
+      let X = { ...K[O], conditions: 1, inner: "" };
+      X.prev = V, X.parens = W.parens, X.output = W.output;
+      let D = ($.capture ? "(" : "") + X.open;
+      W1("parens"), f({ type: Q, value: O, output: W.output ? "" : P }), f({ type: "paren", extglob: true, value: R(), output: D }), d.push(X);
+    }, Cq = (Q) => {
+      let O = Q.close + ($.capture ? ")" : ""), X;
+      if (Q.type === "negate") {
+        let D = y;
+        if (Q.inner && Q.inner.length > 1 && Q.inner.includes("/"))
+          D = x($);
+        if (D !== y || l() || /^\)+$/.test(p()))
+          O = Q.close = `)$))${D}`;
+        if (Q.inner.includes("*") && (X = p()) && /^\.[^\\/.]+$/.test(X)) {
+          let E = E1(X, { ...Z, fastpaths: false }).output;
+          O = Q.close = `)${E})${D})`;
+        }
+        if (Q.prev.type === "bos")
+          W.negatedExtglob = true;
+      }
+      f({ type: "paren", extglob: true, value: Y, output: O }), e("parens");
+    };
+    if ($.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(q)) {
+      let Q = false, O = q.replace(yZ, (X, D, E, u, k, w1) => {
+        if (u === "\\")
+          return Q = true, X;
+        if (u === "?") {
+          if (D)
+            return D + u + (k ? I.repeat(k.length) : "");
+          if (w1 === 0)
+            return w + (k ? I.repeat(k.length) : "");
+          return I.repeat(E.length);
+        }
+        if (u === ".")
+          return F.repeat(E.length);
+        if (u === "*") {
+          if (D)
+            return D + u + (k ? y : "");
+          return y;
+        }
+        return D ? X : `\\${X}`;
+      });
+      if (Q === true)
+        if ($.unescape === true)
+          O = O.replace(/\\/g, "");
+        else
+          O = O.replace(/\\+/g, (X) => {
+            return X.length % 2 === 0 ? "\\\\" : X ? "\\" : "";
+          });
+      if (O === q && $.contains === true)
+        return W.output = q, W;
+      return W.output = r.wrapOutput(O, W, Z), W;
+    }
+    while (!l()) {
+      if (Y = R(), Y === "\0")
+        continue;
+      if (Y === "\\") {
+        let X = L();
+        if (X === "/" && $.bash !== true)
+          continue;
+        if (X === "." || X === ";")
+          continue;
+        if (!X) {
+          Y += "\\", f({ type: "text", value: Y });
+          continue;
+        }
+        let D = /^\\+/.exec(p()), E = 0;
+        if (D && D[0].length > 2) {
+          if (E = D[0].length, W.index += E, E % 2 !== 0)
+            Y += "\\";
+        }
+        if ($.unescape === true)
+          Y = R();
+        else
+          Y += R();
+        if (W.brackets === 0) {
+          f({ type: "text", value: Y });
+          continue;
+        }
+      }
+      if (W.brackets > 0 && (Y !== "]" || V.value === "[" || V.value === "[^")) {
+        if ($.posix !== false && Y === ":") {
+          let X = V.value.slice(1);
+          if (X.includes("[")) {
+            if (V.posix = true, X.includes(":")) {
+              let D = V.value.lastIndexOf("["), E = V.value.slice(0, D), u = V.value.slice(D + 2), k = NZ[u];
+              if (k) {
+                if (V.value = E + k, W.backtrack = true, R(), !z.output && U.indexOf(V) === 1)
+                  z.output = P;
+                continue;
+              }
+            }
+          }
+        }
+        if (Y === "[" && L() !== ":" || Y === "-" && L() === "]")
+          Y = `\\${Y}`;
+        if (Y === "]" && (V.value === "[" || V.value === "[^"))
+          Y = `\\${Y}`;
+        if ($.posix === true && Y === "!" && V.value === "[")
+          Y = "^";
+        V.value += Y, s({ value: Y });
+        continue;
+      }
+      if (W.quotes === 1 && Y !== '"') {
+        Y = r.escapeRegex(Y), V.value += Y, s({ value: Y });
+        continue;
+      }
+      if (Y === '"') {
+        if (W.quotes = W.quotes === 1 ? 0 : 1, $.keepQuotes === true)
+          f({ type: "text", value: Y });
+        continue;
+      }
+      if (Y === "(") {
+        W1("parens"), f({ type: "paren", value: Y });
+        continue;
+      }
+      if (Y === ")") {
+        if (W.parens === 0 && $.strictBrackets === true)
+          throw new SyntaxError($1("opening", "("));
+        let X = d[d.length - 1];
+        if (X && W.parens === X.parens + 1) {
+          Cq(d.pop());
+          continue;
+        }
+        f({ type: "paren", value: Y, output: W.parens ? ")" : "\\)" }), e("parens");
+        continue;
+      }
+      if (Y === "[") {
+        if ($.nobracket === true || !p().includes("]")) {
+          if ($.nobracket !== true && $.strictBrackets === true)
+            throw new SyntaxError($1("closing", "]"));
+          Y = `\\${Y}`;
+        } else
+          W1("brackets");
+        f({ type: "bracket", value: Y });
+        continue;
+      }
+      if (Y === "]") {
+        if ($.nobracket === true || V && V.type === "bracket" && V.value.length === 1) {
+          f({ type: "text", value: Y, output: `\\${Y}` });
+          continue;
+        }
+        if (W.brackets === 0) {
+          if ($.strictBrackets === true)
+            throw new SyntaxError($1("opening", "["));
+          f({ type: "text", value: Y, output: `\\${Y}` });
+          continue;
+        }
+        e("brackets");
+        let X = V.value.slice(1);
+        if (V.posix !== true && X[0] === "^" && !X.includes("/"))
+          Y = `/${Y}`;
+        if (V.value += Y, s({ value: Y }), $.literalBrackets === false || r.hasRegexChars(X))
+          continue;
+        let D = r.escapeRegex(V.value);
+        if (W.output = W.output.slice(0, -V.value.length), $.literalBrackets === true) {
+          W.output += D, V.value = D;
+          continue;
+        }
+        V.value = `(${B}${D}|${V.value})`, W.output += V.value;
+        continue;
+      }
+      if (Y === "{" && $.nobrace !== true) {
+        W1("braces");
+        let X = { type: "brace", value: Y, output: "(", outputIndex: W.output.length, tokensIndex: W.tokens.length };
+        b.push(X), f(X);
+        continue;
+      }
+      if (Y === "}") {
+        let X = b[b.length - 1];
+        if ($.nobrace === true || !X) {
+          f({ type: "text", value: Y, output: Y });
+          continue;
+        }
+        let D = ")";
+        if (X.dots === true) {
+          let E = U.slice(), u = [];
+          for (let k = E.length - 1;k >= 0; k--) {
+            if (U.pop(), E[k].type === "brace")
+              break;
+            if (E[k].type !== "dots")
+              u.unshift(E[k].value);
+          }
+          D = IZ(u, $), W.backtrack = true;
+        }
+        if (X.comma !== true && X.dots !== true) {
+          let E = W.output.slice(0, X.outputIndex), u = W.tokens.slice(X.tokensIndex);
+          X.value = X.output = "\\{", Y = D = "\\}", W.output = E;
+          for (let k of u)
+            W.output += k.output || k.value;
+        }
+        f({ type: "brace", value: Y, output: D }), e("braces"), b.pop();
+        continue;
+      }
+      if (Y === "|") {
+        if (d.length > 0)
+          d[d.length - 1].conditions++;
+        f({ type: "text", value: Y });
+        continue;
+      }
+      if (Y === ",") {
+        let X = Y, D = b[b.length - 1];
+        if (D && S[S.length - 1] === "braces")
+          D.comma = true, X = "|";
+        f({ type: "comma", value: Y, output: X });
+        continue;
+      }
+      if (Y === "/") {
+        if (V.type === "dot" && W.index === W.start + 1) {
+          W.start = W.index + 1, W.consumed = "", W.output = "", U.pop(), V = z;
+          continue;
+        }
+        f({ type: "slash", value: Y, output: H });
+        continue;
+      }
+      if (Y === ".") {
+        if (W.braces > 0 && V.type === "dot") {
+          if (V.value === ".")
+            V.output = F;
+          let X = b[b.length - 1];
+          V.type = "dots", V.output += Y, V.value += Y, X.dots = true;
+          continue;
+        }
+        if (W.braces + W.parens === 0 && V.type !== "bos" && V.type !== "slash") {
+          f({ type: "text", value: Y, output: F });
+          continue;
+        }
+        f({ type: "dot", value: Y, output: F });
+        continue;
+      }
+      if (Y === "?") {
+        if (!(V && V.value === "(") && $.noextglob !== true && L() === "(" && L(2) !== "?") {
+          z1("qmark", Y);
+          continue;
+        }
+        if (V && V.type === "paren") {
+          let D = L(), E = Y;
+          if (V.value === "(" && !/[!=<:]/.test(D) || D === "<" && !/<([!=]|\w+>)/.test(p()))
+            E = `\\${Y}`;
+          f({ type: "text", value: Y, output: E });
+          continue;
+        }
+        if ($.dot !== true && (V.type === "slash" || V.type === "bos")) {
+          f({ type: "qmark", value: Y, output: g });
+          continue;
+        }
+        f({ type: "qmark", value: Y, output: I });
+        continue;
+      }
+      if (Y === "!") {
+        if ($.noextglob !== true && L() === "(") {
+          if (L(2) !== "?" || !/[!=<:]/.test(L(3))) {
+            z1("negate", Y);
+            continue;
+          }
+        }
+        if ($.nonegate !== true && W.index === 0) {
+          Hq();
+          continue;
+        }
+      }
+      if (Y === "+") {
+        if ($.noextglob !== true && L() === "(" && L(2) !== "?") {
+          z1("plus", Y);
+          continue;
+        }
+        if (V && V.value === "(" || $.regex === false) {
+          f({ type: "plus", value: Y, output: T });
+          continue;
+        }
+        if (V && (V.type === "bracket" || V.type === "paren" || V.type === "brace") || W.parens > 0) {
+          f({ type: "plus", value: Y });
+          continue;
+        }
+        f({ type: "plus", value: T });
+        continue;
+      }
+      if (Y === "@") {
+        if ($.noextglob !== true && L() === "(" && L(2) !== "?") {
+          f({ type: "at", extglob: true, value: Y, output: "" });
+          continue;
+        }
+        f({ type: "text", value: Y });
+        continue;
+      }
+      if (Y !== "*") {
+        if (Y === "$" || Y === "^")
+          Y = `\\${Y}`;
+        let X = wZ.exec(p());
+        if (X)
+          Y += X[0], W.index += X[0].length;
+        f({ type: "text", value: Y });
+        continue;
+      }
+      if (V && (V.type === "globstar" || V.star === true)) {
+        V.type = "star", V.star = true, V.value += Y, V.output = y, W.backtrack = true, W.globstar = true, c(Y);
+        continue;
+      }
+      let Q = p();
+      if ($.noextglob !== true && /^\([^?]/.test(Q)) {
+        z1("star", Y);
+        continue;
+      }
+      if (V.type === "star") {
+        if ($.noglobstar === true) {
+          c(Y);
+          continue;
+        }
+        let X = V.prev, D = X.prev, E = X.type === "slash" || X.type === "bos", u = D && (D.type === "star" || D.type === "globstar");
+        if ($.bash === true && (!E || Q[0] && Q[0] !== "/")) {
+          f({ type: "star", value: Y, output: "" });
+          continue;
+        }
+        let k = W.braces > 0 && (X.type === "comma" || X.type === "brace"), w1 = d.length && (X.type === "pipe" || X.type === "paren");
+        if (!E && X.type !== "paren" && !k && !w1) {
+          f({ type: "star", value: Y, output: "" });
+          continue;
+        }
+        while (Q.slice(0, 3) === "/**") {
+          let U1 = q[W.index + 4];
+          if (U1 && U1 !== "/")
+            break;
+          Q = Q.slice(3), c("/**", 3);
+        }
+        if (X.type === "bos" && l()) {
+          V.type = "globstar", V.value += Y, V.output = x($), W.output = V.output, W.globstar = true, c(Y);
+          continue;
+        }
+        if (X.type === "slash" && X.prev.type !== "bos" && !u && l()) {
+          W.output = W.output.slice(0, -(X.output + V.output).length), X.output = `(?:${X.output}`, V.type = "globstar", V.output = x($) + ($.strictSlashes ? ")" : "|$)"), V.value += Y, W.globstar = true, W.output += X.output + V.output, c(Y);
+          continue;
+        }
+        if (X.type === "slash" && X.prev.type !== "bos" && Q[0] === "/") {
+          let U1 = Q[1] !== undefined ? "|$" : "";
+          W.output = W.output.slice(0, -(X.output + V.output).length), X.output = `(?:${X.output}`, V.type = "globstar", V.output = `${x($)}${H}|${H}${U1})`, V.value += Y, W.output += X.output + V.output, W.globstar = true, c(Y + R()), f({ type: "slash", value: "/", output: "" });
+          continue;
+        }
+        if (X.type === "bos" && Q[0] === "/") {
+          V.type = "globstar", V.value += Y, V.output = `(?:^|${H}|${x($)}${H})`, W.output = V.output, W.globstar = true, c(Y + R()), f({ type: "slash", value: "/", output: "" });
+          continue;
+        }
+        W.output = W.output.slice(0, -V.output.length), V.type = "globstar", V.output = x($), V.value += Y, W.output += V.output, W.globstar = true, c(Y);
+        continue;
+      }
+      let O = { type: "star", value: Y, output: y };
+      if ($.bash === true) {
+        if (O.output = ".*?", V.type === "bos" || V.type === "slash")
+          O.output = m + O.output;
+        f(O);
+        continue;
+      }
+      if (V && (V.type === "bracket" || V.type === "paren") && $.regex === true) {
+        O.output = Y, f(O);
+        continue;
+      }
+      if (W.index === W.start || V.type === "slash" || V.type === "dot") {
+        if (V.type === "dot")
+          W.output += h, V.output += h;
+        else if ($.dot === true)
+          W.output += C, V.output += C;
+        else
+          W.output += m, V.output += m;
+        if (L() !== "*")
+          W.output += P, V.output += P;
+      }
+      f(O);
+    }
+    while (W.brackets > 0) {
+      if ($.strictBrackets === true)
+        throw new SyntaxError($1("closing", "]"));
+      W.output = r.escapeLast(W.output, "["), e("brackets");
+    }
+    while (W.parens > 0) {
+      if ($.strictBrackets === true)
+        throw new SyntaxError($1("closing", ")"));
+      W.output = r.escapeLast(W.output, "("), e("parens");
+    }
+    while (W.braces > 0) {
+      if ($.strictBrackets === true)
+        throw new SyntaxError($1("closing", "}"));
+      W.output = r.escapeLast(W.output, "{"), e("braces");
+    }
+    if ($.strictSlashes !== true && (V.type === "star" || V.type === "bracket"))
+      f({ type: "maybe_slash", value: "", output: `${H}?` });
+    if (W.backtrack === true) {
+      W.output = "";
+      for (let Q of W.tokens)
+        if (W.output += Q.output != null ? Q.output : Q.value, Q.suffix)
+          W.output += Q.suffix;
+    }
+    return W;
+  };
+  E1.fastpaths = (q, Z) => {
+    let $ = { ...Z }, J = typeof $.maxLength === "number" ? Math.min(M1, $.maxLength) : M1, j = q.length;
+    if (j > J)
+      throw new SyntaxError(`Input length: ${j}, exceeds maximum allowed length: ${J}`);
+    q = o0[q] || q;
+    let { DOT_LITERAL: z, SLASH_LITERAL: U, ONE_CHAR: B, DOTS_SLASH: M, NO_DOT: K, NO_DOTS: F, NO_DOTS_SLASH: T, STAR: H, START_ANCHOR: P } = G1.globChars($.windows), N = $.dot ? F : K, G = $.dot ? T : K, h = $.capture ? "" : "?:", C = { negated: false, prefix: "" }, I = $.bash === true ? ".*?" : H;
+    if ($.capture)
+      I = `(${I})`;
+    let g = (m) => {
+      if (m.noglobstar === true)
+        return I;
+      return `(${h}(?:(?!${P}${m.dot ? M : z}).)*?)`;
+    }, i = (m) => {
+      switch (m) {
+        case "*":
+          return `${N}${B}${I}`;
+        case ".*":
+          return `${z}${B}${I}`;
+        case "*.*":
+          return `${N}${I}${z}${B}${I}`;
+        case "*/*":
+          return `${N}${I}${U}${B}${G}${I}`;
+        case "**":
+          return N + g($);
+        case "**/*":
+          return `(?:${N}${g($)}${U})?${G}${B}${I}`;
+        case "**/*.*":
+          return `(?:${N}${g($)}${U})?${G}${I}${z}${B}${I}`;
+        case "**/.*":
+          return `(?:${N}${g($)}${U})?${z}${B}${I}`;
+        default: {
+          let w = /^(.*?)\.(\w+)$/.exec(m);
+          if (!w)
+            return;
+          let y = i(w[1]);
+          if (!y)
+            return;
+          return y + z + w[2];
+        }
+      }
+    }, v = r.removePrefix(q, C), x = i(v);
+    if (x && $.strictSlashes !== true)
+      x += `${U}?`;
+    return x;
+  };
+  e0.exports = E1;
+});
+var Zq = _((H8, $q) => {
+  var DZ = s0(), S1 = t0(), qq = j1(), fZ = J1(), HZ = (q) => q && typeof q === "object" && !Array.isArray(q), A = (q, Z, $ = false) => {
+    if (Array.isArray(q)) {
+      let F = q.map((H) => A(H, Z, $));
+      return (H) => {
+        for (let P of F) {
+          let N = P(H);
+          if (N)
+            return N;
+        }
+        return false;
+      };
+    }
+    let J = HZ(q) && q.tokens && q.input;
+    if (q === "" || typeof q !== "string" && !J)
+      throw new TypeError("Expected pattern to be a non-empty string");
+    let j = Z || {}, z = j.windows, U = J ? A.compileRe(q, Z) : A.makeRe(q, Z, false, true), B = U.state;
+    delete U.state;
+    let M = () => false;
+    if (j.ignore) {
+      let F = { ...Z, ignore: null, onMatch: null, onResult: null };
+      M = A(j.ignore, F, $);
+    }
+    let K = (F, T = false) => {
+      let { isMatch: H, match: P, output: N } = A.test(F, U, Z, { glob: q, posix: z }), G = { glob: q, state: B, regex: U, posix: z, input: F, output: N, match: P, isMatch: H };
+      if (typeof j.onResult === "function")
+        j.onResult(G);
+      if (H === false)
+        return G.isMatch = false, T ? G : false;
+      if (M(F)) {
+        if (typeof j.onIgnore === "function")
+          j.onIgnore(G);
+        return G.isMatch = false, T ? G : false;
+      }
+      if (typeof j.onMatch === "function")
+        j.onMatch(G);
+      return T ? G : true;
+    };
+    if ($)
+      K.state = B;
+    return K;
+  };
+  A.test = (q, Z, $, { glob: J, posix: j } = {}) => {
+    if (typeof q !== "string")
+      throw new TypeError("Expected input to be a string");
+    if (q === "")
+      return { isMatch: false, output: "" };
+    let z = $ || {}, U = z.format || (j ? qq.toPosixSlashes : null), B = q === J, M = B && U ? U(q) : q;
+    if (B === false)
+      M = U ? U(q) : q, B = M === J;
+    if (B === false || z.capture === true)
+      if (z.matchBase === true || z.basename === true)
+        B = A.matchBase(q, Z, $, j);
+      else
+        B = Z.exec(M);
+    return { isMatch: Boolean(B), match: B, output: M };
+  };
+  A.matchBase = (q, Z, $) => {
+    return (Z instanceof RegExp ? Z : A.makeRe(Z, $)).test(qq.basename(q));
+  };
+  A.isMatch = (q, Z, $) => A(Z, $)(q);
+  A.parse = (q, Z) => {
+    if (Array.isArray(q))
+      return q.map(($) => A.parse($, Z));
+    return S1(q, { ...Z, fastpaths: false });
+  };
+  A.scan = (q, Z) => DZ(q, Z);
+  A.compileRe = (q, Z, $ = false, J = false) => {
+    if ($ === true)
+      return q.output;
+    let j = Z || {}, z = j.contains ? "" : "^", U = j.contains ? "" : "$", B = `${z}(?:${q.output})${U}`;
+    if (q && q.negated === true)
+      B = `^(?!${B}).*$`;
+    let M = A.toRegex(B, Z);
+    if (J === true)
+      M.state = q;
+    return M;
+  };
+  A.makeRe = (q, Z = {}, $ = false, J = false) => {
+    if (!q || typeof q !== "string")
+      throw new TypeError("Expected a non-empty string");
+    let j = { negated: false, fastpaths: true };
+    if (Z.fastpaths !== false && (q[0] === "." || q[0] === "*"))
+      j.output = S1.fastpaths(q, Z);
+    if (!j.output)
+      j = S1(q, Z);
+    return A.compileRe(j, Z, $, J);
+  };
+  A.toRegex = (q, Z) => {
+    try {
+      let $ = Z || {};
+      return new RegExp(q, $.flags || ($.nocase ? "i" : ""));
+    } catch ($) {
+      if (Z && Z.debug === true)
+        throw $;
+      return /$^/;
+    }
+  };
+  A.constants = fZ;
+  $q.exports = A;
+});
+var Y1 = _((C8, Vq) => {
+  var Jq = Zq(), CZ = j1();
+  function jq(q, Z, $ = false) {
+    if (Z && (Z.windows === null || Z.windows === undefined))
+      Z = { ...Z, windows: CZ.isWindows() };
+    return Jq(q, Z, $);
+  }
+  Object.assign(jq, Jq);
+  Vq.exports = jq;
+});
+var Bq = _((Uq) => {
+  Object.defineProperty(Uq, "__esModule", { value: true });
+  Uq.Builder = undefined;
+  var LZ = import.meta.require("path"), Yq = v0(), Wq = null;
+  try {
+    import.meta.require.resolve("picomatch"), Wq = Y1();
+  } catch (q) {
+  }
+
+  class zq {
+    globCache = {};
+    options = { maxDepth: 1 / 0, suppressErrors: true, pathSeparator: LZ.sep, filters: [] };
+    globFunction;
+    constructor(q) {
+      this.options = { ...this.options, ...q }, this.globFunction = this.options.globFunction;
+    }
+    group() {
+      return this.options.group = true, this;
+    }
+    withPathSeparator(q) {
+      return this.options.pathSeparator = q, this;
+    }
+    withBasePath() {
+      return this.options.includeBasePath = true, this;
+    }
+    withRelativePaths() {
+      return this.options.relativePaths = true, this;
+    }
+    withDirs() {
+      return this.options.includeDirs = true, this;
+    }
+    withMaxDepth(q) {
+      return this.options.maxDepth = q, this;
+    }
+    withMaxFiles(q) {
+      return this.options.maxFiles = q, this;
+    }
+    withFullPaths() {
+      return this.options.resolvePaths = true, this.options.includeBasePath = true, this;
+    }
+    withErrors() {
+      return this.options.suppressErrors = false, this;
+    }
+    withSymlinks({ resolvePaths: q = true } = {}) {
+      return this.options.resolveSymlinks = true, this.options.useRealPaths = q, this.withFullPaths();
+    }
+    withAbortSignal(q) {
+      return this.options.signal = q, this;
+    }
+    normalize() {
+      return this.options.normalizePath = true, this;
+    }
+    filter(q) {
+      return this.options.filters.push(q), this;
+    }
+    onlyDirs() {
+      return this.options.excludeFiles = true, this.options.includeDirs = true, this;
+    }
+    exclude(q) {
+      return this.options.exclude = q, this;
+    }
+    onlyCounts() {
+      return this.options.onlyCounts = true, this;
+    }
+    crawl(q) {
+      return new Yq.APIBuilder(q || ".", this.options);
+    }
+    withGlobFunction(q) {
+      return this.globFunction = q, this;
+    }
+    crawlWithOptions(q, Z) {
+      return this.options = { ...this.options, ...Z }, new Yq.APIBuilder(q || ".", this.options);
+    }
+    glob(...q) {
+      if (this.globFunction)
+        return this.globWithOptions(q);
+      return this.globWithOptions(q, ...[{ dot: true }]);
+    }
+    globWithOptions(q, ...Z) {
+      let $ = this.globFunction || Wq;
+      if (!$)
+        throw new Error("Please specify a glob function to use glob matching.");
+      var J = this.globCache[q.join("\0")];
+      if (!J)
+        J = $(q, ...Z), this.globCache[q.join("\0")] = J;
+      return this.options.filters.push((j) => J(j)), this;
+    }
+  }
+  Uq.Builder = zq;
+});
+var Fq = _((Qq) => {
+  Object.defineProperty(Qq, "__esModule", { value: true });
+});
+var Kq = _((a) => {
+  var PZ = a && a.__createBinding || (Object.create ? function(q, Z, $, J) {
+    if (J === undefined)
+      J = $;
+    var j = Object.getOwnPropertyDescriptor(Z, $);
+    if (!j || ("get" in j ? !Z.__esModule : j.writable || j.configurable))
+      j = { enumerable: true, get: function() {
+        return Z[$];
+      } };
+    Object.defineProperty(q, J, j);
+  } : function(q, Z, $, J) {
+    if (J === undefined)
+      J = $;
+    q[J] = Z[$];
+  }), TZ = a && a.__exportStar || function(q, Z) {
+    for (var $ in q)
+      if ($ !== "default" && !Object.prototype.hasOwnProperty.call(Z, $))
+        PZ(Z, q, $);
+  };
+  Object.defineProperty(a, "__esModule", { value: true });
+  a.fdir = undefined;
+  var OZ = Bq();
+  Object.defineProperty(a, "fdir", { enumerable: true, get: function() {
+    return OZ.Builder;
+  } });
+  TZ(Fq(), a);
+});
+async function k1(q, Z) {
+  await Bun.write(q, Z);
+}
+async function y1(q) {
+  let Z = q ?? Z1.root, $ = await _q(Z, { withFileTypes: true }), J = await Promise.all($.map((j) => {
+    let z = g1(Z, j.name);
+    return j.isDirectory() ? y1(z) : z;
+  }));
+  return Array.prototype.concat(...J).filter((j) => Eq(j) === ".ts");
+}
+async function v1(q) {
+  try {
+    let Z = q?.tsconfigPath || g1(q?.root ?? Sq.cwd(), "tsconfig.json"), $ = await Rq(Z, "utf-8");
+    return JSON.parse($).compilerOptions?.isolatedDeclarations === true;
+  } catch (Z) {
+    return console.log("Error reading tsconfig.json:", Z), false;
+  }
+}
+function m1(q) {
+  let J = q.split("\n").map((j) => {
+    if (j = j.trimEnd(), j.startsWith("export interface") || j.startsWith("export type")) {
+      let z = j.split("{");
+      if (z.length > 1)
+        return `${z[0].trim()} {${z[1]}`;
+    }
+    if (j.endsWith(";"))
+      j = j.slice(0, -1);
+    return j;
+  }).join("\n");
+  return J = J.replace(/\n{3,}/g, "\n\n"), J = J.replace(/\/\*\*\n([^*]*)(\n \*\/)/g, (j, z) => {
+    return `/**\n${z.split("\n").map((B) => ` *${B.trim() ? ` ${B.trim()}` : ""}`).join("\n")}\n */`;
+  }), `${J.trim()}\n`;
+}
+function u1(q) {
+  let Z = q.split("\n");
+  return Z.map(($, J) => {
+    if (J === 0)
+      return "/**";
+    if (J === Z.length - 1)
+      return " */";
+    return ` * ${$.replace(/^\s*\*?\s?/, "").trim()}`;
+  }).join("\n");
+}
+function Q1(q, ...Z) {
+  if (!Z.length)
+    return q;
+  let $ = Z.shift();
+  if (B1(q) && B1($)) {
+    for (let J in $)
+      if (Object.prototype.hasOwnProperty.call($, J)) {
+        let j = $[J];
+        if (B1(j) && B1(q[J]))
+          q[J] = Q1(q[J], j);
+        else
+          q[J] = j;
+      }
+  }
+  return Q1(q, ...Z);
+}
+function B1(q) {
+  return q && typeof q === "object" && !Array.isArray(q);
+}
+async function bq({ name: q, cwd: Z, defaultConfig: $ }) {
+  let J = Z ?? I1.cwd(), j = xq(J, `${q}.config`);
+  if (Aq(j))
+    try {
+      let z = await import(j), U = z.default || z;
+      return Q1($, U);
+    } catch (z) {
+      console.error(`Error loading config from ${j}:`, z);
+    }
+  return $;
+}
+var Z1 = await bq({ name: "dts", cwd: I1.cwd(), defaultConfig: { cwd: I1.cwd(), root: "./src", entrypoints: ["**/*.ts"], outdir: "./dist", keepComments: true, clean: true, tsconfigPath: "./tsconfig.json" } });
+async function h1(q) {
+  let Z = await gq(q, "utf-8"), $ = "", J = new Set, j = new Map, z = /export\s*(?:\*|\{[^}]*\})\s*from\s*['"][^'"]+['"]/g, U = Z.match(z) || [];
+  $ += `${U.join("\n")}\n`;
+  let B = /import\s+(?:(type)\s+)?(?:(\{[^}]+\})|(\w+))(?:\s*,\s*(?:(\{[^}]+\})|(\w+)))?\s+from\s+['"]([^'"]+)['"]/g;
+  Array.from(Z.matchAll(B)).forEach(([, H, P, N, G, h, C]) => {
+    if (!j.has(C))
+      j.set(C, new Set);
+    let I = (g, i) => {
+      if (g)
+        g.replace(/[{}]/g, "").split(",").map((x) => {
+          let [m, w] = x.split(" as ").map((y) => y.trim());
+          return { name: m.replace(/^type\s+/, ""), alias: w || m.replace(/^type\s+/, "") };
+        }).forEach(({ name: x }) => {
+          j.get(C).add(x);
+        });
+    };
+    if (I(P, !!H), I(G, !!H), N)
+      j.get(C).add(N);
+    if (h)
+      j.get(C).add(h);
+  });
+  let K = Z.split("\n"), F = 0;
+  while (F < K.length) {
+    let H = "", P = "";
+    if (K[F].trim().startsWith("/**")) {
+      while (F < K.length && !K[F].includes("*/"))
+        H += `${K[F]}\n`, F++;
+      H += `${K[F]}\n`, F++;
+    }
+    if (F < K.length && K[F].trim().startsWith("export")) {
+      P = K[F], F++;
+      while (F < K.length && !K[F].trim().startsWith("export") && !K[F].trim().startsWith("/**"))
+        P += `\n${K[F]}`, F++;
+    }
+    if (P) {
+      let N = H ? u1(H.trim()) : "", G = P.trim();
+      if (G.startsWith("export function") || G.startsWith("export async function")) {
+        G = G.replace(/^export\s+(async\s+)?function/, "export declare function");
+        let I = G.match(/^.*?\)/);
+        if (I) {
+          let g = I[0].slice(I[0].indexOf("(") + 1, -1);
+          g = g.replace(/\s*=[^,)]+/g, "");
+          let i = G.match(/\):\s*([^{]+)/);
+          G = `export declare function ${G.split("function")[1].split("(")[0].trim()}(${g})${i ? `: ${i[1].trim()}` : ""};`;
+        }
+      } else if (G.startsWith("export const") || G.startsWith("export let") || G.startsWith("export var"))
+        G = G.replace(/^export\s+(const|let|var)/, "export declare $1"), G = `${G.split("=")[0].trim()};`;
+      $ += `${N}\n${G}\n\n`;
+      let h = /\b([A-Z]\w+)(?:<[^>]*>)?/g;
+      Array.from(G.matchAll(h)).forEach(([, I]) => J.add(I));
+    }
+    if (!P && !H)
+      F++;
+  }
+  let T = "";
+  if (j.forEach((H, P) => {
+    let N = [...H].filter((G) => J.has(G));
+    if (N.length > 0)
+      T += `import type { ${N.join(", ")} } from '${P}'\n`;
+  }), T)
+    $ = `${T}\n${$}`;
+  return m1($);
+}
+var wq = X1(Kq(), 1);
+var A1 = X1(Y1(), 1);
+var yq = X1(Y1(), 1);
+var _Z = /\\(?![()[\]{}!+@])/g;
+function RZ(q) {
+  return Iq(q);
+}
+function EZ(q) {
+  return Dq(q).replace(_Z, "/");
+}
+var _8 = process.platform === "win32" ? EZ : RZ;
+var SZ = /(?<!\\)([()[\]{}*?|]|^!|[!+@](?=\()|\\(?![()[\]{}!*+?@|]))/g;
+var AZ = /(?<!\\)([()[\]{}]|^!|[!+@](?=\())/g;
+var Iq = (q) => q.replace(SZ, "\\$&");
+var Dq = (q) => q.replace(AZ, "\\$&");
+var R8 = process.platform === "win32" ? Dq : Iq;
+function xZ(q, Z) {
+  if ((Z == null ? undefined : Z.caseSensitiveMatch) === false)
+    return true;
+  let $ = yq.default.scan(q);
+  return $.isGlob || $.negated;
+}
+function Gq(q, Z, $, J, j) {
+  var z;
+  let U = q;
+  if (q.endsWith("/"))
+    U = q.slice(0, -1);
+  if (!U.endsWith("*") && Z)
+    U += "/**";
+  if (Nq.isAbsolute(U.replace(/\\(?=[()[\]{}!*+?@|])/g, "")))
+    U = N1.relative($, U);
+  else
+    U = N1.normalize(U);
+  let B = /^(\/?\.\.)+/.exec(U);
+  if (B == null ? undefined : B[0]) {
+    let M = N1.join($, B[0]);
+    if (J.root.length > M.length)
+      J.root = M, J.depthOffset = -(B[0].length + 1) / 3;
+  } else if (!j && J.depthOffset >= 0) {
+    let M = U.split("/");
+    (z = J.commonPath) != null || (J.commonPath = M);
+    let K = [];
+    for (let F = 0;F < Math.min(J.commonPath.length, M.length); F++) {
+      let T = M[F];
+      if (T === "**" && !M[F + 1]) {
+        K.pop();
+        break;
+      }
+      if (T !== J.commonPath[F] || xZ(T) || F === M.length - 1)
+        break;
+      K.push(T);
+    }
+    J.depthOffset = K.length, J.commonPath = K, J.root = K.length > 0 ? `${$}/${K.join("/")}` : $;
+  }
+  return U;
+}
+function bZ({ patterns: q, ignore: Z = [], expandDirectories: $ = true }, J, j) {
+  if (typeof q === "string")
+    q = [q];
+  if (typeof Z === "string")
+    Z = [Z];
+  let z = [], U = Z.map((B) => Gq(B, $, J, j, true));
+  if (!q)
+    return { match: ["**/*"], ignore: U };
+  for (let B of q)
+    if (B = Gq(B, $, J, j, false), B.startsWith("!") && B[1] !== "(")
+      U.push(B.slice(1));
+    else
+      z.push(B);
+  return { match: z, ignore: U };
+}
+function x1(q, Z, $) {
+  return N1.relative(Z, `${$}/${q}`);
+}
+function Mq(q, Z, $, J, j) {
+  let z = j ? q.slice($.length + 1) || "." : q;
+  if ($ === Z)
+    return J && z !== "." ? z.slice(0, -1) : z;
+  return x1(z, Z, $);
+}
+function gZ(q, Z, $) {
+  let J = { root: Z, commonPath: null, depthOffset: 0 }, j = bZ(q, Z, J), z = A1.default(j.match, { dot: q.dot, nocase: q.caseSensitiveMatch === false, ignore: j.ignore }), U = A1.default(j.ignore, { dot: q.dot, nocase: q.caseSensitiveMatch === false }), B = { filters: [(K, F) => z(Mq(K, Z, J.root, F, q.absolute))], exclude: (K, F) => U(Mq(F, Z, J.root, true, true)), pathSeparator: "/", relativePaths: true };
+  if (q.deep)
+    B.maxDepth = Math.round(q.deep - J.depthOffset);
+  if (q.absolute)
+    B.relativePaths = false, B.resolvePaths = true, B.includeBasePath = true;
+  if (q.followSymbolicLinks === false)
+    B.resolveSymlinks = false, B.excludeSymlinks = true;
+  if (q.onlyDirectories)
+    B.excludeFiles = true, B.includeDirs = true;
+  else if (q.onlyFiles === false)
+    B.includeDirs = true;
+  J.root = J.root.replace(/\\/g, "");
+  let M = new wq.fdir(B).crawl(J.root);
+  if (Z === J.root || q.absolute)
+    return $ ? M.sync() : M.withPromise();
+  return $ ? M.sync().map((K) => x1(K, Z, J.root) + (!K || K.endsWith("/") ? "/" : "")) : M.withPromise().then((K) => K.map((F) => x1(F, Z, J.root) + (!F || F.endsWith("/") ? "/" : "")));
+}
+async function fq(q, Z) {
+  if (q && (Z == null ? undefined : Z.patterns))
+    throw new Error("Cannot pass patterns as both an argument and an option");
+  let $ = Array.isArray(q) || typeof q === "string" ? { ...Z, patterns: q } : q, J = $.cwd ? Nq.resolve($.cwd).replace(/\\/g, "/") : process.cwd().replace(/\\/g, "/");
+  return gZ($, J, false);
+}
+async function lZ(q) {
+  try {
+    if (!await v1(q)) {
+      console.error("Error: isolatedModules must be set to true in your tsconfig.json. Ensure `tsc --noEmit` does not output any errors.");
+      return;
+    }
+    if (q?.clean)
+      await vZ(q.outdir, { recursive: true, force: true });
+    let $;
+    if (q?.entrypoints)
+      $ = await fq(q.entrypoints, { cwd: q.root ?? q.cwd, absolute: true });
+    else
+      $ = await y1(q?.root);
+    for (let J of $) {
+      let j = await h1(J);
+      if (j) {
+        let z = dZ(q?.root ?? "./src", J), U = hZ(z), B = uZ(q?.outdir ?? "./dist", `${U.name}.d.ts`);
+        await kZ(mZ(B), { recursive: true }), await k1(B, j);
+      } else
+        console.warn(`No declarations extracted for ${J}`);
+    }
+  } catch (Z) {
+    console.error("Error generating declarations:", Z);
+  }
+}
+async function v8(q) {
+  await lZ({ ...Z1, ...q });
+}
+
+// src/index.ts
+function dts(options) {
+  return {
+    name: "bun-plugin-dtsx",
+    async setup(build) {
+      const cwd = options?.cwd ?? process2.cwd();
+      const root = options?.root ?? build.config.root;
+      const entrypoints = options?.entrypoints ?? build.config.entrypoints;
+      const outdir = options?.outdir ?? build.config.outdir;
+      const keepComments = options?.keepComments ?? true;
+      const clean = options?.clean ?? false;
+      const tsconfigPath = options?.tsconfigPath ?? "./tsconfig.json";
+      await v8({
+        ...options,
+        cwd,
+        root,
+        entrypoints,
+        outdir,
+        keepComments,
+        clean,
+        tsconfigPath
+      });
+    }
+  };
+}
+var src_default = dts;
+export {
+  dts,
+  src_default as default
+};