@cloudflare/workers-utils 0.21.1 → 0.22.1

package/dist/index.mjs

@@ -1,16 +1,18 @@
-export { assertNever, constructWranglerConfig, getTodaysCompatDate, isCompatDate, mapWorkerMetadataBindings } from './chunk-BLWXWFJK.mjs';
+export { assertNever, constructWranglerConfig, getTodaysCompatDate, isCompatDate, mapWorkerMetadataBindings } from './chunk-UFU4JGIG.mjs';
 export { MetricsRegistry } from './chunk-O4YGOZSW.mjs';
-import { isDirectory, UserError, isRedirectedRawConfig, dedent, configFileName, formatConfigSnippet, FatalError, removeDirSync, readFileSync, parseTOML, modify, applyEdits, format, dist_default, parseJSONC } from './chunk-GMTGAG26.mjs';
+import { isDirectory, UserError, isRedirectedRawConfig, dedent, configFileName, formatConfigSnippet, FatalError, removeDirSync, ParseError, parseJSON, APIError, readFileSync as readFileSync$1, parseTOML, modify, applyEdits, format, dist_default, parseJSONC } from './chunk-GMTGAG26.mjs';
 export { APIError, CommandLineArgsError, DeprecationError, FatalError, JsonFriendlyFatalError, MissingConfigError, ParseError, UserError, configFileName, configFormat, createFatalError, experimental_readRawConfig, findWranglerConfig, formatConfigSnippet, indexLocation, isDirectory, isRedirectedConfig, parseByteSize, parseHumanDuration, parseJSON, parseJSONC, parseNonHyphenedUuid, parsePackageJSON, parseTOML, readFileSync, readFileSyncToBuffer, removeDir, removeDirSync, resolveWranglerConfigPath, searchLocation } from './chunk-GMTGAG26.mjs';
 export { ENVIRONMENT_TAG_PREFIX, INHERIT_SYMBOL, JSON_CONFIG_FORMATS, PATH_TO_DEPLOY_CONFIG, SERVICE_TAG_PREFIX } from './chunk-OZQVB3L3.mjs';
 import { __commonJS, __name, __require, __export, __toESM, __reExport } from './chunk-DCOBXSFB.mjs';
-import fs, { accessSync, constants, writeFileSync, renameSync, existsSync, unlinkSync, mkdirSync, chmodSync } from 'node:fs';
+import fs2, { accessSync, constants, writeFileSync, renameSync, existsSync, unlinkSync, mkdirSync, chmodSync, readFileSync } from 'node:fs';
 import assert from 'node:assert';
 import path3, { join, dirname } from 'node:path';
 import os, { arch } from 'node:os';
 import { execFileSync, spawn } from 'node:child_process';
 import { createHash } from 'node:crypto';
