create-tamagui 1.97.0 → 1.98.0

package/dist/index.js

@@ -1007,8 +1007,8 @@ var require_source = __commonJS({
 // ../../node_modules/commander/index.js
 var require_commander = __commonJS({
   "../../node_modules/commander/index.js"(exports2, module2) {
-    var EventEmitter2 = require("events").EventEmitter, spawn2 = require("child_process").spawn, path6 = require("path"), dirname = path6.dirname, basename2 = path6.basename, fs7 = require("fs");
-    require("util").inherits(Command, EventEmitter2);
+    var EventEmitter3 = require("events").EventEmitter, spawn2 = require("child_process").spawn, path6 = require("path"), dirname = path6.dirname, basename2 = path6.basename, fs7 = require("fs");
+    require("util").inherits(Command, EventEmitter3);
     exports2 = module2.exports = new Command();
     exports2.Command = Command;
     exports2.Option = Option;
@@ -1100,16 +1100,16 @@ var require_commander = __commonJS({
       baseDir = dirname(resolvedLink);
       var localBin = path6.join(baseDir, bin), isExplicitJS = !1;
       exists(localBin + ".js") ? (bin = localBin + ".js", isExplicitJS = !0) : exists(localBin + ".ts") ? (bin = localBin + ".ts", isExplicitJS = !0) : exists(localBin) && (bin = localBin), args = args.slice(1);
-      var proc2;
-      process.platform !== "win32" ? isExplicitJS ? (args.unshift(bin), args = (process.execArgv || []).concat(args), proc2 = spawn2(process.argv[0], args, { stdio: "inherit", customFds: [0, 1, 2] })) : proc2 = spawn2(bin, args, { stdio: "inherit", customFds: [0, 1, 2] }) : (args.unshift(bin), proc2 = spawn2(process.execPath, args, { stdio: "inherit" }));
+      var proc3;
+      process.platform !== "win32" ? isExplicitJS ? (args.unshift(bin), args = (process.execArgv || []).concat(args), proc3 = spawn2(process.argv[0], args, { stdio: "inherit", customFds: [0, 1, 2] })) : proc3 = spawn2(bin, args, { stdio: "inherit", customFds: [0, 1, 2] }) : (args.unshift(bin), proc3 = spawn2(process.execPath, args, { stdio: "inherit" }));
       var signals = ["SIGUSR1", "SIGUSR2", "SIGTERM", "SIGINT", "SIGHUP"];
       signals.forEach(function(signal) {
         process.on(signal, function() {
-          proc2.killed === !1 && proc2.exitCode === null && proc2.kill(signal);
+          proc3.killed === !1 && proc3.exitCode === null && proc3.kill(signal);
         });
-      }), proc2.on("close", process.exit.bind(process)), proc2.on("error", function(err) {
+      }), proc3.on("close", process.exit.bind(process)), proc3.on("error", function(err) {
         err.code === "ENOENT" ? console.error("error: %s(1) does not exist, try --help", bin) : err.code === "EACCES" && console.error("error: %s(1) not executable. try chmod or run with root", bin), process.exit(1);
-      }), this.runningCommand = proc2;
+      }), this.runningCommand = proc3;
     };
     Command.prototype.normalize = function(args) {
       for (var ret = [], arg, lastOpt, index, i = 0, len = args.length; i < len; ++i)
@@ -2356,12 +2356,12 @@ var require_kill = __commonJS({
 var require_is_stream = __commonJS({
   "../../node_modules/is-stream/index.js"(exports2, module2) {
     "use strict";
-    var isStream2 = (stream2) => stream2 !== null && typeof stream2 == "object" && typeof stream2.pipe == "function";
-    isStream2.writable = (stream2) => isStream2(stream2) && stream2.writable !== !1 && typeof stream2._write == "function" && typeof stream2._writableState == "object";
-    isStream2.readable = (stream2) => isStream2(stream2) && stream2.readable !== !1 && typeof stream2._read == "function" && typeof stream2._readableState == "object";
-    isStream2.duplex = (stream2) => isStream2.writable(stream2) && isStream2.readable(stream2);
-    isStream2.transform = (stream2) => isStream2.duplex(stream2) && typeof stream2._transform == "function";
-    module2.exports = isStream2;
+    var isStream3 = (stream2) => stream2 !== null && typeof stream2 == "object" && typeof stream2.pipe == "function";
+    isStream3.writable = (stream2) => isStream3(stream2) && stream2.writable !== !1 && typeof stream2._write == "function" && typeof stream2._writableState == "object";
+    isStream3.readable = (stream2) => isStream3(stream2) && stream2.readable !== !1 && typeof stream2._read == "function" && typeof stream2._readableState == "object";
+    isStream3.duplex = (stream2) => isStream3.writable(stream2) && isStream3.readable(stream2);
+    isStream3.transform = (stream2) => isStream3.duplex(stream2) && typeof stream2._transform == "function";
+    module2.exports = isStream3;
   }
 });
 
@@ -2450,8 +2450,8 @@ var require_merge_stream = __commonJS({
 var require_stream = __commonJS({
   "../../node_modules/execa/lib/stream.js"(exports2, module2) {
     "use strict";
-    var isStream2 = require_is_stream(), getStream = require_get_stream(), mergeStream = require_merge_stream(), handleInput = (spawned, input) => {
-      input === void 0 || spawned.stdin === void 0 || (isStream2(input) ? input.pipe(spawned.stdin) : spawned.stdin.end(input));
+    var isStream3 = require_is_stream(), getStream = require_get_stream(), mergeStream = require_merge_stream(), handleInput = (spawned, input) => {
+      input === void 0 || spawned.stdin === void 0 || (isStream3(input) ? input.pipe(spawned.stdin) : spawned.stdin.end(input));
     }, makeAllStream = (spawned, { all }) => {
       if (!all || !spawned.stdout && !spawned.stderr)
         return;
@@ -2482,7 +2482,7 @@ var require_stream = __commonJS({
         ]);
       }
     }, validateInputSync = ({ input }) => {
-      if (isStream2(input))
+      if (isStream3(input))
         throw new TypeError("The `input` option cannot be a stream in sync mode");
     };
     module2.exports = {
@@ -2937,7 +2937,7 @@ var require_polyfills = __commonJS({
 // ../../node_modules/graceful-fs/legacy-streams.js
 var require_legacy_streams = __commonJS({
   "../../node_modules/graceful-fs/legacy-streams.js"(exports2, module2) {
-    var Stream2 = require("stream").Stream;
+    var Stream3 = require("stream").Stream;
     module2.exports = legacy;
     function legacy(fs7) {
       return {
@@ -2947,7 +2947,7 @@ var require_legacy_streams = __commonJS({
       function ReadStream(path6, options) {
         if (!(this instanceof ReadStream))
           return new ReadStream(path6, options);
-        Stream2.call(this);
+        Stream3.call(this);
         var self = this;
         this.path = path6, this.fd = null, this.readable = !0, this.paused = !1, this.flags = "r", this.mode = 438, this.bufferSize = 64 * 1024, options = options || {};
         for (var keys = Object.keys(options), index = 0, length = keys.length; index < length; index++) {
@@ -2982,7 +2982,7 @@ var require_legacy_streams = __commonJS({
       function WriteStream(path6, options) {
         if (!(this instanceof WriteStream))
           return new WriteStream(path6, options);
-        Stream2.call(this), this.path = path6, this.fd = null, this.writable = !0, this.flags = "w", this.encoding = "binary", this.mode = 438, this.bytesWritten = 0, options = options || {};
+        Stream3.call(this), this.path = path6, this.fd = null, this.writable = !0, this.flags = "w", this.encoding = "binary", this.mode = 438, this.bytesWritten = 0, options = options || {};
         for (var keys = Object.keys(options), index = 0, length = keys.length; index < length; index++) {
           var key = keys[index];
           this[key] = options[key];
@@ -4075,8 +4075,8 @@ var require_utils2 = __commonJS({
   "../../node_modules/jsonfile/utils.js"(exports2, module2) {
     function stringify(obj, { EOL = `
 `, finalEOL = !0, replacer = null, spaces } = {}) {
-      let EOF2 = finalEOL ? EOL : "";
-      return JSON.stringify(obj, replacer, spaces).replace(/\n/g, EOL) + EOF2;
+      let EOF3 = finalEOL ? EOL : "";
+      return JSON.stringify(obj, replacer, spaces).replace(/\n/g, EOL) + EOF3;
     }
     function stripBom(content) {
       return Buffer.isBuffer(content) && (content = content.toString("utf8")), content.replace(/^\uFEFF/, "");
@@ -4617,7 +4617,7 @@ var require_util2 = __commonJS({
 var require_prompt = __commonJS({
   "../../node_modules/prompts/dist/elements/prompt.js"(exports2, module2) {
     "use strict";
-    var readline = require("readline"), _require = require_util2(), action = _require.action, EventEmitter2 = require("events"), _require2 = require_src(), beep = _require2.beep, cursor = _require2.cursor, color = require_kleur(), Prompt = class extends EventEmitter2 {
+    var readline = require("readline"), _require = require_util2(), action = _require.action, EventEmitter3 = require("events"), _require2 = require_src(), beep = _require2.beep, cursor = _require2.cursor, color = require_kleur(), Prompt = class extends EventEmitter3 {
       constructor(opts = {}) {
         super(), this.firstRender = !0, this.in = opts.in || process.stdin, this.out = opts.out || process.stdout, this.onRender = (opts.onRender || (() => {
         })).bind(this);
@@ -6163,7 +6163,7 @@ var require_util3 = __commonJS({
 var require_prompt2 = __commonJS({
   "../../node_modules/prompts/lib/elements/prompt.js"(exports2, module2) {
     "use strict";
-    var readline = require("readline"), { action } = require_util3(), EventEmitter2 = require("events"), { beep, cursor } = require_src(), color = require_kleur(), Prompt = class extends EventEmitter2 {
+    var readline = require("readline"), { action } = require_util3(), EventEmitter3 = require("events"), { beep, cursor } = require_src(), color = require_kleur(), Prompt = class extends EventEmitter3 {
       constructor(opts = {}) {
         super(), this.firstRender = !0, this.in = opts.in || process.stdin, this.out = opts.out || process.stdout, this.onRender = (opts.onRender || (() => {
         })).bind(this);
@@ -7490,7 +7490,7 @@ var require_lib3 = __commonJS({
 // ../../node_modules/through/index.js
 var require_through = __commonJS({
   "../../node_modules/through/index.js"(exports2, module2) {
-    var Stream2 = require("stream");
+    var Stream3 = require("stream");
     exports2 = module2.exports = through;
     through.through = through;
     function through(write, end, opts) {
@@ -7499,7 +7499,7 @@ var require_through = __commonJS({
       }, end = end || function() {
         this.queue(null);
       };
-      var ended = !1, destroyed = !1, buffer = [], _ended = !1, stream2 = new Stream2();
+      var ended = !1, destroyed = !1, buffer = [], _ended = !1, stream2 = new Stream3();
       stream2.readable = stream2.writable = !0, stream2.paused = !1, stream2.autoDestroy = !(opts && opts.autoDestroy === !1), stream2.write = function(data) {
         return write.call(this, data), !stream2.paused;
       };
@@ -7541,7 +7541,7 @@ var require_through = __commonJS({
 var require_from = __commonJS({
   "../../node_modules/from/index.js"(exports2, module2) {
     "use strict";
-    var Stream2 = require("stream");
+    var Stream3 = require("stream");
     module2.exports = function from(source) {
       if (Array.isArray(source)) {
         var source_index = 0, source_len = source.length;
@@ -7549,7 +7549,7 @@ var require_from = __commonJS({
           return source_index < source_len ? this.emit("data", source[source_index++]) : this.emit("end"), !0;
         });
       }
-      var s = new Stream2(), i = 0;
+      var s = new Stream3(), i = 0;
       s.ended = !1, s.started = !1, s.readable = !0, s.writable = !1, s.paused = !1, s.ended = !1, s.pause = function() {
         s.started = !0, s.paused = !0;
       };
@@ -7576,7 +7576,7 @@ var require_from = __commonJS({
 // ../../node_modules/duplexer/index.js
 var require_duplexer = __commonJS({
   "../../node_modules/duplexer/index.js"(exports2, module2) {
-    var Stream2 = require("stream"), writeMethods = ["write", "end", "destroy"], readMethods = ["resume", "pause"], readEvents = ["data", "close"], slice = Array.prototype.slice;
+    var Stream3 = require("stream"), writeMethods = ["write", "end", "destroy"], readMethods = ["resume", "pause"], readEvents = ["data", "close"], slice = Array.prototype.slice;
     module2.exports = duplex;
     function forEach(arr, fn) {
       if (arr.forEach)
@@ -7585,7 +7585,7 @@ var require_duplexer = __commonJS({
         fn(arr[i], i);
     }
     function duplex(writer, reader) {
-      var stream2 = new Stream2(), ended = !1;
+      var stream2 = new Stream3(), ended = !1;
       return forEach(writeMethods, proxyWriter), forEach(readMethods, proxyReader), forEach(readEvents, proxyStream), reader.on("end", handleEnd), writer.on("drain", function() {
         stream2.emit("drain");
       }), writer.on("error", reemit), reader.on("error", reemit), stream2.writable = writer.writable, stream2.readable = reader.readable, stream2;
@@ -7629,9 +7629,9 @@ var require_duplexer = __commonJS({
 // ../../node_modules/map-stream/index.js
 var require_map_stream = __commonJS({
   "../../node_modules/map-stream/index.js"(exports2, module2) {
-    var Stream2 = require("stream").Stream;
+    var Stream3 = require("stream").Stream;
     module2.exports = function(mapper, opts) {
-      var stream2 = new Stream2(), self = this, inputs = 0, outputs = 0, ended = !1, paused = !1, destroyed = !1, lastWritten = 0, inNext = !1;
+      var stream2 = new Stream3(), self = this, inputs = 0, outputs = 0, ended = !1, paused = !1, destroyed = !1, lastWritten = 0, inNext = !1;
       this.opts = opts || {};
       var errorEventName = this.opts.failures ? "failure" : "error", writeQueue = {};
       stream2.writable = !0, stream2.readable = !0;
@@ -7691,9 +7691,9 @@ var require_pause_stream = __commonJS({
   }
 });
 
-// ../../node_modules/split/index.js
+// ../../node_modules/event-stream/node_modules/split/index.js
 var require_split = __commonJS({
-  "../../node_modules/split/index.js"(exports2, module2) {
+  "../../node_modules/event-stream/node_modules/split/index.js"(exports2, module2) {
     var through = require_through(), Decoder = require("string_decoder").StringDecoder;
     module2.exports = split;
     function split(matcher, mapper, options) {
@@ -7758,8 +7758,8 @@ var require_stream_combiner = __commonJS({
 // ../../node_modules/event-stream/index.js
 var require_event_stream = __commonJS({
   "../../node_modules/event-stream/index.js"(exports2) {
-    var Stream2 = require("stream").Stream, es = exports2, through = require_through(), from = require_from(), duplex = require_duplexer(), map = require_map_stream(), pause = require_pause_stream(), split = require_split(), pipeline = require_stream_combiner(), immediately = global.setImmediate || process.nextTick;
-    es.Stream = Stream2;
+    var Stream3 = require("stream").Stream, es = exports2, through = require_through(), from = require_from(), duplex = require_duplexer(), map = require_map_stream(), pause = require_pause_stream(), split = require_split(), pipeline = require_stream_combiner(), immediately = global.setImmediate || process.nextTick;
+    es.Stream = Stream3;
     es.through = through;
     es.from = from;
     es.duplex = duplex;
@@ -7771,7 +7771,7 @@ var require_event_stream = __commonJS({
     es.merge = function() {
       var toMerge = [].slice.call(arguments);
       toMerge.length === 1 && toMerge[0] instanceof Array && (toMerge = toMerge[0]);
-      var stream2 = new Stream2();
+      var stream2 = new Stream3();
       stream2.setMaxListeners(0);
       var endCount = 0;
       return stream2.writable = stream2.readable = !0, toMerge.length ? toMerge.forEach(function(e) {
@@ -7793,7 +7793,7 @@ var require_event_stream = __commonJS({
     es.writeArray = function(done) {
       if (typeof done != "function")
         throw new Error("function writeArray (done): done must be function");
-      var a = new Stream2(), array = [], isDone = !1;
+      var a = new Stream3(), array = [], isDone = !1;
       return a.write = function(l) {
         array.push(l);
       }, a.end = function() {
@@ -7803,7 +7803,7 @@ var require_event_stream = __commonJS({
       }, a;
     };
     es.readArray = function(array) {
-      var stream2 = new Stream2(), i = 0, paused = !1, ended = !1;
+      var stream2 = new Stream3(), i = 0, paused = !1, ended = !1;
       if (stream2.readable = !0, stream2.writable = !1, !Array.isArray(array))
         throw new Error("event-stream.read expects an array");
       return stream2.resume = function() {
@@ -7820,7 +7820,7 @@ var require_event_stream = __commonJS({
       }, stream2;
     };
     es.readable = function(func, continueOnError) {
-      var stream2 = new Stream2(), i = 0, paused = !1, ended = !1, reading = !1;
+      var stream2 = new Stream3(), i = 0, paused = !1, ended = !1, reading = !1;
       if (stream2.readable = !0, stream2.writable = !1, typeof func != "function")
         throw new Error("event-stream.readable expects async function");
       stream2.on("end", function() {
@@ -7939,8 +7939,8 @@ var require_ps_tree = __commonJS({
         }),
         es.writeArray(function(err, ps) {
           var parents = {}, children = [];
-          parents[pid] = !0, ps.forEach(function(proc2) {
-            parents[proc2.PPID] && (parents[proc2.PID] = !0, children.push(proc2));
+          parents[pid] = !0, ps.forEach(function(proc3) {
+            parents[proc3.PPID] && (parents[proc3.PID] = !0, children.push(proc3));
           }), callback(null, children);
         })
       ).on("error", callback);
@@ -7968,7 +7968,7 @@ var require_ps_tree = __commonJS({
 var require_merge2 = __commonJS({
   "../../node_modules/merge2/index.js"(exports2, module2) {
     "use strict";
-    var Stream2 = require("stream"), PassThrough = Stream2.PassThrough, slice = Array.prototype.slice;
+    var Stream3 = require("stream"), PassThrough = Stream3.PassThrough, slice = Array.prototype.slice;
     module2.exports = merge22;
     function merge22() {
       let streamsQueue = [], args = slice.call(arguments), merging = !1, options = args[args.length - 1];
@@ -17905,9 +17905,9 @@ ${callerStack}`), Object.assign(error, result), reject(error);
   }
 });
 
-// ../../node_modules/@expo/package-manager/node_modules/sudo-prompt/index.js
+// ../../node_modules/sudo-prompt/index.js
 var require_sudo_prompt = __commonJS({
-  "../../node_modules/@expo/package-manager/node_modules/sudo-prompt/index.js"(exports2, module2) {
+  "../../node_modules/sudo-prompt/index.js"(exports2, module2) {
     var Node = {
       child: require("child_process"),
       crypto: require("crypto"),
@@ -18867,6 +18867,48 @@ var require_lib4 = __commonJS({
   }
 });
 
+// ../../node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS({
+  "../../node_modules/picocolors/picocolors.js"(exports2, module2) {
+    var tty2 = require("tty"), isColorSupported = !("NO_COLOR" in process.env || process.argv.includes("--no-color")) && ("FORCE_COLOR" in process.env || process.argv.includes("--color") || process.platform === "win32" || tty2.isatty(1) && process.env.TERM !== "dumb" || "CI" in process.env), formatter = (open3, close, replace = open3) => (input) => {
+      let string = "" + input, index = string.indexOf(close, open3.length);
+      return ~index ? open3 + replaceClose(string, close, replace, index) + close : open3 + string + close;
+    }, replaceClose = (string, close, replace, index) => {
+      let start = string.substring(0, index) + replace, end = string.substring(index + close.length), nextIndex = end.indexOf(close);
+      return ~nextIndex ? start + replaceClose(end, close, replace, nextIndex) : start + end;
+    }, createColors = (enabled = isColorSupported) => ({
+      isColorSupported: enabled,
+      reset: enabled ? (s) => `\x1B[0m${s}\x1B[0m` : String,
+      bold: enabled ? formatter("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m") : String,
+      dim: enabled ? formatter("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m") : String,
+      italic: enabled ? formatter("\x1B[3m", "\x1B[23m") : String,
+      underline: enabled ? formatter("\x1B[4m", "\x1B[24m") : String,
+      inverse: enabled ? formatter("\x1B[7m", "\x1B[27m") : String,
+      hidden: enabled ? formatter("\x1B[8m", "\x1B[28m") : String,
+      strikethrough: enabled ? formatter("\x1B[9m", "\x1B[29m") : String,
+      black: enabled ? formatter("\x1B[30m", "\x1B[39m") : String,
+      red: enabled ? formatter("\x1B[31m", "\x1B[39m") : String,
+      green: enabled ? formatter("\x1B[32m", "\x1B[39m") : String,
+      yellow: enabled ? formatter("\x1B[33m", "\x1B[39m") : String,
+      blue: enabled ? formatter("\x1B[34m", "\x1B[39m") : String,
+      magenta: enabled ? formatter("\x1B[35m", "\x1B[39m") : String,
+      cyan: enabled ? formatter("\x1B[36m", "\x1B[39m") : String,
+      white: enabled ? formatter("\x1B[37m", "\x1B[39m") : String,
+      gray: enabled ? formatter("\x1B[90m", "\x1B[39m") : String,
+      bgBlack: enabled ? formatter("\x1B[40m", "\x1B[49m") : String,
+      bgRed: enabled ? formatter("\x1B[41m", "\x1B[49m") : String,
+      bgGreen: enabled ? formatter("\x1B[42m", "\x1B[49m") : String,
+      bgYellow: enabled ? formatter("\x1B[43m", "\x1B[49m") : String,
+      bgBlue: enabled ? formatter("\x1B[44m", "\x1B[49m") : String,
+      bgMagenta: enabled ? formatter("\x1B[45m", "\x1B[49m") : String,
+      bgCyan: enabled ? formatter("\x1B[46m", "\x1B[49m") : String,
+      bgWhite: enabled ? formatter("\x1B[47m", "\x1B[49m") : String
+    });
+    module2.exports = createColors();
+    module2.exports.createColors = createColors;
+  }
+});
+
 // ../../node_modules/@babel/highlight/node_modules/escape-string-regexp/index.js
 var require_escape_string_regexp = __commonJS({
   "../../node_modules/@babel/highlight/node_modules/escape-string-regexp/index.js"(exports2, module2) {
@@ -19820,43 +19862,43 @@ var require_lib5 = __commonJS({
     });
     exports2.default = highlight;
     exports2.shouldHighlight = shouldHighlight;
-    var _jsTokens = require_js_tokens(), _helperValidatorIdentifier = require_lib4(), _chalk = _interopRequireWildcard(require_chalk(), !0);
-    function _getRequireWildcardCache(nodeInterop) {
+    var _jsTokens = require_js_tokens(), _helperValidatorIdentifier = require_lib4(), _picocolors = _interopRequireWildcard(require_picocolors(), !0);
+    function _getRequireWildcardCache(e) {
       if (typeof WeakMap != "function")
         return null;
-      var cacheBabelInterop = /* @__PURE__ */ new WeakMap(), cacheNodeInterop = /* @__PURE__ */ new WeakMap();
-      return (_getRequireWildcardCache = function(nodeInterop2) {
-        return nodeInterop2 ? cacheNodeInterop : cacheBabelInterop;
-      })(nodeInterop);
-    }
-    function _interopRequireWildcard(obj, nodeInterop) {
-      if (!nodeInterop && obj && obj.__esModule)
-        return obj;
-      if (obj === null || typeof obj != "object" && typeof obj != "function")
-        return { default: obj };
-      var cache2 = _getRequireWildcardCache(nodeInterop);
-      if (cache2 && cache2.has(obj))
-        return cache2.get(obj);
-      var newObj = {}, hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
-      for (var key in obj)
-        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
-          var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
-          desc && (desc.get || desc.set) ? Object.defineProperty(newObj, key, desc) : newObj[key] = obj[key];
-        }
-      return newObj.default = obj, cache2 && cache2.set(obj, newObj), newObj;
-    }
-    var sometimesKeywords = /* @__PURE__ */ new Set(["as", "async", "from", "get", "of", "set"]);
-    function getDefs(chalk13) {
+      var r = /* @__PURE__ */ new WeakMap(), t = /* @__PURE__ */ new WeakMap();
+      return (_getRequireWildcardCache = function(e2) {
+        return e2 ? t : r;
+      })(e);
+    }
+    function _interopRequireWildcard(e, r) {
+      if (!r && e && e.__esModule)
+        return e;
+      if (e === null || typeof e != "object" && typeof e != "function")
+        return { default: e };
+      var t = _getRequireWildcardCache(r);
+      if (t && t.has(e))
+        return t.get(e);
+      var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor;
+      for (var u in e)
+        if (u !== "default" && Object.prototype.hasOwnProperty.call(e, u)) {
+          var i = a ? Object.getOwnPropertyDescriptor(e, u) : null;
+          i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u];
+        }
+      return n.default = e, t && t.set(e, n), n;
+    }
+    var colors = typeof process == "object" && (process.env.FORCE_COLOR === "0" || process.env.FORCE_COLOR === "false") ? (0, _picocolors.createColors)(!1) : _picocolors.default, compose = (f, g) => (v) => f(g(v)), sometimesKeywords = /* @__PURE__ */ new Set(["as", "async", "from", "get", "of", "set"]);
+    function getDefs(colors2) {
       return {
-        keyword: chalk13.cyan,
-        capitalized: chalk13.yellow,
-        jsxIdentifier: chalk13.yellow,
-        punctuator: chalk13.yellow,
-        number: chalk13.magenta,
-        string: chalk13.green,
-        regex: chalk13.magenta,
-        comment: chalk13.grey,
-        invalid: chalk13.white.bgRed.bold
+        keyword: colors2.cyan,
+        capitalized: colors2.yellow,
+        jsxIdentifier: colors2.yellow,
+        punctuator: colors2.yellow,
+        number: colors2.magenta,
+        string: colors2.green,
+        regex: colors2.magenta,
+        comment: colors2.gray,
+        invalid: compose(compose(colors2.white, colors2.bgRed), colors2.bold)
       };
     }
     var NEWLINE = /\r\n|[\n\r\u2028\u2029]/, BRACKET = /^[()[\]{}]$/, tokenize;
@@ -19896,27 +19938,39 @@ var require_lib5 = __commonJS({
       return highlighted;
     }
     function shouldHighlight(options) {
-      return _chalk.default.level > 0 || options.forceColor;
+      return colors.isColorSupported || options.forceColor;
     }
-    var chalkWithForcedColor;
-    function getChalk(forceColor) {
+    var pcWithForcedColor;
+    function getColors(forceColor) {
       if (forceColor) {
-        var _chalkWithForcedColor;
-        return (_chalkWithForcedColor = chalkWithForcedColor) != null || (chalkWithForcedColor = new _chalk.default.constructor({
-          enabled: !0,
-          level: 1
-        })), chalkWithForcedColor;
+        var _pcWithForcedColor;
+        return (_pcWithForcedColor = pcWithForcedColor) != null || (pcWithForcedColor = (0, _picocolors.createColors)(!0)), pcWithForcedColor;
       }
-      return _chalk.default;
+      return colors;
     }
-    exports2.getChalk = (options) => getChalk(options.forceColor);
     function highlight(code, options = {}) {
       if (code !== "" && shouldHighlight(options)) {
-        let defs = getDefs(getChalk(options.forceColor));
+        let defs = getDefs(getColors(options.forceColor));
         return highlightTokens(defs, code);
       } else
         return code;
     }
+    {
+      let chalk13, chalkWithForcedColor;
+      exports2.getChalk = ({
+        forceColor
+      }) => {
+        var _chalk;
+        if ((_chalk = chalk13) != null || (chalk13 = require_chalk()), forceColor) {
+          var _chalkWithForcedColor;
+          return (_chalkWithForcedColor = chalkWithForcedColor) != null || (chalkWithForcedColor = new chalk13.constructor({
+            enabled: !0,
+            level: 1
+          })), chalkWithForcedColor;
+        }
+        return chalk13;
+      };
+    }
   }
 });
 
@@ -26253,7 +26307,7 @@ var globby2 = Object.assign(function(patterns, options) {
 // package.json
 var package_default = {
   name: "create-tamagui",
-  version: "1.96.0",
+  version: "1.97.1",
   bin: "./run.js",
   main: "dist",
   files: [
@@ -26274,7 +26328,7 @@ var package_default = {
   devDependencies: {
     "@expo/package-manager": "^1.1.2",
     "@playwright/test": "^1.40.1",
-    "@tamagui/build": "1.96.0",
+    "@tamagui/build": "1.97.1",
     "@types/async-retry": "1.4.2",
     "@types/cross-spawn": "^6.0.2",
     "@types/node": "^16.11.9",
@@ -27256,7 +27310,7 @@ minimatch.Minimatch = Minimatch;
 minimatch.escape = escape;
 minimatch.unescape = unescape;
 
-// ../../node_modules/rimraf/node_modules/lru-cache/dist/mjs/index.js
+// ../../node_modules/path-scurry/node_modules/lru-cache/dist/esm/index.js
 var perf = typeof performance == "object" && performance && typeof performance.now == "function" ? performance : Date, warned = /* @__PURE__ */ new Set(), PROCESS = typeof process == "object" && process ? process : {}, emitWarning = (msg, type, code, fn) => {
   typeof PROCESS.emitWarning == "function" ? PROCESS.emitWarning(msg, type, code, fn) : console.error(`[${code}] ${type}: ${msg}`);
 }, AC = globalThis.AbortController, AS = globalThis.AbortSignal;
@@ -27535,6 +27589,8 @@ var shouldWarn = (code) => !warned.has(code), TYPE = Symbol("type"), isPosInt =
     }, this.#statusTTL = (status, index) => {
       if (ttls[index]) {
         let ttl = ttls[index], start = starts[index];
+        if (!ttl || !start)
+          return;
         status.ttl = ttl, status.start = start, status.now = cachedNow || getNow();
         let age = status.now - start;
         status.remainingTTL = ttl - age;
@@ -27554,11 +27610,14 @@ var shouldWarn = (code) => !warned.has(code), TYPE = Symbol("type"), isPosInt =
       if (index === void 0)
         return 0;
       let ttl = ttls[index], start = starts[index];
-      if (ttl === 0 || start === 0)
+      if (!ttl || !start)
         return 1 / 0;
       let age = (cachedNow || getNow()) - start;
       return ttl - age;
-    }, this.#isStale = (index) => ttls[index] !== 0 && starts[index] !== 0 && (cachedNow || getNow()) - starts[index] > ttls[index];
+    }, this.#isStale = (index) => {
+      let s = starts[index], t = ttls[index];
+      return !!t && !!s && (cachedNow || getNow()) - s > t;
+    };
   }
   // conditionally set private methods related to TTL
   #updateItemAge = () => {
@@ -27681,6 +27740,11 @@ var shouldWarn = (code) => !warned.has(code), TYPE = Symbol("type"), isPosInt =
   [Symbol.iterator]() {
     return this.entries();
   }
+  /**
+   * A String value that is used in the creation of the default string description of an object.
+   * Called by the built-in method Object.prototype.toString.
+   */
+  [Symbol.toStringTag] = "LRUCache";
   /**
    * Find a value for which the supplied fn method returns a truthy value,
    * similar to Array.find().  fn is called as fn(value, key, cache).
@@ -27724,6 +27788,29 @@ var shouldWarn = (code) => !warned.has(code), TYPE = Symbol("type"), isPosInt =
       this.#isStale(i) && (this.delete(this.#keyList[i]), deleted = !0);
     return deleted;
   }
+  /**
+   * Get the extended info about a given entry, to get its value, size, and
+   * TTL info simultaneously. Like {@link LRUCache#dump}, but just for a
+   * single key. Always returns stale values, if their info is found in the
+   * cache, so be sure to check for expired TTLs if relevant.
+   */
+  info(key) {
+    let i = this.#keyMap.get(key);
+    if (i === void 0)
+      return;
+    let v = this.#valList[i], value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+    if (value === void 0)
+      return;
+    let entry = { value };
+    if (this.#ttls && this.#starts) {
+      let ttl = this.#ttls[i], start = this.#starts[i];
+      if (ttl && start) {
+        let remain = ttl - (perf.now() - start);
+        entry.ttl = remain, entry.start = Date.now();
+      }
+    }
+    return this.#sizes && (entry.size = this.#sizes[i]), entry;
+  }
   /**
    * Return an array of [key, {@link LRUCache.Entry}] tuples which can be
    * passed to cache.load()
@@ -27856,10 +27943,10 @@ var shouldWarn = (code) => !warned.has(code), TYPE = Symbol("type"), isPosInt =
    */
   peek(k, peekOptions = {}) {
     let { allowStale = this.allowStale } = peekOptions, index = this.#keyMap.get(k);
-    if (index !== void 0 && (allowStale || !this.#isStale(index))) {
-      let v = this.#valList[index];
-      return this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
-    }
+    if (index === void 0 || !allowStale && this.#isStale(index))
+      return;
+    let v = this.#valList[index];
+    return this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
   }
   #backgroundFetch(k, index, options, context) {
     let v = index === void 0 ? void 0 : this.#valList[index];
@@ -28001,7 +28088,17 @@ var shouldWarn = (code) => !warned.has(code), TYPE = Symbol("type"), isPosInt =
         else {
           this.#removeItemSize(index);
           let v = this.#valList[index];
-          this.#isBackgroundFetch(v) ? v.__abortController.abort(new Error("deleted")) : (this.#hasDispose || this.#hasDisposeAfter) && (this.#hasDispose && this.#dispose?.(v, k, "delete"), this.#hasDisposeAfter && this.#disposed?.push([v, k, "delete"])), this.#keyMap.delete(k), this.#keyList[index] = void 0, this.#valList[index] = void 0, index === this.#tail ? this.#tail = this.#prev[index] : index === this.#head ? this.#head = this.#next[index] : (this.#next[this.#prev[index]] = this.#next[index], this.#prev[this.#next[index]] = this.#prev[index]), this.#size--, this.#free.push(index);
+          if (this.#isBackgroundFetch(v) ? v.__abortController.abort(new Error("deleted")) : (this.#hasDispose || this.#hasDisposeAfter) && (this.#hasDispose && this.#dispose?.(v, k, "delete"), this.#hasDisposeAfter && this.#disposed?.push([v, k, "delete"])), this.#keyMap.delete(k), this.#keyList[index] = void 0, this.#valList[index] = void 0, index === this.#tail)
+            this.#tail = this.#prev[index];
+          else if (index === this.#head)
+            this.#head = this.#next[index];
+          else {
+            let pi = this.#prev[index];
+            this.#next[pi] = this.#next[index];
+            let ni = this.#next[index];
+            this.#prev[ni] = this.#prev[index];
+          }
+          this.#size--, this.#free.push(index);
         }
     }
     if (this.#hasDisposeAfter && this.#disposed?.length) {
@@ -28032,10 +28129,10 @@ var shouldWarn = (code) => !warned.has(code), TYPE = Symbol("type"), isPosInt =
   }
 };
 
-// ../../node_modules/rimraf/node_modules/path-scurry/dist/mjs/index.js
+// ../../node_modules/path-scurry/dist/esm/index.js
 var import_path3 = require("path"), import_url = require("url"), actualFS = __toESM(require("fs"), 1), import_fs2 = require("fs"), import_promises = require("fs/promises");
 
-// ../../node_modules/rimraf/node_modules/minipass/dist/mjs/index.js
+// ../../node_modules/path-scurry/node_modules/minipass/dist/esm/index.js
 var import_events = require("events"), import_stream = __toESM(require("stream"), 1), import_string_decoder = require("string_decoder"), proc = typeof process == "object" && process ? process : {
   stdout: null,
   stderr: null
@@ -28591,7 +28688,7 @@ s.pipe !== import_stream.default.Writable.prototype.pipe, isWritable = (s) => !!
   }
 };
 
-// ../../node_modules/rimraf/node_modules/path-scurry/dist/mjs/index.js
+// ../../node_modules/path-scurry/dist/esm/index.js
 var realpathSync = import_fs2.realpathSync.native, defaultFS = {
   lstatSync: import_fs2.lstatSync,
   readdir: import_fs2.readdir,
@@ -29069,7 +29166,7 @@ var realpathSync = import_fs2.realpathSync.native, defaultFS = {
       return target;
     if (this.canReadlink() && this.parent)
       try {
-        let read = await this.#fs.promises.readlink(this.fullpath()), linkTarget = this.parent.resolve(read);
+        let read = await this.#fs.promises.readlink(this.fullpath()), linkTarget = (await this.parent.realpath())?.resolve(read);
         if (linkTarget)
           return this.#linkTarget = linkTarget;
       } catch (er) {
@@ -29086,7 +29183,7 @@ var realpathSync = import_fs2.realpathSync.native, defaultFS = {
       return target;
     if (this.canReadlink() && this.parent)
       try {
-        let read = this.#fs.readlinkSync(this.fullpath()), linkTarget = this.parent.resolve(read);
+        let read = this.#fs.readlinkSync(this.fullpath()), linkTarget = this.parent.realpathSync()?.resolve(read);
         if (linkTarget)
           return this.#linkTarget = linkTarget;
       } catch (er) {
@@ -29096,8 +29193,10 @@ var realpathSync = import_fs2.realpathSync.native, defaultFS = {
   }
   #readdirSuccess(children) {
     this.#type |= READDIR_CALLED;
-    for (let p = children.provisional; p < children.length; p++)
-      children[p].#markENOENT();
+    for (let p = children.provisional; p < children.length; p++) {
+      let c = children[p];
+      c && c.#markENOENT();
+    }
   }
   #markENOENT() {
     this.#type & ENOENT || (this.#type = (this.#type | ENOENT) & IFMT_UNKNOWN, this.#markChildrenENOENT());
@@ -29867,10 +29966,10 @@ var realpathSync = import_fs2.realpathSync.native, defaultFS = {
   }
 }, Path = process.platform === "win32" ? PathWin32 : PathPosix, PathScurry = process.platform === "win32" ? PathScurryWin32 : process.platform === "darwin" ? PathScurryDarwin : PathScurryPosix;
 
-// ../../node_modules/rimraf/node_modules/glob/dist/mjs/glob.js
+// ../../node_modules/rimraf/node_modules/glob/dist/esm/glob.js
 var import_url2 = require("url");
 
-// ../../node_modules/rimraf/node_modules/glob/dist/mjs/pattern.js
+// ../../node_modules/rimraf/node_modules/glob/dist/esm/pattern.js
 var isPatternList = (pl) => pl.length >= 1, isGlobList = (gl) => gl.length >= 1, Pattern = class _Pattern {
   #patternList;
   #globList;
@@ -29999,7 +30098,563 @@ var isPatternList = (pl) => pl.length >= 1, isGlobList = (gl) => gl.length >= 1,
   }
 };
 
-// ../../node_modules/rimraf/node_modules/glob/dist/mjs/ignore.js
+// ../../node_modules/rimraf/node_modules/minipass/dist/esm/index.js
+var import_events2 = require("events"), import_stream2 = __toESM(require("stream"), 1), import_string_decoder2 = require("string_decoder"), proc2 = typeof process == "object" && process ? process : {
+  stdout: null,
+  stderr: null
+}, isStream2 = (s) => !!s && typeof s == "object" && (s instanceof Minipass2 || s instanceof import_stream2.default || isReadable2(s) || isWritable2(s)), isReadable2 = (s) => !!s && typeof s == "object" && s instanceof import_events2.EventEmitter && typeof s.pipe == "function" && // node core Writable streams have a pipe() method, but it throws
+s.pipe !== import_stream2.default.Writable.prototype.pipe, isWritable2 = (s) => !!s && typeof s == "object" && s instanceof import_events2.EventEmitter && typeof s.write == "function" && typeof s.end == "function", EOF2 = Symbol("EOF"), MAYBE_EMIT_END2 = Symbol("maybeEmitEnd"), EMITTED_END2 = Symbol("emittedEnd"), EMITTING_END2 = Symbol("emittingEnd"), EMITTED_ERROR2 = Symbol("emittedError"), CLOSED2 = Symbol("closed"), READ2 = Symbol("read"), FLUSH2 = Symbol("flush"), FLUSHCHUNK2 = Symbol("flushChunk"), ENCODING2 = Symbol("encoding"), DECODER2 = Symbol("decoder"), FLOWING2 = Symbol("flowing"), PAUSED2 = Symbol("paused"), RESUME2 = Symbol("resume"), BUFFER2 = Symbol("buffer"), PIPES2 = Symbol("pipes"), BUFFERLENGTH2 = Symbol("bufferLength"), BUFFERPUSH2 = Symbol("bufferPush"), BUFFERSHIFT2 = Symbol("bufferShift"), OBJECTMODE2 = Symbol("objectMode"), DESTROYED2 = Symbol("destroyed"), ERROR2 = Symbol("error"), EMITDATA2 = Symbol("emitData"), EMITEND3 = Symbol("emitEnd"), EMITEND22 = Symbol("emitEnd2"), ASYNC2 = Symbol("async"), ABORT2 = Symbol("abort"), ABORTED2 = Symbol("aborted"), SIGNAL2 = Symbol("signal"), DATALISTENERS2 = Symbol("dataListeners"), DISCARDED2 = Symbol("discarded"), defer2 = (fn) => Promise.resolve().then(fn), nodefer2 = (fn) => fn(), isEndish2 = (ev) => ev === "end" || ev === "finish" || ev === "prefinish", isArrayBufferLike2 = (b) => b instanceof ArrayBuffer || !!b && typeof b == "object" && b.constructor && b.constructor.name === "ArrayBuffer" && b.byteLength >= 0, isArrayBufferView2 = (b) => !Buffer.isBuffer(b) && ArrayBuffer.isView(b), Pipe2 = class {
+  src;
+  dest;
+  opts;
+  ondrain;
+  constructor(src, dest, opts) {
+    this.src = src, this.dest = dest, this.opts = opts, this.ondrain = () => src[RESUME2](), this.dest.on("drain", this.ondrain);
+  }
+  unpipe() {
+    this.dest.removeListener("drain", this.ondrain);
+  }
+  // only here for the prototype
+  /* c8 ignore start */
+  proxyErrors(_er) {
+  }
+  /* c8 ignore stop */
+  end() {
+    this.unpipe(), this.opts.end && this.dest.end();
+  }
+}, PipeProxyErrors2 = class extends Pipe2 {
+  unpipe() {
+    this.src.removeListener("error", this.proxyErrors), super.unpipe();
+  }
+  constructor(src, dest, opts) {
+    super(src, dest, opts), this.proxyErrors = (er) => dest.emit("error", er), src.on("error", this.proxyErrors);
+  }
+}, isObjectModeOptions2 = (o) => !!o.objectMode, isEncodingOptions2 = (o) => !o.objectMode && !!o.encoding && o.encoding !== "buffer", Minipass2 = class extends import_events2.EventEmitter {
+  [FLOWING2] = !1;
+  [PAUSED2] = !1;
+  [PIPES2] = [];
+  [BUFFER2] = [];
+  [OBJECTMODE2];
+  [ENCODING2];
+  [ASYNC2];
+  [DECODER2];
+  [EOF2] = !1;
+  [EMITTED_END2] = !1;
+  [EMITTING_END2] = !1;
+  [CLOSED2] = !1;
+  [EMITTED_ERROR2] = null;
+  [BUFFERLENGTH2] = 0;
+  [DESTROYED2] = !1;
+  [SIGNAL2];
+  [ABORTED2] = !1;
+  [DATALISTENERS2] = 0;
+  [DISCARDED2] = !1;
+  /**
+   * true if the stream can be written
+   */
+  writable = !0;
+  /**
+   * true if the stream can be read
+   */
+  readable = !0;
+  /**
+   * If `RType` is Buffer, then options do not need to be provided.
+   * Otherwise, an options object must be provided to specify either
+   * {@link Minipass.SharedOptions.objectMode} or
+   * {@link Minipass.SharedOptions.encoding}, as appropriate.
+   */
+  constructor(...args) {
+    let options = args[0] || {};
+    if (super(), options.objectMode && typeof options.encoding == "string")
+      throw new TypeError("Encoding and objectMode may not be used together");
+    isObjectModeOptions2(options) ? (this[OBJECTMODE2] = !0, this[ENCODING2] = null) : isEncodingOptions2(options) ? (this[ENCODING2] = options.encoding, this[OBJECTMODE2] = !1) : (this[OBJECTMODE2] = !1, this[ENCODING2] = null), this[ASYNC2] = !!options.async, this[DECODER2] = this[ENCODING2] ? new import_string_decoder2.StringDecoder(this[ENCODING2]) : null, options && options.debugExposeBuffer === !0 && Object.defineProperty(this, "buffer", { get: () => this[BUFFER2] }), options && options.debugExposePipes === !0 && Object.defineProperty(this, "pipes", { get: () => this[PIPES2] });
+    let { signal } = options;
+    signal && (this[SIGNAL2] = signal, signal.aborted ? this[ABORT2]() : signal.addEventListener("abort", () => this[ABORT2]()));
+  }
+  /**
+   * The amount of data stored in the buffer waiting to be read.
+   *
+   * For Buffer strings, this will be the total byte length.
+   * For string encoding streams, this will be the string character length,
+   * according to JavaScript's `string.length` logic.
+   * For objectMode streams, this is a count of the items waiting to be
+   * emitted.
+   */
+  get bufferLength() {
+    return this[BUFFERLENGTH2];
+  }
+  /**
+   * The `BufferEncoding` currently in use, or `null`
+   */
+  get encoding() {
+    return this[ENCODING2];
+  }
+  /**
+   * @deprecated - This is a read only property
+   */
+  set encoding(_enc) {
+    throw new Error("Encoding must be set at instantiation time");
+  }
+  /**
+   * @deprecated - Encoding may only be set at instantiation time
+   */
+  setEncoding(_enc) {
+    throw new Error("Encoding must be set at instantiation time");
+  }
+  /**
+   * True if this is an objectMode stream
+   */
+  get objectMode() {
+    return this[OBJECTMODE2];
+  }
+  /**
+   * @deprecated - This is a read-only property
+   */
+  set objectMode(_om) {
+    throw new Error("objectMode must be set at instantiation time");
+  }
+  /**
+   * true if this is an async stream
+   */
+  get async() {
+    return this[ASYNC2];
+  }
+  /**
+   * Set to true to make this stream async.
+   *
+   * Once set, it cannot be unset, as this would potentially cause incorrect
+   * behavior.  Ie, a sync stream can be made async, but an async stream
+   * cannot be safely made sync.
+   */
+  set async(a) {
+    this[ASYNC2] = this[ASYNC2] || !!a;
+  }
+  // drop everything and get out of the flow completely
+  [ABORT2]() {
+    this[ABORTED2] = !0, this.emit("abort", this[SIGNAL2]?.reason), this.destroy(this[SIGNAL2]?.reason);
+  }
+  /**
+   * True if the stream has been aborted.
+   */
+  get aborted() {
+    return this[ABORTED2];
+  }
+  /**
+   * No-op setter. Stream aborted status is set via the AbortSignal provided
+   * in the constructor options.
+   */
+  set aborted(_) {
+  }
+  write(chunk, encoding, cb) {
+    if (this[ABORTED2])
+      return !1;
+    if (this[EOF2])
+      throw new Error("write after end");
+    if (this[DESTROYED2])
+      return this.emit("error", Object.assign(new Error("Cannot call write after a stream was destroyed"), { code: "ERR_STREAM_DESTROYED" })), !0;
+    typeof encoding == "function" && (cb = encoding, encoding = "utf8"), encoding || (encoding = "utf8");
+    let fn = this[ASYNC2] ? defer2 : nodefer2;
+    if (!this[OBJECTMODE2] && !Buffer.isBuffer(chunk)) {
+      if (isArrayBufferView2(chunk))
+        chunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+      else if (isArrayBufferLike2(chunk))
+        chunk = Buffer.from(chunk);
+      else if (typeof chunk != "string")
+        throw new Error("Non-contiguous data written to non-objectMode stream");
+    }
+    return this[OBJECTMODE2] ? (this[FLOWING2] && this[BUFFERLENGTH2] !== 0 && this[FLUSH2](!0), this[FLOWING2] ? this.emit("data", chunk) : this[BUFFERPUSH2](chunk), this[BUFFERLENGTH2] !== 0 && this.emit("readable"), cb && fn(cb), this[FLOWING2]) : chunk.length ? (typeof chunk == "string" && // unless it is a string already ready for us to use
+    !(encoding === this[ENCODING2] && !this[DECODER2]?.lastNeed) && (chunk = Buffer.from(chunk, encoding)), Buffer.isBuffer(chunk) && this[ENCODING2] && (chunk = this[DECODER2].write(chunk)), this[FLOWING2] && this[BUFFERLENGTH2] !== 0 && this[FLUSH2](!0), this[FLOWING2] ? this.emit("data", chunk) : this[BUFFERPUSH2](chunk), this[BUFFERLENGTH2] !== 0 && this.emit("readable"), cb && fn(cb), this[FLOWING2]) : (this[BUFFERLENGTH2] !== 0 && this.emit("readable"), cb && fn(cb), this[FLOWING2]);
+  }
+  /**
+   * Low-level explicit read method.
+   *
+   * In objectMode, the argument is ignored, and one item is returned if
+   * available.
+   *
+   * `n` is the number of bytes (or in the case of encoding streams,
+   * characters) to consume. If `n` is not provided, then the entire buffer
+   * is returned, or `null` is returned if no data is available.
+   *
+   * If `n` is greater that the amount of data in the internal buffer,
+   * then `null` is returned.
+   */
+  read(n) {
+    if (this[DESTROYED2])
+      return null;
+    if (this[DISCARDED2] = !1, this[BUFFERLENGTH2] === 0 || n === 0 || n && n > this[BUFFERLENGTH2])
+      return this[MAYBE_EMIT_END2](), null;
+    this[OBJECTMODE2] && (n = null), this[BUFFER2].length > 1 && !this[OBJECTMODE2] && (this[BUFFER2] = [
+      this[ENCODING2] ? this[BUFFER2].join("") : Buffer.concat(this[BUFFER2], this[BUFFERLENGTH2])
+    ]);
+    let ret = this[READ2](n || null, this[BUFFER2][0]);
+    return this[MAYBE_EMIT_END2](), ret;
+  }
+  [READ2](n, chunk) {
+    if (this[OBJECTMODE2])
+      this[BUFFERSHIFT2]();
+    else {
+      let c = chunk;
+      n === c.length || n === null ? this[BUFFERSHIFT2]() : typeof c == "string" ? (this[BUFFER2][0] = c.slice(n), chunk = c.slice(0, n), this[BUFFERLENGTH2] -= n) : (this[BUFFER2][0] = c.subarray(n), chunk = c.subarray(0, n), this[BUFFERLENGTH2] -= n);
+    }
+    return this.emit("data", chunk), !this[BUFFER2].length && !this[EOF2] && this.emit("drain"), chunk;
+  }
+  end(chunk, encoding, cb) {
+    return typeof chunk == "function" && (cb = chunk, chunk = void 0), typeof encoding == "function" && (cb = encoding, encoding = "utf8"), chunk !== void 0 && this.write(chunk, encoding), cb && this.once("end", cb), this[EOF2] = !0, this.writable = !1, (this[FLOWING2] || !this[PAUSED2]) && this[MAYBE_EMIT_END2](), this;
+  }
+  // don't let the internal resume be overwritten
+  [RESUME2]() {
+    this[DESTROYED2] || (!this[DATALISTENERS2] && !this[PIPES2].length && (this[DISCARDED2] = !0), this[PAUSED2] = !1, this[FLOWING2] = !0, this.emit("resume"), this[BUFFER2].length ? this[FLUSH2]() : this[EOF2] ? this[MAYBE_EMIT_END2]() : this.emit("drain"));
+  }
+  /**
+   * Resume the stream if it is currently in a paused state
+   *
+   * If called when there are no pipe destinations or `data` event listeners,
+   * this will place the stream in a "discarded" state, where all data will
+   * be thrown away. The discarded state is removed if a pipe destination or
+   * data handler is added, if pause() is called, or if any synchronous or
+   * asynchronous iteration is started.
+   */
+  resume() {
+    return this[RESUME2]();
+  }
+  /**
+   * Pause the stream
+   */
+  pause() {
+    this[FLOWING2] = !1, this[PAUSED2] = !0, this[DISCARDED2] = !1;
+  }
+  /**
+   * true if the stream has been forcibly destroyed
+   */
+  get destroyed() {
+    return this[DESTROYED2];
+  }
+  /**
+   * true if the stream is currently in a flowing state, meaning that
+   * any writes will be immediately emitted.
+   */
+  get flowing() {
+    return this[FLOWING2];
+  }
+  /**
+   * true if the stream is currently in a paused state
+   */
+  get paused() {
+    return this[PAUSED2];
+  }
+  [BUFFERPUSH2](chunk) {
+    this[OBJECTMODE2] ? this[BUFFERLENGTH2] += 1 : this[BUFFERLENGTH2] += chunk.length, this[BUFFER2].push(chunk);
+  }
+  [BUFFERSHIFT2]() {
+    return this[OBJECTMODE2] ? this[BUFFERLENGTH2] -= 1 : this[BUFFERLENGTH2] -= this[BUFFER2][0].length, this[BUFFER2].shift();
+  }
+  [FLUSH2](noDrain = !1) {
+    do
+      ;
+    while (this[FLUSHCHUNK2](this[BUFFERSHIFT2]()) && this[BUFFER2].length);
+    !noDrain && !this[BUFFER2].length && !this[EOF2] && this.emit("drain");
+  }
+  [FLUSHCHUNK2](chunk) {
+    return this.emit("data", chunk), this[FLOWING2];
+  }
+  /**
+   * Pipe all data emitted by this stream into the destination provided.
+   *
+   * Triggers the flow of data.
+   */
+  pipe(dest, opts) {
+    if (this[DESTROYED2])
+      return dest;
+    this[DISCARDED2] = !1;
+    let ended = this[EMITTED_END2];
+    return opts = opts || {}, dest === proc2.stdout || dest === proc2.stderr ? opts.end = !1 : opts.end = opts.end !== !1, opts.proxyErrors = !!opts.proxyErrors, ended ? opts.end && dest.end() : (this[PIPES2].push(opts.proxyErrors ? new PipeProxyErrors2(this, dest, opts) : new Pipe2(this, dest, opts)), this[ASYNC2] ? defer2(() => this[RESUME2]()) : this[RESUME2]()), dest;
+  }
+  /**
+   * Fully unhook a piped destination stream.
+   *
+   * If the destination stream was the only consumer of this stream (ie,
+   * there are no other piped destinations or `'data'` event listeners)
+   * then the flow of data will stop until there is another consumer or
+   * {@link Minipass#resume} is explicitly called.
+   */
+  unpipe(dest) {
+    let p = this[PIPES2].find((p2) => p2.dest === dest);
+    p && (this[PIPES2].length === 1 ? (this[FLOWING2] && this[DATALISTENERS2] === 0 && (this[FLOWING2] = !1), this[PIPES2] = []) : this[PIPES2].splice(this[PIPES2].indexOf(p), 1), p.unpipe());
+  }
+  /**
+   * Alias for {@link Minipass#on}
+   */
+  addListener(ev, handler) {
+    return this.on(ev, handler);
+  }
+  /**
+   * Mostly identical to `EventEmitter.on`, with the following
+   * behavior differences to prevent data loss and unnecessary hangs:
+   *
+   * - Adding a 'data' event handler will trigger the flow of data
+   *
+   * - Adding a 'readable' event handler when there is data waiting to be read
+   *   will cause 'readable' to be emitted immediately.
+   *
+   * - Adding an 'endish' event handler ('end', 'finish', etc.) which has
+   *   already passed will cause the event to be emitted immediately and all
+   *   handlers removed.
+   *
+   * - Adding an 'error' event handler after an error has been emitted will
+   *   cause the event to be re-emitted immediately with the error previously
+   *   raised.
+   */
+  on(ev, handler) {
+    let ret = super.on(ev, handler);
+    if (ev === "data")
+      this[DISCARDED2] = !1, this[DATALISTENERS2]++, !this[PIPES2].length && !this[FLOWING2] && this[RESUME2]();
+    else if (ev === "readable" && this[BUFFERLENGTH2] !== 0)
+      super.emit("readable");
+    else if (isEndish2(ev) && this[EMITTED_END2])
+      super.emit(ev), this.removeAllListeners(ev);
+    else if (ev === "error" && this[EMITTED_ERROR2]) {
+      let h = handler;
+      this[ASYNC2] ? defer2(() => h.call(this, this[EMITTED_ERROR2])) : h.call(this, this[EMITTED_ERROR2]);
+    }
+    return ret;
+  }
+  /**
+   * Alias for {@link Minipass#off}
+   */
+  removeListener(ev, handler) {
+    return this.off(ev, handler);
+  }
+  /**
+   * Mostly identical to `EventEmitter.off`
+   *
+   * If a 'data' event handler is removed, and it was the last consumer
+   * (ie, there are no pipe destinations or other 'data' event listeners),
+   * then the flow of data will stop until there is another consumer or
+   * {@link Minipass#resume} is explicitly called.
+   */
+  off(ev, handler) {
+    let ret = super.off(ev, handler);
+    return ev === "data" && (this[DATALISTENERS2] = this.listeners("data").length, this[DATALISTENERS2] === 0 && !this[DISCARDED2] && !this[PIPES2].length && (this[FLOWING2] = !1)), ret;
+  }
+  /**
+   * Mostly identical to `EventEmitter.removeAllListeners`
+   *
+   * If all 'data' event handlers are removed, and they were the last consumer
+   * (ie, there are no pipe destinations), then the flow of data will stop
+   * until there is another consumer or {@link Minipass#resume} is explicitly
+   * called.
+   */
+  removeAllListeners(ev) {
+    let ret = super.removeAllListeners(ev);
+    return (ev === "data" || ev === void 0) && (this[DATALISTENERS2] = 0, !this[DISCARDED2] && !this[PIPES2].length && (this[FLOWING2] = !1)), ret;
+  }
+  /**
+   * true if the 'end' event has been emitted
+   */
+  get emittedEnd() {
+    return this[EMITTED_END2];
+  }
+  [MAYBE_EMIT_END2]() {
+    !this[EMITTING_END2] && !this[EMITTED_END2] && !this[DESTROYED2] && this[BUFFER2].length === 0 && this[EOF2] && (this[EMITTING_END2] = !0, this.emit("end"), this.emit("prefinish"), this.emit("finish"), this[CLOSED2] && this.emit("close"), this[EMITTING_END2] = !1);
+  }
+  /**
+   * Mostly identical to `EventEmitter.emit`, with the following
+   * behavior differences to prevent data loss and unnecessary hangs:
+   *
+   * If the stream has been destroyed, and the event is something other
+   * than 'close' or 'error', then `false` is returned and no handlers
+   * are called.
+   *
+   * If the event is 'end', and has already been emitted, then the event
+   * is ignored. If the stream is in a paused or non-flowing state, then
+   * the event will be deferred until data flow resumes. If the stream is
+   * async, then handlers will be called on the next tick rather than
+   * immediately.
+   *
+   * If the event is 'close', and 'end' has not yet been emitted, then
+   * the event will be deferred until after 'end' is emitted.
+   *
+   * If the event is 'error', and an AbortSignal was provided for the stream,
+   * and there are no listeners, then the event is ignored, matching the
+   * behavior of node core streams in the presense of an AbortSignal.
+   *
+   * If the event is 'finish' or 'prefinish', then all listeners will be
+   * removed after emitting the event, to prevent double-firing.
+   */
+  emit(ev, ...args) {
+    let data = args[0];
+    if (ev !== "error" && ev !== "close" && ev !== DESTROYED2 && this[DESTROYED2])
+      return !1;
+    if (ev === "data")
+      return !this[OBJECTMODE2] && !data ? !1 : this[ASYNC2] ? (defer2(() => this[EMITDATA2](data)), !0) : this[EMITDATA2](data);
+    if (ev === "end")
+      return this[EMITEND3]();
+    if (ev === "close") {
+      if (this[CLOSED2] = !0, !this[EMITTED_END2] && !this[DESTROYED2])
+        return !1;
+      let ret2 = super.emit("close");
+      return this.removeAllListeners("close"), ret2;
+    } else if (ev === "error") {
+      this[EMITTED_ERROR2] = data, super.emit(ERROR2, data);
+      let ret2 = !this[SIGNAL2] || this.listeners("error").length ? super.emit("error", data) : !1;
+      return this[MAYBE_EMIT_END2](), ret2;
+    } else if (ev === "resume") {
+      let ret2 = super.emit("resume");
+      return this[MAYBE_EMIT_END2](), ret2;
+    } else if (ev === "finish" || ev === "prefinish") {
+      let ret2 = super.emit(ev);
+      return this.removeAllListeners(ev), ret2;
+    }
+    let ret = super.emit(ev, ...args);
+    return this[MAYBE_EMIT_END2](), ret;
+  }
+  [EMITDATA2](data) {
+    for (let p of this[PIPES2])
+      p.dest.write(data) === !1 && this.pause();
+    let ret = this[DISCARDED2] ? !1 : super.emit("data", data);
+    return this[MAYBE_EMIT_END2](), ret;
+  }
+  [EMITEND3]() {
+    return this[EMITTED_END2] ? !1 : (this[EMITTED_END2] = !0, this.readable = !1, this[ASYNC2] ? (defer2(() => this[EMITEND22]()), !0) : this[EMITEND22]());
+  }
+  [EMITEND22]() {
+    if (this[DECODER2]) {
+      let data = this[DECODER2].end();
+      if (data) {
+        for (let p of this[PIPES2])
+          p.dest.write(data);
+        this[DISCARDED2] || super.emit("data", data);
+      }
+    }
+    for (let p of this[PIPES2])
+      p.end();
+    let ret = super.emit("end");
+    return this.removeAllListeners("end"), ret;
+  }
+  /**
+   * Return a Promise that resolves to an array of all emitted data once
+   * the stream ends.
+   */
+  async collect() {
+    let buf = Object.assign([], {
+      dataLength: 0
+    });
+    this[OBJECTMODE2] || (buf.dataLength = 0);
+    let p = this.promise();
+    return this.on("data", (c) => {
+      buf.push(c), this[OBJECTMODE2] || (buf.dataLength += c.length);
+    }), await p, buf;
+  }
+  /**
+   * Return a Promise that resolves to the concatenation of all emitted data
+   * once the stream ends.
+   *
+   * Not allowed on objectMode streams.
+   */
+  async concat() {
+    if (this[OBJECTMODE2])
+      throw new Error("cannot concat in objectMode");
+    let buf = await this.collect();
+    return this[ENCODING2] ? buf.join("") : Buffer.concat(buf, buf.dataLength);
+  }
+  /**
+   * Return a void Promise that resolves once the stream ends.
+   */
+  async promise() {
+    return new Promise((resolve7, reject) => {
+      this.on(DESTROYED2, () => reject(new Error("stream destroyed"))), this.on("error", (er) => reject(er)), this.on("end", () => resolve7());
+    });
+  }
+  /**
+   * Asynchronous `for await of` iteration.
+   *
+   * This will continue emitting all chunks until the stream terminates.
+   */
+  [Symbol.asyncIterator]() {
+    this[DISCARDED2] = !1;
+    let stopped = !1, stop = async () => (this.pause(), stopped = !0, { value: void 0, done: !0 });
+    return {
+      next: () => {
+        if (stopped)
+          return stop();
+        let res = this.read();
+        if (res !== null)
+          return Promise.resolve({ done: !1, value: res });
+        if (this[EOF2])
+          return stop();
+        let resolve7, reject, onerr = (er) => {
+          this.off("data", ondata), this.off("end", onend), this.off(DESTROYED2, ondestroy), stop(), reject(er);
+        }, ondata = (value) => {
+          this.off("error", onerr), this.off("end", onend), this.off(DESTROYED2, ondestroy), this.pause(), resolve7({ value, done: !!this[EOF2] });
+        }, onend = () => {
+          this.off("error", onerr), this.off("data", ondata), this.off(DESTROYED2, ondestroy), stop(), resolve7({ done: !0, value: void 0 });
+        }, ondestroy = () => onerr(new Error("stream destroyed"));
+        return new Promise((res2, rej) => {
+          reject = rej, resolve7 = res2, this.once(DESTROYED2, ondestroy), this.once("error", onerr), this.once("end", onend), this.once("data", ondata);
+        });
+      },
+      throw: stop,
+      return: stop,
+      [Symbol.asyncIterator]() {
+        return this;
+      }
+    };
+  }
+  /**
+   * Synchronous `for of` iteration.
+   *
+   * The iteration will terminate when the internal buffer runs out, even
+   * if the stream has not yet terminated.
+   */
+  [Symbol.iterator]() {
+    this[DISCARDED2] = !1;
+    let stopped = !1, stop = () => (this.pause(), this.off(ERROR2, stop), this.off(DESTROYED2, stop), this.off("end", stop), stopped = !0, { done: !0, value: void 0 }), next = () => {
+      if (stopped)
+        return stop();
+      let value = this.read();
+      return value === null ? stop() : { done: !1, value };
+    };
+    return this.once("end", stop), this.once(ERROR2, stop), this.once(DESTROYED2, stop), {
+      next,
+      throw: stop,
+      return: stop,
+      [Symbol.iterator]() {
+        return this;
+      }
+    };
+  }
+  /**
+   * Destroy a stream, preventing it from being used for any further purpose.
+   *
+   * If the stream has a `close()` method, then it will be called on
+   * destruction.
+   *
+   * After destruction, any attempt to write data, read data, or emit most
+   * events will be ignored.
+   *
+   * If an error argument is provided, then it will be emitted in an
+   * 'error' event.
+   */
+  destroy(er) {
+    if (this[DESTROYED2])
+      return er ? this.emit("error", er) : this.emit(DESTROYED2), this;
+    this[DESTROYED2] = !0, this[DISCARDED2] = !0, this[BUFFER2].length = 0, this[BUFFERLENGTH2] = 0;
+    let wc = this;
+    return typeof wc.close == "function" && !this[CLOSED2] && wc.close(), er ? this.emit("error", er) : this.emit(DESTROYED2), this;
+  }
+  /**
+   * Alias for {@link isStream}
+   *
+   * Former export location, maintained for backwards compatibility.
+   *
+   * @deprecated
+   */
+  static get isStream() {
+    return isStream2;
+  }
+};
+
+// ../../node_modules/rimraf/node_modules/glob/dist/esm/ignore.js
 var defaultPlatform2 = typeof process == "object" && process && typeof process.platform == "string" ? process.platform : "linux", Ignore = class {
   relative;
   relativeChildren;
@@ -30021,7 +30676,12 @@ var defaultPlatform2 = typeof process == "object" && process && typeof process.p
     for (let ign of ignored) {
       let mm = new Minimatch(ign, mmopts);
       for (let i = 0; i < mm.set.length; i++) {
-        let parsed = mm.set[i], globParts = mm.globParts[i], p = new Pattern(parsed, globParts, 0, platform), m = new Minimatch(p.globString(), mmopts), children = globParts[globParts.length - 1] === "**", absolute = p.isAbsolute();
+        let parsed = mm.set[i], globParts = mm.globParts[i];
+        if (!parsed || !globParts)
+          throw new Error("invalid pattern object");
+        for (; parsed[0] === "." && globParts[0] === "."; )
+          parsed.shift(), globParts.shift();
+        let p = new Pattern(parsed, globParts, 0, platform), m = new Minimatch(p.globString(), mmopts), children = globParts[globParts.length - 1] === "**", absolute = p.isAbsolute();
         absolute ? this.absolute.push(m) : this.relative.push(m), children && (absolute ? this.absoluteChildren.push(m) : this.relativeChildren.push(m));
       }
     }
@@ -30042,12 +30702,13 @@ var defaultPlatform2 = typeof process == "object" && process && typeof process.p
       if (m.match(relative))
         return !0;
     for (let m of this.absoluteChildren)
-      m.match(fullpath);
+      if (m.match(fullpath))
+        return !0;
     return !1;
   }
 };
 
-// ../../node_modules/rimraf/node_modules/glob/dist/mjs/processor.js
+// ../../node_modules/rimraf/node_modules/glob/dist/esm/processor.js
 var HasWalkedCache = class _HasWalkedCache {
   store;
   constructor(store = /* @__PURE__ */ new Map()) {
@@ -30127,24 +30788,16 @@ var HasWalkedCache = class _HasWalkedCache {
       if (t.isENOENT())
         continue;
       let p, rest, changed = !1;
-      for (; typeof (p = pattern.pattern()) == "string" && (rest = pattern.rest()); ) {
-        let c = t.resolve(p);
-        if (c.isUnknown() && p !== "..")
-          break;
-        t = c, pattern = rest, changed = !0;
-      }
+      for (; typeof (p = pattern.pattern()) == "string" && (rest = pattern.rest()); )
+        t = t.resolve(p), pattern = rest, changed = !0;
       if (p = pattern.pattern(), rest = pattern.rest(), changed) {
         if (this.hasWalkedCache.hasWalked(t, pattern))
           continue;
         this.hasWalkedCache.storeWalked(t, pattern);
       }
       if (typeof p == "string") {
-        if (rest)
-          this.subwalks.add(t, pattern);
-        else {
-          let ifDir = p === ".." || p === "" || p === ".";
-          this.matches.add(t.resolve(p), absolute, ifDir);
-        }
+        let ifDir = p === ".." || p === "" || p === ".";
+        this.matches.add(t.resolve(p), absolute, ifDir);
         continue;
       } else if (p === GLOBSTAR) {
         (!t.isSymbolicLink() || this.follow || pattern.checkFollowGlobstar()) && this.subwalks.add(t, pattern);
@@ -30200,7 +30853,7 @@ var HasWalkedCache = class _HasWalkedCache {
   }
 };
 
-// ../../node_modules/rimraf/node_modules/glob/dist/mjs/walker.js
+// ../../node_modules/rimraf/node_modules/glob/dist/esm/walker.js
 var makeIgnore = (ignore, opts) => typeof ignore == "string" ? new Ignore([ignore], opts) : Array.isArray(ignore) ? new Ignore(ignore, opts) : ignore, GlobUtil = class {
   path;
   patterns;
@@ -30250,11 +30903,15 @@ var makeIgnore = (ignore, opts) => typeof ignore == "string" ? new Ignore([ignor
         return;
       e = rpc;
     }
-    let needStat = e.isUnknown() || this.opts.stat;
-    return this.matchCheckTest(needStat ? await e.lstat() : e, ifDir);
+    let s = e.isUnknown() || this.opts.stat ? await e.lstat() : e;
+    if (this.opts.follow && this.opts.nodir && s?.isSymbolicLink()) {
+      let target = await s.realpath();
+      target && (target.isUnknown() || this.opts.stat) && await target.lstat();
+    }
+    return this.matchCheckTest(s, ifDir);
   }
   matchCheckTest(e, ifDir) {
-    return e && (this.maxDepth === 1 / 0 || e.depth() <= this.maxDepth) && (!ifDir || e.canReaddir()) && (!this.opts.nodir || !e.isDirectory()) && !this.#ignored(e) ? e : void 0;
+    return e && (this.maxDepth === 1 / 0 || e.depth() <= this.maxDepth) && (!ifDir || e.canReaddir()) && (!this.opts.nodir || !e.isDirectory()) && (!this.opts.nodir || !this.opts.follow || !e.isSymbolicLink() || !e.realpathCached()?.isDirectory()) && !this.#ignored(e) ? e : void 0;
   }
   matchCheckSync(e, ifDir) {
     if (ifDir && this.opts.nodir)
@@ -30265,8 +30922,12 @@ var makeIgnore = (ignore, opts) => typeof ignore == "string" ? new Ignore([ignor
         return;
       e = rpc;
     }
-    let needStat = e.isUnknown() || this.opts.stat;
-    return this.matchCheckTest(needStat ? e.lstatSync() : e, ifDir);
+    let s = e.isUnknown() || this.opts.stat ? e.lstatSync() : e;
+    if (this.opts.follow && this.opts.nodir && s?.isSymbolicLink()) {
+      let target = s.realpathSync();
+      target && (target?.isUnknown() || this.opts.stat) && target.lstatSync();
+    }
+    return this.matchCheckTest(s, ifDir);
   }
   matchFinish(e, absolute) {
     if (this.#ignored(e))
@@ -30392,7 +31053,7 @@ var makeIgnore = (ignore, opts) => typeof ignore == "string" ? new Ignore([ignor
 }, GlobStream = class extends GlobUtil {
   results;
   constructor(patterns, path6, opts) {
-    super(patterns, path6, opts), this.results = new Minipass({
+    super(patterns, path6, opts), this.results = new Minipass2({
       signal: this.signal,
       objectMode: !0
     }), this.results.on("drain", () => this.resume()), this.results.on("resume", () => this.resume());
@@ -30411,7 +31072,7 @@ var makeIgnore = (ignore, opts) => typeof ignore == "string" ? new Ignore([ignor
   }
 };
 
-// ../../node_modules/rimraf/node_modules/glob/dist/mjs/glob.js
+// ../../node_modules/rimraf/node_modules/glob/dist/esm/glob.js
 var defaultPlatform3 = typeof process == "object" && process && typeof process.platform == "string" ? process.platform : "linux", Glob = class {
   absolute;
   cwd;
@@ -30494,7 +31155,12 @@ var defaultPlatform3 = typeof process == "object" && process && typeof process.p
       windowsPathsNoEscape: this.windowsPathsNoEscape,
       debug: !!this.opts.debug
     }, mms = this.pattern.map((p) => new Minimatch(p, mmo)), [matchSet, globParts] = mms.reduce((set, m) => (set[0].push(...m.set), set[1].push(...m.globParts), set), [[], []]);
-    this.patterns = matchSet.map((set, i) => new Pattern(set, globParts[i], 0, this.platform));
+    this.patterns = matchSet.map((set, i) => {
+      let g = globParts[i];
+      if (!g)
+        throw new Error("invalid pattern object");
+      return new Pattern(set, g, 0, this.platform);
+    });
   }
   async walk() {
     return [
@@ -30554,7 +31220,7 @@ var defaultPlatform3 = typeof process == "object" && process && typeof process.p
   }
 };
 
-// ../../node_modules/rimraf/node_modules/glob/dist/mjs/has-magic.js
+// ../../node_modules/rimraf/node_modules/glob/dist/esm/has-magic.js
 var hasMagic = (pattern, options = {}) => {
   Array.isArray(pattern) || (pattern = [pattern]);
   for (let p of pattern)
@@ -30563,7 +31229,7 @@ var hasMagic = (pattern, options = {}) => {
   return !1;
 };
 
-// ../../node_modules/rimraf/node_modules/glob/dist/mjs/index.js
+// ../../node_modules/rimraf/node_modules/glob/dist/esm/index.js
 function globStreamSync(pattern, options = {}) {
   return new Glob(pattern, options).streamSync();
 }