tinker-token-usage 0.1.2 → 0.1.3

package/dist/preload/index-CYePjqCs.mjs

@@ -0,0 +1,1501 @@
+var ae = Object.defineProperty;
+var ce = (t, s, e) => s in t ? ae(t, s, { enumerable: !0, configurable: !0, writable: !0, value: e }) : t[s] = e;
+var D = (t, s, e) => ce(t, typeof s != "symbol" ? s + "" : s, e);
+import * as le from "fs";
+import J from "fs";
+import Nt, { sep as Bt, basename as pe, dirname as bt, resolve as fe, normalize as he, relative as ge, posix as V } from "path";
+import { fileURLToPath as Ae } from "url";
+import { createRequire as ye } from "module";
+var Ht = /* @__PURE__ */ ye(import.meta.url);
+function _e(t) {
+  let s = he(t);
+  return s.length > 1 && s[s.length - 1] === Bt && (s = s.substring(0, s.length - 1)), s;
+}
+const Re = /[\\/]/g;
+function Ft(t, s) {
+  return t.replace(Re, s);
+}
+const de = /^[a-z]:[\\/]$/i;
+function Se(t) {
+  return t === "/" || de.test(t);
+}
+function At(t, s) {
+  const { resolvePaths: e, normalizePath: n, pathSeparator: o } = s, r = process.platform === "win32" && t.includes("/") || t.startsWith(".");
+  if (e && (t = fe(t)), (n || r) && (t = _e(t)), t === ".") return "";
+  const c = t[t.length - 1] !== o;
+  return Ft(c ? t + o : t, o);
+}
+function Mt(t, s) {
+  return s + t;
+}
+function Ee(t, s) {
+  return function(e, n) {
+    return n.startsWith(t) ? n.slice(t.length) + e : Ft(ge(t, n), s.pathSeparator) + s.pathSeparator + e;
+  };
+}
+function be(t) {
+  return t;
+}
+function me(t, s, e) {
+  return s + t + e;
+}
+function Ce(t, s) {
+  const { relativePaths: e, includeBasePath: n } = s;
+  return e && t ? Ee(t, s) : n ? Mt : be;
+}
+function $e(t) {
+  return function(s, e) {
+    e.push(s.substring(t.length) || ".");
+  };
+}
+function xe(t) {
+  return function(s, e, n) {
+    const o = s.substring(t.length) || ".";
+    n.every((r) => r(o, !0)) && e.push(o);
+  };
+}
+const ve = (t, s) => {
+  s.push(t || ".");
+}, He = (t, s, e) => {
+  const n = t || ".";
+  e.every((o) => o(n, !0)) && s.push(n);
+}, we = () => {
+};
+function Le(t, s) {
+  const { includeDirs: e, filters: n, relativePaths: o } = s;
+  return e ? o ? n && n.length ? xe(t) : $e(t) : n && n.length ? He : ve : we;
+}
+const Pe = (t, s, e, n) => {
+  n.every((o) => o(t, !1)) && e.files++;
+}, Te = (t, s, e, n) => {
+  n.every((o) => o(t, !1)) && s.push(t);
+}, ke = (t, s, e, n) => {
+  e.files++;
+}, Oe = (t, s) => {
+  s.push(t);
+}, De = () => {
+};
+function Ie(t) {
+  const { excludeFiles: s, filters: e, onlyCounts: n } = t;
+  return s ? De : e && e.length ? n ? Pe : Te : n ? ke : Oe;
+}
+const Ne = (t) => t, Be = () => [""].slice(0, 0);
+function Fe(t) {
+  return t.group ? Be : Ne;
+}
+const Me = (t, s, e) => {
+  t.push({
+    directory: s,
+    files: e,
+    dir: s
+  });
+}, Ge = () => {
+};
+function We(t) {
+  return t.group ? Me : Ge;
+}
+const Ue = function(t, s, e) {
+  const { queue: n, fs: o, options: { suppressErrors: r } } = s;
+  n.enqueue(), o.realpath(t, (c, l) => {
+    if (c) return n.dequeue(r ? null : c, s);
+    o.stat(l, (h, R) => {
+      if (h) return n.dequeue(r ? null : h, s);
+      if (R.isDirectory() && Gt(t, l, s)) return n.dequeue(null, s);
+      e(R, l), n.dequeue(null, s);
+    });
+  });
+}, Ke = function(t, s, e) {
+  const { queue: n, fs: o, options: { suppressErrors: r } } = s;
+  n.enqueue();
+  try {
+    const c = o.realpathSync(t), l = o.statSync(c);
+    if (l.isDirectory() && Gt(t, c, s)) return;
+    e(l, c);
+  } catch (c) {
+    if (!r) throw c;
+  }
+};
+function qe(t, s) {
+  return !t.resolveSymlinks || t.excludeSymlinks ? null : s ? Ke : Ue;
+}
+function Gt(t, s, e) {
+  if (e.options.useRealPaths) return Xe(s, e);
+  let n = bt(t), o = 1;
+  for (; n !== e.root && o < 2; ) {
+    const r = e.symlinks.get(n);
+    !!r && (r === s || r.startsWith(s) || s.startsWith(r)) ? o++ : n = bt(n);
+  }
+  return e.symlinks.set(t, s), o > 1;
+}
+function Xe(t, s) {
+  return s.visited.includes(t + s.options.pathSeparator);
+}
+const Qe = (t) => t.counts, je = (t) => t.groups, ze = (t) => t.paths, Ye = (t) => t.paths.slice(0, t.options.maxFiles), Ze = (t, s, e) => (pt(s, e, t.counts, t.options.suppressErrors), null), Ve = (t, s, e) => (pt(s, e, t.paths, t.options.suppressErrors), null), Je = (t, s, e) => (pt(s, e, t.paths.slice(0, t.options.maxFiles), t.options.suppressErrors), null), ts = (t, s, e) => (pt(s, e, t.groups, t.options.suppressErrors), null);
+function pt(t, s, e, n) {
+  s(t && !n ? t : null, e);
+}
+function es(t, s) {
+  const { onlyCounts: e, group: n, maxFiles: o } = t;
+  return e ? s ? Qe : Ze : n ? s ? je : ts : o ? s ? Ye : Je : s ? ze : Ve;
+}
+const Wt = { withFileTypes: !0 }, ss = (t, s, e, n, o) => {
+  if (t.queue.enqueue(), n < 0) return t.queue.dequeue(null, t);
+  const { fs: r } = t;
+  t.visited.push(s), t.counts.directories++, r.readdir(s || ".", Wt, (c, l = []) => {
+    o(l, e, n), t.queue.dequeue(t.options.suppressErrors ? null : c, t);
+  });
+}, ns = (t, s, e, n, o) => {
+  const { fs: r } = t;
+  if (n < 0) return;
+  t.visited.push(s), t.counts.directories++;
+  let c = [];
+  try {
+    c = r.readdirSync(s || ".", Wt);
+  } catch (l) {
+    if (!t.options.suppressErrors) throw l;
+  }
+  o(c, e, n);
+};
+function rs(t) {
+  return t ? ns : ss;
+}
+var os = class {
+  constructor(t) {
+    D(this, "count", 0);
+    this.onQueueEmpty = t;
+  }
+  enqueue() {
+    return this.count++, this.count;
+  }
+  dequeue(t, s) {
+    this.onQueueEmpty && (--this.count <= 0 || t) && (this.onQueueEmpty(t, s), t && (s.controller.abort(), this.onQueueEmpty = void 0));
+  }
+}, is = class {
+  constructor() {
+    D(this, "_files", 0);
+    D(this, "_directories", 0);
+  }
+  set files(t) {
+    this._files = t;
+  }
+  get files() {
+    return this._files;
+  }
+  set directories(t) {
+    this._directories = t;
+  }
+  get directories() {
+    return this._directories;
+  }
+  /**
+  * @deprecated use `directories` instead
+  */
+  /* c8 ignore next 3 */
+  get dirs() {
+    return this._directories;
+  }
+}, us = class {
+  constructor() {
+    D(this, "aborted", !1);
+  }
+  abort() {
+    this.aborted = !0;
+  }
+}, Ut = class {
+  constructor(t, s, e) {
+    D(this, "root");
+    D(this, "isSynchronous");
+    D(this, "state");
+    D(this, "joinPath");
+    D(this, "pushDirectory");
+    D(this, "pushFile");
+    D(this, "getArray");
+    D(this, "groupFiles");
+    D(this, "resolveSymlink");
+    D(this, "walkDirectory");
+    D(this, "callbackInvoker");
+    D(this, "walk", (t, s, e) => {
+      const { paths: n, options: { filters: o, resolveSymlinks: r, excludeSymlinks: c, exclude: l, maxFiles: h, signal: R, useRealPaths: g, pathSeparator: E }, controller: A } = this.state;
+      if (A.aborted || R && R.aborted || h && n.length > h) return;
+      const b = this.getArray(this.state.paths);
+      for (let d = 0; d < t.length; ++d) {
+        const $ = t[d];
+        if ($.isFile() || $.isSymbolicLink() && !r && !c) {
+          const x = this.joinPath($.name, s);
+          this.pushFile(x, b, this.state.counts, o);
+        } else if ($.isDirectory()) {
+          let x = me($.name, s, this.state.options.pathSeparator);
+          if (l && l($.name, x)) continue;
+          this.pushDirectory(x, n, o), this.walkDirectory(this.state, x, x, e - 1, this.walk);
+        } else if (this.resolveSymlink && $.isSymbolicLink()) {
+          let x = Mt($.name, s);
+          this.resolveSymlink(x, this.state, (w, y) => {
+            if (w.isDirectory()) {
+              if (y = At(y, this.state.options), l && l($.name, g ? y : x + E)) return;
+              this.walkDirectory(this.state, y, g ? y : x + E, e - 1, this.walk);
+            } else {
+              y = g ? y : x;
+              const W = pe(y), Q = At(bt(y), this.state.options);
+              y = this.joinPath(W, Q), this.pushFile(y, b, this.state.counts, o);
+            }
+          });
+        }
+      }
+      this.groupFiles(this.state.groups, s, b);
+    });
+    this.isSynchronous = !e, this.callbackInvoker = es(s, this.isSynchronous), this.root = At(t, s), this.state = {
+      root: Se(this.root) ? this.root : this.root.slice(0, -1),
+      paths: [""].slice(0, 0),
+      groups: [],
+      counts: new is(),
+      options: s,
+      queue: new os((n, o) => this.callbackInvoker(o, n, e)),
+      symlinks: /* @__PURE__ */ new Map(),
+      visited: [""].slice(0, 0),
+      controller: new us(),
+      fs: s.fs || le
+    }, this.joinPath = Ce(this.root, s), this.pushDirectory = Le(this.root, s), this.pushFile = Ie(s), this.getArray = Fe(s), this.groupFiles = We(s), this.resolveSymlink = qe(s, this.isSynchronous), this.walkDirectory = rs(this.isSynchronous);
+  }
+  start() {
+    return this.pushDirectory(this.root, this.state.paths, this.state.options.filters), this.walkDirectory(this.state, this.root, this.root, this.state.options.maxDepth, this.walk), this.isSynchronous ? this.callbackInvoker(this.state, null) : null;
+  }
+};
+function as(t, s) {
+  return new Promise((e, n) => {
+    Kt(t, s, (o, r) => {
+      if (o) return n(o);
+      e(r);
+    });
+  });
+}
+function Kt(t, s, e) {
+  new Ut(t, s, e).start();
+}
+function cs(t, s) {
+  return new Ut(t, s).start();
+}
+var wt = class {
+  constructor(t, s) {
+    this.root = t, this.options = s;
+  }
+  withPromise() {
+    return as(this.root, this.options);
+  }
+  withCallback(t) {
+    Kt(this.root, this.options, t);
+  }
+  sync() {
+    return cs(this.root, this.options);
+  }
+};
+let qt = null;
+try {
+  Ht.resolve("picomatch"), qt = Ht("picomatch");
+} catch {
+}
+var ls = class {
+  constructor(t) {
+    D(this, "globCache", {});
+    D(this, "options", {
+      maxDepth: 1 / 0,
+      suppressErrors: !0,
+      pathSeparator: Bt,
+      filters: []
+    });
+    D(this, "globFunction");
+    this.options = {
+      ...this.options,
+      ...t
+    }, this.globFunction = this.options.globFunction;
+  }
+  group() {
+    return this.options.group = !0, this;
+  }
+  withPathSeparator(t) {
+    return this.options.pathSeparator = t, this;
+  }
+  withBasePath() {
+    return this.options.includeBasePath = !0, this;
+  }
+  withRelativePaths() {
+    return this.options.relativePaths = !0, this;
+  }
+  withDirs() {
+    return this.options.includeDirs = !0, this;
+  }
+  withMaxDepth(t) {
+    return this.options.maxDepth = t, this;
+  }
+  withMaxFiles(t) {
+    return this.options.maxFiles = t, this;
+  }
+  withFullPaths() {
+    return this.options.resolvePaths = !0, this.options.includeBasePath = !0, this;
+  }
+  withErrors() {
+    return this.options.suppressErrors = !1, this;
+  }
+  withSymlinks({ resolvePaths: t = !0 } = {}) {
+    return this.options.resolveSymlinks = !0, this.options.useRealPaths = t, this.withFullPaths();
+  }
+  withAbortSignal(t) {
+    return this.options.signal = t, this;
+  }
+  normalize() {
+    return this.options.normalizePath = !0, this;
+  }
+  filter(t) {
+    return this.options.filters.push(t), this;
+  }
+  onlyDirs() {
+    return this.options.excludeFiles = !0, this.options.includeDirs = !0, this;
+  }
+  exclude(t) {
+    return this.options.exclude = t, this;
+  }
+  onlyCounts() {
+    return this.options.onlyCounts = !0, this;
+  }
+  crawl(t) {
+    return new wt(t || ".", this.options);
+  }
+  withGlobFunction(t) {
+    return this.globFunction = t, this;
+  }
+  /**
+  * @deprecated Pass options using the constructor instead:
+  * ```ts
+  * new fdir(options).crawl("/path/to/root");
+  * ```
+  * This method will be removed in v7.0
+  */
+  /* c8 ignore next 4 */
+  crawlWithOptions(t, s) {
+    return this.options = {
+      ...this.options,
+      ...s
+    }, new wt(t || ".", this.options);
+  }
+  glob(...t) {
+    return this.globFunction ? this.globWithOptions(t) : this.globWithOptions(t, { dot: !0 });
+  }
+  globWithOptions(t, ...s) {
+    const e = this.globFunction || qt;
+    if (!e) throw new Error("Please specify a glob function to use glob matching.");
+    var n = this.globCache[t.join("\0")];
+    return n || (n = e(t, ...s), this.globCache[t.join("\0")] = n), this.options.filters.push((o) => n(o)), this;
+  }
+};
+function ps(t) {
+  return t && t.__esModule && Object.prototype.hasOwnProperty.call(t, "default") ? t.default : t;
+}
+var rt = {};
+const q = "\\\\/", Lt = `[^${q}]`, z = "\\.", fs = "\\+", hs = "\\?", ft = "\\/", gs = "(?=.)", Xt = "[^/]", Ct = `(?:${ft}|$)`, Qt = `(?:^|${ft})`, $t = `${z}{1,2}${Ct}`, As = `(?!${z})`, ys = `(?!${Qt}${$t})`, _s = `(?!${z}{0,1}${Ct})`, Rs = `(?!${$t})`, ds = `[^.${ft}]`, Ss = `${Xt}*?`, Es = "/", jt = {
+  DOT_LITERAL: z,
+  PLUS_LITERAL: fs,
+  QMARK_LITERAL: hs,
+  SLASH_LITERAL: ft,
+  ONE_CHAR: gs,
+  QMARK: Xt,
+  END_ANCHOR: Ct,
+  DOTS_SLASH: $t,
+  NO_DOT: As,
+  NO_DOTS: ys,
+  NO_DOT_SLASH: _s,
+  NO_DOTS_SLASH: Rs,
+  QMARK_NO_DOT: ds,
+  STAR: Ss,
+  START_ANCHOR: Qt,
+  SEP: Es
+}, bs = {
+  ...jt,
+  SLASH_LITERAL: `[${q}]`,
+  QMARK: Lt,
+  STAR: `${Lt}*?`,
+  DOTS_SLASH: `${z}{1,2}(?:[${q}]|$)`,
+  NO_DOT: `(?!${z})`,
+  NO_DOTS: `(?!(?:^|[${q}])${z}{1,2}(?:[${q}]|$))`,
+  NO_DOT_SLASH: `(?!${z}{0,1}(?:[${q}]|$))`,
+  NO_DOTS_SLASH: `(?!${z}{1,2}(?:[${q}]|$))`,
+  QMARK_NO_DOT: `[^.${q}]`,
+  START_ANCHOR: `(?:^|[${q}])`,
+  END_ANCHOR: `(?:[${q}]|$)`,
+  SEP: "\\"
+}, ms = {
+  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"
+};
+var ht = {
+  MAX_LENGTH: 1024 * 64,
+  POSIX_REGEX_SOURCE: ms,
+  // regular expressions
+  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,
+  // Replace globs with equivalent patterns to reduce parsing time.
+  REPLACEMENTS: {
+    __proto__: null,
+    "***": "*",
+    "**/**": "**",
+    "**/**/**": "**"
+  },
+  // Digits
+  CHAR_0: 48,
+  /* 0 */
+  CHAR_9: 57,
+  /* 9 */
+  // Alphabet chars.
+  CHAR_UPPERCASE_A: 65,
+  /* A */
+  CHAR_LOWERCASE_A: 97,
+  /* a */
+  CHAR_UPPERCASE_Z: 90,
+  /* Z */
+  CHAR_LOWERCASE_Z: 122,
+  /* z */
+  CHAR_LEFT_PARENTHESES: 40,
+  /* ( */
+  CHAR_RIGHT_PARENTHESES: 41,
+  /* ) */
+  CHAR_ASTERISK: 42,
+  /* * */
+  // Non-alphabetic chars.
+  CHAR_AMPERSAND: 38,
+  /* & */
+  CHAR_AT: 64,
+  /* @ */
+  CHAR_BACKWARD_SLASH: 92,
+  /* \ */
+  CHAR_CARRIAGE_RETURN: 13,
+  /* \r */
+  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,
+  /* \f */
+  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,
+  /* \n */
+  CHAR_NO_BREAK_SPACE: 160,
+  /* \u00A0 */
+  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,
+  /* \t */
+  CHAR_UNDERSCORE: 95,
+  /* _ */
+  CHAR_VERTICAL_LINE: 124,
+  /* | */
+  CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
+  /* \uFEFF */
+  /**
+   * Create EXTGLOB_CHARS
+   */
+  extglobChars(t) {
+    return {
+      "!": { type: "negate", open: "(?:(?!(?:", close: `))${t.STAR})` },
+      "?": { type: "qmark", open: "(?:", close: ")?" },
+      "+": { type: "plus", open: "(?:", close: ")+" },
+      "*": { type: "star", open: "(?:", close: ")*" },
+      "@": { type: "at", open: "(?:", close: ")" }
+    };
+  },
+  /**
+   * Create GLOB_CHARS
+   */
+  globChars(t) {
+    return t === !0 ? bs : jt;
+  }
+};
+(function(t) {
+  const {
+    REGEX_BACKSLASH: s,
+    REGEX_REMOVE_BACKSLASH: e,
+    REGEX_SPECIAL_CHARS: n,
+    REGEX_SPECIAL_CHARS_GLOBAL: o
+  } = ht;
+  t.isObject = (r) => r !== null && typeof r == "object" && !Array.isArray(r), t.hasRegexChars = (r) => n.test(r), t.isRegexChar = (r) => r.length === 1 && t.hasRegexChars(r), t.escapeRegex = (r) => r.replace(o, "\\$1"), t.toPosixSlashes = (r) => r.replace(s, "/"), t.isWindows = () => {
+    if (typeof navigator < "u" && navigator.platform) {
+      const r = navigator.platform.toLowerCase();
+      return r === "win32" || r === "windows";
+    }
+    return typeof process < "u" && process.platform ? process.platform === "win32" : !1;
+  }, t.removeBackslashes = (r) => r.replace(e, (c) => c === "\\" ? "" : c), t.escapeLast = (r, c, l) => {
+    const h = r.lastIndexOf(c, l);
+    return h === -1 ? r : r[h - 1] === "\\" ? t.escapeLast(r, c, h - 1) : `${r.slice(0, h)}\\${r.slice(h)}`;
+  }, t.removePrefix = (r, c = {}) => {
+    let l = r;
+    return l.startsWith("./") && (l = l.slice(2), c.prefix = "./"), l;
+  }, t.wrapOutput = (r, c = {}, l = {}) => {
+    const h = l.contains ? "" : "^", R = l.contains ? "" : "$";
+    let g = `${h}(?:${r})${R}`;
+    return c.negated === !0 && (g = `(?:^(?!${g}).*$)`), g;
+  }, t.basename = (r, { windows: c } = {}) => {
+    const l = r.split(c ? /[\\/]/ : "/"), h = l[l.length - 1];
+    return h === "" ? l[l.length - 2] : h;
+  };
+})(rt);
+const Pt = rt, {
+  CHAR_ASTERISK: yt,
+  /* * */
+  CHAR_AT: Cs,
+  /* @ */
+  CHAR_BACKWARD_SLASH: st,
+  /* \ */
+  CHAR_COMMA: $s,
+  /* , */
+  CHAR_DOT: _t,
+  /* . */
+  CHAR_EXCLAMATION_MARK: Rt,
+  /* ! */
+  CHAR_FORWARD_SLASH: zt,
+  /* / */
+  CHAR_LEFT_CURLY_BRACE: dt,
+  /* { */
+  CHAR_LEFT_PARENTHESES: St,
+  /* ( */
+  CHAR_LEFT_SQUARE_BRACKET: xs,
+  /* [ */
+  CHAR_PLUS: vs,
+  /* + */
+  CHAR_QUESTION_MARK: Tt,
+  /* ? */
+  CHAR_RIGHT_CURLY_BRACE: Hs,
+  /* } */
+  CHAR_RIGHT_PARENTHESES: kt,
+  /* ) */
+  CHAR_RIGHT_SQUARE_BRACKET: ws
+  /* ] */
+} = ht, Ot = (t) => t === zt || t === st, Dt = (t) => {
+  t.isPrefix !== !0 && (t.depth = t.isGlobstar ? 1 / 0 : 1);
+}, Ls = (t, s) => {
+  const e = s || {}, n = t.length - 1, o = e.parts === !0 || e.scanToEnd === !0, r = [], c = [], l = [];
+  let h = t, R = -1, g = 0, E = 0, A = !1, b = !1, d = !1, $ = !1, x = !1, w = !1, y = !1, W = !1, Q = !1, B = !1, N = 0, G, _, m = { value: "", depth: 0, isGlob: !1 };
+  const a = () => R >= n, M = () => h.charCodeAt(R + 1), O = () => (G = _, h.charCodeAt(++R));
+  for (; R < n; ) {
+    _ = O();
+    let v;
+    if (_ === st) {
+      y = m.backslashes = !0, _ = O(), _ === dt && (w = !0);
+      continue;
+    }
+    if (w === !0 || _ === dt) {
+      for (N++; a() !== !0 && (_ = O()); ) {
+        if (_ === st) {
+          y = m.backslashes = !0, O();
+          continue;
+        }
+        if (_ === dt) {
+          N++;
+          continue;
+        }
+        if (w !== !0 && _ === _t && (_ = O()) === _t) {
+          if (A = m.isBrace = !0, d = m.isGlob = !0, B = !0, o === !0)
+            continue;
+          break;
+        }
+        if (w !== !0 && _ === $s) {
+          if (A = m.isBrace = !0, d = m.isGlob = !0, B = !0, o === !0)
+            continue;
+          break;
+        }
+        if (_ === Hs && (N--, N === 0)) {
+          w = !1, A = m.isBrace = !0, B = !0;
+          break;
+        }
+      }
+      if (o === !0)
+        continue;
+      break;
+    }
+    if (_ === zt) {
+      if (r.push(R), c.push(m), m = { value: "", depth: 0, isGlob: !1 }, B === !0) continue;
+      if (G === _t && R === g + 1) {
+        g += 2;
+        continue;
+      }
+      E = R + 1;
+      continue;
+    }
+    if (e.noext !== !0 && (_ === vs || _ === Cs || _ === yt || _ === Tt || _ === Rt) === !0 && M() === St) {
+      if (d = m.isGlob = !0, $ = m.isExtglob = !0, B = !0, _ === Rt && R === g && (Q = !0), o === !0) {
+        for (; a() !== !0 && (_ = O()); ) {
+          if (_ === st) {
+            y = m.backslashes = !0, _ = O();
+            continue;
+          }
+          if (_ === kt) {
+            d = m.isGlob = !0, B = !0;
+            break;
+          }
+        }
+        continue;
+      }
+      break;
+    }
+    if (_ === yt) {
+      if (G === yt && (x = m.isGlobstar = !0), d = m.isGlob = !0, B = !0, o === !0)
+        continue;
+      break;
+    }
+    if (_ === Tt) {
+      if (d = m.isGlob = !0, B = !0, o === !0)
+        continue;
+      break;
+    }
+    if (_ === xs) {
+      for (; a() !== !0 && (v = O()); ) {
+        if (v === st) {
+          y = m.backslashes = !0, O();
+          continue;
+        }
+        if (v === ws) {
+          b = m.isBracket = !0, d = m.isGlob = !0, B = !0;
+          break;
+        }
+      }
+      if (o === !0)
+        continue;
+      break;
+    }
+    if (e.nonegate !== !0 && _ === Rt && R === g) {
+      W = m.negated = !0, g++;
+      continue;
+    }
+    if (e.noparen !== !0 && _ === St) {
+      if (d = m.isGlob = !0, o === !0) {
+        for (; a() !== !0 && (_ = O()); ) {
+          if (_ === St) {
+            y = m.backslashes = !0, _ = O();
+            continue;
+          }
+          if (_ === kt) {
+            B = !0;
+            break;
+          }
+        }
+        continue;
+      }
+      break;
+    }
+    if (d === !0) {
+      if (B = !0, o === !0)
+        continue;
+      break;
+    }
+  }
+  e.noext === !0 && ($ = !1, d = !1);
+  let T = h, i = "", u = "";
+  g > 0 && (i = h.slice(0, g), h = h.slice(g), E -= g), T && d === !0 && E > 0 ? (T = h.slice(0, E), u = h.slice(E)) : d === !0 ? (T = "", u = h) : T = h, T && T !== "" && T !== "/" && T !== h && Ot(T.charCodeAt(T.length - 1)) && (T = T.slice(0, -1)), e.unescape === !0 && (u && (u = Pt.removeBackslashes(u)), T && y === !0 && (T = Pt.removeBackslashes(T)));
+  const U = {
+    prefix: i,
+    input: t,
+    start: g,
+    base: T,
+    glob: u,
+    isBrace: A,
+    isBracket: b,
+    isGlob: d,
+    isExtglob: $,
+    isGlobstar: x,
+    negated: W,
+    negatedExtglob: Q
+  };
+  if (e.tokens === !0 && (U.maxDepth = 0, Ot(_) || c.push(m), U.tokens = c), e.parts === !0 || e.tokens === !0) {
+    let v;
+    for (let L = 0; L < r.length; L++) {
+      const j = v ? v + 1 : g, K = r[L], Y = t.slice(j, K);
+      e.tokens && (L === 0 && g !== 0 ? (c[L].isPrefix = !0, c[L].value = i) : c[L].value = Y, Dt(c[L]), U.maxDepth += c[L].depth), (L !== 0 || Y !== "") && l.push(Y), v = K;
+    }
+    if (v && v + 1 < t.length) {
+      const L = t.slice(v + 1);
+      l.push(L), e.tokens && (c[c.length - 1].value = L, Dt(c[c.length - 1]), U.maxDepth += c[c.length - 1].depth);
+    }
+    U.slashes = r, U.parts = l;
+  }
+  return U;
+};
+var Ps = Ls;
+const ct = ht, X = rt, {
+  MAX_LENGTH: lt,
+  POSIX_REGEX_SOURCE: Ts,
+  REGEX_NON_SPECIAL_CHARS: ks,
+  REGEX_SPECIAL_CHARS_BACKREF: Os,
+  REPLACEMENTS: Yt
+} = ct, Ds = (t, s) => {
+  if (typeof s.expandRange == "function")
+    return s.expandRange(...t, s);
+  t.sort();
+  const e = `[${t.join("-")}]`;
+  try {
+    new RegExp(e);
+  } catch {
+    return t.map((o) => X.escapeRegex(o)).join("..");
+  }
+  return e;
+}, tt = (t, s) => `Missing ${t}: "${s}" - use "\\\\${s}" to match literal characters`, xt = (t, s) => {
+  if (typeof t != "string")
+    throw new TypeError("Expected a string");
+  t = Yt[t] || t;
+  const e = { ...s }, n = typeof e.maxLength == "number" ? Math.min(lt, e.maxLength) : lt;
+  let o = t.length;
+  if (o > n)
+    throw new SyntaxError(`Input length: ${o}, exceeds maximum allowed length: ${n}`);
+  const r = { type: "bos", value: "", output: e.prepend || "" }, c = [r], l = e.capture ? "" : "?:", h = ct.globChars(e.windows), R = ct.extglobChars(h), {
+    DOT_LITERAL: g,
+    PLUS_LITERAL: E,
+    SLASH_LITERAL: A,
+    ONE_CHAR: b,
+    DOTS_SLASH: d,
+    NO_DOT: $,
+    NO_DOT_SLASH: x,
+    NO_DOTS_SLASH: w,
+    QMARK: y,
+    QMARK_NO_DOT: W,
+    STAR: Q,
+    START_ANCHOR: B
+  } = h, N = (f) => `(${l}(?:(?!${B}${f.dot ? d : g}).)*?)`, G = e.dot ? "" : $, _ = e.dot ? y : W;
+  let m = e.bash === !0 ? N(e) : Q;
+  e.capture && (m = `(${m})`), typeof e.noext == "boolean" && (e.noextglob = e.noext);
+  const a = {
+    input: t,
+    index: -1,
+    start: 0,
+    dot: e.dot === !0,
+    consumed: "",
+    output: "",
+    prefix: "",
+    backtrack: !1,
+    negated: !1,
+    brackets: 0,
+    braces: 0,
+    parens: 0,
+    quotes: 0,
+    globstar: !1,
+    tokens: c
+  };
+  t = X.removePrefix(t, a), o = t.length;
+  const M = [], O = [], T = [];
+  let i = r, u;
+  const U = () => a.index === o - 1, v = a.peek = (f = 1) => t[a.index + f], L = a.advance = () => t[++a.index] || "", j = () => t.slice(a.index + 1), K = (f = "", H = 0) => {
+    a.consumed += f, a.index += H;
+  }, Y = (f) => {
+    a.output += f.output != null ? f.output : f.value, K(f.value);
+  }, ie = () => {
+    let f = 1;
+    for (; v() === "!" && (v(2) !== "(" || v(3) === "?"); )
+      L(), a.start++, f++;
+    return f % 2 === 0 ? !1 : (a.negated = !0, a.start++, !0);
+  }, ot = (f) => {
+    a[f]++, T.push(f);
+  }, Z = (f) => {
+    a[f]--, T.pop();
+  }, C = (f) => {
+    if (i.type === "globstar") {
+      const H = a.braces > 0 && (f.type === "comma" || f.type === "brace"), p = f.extglob === !0 || M.length && (f.type === "pipe" || f.type === "paren");
+      f.type !== "slash" && f.type !== "paren" && !H && !p && (a.output = a.output.slice(0, -i.output.length), i.type = "star", i.value = "*", i.output = m, a.output += i.output);
+    }
+    if (M.length && f.type !== "paren" && (M[M.length - 1].inner += f.value), (f.value || f.output) && Y(f), i && i.type === "text" && f.type === "text") {
+      i.output = (i.output || i.value) + f.value, i.value += f.value;
+      return;
+    }
+    f.prev = i, c.push(f), i = f;
+  }, it = (f, H) => {
+    const p = { ...R[H], conditions: 1, inner: "" };
+    p.prev = i, p.parens = a.parens, p.output = a.output;
+    const S = (e.capture ? "(" : "") + p.open;
+    ot("parens"), C({ type: f, value: H, output: a.output ? "" : b }), C({ type: "paren", extglob: !0, value: L(), output: S }), M.push(p);
+  }, ue = (f) => {
+    let H = f.close + (e.capture ? ")" : ""), p;
+    if (f.type === "negate") {
+      let S = m;
+      if (f.inner && f.inner.length > 1 && f.inner.includes("/") && (S = N(e)), (S !== m || U() || /^\)+$/.test(j())) && (H = f.close = `)$))${S}`), f.inner.includes("*") && (p = j()) && /^\.[^\\/.]+$/.test(p)) {
+        const P = xt(p, { ...s, fastpaths: !1 }).output;
+        H = f.close = `)${P})${S})`;
+      }
+      f.prev.type === "bos" && (a.negatedExtglob = !0);
+    }
+    C({ type: "paren", extglob: !0, value: u, output: H }), Z("parens");
+  };
+  if (e.fastpaths !== !1 && !/(^[*!]|[/()[\]{}"])/.test(t)) {
+    let f = !1, H = t.replace(Os, (p, S, P, F, I, gt) => F === "\\" ? (f = !0, p) : F === "?" ? S ? S + F + (I ? y.repeat(I.length) : "") : gt === 0 ? _ + (I ? y.repeat(I.length) : "") : y.repeat(P.length) : F === "." ? g.repeat(P.length) : F === "*" ? S ? S + F + (I ? m : "") : m : S ? p : `\\${p}`);
+    return f === !0 && (e.unescape === !0 ? H = H.replace(/\\/g, "") : H = H.replace(/\\+/g, (p) => p.length % 2 === 0 ? "\\\\" : p ? "\\" : "")), H === t && e.contains === !0 ? (a.output = t, a) : (a.output = X.wrapOutput(H, a, s), a);
+  }
+  for (; !U(); ) {
+    if (u = L(), u === "\0")
+      continue;
+    if (u === "\\") {
+      const p = v();
+      if (p === "/" && e.bash !== !0 || p === "." || p === ";")
+        continue;
+      if (!p) {
+        u += "\\", C({ type: "text", value: u });
+        continue;
+      }
+      const S = /^\\+/.exec(j());
+      let P = 0;
+      if (S && S[0].length > 2 && (P = S[0].length, a.index += P, P % 2 !== 0 && (u += "\\")), e.unescape === !0 ? u = L() : u += L(), a.brackets === 0) {
+        C({ type: "text", value: u });
+        continue;
+      }
+    }
+    if (a.brackets > 0 && (u !== "]" || i.value === "[" || i.value === "[^")) {
+      if (e.posix !== !1 && u === ":") {
+        const p = i.value.slice(1);
+        if (p.includes("[") && (i.posix = !0, p.includes(":"))) {
+          const S = i.value.lastIndexOf("["), P = i.value.slice(0, S), F = i.value.slice(S + 2), I = Ts[F];
+          if (I) {
+            i.value = P + I, a.backtrack = !0, L(), !r.output && c.indexOf(i) === 1 && (r.output = b);
+            continue;
+          }
+        }
+      }
+      (u === "[" && v() !== ":" || u === "-" && v() === "]") && (u = `\\${u}`), u === "]" && (i.value === "[" || i.value === "[^") && (u = `\\${u}`), e.posix === !0 && u === "!" && i.value === "[" && (u = "^"), i.value += u, Y({ value: u });
+      continue;
+    }
+    if (a.quotes === 1 && u !== '"') {
+      u = X.escapeRegex(u), i.value += u, Y({ value: u });
+      continue;
+    }
+    if (u === '"') {
+      a.quotes = a.quotes === 1 ? 0 : 1, e.keepQuotes === !0 && C({ type: "text", value: u });
+      continue;
+    }
+    if (u === "(") {
+      ot("parens"), C({ type: "paren", value: u });
+      continue;
+    }
+    if (u === ")") {
+      if (a.parens === 0 && e.strictBrackets === !0)
+        throw new SyntaxError(tt("opening", "("));
+      const p = M[M.length - 1];
+      if (p && a.parens === p.parens + 1) {
+        ue(M.pop());
+        continue;
+      }
+      C({ type: "paren", value: u, output: a.parens ? ")" : "\\)" }), Z("parens");
+      continue;
+    }
+    if (u === "[") {
+      if (e.nobracket === !0 || !j().includes("]")) {
+        if (e.nobracket !== !0 && e.strictBrackets === !0)
+          throw new SyntaxError(tt("closing", "]"));
+        u = `\\${u}`;
+      } else
+        ot("brackets");
+      C({ type: "bracket", value: u });
+      continue;
+    }
+    if (u === "]") {
+      if (e.nobracket === !0 || i && i.type === "bracket" && i.value.length === 1) {
+        C({ type: "text", value: u, output: `\\${u}` });
+        continue;
+      }
+      if (a.brackets === 0) {
+        if (e.strictBrackets === !0)
+          throw new SyntaxError(tt("opening", "["));
+        C({ type: "text", value: u, output: `\\${u}` });
+        continue;
+      }
+      Z("brackets");
+      const p = i.value.slice(1);
+      if (i.posix !== !0 && p[0] === "^" && !p.includes("/") && (u = `/${u}`), i.value += u, Y({ value: u }), e.literalBrackets === !1 || X.hasRegexChars(p))
+        continue;
+      const S = X.escapeRegex(i.value);
+      if (a.output = a.output.slice(0, -i.value.length), e.literalBrackets === !0) {
+        a.output += S, i.value = S;
+        continue;
+      }
+      i.value = `(${l}${S}|${i.value})`, a.output += i.value;
+      continue;
+    }
+    if (u === "{" && e.nobrace !== !0) {
+      ot("braces");
+      const p = {
+        type: "brace",
+        value: u,
+        output: "(",
+        outputIndex: a.output.length,
+        tokensIndex: a.tokens.length
+      };
+      O.push(p), C(p);
+      continue;
+    }
+    if (u === "}") {
+      const p = O[O.length - 1];
+      if (e.nobrace === !0 || !p) {
+        C({ type: "text", value: u, output: u });
+        continue;
+      }
+      let S = ")";
+      if (p.dots === !0) {
+        const P = c.slice(), F = [];
+        for (let I = P.length - 1; I >= 0 && (c.pop(), P[I].type !== "brace"); I--)
+          P[I].type !== "dots" && F.unshift(P[I].value);
+        S = Ds(F, e), a.backtrack = !0;
+      }
+      if (p.comma !== !0 && p.dots !== !0) {
+        const P = a.output.slice(0, p.outputIndex), F = a.tokens.slice(p.tokensIndex);
+        p.value = p.output = "\\{", u = S = "\\}", a.output = P;
+        for (const I of F)
+          a.output += I.output || I.value;
+      }
+      C({ type: "brace", value: u, output: S }), Z("braces"), O.pop();
+      continue;
+    }
+    if (u === "|") {
+      M.length > 0 && M[M.length - 1].conditions++, C({ type: "text", value: u });
+      continue;
+    }
+    if (u === ",") {
+      let p = u;
+      const S = O[O.length - 1];
+      S && T[T.length - 1] === "braces" && (S.comma = !0, p = "|"), C({ type: "comma", value: u, output: p });
+      continue;
+    }
+    if (u === "/") {
+      if (i.type === "dot" && a.index === a.start + 1) {
+        a.start = a.index + 1, a.consumed = "", a.output = "", c.pop(), i = r;
+        continue;
+      }
+      C({ type: "slash", value: u, output: A });
+      continue;
+    }
+    if (u === ".") {
+      if (a.braces > 0 && i.type === "dot") {
+        i.value === "." && (i.output = g);
+        const p = O[O.length - 1];
+        i.type = "dots", i.output += u, i.value += u, p.dots = !0;
+        continue;
+      }
+      if (a.braces + a.parens === 0 && i.type !== "bos" && i.type !== "slash") {
+        C({ type: "text", value: u, output: g });
+        continue;
+      }
+      C({ type: "dot", value: u, output: g });
+      continue;
+    }
+    if (u === "?") {
+      if (!(i && i.value === "(") && e.noextglob !== !0 && v() === "(" && v(2) !== "?") {
+        it("qmark", u);
+        continue;
+      }
+      if (i && i.type === "paren") {
+        const S = v();
+        let P = u;
+        (i.value === "(" && !/[!=<:]/.test(S) || S === "<" && !/<([!=]|\w+>)/.test(j())) && (P = `\\${u}`), C({ type: "text", value: u, output: P });
+        continue;
+      }
+      if (e.dot !== !0 && (i.type === "slash" || i.type === "bos")) {
+        C({ type: "qmark", value: u, output: W });
+        continue;
+      }
+      C({ type: "qmark", value: u, output: y });
+      continue;
+    }
+    if (u === "!") {
+      if (e.noextglob !== !0 && v() === "(" && (v(2) !== "?" || !/[!=<:]/.test(v(3)))) {
+        it("negate", u);
+        continue;
+      }
+      if (e.nonegate !== !0 && a.index === 0) {
+        ie();
+        continue;
+      }
+    }
+    if (u === "+") {
+      if (e.noextglob !== !0 && v() === "(" && v(2) !== "?") {
+        it("plus", u);
+        continue;
+      }
+      if (i && i.value === "(" || e.regex === !1) {
+        C({ type: "plus", value: u, output: E });
+        continue;
+      }
+      if (i && (i.type === "bracket" || i.type === "paren" || i.type === "brace") || a.parens > 0) {
+        C({ type: "plus", value: u });
+        continue;
+      }
+      C({ type: "plus", value: E });
+      continue;
+    }
+    if (u === "@") {
+      if (e.noextglob !== !0 && v() === "(" && v(2) !== "?") {
+        C({ type: "at", extglob: !0, value: u, output: "" });
+        continue;
+      }
+      C({ type: "text", value: u });
+      continue;
+    }
+    if (u !== "*") {
+      (u === "$" || u === "^") && (u = `\\${u}`);
+      const p = ks.exec(j());
+      p && (u += p[0], a.index += p[0].length), C({ type: "text", value: u });
+      continue;
+    }
+    if (i && (i.type === "globstar" || i.star === !0)) {
+      i.type = "star", i.star = !0, i.value += u, i.output = m, a.backtrack = !0, a.globstar = !0, K(u);
+      continue;
+    }
+    let f = j();
+    if (e.noextglob !== !0 && /^\([^?]/.test(f)) {
+      it("star", u);
+      continue;
+    }
+    if (i.type === "star") {
+      if (e.noglobstar === !0) {
+        K(u);
+        continue;
+      }
+      const p = i.prev, S = p.prev, P = p.type === "slash" || p.type === "bos", F = S && (S.type === "star" || S.type === "globstar");
+      if (e.bash === !0 && (!P || f[0] && f[0] !== "/")) {
+        C({ type: "star", value: u, output: "" });
+        continue;
+      }
+      const I = a.braces > 0 && (p.type === "comma" || p.type === "brace"), gt = M.length && (p.type === "pipe" || p.type === "paren");
+      if (!P && p.type !== "paren" && !I && !gt) {
+        C({ type: "star", value: u, output: "" });
+        continue;
+      }
+      for (; f.slice(0, 3) === "/**"; ) {
+        const ut = t[a.index + 4];
+        if (ut && ut !== "/")
+          break;
+        f = f.slice(3), K("/**", 3);
+      }
+      if (p.type === "bos" && U()) {
+        i.type = "globstar", i.value += u, i.output = N(e), a.output = i.output, a.globstar = !0, K(u);
+        continue;
+      }
+      if (p.type === "slash" && p.prev.type !== "bos" && !F && U()) {
+        a.output = a.output.slice(0, -(p.output + i.output).length), p.output = `(?:${p.output}`, i.type = "globstar", i.output = N(e) + (e.strictSlashes ? ")" : "|$)"), i.value += u, a.globstar = !0, a.output += p.output + i.output, K(u);
+        continue;
+      }
+      if (p.type === "slash" && p.prev.type !== "bos" && f[0] === "/") {
+        const ut = f[1] !== void 0 ? "|$" : "";
+        a.output = a.output.slice(0, -(p.output + i.output).length), p.output = `(?:${p.output}`, i.type = "globstar", i.output = `${N(e)}${A}|${A}${ut})`, i.value += u, a.output += p.output + i.output, a.globstar = !0, K(u + L()), C({ type: "slash", value: "/", output: "" });
+        continue;
+      }
+      if (p.type === "bos" && f[0] === "/") {
+        i.type = "globstar", i.value += u, i.output = `(?:^|${A}|${N(e)}${A})`, a.output = i.output, a.globstar = !0, K(u + L()), C({ type: "slash", value: "/", output: "" });
+        continue;
+      }
+      a.output = a.output.slice(0, -i.output.length), i.type = "globstar", i.output = N(e), i.value += u, a.output += i.output, a.globstar = !0, K(u);
+      continue;
+    }
+    const H = { type: "star", value: u, output: m };
+    if (e.bash === !0) {
+      H.output = ".*?", (i.type === "bos" || i.type === "slash") && (H.output = G + H.output), C(H);
+      continue;
+    }
+    if (i && (i.type === "bracket" || i.type === "paren") && e.regex === !0) {
+      H.output = u, C(H);
+      continue;
+    }
+    (a.index === a.start || i.type === "slash" || i.type === "dot") && (i.type === "dot" ? (a.output += x, i.output += x) : e.dot === !0 ? (a.output += w, i.output += w) : (a.output += G, i.output += G), v() !== "*" && (a.output += b, i.output += b)), C(H);
+  }
+  for (; a.brackets > 0; ) {
+    if (e.strictBrackets === !0) throw new SyntaxError(tt("closing", "]"));
+    a.output = X.escapeLast(a.output, "["), Z("brackets");
+  }
+  for (; a.parens > 0; ) {
+    if (e.strictBrackets === !0) throw new SyntaxError(tt("closing", ")"));
+    a.output = X.escapeLast(a.output, "("), Z("parens");
+  }
+  for (; a.braces > 0; ) {
+    if (e.strictBrackets === !0) throw new SyntaxError(tt("closing", "}"));
+    a.output = X.escapeLast(a.output, "{"), Z("braces");
+  }
+  if (e.strictSlashes !== !0 && (i.type === "star" || i.type === "bracket") && C({ type: "maybe_slash", value: "", output: `${A}?` }), a.backtrack === !0) {
+    a.output = "";
+    for (const f of a.tokens)
+      a.output += f.output != null ? f.output : f.value, f.suffix && (a.output += f.suffix);
+  }
+  return a;
+};
+xt.fastpaths = (t, s) => {
+  const e = { ...s }, n = typeof e.maxLength == "number" ? Math.min(lt, e.maxLength) : lt, o = t.length;
+  if (o > n)
+    throw new SyntaxError(`Input length: ${o}, exceeds maximum allowed length: ${n}`);
+  t = Yt[t] || t;
+  const {
+    DOT_LITERAL: r,
+    SLASH_LITERAL: c,
+    ONE_CHAR: l,
+    DOTS_SLASH: h,
+    NO_DOT: R,
+    NO_DOTS: g,
+    NO_DOTS_SLASH: E,
+    STAR: A,
+    START_ANCHOR: b
+  } = ct.globChars(e.windows), d = e.dot ? g : R, $ = e.dot ? E : R, x = e.capture ? "" : "?:", w = { negated: !1, prefix: "" };
+  let y = e.bash === !0 ? ".*?" : A;
+  e.capture && (y = `(${y})`);
+  const W = (G) => G.noglobstar === !0 ? y : `(${x}(?:(?!${b}${G.dot ? h : r}).)*?)`, Q = (G) => {
+    switch (G) {
+      case "*":
+        return `${d}${l}${y}`;
+      case ".*":
+        return `${r}${l}${y}`;
+      case "*.*":
+        return `${d}${y}${r}${l}${y}`;
+      case "*/*":
+        return `${d}${y}${c}${l}${$}${y}`;
+      case "**":
+        return d + W(e);
+      case "**/*":
+        return `(?:${d}${W(e)}${c})?${$}${l}${y}`;
+      case "**/*.*":
+        return `(?:${d}${W(e)}${c})?${$}${y}${r}${l}${y}`;
+      case "**/.*":
+        return `(?:${d}${W(e)}${c})?${r}${l}${y}`;
+      default: {
+        const _ = /^(.*?)\.(\w+)$/.exec(G);
+        if (!_) return;
+        const m = Q(_[1]);
+        return m ? m + r + _[2] : void 0;
+      }
+    }
+  }, B = X.removePrefix(t, w);
+  let N = Q(B);
+  return N && e.strictSlashes !== !0 && (N += `${c}?`), N;
+};
+var Is = xt;
+const Ns = Ps, mt = Is, Zt = rt, Bs = ht, Fs = (t) => t && typeof t == "object" && !Array.isArray(t), k = (t, s, e = !1) => {
+  if (Array.isArray(t)) {
+    const g = t.map((A) => k(A, s, e));
+    return (A) => {
+      for (const b of g) {
+        const d = b(A);
+        if (d) return d;
+      }
+      return !1;
+    };
+  }
+  const n = Fs(t) && t.tokens && t.input;
+  if (t === "" || typeof t != "string" && !n)
+    throw new TypeError("Expected pattern to be a non-empty string");
+  const o = s || {}, r = o.windows, c = n ? k.compileRe(t, s) : k.makeRe(t, s, !1, !0), l = c.state;
+  delete c.state;
+  let h = () => !1;
+  if (o.ignore) {
+    const g = { ...s, ignore: null, onMatch: null, onResult: null };
+    h = k(o.ignore, g, e);
+  }
+  const R = (g, E = !1) => {
+    const { isMatch: A, match: b, output: d } = k.test(g, c, s, { glob: t, posix: r }), $ = { glob: t, state: l, regex: c, posix: r, input: g, output: d, match: b, isMatch: A };
+    return typeof o.onResult == "function" && o.onResult($), A === !1 ? ($.isMatch = !1, E ? $ : !1) : h(g) ? (typeof o.onIgnore == "function" && o.onIgnore($), $.isMatch = !1, E ? $ : !1) : (typeof o.onMatch == "function" && o.onMatch($), E ? $ : !0);
+  };
+  return e && (R.state = l), R;
+};
+k.test = (t, s, e, { glob: n, posix: o } = {}) => {
+  if (typeof t != "string")
+    throw new TypeError("Expected input to be a string");
+  if (t === "")
+    return { isMatch: !1, output: "" };
+  const r = e || {}, c = r.format || (o ? Zt.toPosixSlashes : null);
+  let l = t === n, h = l && c ? c(t) : t;
+  return l === !1 && (h = c ? c(t) : t, l = h === n), (l === !1 || r.capture === !0) && (r.matchBase === !0 || r.basename === !0 ? l = k.matchBase(t, s, e, o) : l = s.exec(h)), { isMatch: !!l, match: l, output: h };
+};
+k.matchBase = (t, s, e) => (s instanceof RegExp ? s : k.makeRe(s, e)).test(Zt.basename(t));
+k.isMatch = (t, s, e) => k(s, e)(t);
+k.parse = (t, s) => Array.isArray(t) ? t.map((e) => k.parse(e, s)) : mt(t, { ...s, fastpaths: !1 });
+k.scan = (t, s) => Ns(t, s);
+k.compileRe = (t, s, e = !1, n = !1) => {
+  if (e === !0)
+    return t.output;
+  const o = s || {}, r = o.contains ? "" : "^", c = o.contains ? "" : "$";
+  let l = `${r}(?:${t.output})${c}`;
+  t && t.negated === !0 && (l = `^(?!${l}).*$`);
+  const h = k.toRegex(l, s);
+  return n === !0 && (h.state = t), h;
+};
+k.makeRe = (t, s = {}, e = !1, n = !1) => {
+  if (!t || typeof t != "string")
+    throw new TypeError("Expected a non-empty string");
+  let o = { negated: !1, fastpaths: !0 };
+  return s.fastpaths !== !1 && (t[0] === "." || t[0] === "*") && (o.output = mt.fastpaths(t, s)), o.output || (o = mt(t, s)), k.compileRe(o, s, e, n);
+};
+k.toRegex = (t, s) => {
+  try {
+    const e = s || {};
+    return new RegExp(t, e.flags || (e.nocase ? "i" : ""));
+  } catch (e) {
+    if (s && s.debug === !0) throw e;
+    return /$^/;
+  }
+};
+k.constants = Bs;
+var Ms = k;
+const Vt = Ms, Gs = rt;
+function Jt(t, s, e = !1) {
+  return s && (s.windows === null || s.windows === void 0) && (s = { ...s, windows: Gs.isWindows() }), Vt(t, s, e);
+}
+Object.assign(Jt, Vt);
+var Ws = Jt;
+const nt = /* @__PURE__ */ ps(Ws), te = Array.isArray, vt = process.platform === "win32", Us = /^(\/?\.\.)+$/;
+function Ks(t, s = {}) {
+  const e = t.length, n = Array(e), o = Array(e), r = !s.noglobstar;
+  for (let c = 0; c < e; c++) {
+    const l = ee(t[c]);
+    n[c] = l;
+    const h = l.length, R = Array(h);
+    for (let g = 0; g < h; g++) R[g] = nt(l[g], s);
+    o[c] = R;
+  }
+  return (c) => {
+    const l = c.split("/");
+    if (l[0] === ".." && Us.test(c)) return !0;
+    for (let h = 0; h < t.length; h++) {
+      const R = n[h], g = o[h], E = l.length, A = Math.min(E, R.length);
+      let b = 0;
+      for (; b < A; ) {
+        const d = R[b];
+        if (d.includes("/")) return !0;
+        if (!g[b](l[b])) break;
+        if (r && d === "**") return !0;
+        b++;
+      }
+      if (b === E) return !0;
+    }
+    return !1;
+  };
+}
+const qs = /^[A-Z]:\/$/i, Xs = vt ? (t) => qs.test(t) : (t) => t === "/";
+function It(t, s, e) {
+  if (t === s || s.startsWith(`${t}/`)) {
+    if (e) {
+      const o = Xs(t) ? t.length : t.length + 1;
+      return (r, c) => r.slice(o, c ? -1 : void 0) || ".";
+    }
+    const n = s.slice(t.length + 1);
+    return n ? (o, r) => {
+      if (o === ".") return n;
+      const c = `${n}/${o}`;
+      return r ? c.slice(0, -1) : c;
+    } : (o, r) => r && o !== "." ? o.slice(0, -1) : o;
+  }
+  return e ? (n) => V.relative(t, n) || "." : (n) => V.relative(t, `${s}/${n}`) || ".";
+}
+function Qs(t, s) {
+  if (s.startsWith(`${t}/`)) {
+    const e = s.slice(t.length + 1);
+    return (n) => `${e}/${n}`;
+  }
+  return (e) => {
+    const n = V.relative(t, `${s}/${e}`);
+    return e.endsWith("/") && n !== "" ? `${n}/` : n || ".";
+  };
+}
+const js = { parts: !0 };
+function ee(t) {
+  var s;
+  const e = nt.scan(t, js);
+  return !((s = e.parts) === null || s === void 0) && s.length ? e.parts : [t];
+}
+const zs = /\\(?![()[\]{}!+@])/g;
+function Ys(t) {
+  return se(t);
+}
+function Zs(t) {
+  return ne(t).replace(zs, "/");
+}
+const fn = vt ? Zs : Ys, Vs = new RegExp("(?<!\\\\)([()[\\]{}*?|]|^!|[!+@](?=\\()|\\\\(?![()[\\]{}!*+?@|]))", "g"), Js = new RegExp("(?<!\\\\)([()[\\]{}]|^!|[!+@](?=\\())", "g"), se = (t) => t.replace(Vs, "\\$&"), ne = (t) => t.replace(Js, "\\$&"), tn = vt ? ne : se;
+function en(t, s) {
+  if ((s == null ? void 0 : s.caseSensitiveMatch) === !1) return !0;
+  const e = nt.scan(t);
+  return e.isGlob || e.negated;
+}
+function et(...t) {
+  console.log(`[tinyglobby ${(/* @__PURE__ */ new Date()).toLocaleTimeString("es")}]`, ...t);
+}
+const sn = /^(\/?\.\.)+/, nn = /\\(?=[()[\]{}!*+?@|])/g, at = /\\/g;
+function Et(t, s, e, n, o) {
+  let r = t;
+  t.endsWith("/") && (r = t.slice(0, -1)), !r.endsWith("*") && s && (r += "/**");
+  const c = tn(e);
+  Nt.isAbsolute(r.replace(nn, "")) ? r = V.relative(c, r) : r = V.normalize(r);
+  const l = sn.exec(r), h = ee(r);
+  if (l != null && l[0]) {
+    const g = (l[0].length + 1) / 3;
+    let E = 0;
+    const A = c.split("/");
+    for (; E < g && h[E + g] === A[A.length + E - g]; )
+      r = r.slice(0, (g - E - 1) * 3) + r.slice((g - E) * 3 + h[E + g].length + 1) || ".", E++;
+    const b = V.join(e, l[0].slice(E * 3));
+    !b.startsWith(".") && n.root.length > b.length && (n.root = b, n.depthOffset = -g + E);
+  }
+  if (!o && n.depthOffset >= 0) {
+    var R;
+    (R = n.commonPath) !== null && R !== void 0 || (n.commonPath = h);
+    const g = [], E = Math.min(n.commonPath.length, h.length);
+    for (let A = 0; A < E; A++) {
+      const b = h[A];
+      if (b === "**" && !h[A + 1]) {
+        g.pop();
+        break;
+      }
+      if (b !== n.commonPath[A] || en(b) || A === h.length - 1) break;
+      g.push(b);
+    }
+    n.depthOffset = g.length, n.commonPath = g, n.root = g.length > 0 ? V.join(e, ...g) : e;
+  }
+  return r;
+}
+function rn({ patterns: t = ["**/*"], ignore: s = [], expandDirectories: e = !0 }, n, o) {
+  typeof t == "string" && (t = [t]), typeof s == "string" && (s = [s]);
+  const r = [], c = [];
+  for (const l of s)
+    l && (l[0] !== "!" || l[1] === "(") && c.push(Et(l, e, n, o, !0));
+  for (const l of t)
+    l && (l[0] !== "!" || l[1] === "(" ? r.push(Et(l, e, n, o, !1)) : (l[1] !== "!" || l[2] === "(") && c.push(Et(l.slice(1), e, n, o, !0)));
+  return {
+    match: r,
+    ignore: c
+  };
+}
+function re(t, s) {
+  for (let e = t.length - 1; e >= 0; e--) {
+    const n = t[e];
+    t[e] = s(n);
+  }
+  return t;
+}
+function on(t) {
+  return t ? t instanceof URL ? Ae(t).replace(at, "/") : Nt.resolve(t).replace(at, "/") : process.cwd().replace(at, "/");
+}
+function oe(t, s = {}) {
+  const e = process.env.TINYGLOBBY_DEBUG ? {
+    ...s,
+    debug: !0
+  } : s, n = on(e.cwd);
+  if (e.debug && et("globbing with:", {
+    patterns: t,
+    options: e,
+    cwd: n
+  }), Array.isArray(t) && t.length === 0) return [{
+    sync: () => [],
+    withPromise: async () => []
+  }, !1];
+  const o = {
+    root: n,
+    commonPath: null,
+    depthOffset: 0
+  }, r = rn({
+    ...e,
+    patterns: t
+  }, n, o);
+  e.debug && et("internal processing patterns:", r);
+  const c = {
+    dot: e.dot,
+    nobrace: e.braceExpansion === !1,
+    nocase: e.caseSensitiveMatch === !1,
+    noextglob: e.extglob === !1,
+    noglobstar: e.globstar === !1,
+    posix: !0
+  }, l = nt(r.match, {
+    ...c,
+    ignore: r.ignore
+  }), h = nt(r.ignore, c), R = Ks(r.match, c), g = It(n, o.root, e.absolute), E = e.absolute ? g : It(n, o.root, !0), A = {
+    filters: [e.debug ? ($, x) => {
+      const w = g($, x), y = l(w);
+      return y && et(`matched ${w}`), y;
+    } : ($, x) => l(g($, x))],
+    exclude: e.debug ? ($, x) => {
+      const w = E(x, !0), y = w !== "." && !R(w) || h(w);
+      return et(y ? `skipped ${x}` : `crawling ${x}`), y;
+    } : ($, x) => {
+      const w = E(x, !0);
+      return w !== "." && !R(w) || h(w);
+    },
+    fs: e.fs ? {
+      readdir: e.fs.readdir || J.readdir,
+      readdirSync: e.fs.readdirSync || J.readdirSync,
+      realpath: e.fs.realpath || J.realpath,
+      realpathSync: e.fs.realpathSync || J.realpathSync,
+      stat: e.fs.stat || J.stat,
+      statSync: e.fs.statSync || J.statSync
+    } : void 0,
+    pathSeparator: "/",
+    relativePaths: !0,
+    resolveSymlinks: !0,
+    signal: e.signal
+  };
+  e.deep !== void 0 && (A.maxDepth = Math.round(e.deep - o.depthOffset)), e.absolute && (A.relativePaths = !1, A.resolvePaths = !0, A.includeBasePath = !0), e.followSymbolicLinks === !1 && (A.resolveSymlinks = !1, A.excludeSymlinks = !0), e.onlyDirectories ? (A.excludeFiles = !0, A.includeDirs = !0) : e.onlyFiles === !1 && (A.includeDirs = !0), o.root = o.root.replace(at, "");
+  const b = o.root;
+  e.debug && et("internal properties:", o);
+  const d = n !== b && !e.absolute && Qs(n, o.root);
+  return [new ls(A).crawl(b), d];
+}
+async function hn(t, s) {
+  if (t && (s != null && s.patterns)) throw new Error("Cannot pass patterns as both an argument and an option");
+  const e = te(t) || typeof t == "string", n = e ? s : t, o = e ? t : t.patterns, [r, c] = oe(o, n);
+  return c ? re(await r.withPromise(), c) : r.withPromise();
+}
+function gn(t, s) {
+  if (t && (s != null && s.patterns)) throw new Error("Cannot pass patterns as both an argument and an option");
+  const e = te(t) || typeof t == "string", n = e ? s : t, o = e ? t : t.patterns, [r, c] = oe(o, n);
+  return c ? re(r.sync(), c) : r.sync();
+}
+export {
+  fn as convertPathToPattern,
+  tn as escapePath,
+  hn as glob,
+  gn as globSync,
+  en as isDynamicPattern
+};