-import { fetch } from 'undici';
+import { fetch, Headers, FormData, Response } from 'undici';
+import { URLSearchParams } from 'node:url';
+import * as timersPromises from 'node:timers/promises';
 
 // ../../node_modules/.pnpm/xdg-app-paths@8.3.0/node_modules/xdg-app-paths/dist/cjs/lib/XDGAppPaths.js
 var require_XDGAppPaths = __commonJS({
@@ -34,7 +36,7 @@ var require_XDGAppPaths = __commonJS({
     }
     __name(typeOf, "typeOf");
     function Adapt(adapter_) {
-      var meta = adapter_.meta, path4 = adapter_.path, xdg = adapter_.xdg;
+      var meta = adapter_.meta, path5 = adapter_.path, xdg = adapter_.xdg;
       var XDGAppPaths_ = /* @__PURE__ */ function() {
         function XDGAppPaths_2(options_) {
           if (options_ === void 0) {
@@ -57,7 +59,7 @@ var require_XDGAppPaths = __commonJS({
             meta.mainFilename()
           ];
           var nameFallback = "$eval";
-          var name = path4.parse(((_c = namePriorityList.find(function(e2) {
+          var name = path5.parse(((_c = namePriorityList.find(function(e2) {
             return isString2(e2);
           })) !== null && _c !== void 0 ? _c : nameFallback) + suffix).name;
           XDGAppPaths.$name = /* @__PURE__ */ __name(function $name() {
@@ -78,28 +80,28 @@ var require_XDGAppPaths = __commonJS({
           }
           __name(finalPathSegment, "finalPathSegment");
           XDGAppPaths.cache = /* @__PURE__ */ __name(function cache(dirOptions) {
-            return path4.join(xdg.cache(), finalPathSegment(dirOptions));
+            return path5.join(xdg.cache(), finalPathSegment(dirOptions));
           }, "cache");
           XDGAppPaths.config = /* @__PURE__ */ __name(function config(dirOptions) {
-            return path4.join(xdg.config(), finalPathSegment(dirOptions));
+            return path5.join(xdg.config(), finalPathSegment(dirOptions));
           }, "config");
           XDGAppPaths.data = /* @__PURE__ */ __name(function data(dirOptions) {
-            return path4.join(xdg.data(), finalPathSegment(dirOptions));
+            return path5.join(xdg.data(), finalPathSegment(dirOptions));
           }, "data");
           XDGAppPaths.runtime = /* @__PURE__ */ __name(function runtime(dirOptions) {
-            return xdg.runtime() ? path4.join(xdg.runtime(), finalPathSegment(dirOptions)) : void 0;
+            return xdg.runtime() ? path5.join(xdg.runtime(), finalPathSegment(dirOptions)) : void 0;
           }, "runtime");
           XDGAppPaths.state = /* @__PURE__ */ __name(function state(dirOptions) {
-            return path4.join(xdg.state(), finalPathSegment(dirOptions));
+            return path5.join(xdg.state(), finalPathSegment(dirOptions));
           }, "state");
           XDGAppPaths.configDirs = /* @__PURE__ */ __name(function configDirs(dirOptions) {
             return xdg.configDirs().map(function(s) {
-              return path4.join(s, finalPathSegment(dirOptions));
+              return path5.join(s, finalPathSegment(dirOptions));
             });
           }, "configDirs");
           XDGAppPaths.dataDirs = /* @__PURE__ */ __name(function dataDirs(dirOptions) {
             return xdg.dataDirs().map(function(s) {
-              return path4.join(s, finalPathSegment(dirOptions));
+              return path5.join(s, finalPathSegment(dirOptions));
             });
           }, "dataDirs");
           return XDGAppPaths;
@@ -125,7 +127,7 @@ var require_XDG = __commonJS({
     exports.__esModule = true;
     exports.Adapt = void 0;
     function Adapt(adapter_) {
-      var env = adapter_.env, osPaths = adapter_.osPaths, path4 = adapter_.path;
+      var env = adapter_.env, osPaths = adapter_.osPaths, path5 = adapter_.path;
       var isMacOS = /^darwin$/i.test(adapter_.process.platform);
       var isWinOS = /^win/i.test(adapter_.process.platform);
       function baseDir() {
@@ -133,7 +135,7 @@ var require_XDG = __commonJS({
       }
       __name(baseDir, "baseDir");
       function valOrPath(val, pathSegments) {
-        return val || path4.join.apply(path4, pathSegments);
+        return val || path5.join.apply(path5, pathSegments);
       }
       __name(valOrPath, "valOrPath");
       var linux = /* @__PURE__ */ __name(function() {
@@ -212,11 +214,11 @@ var require_XDG = __commonJS({
           XDG.state = extension.state;
           XDG.configDirs = /* @__PURE__ */ __name(function configDirs() {
             var pathList = env.get("XDG_CONFIG_DIRS");
-            return __spreadArray([extension.config()], pathList ? pathList.split(path4.delimiter) : []);
+            return __spreadArray([extension.config()], pathList ? pathList.split(path5.delimiter) : []);
           }, "configDirs");
           XDG.dataDirs = /* @__PURE__ */ __name(function dataDirs() {
             var pathList = env.get("XDG_DATA_DIRS");
-            return __spreadArray([extension.data()], pathList ? pathList.split(path4.delimiter) : []);
+            return __spreadArray([extension.data()], pathList ? pathList.split(path5.delimiter) : []);
           }, "dataDirs");
           return XDG;
         }
@@ -245,7 +247,7 @@ var require_OSPaths = __commonJS({
     }
     __name(isEmpty, "isEmpty");
     function Adapt(adapter_) {
-      var env = adapter_.env, os2 = adapter_.os, path4 = adapter_.path;
+      var env = adapter_.env, os2 = adapter_.os, path5 = adapter_.path;
       var isWinOS = /^win/i.test(adapter_.process.platform);
       function normalizePath(path_) {
         return path_ ? adapter_.path.normalize(adapter_.path.join(path_, ".")) : void 0;
@@ -260,7 +262,7 @@ var require_OSPaths = __commonJS({
             typeof os2.homedir === "function" ? os2.homedir() : void 0,
             env.get("USERPROFILE"),
             env.get("HOME"),
-            env.get("HOMEDRIVE") || env.get("HOMEPATH") ? path4.join(env.get("HOMEDRIVE") || "", env.get("HOMEPATH") || "") : void 0
+            env.get("HOMEDRIVE") || env.get("HOMEPATH") ? path5.join(env.get("HOMEDRIVE") || "", env.get("HOMEPATH") || "") : void 0
           ];
           return normalizePath(priorityList.find(function(v) {
             return !isEmpty(v);
@@ -271,7 +273,7 @@ var require_OSPaths = __commonJS({
       __name(home, "home");
       function temp() {
         function joinPathToBase(base, segments) {
-          return base ? path4.join.apply(path4, __spreadArray([base], segments)) : void 0;
+          return base ? path5.join.apply(path5, __spreadArray([base], segments)) : void 0;
         }
         __name(joinPathToBase, "joinPathToBase");
         function posix() {
@@ -376,7 +378,7 @@ var require_node = __commonJS({
     exports.__esModule = true;
     exports.adapter = void 0;
     var os2 = __importStar(__require("os"));
-    var path4 = __importStar(__require("path"));
+    var path5 = __importStar(__require("path"));
     exports.adapter = {
       atImportPermissions: { env: true },
       env: {
@@ -385,7 +387,7 @@ var require_node = __commonJS({
         }, "get")
       },
       os: os2,
-      path: path4,
+      path: path5,
       process
     };
   }
@@ -431,7 +433,7 @@ var require_node2 = __commonJS({
     };
     exports.__esModule = true;
     exports.adapter = void 0;
-    var path4 = __importStar(__require("path"));
+    var path5 = __importStar(__require("path"));
     var os_paths_1 = __importDefault(require_mod_cjs());
     exports.adapter = {
       atImportPermissions: { env: true },
@@ -441,7 +443,7 @@ var require_node2 = __commonJS({
         }, "get")
       },
       osPaths: os_paths_1["default"],
-      path: path4,
+      path: path5,
       process
     };
   }
@@ -487,7 +489,7 @@ var require_node3 = __commonJS({
     };
     exports.__esModule = true;
     exports.adapter = void 0;
-    var path4 = __importStar(__require("path"));
+    var path5 = __importStar(__require("path"));
     var xdg_portable_1 = __importDefault(require_mod_cjs2());
     exports.adapter = {
       atImportPermissions: { env: true, read: true },
@@ -502,7 +504,7 @@ var require_node3 = __commonJS({
           return process.pkg ? process.execPath : void 0;
         }, "pkgMainFilename")
       },
-      path: path4,
+      path: path5,
       process,
       xdg: xdg_portable_1["default"]
     };
@@ -518,16 +520,212 @@ var require_mod_cjs3 = __commonJS({
   }
 });
 
+// ../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/signals.js
+var require_signals = __commonJS({
+  "../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/signals.js"(exports, module) {
+    module.exports = [
+      "SIGABRT",
+      "SIGALRM",
+      "SIGHUP",
+      "SIGINT",
+      "SIGTERM"
+    ];
+    if (process.platform !== "win32") {
+      module.exports.push(
+        "SIGVTALRM",
+        "SIGXCPU",
+        "SIGXFSZ",
+        "SIGUSR2",
+        "SIGTRAP",
+        "SIGSYS",
+        "SIGQUIT",
+        "SIGIOT"
+        // should detect profiler and enable/disable accordingly.
+        // see #21
+        // 'SIGPROF'
+      );
+    }
+    if (process.platform === "linux") {
+      module.exports.push(
+        "SIGIO",
+        "SIGPOLL",
+        "SIGPWR",
+        "SIGSTKFLT",
+        "SIGUNUSED"
+      );
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/index.js
+var require_signal_exit = __commonJS({
+  "../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/index.js"(exports, module) {
+    var process2 = global.process;
+    var processOk = /* @__PURE__ */ __name(function(process3) {
+      return process3 && typeof process3 === "object" && typeof process3.removeListener === "function" && typeof process3.emit === "function" && typeof process3.reallyExit === "function" && typeof process3.listeners === "function" && typeof process3.kill === "function" && typeof process3.pid === "number" && typeof process3.on === "function";
+    }, "processOk");
+    if (!processOk(process2)) {
+      module.exports = function() {
+        return function() {
+        };
+      };
+    } else {
+      assert3 = __require("assert");
+      signals = require_signals();
+      isWin = /^win/i.test(process2.platform);
+      EE = __require("events");
+      if (typeof EE !== "function") {
+        EE = EE.EventEmitter;
+      }
+      if (process2.__signal_exit_emitter__) {
+        emitter = process2.__signal_exit_emitter__;
+      } else {
+        emitter = process2.__signal_exit_emitter__ = new EE();
+        emitter.count = 0;
+        emitter.emitted = {};
+      }
+      if (!emitter.infinite) {
+        emitter.setMaxListeners(Infinity);
+        emitter.infinite = true;
+      }
+      module.exports = function(cb, opts) {
+        if (!processOk(global.process)) {
+          return function() {
+          };
+        }
+        assert3.equal(typeof cb, "function", "a callback must be provided for exit handler");
+        if (loaded === false) {
+          load();
+        }
+        var ev = "exit";
+        if (opts && opts.alwaysLast) {
+          ev = "afterexit";
+        }
+        var remove = /* @__PURE__ */ __name(function() {
+          emitter.removeListener(ev, cb);
+          if (emitter.listeners("exit").length === 0 && emitter.listeners("afterexit").length === 0) {
+            unload();
+          }
+        }, "remove");
+        emitter.on(ev, cb);
+        return remove;
+      };
+      unload = /* @__PURE__ */ __name(function unload2() {
+        if (!loaded || !processOk(global.process)) {
+          return;
+        }
+        loaded = false;
+        signals.forEach(function(sig) {
+          try {
+            process2.removeListener(sig, sigListeners[sig]);
+          } catch (er) {
+          }
+        });
+        process2.emit = originalProcessEmit;
+        process2.reallyExit = originalProcessReallyExit;
+        emitter.count -= 1;
+      }, "unload");
+      module.exports.unload = unload;
+      emit = /* @__PURE__ */ __name(function emit2(event, code, signal) {
+        if (emitter.emitted[event]) {
+          return;
+        }
+        emitter.emitted[event] = true;
+        emitter.emit(event, code, signal);
+      }, "emit");
+      sigListeners = {};
+      signals.forEach(function(sig) {
+        sigListeners[sig] = /* @__PURE__ */ __name(function listener() {
+          if (!processOk(global.process)) {
+            return;
+          }
+          var listeners = process2.listeners(sig);
+          if (listeners.length === emitter.count) {
+            unload();
+            emit("exit", null, sig);
+            emit("afterexit", null, sig);
+            if (isWin && sig === "SIGHUP") {
+              sig = "SIGINT";
+            }
+            process2.kill(process2.pid, sig);
+          }
+        }, "listener");
+      });
+      module.exports.signals = function() {
+        return signals;
+      };
+      loaded = false;
+      load = /* @__PURE__ */ __name(function load2() {
+        if (loaded || !processOk(global.process)) {
+          return;
+        }
+        loaded = true;
+        emitter.count += 1;
+        signals = signals.filter(function(sig) {
+          try {
+            process2.on(sig, sigListeners[sig]);
+            return true;
+          } catch (er) {
+            return false;
+          }
+        });
+        process2.emit = processEmit;
+        process2.reallyExit = processReallyExit;
+      }, "load");
+      module.exports.load = load;
+      originalProcessReallyExit = process2.reallyExit;
+      processReallyExit = /* @__PURE__ */ __name(function processReallyExit2(code) {
+        if (!processOk(global.process)) {
+          return;
+        }
+        process2.exitCode = code || /* istanbul ignore next */
+        0;
+        emit("exit", process2.exitCode, null);
+        emit("afterexit", process2.exitCode, null);
+        originalProcessReallyExit.call(process2, process2.exitCode);
+      }, "processReallyExit");
+      originalProcessEmit = process2.emit;
+      processEmit = /* @__PURE__ */ __name(function processEmit2(ev, arg) {
+        if (ev === "exit" && processOk(global.process)) {
+          if (arg !== void 0) {
+            process2.exitCode = arg;
+          }
+          var ret = originalProcessEmit.apply(this, arguments);
+          emit("exit", process2.exitCode, null);
+          emit("afterexit", process2.exitCode, null);
+          return ret;
+        } else {
+          return originalProcessEmit.apply(this, arguments);
+        }
+      }, "processEmit");
+    }
+    var assert3;
+    var signals;
+    var isWin;
+    var EE;
+    var emitter;
+    var unload;
+    var emit;
+    var sigListeners;
+    var loaded;
+    var load;
+    var originalProcessReallyExit;
+    var processReallyExit;
+    var originalProcessEmit;
+    var processEmit;
+  }
+});
+
 // ../../node_modules/.pnpm/command-exists@1.2.9/node_modules/command-exists/lib/command-exists.js
 var require_command_exists = __commonJS({
   "../../node_modules/.pnpm/command-exists@1.2.9/node_modules/command-exists/lib/command-exists.js"(exports, module) {
     var exec = __require("child_process").exec;
     var execSync = __require("child_process").execSync;
-    var fs2 = __require("fs");
-    var path4 = __require("path");
-    var access = fs2.access;
-    var accessSync2 = fs2.accessSync;
-    var constants2 = fs2.constants || fs2;
+    var fs3 = __require("fs");
+    var path5 = __require("path");
+    var access = fs3.access;
+    var accessSync2 = fs3.accessSync;
+    var constants2 = fs3.constants || fs3;
     var isUsingWindows = process.platform == "win32";
     var fileNotExists = /* @__PURE__ */ __name(function(commandName, callback) {
       access(
@@ -628,8 +826,8 @@ var require_command_exists = __commonJS({
       cleanInput = /* @__PURE__ */ __name(function(s) {
         var isPathName = /[\\]/.test(s);
         if (isPathName) {
-          var dirname2 = '"' + path4.dirname(s) + '"';
-          var basename = '"' + path4.basename(s) + '"';
+          var dirname2 = '"' + path5.dirname(s) + '"';
+          var basename = '"' + path5.basename(s) + '"';
           return dirname2 + ":" + basename;
         }
         return '"' + s + '"';
@@ -672,6 +870,997 @@ var require_command_exists2 = __commonJS({
   }
 });
 
+// ../../node_modules/.pnpm/ini@1.3.8/node_modules/ini/ini.js
+var require_ini = __commonJS({
+  "../../node_modules/.pnpm/ini@1.3.8/node_modules/ini/ini.js"(exports) {
+    exports.parse = exports.decode = decode;
+    exports.stringify = exports.encode = encode;
+    exports.safe = safe;
+    exports.unsafe = unsafe;
+    var eol = typeof process !== "undefined" && process.platform === "win32" ? "\r\n" : "\n";
+    function encode(obj, opt) {
+      var children = [];
+      var out = "";
+      if (typeof opt === "string") {
+        opt = {
+          section: opt,
+          whitespace: false
+        };
+      } else {
+        opt = opt || {};
+        opt.whitespace = opt.whitespace === true;
+      }
+      var separator = opt.whitespace ? " = " : "=";
+      Object.keys(obj).forEach(function(k, _2, __) {
+        var val = obj[k];
+        if (val && Array.isArray(val)) {
+          val.forEach(function(item) {
+            out += safe(k + "[]") + separator + safe(item) + "\n";
+          });
+        } else if (val && typeof val === "object")
+          children.push(k);
+        else
+          out += safe(k) + separator + safe(val) + eol;
+      });
+      if (opt.section && out.length)
+        out = "[" + safe(opt.section) + "]" + eol + out;
+      children.forEach(function(k, _2, __) {
+        var nk = dotSplit(k).join("\\.");
+        var section = (opt.section ? opt.section + "." : "") + nk;
+        var child = encode(obj[k], {
+          section,
+          whitespace: opt.whitespace
+        });
+        if (out.length && child.length)
+          out += eol;
+        out += child;
+      });
+      return out;
+    }
+    __name(encode, "encode");
+    function dotSplit(str) {
+      return str.replace(/\1/g, "LITERAL\\1LITERAL").replace(/\\\./g, "
").split(/\./).map(function(part) {
+        return part.replace(/\1/g, "\\.").replace(/\2LITERAL\\1LITERAL\2/g, "
");
+      });
+    }
+    __name(dotSplit, "dotSplit");
+    function decode(str) {
+      var out = {};
+      var p = out;
+      var section = null;
+      var re = /^\[([^\]]*)\]$|^([^=]+)(=(.*))?$/i;
+      var lines = str.split(/[\r\n]+/g);
+      lines.forEach(function(line, _2, __) {
+        if (!line || line.match(/^\s*[;#]/))
+          return;
+        var match = line.match(re);
+        if (!match)
+          return;
+        if (match[1] !== void 0) {
+          section = unsafe(match[1]);
+          if (section === "__proto__") {
+            p = {};
+            return;
+          }
+          p = out[section] = out[section] || {};
+          return;
+        }
+        var key = unsafe(match[2]);
+        if (key === "__proto__")
+          return;
+        var value = match[3] ? unsafe(match[4]) : true;
+        switch (value) {
+          case "true":
+          case "false":
+          case "null":
+            value = JSON.parse(value);
+        }
+        if (key.length > 2 && key.slice(-2) === "[]") {
+          key = key.substring(0, key.length - 2);
+          if (key === "__proto__")
+            return;
+          if (!p[key])
+            p[key] = [];
+          else if (!Array.isArray(p[key]))
+            p[key] = [p[key]];
+        }
+        if (Array.isArray(p[key]))
+          p[key].push(value);
+        else
+          p[key] = value;
+      });
+      Object.keys(out).filter(function(k, _2, __) {
+        if (!out[k] || typeof out[k] !== "object" || Array.isArray(out[k]))
+          return false;
+        var parts = dotSplit(k);
+        var p2 = out;
+        var l = parts.pop();
+        var nl = l.replace(/\\\./g, ".");
+        parts.forEach(function(part, _3, __2) {
+          if (part === "__proto__")
+            return;
+          if (!p2[part] || typeof p2[part] !== "object")
+            p2[part] = {};
+          p2 = p2[part];
+        });
+        if (p2 === out && nl === l)
+          return false;
+        p2[nl] = out[k];
+        return true;
+      }).forEach(function(del, _2, __) {
+        delete out[del];
+      });
+      return out;
+    }
+    __name(decode, "decode");
+    function isQuoted(val) {
+      return val.charAt(0) === '"' && val.slice(-1) === '"' || val.charAt(0) === "'" && val.slice(-1) === "'";
+    }
+    __name(isQuoted, "isQuoted");
+    function safe(val) {
+      return typeof val !== "string" || val.match(/[=\r\n]/) || val.match(/^\[/) || val.length > 1 && isQuoted(val) || val !== val.trim() ? JSON.stringify(val) : val.replace(/;/g, "\\;").replace(/#/g, "\\#");
+    }
+    __name(safe, "safe");
+    function unsafe(val, doUnesc) {
+      val = (val || "").trim();
+      if (isQuoted(val)) {
+        if (val.charAt(0) === "'")
+          val = val.substr(1, val.length - 2);
+        try {
+          val = JSON.parse(val);
+        } catch (_2) {
+        }
+      } else {
+        var esc = false;
+        var unesc = "";
+        for (var i = 0, l = val.length; i < l; i++) {
+          var c = val.charAt(i);
+          if (esc) {
+            if ("\\;#".indexOf(c) !== -1)
+              unesc += c;
+            else
+              unesc += "\\" + c;
+            esc = false;
+          } else if (";#".indexOf(c) !== -1)
+            break;
+          else if (c === "\\")
+            esc = true;
+          else
+            unesc += c;
+        }
+        if (esc)
+          unesc += "\\";
+        return unesc.trim();
+      }
+      return val;
+    }
+    __name(unsafe, "unsafe");
+  }
+});
+
+// ../../node_modules/.pnpm/strip-json-comments@2.0.1/node_modules/strip-json-comments/index.js
+var require_strip_json_comments = __commonJS({
+  "../../node_modules/.pnpm/strip-json-comments@2.0.1/node_modules/strip-json-comments/index.js"(exports, module) {
+    var singleComment = 1;
+    var multiComment = 2;
+    function stripWithoutWhitespace() {
+      return "";
+    }
+    __name(stripWithoutWhitespace, "stripWithoutWhitespace");
+    function stripWithWhitespace(str, start, end) {
+      return str.slice(start, end).replace(/\S/g, " ");
+    }
+    __name(stripWithWhitespace, "stripWithWhitespace");
+    module.exports = function(str, opts) {
+      opts = opts || {};
+      var currentChar;
+      var nextChar;
+      var insideString = false;
+      var insideComment = false;
+      var offset = 0;
+      var ret = "";
+      var strip = opts.whitespace === false ? stripWithoutWhitespace : stripWithWhitespace;
+      for (var i = 0; i < str.length; i++) {
+        currentChar = str[i];
+        nextChar = str[i + 1];
+        if (!insideComment && currentChar === '"') {
+          var escaped = str[i - 1] === "\\" && str[i - 2] !== "\\";
+          if (!escaped) {
+            insideString = !insideString;
+          }
+        }
+        if (insideString) {
+          continue;
+        }
+        if (!insideComment && currentChar + nextChar === "//") {
+          ret += str.slice(offset, i);
+          offset = i;
+          insideComment = singleComment;
+          i++;
+        } else if (insideComment === singleComment && currentChar + nextChar === "\r\n") {
+          i++;
+          insideComment = false;
+          ret += strip(str, offset, i);
+          offset = i;
+          continue;
+        } else if (insideComment === singleComment && currentChar === "\n") {
+          insideComment = false;
+          ret += strip(str, offset, i);
+          offset = i;
+        } else if (!insideComment && currentChar + nextChar === "/*") {
+          ret += str.slice(offset, i);
+          offset = i;
+          insideComment = multiComment;
+          i++;
+          continue;
+        } else if (insideComment === multiComment && currentChar + nextChar === "*/") {
+          i++;
+          insideComment = false;
+          ret += strip(str, offset, i + 1);
+          offset = i + 1;
+          continue;
+        }
+      }
+      return ret + (insideComment ? strip(str.substr(offset)) : str.substr(offset));
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/rc@1.2.8/node_modules/rc/lib/utils.js
+var require_utils = __commonJS({
+  "../../node_modules/.pnpm/rc@1.2.8/node_modules/rc/lib/utils.js"(exports) {
+    var fs3 = __require("fs");
+    var ini = require_ini();
+    var path5 = __require("path");
+    var stripJsonComments = require_strip_json_comments();
+    var parse = exports.parse = function(content) {
+      if (/^\s*{/.test(content))
+        return JSON.parse(stripJsonComments(content));
+      return ini.parse(content);
+    };
+    var file = exports.file = function() {
+      var args = [].slice.call(arguments).filter(function(arg) {
+        return arg != null;
+      });
+      for (var i in args)
+        if ("string" !== typeof args[i])
+          return;
+      var file2 = path5.join.apply(null, args);
+      try {
+        return fs3.readFileSync(file2, "utf-8");
+      } catch (err) {
+        return;
+      }
+    };
+    exports.json = function() {
+      var content = file.apply(null, arguments);
+      return content ? parse(content) : null;
+    };
+    exports.env = function(prefix, env2) {
+      env2 = env2 || process.env;
+      var obj = {};
+      var l = prefix.length;
+      for (var k in env2) {
+        if (k.toLowerCase().indexOf(prefix.toLowerCase()) === 0) {
+          var keypath = k.substring(l).split("__");
+          var _emptyStringIndex;
+          while ((_emptyStringIndex = keypath.indexOf("")) > -1) {
+            keypath.splice(_emptyStringIndex, 1);
+          }
+          var cursor = obj;
+          keypath.forEach(/* @__PURE__ */ __name(function _buildSubObj(_subkey, i) {
+            if (!_subkey || typeof cursor !== "object")
+              return;
+            if (i === keypath.length - 1)
+              cursor[_subkey] = env2[k];
+            if (cursor[_subkey] === void 0)
+              cursor[_subkey] = {};
+            cursor = cursor[_subkey];
+          }, "_buildSubObj"));
+        }
+      }
+      return obj;
+    };
+    exports.find = function() {
+      var rel = path5.join.apply(null, [].slice.call(arguments));
+      function find2(start, rel2) {
+        var file2 = path5.join(start, rel2);
+        try {
+          fs3.statSync(file2);
+          return file2;
+        } catch (err) {
+          if (path5.dirname(start) !== start)
+            return find2(path5.dirname(start), rel2);
+        }
+      }
+      __name(find2, "find");
+      return find2(process.cwd(), rel);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/deep-extend@0.6.0/node_modules/deep-extend/lib/deep-extend.js
+var require_deep_extend = __commonJS({
+  "../../node_modules/.pnpm/deep-extend@0.6.0/node_modules/deep-extend/lib/deep-extend.js"(exports, module) {
+    function isSpecificValue(val) {
+      return val instanceof Buffer || val instanceof Date || val instanceof RegExp ? true : false;
+    }
+    __name(isSpecificValue, "isSpecificValue");
+    function cloneSpecificValue(val) {
+      if (val instanceof Buffer) {
+        var x = Buffer.alloc ? Buffer.alloc(val.length) : new Buffer(val.length);
+        val.copy(x);
+        return x;
+      } else if (val instanceof Date) {
+        return new Date(val.getTime());
+      } else if (val instanceof RegExp) {
+        return new RegExp(val);
+      } else {
+        throw new Error("Unexpected situation");
+      }
+    }
+    __name(cloneSpecificValue, "cloneSpecificValue");
+    function deepCloneArray(arr) {
+      var clone = [];
+      arr.forEach(function(item, index) {
+        if (typeof item === "object" && item !== null) {
+          if (Array.isArray(item)) {
+            clone[index] = deepCloneArray(item);
+          } else if (isSpecificValue(item)) {
+            clone[index] = cloneSpecificValue(item);
+          } else {
+            clone[index] = deepExtend({}, item);
+          }
+        } else {
+          clone[index] = item;
+        }
+      });
+      return clone;
+    }
+    __name(deepCloneArray, "deepCloneArray");
+    function safeGetProperty(object, property) {
+      return property === "__proto__" ? void 0 : object[property];
+    }
+    __name(safeGetProperty, "safeGetProperty");
+    var deepExtend = module.exports = function() {
+      if (arguments.length < 1 || typeof arguments[0] !== "object") {
+        return false;
+      }
+      if (arguments.length < 2) {
+        return arguments[0];
+      }
+      var target = arguments[0];
+      var args = Array.prototype.slice.call(arguments, 1);
+      var val, src;
+      args.forEach(function(obj) {
+        if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
+          return;
+        }
+        Object.keys(obj).forEach(function(key) {
+          src = safeGetProperty(target, key);
+          val = safeGetProperty(obj, key);
+          if (val === target) {
+            return;
+          } else if (typeof val !== "object" || val === null) {
+            target[key] = val;
+            return;
+          } else if (Array.isArray(val)) {
+            target[key] = deepCloneArray(val);
+            return;
+          } else if (isSpecificValue(val)) {
+            target[key] = cloneSpecificValue(val);
+            return;
+          } else if (typeof src !== "object" || src === null || Array.isArray(src)) {
+            target[key] = deepExtend({}, val);
+            return;
+          } else {
+            target[key] = deepExtend(src, val);
+            return;
+          }
+        });
+      });
+      return target;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/minimist@1.2.6/node_modules/minimist/index.js
+var require_minimist = __commonJS({
+  "../../node_modules/.pnpm/minimist@1.2.6/node_modules/minimist/index.js"(exports, module) {
+    module.exports = function(args, opts) {
+      if (!opts) opts = {};
+      var flags = { bools: {}, strings: {}, unknownFn: null };
+      if (typeof opts["unknown"] === "function") {
+        flags.unknownFn = opts["unknown"];
+      }
+      if (typeof opts["boolean"] === "boolean" && opts["boolean"]) {
+        flags.allBools = true;
+      } else {
+        [].concat(opts["boolean"]).filter(Boolean).forEach(function(key2) {
+          flags.bools[key2] = true;
+        });
+      }
+      var aliases = {};
+      Object.keys(opts.alias || {}).forEach(function(key2) {
+        aliases[key2] = [].concat(opts.alias[key2]);
+        aliases[key2].forEach(function(x) {
+          aliases[x] = [key2].concat(aliases[key2].filter(function(y) {
+            return x !== y;
+          }));
+        });
+      });
+      [].concat(opts.string).filter(Boolean).forEach(function(key2) {
+        flags.strings[key2] = true;
+        if (aliases[key2]) {
+          flags.strings[aliases[key2]] = true;
+        }
+      });
+      var defaults = opts["default"] || {};
+      var argv = { _: [] };
+      Object.keys(flags.bools).forEach(function(key2) {
+        setArg(key2, defaults[key2] === void 0 ? false : defaults[key2]);
+      });
+      var notFlags = [];
+      if (args.indexOf("--") !== -1) {
+        notFlags = args.slice(args.indexOf("--") + 1);
+        args = args.slice(0, args.indexOf("--"));
+      }
+      function argDefined(key2, arg2) {
+        return flags.allBools && /^--[^=]+$/.test(arg2) || flags.strings[key2] || flags.bools[key2] || aliases[key2];
+      }
+      __name(argDefined, "argDefined");
+      function setArg(key2, val, arg2) {
+        if (arg2 && flags.unknownFn && !argDefined(key2, arg2)) {
+          if (flags.unknownFn(arg2) === false) return;
+        }
+        var value2 = !flags.strings[key2] && isNumber(val) ? Number(val) : val;
+        setKey(argv, key2.split("."), value2);
+        (aliases[key2] || []).forEach(function(x) {
+          setKey(argv, x.split("."), value2);
+        });
+      }
+      __name(setArg, "setArg");
+      function setKey(obj, keys, value2) {
+        var o = obj;
+        for (var i2 = 0; i2 < keys.length - 1; i2++) {
+          var key2 = keys[i2];
+          if (isConstructorOrProto(o, key2)) return;
+          if (o[key2] === void 0) o[key2] = {};
+          if (o[key2] === Object.prototype || o[key2] === Number.prototype || o[key2] === String.prototype) o[key2] = {};
+          if (o[key2] === Array.prototype) o[key2] = [];
+          o = o[key2];
+        }
+        var key2 = keys[keys.length - 1];
+        if (isConstructorOrProto(o, key2)) return;
+        if (o === Object.prototype || o === Number.prototype || o === String.prototype) o = {};
+        if (o === Array.prototype) o = [];
+        if (o[key2] === void 0 || flags.bools[key2] || typeof o[key2] === "boolean") {
+          o[key2] = value2;
+        } else if (Array.isArray(o[key2])) {
+          o[key2].push(value2);
+        } else {
+          o[key2] = [o[key2], value2];
+        }
+      }
+      __name(setKey, "setKey");
+      function aliasIsBoolean(key2) {
+        return aliases[key2].some(function(x) {
+          return flags.bools[x];
+        });
+      }
+      __name(aliasIsBoolean, "aliasIsBoolean");
+      for (var i = 0; i < args.length; i++) {
+        var arg = args[i];
+        if (/^--.+=/.test(arg)) {
+          var m = arg.match(/^--([^=]+)=([\s\S]*)$/);
+          var key = m[1];
+          var value = m[2];
+          if (flags.bools[key]) {
+            value = value !== "false";
+          }
+          setArg(key, value, arg);
+        } else if (/^--no-.+/.test(arg)) {
+          var key = arg.match(/^--no-(.+)/)[1];
+          setArg(key, false, arg);
+        } else if (/^--.+/.test(arg)) {
+          var key = arg.match(/^--(.+)/)[1];
+          var next = args[i + 1];
+          if (next !== void 0 && !/^-/.test(next) && !flags.bools[key] && !flags.allBools && (aliases[key] ? !aliasIsBoolean(key) : true)) {
+            setArg(key, next, arg);
+            i++;
+          } else if (/^(true|false)$/.test(next)) {
+            setArg(key, next === "true", arg);
+            i++;
+          } else {
+            setArg(key, flags.strings[key] ? "" : true, arg);
+          }
+        } else if (/^-[^-]+/.test(arg)) {
+          var letters = arg.slice(1, -1).split("");
+          var broken = false;
+          for (var j = 0; j < letters.length; j++) {
+            var next = arg.slice(j + 2);
+            if (next === "-") {
+              setArg(letters[j], next, arg);
+              continue;
+            }
+            if (/[A-Za-z]/.test(letters[j]) && /=/.test(next)) {
+              setArg(letters[j], next.split("=")[1], arg);
+              broken = true;
+              break;
+            }
+            if (/[A-Za-z]/.test(letters[j]) && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
+              setArg(letters[j], next, arg);
+              broken = true;
+              break;
+            }
+            if (letters[j + 1] && letters[j + 1].match(/\W/)) {
+              setArg(letters[j], arg.slice(j + 2), arg);
+              broken = true;
+              break;
+            } else {
+              setArg(letters[j], flags.strings[letters[j]] ? "" : true, arg);
+            }
+          }
+          var key = arg.slice(-1)[0];
+          if (!broken && key !== "-") {
+            if (args[i + 1] && !/^(-|--)[^-]/.test(args[i + 1]) && !flags.bools[key] && (aliases[key] ? !aliasIsBoolean(key) : true)) {
+              setArg(key, args[i + 1], arg);
+              i++;
+            } else if (args[i + 1] && /^(true|false)$/.test(args[i + 1])) {
+              setArg(key, args[i + 1] === "true", arg);
+              i++;
+            } else {
+              setArg(key, flags.strings[key] ? "" : true, arg);
+            }
+          }
+        } else {
+          if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
+            argv._.push(
+              flags.strings["_"] || !isNumber(arg) ? arg : Number(arg)
+            );
+          }
+          if (opts.stopEarly) {
+            argv._.push.apply(argv._, args.slice(i + 1));
+            break;
+          }
+        }
+      }
+      Object.keys(defaults).forEach(function(key2) {
+        if (!hasKey(argv, key2.split("."))) {
+          setKey(argv, key2.split("."), defaults[key2]);
+          (aliases[key2] || []).forEach(function(x) {
+            setKey(argv, x.split("."), defaults[key2]);
+          });
+        }
+      });
+      if (opts["--"]) {
+        argv["--"] = new Array();
+        notFlags.forEach(function(key2) {
+          argv["--"].push(key2);
+        });
+      } else {
+        notFlags.forEach(function(key2) {
+          argv._.push(key2);
+        });
+      }
+      return argv;
+    };
+    function hasKey(obj, keys) {
+      var o = obj;
+      keys.slice(0, -1).forEach(function(key2) {
+        o = o[key2] || {};
+      });
+      var key = keys[keys.length - 1];
+      return key in o;
+    }
+    __name(hasKey, "hasKey");
+    function isNumber(x) {
+      if (typeof x === "number") return true;
+      if (/^0x[0-9a-f]+$/i.test(x)) return true;
+      return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
+    }
+    __name(isNumber, "isNumber");
+    function isConstructorOrProto(obj, key) {
+      return key === "constructor" && typeof obj[key] === "function" || key === "__proto__";
+    }
+    __name(isConstructorOrProto, "isConstructorOrProto");
+  }
+});
+
+// ../../node_modules/.pnpm/rc@1.2.8/node_modules/rc/index.js
+var require_rc = __commonJS({
+  "../../node_modules/.pnpm/rc@1.2.8/node_modules/rc/index.js"(exports, module) {
+    var cc = require_utils();
+    var join2 = __require("path").join;
+    var deepExtend = require_deep_extend();
+    var etc = "/etc";
+    var win = process.platform === "win32";
+    var home = win ? process.env.USERPROFILE : process.env.HOME;
+    module.exports = function(name, defaults, argv, parse) {
+      if ("string" !== typeof name)
+        throw new Error("rc(name): name *must* be string");
+      if (!argv)
+        argv = require_minimist()(process.argv.slice(2));
+      defaults = ("string" === typeof defaults ? cc.json(defaults) : defaults) || {};
+      parse = parse || cc.parse;
+      var env = cc.env(name + "_");
+      var configs = [defaults];
+      var configFiles = [];
+      function addConfigFile(file) {
+        if (configFiles.indexOf(file) >= 0) return;
+        var fileConfig = cc.file(file);
+        if (fileConfig) {
+          configs.push(parse(fileConfig));
+          configFiles.push(file);
+        }
+      }
+      __name(addConfigFile, "addConfigFile");
+      if (!win)
+        [
+          join2(etc, name, "config"),
+          join2(etc, name + "rc")
+        ].forEach(addConfigFile);
+      if (home)
+        [
+          join2(home, ".config", name, "config"),
+          join2(home, ".config", name),
+          join2(home, "." + name, "config"),
+          join2(home, "." + name + "rc")
+        ].forEach(addConfigFile);
+      addConfigFile(cc.find("." + name + "rc"));
+      if (env.config) addConfigFile(env.config);
+      if (argv.config) addConfigFile(argv.config);
+      return deepExtend.apply(null, configs.concat([
+        env,
+        argv,
+        configFiles.length ? { configs: configFiles, config: configFiles[configFiles.length - 1] } : void 0
+      ]));
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/registry-url@3.1.0/node_modules/registry-url/index.js
+var require_registry_url = __commonJS({
+  "../../node_modules/.pnpm/registry-url@3.1.0/node_modules/registry-url/index.js"(exports, module) {
+    module.exports = function(scope) {
+      var rc = require_rc()("npm", { registry: "https://registry.npmjs.org/" });
+      var url = rc[scope + ":registry"] || rc.registry;
+      return url.slice(-1) === "/" ? url : url + "/";
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/safe-buffer@5.2.1/node_modules/safe-buffer/index.js
+var require_safe_buffer = __commonJS({
+  "../../node_modules/.pnpm/safe-buffer@5.2.1/node_modules/safe-buffer/index.js"(exports, module) {
+    var buffer = __require("buffer");
+    var Buffer2 = buffer.Buffer;
+    function copyProps(src, dst) {
+      for (var key in src) {
+        dst[key] = src[key];
+      }
+    }
+    __name(copyProps, "copyProps");
+    if (Buffer2.from && Buffer2.alloc && Buffer2.allocUnsafe && Buffer2.allocUnsafeSlow) {
+      module.exports = buffer;
+    } else {
+      copyProps(buffer, exports);
+      exports.Buffer = SafeBuffer;
+    }
+    function SafeBuffer(arg, encodingOrOffset, length) {
+      return Buffer2(arg, encodingOrOffset, length);
+    }
+    __name(SafeBuffer, "SafeBuffer");
+    SafeBuffer.prototype = Object.create(Buffer2.prototype);
+    copyProps(Buffer2, SafeBuffer);
+    SafeBuffer.from = function(arg, encodingOrOffset, length) {
+      if (typeof arg === "number") {
+        throw new TypeError("Argument must not be a number");
+      }
+      return Buffer2(arg, encodingOrOffset, length);
+    };
+    SafeBuffer.alloc = function(size, fill, encoding) {
+      if (typeof size !== "number") {
+        throw new TypeError("Argument must be a number");
+      }
+      var buf = Buffer2(size);
+      if (fill !== void 0) {
+        if (typeof encoding === "string") {
+          buf.fill(fill, encoding);
+        } else {
+          buf.fill(fill);
+        }
+      } else {
+        buf.fill(0);
+      }
+      return buf;
+    };
+    SafeBuffer.allocUnsafe = function(size) {
+      if (typeof size !== "number") {
+        throw new TypeError("Argument must be a number");
+      }
+      return Buffer2(size);
+    };
+    SafeBuffer.allocUnsafeSlow = function(size) {
+      if (typeof size !== "number") {
+        throw new TypeError("Argument must be a number");
+      }
+      return buffer.SlowBuffer(size);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/registry-auth-token@3.3.2/node_modules/registry-auth-token/base64.js
+var require_base64 = __commonJS({
+  "../../node_modules/.pnpm/registry-auth-token@3.3.2/node_modules/registry-auth-token/base64.js"(exports, module) {
+    var safeBuffer = require_safe_buffer().Buffer;
+    function decodeBase64(base64) {
+      return safeBuffer.from(base64, "base64").toString("utf8");
+    }
+    __name(decodeBase64, "decodeBase64");
+    function encodeBase64(string) {
+      return safeBuffer.from(string, "utf8").toString("base64");
+    }
+    __name(encodeBase64, "encodeBase64");
+    module.exports = {
+      decodeBase64,
+      encodeBase64
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/registry-auth-token@3.3.2/node_modules/registry-auth-token/index.js
+var require_registry_auth_token = __commonJS({
+  "../../node_modules/.pnpm/registry-auth-token@3.3.2/node_modules/registry-auth-token/index.js"(exports, module) {
+    var url = __require("url");
+    var base64 = require_base64();
+    var decodeBase64 = base64.decodeBase64;
+    var encodeBase64 = base64.encodeBase64;
+    var tokenKey = ":_authToken";
+    var userKey = ":username";
+    var passwordKey = ":_password";
+    module.exports = function() {
+      var checkUrl;
+      var options;
+      if (arguments.length >= 2) {
+        checkUrl = arguments[0];
+        options = arguments[1];
+      } else if (typeof arguments[0] === "string") {
+        checkUrl = arguments[0];
+      } else {
+        options = arguments[0];
+      }
+      options = options || {};
+      options.npmrc = options.npmrc || require_rc()("npm", { registry: "https://registry.npmjs.org/" });
+      checkUrl = checkUrl || options.npmrc.registry;
+      return getRegistryAuthInfo(checkUrl, options) || getLegacyAuthInfo(options.npmrc);
+    };
+    function getRegistryAuthInfo(checkUrl, options) {
+      var parsed = url.parse(checkUrl, false, true);
+      var pathname;
+      while (pathname !== "/" && parsed.pathname !== pathname) {
+        pathname = parsed.pathname || "/";
+        var regUrl = "//" + parsed.host + pathname.replace(/\/$/, "");
+        var authInfo = getAuthInfoForUrl(regUrl, options.npmrc);
+        if (authInfo) {
+          return authInfo;
+        }
+        if (!options.recursive) {
+          return /\/$/.test(checkUrl) ? void 0 : getRegistryAuthInfo(url.resolve(checkUrl, "."), options);
+        }
+        parsed.pathname = url.resolve(normalizePath(pathname), "..") || "/";
+      }
+      return void 0;
+    }
+    __name(getRegistryAuthInfo, "getRegistryAuthInfo");
+    function getLegacyAuthInfo(npmrc) {
+      if (npmrc._auth) {
+        return { token: npmrc._auth, type: "Basic" };
+      }
+      return void 0;
+    }
+    __name(getLegacyAuthInfo, "getLegacyAuthInfo");
+    function normalizePath(path5) {
+      return path5[path5.length - 1] === "/" ? path5 : path5 + "/";
+    }
+    __name(normalizePath, "normalizePath");
+    function getAuthInfoForUrl(regUrl, npmrc) {
+      var bearerAuth = getBearerToken(npmrc[regUrl + tokenKey] || npmrc[regUrl + "/" + tokenKey]);
+      if (bearerAuth) {
+        return bearerAuth;
+      }
+      var username = npmrc[regUrl + userKey] || npmrc[regUrl + "/" + userKey];
+      var password = npmrc[regUrl + passwordKey] || npmrc[regUrl + "/" + passwordKey];
+      var basicAuth = getTokenForUsernameAndPassword(username, password);
+      if (basicAuth) {
+        return basicAuth;
+      }
+      return void 0;
+    }
+    __name(getAuthInfoForUrl, "getAuthInfoForUrl");
+    function getBearerToken(tok) {
+      if (!tok) {
+        return void 0;
+      }
+      var token = tok.replace(/^\$\{?([^}]*)\}?$/, function(fullMatch, envVar) {
+        return process.env[envVar];
+      });
+      return { token, type: "Bearer" };
+    }
+    __name(getBearerToken, "getBearerToken");
+    function getTokenForUsernameAndPassword(username, password) {
+      if (!username || !password) {
+        return void 0;
+      }
+      var pass = decodeBase64(password.replace(/^\$\{?([^}]*)\}?$/, function(fullMatch, envVar) {
+        return process.env[envVar];
+      }));
+      var token = encodeBase64(username + ":" + pass);
+      return {
+        token,
+        type: "Basic",
+        password: pass,
+        username
+      };
+    }
+    __name(getTokenForUsernameAndPassword, "getTokenForUsernameAndPassword");
+  }
+});
+
+// ../../node_modules/.pnpm/update-check@1.5.4/node_modules/update-check/index.js
+var require_update_check = __commonJS({
+  "../../node_modules/.pnpm/update-check@1.5.4/node_modules/update-check/index.js"(exports, module) {
+    var { URL: URL2 } = __require("url");
+    var { join: join2 } = __require("path");
+    var fs3 = __require("fs");
+    var { promisify } = __require("util");
+    var { tmpdir } = __require("os");
+    var registryUrl = require_registry_url();
+    var writeFile = promisify(fs3.writeFile);
+    var mkdir = promisify(fs3.mkdir);
+    var readFile = promisify(fs3.readFile);
+    var compareVersions = /* @__PURE__ */ __name((a, b) => a.localeCompare(b, "en-US", { numeric: true }), "compareVersions");
+    var encode = /* @__PURE__ */ __name((value) => encodeURIComponent(value).replace(/^%40/, "@"), "encode");
+    var getFile = /* @__PURE__ */ __name(async (details, distTag) => {
+      const rootDir = tmpdir();
+      const subDir = join2(rootDir, "update-check");
+      if (!fs3.existsSync(subDir)) {
+        await mkdir(subDir);
+      }
+      let name = `${details.name}-${distTag}.json`;
+      if (details.scope) {
+        name = `${details.scope}-${name}`;
+      }
+      return join2(subDir, name);
+    }, "getFile");
+    var evaluateCache = /* @__PURE__ */ __name(async (file, time, interval) => {
+      if (fs3.existsSync(file)) {
+        const content = await readFile(file, "utf8");
+        const { lastUpdate, latest } = JSON.parse(content);
+        const nextCheck = lastUpdate + interval;
+        if (nextCheck > time) {
+          return {
+            shouldCheck: false,
+            latest
+          };
+        }
+      }
+      return {
+        shouldCheck: true,
+        latest: null
+      };
+    }, "evaluateCache");
+    var updateCache = /* @__PURE__ */ __name(async (file, latest, lastUpdate) => {
+      const content = JSON.stringify({
+        latest,
+        lastUpdate
+      });
+      await writeFile(file, content, "utf8");
+    }, "updateCache");
+    var loadPackage = /* @__PURE__ */ __name((url, authInfo) => new Promise((resolve, reject) => {
+      const options = {
+        host: url.hostname,
+        path: url.pathname,
+        port: url.port,
+        headers: {
+          accept: "application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*"
+        },
+        timeout: 2e3
+      };
+      if (authInfo) {
+        options.headers.authorization = `${authInfo.type} ${authInfo.token}`;
+      }
+      const { get } = url.protocol === "https:" ? __require("https") : __require("http");
+      get(options, (response) => {
+        const { statusCode } = response;
+        if (statusCode !== 200) {
+          const error = new Error(`Request failed with code ${statusCode}`);
+          error.code = statusCode;
+          reject(error);
+          response.resume();
+          return;
+        }
+        let rawData = "";
+        response.setEncoding("utf8");
+        response.on("data", (chunk) => {
+          rawData += chunk;
+        });
+        response.on("end", () => {
+          try {
+            const parsedData = JSON.parse(rawData);
+            resolve(parsedData);
+          } catch (e2) {
+            reject(e2);
+          }
+        });
+      }).on("error", reject).on("timeout", reject);
+    }), "loadPackage");
+    var getMostRecent = /* @__PURE__ */ __name(async ({ full, scope }, distTag) => {
+      const regURL = registryUrl(scope);
+      const url = new URL2(full, regURL);
+      let spec = null;
+      try {
+        spec = await loadPackage(url);
+      } catch (err) {
+        if (err.code && String(err.code).startsWith(4)) {
+          const registryAuthToken = require_registry_auth_token();
+          const authInfo = registryAuthToken(regURL, { recursive: true });
+          spec = await loadPackage(url, authInfo);
+        } else {
+          throw err;
+        }
+      }
+      const version = spec["dist-tags"][distTag];
+      if (!version) {
+        throw new Error(`Distribution tag ${distTag} is not available`);
+      }
+      return version;
+    }, "getMostRecent");
+    var defaultConfig = {
+      interval: 36e5,
+      distTag: "latest"
+    };
+    var getDetails = /* @__PURE__ */ __name((name) => {
+      const spec = {
+        full: encode(name)
+      };
+      if (name.includes("/")) {
+        const parts = name.split("/");
+        spec.scope = parts[0];
+        spec.name = parts[1];
+      } else {
+        spec.scope = null;
+        spec.name = name;
+      }
+      return spec;
+    }, "getDetails");
+    module.exports = async (pkg, config) => {
+      if (typeof pkg !== "object") {
+        throw new Error("The first parameter should be your package.json file content");
+      }
+      const details = getDetails(pkg.name);
+      const time = Date.now();
+      const { distTag, interval } = Object.assign({}, defaultConfig, config);
+      const file = await getFile(details, distTag);
+      let latest = null;
+      let shouldCheck = true;
+      ({ shouldCheck, latest } = await evaluateCache(file, time, interval));
+      if (shouldCheck) {
+        latest = await getMostRecent(details, distTag);
+        await updateCache(file, latest, time);
+      }
+      const comparision = compareVersions(pkg.version, latest);
+      if (comparision === -1) {
+        return {
+          latest,
+          fromCache: !shouldCheck
+        };
+      }
+      return null;
+    };
+  }
+});
+
 // src/config/config.ts
 var defaultWranglerConfig = {
   /* COMPUTED_FIELDS */
@@ -722,6 +1911,8 @@ var defaultWranglerConfig = {
   vectorize: [],
   ai_search_namespaces: [],
   ai_search: [],
+  web_search: void 0,
+  agent_memory: [],
   hyperdrive: [],
   workflows: [],
   secrets_store_secrets: [],
@@ -797,7 +1988,7 @@ var defaultWranglerConfig = {
   vpc_networks: []
 };
 var experimental_patchConfig = /* @__PURE__ */ __name((configPath, patch, isArrayInsertion = true) => {
-  let configString = readFileSync(configPath);
+  let configString = readFileSync$1(configPath);
   if (configPath.endsWith("toml")) {
     if (configString.includes("#")) {
       throw new PatchConfigError(
@@ -1206,8 +2397,8 @@ function getErrorMap() {
 }
 __name(getErrorMap, "getErrorMap");
 var makeIssue = /* @__PURE__ */ __name((params) => {
-  const { data, path: path4, errorMaps, issueData } = params;
-  const fullPath = [...path4, ...issueData.path || []];
+  const { data, path: path5, errorMaps, issueData } = params;
+  const fullPath = [...path5, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -1313,11 +2504,11 @@ var ParseInputLazyPath = class {
   static {
     __name(this, "ParseInputLazyPath");
   }
-  constructor(parent, value, path4, key) {
+  constructor(parent, value, path5, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path4;
+    this._path = path5;
     this._key = key;
   }
   get path() {
@@ -4820,7 +6011,8 @@ var getWranglerSendMetricsFromEnv = getBooleanEnvironmentVariableFactory({
   variableName: "WRANGLER_SEND_METRICS"
 });
 var getWranglerSendErrorReportsFromEnv = getBooleanEnvironmentVariableFactory({
-  variableName: "WRANGLER_SEND_ERROR_REPORTS"
+  variableName: "WRANGLER_SEND_ERROR_REPORTS",
+  defaultValue: false
 });
 var getCloudflareApiEnvironmentFromEnv = getEnvironmentVariableFactory(
   {
@@ -5120,9 +6312,9 @@ Please add "${field}" to "env.${envName}".`
   return rawEnv[field] ?? defaultValue;
 }
 __name(notInheritable, "notInheritable");
-function unwindPropertyPath(root, path4) {
+function unwindPropertyPath(root, path5) {
   let container = root;
-  const parts = path4.split(".");
+  const parts = path5.split(".");
   for (let i = 0; i < parts.length - 1; i++) {
     if (!hasProperty(container, parts[i])) {
       return;
@@ -5396,6 +6588,8 @@ var friendlyBindingNames = {
   vectorize: "Vectorize Index",
   ai_search_namespaces: "AI Search Namespace",
   ai_search: "AI Search Instance",
+  web_search: "Web Search",
+  agent_memory: "Agent Memory",
   hyperdrive: "Hyperdrive Config",
   r2_buckets: "R2 Bucket",
   logfwdr: "logfwdr",
@@ -5448,6 +6642,8 @@ var bindingTypeFriendlyNames = {
   vectorize: "Vectorize Index",
   ai_search_namespace: "AI Search Namespace",
   ai_search: "AI Search Instance",
+  web_search: "Web Search",
+  agent_memory: "Agent Memory",
   hyperdrive: "Hyperdrive Config",
   service: "Worker",
   fetcher: "Service Binding",
@@ -6642,6 +7838,26 @@ function normalizeAndValidateEnvironment(diagnostics, configPath, rawEnv, isDisp
       validateBindingArray(envName, validateAISearchBinding),
       []
     ),
+    web_search: notInheritable(
+      diagnostics,
+      topLevelEnv,
+      rawConfig,
+      rawEnv,
+      envName,
+      "web_search",
+      validateNamedSimpleBinding(envName),
+      void 0
+    ),
+    agent_memory: notInheritable(
+      diagnostics,
+      topLevelEnv,
+      rawConfig,
+      rawEnv,
+      envName,
+      "agent_memory",
+      validateBindingArray(envName, validateAgentMemoryBinding),
+      []
+    ),
     hyperdrive: notInheritable(
       diagnostics,
       topLevelEnv,
@@ -7438,36 +8654,36 @@ var validateWorkflowBinding = /* @__PURE__ */ __name((diagnostics, field, value)
     );
     isValid2 = false;
   }
-  if (hasProperty(value, "schedule") && value.schedule !== void 0) {
-    if (typeof value.schedule === "string") {
-      if (value.schedule.length === 0) {
+  if (hasProperty(value, "schedules") && value.schedules !== void 0) {
+    if (typeof value.schedules === "string") {
+      if (value.schedules.length === 0) {
         diagnostics.errors.push(
-          `"${field}" bindings "schedule" field must not be an empty string.`
+          `"${field}" bindings "schedules" field must not be an empty string.`
         );
         isValid2 = false;
       }
-    } else if (Array.isArray(value.schedule)) {
-      if (value.schedule.length === 0) {
+    } else if (Array.isArray(value.schedules)) {
+      if (value.schedules.length === 0) {
         diagnostics.errors.push(
-          `"${field}" bindings "schedule" field must not be an empty array.`
+          `"${field}" bindings "schedules" field must not be an empty array.`
         );
         isValid2 = false;
-      } else if (!value.schedule.every((s) => typeof s === "string")) {
+      } else if (!value.schedules.every((s) => typeof s === "string")) {
         diagnostics.errors.push(
-          `"${field}" bindings should, optionally, have a string or array of strings "schedule" field but got ${JSON.stringify(
+          `"${field}" bindings should, optionally, have a string or array of strings "schedules" field but got ${JSON.stringify(
             value
           )}.`
         );
         isValid2 = false;
-      } else if (value.schedule.some((s) => s === "")) {
+      } else if (value.schedules.some((s) => s === "")) {
         diagnostics.errors.push(
-          `"${field}" bindings "schedule" field must not contain empty strings.`
+          `"${field}" bindings "schedules" field must not contain empty strings.`
         );
         isValid2 = false;
       }
     } else {
       diagnostics.errors.push(
-        `"${field}" bindings should, optionally, have a string or array of strings "schedule" field but got ${JSON.stringify(
+        `"${field}" bindings should, optionally, have a string or array of strings "schedules" field but got ${JSON.stringify(
           value
         )}.`
       );
@@ -7513,7 +8729,7 @@ var validateWorkflowBinding = /* @__PURE__ */ __name((diagnostics, field, value)
     "script_name",
     "remote",
     "limits",
-    "schedule"
+    "schedules"
   ]);
   return isValid2;
 }, "validateWorkflowBinding");
@@ -7725,6 +8941,8 @@ var validateUnsafeBinding = /* @__PURE__ */ __name((diagnostics, field, value) =
       "ai",
       "ai_search_namespace",
       "ai_search",
+      "web_search",
+      "agent_memory",
       "kv_namespace",
       "durable_object_namespace",
       "d1_database",
@@ -8640,6 +9858,36 @@ var validateAISearchBinding = /* @__PURE__ */ __name((diagnostics, field, value)
   ]);
   return isValid2;
 }, "validateAISearchBinding");
+var validateAgentMemoryBinding = /* @__PURE__ */ __name((diagnostics, field, value) => {
+  if (typeof value !== "object" || value === null) {
+    diagnostics.errors.push(
+      `"agent_memory" bindings should be objects, but got ${JSON.stringify(value)}`
+    );
+    return false;
+  }
+  let isValid2 = true;
+  if (!isRequiredProperty(value, "binding", "string")) {
+    diagnostics.errors.push(
+      `"${field}" bindings should have a string "binding" field but got ${JSON.stringify(value)}.`
+    );
+    isValid2 = false;
+  }
+  if (!isRequiredProperty(value, "namespace", "string")) {
+    diagnostics.errors.push(
+      `"${field}" bindings must have a "namespace" field but got ${JSON.stringify(value)}.`
+    );
+    isValid2 = false;
+  }
+  if (!isRemoteValid(value, field, diagnostics)) {
+    isValid2 = false;
+  }
+  validateAdditionalProperties(diagnostics, field, Object.keys(value), [
+    "binding",
+    "namespace",
+    "remote"
+  ]);
+  return isValid2;
+}, "validateAgentMemoryBinding");
 var validateHyperdriveBinding = /* @__PURE__ */ __name((diagnostics, field, value) => {
   if (typeof value !== "object" || value === null) {
     diagnostics.errors.push(
@@ -9139,9 +10387,16 @@ var validatePipelineBinding = /* @__PURE__ */ __name((diagnostics, field, value)
     );
     isValid2 = false;
   }
-  if (!isRequiredProperty(value, "pipeline", "string")) {
+  const hasStream = isOptionalProperty(value, "stream", "string");
+  const hasPipeline = isOptionalProperty(value, "pipeline", "string");
+  const v = value;
+  if (hasStream && v.stream) ; else if (hasPipeline && v.pipeline) {
+    diagnostics.warnings.push(
+      `The "pipeline" field in "${field}" bindings is deprecated. Use "stream" instead.`
+    );
+  } else {
     diagnostics.errors.push(
-      `"${field}" bindings must have a string "pipeline" field but got ${JSON.stringify(
+      `"${field}" bindings must have a string "stream" field but got ${JSON.stringify(
         value
       )}.`
     );
@@ -9152,6 +10407,7 @@ var validatePipelineBinding = /* @__PURE__ */ __name((diagnostics, field, value)
   }
   validateAdditionalProperties(diagnostics, field, Object.keys(value), [
     "binding",
+    "stream",
     "pipeline",
     "remote"
   ]);
@@ -10012,7 +11268,7 @@ __name(isRemoteValid, "isRemoteValid");
 function isDockerfile(imagePath, configPath) {
   const baseDir = configPath ? path3.dirname(configPath) : process.cwd();
   const maybeDockerfile = path3.resolve(baseDir, imagePath);
-  if (fs.existsSync(maybeDockerfile)) {
+  if (fs2.existsSync(maybeDockerfile)) {
     if (isDirectory(maybeDockerfile)) {
       throw new UserError(
         `${imagePath} is a directory, you should specify a path to the Dockerfile`,
@@ -10050,6 +11306,61 @@ function isDockerfile(imagePath, configPath) {
 }
 __name(isDockerfile, "isDockerfile");
 
+// src/config/binding-local-support.ts
+var BINDING_LOCAL_SUPPORT = {
+  plain_text: "local-only",
+  secret_text: "local-only",
+  json: "local-only",
+  wasm_module: "local-only",
+  text_blob: "local-only",
+  data_blob: "local-only",
+  version_metadata: "local-only",
+  inherit: "local-only",
+  logfwdr: "local-only",
+  assets: "local-only",
+  unsafe_hello_world: "local-only",
+  durable_object_namespace: "local-only",
+  hyperdrive: "local-only",
+  fetcher: "local-only",
+  analytics_engine: "local-only",
+  secrets_store_secret: "local-only",
+  ratelimit: "local-only",
+  worker_loader: "local-only",
+  kv_namespace: "local-and-remote",
+  r2_bucket: "local-and-remote",
+  d1: "local-and-remote",
+  workflow: "local-and-remote",
+  browser: "local-and-remote",
+  images: "local-and-remote",
+  stream: "local-and-remote",
+  send_email: "local-and-remote",
+  pipeline: "local-and-remote",
+  service: "local-and-remote",
+  // TODO: Miniflare currently ignores `remote: true` on queues, tracked in #13727.
+  queue: "local-and-remote",
+  vectorize: "remote",
+  mtls_certificate: "remote",
+  dispatch_namespace: "remote",
+  // Reach out to the @cloudflare/wrangler team before adding anything here
+  ai: "DO-NOT-USE-this-resource-will-never-have-a-local-simulator",
+  ai_search: "DO-NOT-USE-this-resource-will-never-have-a-local-simulator",
+  ai_search_namespace: "DO-NOT-USE-this-resource-will-never-have-a-local-simulator",
+  media: "DO-NOT-USE-this-resource-will-never-have-a-local-simulator",
+  artifacts: "DO-NOT-USE-this-resource-will-never-have-a-local-simulator",
+  flagship: "DO-NOT-USE-this-resource-will-never-have-a-local-simulator",
+  vpc_service: "DO-NOT-USE-this-resource-will-never-have-a-local-simulator",
+  vpc_network: "DO-NOT-USE-this-resource-will-never-have-a-local-simulator",
+  web_search: "DO-NOT-USE-this-resource-will-never-have-a-local-simulator",
+  agent_memory: "DO-NOT-USE-this-resource-will-never-have-a-local-simulator"
+};
+function getBindingLocalSupport(type) {
+  if (type in BINDING_LOCAL_SUPPORT) {
+    return BINDING_LOCAL_SUPPORT[type];
+  }
+  return "local-only";
+}
+__name(getBindingLocalSupport, "getBindingLocalSupport");
+
 // src/config/validation-pages.ts
 var supportedPagesConfigFields = [
   "pages_build_output_dir",
@@ -10181,6 +11492,66 @@ Pages requires Durable Object bindings to specify the name of the Worker where t
 }
 __name(validateDurableObjectBinding2, "validateDurableObjectBinding");
 
+// src/wrangler-tmp-dir.ts
+var import_signal_exit = __toESM(require_signal_exit());
+function getWranglerHiddenDirPath(projectRoot) {
+  projectRoot ??= process.cwd();
+  return path3.join(projectRoot, ".wrangler");
+}
+__name(getWranglerHiddenDirPath, "getWranglerHiddenDirPath");
+var STALE_WRANGLER_TMP_DIR_MS = 24 * 60 * 60 * 1e3;
+var sweptTmpRoots = /* @__PURE__ */ new Set();
+function sweepStaleWranglerTmpDirs(tmpRoot) {
+  if (sweptTmpRoots.has(tmpRoot)) {
+    return;
+  }
+  sweptTmpRoots.add(tmpRoot);
+  let entries;
+  try {
+    entries = fs2.readdirSync(tmpRoot, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  const cutoff = Date.now() - STALE_WRANGLER_TMP_DIR_MS;
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const entryPath = path3.join(tmpRoot, entry.name);
+    try {
+      if (fs2.statSync(entryPath).mtimeMs < cutoff) {
+        removeDirSync(entryPath);
+      }
+    } catch {
+    }
+  }
+}
+__name(sweepStaleWranglerTmpDirs, "sweepStaleWranglerTmpDirs");
+function getWranglerTmpDir(projectRoot, prefix, cleanup = true) {
+  const tmpRoot = path3.join(getWranglerHiddenDirPath(projectRoot), "tmp");
+  fs2.mkdirSync(tmpRoot, { recursive: true });
+  sweepStaleWranglerTmpDirs(tmpRoot);
+  const tmpPrefix = path3.join(tmpRoot, `${prefix}-`);
+  const tmpDir = fs2.realpathSync(fs2.mkdtempSync(tmpPrefix));
+  const cleanupDir = /* @__PURE__ */ __name(() => {
+    if (cleanup) {
+      try {
+        removeDirSync(tmpDir);
+      } catch {
+      }
+    }
+  }, "cleanupDir");
+  const removeExitListener = (0, import_signal_exit.default)(cleanupDir);
+  return {
+    path: tmpDir,
+    remove() {
+      removeExitListener();
+      cleanupDir();
+    }
+  };
+}
+__name(getWranglerTmpDir, "getWranglerTmpDir");
+
 // src/cloudflared.ts
 var import_command_exists = __toESM(require_command_exists2());
 var UPDATE_SERVICE_URL = "https://update.argotunnel.com";
@@ -10555,18 +11926,6 @@ __name(downloadCloudflared, "downloadCloudflared");
 async function downloadAndExtractTarball(response, expectedChecksum, binPath, cacheDir) {
   const tempTarPath = join(cacheDir, "cloudflared.tgz");
   const buffer = Buffer.from(await response.arrayBuffer());
-  if (expectedChecksum) {
-    const actualSha256 = sha256Hex(buffer);
-    if (actualSha256 !== expectedChecksum) {
-      throw new UserError(
-        `[cloudflared] SHA256 mismatch for downloaded cloudflared tarball.
-
-Expected: ${expectedChecksum}
-Actual:   ${actualSha256}`,
-        { telemetryMessage: "tunnel cloudflared tarball checksum mismatch" }
-      );
-    }
-  }
   writeFileSync(tempTarPath, buffer);
   try {
     execFileSync("tar", ["-xzf", tempTarPath, "-C", cacheDir], {
@@ -10576,6 +11935,21 @@ Actual:   ${actualSha256}`,
     if (extractedPath !== binPath && existsSync(extractedPath)) {
       renameSync(extractedPath, binPath);
     }
+    if (expectedChecksum) {
+      const extractedBinary = readFileSync(binPath);
+      const actualSha256 = sha256Hex(extractedBinary);
+      if (actualSha256 !== expectedChecksum) {
+        throw new UserError(
+          `[cloudflared] SHA256 mismatch for downloaded cloudflared binary.
+
+Expected: ${expectedChecksum}
+Actual:   ${actualSha256}`,
+          {
+            telemetryMessage: "tunnel cloudflared extracted binary checksum mismatch"
+          }
+        );
+      }
+    }
   } finally {
     try {
       if (existsSync(tempTarPath)) {
@@ -10774,7 +12148,7 @@ function startTunnel(options) {
           return;
         }
         logger?.log(
-          `${publicURL ? `The tunnel is still open at ${publicURL}.` : "The tunnel is still open."} It expires in ${formatTunnelDuration(remainingMs)}. ${options.extendHint ?? ""}`
+          `${publicURL ? `Tunnel still open, expires in ${formatTunnelDuration(remainingMs)}: ${publicURL}` : `The tunnel is still open. It expires in ${formatTunnelDuration(remainingMs)}.`}${options.extendHint ? ` ${options.extendHint}` : ""}`
         );
       }, reminderIntervalMs);
       reminderInterval.unref?.();
@@ -10925,7 +12299,7 @@ function createTunnelStartupError(message, stderrOutput, origin) {
 cloudflared output:
 ${stderrOutput || "(no output)"}
 
-The local dev server started at ${origin.href}.
+The local dev server started at ${origin.href}
 ` + (isQuickTunnelRateLimited ? "Cloudflare Quick Tunnel creation was rate limited. Try again in a few minutes, or use a named tunnel if you need more reliable access." : `Check the cloudflared output above for more details, and verify that ${origin.href} is reachable from this machine if this keeps happening.`);
   if (isQuickTunnelRateLimited) {
     return new UserError(errorMessage, { telemetryMessage: false });
@@ -10934,4 +12308,410 @@ The local dev server started at ${origin.href}.
 }
 __name(createTunnelStartupError, "createTunnelStartupError");
 
-export { COMPLIANCE_REGION_CONFIG_PUBLIC, COMPLIANCE_REGION_CONFIG_UNKNOWN, Diagnostics, PatchConfigError, bucketFormatMessage, defaultWranglerConfig, experimental_patchConfig, friendlyBindingNames, getBindingTypeFriendlyName, getBooleanEnvironmentVariableFactory, getBrowserRenderingHeadfulFromEnv, getBuildConditionsFromEnv, getBuildPlatformFromEnv, getC3CommandFromEnv, getCIGeneratePreviewAlias, getCIMatchTag, getCIOverrideName, getCIOverrideNetworkModeHost, getCfFetchEnabledFromEnv, getCfFetchPathFromEnv, getCloudflareApiBaseUrl, getCloudflareApiEnvironmentFromEnv, getCloudflareComplianceRegion, getCloudflareEnv, getCloudflareIncludeProcessEnvFromEnv, getCloudflareLoadDevVarsFromDotEnv, getCloudflaredPathFromEnv, getComplianceRegionSubdomain, getD1ExtraLocationChoices, getDisableConfigWatching, getDockerPath, getEnvironmentVariableFactory, getGlobalWranglerConfigPath, getLocalExplorerEnabledFromEnv, getOpenNextDeployFromEnv, getOutputFileDirectoryFromEnv, getOutputFilePathFromEnv, getRegistryPath, getSanitizeLogs, getSubdomainMixedStateCheckDisabled, getTraceHeader, getWorkersCIBranchName, getWranglerCacheDirFromEnv, getWranglerHideBanner, getWranglerSendErrorReportsFromEnv, getWranglerSendMetricsFromEnv, hasProperty, isDockerfile, isOptionalProperty, isPagesConfig, isRequiredProperty, isValidR2BucketName, normalizeAndValidateConfig, spawnCloudflared, startTunnel, validatePagesConfig };
+// src/cfetch/errors.ts
+function buildDetailedError(message, ...extra) {
+  return new ParseError({
+    text: message,
+    notes: extra.map((text) => ({ text })),
+    telemetryMessage: false
+  });
+}
+__name(buildDetailedError, "buildDetailedError");
+function maybeThrowFriendlyError(error) {
+  if (error.message === "workers.api.error.email_verification_required") {
+    throw buildDetailedError(
+      "Please verify your account's email address and try again.",
+      "Check your email for a verification link, or login to https://dash.cloudflare.com and request a new one."
+    );
+  }
+}
+__name(maybeThrowFriendlyError, "maybeThrowFriendlyError");
+
+// src/cfetch/index.ts
+function logHeaders(headers, logger) {
+  const clone = cloneHeaders(headers);
+  clone.delete("Authorization");
+  logger.debugWithSanitization(
+    "HEADERS:",
+    JSON.stringify(Object.fromEntries(clone), null, 2)
+  );
+}
+__name(logHeaders, "logHeaders");
+async function performApiFetchBase(complianceConfig, resource, init = {}, userAgent, logger, queryParams, abortSignal, credentials) {
+  assert(credentials, "credentials are required for performApiFetch");
+  const method = init.method ?? "GET";
+  assert(
+    resource.startsWith("/"),
+    `CF API fetch - resource path must start with a "/" but got "${resource}"`
+  );
+  const headers = cloneHeaders(new Headers(init.headers));
+  addAuthorizationHeader(headers, credentials);
+  headers.set("User-Agent", userAgent);
+  maybeAddTraceHeader(headers);
+  const queryString = queryParams ? `?${queryParams.toString()}` : "";
+  logger.debug(
+    `-- START CF API REQUEST: ${method} ${getCloudflareApiBaseUrl(complianceConfig)}${resource}`
+  );
+  logger.debugWithSanitization("QUERY STRING:", queryString);
+  logHeaders(headers, logger);
+  logger.debugWithSanitization("INIT:", JSON.stringify({ ...init }, null, 2));
+  if (init.body instanceof FormData) {
+    logger.debugWithSanitization(
+      "BODY:",
+      await new Response(init.body).text(),
+      null,
+      2
+    );
+  }
+  logger.debug("-- END CF API REQUEST");
+  return await fetch(
+    `${getCloudflareApiBaseUrl(complianceConfig)}${resource}${queryString}`,
+    {
+      method,
+      ...init,
+      headers,
+      signal: abortSignal
+    }
+  );
+}
+__name(performApiFetchBase, "performApiFetchBase");
+async function fetchInternalBase(complianceConfig, resource, init = {}, userAgent, logger, queryParams, abortSignal, credentials) {
+  const method = init.method ?? "GET";
+  const response = await performApiFetchBase(
+    complianceConfig,
+    resource,
+    init,
+    userAgent,
+    logger,
+    queryParams,
+    abortSignal,
+    credentials
+  );
+  const jsonText = await response.text();
+  logger.debug(
+    "-- START CF API RESPONSE:",
+    response.statusText,
+    response.status
+  );
+  logHeaders(response.headers, logger);
+  logger.debugWithSanitization("RESPONSE:", jsonText);
+  logger.debug("-- END CF API RESPONSE");
+  if (!jsonText && (response.status === 204 || response.status === 205)) {
+    return {
+      response: {
+        result: {},
+        success: true,
+        errors: [],
+        messages: []
+      },
+      status: response.status
+    };
+  }
+  if (isWAFBlockResponse(response.headers)) {
+    throwWAFBlockError(
+      response.headers,
+      method,
+      resource,
+      response.status,
+      response.statusText
+    );
+  }
+  try {
+    const json = parseJSON(jsonText);
+    return { response: json, status: response.status };
+  } catch {
+    const rayId = extractWAFBlockRayId(response.headers);
+    throw new APIError({
+      text: "Received a malformed response from the API",
+      notes: [
+        {
+          text: truncate(jsonText, 100)
+        },
+        {
+          text: `${method} ${resource} -> ${response.status} ${response.statusText}`
+        },
+        ...rayId ? [{ text: `Cloudflare Ray ID: ${rayId}` }] : []
+      ],
+      status: response.status,
+      telemetryMessage: false
+    });
+  }
+}
+__name(fetchInternalBase, "fetchInternalBase");
+async function fetchResultBase(complianceConfig, resource, init = {}, userAgent, logger, queryParams, abortSignal, credentials) {
+  const { response: json, status } = await fetchInternalBase(
+    complianceConfig,
+    resource,
+    init,
+    userAgent,
+    logger,
+    queryParams,
+    abortSignal,
+    credentials
+  );
+  if (json.success) {
+    return json.result;
+  } else {
+    throwFetchError(resource, json, status);
+  }
+}
+__name(fetchResultBase, "fetchResultBase");
+async function fetchListResultBase(complianceConfig, resource, init = {}, userAgent, logger, queryParams, credentials) {
+  const results = [];
+  let getMoreResults = true;
+  let cursor;
+  while (getMoreResults) {
+    if (cursor) {
+      queryParams = new URLSearchParams(queryParams);
+      queryParams.set("cursor", cursor);
+    }
+    const { response: json, status } = await fetchInternalBase(
+      complianceConfig,
+      resource,
+      init,
+      userAgent,
+      logger,
+      queryParams,
+      void 0,
+      credentials
+    );
+    if (json.success) {
+      results.push(...json.result);
+      if (hasCursor(json.result_info)) {
+        cursor = json.result_info?.cursor;
+      } else {
+        getMoreResults = false;
+      }
+    } else {
+      throwFetchError(resource, json, status);
+    }
+  }
+  return results;
+}
+__name(fetchListResultBase, "fetchListResultBase");
+function truncate(text, maxLength) {
+  const { length } = text;
+  if (length <= maxLength) {
+    return text;
+  }
+  return `${text.substring(0, maxLength)}... (length = ${length})`;
+}
+__name(truncate, "truncate");
+function isWAFBlockResponse(headers) {
+  return headers.get("cf-mitigated") === "challenge";
+}
+__name(isWAFBlockResponse, "isWAFBlockResponse");
+function extractWAFBlockRayId(headers) {
+  return headers.get("cf-ray") ?? void 0;
+}
+__name(extractWAFBlockRayId, "extractWAFBlockRayId");
+function extractAccountTag(resource) {
+  const re = new RegExp("/accounts/([a-zA-Z0-9]+)/?");
+  const matches = re.exec(resource);
+  return matches?.[1];
+}
+__name(extractAccountTag, "extractAccountTag");
+function hasMorePages(result_info) {
+  const page = result_info?.page;
+  const per_page = result_info?.per_page;
+  const total = result_info?.total_count;
+  return page !== void 0 && per_page !== void 0 && total !== void 0 && page * per_page < total;
+}
+__name(hasMorePages, "hasMorePages");
+function renderError(err, level = 0) {
+  const indent = "  ".repeat(level);
+  const message = err.message ?? "";
+  const chainedMessages = "error_chain" in err ? err.error_chain?.map(
+    (chainedError) => `
+
+${indent}- ${renderError(chainedError, level + 1)}`
+  ).join("\n") ?? "" : "";
+  return (err.code ? `${message} [code: ${err.code}]` : message) + (err.documentation_url ? `
+${indent}To learn more about this error, visit: ${err.documentation_url}` : "") + chainedMessages;
+}
+__name(renderError, "renderError");
+function addAuthorizationHeader(headers, auth, overrideExisting = false) {
+  if (!headers.has("Authorization") || overrideExisting) {
+    if ("apiToken" in auth) {
+      const authorizationHeader = `Bearer ${auth.apiToken}`;
+      validateAuthorizationHeaderValue(authorizationHeader);
+      headers.set("Authorization", authorizationHeader);
+    } else {
+      headers.set("X-Auth-Key", auth.authKey);
+      headers.set("X-Auth-Email", auth.authEmail);
+    }
+  }
+}
+__name(addAuthorizationHeader, "addAuthorizationHeader");
+function validateAuthorizationHeaderValue(value) {
+  for (const character of value) {
+    const codePoint = character.codePointAt(0);
+    if (codePoint === void 0 || codePoint > 255) {
+      throw new UserError(
+        `The configured Cloudflare API token contains a character that cannot be used in an HTTP Authorization header: ${formatAuthorizationHeaderCharacter(character, codePoint)}. Recreate or copy the token again, making sure it does not include characters such as ellipses.`,
+        {
+          telemetryMessage: "cfetch auth invalid authorization header"
+        }
+      );
+    }
+  }
+}
+__name(validateAuthorizationHeaderValue, "validateAuthorizationHeaderValue");
+function formatAuthorizationHeaderCharacter(character, codePoint) {
+  if (codePoint === void 0) {
+    return '"\\u{unknown}"';
+  }
+  const codePointLabel = `U+${codePoint.toString(16).toUpperCase().padStart(4, "0")}`;
+  const characterLabel = isPrintableCharacter(character) ? `"${character}"` : `"${escapeCharacter(character)}"`;
+  return `${characterLabel} (${codePointLabel})`;
+}
+__name(formatAuthorizationHeaderCharacter, "formatAuthorizationHeaderCharacter");
+function isPrintableCharacter(character) {
+  return !/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/u.test(character);
+}
+__name(isPrintableCharacter, "isPrintableCharacter");
+function escapeCharacter(character) {
+  return Array.from(character).map((c) => {
+    const codePoint = c.codePointAt(0);
+    if (codePoint === void 0) {
+      return "";
+    }
+    return codePoint <= 65535 ? `\\u${codePoint.toString(16).toUpperCase().padStart(4, "0")}` : `\\u{${codePoint.toString(16).toUpperCase()}}`;
+  }).join("");
+}
+__name(escapeCharacter, "escapeCharacter");
+function throwFetchError(resource, response, status) {
+  const errors = response.errors ?? [];
+  for (const error2 of errors) {
+    maybeThrowFriendlyError(error2);
+  }
+  const notes = [
+    ...errors.map((err) => ({ text: renderError(err) })),
+    ...response.messages?.map((msg) => ({
+      text: typeof msg === "string" ? msg : msg.message ?? String(msg)
+    })) ?? []
+  ];
+  if (notes.length === 0) {
+    const raw = response;
+    const fallbackMessage = typeof raw.error === "string" ? `${raw.error}${raw.code ? ` [code: ${raw.code}]` : ""}` : void 0;
+    if (fallbackMessage) {
+      notes.push({ text: fallbackMessage });
+    }
+  }
+  const error = new APIError({
+    text: `A request to the Cloudflare API (${resource}) failed.`,
+    notes,
+    status,
+    telemetryMessage: false
+  });
+  const code = errors[0]?.code;
+  if (code) {
+    error.code = code;
+  }
+  error.accountTag = extractAccountTag(resource);
+  throw error;
+}
+__name(throwFetchError, "throwFetchError");
+function throwWAFBlockError(headers, method, resource, status, statusText) {
+  const rayId = extractWAFBlockRayId(headers);
+  throw new APIError({
+    text: "The Cloudflare API responded with a WAF block page instead of the expected JSON response",
+    notes: [
+      {
+        text: "Cloudflare's firewall (WAF) blocked this API request. This is usually a false positive."
+      },
+      ...rayId ? [{ text: `Cloudflare Ray ID: ${rayId}` }] : [],
+      {
+        text: rayId ? "If the issue persists, please open a Cloudflare Support ticket and include the Ray ID above." : "If the issue persists, please open a Cloudflare Support ticket. You can find the Cloudflare Ray ID on the block page in your browser."
+      },
+      {
+        text: `${method} ${resource} -> ${status} ${statusText}`
+      }
+    ],
+    status,
+    telemetryMessage: false
+  });
+}
+__name(throwWAFBlockError, "throwWAFBlockError");
+function hasCursor(result_info) {
+  const cursor = result_info?.cursor;
+  return cursor !== void 0 && cursor !== null && cursor !== "";
+}
+__name(hasCursor, "hasCursor");
+function maybeAddTraceHeader(headers) {
+  const traceHeader = getTraceHeader();
+  if (traceHeader) {
+    headers.set("Cf-Trace-Id", traceHeader);
+  }
+}
+__name(maybeAddTraceHeader, "maybeAddTraceHeader");
+function cloneHeaders(headers) {
+  return new Headers(headers);
+}
+__name(cloneHeaders, "cloneHeaders");
+
+// src/update-check.ts
+var import_update_check = __toESM(require_update_check());
+var UPDATE_CHECK_TIMEOUT_MS = 3e3;
+var TIMED_OUT = Symbol("timed_out");
+async function fetchLatestNpmVersion(name, version) {
+  let result = null;
+  try {
+    result = await Promise.race([
+      (0, import_update_check.default)(
+        { name, version },
+        {
+          distTag: version.startsWith("0.0.0") ? "beta" : "latest"
+        }
+      ),
+      timersPromises.setTimeout(UPDATE_CHECK_TIMEOUT_MS, TIMED_OUT, {
+        ref: false
+      })
+    ]);
+  } catch {
+    return { status: "failed" };
+  }
+  if (result === TIMED_OUT) {
+    return { status: "failed" };
+  }
+  if (result === null) {
+    return { status: "up-to-date" };
+  }
+  return { status: "update-available", latest: result.latest };
+}
+__name(fetchLatestNpmVersion, "fetchLatestNpmVersion");
+/*! Bundled license information:
+
+deep-extend/lib/deep-extend.js:
+  (*!
+   * @description Recursive object extending
+   * @author Viacheslav Lotsmanov <lotsmanov89@gmail.com>
+   * @license MIT
+   *
+   * The MIT License (MIT)
+   *
+   * Copyright (c) 2013-2018 Viacheslav Lotsmanov
+   *
+   * Permission is hereby granted, free of charge, to any person obtaining a copy of
+   * this software and associated documentation files (the "Software"), to deal in
+   * the Software without restriction, including without limitation the rights to
+   * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+   * the Software, and to permit persons to whom the Software is furnished to do so,
+   * subject to the following conditions:
+   *
+   * The above copyright notice and this permission notice shall be included in all
+   * copies or substantial portions of the Software.
+   *
+   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+   * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+   * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+   * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+   * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+   *)
+
+safe-buffer/index.js:
+  (*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> *)
+*/
+
+export { COMPLIANCE_REGION_CONFIG_PUBLIC, COMPLIANCE_REGION_CONFIG_UNKNOWN, Diagnostics, PatchConfigError, addAuthorizationHeader, bucketFormatMessage, defaultWranglerConfig, experimental_patchConfig, extractAccountTag, extractWAFBlockRayId, fetchInternalBase, fetchLatestNpmVersion, fetchListResultBase, fetchResultBase, friendlyBindingNames, getBindingLocalSupport, getBindingTypeFriendlyName, getBooleanEnvironmentVariableFactory, getBrowserRenderingHeadfulFromEnv, getBuildConditionsFromEnv, getBuildPlatformFromEnv, getC3CommandFromEnv, getCIGeneratePreviewAlias, getCIMatchTag, getCIOverrideName, getCIOverrideNetworkModeHost, getCfFetchEnabledFromEnv, getCfFetchPathFromEnv, getCloudflareApiBaseUrl, getCloudflareApiEnvironmentFromEnv, getCloudflareComplianceRegion, getCloudflareEnv, getCloudflareIncludeProcessEnvFromEnv, getCloudflareLoadDevVarsFromDotEnv, getCloudflaredPathFromEnv, getComplianceRegionSubdomain, getD1ExtraLocationChoices, getDisableConfigWatching, getDockerPath, getEnvironmentVariableFactory, getGlobalWranglerConfigPath, getLocalExplorerEnabledFromEnv, getOpenNextDeployFromEnv, getOutputFileDirectoryFromEnv, getOutputFilePathFromEnv, getRegistryPath, getSanitizeLogs, getSubdomainMixedStateCheckDisabled, getTraceHeader, getWorkersCIBranchName, getWranglerCacheDirFromEnv, getWranglerHiddenDirPath, getWranglerHideBanner, getWranglerSendErrorReportsFromEnv, getWranglerSendMetricsFromEnv, getWranglerTmpDir, hasCursor, hasMorePages, hasProperty, isDockerfile, isOptionalProperty, isPagesConfig, isRequiredProperty, isValidR2BucketName, isWAFBlockResponse, maybeAddTraceHeader, normalizeAndValidateConfig, performApiFetchBase, renderError, spawnCloudflared, startTunnel, sweepStaleWranglerTmpDirs, throwFetchError, truncate, validatePagesConfig };