@wix/cli-app 1.1.38 → 1.1.40

package/build/miniflare/worker-entry.js

@@ -0,0 +1,2767 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/balanced-match/index.js
+var require_balanced_match = __commonJS({
+  "../../node_modules/balanced-match/index.js"(exports, module) {
+    "use strict";
+    module.exports = balanced;
+    function balanced(a, b, str) {
+      if (a instanceof RegExp) a = maybeMatch(a, str);
+      if (b instanceof RegExp) b = maybeMatch(b, str);
+      var r = range(a, b, str);
+      return r && {
+        start: r[0],
+        end: r[1],
+        pre: str.slice(0, r[0]),
+        body: str.slice(r[0] + a.length, r[1]),
+        post: str.slice(r[1] + b.length)
+      };
+    }
+    function maybeMatch(reg, str) {
+      var m = str.match(reg);
+      return m ? m[0] : null;
+    }
+    balanced.range = range;
+    function range(a, b, str) {
+      var begs, beg, left, right, result;
+      var ai = str.indexOf(a);
+      var bi = str.indexOf(b, ai + 1);
+      var i = ai;
+      if (ai >= 0 && bi > 0) {
+        if (a === b) {
+          return [ai, bi];
+        }
+        begs = [];
+        left = str.length;
+        while (i >= 0 && !result) {
+          if (i == ai) {
+            begs.push(i);
+            ai = str.indexOf(a, i + 1);
+          } else if (begs.length == 1) {
+            result = [begs.pop(), bi];
+          } else {
+            beg = begs.pop();
+            if (beg < left) {
+              left = beg;
+              right = bi;
+            }
+            bi = str.indexOf(b, i + 1);
+          }
+          i = ai < bi && ai >= 0 ? ai : bi;
+        }
+        if (begs.length) {
+          result = [left, right];
+        }
+      }
+      return result;
+    }
+  }
+});
+
+// ../../node_modules/brace-expansion/index.js
+var require_brace_expansion = __commonJS({
+  "../../node_modules/brace-expansion/index.js"(exports, module) {
+    "use strict";
+    var balanced = require_balanced_match();
+    module.exports = expandTop;
+    var escSlash = "\0SLASH" + Math.random() + "\0";
+    var escOpen = "\0OPEN" + Math.random() + "\0";
+    var escClose = "\0CLOSE" + Math.random() + "\0";
+    var escComma = "\0COMMA" + Math.random() + "\0";
+    var escPeriod = "\0PERIOD" + Math.random() + "\0";
+    function numeric(str) {
+      return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
+    }
+    function escapeBraces(str) {
+      return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
+    }
+    function unescapeBraces(str) {
+      return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
+    }
+    function parseCommaParts(str) {
+      if (!str)
+        return [""];
+      var parts = [];
+      var m = balanced("{", "}", str);
+      if (!m)
+        return str.split(",");
+      var pre = m.pre;
+      var body = m.body;
+      var post = m.post;
+      var p = pre.split(",");
+      p[p.length - 1] += "{" + body + "}";
+      var postParts = parseCommaParts(post);
+      if (post.length) {
+        p[p.length - 1] += postParts.shift();
+        p.push.apply(p, postParts);
+      }
+      parts.push.apply(parts, p);
+      return parts;
+    }
+    function expandTop(str) {
+      if (!str)
+        return [];
+      if (str.substr(0, 2) === "{}") {
+        str = "\\{\\}" + str.substr(2);
+      }
+      return expand2(escapeBraces(str), true).map(unescapeBraces);
+    }
+    function embrace(str) {
+      return "{" + str + "}";
+    }
+    function isPadded(el) {
+      return /^-?0\d/.test(el);
+    }
+    function lte(i, y) {
+      return i <= y;
+    }
+    function gte(i, y) {
+      return i >= y;
+    }
+    function expand2(str, isTop) {
+      var expansions = [];
+      var m = balanced("{", "}", str);
+      if (!m) return [str];
+      var pre = m.pre;
+      var post = m.post.length ? expand2(m.post, false) : [""];
+      if (/\$$/.test(m.pre)) {
+        for (var k = 0; k < post.length; k++) {
+          var expansion = pre + "{" + m.body + "}" + post[k];
+          expansions.push(expansion);
+        }
+      } else {
+        var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+        var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+        var isSequence = isNumericSequence || isAlphaSequence;
+        var isOptions = m.body.indexOf(",") >= 0;
+        if (!isSequence && !isOptions) {
+          if (m.post.match(/,.*\}/)) {
+            str = m.pre + "{" + m.body + escClose + m.post;
+            return expand2(str);
+          }
+          return [str];
+        }
+        var n;
+        if (isSequence) {
+          n = m.body.split(/\.\./);
+        } else {
+          n = parseCommaParts(m.body);
+          if (n.length === 1) {
+            n = expand2(n[0], false).map(embrace);
+            if (n.length === 1) {
+              return post.map(function(p) {
+                return m.pre + n[0] + p;
+              });
+            }
+          }
+        }
+        var N;
+        if (isSequence) {
+          var x = numeric(n[0]);
+          var y = numeric(n[1]);
+          var width = Math.max(n[0].length, n[1].length);
+          var incr = n.length == 3 ? Math.abs(numeric(n[2])) : 1;
+          var test = lte;
+          var reverse = y < x;
+          if (reverse) {
+            incr *= -1;
+            test = gte;
+          }
+          var pad = n.some(isPadded);
+          N = [];
+          for (var i = x; test(i, y); i += incr) {
+            var c;
+            if (isAlphaSequence) {
+              c = String.fromCharCode(i);
+              if (c === "\\")
+                c = "";
+            } else {
+              c = String(i);
+              if (pad) {
+                var need = width - c.length;
+                if (need > 0) {
+                  var z = new Array(need + 1).join("0");
+                  if (i < 0)
+                    c = "-" + z + c.slice(1);
+                  else
+                    c = z + c;
+                }
+              }
+            }
+            N.push(c);
+          }
+        } else {
+          N = [];
+          for (var j = 0; j < n.length; j++) {
+            N.push.apply(N, expand2(n[j], false));
+          }
+        }
+        for (var j = 0; j < N.length; j++) {
+          for (var k = 0; k < post.length; k++) {
+            var expansion = pre + N[j] + post[k];
+            if (!isTop || isSequence || expansion)
+              expansions.push(expansion);
+          }
+        }
+      }
+      return expansions;
+    }
+  }
+});
+
+// ../cli-test-overrides/src/constants.ts
+var TEST_OVERRIDES_ENV_VAR = "WIX_CLI_TEST_OVERRIDES";
+
+// ../../node_modules/vite/dist/node/runtime.js
+var VALID_ID_PREFIX = "/@id/";
+var NULL_BYTE_PLACEHOLDER = "__x00__";
+var SOURCEMAPPING_URL = "sourceMa";
+SOURCEMAPPING_URL += "ppingURL";
+var isWindows = typeof process < "u" && process.platform === "win32";
+function wrapId(id) {
+  return id.startsWith(VALID_ID_PREFIX) ? id : VALID_ID_PREFIX + id.replace("\0", NULL_BYTE_PLACEHOLDER);
+}
+function unwrapId(id) {
+  return id.startsWith(VALID_ID_PREFIX) ? id.slice(VALID_ID_PREFIX.length).replace(NULL_BYTE_PLACEHOLDER, "\0") : id;
+}
+var windowsSlashRE = /\\/g;
+function slash(p) {
+  return p.replace(windowsSlashRE, "/");
+}
+var postfixRE = /[?#].*$/;
+function cleanUrl(url) {
+  return url.replace(postfixRE, "");
+}
+function isPrimitive(value) {
+  return !value || typeof value != "object" && typeof value != "function";
+}
+function withTrailingSlash(path2) {
+  return path2[path2.length - 1] !== "/" ? `${path2}/` : path2;
+}
+var AsyncFunction = async function() {
+}.constructor;
+var _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+  return input && input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+var _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+var _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+function cwd() {
+  return typeof process < "u" && typeof process.cwd == "function" ? process.cwd().replace(/\\/g, "/") : "/";
+}
+var resolve = function(...arguments_) {
+  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+  let resolvedPath = "", resolvedAbsolute = false;
+  for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+    const path2 = index >= 0 ? arguments_[index] : cwd();
+    !path2 || path2.length === 0 || (resolvedPath = `${path2}/${resolvedPath}`, resolvedAbsolute = isAbsolute(path2));
+  }
+  return resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute), resolvedAbsolute && !isAbsolute(resolvedPath) ? `/${resolvedPath}` : resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path2, allowAboveRoot) {
+  let res = "", lastSegmentLength = 0, lastSlash = -1, dots = 0, char = null;
+  for (let index = 0; index <= path2.length; ++index) {
+    if (index < path2.length)
+      char = path2[index];
+    else {
+      if (char === "/")
+        break;
+      char = "/";
+    }
+    if (char === "/") {
+      if (!(lastSlash === index - 1 || dots === 1)) if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            lastSlashIndex === -1 ? (res = "", lastSegmentLength = 0) : (res = res.slice(0, lastSlashIndex), lastSegmentLength = res.length - 1 - res.lastIndexOf("/")), lastSlash = index, dots = 0;
+            continue;
+          } else if (res.length > 0) {
+            res = "", lastSegmentLength = 0, lastSlash = index, dots = 0;
+            continue;
+          }
+        }
+        allowAboveRoot && (res += res.length > 0 ? "/.." : "..", lastSegmentLength = 2);
+      } else
+        res.length > 0 ? res += `/${path2.slice(lastSlash + 1, index)}` : res = path2.slice(lastSlash + 1, index), lastSegmentLength = index - lastSlash - 1;
+      lastSlash = index, dots = 0;
+    } else char === "." && dots !== -1 ? ++dots : dots = -1;
+  }
+  return res;
+}
+var isAbsolute = function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+};
+var dirname = function(p) {
+  const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
+  return segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0]) && (segments[0] += "/"), segments.join("/") || (isAbsolute(p) ? "/" : ".");
+};
+var decodeBase64 = typeof atob < "u" ? atob : (str) => Buffer.from(str, "base64").toString("utf-8");
+var CHAR_FORWARD_SLASH = 47;
+var CHAR_BACKWARD_SLASH = 92;
+var percentRegEx = /%/g;
+var backslashRegEx = /\\/g;
+var newlineRegEx = /\n/g;
+var carriageReturnRegEx = /\r/g;
+var tabRegEx = /\t/g;
+var questionRegex = /\?/g;
+var hashRegex = /#/g;
+function encodePathChars(filepath) {
+  return filepath.indexOf("%") !== -1 && (filepath = filepath.replace(percentRegEx, "%25")), !isWindows && filepath.indexOf("\\") !== -1 && (filepath = filepath.replace(backslashRegEx, "%5C")), filepath.indexOf(`
+`) !== -1 && (filepath = filepath.replace(newlineRegEx, "%0A")), filepath.indexOf("\r") !== -1 && (filepath = filepath.replace(carriageReturnRegEx, "%0D")), filepath.indexOf("	") !== -1 && (filepath = filepath.replace(tabRegEx, "%09")), filepath;
+}
+var posixDirname = dirname;
+var posixResolve = resolve;
+function posixPathToFileHref(posixPath) {
+  let resolved = posixResolve(posixPath);
+  const filePathLast = posixPath.charCodeAt(posixPath.length - 1);
+  return (filePathLast === CHAR_FORWARD_SLASH || isWindows && filePathLast === CHAR_BACKWARD_SLASH) && resolved[resolved.length - 1] !== "/" && (resolved += "/"), resolved = encodePathChars(resolved), resolved.indexOf("?") !== -1 && (resolved = resolved.replace(questionRegex, "%3F")), resolved.indexOf("#") !== -1 && (resolved = resolved.replace(hashRegex, "%23")), new URL(`file://${resolved}`).href;
+}
+function toWindowsPath(path2) {
+  return path2.replace(/\//g, "\\");
+}
+var comma = 44;
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+  const c = chars.charCodeAt(i);
+  intToChar[i] = c, charToInt[c] = i;
+}
+function decodeInteger(reader, relative2) {
+  let value = 0, shift = 0, integer = 0;
+  do {
+    const c = reader.next();
+    integer = charToInt[c], value |= (integer & 31) << shift, shift += 5;
+  } while (integer & 32);
+  const shouldNegate = value & 1;
+  return value >>>= 1, shouldNegate && (value = -2147483648 | -value), relative2 + value;
+}
+function hasMoreVlq(reader, max) {
+  return reader.pos >= max ? false : reader.peek() !== comma;
+}
+var StringReader = class {
+  constructor(buffer) {
+    this.pos = 0, this.buffer = buffer;
+  }
+  next() {
+    return this.buffer.charCodeAt(this.pos++);
+  }
+  peek() {
+    return this.buffer.charCodeAt(this.pos);
+  }
+  indexOf(char) {
+    const { buffer, pos } = this, idx = buffer.indexOf(char, pos);
+    return idx === -1 ? buffer.length : idx;
+  }
+};
+function decode(mappings) {
+  const { length } = mappings, reader = new StringReader(mappings), decoded = [];
+  let genColumn = 0, sourcesIndex = 0, sourceLine = 0, sourceColumn = 0, namesIndex = 0;
+  do {
+    const semi = reader.indexOf(";"), line = [];
+    let sorted = true, lastCol = 0;
+    for (genColumn = 0; reader.pos < semi; ) {
+      let seg;
+      genColumn = decodeInteger(reader, genColumn), genColumn < lastCol && (sorted = false), lastCol = genColumn, hasMoreVlq(reader, semi) ? (sourcesIndex = decodeInteger(reader, sourcesIndex), sourceLine = decodeInteger(reader, sourceLine), sourceColumn = decodeInteger(reader, sourceColumn), hasMoreVlq(reader, semi) ? (namesIndex = decodeInteger(reader, namesIndex), seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex]) : seg = [genColumn, sourcesIndex, sourceLine, sourceColumn]) : seg = [genColumn], line.push(seg), reader.pos++;
+    }
+    sorted || sort(line), decoded.push(line), reader.pos = semi + 1;
+  } while (reader.pos <= length);
+  return decoded;
+}
+function sort(line) {
+  line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+  return a[0] - b[0];
+}
+var COLUMN = 0;
+var SOURCES_INDEX = 1;
+var SOURCE_LINE = 2;
+var SOURCE_COLUMN = 3;
+var NAMES_INDEX = 4;
+var found = false;
+function binarySearch(haystack, needle, low, high) {
+  for (; low <= high; ) {
+    const mid = low + (high - low >> 1), cmp = haystack[mid][COLUMN] - needle;
+    if (cmp === 0)
+      return found = true, mid;
+    cmp < 0 ? low = mid + 1 : high = mid - 1;
+  }
+  return found = false, low - 1;
+}
+function upperBound(haystack, needle, index) {
+  for (let i = index + 1; i < haystack.length && haystack[i][COLUMN] === needle; index = i++)
+    ;
+  return index;
+}
+function lowerBound(haystack, needle, index) {
+  for (let i = index - 1; i >= 0 && haystack[i][COLUMN] === needle; index = i--)
+    ;
+  return index;
+}
+function memoizedBinarySearch(haystack, needle, state, key) {
+  const { lastKey, lastNeedle, lastIndex } = state;
+  let low = 0, high = haystack.length - 1;
+  if (key === lastKey) {
+    if (needle === lastNeedle)
+      return found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle, lastIndex;
+    needle >= lastNeedle ? low = lastIndex === -1 ? 0 : lastIndex : high = lastIndex;
+  }
+  return state.lastKey = key, state.lastNeedle = needle, state.lastIndex = binarySearch(haystack, needle, low, high);
+}
+var LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)";
+var COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)";
+var LEAST_UPPER_BOUND = -1;
+var GREATEST_LOWER_BOUND = 1;
+function decodedMappings(map) {
+  var _a;
+  return (_a = map)._decoded || (_a._decoded = decode(map._encoded));
+}
+function originalPositionFor(map, needle) {
+  let { line, column, bias } = needle;
+  if (line--, line < 0)
+    throw new Error(LINE_GTR_ZERO);
+  if (column < 0)
+    throw new Error(COL_GTR_EQ_ZERO);
+  const decoded = decodedMappings(map);
+  if (line >= decoded.length)
+    return OMapping(null, null, null, null);
+  const segments = decoded[line], index = traceSegmentInternal(segments, map._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
+  if (index === -1)
+    return OMapping(null, null, null, null);
+  const segment = segments[index];
+  if (segment.length === 1)
+    return OMapping(null, null, null, null);
+  const { names, resolvedSources } = map;
+  return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], segment.length === 5 ? names[segment[NAMES_INDEX]] : null);
+}
+function OMapping(source, line, column, name) {
+  return { source, line, column, name };
+}
+function traceSegmentInternal(segments, memo, line, column, bias) {
+  let index = memoizedBinarySearch(segments, column, memo, line);
+  return found ? index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index) : bias === LEAST_UPPER_BOUND && index++, index === -1 || index === segments.length ? -1 : index;
+}
+var DecodedMap = class {
+  constructor(map, from) {
+    this.map = map;
+    const { mappings, names, sources } = map;
+    this.version = map.version, this.names = names || [], this._encoded = mappings || "", this._decodedMemo = memoizedState(), this.url = from, this.resolvedSources = (sources || []).map(
+      (s) => posixResolve(s || "", from)
+    );
+  }
+  _encoded;
+  _decoded;
+  _decodedMemo;
+  url;
+  version;
+  names = [];
+  resolvedSources;
+};
+function memoizedState() {
+  return {
+    lastKey: -1,
+    lastNeedle: -1,
+    lastIndex: -1
+  };
+}
+function getOriginalPosition(map, needle) {
+  const result = originalPositionFor(map, needle);
+  return result.column == null ? null : result;
+}
+var VITE_RUNTIME_SOURCEMAPPING_REGEXP = new RegExp(
+  `//# ${SOURCEMAPPING_URL}=data:application/json;base64,(.+)`
+);
+var ModuleCacheMap = class extends Map {
+  root;
+  constructor(root, entries) {
+    super(entries), this.root = withTrailingSlash(root);
+  }
+  normalize(fsPath) {
+    return normalizeModuleId(fsPath, this.root);
+  }
+  /**
+   * Assign partial data to the map
+   */
+  update(fsPath, mod) {
+    return fsPath = this.normalize(fsPath), super.has(fsPath) ? Object.assign(super.get(fsPath), mod) : this.setByModuleId(fsPath, mod), this;
+  }
+  setByModuleId(modulePath, mod) {
+    return super.set(modulePath, mod);
+  }
+  set(fsPath, mod) {
+    return this.setByModuleId(this.normalize(fsPath), mod);
+  }
+  getByModuleId(modulePath) {
+    super.has(modulePath) || this.setByModuleId(modulePath, {});
+    const mod = super.get(modulePath);
+    return mod.imports || Object.assign(mod, {
+      imports: /* @__PURE__ */ new Set(),
+      importers: /* @__PURE__ */ new Set()
+    }), mod;
+  }
+  get(fsPath) {
+    return this.getByModuleId(this.normalize(fsPath));
+  }
+  deleteByModuleId(modulePath) {
+    return super.delete(modulePath);
+  }
+  delete(fsPath) {
+    return this.deleteByModuleId(this.normalize(fsPath));
+  }
+  invalidate(id) {
+    const module = this.get(id);
+    module.evaluated = false, module.meta = void 0, module.map = void 0, module.promise = void 0, module.exports = void 0, module.imports?.clear();
+  }
+  isImported({
+    importedId,
+    importedBy
+  }, seen = /* @__PURE__ */ new Set()) {
+    if (importedId = this.normalize(importedId), importedBy = this.normalize(importedBy), importedBy === importedId) return true;
+    if (seen.has(importedId)) return false;
+    seen.add(importedId);
+    const importers = this.getByModuleId(importedId)?.importers;
+    if (!importers) return false;
+    if (importers.has(importedBy)) return true;
+    for (const importer of importers)
+      if (this.isImported({
+        importedBy,
+        importedId: importer
+      }))
+        return true;
+    return false;
+  }
+  /**
+   * Invalidate modules that dependent on the given modules, up to the main entry
+   */
+  invalidateDepTree(ids, invalidated = /* @__PURE__ */ new Set()) {
+    for (const _id of ids) {
+      const id = this.normalize(_id);
+      if (invalidated.has(id)) continue;
+      invalidated.add(id);
+      const mod = super.get(id);
+      mod?.importers && this.invalidateDepTree(mod.importers, invalidated), super.delete(id);
+    }
+    return invalidated;
+  }
+  /**
+   * Invalidate dependency modules of the given modules, down to the bottom-level dependencies
+   */
+  invalidateSubDepTree(ids, invalidated = /* @__PURE__ */ new Set()) {
+    for (const _id of ids) {
+      const id = this.normalize(_id);
+      if (invalidated.has(id)) continue;
+      invalidated.add(id);
+      const subIds = Array.from(super.entries()).filter(([, mod]) => mod.importers?.has(id)).map(([key]) => key);
+      subIds.length && this.invalidateSubDepTree(subIds, invalidated), super.delete(id);
+    }
+    return invalidated;
+  }
+  getSourceMap(moduleId) {
+    const mod = this.get(moduleId);
+    if (mod.map) return mod.map;
+    if (!mod.meta || !("code" in mod.meta)) return null;
+    const mapString = VITE_RUNTIME_SOURCEMAPPING_REGEXP.exec(mod.meta.code)?.[1];
+    if (!mapString) return null;
+    const baseFile = mod.meta.file || moduleId.split("?")[0];
+    return mod.map = new DecodedMap(JSON.parse(decodeBase64(mapString)), baseFile), mod.map;
+  }
+};
+var prefixedBuiltins = /* @__PURE__ */ new Set(["node:test"]);
+function normalizeModuleId(file, root) {
+  if (prefixedBuiltins.has(file)) return file;
+  let unixFile = slash(file).replace(/^\/@fs\//, isWindows ? "" : "/").replace(/^node:/, "").replace(/^\/+/, "/");
+  return unixFile.startsWith(root) && (unixFile = unixFile.slice(root.length - 1)), unixFile.replace(/^file:\//, "/");
+}
+var HMRContext = class {
+  constructor(hmrClient, ownerPath) {
+    this.hmrClient = hmrClient, this.ownerPath = ownerPath, hmrClient.dataMap.has(ownerPath) || hmrClient.dataMap.set(ownerPath, {});
+    const mod = hmrClient.hotModulesMap.get(ownerPath);
+    mod && (mod.callbacks = []);
+    const staleListeners = hmrClient.ctxToListenersMap.get(ownerPath);
+    if (staleListeners)
+      for (const [event, staleFns] of staleListeners) {
+        const listeners = hmrClient.customListenersMap.get(event);
+        listeners && hmrClient.customListenersMap.set(
+          event,
+          listeners.filter((l) => !staleFns.includes(l))
+        );
+      }
+    this.newListeners = /* @__PURE__ */ new Map(), hmrClient.ctxToListenersMap.set(ownerPath, this.newListeners);
+  }
+  newListeners;
+  get data() {
+    return this.hmrClient.dataMap.get(this.ownerPath);
+  }
+  accept(deps, callback) {
+    if (typeof deps == "function" || !deps)
+      this.acceptDeps([this.ownerPath], ([mod]) => deps?.(mod));
+    else if (typeof deps == "string")
+      this.acceptDeps([deps], ([mod]) => callback?.(mod));
+    else if (Array.isArray(deps))
+      this.acceptDeps(deps, callback);
+    else
+      throw new Error("invalid hot.accept() usage.");
+  }
+  // export names (first arg) are irrelevant on the client side, they're
+  // extracted in the server for propagation
+  acceptExports(_, callback) {
+    this.acceptDeps([this.ownerPath], ([mod]) => callback?.(mod));
+  }
+  dispose(cb) {
+    this.hmrClient.disposeMap.set(this.ownerPath, cb);
+  }
+  prune(cb) {
+    this.hmrClient.pruneMap.set(this.ownerPath, cb);
+  }
+  // Kept for backward compatibility (#11036)
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  decline() {
+  }
+  invalidate(message) {
+    this.hmrClient.notifyListeners("vite:invalidate", {
+      path: this.ownerPath,
+      message
+    }), this.send("vite:invalidate", { path: this.ownerPath, message }), this.hmrClient.logger.debug(
+      `[vite] invalidate ${this.ownerPath}${message ? `: ${message}` : ""}`
+    );
+  }
+  on(event, cb) {
+    const addToMap = (map) => {
+      const existing = map.get(event) || [];
+      existing.push(cb), map.set(event, existing);
+    };
+    addToMap(this.hmrClient.customListenersMap), addToMap(this.newListeners);
+  }
+  off(event, cb) {
+    const removeFromMap = (map) => {
+      const existing = map.get(event);
+      if (existing === void 0)
+        return;
+      const pruned = existing.filter((l) => l !== cb);
+      if (pruned.length === 0) {
+        map.delete(event);
+        return;
+      }
+      map.set(event, pruned);
+    };
+    removeFromMap(this.hmrClient.customListenersMap), removeFromMap(this.newListeners);
+  }
+  send(event, data) {
+    this.hmrClient.messenger.send(
+      JSON.stringify({ type: "custom", event, data })
+    );
+  }
+  acceptDeps(deps, callback = () => {
+  }) {
+    const mod = this.hmrClient.hotModulesMap.get(this.ownerPath) || {
+      id: this.ownerPath,
+      callbacks: []
+    };
+    mod.callbacks.push({
+      deps,
+      fn: callback
+    }), this.hmrClient.hotModulesMap.set(this.ownerPath, mod);
+  }
+};
+var HMRMessenger = class {
+  constructor(connection) {
+    this.connection = connection;
+  }
+  queue = [];
+  send(message) {
+    this.queue.push(message), this.flush();
+  }
+  flush() {
+    this.connection.isReady() && (this.queue.forEach((msg) => this.connection.send(msg)), this.queue = []);
+  }
+};
+var HMRClient = class {
+  constructor(logger, connection, importUpdatedModule) {
+    this.logger = logger, this.importUpdatedModule = importUpdatedModule, this.messenger = new HMRMessenger(connection);
+  }
+  hotModulesMap = /* @__PURE__ */ new Map();
+  disposeMap = /* @__PURE__ */ new Map();
+  pruneMap = /* @__PURE__ */ new Map();
+  dataMap = /* @__PURE__ */ new Map();
+  customListenersMap = /* @__PURE__ */ new Map();
+  ctxToListenersMap = /* @__PURE__ */ new Map();
+  messenger;
+  async notifyListeners(event, data) {
+    const cbs = this.customListenersMap.get(event);
+    cbs && await Promise.allSettled(cbs.map((cb) => cb(data)));
+  }
+  clear() {
+    this.hotModulesMap.clear(), this.disposeMap.clear(), this.pruneMap.clear(), this.dataMap.clear(), this.customListenersMap.clear(), this.ctxToListenersMap.clear();
+  }
+  // After an HMR update, some modules are no longer imported on the page
+  // but they may have left behind side effects that need to be cleaned up
+  // (.e.g style injections)
+  async prunePaths(paths) {
+    await Promise.all(
+      paths.map((path2) => {
+        const disposer = this.disposeMap.get(path2);
+        if (disposer) return disposer(this.dataMap.get(path2));
+      })
+    ), paths.forEach((path2) => {
+      const fn = this.pruneMap.get(path2);
+      fn && fn(this.dataMap.get(path2));
+    });
+  }
+  warnFailedUpdate(err, path2) {
+    err.message.includes("fetch") || this.logger.error(err), this.logger.error(
+      `[hmr] Failed to reload ${path2}. This could be due to syntax errors or importing non-existent modules. (see errors above)`
+    );
+  }
+  updateQueue = [];
+  pendingUpdateQueue = false;
+  /**
+   * buffer multiple hot updates triggered by the same src change
+   * so that they are invoked in the same order they were sent.
+   * (otherwise the order may be inconsistent because of the http request round trip)
+   */
+  async queueUpdate(payload) {
+    if (this.updateQueue.push(this.fetchUpdate(payload)), !this.pendingUpdateQueue) {
+      this.pendingUpdateQueue = true, await Promise.resolve(), this.pendingUpdateQueue = false;
+      const loading = [...this.updateQueue];
+      this.updateQueue = [], (await Promise.all(loading)).forEach((fn) => fn && fn());
+    }
+  }
+  async fetchUpdate(update) {
+    const { path: path2, acceptedPath } = update, mod = this.hotModulesMap.get(path2);
+    if (!mod)
+      return;
+    let fetchedModule;
+    const isSelfUpdate = path2 === acceptedPath, qualifiedCallbacks = mod.callbacks.filter(
+      ({ deps }) => deps.includes(acceptedPath)
+    );
+    if (isSelfUpdate || qualifiedCallbacks.length > 0) {
+      const disposer = this.disposeMap.get(acceptedPath);
+      disposer && await disposer(this.dataMap.get(acceptedPath));
+      try {
+        fetchedModule = await this.importUpdatedModule(update);
+      } catch (e) {
+        this.warnFailedUpdate(e, acceptedPath);
+      }
+    }
+    return () => {
+      for (const { deps, fn } of qualifiedCallbacks)
+        fn(
+          deps.map((dep) => dep === acceptedPath ? fetchedModule : void 0)
+        );
+      const loggedPath = isSelfUpdate ? path2 : `${acceptedPath} via ${path2}`;
+      this.logger.debug(`[vite] hot updated: ${loggedPath}`);
+    };
+  }
+};
+function analyzeImportedModDifference(mod, rawId, moduleType, metadata) {
+  if (!metadata?.isDynamicImport && metadata?.importedNames?.length) {
+    const missingBindings = metadata.importedNames.filter((s) => !(s in mod));
+    if (missingBindings.length) {
+      const lastBinding = missingBindings[missingBindings.length - 1];
+      throw moduleType === "module" ? new SyntaxError(
+        `[vite] The requested module '${rawId}' does not provide an export named '${lastBinding}'`
+      ) : new SyntaxError(`[vite] Named export '${lastBinding}' not found. The requested module '${rawId}' is a CommonJS module, which may not support all module.exports as named exports.
+CommonJS modules can always be imported via the default export, for example using:
+
+import pkg from '${rawId}';
+const {${missingBindings.join(", ")}} = pkg;
+`);
+    }
+  }
+}
+var ssrModuleExportsKey = "__vite_ssr_exports__";
+var ssrImportKey = "__vite_ssr_import__";
+var ssrDynamicImportKey = "__vite_ssr_dynamic_import__";
+var ssrExportAllKey = "__vite_ssr_exportAll__";
+var ssrImportMetaKey = "__vite_ssr_import_meta__";
+var noop = () => {
+};
+var silentConsole = {
+  debug: noop,
+  error: noop
+};
+function createHMRHandler(runtime2) {
+  const queue = new Queue();
+  return (payload) => queue.enqueue(() => handleHMRPayload(runtime2, payload));
+}
+async function handleHMRPayload(runtime2, payload) {
+  const hmrClient = runtime2.hmrClient;
+  if (!(!hmrClient || runtime2.isDestroyed()))
+    switch (payload.type) {
+      case "connected":
+        hmrClient.logger.debug("[vite] connected."), hmrClient.messenger.flush();
+        break;
+      case "update":
+        await hmrClient.notifyListeners("vite:beforeUpdate", payload), await Promise.all(
+          payload.updates.map(async (update) => {
+            if (update.type === "js-update")
+              return update.acceptedPath = unwrapId(update.acceptedPath), update.path = unwrapId(update.path), hmrClient.queueUpdate(update);
+            hmrClient.logger.error(
+              "[vite] css hmr is not supported in runtime mode."
+            );
+          })
+        ), await hmrClient.notifyListeners("vite:afterUpdate", payload);
+        break;
+      case "custom": {
+        await hmrClient.notifyListeners(payload.event, payload.data);
+        break;
+      }
+      case "full-reload": {
+        const { triggeredBy } = payload, clearEntrypoints = triggeredBy ? [...runtime2.entrypoints].filter(
+          (entrypoint) => runtime2.moduleCache.isImported({
+            importedId: triggeredBy,
+            importedBy: entrypoint
+          })
+        ) : [...runtime2.entrypoints];
+        if (!clearEntrypoints.length) break;
+        hmrClient.logger.debug("[vite] program reload"), await hmrClient.notifyListeners("vite:beforeFullReload", payload), runtime2.moduleCache.clear();
+        for (const id of clearEntrypoints)
+          await runtime2.executeUrl(id);
+        break;
+      }
+      case "prune":
+        await hmrClient.notifyListeners("vite:beforePrune", payload), await hmrClient.prunePaths(payload.paths);
+        break;
+      case "error": {
+        await hmrClient.notifyListeners("vite:error", payload);
+        const err = payload.err;
+        hmrClient.logger.error(
+          `[vite] Internal Server Error
+${err.message}
+${err.stack}`
+        );
+        break;
+      }
+      default:
+        return payload;
+    }
+}
+var Queue = class {
+  queue = [];
+  pending = false;
+  enqueue(promise) {
+    return new Promise((resolve2, reject) => {
+      this.queue.push({
+        promise,
+        resolve: resolve2,
+        reject
+      }), this.dequeue();
+    });
+  }
+  dequeue() {
+    if (this.pending)
+      return false;
+    const item = this.queue.shift();
+    return item ? (this.pending = true, item.promise().then(item.resolve).catch(item.reject).finally(() => {
+      this.pending = false, this.dequeue();
+    }), true) : false;
+  }
+};
+var sourceMapCache = {};
+var fileContentsCache = {};
+var moduleGraphs = /* @__PURE__ */ new Set();
+var retrieveFileHandlers = /* @__PURE__ */ new Set();
+var retrieveSourceMapHandlers = /* @__PURE__ */ new Set();
+var createExecHandlers = (handlers) => (...args) => {
+  for (const handler of handlers) {
+    const result = handler(...args);
+    if (result) return result;
+  }
+  return null;
+};
+var retrieveFileFromHandlers = createExecHandlers(retrieveFileHandlers);
+var retrieveSourceMapFromHandlers = createExecHandlers(
+  retrieveSourceMapHandlers
+);
+var overridden = false;
+var originalPrepare = Error.prepareStackTrace;
+function resetInterceptor(runtime2, options) {
+  moduleGraphs.delete(runtime2.moduleCache), options.retrieveFile && retrieveFileHandlers.delete(options.retrieveFile), options.retrieveSourceMap && retrieveSourceMapHandlers.delete(options.retrieveSourceMap), moduleGraphs.size === 0 && (Error.prepareStackTrace = originalPrepare, overridden = false);
+}
+function interceptStackTrace(runtime2, options = {}) {
+  return overridden || (Error.prepareStackTrace = prepareStackTrace, overridden = true), moduleGraphs.add(runtime2.moduleCache), options.retrieveFile && retrieveFileHandlers.add(options.retrieveFile), options.retrieveSourceMap && retrieveSourceMapHandlers.add(options.retrieveSourceMap), () => resetInterceptor(runtime2, options);
+}
+function supportRelativeURL(file, url) {
+  if (!file) return url;
+  const dir = posixDirname(slash(file)), match2 = /^\w+:\/\/[^/]*/.exec(dir);
+  let protocol = match2 ? match2[0] : "";
+  const startPath = dir.slice(protocol.length);
+  return protocol && /^\/\w:/.test(startPath) ? (protocol += "/", protocol + slash(posixResolve(startPath, url))) : protocol + posixResolve(startPath, url);
+}
+function getRuntimeSourceMap(position) {
+  for (const moduleCache of moduleGraphs) {
+    const sourceMap = moduleCache.getSourceMap(position.source);
+    if (sourceMap)
+      return {
+        url: position.source,
+        map: sourceMap,
+        vite: true
+      };
+  }
+  return null;
+}
+function retrieveFile(path2) {
+  if (path2 in fileContentsCache) return fileContentsCache[path2];
+  const content = retrieveFileFromHandlers(path2);
+  return typeof content == "string" ? (fileContentsCache[path2] = content, content) : null;
+}
+function retrieveSourceMapURL(source) {
+  const fileData = retrieveFile(source);
+  if (!fileData) return null;
+  const re = /\/\/[@#]\s*sourceMappingURL=([^\s'"]+)\s*$|\/\*[@#]\s*sourceMappingURL=[^\s*'"]+\s*\*\/\s*$/gm;
+  let lastMatch, match2;
+  for (; match2 = re.exec(fileData); ) lastMatch = match2;
+  return lastMatch ? lastMatch[1] : null;
+}
+var reSourceMap = /^data:application\/json[^,]+base64,/;
+function retrieveSourceMap(source) {
+  const urlAndMap = retrieveSourceMapFromHandlers(source);
+  if (urlAndMap) return urlAndMap;
+  let sourceMappingURL = retrieveSourceMapURL(source);
+  if (!sourceMappingURL) return null;
+  let sourceMapData;
+  if (reSourceMap.test(sourceMappingURL)) {
+    const rawData = sourceMappingURL.slice(sourceMappingURL.indexOf(",") + 1);
+    sourceMapData = Buffer.from(rawData, "base64").toString(), sourceMappingURL = source;
+  } else
+    sourceMappingURL = supportRelativeURL(source, sourceMappingURL), sourceMapData = retrieveFile(sourceMappingURL);
+  return sourceMapData ? {
+    url: sourceMappingURL,
+    map: sourceMapData
+  } : null;
+}
+function mapSourcePosition(position) {
+  if (!position.source) return position;
+  let sourceMap = getRuntimeSourceMap(position);
+  if (sourceMap || (sourceMap = sourceMapCache[position.source]), !sourceMap) {
+    const urlAndMap = retrieveSourceMap(position.source);
+    if (urlAndMap && urlAndMap.map) {
+      const url = urlAndMap.url;
+      sourceMap = sourceMapCache[position.source] = {
+        url,
+        map: new DecodedMap(
+          typeof urlAndMap.map == "string" ? JSON.parse(urlAndMap.map) : urlAndMap.map,
+          url
+        )
+      };
+      const contents = sourceMap.map?.map.sourcesContent;
+      sourceMap.map && contents && sourceMap.map.resolvedSources.forEach((source, i) => {
+        const content = contents[i];
+        if (content && source && url) {
+          const contentUrl = supportRelativeURL(url, source);
+          fileContentsCache[contentUrl] = content;
+        }
+      });
+    } else
+      sourceMap = sourceMapCache[position.source] = {
+        url: null,
+        map: null
+      };
+  }
+  if (sourceMap && sourceMap.map && sourceMap.url) {
+    const originalPosition = getOriginalPosition(sourceMap.map, position);
+    if (originalPosition && originalPosition.source != null)
+      return originalPosition.source = supportRelativeURL(
+        sourceMap.url,
+        originalPosition.source
+      ), sourceMap.vite && (originalPosition._vite = true), originalPosition;
+  }
+  return position;
+}
+function mapEvalOrigin(origin) {
+  let match2 = /^eval at ([^(]+) \((.+):(\d+):(\d+)\)$/.exec(origin);
+  if (match2) {
+    const position = mapSourcePosition({
+      name: null,
+      source: match2[2],
+      line: +match2[3],
+      column: +match2[4] - 1
+    });
+    return `eval at ${match2[1]} (${position.source}:${position.line}:${position.column + 1})`;
+  }
+  return match2 = /^eval at ([^(]+) \((.+)\)$/.exec(origin), match2 ? `eval at ${match2[1]} (${mapEvalOrigin(match2[2])})` : origin;
+}
+function CallSiteToString() {
+  let fileName, fileLocation = "";
+  if (this.isNative())
+    fileLocation = "native";
+  else {
+    fileName = this.getScriptNameOrSourceURL(), !fileName && this.isEval() && (fileLocation = this.getEvalOrigin(), fileLocation += ", "), fileName ? fileLocation += fileName : fileLocation += "<anonymous>";
+    const lineNumber = this.getLineNumber();
+    if (lineNumber != null) {
+      fileLocation += `:${lineNumber}`;
+      const columnNumber = this.getColumnNumber();
+      columnNumber && (fileLocation += `:${columnNumber}`);
+    }
+  }
+  let line = "";
+  const functionName = this.getFunctionName();
+  let addSuffix = true;
+  const isConstructor = this.isConstructor();
+  if (this.isToplevel() || isConstructor)
+    isConstructor ? line += `new ${functionName || "<anonymous>"}` : functionName ? line += functionName : (line += fileLocation, addSuffix = false);
+  else {
+    let typeName = this.getTypeName();
+    typeName === "[object Object]" && (typeName = "null");
+    const methodName = this.getMethodName();
+    functionName ? (typeName && functionName.indexOf(typeName) !== 0 && (line += `${typeName}.`), line += functionName, methodName && functionName.indexOf(`.${methodName}`) !== functionName.length - methodName.length - 1 && (line += ` [as ${methodName}]`)) : line += `${typeName}.${methodName || "<anonymous>"}`;
+  }
+  return addSuffix && (line += ` (${fileLocation})`), line;
+}
+function cloneCallSite(frame) {
+  const object = {};
+  return Object.getOwnPropertyNames(Object.getPrototypeOf(frame)).forEach((name) => {
+    const key = name;
+    object[key] = /^(?:is|get)/.test(name) ? function() {
+      return frame[key].call(frame);
+    } : frame[key];
+  }), object.toString = CallSiteToString, object;
+}
+function wrapCallSite(frame, state) {
+  if (state === void 0 && (state = { nextPosition: null, curPosition: null }), frame.isNative())
+    return state.curPosition = null, frame;
+  const source = frame.getFileName() || frame.getScriptNameOrSourceURL();
+  if (source) {
+    const line = frame.getLineNumber();
+    let column = frame.getColumnNumber() - 1;
+    const headerLength = 62;
+    line === 1 && column > headerLength && !frame.isEval() && (column -= headerLength);
+    const position = mapSourcePosition({
+      name: null,
+      source,
+      line,
+      column
+    });
+    state.curPosition = position, frame = cloneCallSite(frame);
+    const originalFunctionName = frame.getFunctionName;
+    return frame.getFunctionName = function() {
+      const name = state.nextPosition == null ? originalFunctionName() : state.nextPosition.name || originalFunctionName();
+      return name === "eval" && "_vite" in position ? null : name;
+    }, frame.getFileName = function() {
+      return position.source ?? void 0;
+    }, frame.getLineNumber = function() {
+      return position.line;
+    }, frame.getColumnNumber = function() {
+      return position.column + 1;
+    }, frame.getScriptNameOrSourceURL = function() {
+      return position.source;
+    }, frame;
+  }
+  let origin = frame.isEval() && frame.getEvalOrigin();
+  return origin && (origin = mapEvalOrigin(origin), frame = cloneCallSite(frame), frame.getEvalOrigin = function() {
+    return origin || void 0;
+  }), frame;
+}
+function prepareStackTrace(error, stack) {
+  const name = error.name || "Error", message = error.message || "", errorString = `${name}: ${message}`, state = { nextPosition: null, curPosition: null }, processedStack = [];
+  for (let i = stack.length - 1; i >= 0; i--)
+    processedStack.push(`
+    at ${wrapCallSite(stack[i], state)}`), state.nextPosition = state.curPosition;
+  return state.curPosition = state.nextPosition = null, errorString + processedStack.reverse().join("");
+}
+function enableSourceMapSupport(runtime2) {
+  if (runtime2.options.sourcemapInterceptor === "node") {
+    if (typeof process > "u")
+      throw new TypeError(
+        `Cannot use "sourcemapInterceptor: 'node'" because global "process" variable is not available.`
+      );
+    if (typeof process.setSourceMapsEnabled != "function")
+      throw new TypeError(
+        `Cannot use "sourcemapInterceptor: 'node'" because "process.setSourceMapsEnabled" function is not available. Please use Node >= 16.6.0.`
+      );
+    const isEnabledAlready = process.sourceMapsEnabled ?? false;
+    return process.setSourceMapsEnabled(true), () => !isEnabledAlready && process.setSourceMapsEnabled(false);
+  }
+  return interceptStackTrace(
+    runtime2,
+    typeof runtime2.options.sourcemapInterceptor == "object" ? runtime2.options.sourcemapInterceptor : void 0
+  );
+}
+var ViteRuntime = class {
+  constructor(options, runner, debug) {
+    this.options = options, this.runner = runner, this.debug = debug, this.moduleCache = options.moduleCache ?? new ModuleCacheMap(options.root), typeof options.hmr == "object" && (this.hmrClient = new HMRClient(
+      options.hmr.logger === false ? silentConsole : options.hmr.logger || console,
+      options.hmr.connection,
+      ({ acceptedPath, ssrInvalidates }) => (this.moduleCache.invalidate(acceptedPath), ssrInvalidates && this.invalidateFiles(ssrInvalidates), this.executeUrl(acceptedPath))
+    ), options.hmr.connection.onUpdate(createHMRHandler(this))), options.sourcemapInterceptor !== false && (this._resetSourceMapSupport = enableSourceMapSupport(this));
+  }
+  /**
+   * Holds the cache of modules
+   * Keys of the map are ids
+   */
+  moduleCache;
+  hmrClient;
+  entrypoints = /* @__PURE__ */ new Set();
+  idToUrlMap = /* @__PURE__ */ new Map();
+  fileToIdMap = /* @__PURE__ */ new Map();
+  envProxy = new Proxy({}, {
+    get(_, p) {
+      throw new Error(
+        `[vite-runtime] Dynamic access of "import.meta.env" is not supported. Please, use "import.meta.env.${String(p)}" instead.`
+      );
+    }
+  });
+  _destroyed = false;
+  _resetSourceMapSupport;
+  /**
+   * URL to execute. Accepts file path, server path or id relative to the root.
+   */
+  async executeUrl(url) {
+    url = this.normalizeEntryUrl(url);
+    const fetchedModule = await this.cachedModule(url);
+    return await this.cachedRequest(url, fetchedModule);
+  }
+  /**
+   * Entrypoint URL to execute. Accepts file path, server path or id relative to the root.
+   * In the case of a full reload triggered by HMR, this is the module that will be reloaded.
+   * If this method is called multiple times, all entrypoints will be reloaded one at a time.
+   */
+  async executeEntrypoint(url) {
+    url = this.normalizeEntryUrl(url);
+    const fetchedModule = await this.cachedModule(url);
+    return await this.cachedRequest(url, fetchedModule, [], {
+      entrypoint: true
+    });
+  }
+  /**
+   * Clear all caches including HMR listeners.
+   */
+  clearCache() {
+    this.moduleCache.clear(), this.idToUrlMap.clear(), this.entrypoints.clear(), this.hmrClient?.clear();
+  }
+  /**
+   * Clears all caches, removes all HMR listeners, and resets source map support.
+   * This method doesn't stop the HMR connection.
+   */
+  async destroy() {
+    this._resetSourceMapSupport?.(), this.clearCache(), this.hmrClient = void 0, this._destroyed = true;
+  }
+  /**
+   * Returns `true` if the runtime has been destroyed by calling `destroy()` method.
+   */
+  isDestroyed() {
+    return this._destroyed;
+  }
+  invalidateFiles(files) {
+    files.forEach((file) => {
+      const ids = this.fileToIdMap.get(file);
+      ids && ids.forEach((id) => this.moduleCache.invalidate(id));
+    });
+  }
+  // we don't use moduleCache.normalize because this URL doesn't have to follow the same rules
+  // this URL is something that user passes down manually, and is later resolved by fetchModule
+  // moduleCache.normalize is used on resolved "file" property
+  normalizeEntryUrl(url) {
+    if (url[0] === ".")
+      return url;
+    url.startsWith("file://") && (url = url.slice(isWindows ? 8 : 7)), url = slash(url);
+    const _root = this.options.root, root = _root[_root.length - 1] === "/" ? _root : `${_root}/`;
+    return url.startsWith(root) ? url.slice(root.length - 1) : url[0] === "/" ? url : wrapId(url);
+  }
+  processImport(exports, fetchResult, metadata) {
+    if (!("externalize" in fetchResult))
+      return exports;
+    const { id, type } = fetchResult;
+    return type !== "module" && type !== "commonjs" || analyzeImportedModDifference(exports, id, type, metadata), exports;
+  }
+  async cachedRequest(id, fetchedModule, callstack = [], metadata) {
+    const moduleId = fetchedModule.id;
+    metadata?.entrypoint && this.entrypoints.add(moduleId);
+    const mod = this.moduleCache.getByModuleId(moduleId), { imports, importers } = mod, importee = callstack[callstack.length - 1];
+    if (importee && importers.add(importee), (callstack.includes(moduleId) || Array.from(imports.values()).some((i) => importers.has(i))) && mod.exports)
+      return this.processImport(mod.exports, fetchedModule, metadata);
+    let debugTimer;
+    this.debug && (debugTimer = setTimeout(() => {
+      const getStack = () => `stack:
+${[...callstack, moduleId].reverse().map((p) => `  - ${p}`).join(`
+`)}`;
+      this.debug(
+        `[vite-runtime] module ${moduleId} takes over 2s to load.
+${getStack()}`
+      );
+    }, 2e3));
+    try {
+      if (mod.promise)
+        return this.processImport(await mod.promise, fetchedModule, metadata);
+      const promise = this.directRequest(id, fetchedModule, callstack);
+      return mod.promise = promise, mod.evaluated = false, this.processImport(await promise, fetchedModule, metadata);
+    } finally {
+      mod.evaluated = true, debugTimer && clearTimeout(debugTimer);
+    }
+  }
+  async cachedModule(id, importer) {
+    if (this._destroyed)
+      throw new Error("[vite] Vite runtime has been destroyed.");
+    const normalized = this.idToUrlMap.get(id);
+    if (normalized) {
+      const mod2 = this.moduleCache.getByModuleId(normalized);
+      if (mod2.meta)
+        return mod2.meta;
+    }
+    this.debug?.("[vite-runtime] fetching", id);
+    const fetchedModule = id.startsWith("data:") ? { externalize: id, type: "builtin" } : await this.options.fetchModule(id, importer), idQuery = id.split("?")[1], query = idQuery ? `?${idQuery}` : "", file = "file" in fetchedModule ? fetchedModule.file : void 0, fullFile = file ? `${file}${query}` : id, moduleId = this.moduleCache.normalize(fullFile), mod = this.moduleCache.getByModuleId(moduleId);
+    if (fetchedModule.id = moduleId, mod.meta = fetchedModule, file) {
+      const fileModules = this.fileToIdMap.get(file) || [];
+      fileModules.push(moduleId), this.fileToIdMap.set(file, fileModules);
+    }
+    return this.idToUrlMap.set(id, moduleId), this.idToUrlMap.set(unwrapId(id), moduleId), fetchedModule;
+  }
+  // override is allowed, consider this a public API
+  async directRequest(id, fetchResult, _callstack) {
+    const moduleId = fetchResult.id, callstack = [..._callstack, moduleId], mod = this.moduleCache.getByModuleId(moduleId), request = async (dep, metadata) => {
+      const fetchedModule = await this.cachedModule(dep, moduleId);
+      return this.moduleCache.getByModuleId(fetchedModule.id).importers.add(moduleId), mod.imports.add(fetchedModule.id), this.cachedRequest(dep, fetchedModule, callstack, metadata);
+    }, dynamicRequest = async (dep) => (dep = String(dep), dep[0] === "." && (dep = posixResolve(posixDirname(id), dep)), request(dep, { isDynamicImport: true }));
+    if ("externalize" in fetchResult) {
+      const { externalize } = fetchResult;
+      this.debug?.("[vite-runtime] externalizing", externalize);
+      const exports2 = await this.runner.runExternalModule(externalize);
+      return mod.exports = exports2, exports2;
+    }
+    const { code, file } = fetchResult;
+    if (code == null) {
+      const importer = callstack[callstack.length - 2];
+      throw new Error(
+        `[vite-runtime] Failed to load "${id}"${importer ? ` imported from ${importer}` : ""}`
+      );
+    }
+    const modulePath = cleanUrl(file || moduleId), href = posixPathToFileHref(modulePath), filename = modulePath, dirname2 = posixDirname(modulePath), meta = {
+      filename: isWindows ? toWindowsPath(filename) : filename,
+      dirname: isWindows ? toWindowsPath(dirname2) : dirname2,
+      url: href,
+      env: this.envProxy,
+      resolve(id2, parent) {
+        throw new Error(
+          '[vite-runtime] "import.meta.resolve" is not supported.'
+        );
+      },
+      // should be replaced during transformation
+      glob() {
+        throw new Error('[vite-runtime] "import.meta.glob" is not supported.');
+      }
+    }, exports = /* @__PURE__ */ Object.create(null);
+    Object.defineProperty(exports, Symbol.toStringTag, {
+      value: "Module",
+      enumerable: false,
+      configurable: false
+    }), mod.exports = exports;
+    let hotContext;
+    this.hmrClient && Object.defineProperty(meta, "hot", {
+      enumerable: true,
+      get: () => {
+        if (!this.hmrClient)
+          throw new Error("[vite-runtime] HMR client was destroyed.");
+        return this.debug?.("[vite-runtime] creating hmr context for", moduleId), hotContext ||= new HMRContext(this.hmrClient, moduleId), hotContext;
+      },
+      set: (value) => {
+        hotContext = value;
+      }
+    });
+    const context = {
+      [ssrImportKey]: request,
+      [ssrDynamicImportKey]: dynamicRequest,
+      [ssrModuleExportsKey]: exports,
+      [ssrExportAllKey]: (obj) => exportAll(exports, obj),
+      [ssrImportMetaKey]: meta
+    };
+    return this.debug?.("[vite-runtime] executing", href), await this.runner.runViteModule(context, code, id), exports;
+  }
+};
+function exportAll(exports, sourceModule) {
+  if (exports !== sourceModule && !(isPrimitive(sourceModule) || Array.isArray(sourceModule) || sourceModule instanceof Promise)) {
+    for (const key in sourceModule)
+      if (key !== "default" && key !== "__esModule")
+        try {
+          Object.defineProperty(exports, key, {
+            enumerable: true,
+            configurable: true,
+            get: () => sourceModule[key]
+          });
+        } catch {
+        }
+  }
+}
+
+// src/worker-entry.ts
+import process2 from "node:process";
+
+// ../../node_modules/minimatch/dist/esm/index.js
+var import_brace_expansion = __toESM(require_brace_expansion(), 1);
+
+// ../../node_modules/minimatch/dist/esm/assert-valid-pattern.js
+var MAX_PATTERN_LENGTH = 1024 * 64;
+var assertValidPattern = (pattern) => {
+  if (typeof pattern !== "string") {
+    throw new TypeError("invalid pattern");
+  }
+  if (pattern.length > MAX_PATTERN_LENGTH) {
+    throw new TypeError("pattern is too long");
+  }
+};
+
+// ../../node_modules/minimatch/dist/esm/brace-expressions.js
+var posixClasses = {
+  "[:alnum:]": ["\\p{L}\\p{Nl}\\p{Nd}", true],
+  "[:alpha:]": ["\\p{L}\\p{Nl}", true],
+  "[:ascii:]": ["\\x00-\\x7f", false],
+  "[:blank:]": ["\\p{Zs}\\t", true],
+  "[:cntrl:]": ["\\p{Cc}", true],
+  "[:digit:]": ["\\p{Nd}", true],
+  "[:graph:]": ["\\p{Z}\\p{C}", true, true],
+  "[:lower:]": ["\\p{Ll}", true],
+  "[:print:]": ["\\p{C}", true],
+  "[:punct:]": ["\\p{P}", true],
+  "[:space:]": ["\\p{Z}\\t\\r\\n\\v\\f", true],
+  "[:upper:]": ["\\p{Lu}", true],
+  "[:word:]": ["\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}", true],
+  "[:xdigit:]": ["A-Fa-f0-9", false]
+};
+var braceEscape = (s) => s.replace(/[[\]\\-]/g, "\\$&");
+var regexpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+var rangesToString = (ranges) => ranges.join("");
+var parseClass = (glob, position) => {
+  const pos = position;
+  if (glob.charAt(pos) !== "[") {
+    throw new Error("not in a brace expression");
+  }
+  const ranges = [];
+  const negs = [];
+  let i = pos + 1;
+  let sawStart = false;
+  let uflag = false;
+  let escaping = false;
+  let negate = false;
+  let endPos = pos;
+  let rangeStart = "";
+  WHILE: while (i < glob.length) {
+    const c = glob.charAt(i);
+    if ((c === "!" || c === "^") && i === pos + 1) {
+      negate = true;
+      i++;
+      continue;
+    }
+    if (c === "]" && sawStart && !escaping) {
+      endPos = i + 1;
+      break;
+    }
+    sawStart = true;
+    if (c === "\\") {
+      if (!escaping) {
+        escaping = true;
+        i++;
+        continue;
+      }
+    }
+    if (c === "[" && !escaping) {
+      for (const [cls, [unip, u, neg]] of Object.entries(posixClasses)) {
+        if (glob.startsWith(cls, i)) {
+          if (rangeStart) {
+            return ["$.", false, glob.length - pos, true];
+          }
+          i += cls.length;
+          if (neg)
+            negs.push(unip);
+          else
+            ranges.push(unip);
+          uflag = uflag || u;
+          continue WHILE;
+        }
+      }
+    }
+    escaping = false;
+    if (rangeStart) {
+      if (c > rangeStart) {
+        ranges.push(braceEscape(rangeStart) + "-" + braceEscape(c));
+      } else if (c === rangeStart) {
+        ranges.push(braceEscape(c));
+      }
+      rangeStart = "";
+      i++;
+      continue;
+    }
+    if (glob.startsWith("-]", i + 1)) {
+      ranges.push(braceEscape(c + "-"));
+      i += 2;
+      continue;
+    }
+    if (glob.startsWith("-", i + 1)) {
+      rangeStart = c;
+      i += 2;
+      continue;
+    }
+    ranges.push(braceEscape(c));
+    i++;
+  }
+  if (endPos < i) {
+    return ["", false, 0, false];
+  }
+  if (!ranges.length && !negs.length) {
+    return ["$.", false, glob.length - pos, true];
+  }
+  if (negs.length === 0 && ranges.length === 1 && /^\\?.$/.test(ranges[0]) && !negate) {
+    const r = ranges[0].length === 2 ? ranges[0].slice(-1) : ranges[0];
+    return [regexpEscape(r), false, endPos - pos, false];
+  }
+  const sranges = "[" + (negate ? "^" : "") + rangesToString(ranges) + "]";
+  const snegs = "[" + (negate ? "" : "^") + rangesToString(negs) + "]";
+  const comb = ranges.length && negs.length ? "(" + sranges + "|" + snegs + ")" : ranges.length ? sranges : snegs;
+  return [comb, uflag, endPos - pos, true];
+};
+
+// ../../node_modules/minimatch/dist/esm/unescape.js
+var unescape = (s, { windowsPathsNoEscape = false } = {}) => {
+  return windowsPathsNoEscape ? s.replace(/\[([^\/\\])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^\/\\])\]/g, "$1$2").replace(/\\([^\/])/g, "$1");
+};
+
+// ../../node_modules/minimatch/dist/esm/ast.js
+var types = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]);
+var isExtglobType = (c) => types.has(c);
+var startNoTraversal = "(?!(?:^|/)\\.\\.?(?:$|/))";
+var startNoDot = "(?!\\.)";
+var addPatternStart = /* @__PURE__ */ new Set(["[", "."]);
+var justDots = /* @__PURE__ */ new Set(["..", "."]);
+var reSpecials = new Set("().*{}+?[]^$\\!");
+var regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+var qmark = "[^/]";
+var star = qmark + "*?";
+var starNoEmpty = qmark + "+?";
+var AST = class _AST {
+  type;
+  #root;
+  #hasMagic;
+  #uflag = false;
+  #parts = [];
+  #parent;
+  #parentIndex;
+  #negs;
+  #filledNegs = false;
+  #options;
+  #toString;
+  // set to true if it's an extglob with no children
+  // (which really means one child of '')
+  #emptyExt = false;
+  constructor(type, parent, options = {}) {
+    this.type = type;
+    if (type)
+      this.#hasMagic = true;
+    this.#parent = parent;
+    this.#root = this.#parent ? this.#parent.#root : this;
+    this.#options = this.#root === this ? options : this.#root.#options;
+    this.#negs = this.#root === this ? [] : this.#root.#negs;
+    if (type === "!" && !this.#root.#filledNegs)
+      this.#negs.push(this);
+    this.#parentIndex = this.#parent ? this.#parent.#parts.length : 0;
+  }
+  get hasMagic() {
+    if (this.#hasMagic !== void 0)
+      return this.#hasMagic;
+    for (const p of this.#parts) {
+      if (typeof p === "string")
+        continue;
+      if (p.type || p.hasMagic)
+        return this.#hasMagic = true;
+    }
+    return this.#hasMagic;
+  }
+  // reconstructs the pattern
+  toString() {
+    if (this.#toString !== void 0)
+      return this.#toString;
+    if (!this.type) {
+      return this.#toString = this.#parts.map((p) => String(p)).join("");
+    } else {
+      return this.#toString = this.type + "(" + this.#parts.map((p) => String(p)).join("|") + ")";
+    }
+  }
+  #fillNegs() {
+    if (this !== this.#root)
+      throw new Error("should only call on root");
+    if (this.#filledNegs)
+      return this;
+    this.toString();
+    this.#filledNegs = true;
+    let n;
+    while (n = this.#negs.pop()) {
+      if (n.type !== "!")
+        continue;
+      let p = n;
+      let pp = p.#parent;
+      while (pp) {
+        for (let i = p.#parentIndex + 1; !pp.type && i < pp.#parts.length; i++) {
+          for (const part of n.#parts) {
+            if (typeof part === "string") {
+              throw new Error("string part in extglob AST??");
+            }
+            part.copyIn(pp.#parts[i]);
+          }
+        }
+        p = pp;
+        pp = p.#parent;
+      }
+    }
+    return this;
+  }
+  push(...parts) {
+    for (const p of parts) {
+      if (p === "")
+        continue;
+      if (typeof p !== "string" && !(p instanceof _AST && p.#parent === this)) {
+        throw new Error("invalid part: " + p);
+      }
+      this.#parts.push(p);
+    }
+  }
+  toJSON() {
+    const ret = this.type === null ? this.#parts.slice().map((p) => typeof p === "string" ? p : p.toJSON()) : [this.type, ...this.#parts.map((p) => p.toJSON())];
+    if (this.isStart() && !this.type)
+      ret.unshift([]);
+    if (this.isEnd() && (this === this.#root || this.#root.#filledNegs && this.#parent?.type === "!")) {
+      ret.push({});
+    }
+    return ret;
+  }
+  isStart() {
+    if (this.#root === this)
+      return true;
+    if (!this.#parent?.isStart())
+      return false;
+    if (this.#parentIndex === 0)
+      return true;
+    const p = this.#parent;
+    for (let i = 0; i < this.#parentIndex; i++) {
+      const pp = p.#parts[i];
+      if (!(pp instanceof _AST && pp.type === "!")) {
+        return false;
+      }
+    }
+    return true;
+  }
+  isEnd() {
+    if (this.#root === this)
+      return true;
+    if (this.#parent?.type === "!")
+      return true;
+    if (!this.#parent?.isEnd())
+      return false;
+    if (!this.type)
+      return this.#parent?.isEnd();
+    const pl = this.#parent ? this.#parent.#parts.length : 0;
+    return this.#parentIndex === pl - 1;
+  }
+  copyIn(part) {
+    if (typeof part === "string")
+      this.push(part);
+    else
+      this.push(part.clone(this));
+  }
+  clone(parent) {
+    const c = new _AST(this.type, parent);
+    for (const p of this.#parts) {
+      c.copyIn(p);
+    }
+    return c;
+  }
+  static #parseAST(str, ast, pos, opt) {
+    let escaping = false;
+    let inBrace = false;
+    let braceStart = -1;
+    let braceNeg = false;
+    if (ast.type === null) {
+      let i2 = pos;
+      let acc2 = "";
+      while (i2 < str.length) {
+        const c = str.charAt(i2++);
+        if (escaping || c === "\\") {
+          escaping = !escaping;
+          acc2 += c;
+          continue;
+        }
+        if (inBrace) {
+          if (i2 === braceStart + 1) {
+            if (c === "^" || c === "!") {
+              braceNeg = true;
+            }
+          } else if (c === "]" && !(i2 === braceStart + 2 && braceNeg)) {
+            inBrace = false;
+          }
+          acc2 += c;
+          continue;
+        } else if (c === "[") {
+          inBrace = true;
+          braceStart = i2;
+          braceNeg = false;
+          acc2 += c;
+          continue;
+        }
+        if (!opt.noext && isExtglobType(c) && str.charAt(i2) === "(") {
+          ast.push(acc2);
+          acc2 = "";
+          const ext2 = new _AST(c, ast);
+          i2 = _AST.#parseAST(str, ext2, i2, opt);
+          ast.push(ext2);
+          continue;
+        }
+        acc2 += c;
+      }
+      ast.push(acc2);
+      return i2;
+    }
+    let i = pos + 1;
+    let part = new _AST(null, ast);
+    const parts = [];
+    let acc = "";
+    while (i < str.length) {
+      const c = str.charAt(i++);
+      if (escaping || c === "\\") {
+        escaping = !escaping;
+        acc += c;
+        continue;
+      }
+      if (inBrace) {
+        if (i === braceStart + 1) {
+          if (c === "^" || c === "!") {
+            braceNeg = true;
+          }
+        } else if (c === "]" && !(i === braceStart + 2 && braceNeg)) {
+          inBrace = false;
+        }
+        acc += c;
+        continue;
+      } else if (c === "[") {
+        inBrace = true;
+        braceStart = i;
+        braceNeg = false;
+        acc += c;
+        continue;
+      }
+      if (isExtglobType(c) && str.charAt(i) === "(") {
+        part.push(acc);
+        acc = "";
+        const ext2 = new _AST(c, part);
+        part.push(ext2);
+        i = _AST.#parseAST(str, ext2, i, opt);
+        continue;
+      }
+      if (c === "|") {
+        part.push(acc);
+        acc = "";
+        parts.push(part);
+        part = new _AST(null, ast);
+        continue;
+      }
+      if (c === ")") {
+        if (acc === "" && ast.#parts.length === 0) {
+          ast.#emptyExt = true;
+        }
+        part.push(acc);
+        acc = "";
+        ast.push(...parts, part);
+        return i;
+      }
+      acc += c;
+    }
+    ast.type = null;
+    ast.#hasMagic = void 0;
+    ast.#parts = [str.substring(pos - 1)];
+    return i;
+  }
+  static fromGlob(pattern, options = {}) {
+    const ast = new _AST(null, void 0, options);
+    _AST.#parseAST(pattern, ast, 0, options);
+    return ast;
+  }
+  // returns the regular expression if there's magic, or the unescaped
+  // string if not.
+  toMMPattern() {
+    if (this !== this.#root)
+      return this.#root.toMMPattern();
+    const glob = this.toString();
+    const [re, body, hasMagic, uflag] = this.toRegExpSource();
+    const anyMagic = hasMagic || this.#hasMagic || this.#options.nocase && !this.#options.nocaseMagicOnly && glob.toUpperCase() !== glob.toLowerCase();
+    if (!anyMagic) {
+      return body;
+    }
+    const flags = (this.#options.nocase ? "i" : "") + (uflag ? "u" : "");
+    return Object.assign(new RegExp(`^${re}$`, flags), {
+      _src: re,
+      _glob: glob
+    });
+  }
+  get options() {
+    return this.#options;
+  }
+  // returns the string match, the regexp source, whether there's magic
+  // in the regexp (so a regular expression is required) and whether or
+  // not the uflag is needed for the regular expression (for posix classes)
+  // TODO: instead of injecting the start/end at this point, just return
+  // the BODY of the regexp, along with the start/end portions suitable
+  // for binding the start/end in either a joined full-path makeRe context
+  // (where we bind to (^|/), or a standalone matchPart context (where
+  // we bind to ^, and not /).  Otherwise slashes get duped!
+  //
+  // In part-matching mode, the start is:
+  // - if not isStart: nothing
+  // - if traversal possible, but not allowed: ^(?!\.\.?$)
+  // - if dots allowed or not possible: ^
+  // - if dots possible and not allowed: ^(?!\.)
+  // end is:
+  // - if not isEnd(): nothing
+  // - else: $
+  //
+  // In full-path matching mode, we put the slash at the START of the
+  // pattern, so start is:
+  // - if first pattern: same as part-matching mode
+  // - if not isStart(): nothing
+  // - if traversal possible, but not allowed: /(?!\.\.?(?:$|/))
+  // - if dots allowed or not possible: /
+  // - if dots possible and not allowed: /(?!\.)
+  // end is:
+  // - if last pattern, same as part-matching mode
+  // - else nothing
+  //
+  // Always put the (?:$|/) on negated tails, though, because that has to be
+  // there to bind the end of the negated pattern portion, and it's easier to
+  // just stick it in now rather than try to inject it later in the middle of
+  // the pattern.
+  //
+  // We can just always return the same end, and leave it up to the caller
+  // to know whether it's going to be used joined or in parts.
+  // And, if the start is adjusted slightly, can do the same there:
+  // - if not isStart: nothing
+  // - if traversal possible, but not allowed: (?:/|^)(?!\.\.?$)
+  // - if dots allowed or not possible: (?:/|^)
+  // - if dots possible and not allowed: (?:/|^)(?!\.)
+  //
+  // But it's better to have a simpler binding without a conditional, for
+  // performance, so probably better to return both start options.
+  //
+  // Then the caller just ignores the end if it's not the first pattern,
+  // and the start always gets applied.
+  //
+  // But that's always going to be $ if it's the ending pattern, or nothing,
+  // so the caller can just attach $ at the end of the pattern when building.
+  //
+  // So the todo is:
+  // - better detect what kind of start is needed
+  // - return both flavors of starting pattern
+  // - attach $ at the end of the pattern when creating the actual RegExp
+  //
+  // Ah, but wait, no, that all only applies to the root when the first pattern
+  // is not an extglob. If the first pattern IS an extglob, then we need all
+  // that dot prevention biz to live in the extglob portions, because eg
+  // +(*|.x*) can match .xy but not .yx.
+  //
+  // So, return the two flavors if it's #root and the first child is not an
+  // AST, otherwise leave it to the child AST to handle it, and there,
+  // use the (?:^|/) style of start binding.
+  //
+  // Even simplified further:
+  // - Since the start for a join is eg /(?!\.) and the start for a part
+  // is ^(?!\.), we can just prepend (?!\.) to the pattern (either root
+  // or start or whatever) and prepend ^ or / at the Regexp construction.
+  toRegExpSource(allowDot) {
+    const dot = allowDot ?? !!this.#options.dot;
+    if (this.#root === this)
+      this.#fillNegs();
+    if (!this.type) {
+      const noEmpty = this.isStart() && this.isEnd();
+      const src = this.#parts.map((p) => {
+        const [re, _, hasMagic, uflag] = typeof p === "string" ? _AST.#parseGlob(p, this.#hasMagic, noEmpty) : p.toRegExpSource(allowDot);
+        this.#hasMagic = this.#hasMagic || hasMagic;
+        this.#uflag = this.#uflag || uflag;
+        return re;
+      }).join("");
+      let start2 = "";
+      if (this.isStart()) {
+        if (typeof this.#parts[0] === "string") {
+          const dotTravAllowed = this.#parts.length === 1 && justDots.has(this.#parts[0]);
+          if (!dotTravAllowed) {
+            const aps = addPatternStart;
+            const needNoTrav = (
+              // dots are allowed, and the pattern starts with [ or .
+              dot && aps.has(src.charAt(0)) || // the pattern starts with \., and then [ or .
+              src.startsWith("\\.") && aps.has(src.charAt(2)) || // the pattern starts with \.\., and then [ or .
+              src.startsWith("\\.\\.") && aps.has(src.charAt(4))
+            );
+            const needNoDot = !dot && !allowDot && aps.has(src.charAt(0));
+            start2 = needNoTrav ? startNoTraversal : needNoDot ? startNoDot : "";
+          }
+        }
+      }
+      let end = "";
+      if (this.isEnd() && this.#root.#filledNegs && this.#parent?.type === "!") {
+        end = "(?:$|\\/)";
+      }
+      const final2 = start2 + src + end;
+      return [
+        final2,
+        unescape(src),
+        this.#hasMagic = !!this.#hasMagic,
+        this.#uflag
+      ];
+    }
+    const repeated = this.type === "*" || this.type === "+";
+    const start = this.type === "!" ? "(?:(?!(?:" : "(?:";
+    let body = this.#partsToRegExp(dot);
+    if (this.isStart() && this.isEnd() && !body && this.type !== "!") {
+      const s = this.toString();
+      this.#parts = [s];
+      this.type = null;
+      this.#hasMagic = void 0;
+      return [s, unescape(this.toString()), false, false];
+    }
+    let bodyDotAllowed = !repeated || allowDot || dot || !startNoDot ? "" : this.#partsToRegExp(true);
+    if (bodyDotAllowed === body) {
+      bodyDotAllowed = "";
+    }
+    if (bodyDotAllowed) {
+      body = `(?:${body})(?:${bodyDotAllowed})*?`;
+    }
+    let final = "";
+    if (this.type === "!" && this.#emptyExt) {
+      final = (this.isStart() && !dot ? startNoDot : "") + starNoEmpty;
+    } else {
+      const close = this.type === "!" ? (
+        // !() must match something,but !(x) can match ''
+        "))" + (this.isStart() && !dot && !allowDot ? startNoDot : "") + star + ")"
+      ) : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && bodyDotAllowed ? ")" : this.type === "*" && bodyDotAllowed ? `)?` : `)${this.type}`;
+      final = start + body + close;
+    }
+    return [
+      final,
+      unescape(body),
+      this.#hasMagic = !!this.#hasMagic,
+      this.#uflag
+    ];
+  }
+  #partsToRegExp(dot) {
+    return this.#parts.map((p) => {
+      if (typeof p === "string") {
+        throw new Error("string type in extglob ast??");
+      }
+      const [re, _, _hasMagic, uflag] = p.toRegExpSource(dot);
+      this.#uflag = this.#uflag || uflag;
+      return re;
+    }).filter((p) => !(this.isStart() && this.isEnd()) || !!p).join("|");
+  }
+  static #parseGlob(glob, hasMagic, noEmpty = false) {
+    let escaping = false;
+    let re = "";
+    let uflag = false;
+    for (let i = 0; i < glob.length; i++) {
+      const c = glob.charAt(i);
+      if (escaping) {
+        escaping = false;
+        re += (reSpecials.has(c) ? "\\" : "") + c;
+        continue;
+      }
+      if (c === "\\") {
+        if (i === glob.length - 1) {
+          re += "\\\\";
+        } else {
+          escaping = true;
+        }
+        continue;
+      }
+      if (c === "[") {
+        const [src, needUflag, consumed, magic] = parseClass(glob, i);
+        if (consumed) {
+          re += src;
+          uflag = uflag || needUflag;
+          i += consumed - 1;
+          hasMagic = hasMagic || magic;
+          continue;
+        }
+      }
+      if (c === "*") {
+        if (noEmpty && glob === "*")
+          re += starNoEmpty;
+        else
+          re += star;
+        hasMagic = true;
+        continue;
+      }
+      if (c === "?") {
+        re += qmark;
+        hasMagic = true;
+        continue;
+      }
+      re += regExpEscape(c);
+    }
+    return [re, unescape(glob), !!hasMagic, uflag];
+  }
+};
+
+// ../../node_modules/minimatch/dist/esm/escape.js
+var escape = (s, { windowsPathsNoEscape = false } = {}) => {
+  return windowsPathsNoEscape ? s.replace(/[?*()[\]]/g, "[$&]") : s.replace(/[?*()[\]\\]/g, "\\$&");
+};
+
+// ../../node_modules/minimatch/dist/esm/index.js
+var minimatch = (p, pattern, options = {}) => {
+  assertValidPattern(pattern);
+  if (!options.nocomment && pattern.charAt(0) === "#") {
+    return false;
+  }
+  return new Minimatch(pattern, options).match(p);
+};
+var starDotExtRE = /^\*+([^+@!?\*\[\(]*)$/;
+var starDotExtTest = (ext2) => (f) => !f.startsWith(".") && f.endsWith(ext2);
+var starDotExtTestDot = (ext2) => (f) => f.endsWith(ext2);
+var starDotExtTestNocase = (ext2) => {
+  ext2 = ext2.toLowerCase();
+  return (f) => !f.startsWith(".") && f.toLowerCase().endsWith(ext2);
+};
+var starDotExtTestNocaseDot = (ext2) => {
+  ext2 = ext2.toLowerCase();
+  return (f) => f.toLowerCase().endsWith(ext2);
+};
+var starDotStarRE = /^\*+\.\*+$/;
+var starDotStarTest = (f) => !f.startsWith(".") && f.includes(".");
+var starDotStarTestDot = (f) => f !== "." && f !== ".." && f.includes(".");
+var dotStarRE = /^\.\*+$/;
+var dotStarTest = (f) => f !== "." && f !== ".." && f.startsWith(".");
+var starRE = /^\*+$/;
+var starTest = (f) => f.length !== 0 && !f.startsWith(".");
+var starTestDot = (f) => f.length !== 0 && f !== "." && f !== "..";
+var qmarksRE = /^\?+([^+@!?\*\[\(]*)?$/;
+var qmarksTestNocase = ([$0, ext2 = ""]) => {
+  const noext = qmarksTestNoExt([$0]);
+  if (!ext2)
+    return noext;
+  ext2 = ext2.toLowerCase();
+  return (f) => noext(f) && f.toLowerCase().endsWith(ext2);
+};
+var qmarksTestNocaseDot = ([$0, ext2 = ""]) => {
+  const noext = qmarksTestNoExtDot([$0]);
+  if (!ext2)
+    return noext;
+  ext2 = ext2.toLowerCase();
+  return (f) => noext(f) && f.toLowerCase().endsWith(ext2);
+};
+var qmarksTestDot = ([$0, ext2 = ""]) => {
+  const noext = qmarksTestNoExtDot([$0]);
+  return !ext2 ? noext : (f) => noext(f) && f.endsWith(ext2);
+};
+var qmarksTest = ([$0, ext2 = ""]) => {
+  const noext = qmarksTestNoExt([$0]);
+  return !ext2 ? noext : (f) => noext(f) && f.endsWith(ext2);
+};
+var qmarksTestNoExt = ([$0]) => {
+  const len = $0.length;
+  return (f) => f.length === len && !f.startsWith(".");
+};
+var qmarksTestNoExtDot = ([$0]) => {
+  const len = $0.length;
+  return (f) => f.length === len && f !== "." && f !== "..";
+};
+var defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
+var path = {
+  win32: { sep: "\\" },
+  posix: { sep: "/" }
+};
+var sep = defaultPlatform === "win32" ? path.win32.sep : path.posix.sep;
+minimatch.sep = sep;
+var GLOBSTAR = Symbol("globstar **");
+minimatch.GLOBSTAR = GLOBSTAR;
+var qmark2 = "[^/]";
+var star2 = qmark2 + "*?";
+var twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
+var twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
+var filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options);
+minimatch.filter = filter;
+var ext = (a, b = {}) => Object.assign({}, a, b);
+var defaults = (def) => {
+  if (!def || typeof def !== "object" || !Object.keys(def).length) {
+    return minimatch;
+  }
+  const orig = minimatch;
+  const m = (p, pattern, options = {}) => orig(p, pattern, ext(def, options));
+  return Object.assign(m, {
+    Minimatch: class Minimatch extends orig.Minimatch {
+      constructor(pattern, options = {}) {
+        super(pattern, ext(def, options));
+      }
+      static defaults(options) {
+        return orig.defaults(ext(def, options)).Minimatch;
+      }
+    },
+    AST: class AST extends orig.AST {
+      /* c8 ignore start */
+      constructor(type, parent, options = {}) {
+        super(type, parent, ext(def, options));
+      }
+      /* c8 ignore stop */
+      static fromGlob(pattern, options = {}) {
+        return orig.AST.fromGlob(pattern, ext(def, options));
+      }
+    },
+    unescape: (s, options = {}) => orig.unescape(s, ext(def, options)),
+    escape: (s, options = {}) => orig.escape(s, ext(def, options)),
+    filter: (pattern, options = {}) => orig.filter(pattern, ext(def, options)),
+    defaults: (options) => orig.defaults(ext(def, options)),
+    makeRe: (pattern, options = {}) => orig.makeRe(pattern, ext(def, options)),
+    braceExpand: (pattern, options = {}) => orig.braceExpand(pattern, ext(def, options)),
+    match: (list, pattern, options = {}) => orig.match(list, pattern, ext(def, options)),
+    sep: orig.sep,
+    GLOBSTAR
+  });
+};
+minimatch.defaults = defaults;
+var braceExpand = (pattern, options = {}) => {
+  assertValidPattern(pattern);
+  if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
+    return [pattern];
+  }
+  return (0, import_brace_expansion.default)(pattern);
+};
+minimatch.braceExpand = braceExpand;
+var makeRe = (pattern, options = {}) => new Minimatch(pattern, options).makeRe();
+minimatch.makeRe = makeRe;
+var match = (list, pattern, options = {}) => {
+  const mm = new Minimatch(pattern, options);
+  list = list.filter((f) => mm.match(f));
+  if (mm.options.nonull && !list.length) {
+    list.push(pattern);
+  }
+  return list;
+};
+minimatch.match = match;
+var globMagic = /[?*]|[+@!]\(.*?\)|\[|\]/;
+var regExpEscape2 = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+var Minimatch = class {
+  options;
+  set;
+  pattern;
+  windowsPathsNoEscape;
+  nonegate;
+  negate;
+  comment;
+  empty;
+  preserveMultipleSlashes;
+  partial;
+  globSet;
+  globParts;
+  nocase;
+  isWindows;
+  platform;
+  windowsNoMagicRoot;
+  regexp;
+  constructor(pattern, options = {}) {
+    assertValidPattern(pattern);
+    options = options || {};
+    this.options = options;
+    this.pattern = pattern;
+    this.platform = options.platform || defaultPlatform;
+    this.isWindows = this.platform === "win32";
+    this.windowsPathsNoEscape = !!options.windowsPathsNoEscape || options.allowWindowsEscape === false;
+    if (this.windowsPathsNoEscape) {
+      this.pattern = this.pattern.replace(/\\/g, "/");
+    }
+    this.preserveMultipleSlashes = !!options.preserveMultipleSlashes;
+    this.regexp = null;
+    this.negate = false;
+    this.nonegate = !!options.nonegate;
+    this.comment = false;
+    this.empty = false;
+    this.partial = !!options.partial;
+    this.nocase = !!this.options.nocase;
+    this.windowsNoMagicRoot = options.windowsNoMagicRoot !== void 0 ? options.windowsNoMagicRoot : !!(this.isWindows && this.nocase);
+    this.globSet = [];
+    this.globParts = [];
+    this.set = [];
+    this.make();
+  }
+  hasMagic() {
+    if (this.options.magicalBraces && this.set.length > 1) {
+      return true;
+    }
+    for (const pattern of this.set) {
+      for (const part of pattern) {
+        if (typeof part !== "string")
+          return true;
+      }
+    }
+    return false;
+  }
+  debug(..._) {
+  }
+  make() {
+    const pattern = this.pattern;
+    const options = this.options;
+    if (!options.nocomment && pattern.charAt(0) === "#") {
+      this.comment = true;
+      return;
+    }
+    if (!pattern) {
+      this.empty = true;
+      return;
+    }
+    this.parseNegate();
+    this.globSet = [...new Set(this.braceExpand())];
+    if (options.debug) {
+      this.debug = (...args) => console.error(...args);
+    }
+    this.debug(this.pattern, this.globSet);
+    const rawGlobParts = this.globSet.map((s) => this.slashSplit(s));
+    this.globParts = this.preprocess(rawGlobParts);
+    this.debug(this.pattern, this.globParts);
+    let set = this.globParts.map((s, _, __) => {
+      if (this.isWindows && this.windowsNoMagicRoot) {
+        const isUNC = s[0] === "" && s[1] === "" && (s[2] === "?" || !globMagic.test(s[2])) && !globMagic.test(s[3]);
+        const isDrive = /^[a-z]:/i.test(s[0]);
+        if (isUNC) {
+          return [...s.slice(0, 4), ...s.slice(4).map((ss) => this.parse(ss))];
+        } else if (isDrive) {
+          return [s[0], ...s.slice(1).map((ss) => this.parse(ss))];
+        }
+      }
+      return s.map((ss) => this.parse(ss));
+    });
+    this.debug(this.pattern, set);
+    this.set = set.filter((s) => s.indexOf(false) === -1);
+    if (this.isWindows) {
+      for (let i = 0; i < this.set.length; i++) {
+        const p = this.set[i];
+        if (p[0] === "" && p[1] === "" && this.globParts[i][2] === "?" && typeof p[3] === "string" && /^[a-z]:$/i.test(p[3])) {
+          p[2] = "?";
+        }
+      }
+    }
+    this.debug(this.pattern, this.set);
+  }
+  // various transforms to equivalent pattern sets that are
+  // faster to process in a filesystem walk.  The goal is to
+  // eliminate what we can, and push all ** patterns as far
+  // to the right as possible, even if it increases the number
+  // of patterns that we have to process.
+  preprocess(globParts) {
+    if (this.options.noglobstar) {
+      for (let i = 0; i < globParts.length; i++) {
+        for (let j = 0; j < globParts[i].length; j++) {
+          if (globParts[i][j] === "**") {
+            globParts[i][j] = "*";
+          }
+        }
+      }
+    }
+    const { optimizationLevel = 1 } = this.options;
+    if (optimizationLevel >= 2) {
+      globParts = this.firstPhasePreProcess(globParts);
+      globParts = this.secondPhasePreProcess(globParts);
+    } else if (optimizationLevel >= 1) {
+      globParts = this.levelOneOptimize(globParts);
+    } else {
+      globParts = this.adjascentGlobstarOptimize(globParts);
+    }
+    return globParts;
+  }
+  // just get rid of adjascent ** portions
+  adjascentGlobstarOptimize(globParts) {
+    return globParts.map((parts) => {
+      let gs = -1;
+      while (-1 !== (gs = parts.indexOf("**", gs + 1))) {
+        let i = gs;
+        while (parts[i + 1] === "**") {
+          i++;
+        }
+        if (i !== gs) {
+          parts.splice(gs, i - gs);
+        }
+      }
+      return parts;
+    });
+  }
+  // get rid of adjascent ** and resolve .. portions
+  levelOneOptimize(globParts) {
+    return globParts.map((parts) => {
+      parts = parts.reduce((set, part) => {
+        const prev = set[set.length - 1];
+        if (part === "**" && prev === "**") {
+          return set;
+        }
+        if (part === "..") {
+          if (prev && prev !== ".." && prev !== "." && prev !== "**") {
+            set.pop();
+            return set;
+          }
+        }
+        set.push(part);
+        return set;
+      }, []);
+      return parts.length === 0 ? [""] : parts;
+    });
+  }
+  levelTwoFileOptimize(parts) {
+    if (!Array.isArray(parts)) {
+      parts = this.slashSplit(parts);
+    }
+    let didSomething = false;
+    do {
+      didSomething = false;
+      if (!this.preserveMultipleSlashes) {
+        for (let i = 1; i < parts.length - 1; i++) {
+          const p = parts[i];
+          if (i === 1 && p === "" && parts[0] === "")
+            continue;
+          if (p === "." || p === "") {
+            didSomething = true;
+            parts.splice(i, 1);
+            i--;
+          }
+        }
+        if (parts[0] === "." && parts.length === 2 && (parts[1] === "." || parts[1] === "")) {
+          didSomething = true;
+          parts.pop();
+        }
+      }
+      let dd = 0;
+      while (-1 !== (dd = parts.indexOf("..", dd + 1))) {
+        const p = parts[dd - 1];
+        if (p && p !== "." && p !== ".." && p !== "**") {
+          didSomething = true;
+          parts.splice(dd - 1, 2);
+          dd -= 2;
+        }
+      }
+    } while (didSomething);
+    return parts.length === 0 ? [""] : parts;
+  }
+  // First phase: single-pattern processing
+  // <pre> is 1 or more portions
+  // <rest> is 1 or more portions
+  // <p> is any portion other than ., .., '', or **
+  // <e> is . or ''
+  //
+  // **/.. is *brutal* for filesystem walking performance, because
+  // it effectively resets the recursive walk each time it occurs,
+  // and ** cannot be reduced out by a .. pattern part like a regexp
+  // or most strings (other than .., ., and '') can be.
+  //
+  // <pre>/**/../<p>/<p>/<rest> -> {<pre>/../<p>/<p>/<rest>,<pre>/**/<p>/<p>/<rest>}
+  // <pre>/<e>/<rest> -> <pre>/<rest>
+  // <pre>/<p>/../<rest> -> <pre>/<rest>
+  // **/**/<rest> -> **/<rest>
+  //
+  // **/*/<rest> -> */**/<rest> <== not valid because ** doesn't follow
+  // this WOULD be allowed if ** did follow symlinks, or * didn't
+  firstPhasePreProcess(globParts) {
+    let didSomething = false;
+    do {
+      didSomething = false;
+      for (let parts of globParts) {
+        let gs = -1;
+        while (-1 !== (gs = parts.indexOf("**", gs + 1))) {
+          let gss = gs;
+          while (parts[gss + 1] === "**") {
+            gss++;
+          }
+          if (gss > gs) {
+            parts.splice(gs + 1, gss - gs);
+          }
+          let next = parts[gs + 1];
+          const p = parts[gs + 2];
+          const p2 = parts[gs + 3];
+          if (next !== "..")
+            continue;
+          if (!p || p === "." || p === ".." || !p2 || p2 === "." || p2 === "..") {
+            continue;
+          }
+          didSomething = true;
+          parts.splice(gs, 1);
+          const other = parts.slice(0);
+          other[gs] = "**";
+          globParts.push(other);
+          gs--;
+        }
+        if (!this.preserveMultipleSlashes) {
+          for (let i = 1; i < parts.length - 1; i++) {
+            const p = parts[i];
+            if (i === 1 && p === "" && parts[0] === "")
+              continue;
+            if (p === "." || p === "") {
+              didSomething = true;
+              parts.splice(i, 1);
+              i--;
+            }
+          }
+          if (parts[0] === "." && parts.length === 2 && (parts[1] === "." || parts[1] === "")) {
+            didSomething = true;
+            parts.pop();
+          }
+        }
+        let dd = 0;
+        while (-1 !== (dd = parts.indexOf("..", dd + 1))) {
+          const p = parts[dd - 1];
+          if (p && p !== "." && p !== ".." && p !== "**") {
+            didSomething = true;
+            const needDot = dd === 1 && parts[dd + 1] === "**";
+            const splin = needDot ? ["."] : [];
+            parts.splice(dd - 1, 2, ...splin);
+            if (parts.length === 0)
+              parts.push("");
+            dd -= 2;
+          }
+        }
+      }
+    } while (didSomething);
+    return globParts;
+  }
+  // second phase: multi-pattern dedupes
+  // {<pre>/*/<rest>,<pre>/<p>/<rest>} -> <pre>/*/<rest>
+  // {<pre>/<rest>,<pre>/<rest>} -> <pre>/<rest>
+  // {<pre>/**/<rest>,<pre>/<rest>} -> <pre>/**/<rest>
+  //
+  // {<pre>/**/<rest>,<pre>/**/<p>/<rest>} -> <pre>/**/<rest>
+  // ^-- not valid because ** doens't follow symlinks
+  secondPhasePreProcess(globParts) {
+    for (let i = 0; i < globParts.length - 1; i++) {
+      for (let j = i + 1; j < globParts.length; j++) {
+        const matched = this.partsMatch(globParts[i], globParts[j], !this.preserveMultipleSlashes);
+        if (matched) {
+          globParts[i] = [];
+          globParts[j] = matched;
+          break;
+        }
+      }
+    }
+    return globParts.filter((gs) => gs.length);
+  }
+  partsMatch(a, b, emptyGSMatch = false) {
+    let ai = 0;
+    let bi = 0;
+    let result = [];
+    let which = "";
+    while (ai < a.length && bi < b.length) {
+      if (a[ai] === b[bi]) {
+        result.push(which === "b" ? b[bi] : a[ai]);
+        ai++;
+        bi++;
+      } else if (emptyGSMatch && a[ai] === "**" && b[bi] === a[ai + 1]) {
+        result.push(a[ai]);
+        ai++;
+      } else if (emptyGSMatch && b[bi] === "**" && a[ai] === b[bi + 1]) {
+        result.push(b[bi]);
+        bi++;
+      } else if (a[ai] === "*" && b[bi] && (this.options.dot || !b[bi].startsWith(".")) && b[bi] !== "**") {
+        if (which === "b")
+          return false;
+        which = "a";
+        result.push(a[ai]);
+        ai++;
+        bi++;
+      } else if (b[bi] === "*" && a[ai] && (this.options.dot || !a[ai].startsWith(".")) && a[ai] !== "**") {
+        if (which === "a")
+          return false;
+        which = "b";
+        result.push(b[bi]);
+        ai++;
+        bi++;
+      } else {
+        return false;
+      }
+    }
+    return a.length === b.length && result;
+  }
+  parseNegate() {
+    if (this.nonegate)
+      return;
+    const pattern = this.pattern;
+    let negate = false;
+    let negateOffset = 0;
+    for (let i = 0; i < pattern.length && pattern.charAt(i) === "!"; i++) {
+      negate = !negate;
+      negateOffset++;
+    }
+    if (negateOffset)
+      this.pattern = pattern.slice(negateOffset);
+    this.negate = negate;
+  }
+  // set partial to true to test if, for example,
+  // "/a/b" matches the start of "/*/b/*/d"
+  // Partial means, if you run out of file before you run
+  // out of pattern, then that's fine, as long as all
+  // the parts match.
+  matchOne(file, pattern, partial = false) {
+    const options = this.options;
+    if (this.isWindows) {
+      const fileDrive = typeof file[0] === "string" && /^[a-z]:$/i.test(file[0]);
+      const fileUNC = !fileDrive && file[0] === "" && file[1] === "" && file[2] === "?" && /^[a-z]:$/i.test(file[3]);
+      const patternDrive = typeof pattern[0] === "string" && /^[a-z]:$/i.test(pattern[0]);
+      const patternUNC = !patternDrive && pattern[0] === "" && pattern[1] === "" && pattern[2] === "?" && typeof pattern[3] === "string" && /^[a-z]:$/i.test(pattern[3]);
+      const fdi = fileUNC ? 3 : fileDrive ? 0 : void 0;
+      const pdi = patternUNC ? 3 : patternDrive ? 0 : void 0;
+      if (typeof fdi === "number" && typeof pdi === "number") {
+        const [fd, pd] = [file[fdi], pattern[pdi]];
+        if (fd.toLowerCase() === pd.toLowerCase()) {
+          pattern[pdi] = fd;
+          if (pdi > fdi) {
+            pattern = pattern.slice(pdi);
+          } else if (fdi > pdi) {
+            file = file.slice(fdi);
+          }
+        }
+      }
+    }
+    const { optimizationLevel = 1 } = this.options;
+    if (optimizationLevel >= 2) {
+      file = this.levelTwoFileOptimize(file);
+    }
+    this.debug("matchOne", this, { file, pattern });
+    this.debug("matchOne", file.length, pattern.length);
+    for (var fi = 0, pi = 0, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
+      this.debug("matchOne loop");
+      var p = pattern[pi];
+      var f = file[fi];
+      this.debug(pattern, p, f);
+      if (p === false) {
+        return false;
+      }
+      if (p === GLOBSTAR) {
+        this.debug("GLOBSTAR", [pattern, p, f]);
+        var fr = fi;
+        var pr = pi + 1;
+        if (pr === pl) {
+          this.debug("** at the end");
+          for (; fi < fl; fi++) {
+            if (file[fi] === "." || file[fi] === ".." || !options.dot && file[fi].charAt(0) === ".")
+              return false;
+          }
+          return true;
+        }
+        while (fr < fl) {
+          var swallowee = file[fr];
+          this.debug("\nglobstar while", file, fr, pattern, pr, swallowee);
+          if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
+            this.debug("globstar found match!", fr, fl, swallowee);
+            return true;
+          } else {
+            if (swallowee === "." || swallowee === ".." || !options.dot && swallowee.charAt(0) === ".") {
+              this.debug("dot detected!", file, fr, pattern, pr);
+              break;
+            }
+            this.debug("globstar swallow a segment, and continue");
+            fr++;
+          }
+        }
+        if (partial) {
+          this.debug("\n>>> no match, partial?", file, fr, pattern, pr);
+          if (fr === fl) {
+            return true;
+          }
+        }
+        return false;
+      }
+      let hit;
+      if (typeof p === "string") {
+        hit = f === p;
+        this.debug("string match", p, f, hit);
+      } else {
+        hit = p.test(f);
+        this.debug("pattern match", p, f, hit);
+      }
+      if (!hit)
+        return false;
+    }
+    if (fi === fl && pi === pl) {
+      return true;
+    } else if (fi === fl) {
+      return partial;
+    } else if (pi === pl) {
+      return fi === fl - 1 && file[fi] === "";
+    } else {
+      throw new Error("wtf?");
+    }
+  }
+  braceExpand() {
+    return braceExpand(this.pattern, this.options);
+  }
+  parse(pattern) {
+    assertValidPattern(pattern);
+    const options = this.options;
+    if (pattern === "**")
+      return GLOBSTAR;
+    if (pattern === "")
+      return "";
+    let m;
+    let fastTest = null;
+    if (m = pattern.match(starRE)) {
+      fastTest = options.dot ? starTestDot : starTest;
+    } else if (m = pattern.match(starDotExtRE)) {
+      fastTest = (options.nocase ? options.dot ? starDotExtTestNocaseDot : starDotExtTestNocase : options.dot ? starDotExtTestDot : starDotExtTest)(m[1]);
+    } else if (m = pattern.match(qmarksRE)) {
+      fastTest = (options.nocase ? options.dot ? qmarksTestNocaseDot : qmarksTestNocase : options.dot ? qmarksTestDot : qmarksTest)(m);
+    } else if (m = pattern.match(starDotStarRE)) {
+      fastTest = options.dot ? starDotStarTestDot : starDotStarTest;
+    } else if (m = pattern.match(dotStarRE)) {
+      fastTest = dotStarTest;
+    }
+    const re = AST.fromGlob(pattern, this.options).toMMPattern();
+    if (fastTest && typeof re === "object") {
+      Reflect.defineProperty(re, "test", { value: fastTest });
+    }
+    return re;
+  }
+  makeRe() {
+    if (this.regexp || this.regexp === false)
+      return this.regexp;
+    const set = this.set;
+    if (!set.length) {
+      this.regexp = false;
+      return this.regexp;
+    }
+    const options = this.options;
+    const twoStar = options.noglobstar ? star2 : options.dot ? twoStarDot : twoStarNoDot;
+    const flags = new Set(options.nocase ? ["i"] : []);
+    let re = set.map((pattern) => {
+      const pp = pattern.map((p) => {
+        if (p instanceof RegExp) {
+          for (const f of p.flags.split(""))
+            flags.add(f);
+        }
+        return typeof p === "string" ? regExpEscape2(p) : p === GLOBSTAR ? GLOBSTAR : p._src;
+      });
+      pp.forEach((p, i) => {
+        const next = pp[i + 1];
+        const prev = pp[i - 1];
+        if (p !== GLOBSTAR || prev === GLOBSTAR) {
+          return;
+        }
+        if (prev === void 0) {
+          if (next !== void 0 && next !== GLOBSTAR) {
+            pp[i + 1] = "(?:\\/|" + twoStar + "\\/)?" + next;
+          } else {
+            pp[i] = twoStar;
+          }
+        } else if (next === void 0) {
+          pp[i - 1] = prev + "(?:\\/|" + twoStar + ")?";
+        } else if (next !== GLOBSTAR) {
+          pp[i - 1] = prev + "(?:\\/|\\/" + twoStar + "\\/)" + next;
+          pp[i + 1] = GLOBSTAR;
+        }
+      });
+      return pp.filter((p) => p !== GLOBSTAR).join("/");
+    }).join("|");
+    const [open, close] = set.length > 1 ? ["(?:", ")"] : ["", ""];
+    re = "^" + open + re + close + "$";
+    if (this.negate)
+      re = "^(?!" + re + ").+$";
+    try {
+      this.regexp = new RegExp(re, [...flags].join(""));
+    } catch (ex) {
+      this.regexp = false;
+    }
+    return this.regexp;
+  }
+  slashSplit(p) {
+    if (this.preserveMultipleSlashes) {
+      return p.split("/");
+    } else if (this.isWindows && /^\/\/[^\/]+/.test(p)) {
+      return ["", ...p.split(/\/+/)];
+    } else {
+      return p.split(/\/+/);
+    }
+  }
+  match(f, partial = this.partial) {
+    this.debug("match", f, this.pattern);
+    if (this.comment) {
+      return false;
+    }
+    if (this.empty) {
+      return f === "";
+    }
+    if (f === "/" && partial) {
+      return true;
+    }
+    const options = this.options;
+    if (this.isWindows) {
+      f = f.split("\\").join("/");
+    }
+    const ff = this.slashSplit(f);
+    this.debug(this.pattern, "split", ff);
+    const set = this.set;
+    this.debug(this.pattern, "set", set);
+    let filename = ff[ff.length - 1];
+    if (!filename) {
+      for (let i = ff.length - 2; !filename && i >= 0; i--) {
+        filename = ff[i];
+      }
+    }
+    for (let i = 0; i < set.length; i++) {
+      const pattern = set[i];
+      let file = ff;
+      if (options.matchBase && pattern.length === 1) {
+        file = [filename];
+      }
+      const hit = this.matchOne(file, pattern, partial);
+      if (hit) {
+        if (options.flipNegate) {
+          return true;
+        }
+        return !this.negate;
+      }
+    }
+    if (options.flipNegate) {
+      return false;
+    }
+    return this.negate;
+  }
+  static defaults(def) {
+    return minimatch.defaults(def).Minimatch;
+  }
+};
+minimatch.AST = AST;
+minimatch.Minimatch = Minimatch;
+minimatch.escape = escape;
+minimatch.unescape = unescape;
+
+// src/worker-entry.ts
+import { relative } from "node:path";
+var exportedHandler = {
+  async fetch(request, env, context) {
+    if (typeof env.__CLI_TEST_OVERRIDES === "string") {
+      Object.assign(process2.env, {
+        [TEST_OVERRIDES_ENV_VAR]: env.__CLI_TEST_OVERRIDES
+      });
+    }
+    try {
+      const module = await fetchEntryModule(env);
+      return await module.default.fetch(request, env, context);
+    } catch (error) {
+      console.error(error);
+      throw error;
+    }
+  }
+};
+var worker_entry_default = exportedHandler;
+var runtime;
+function fetchEntryModule(env) {
+  if (!runtime) {
+    let isHmrReady = false;
+    let onHmrReceive;
+    connectHmrWsClient(env).then((socket) => {
+      isHmrReady = true;
+      socket.addEventListener("message", async (message) => {
+        if (!message.data) {
+          return;
+        }
+        const data = JSON.parse(
+          message.data.toString()
+        );
+        if (data?.type === "update" && runtime) {
+          const needsInvalidate = data.updates.flatMap((update) => update.ssrInvalidates ?? []).map((filepath) => relative(env.__VITE_ROOT, filepath)).some((filepath) => {
+            return env.__INVALIDATE_GLOB_PATTERNS.some(
+              (pattern) => minimatch(filepath, pattern)
+            );
+          });
+          if (needsInvalidate) {
+            const entriesToInvalidate = [
+              ...runtime.moduleCache.keys()
+            ].filter((filepath) => {
+              return env.__INVALIDATE_GLOB_PATTERNS.some(
+                (pattern) => minimatch(filepath.replace(/^\//, ""), pattern)
+              );
+            });
+            runtime.moduleCache.invalidateSubDepTree(entriesToInvalidate);
+          }
+        }
+        if (data) {
+          await onHmrReceive?.(data);
+        }
+      });
+    }).catch((error) => console.error(error));
+    runtime = new ViteRuntime(
+      {
+        root: env.__VITE_ROOT,
+        sourcemapInterceptor: "prepareStackTrace",
+        fetchModule: async (id, importer) => {
+          const url = new URL(
+            env.__VITE_FETCH_MODULE_PATHNAME,
+            env.__VITE_DEV_SERVER_URL
+          );
+          url.searchParams.set("id", id);
+          if (importer) {
+            url.searchParams.set("importer", importer);
+          }
+          const response = await fetch(url);
+          if (!response.ok) {
+            throw new Error(await response.text());
+          }
+          return response.json();
+        },
+        hmr: {
+          connection: {
+            isReady: () => isHmrReady,
+            send: () => {
+            },
+            onUpdate(receiver) {
+              onHmrReceive = receiver;
+              return () => {
+                onHmrReceive = void 0;
+              };
+            }
+          }
+        }
+      },
+      {
+        runExternalModule(file) {
+          if (env.__VITE_NODE_BUILTINS.includes(file)) {
+            return import(file);
+          }
+          throw new Error(`External module not supported: "${file}"`);
+        },
+        async runViteModule(context, code, id) {
+          const initModule = env.__VITE_UNSAFE_EVAL.eval(
+            `'use strict';async (${Object.keys(context).join(
+              ","
+            )})=>{{${code}
+}}`,
+            id
+          );
+          await initModule(...Object.values(context));
+          Object.freeze(context[ssrModuleExportsKey]);
+        }
+      }
+    );
+  }
+  return runtime.executeEntrypoint(env.__VITE_RUNTIME_EXECUTE_URL);
+}
+async function connectHmrWsClient(env) {
+  const hmrUrl = env.__VITE_DEV_SERVER_URL;
+  const { webSocket } = await fetch(hmrUrl, {
+    headers: { Upgrade: "websocket", "sec-websocket-protocol": "vite-hmr" }
+  });
+  if (!webSocket) {
+    throw new Error(`Failed to connect to HMR server`);
+  }
+  webSocket.accept();
+  return webSocket;
+}
+export {
+  worker_entry_default as default
+};