@nuxt/devtools 0.1.1 → 0.1.3

package/dist/chunks/vscode.mjs

@@ -1,29 +1,28 @@
+import require$$1$1, { hostname } from 'os';
 import { logger } from '@nuxt/kit';
 import { execa } from 'execa';
 import { createServer } from 'node:net';
 import { networkInterfaces } from 'node:os';
-import { g as getAugmentedNamespace, r as requireSrc, c as commonjsGlobal, l as lib$4 } from '../shared/devtools.8467d016.mjs';
-import require$$0__default from 'fs';
-import require$$0$1 from 'util';
-import require$$0 from 'url';
+import fs__default from 'fs';
+import require$$0 from 'path';
+import require$$1 from 'util';
+import require$$0$1 from 'url';
 import require$$2$1 from 'https';
-import require$$0$5 from 'net';
-import require$$1 from 'http';
-import require$$0$2 from 'stream';
-import require$$0$3 from 'assert';
+import require$$3 from 'net';
+import require$$1$2 from 'http';
+import require$$0$3 from 'stream';
+import require$$4 from 'assert';
+import require$$0$2 from 'tty';
 import require$$0$4 from 'zlib';
-import require$$1$1 from 'path';
 import { L as LOG_PREFIX } from './module-main.mjs';
-import 'tty';
-import 'os';
 import 'buffer';
 import 'tls';
 import 'crypto';
 import 'events';
 import 'querystring';
-import '../shared/devtools.34d9e53a.mjs';
-import '../shared/devtools.861712a3.mjs';
-import '../shared/devtools.bea56ed1.mjs';
+import '../shared/devtools.cce722d0.mjs';
+import '../shared/devtools.38b2468f.mjs';
+import '../shared/devtools.c43ddaa5.mjs';
 import 'birpc';
 import 'unimport';
 import 'pathe';
@@ -40,6 +39,36 @@ import __cjs_mod__ from 'module';
 const __filename = __cjs_url__.fileURLToPath(import.meta.url);
 const __dirname = __cjs_path__.dirname(__filename);
 const require = __cjs_mod__.createRequire(import.meta.url);
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function getAugmentedNamespace(n) {
+  if (n.__esModule) return n;
+  var f = n.default;
+	if (typeof f == "function") {
+		var a = function a () {
+			if (this instanceof a) {
+				var args = [null];
+				args.push.apply(args, arguments);
+				var Ctor = Function.bind.apply(f, args);
+				return new Ctor();
+			}
+			return f.apply(this, arguments);
+		};
+		a.prototype = f.prototype;
+  } else a = {};
+  Object.defineProperty(a, '__esModule', {value: true});
+	Object.keys(n).forEach(function (k) {
+		var d = Object.getOwnPropertyDescriptor(n, k);
+		Object.defineProperty(a, k, d.get ? d : {
+			enumerable: true,
+			get: function () {
+				return n[k];
+			}
+		});
+	});
+	return a;
+}
+
 const unsafePorts = /* @__PURE__ */ new Set([
   1,
   7,
@@ -274,6 +303,275 @@ async function findPort(ports, host, _verbose = false, _random = true) {
   }
 }
 
+var windows;
+var hasRequiredWindows;
+
+function requireWindows () {
+	if (hasRequiredWindows) return windows;
+	hasRequiredWindows = 1;
+	windows = isexe;
+	isexe.sync = sync;
+
+	var fs = fs__default;
+
+	function checkPathExt (path, options) {
+	  var pathext = options.pathExt !== undefined ?
+	    options.pathExt : process.env.PATHEXT;
+
+	  if (!pathext) {
+	    return true
+	  }
+
+	  pathext = pathext.split(';');
+	  if (pathext.indexOf('') !== -1) {
+	    return true
+	  }
+	  for (var i = 0; i < pathext.length; i++) {
+	    var p = pathext[i].toLowerCase();
+	    if (p && path.substr(-p.length).toLowerCase() === p) {
+	      return true
+	    }
+	  }
+	  return false
+	}
+
+	function checkStat (stat, path, options) {
+	  if (!stat.isSymbolicLink() && !stat.isFile()) {
+	    return false
+	  }
+	  return checkPathExt(path, options)
+	}
+
+	function isexe (path, options, cb) {
+	  fs.stat(path, function (er, stat) {
+	    cb(er, er ? false : checkStat(stat, path, options));
+	  });
+	}
+
+	function sync (path, options) {
+	  return checkStat(fs.statSync(path), path, options)
+	}
+	return windows;
+}
+
+var mode;
+var hasRequiredMode;
+
+function requireMode () {
+	if (hasRequiredMode) return mode;
+	hasRequiredMode = 1;
+	mode = isexe;
+	isexe.sync = sync;
+
+	var fs = fs__default;
+
+	function isexe (path, options, cb) {
+	  fs.stat(path, function (er, stat) {
+	    cb(er, er ? false : checkStat(stat, options));
+	  });
+	}
+
+	function sync (path, options) {
+	  return checkStat(fs.statSync(path), options)
+	}
+
+	function checkStat (stat, options) {
+	  return stat.isFile() && checkMode(stat, options)
+	}
+
+	function checkMode (stat, options) {
+	  var mod = stat.mode;
+	  var uid = stat.uid;
+	  var gid = stat.gid;
+
+	  var myUid = options.uid !== undefined ?
+	    options.uid : process.getuid && process.getuid();
+	  var myGid = options.gid !== undefined ?
+	    options.gid : process.getgid && process.getgid();
+
+	  var u = parseInt('100', 8);
+	  var g = parseInt('010', 8);
+	  var o = parseInt('001', 8);
+	  var ug = u | g;
+
+	  var ret = (mod & o) ||
+	    (mod & g) && gid === myGid ||
+	    (mod & u) && uid === myUid ||
+	    (mod & ug) && myUid === 0;
+
+	  return ret
+	}
+	return mode;
+}
+
+var core;
+if (process.platform === 'win32' || commonjsGlobal.TESTING_WINDOWS) {
+  core = requireWindows();
+} else {
+  core = requireMode();
+}
+
+var isexe_1 = isexe$1;
+isexe$1.sync = sync;
+
+function isexe$1 (path, options, cb) {
+  if (typeof options === 'function') {
+    cb = options;
+    options = {};
+  }
+
+  if (!cb) {
+    if (typeof Promise !== 'function') {
+      throw new TypeError('callback not provided')
+    }
+
+    return new Promise(function (resolve, reject) {
+      isexe$1(path, options || {}, function (er, is) {
+        if (er) {
+          reject(er);
+        } else {
+          resolve(is);
+        }
+      });
+    })
+  }
+
+  core(path, options || {}, function (er, is) {
+    // ignore EACCES because that just means we aren't allowed to run it
+    if (er) {
+      if (er.code === 'EACCES' || options && options.ignoreErrors) {
+        er = null;
+        is = false;
+      }
+    }
+    cb(er, is);
+  });
+}
+
+function sync (path, options) {
+  // my kingdom for a filtered catch
+  try {
+    return core.sync(path, options || {})
+  } catch (er) {
+    if (options && options.ignoreErrors || er.code === 'EACCES') {
+      return false
+    } else {
+      throw er
+    }
+  }
+}
+
+const isexe = isexe_1;
+const { join, delimiter, sep, posix } = require$$0;
+
+const isWindows = process.platform === 'win32';
+
+// used to check for slashed in commands passed in. always checks for the posix
+// seperator on all platforms, and checks for the current separator when not on
+// a posix platform. don't use the isWindows check for this since that is mocked
+// in tests but we still need the code to actually work when called. that is also
+// why it is ignored from coverage.
+/* istanbul ignore next */
+const rSlash = new RegExp(`[${posix.sep}${sep === posix.sep ? '' : sep}]`.replace(/(\\)/g, '\\$1'));
+const rRel = new RegExp(`^\\.${rSlash.source}`);
+
+const getNotFoundError = (cmd) =>
+  Object.assign(new Error(`not found: ${cmd}`), { code: 'ENOENT' });
+
+const getPathInfo = (cmd, {
+  path: optPath = process.env.PATH,
+  pathExt: optPathExt = process.env.PATHEXT,
+  delimiter: optDelimiter = delimiter,
+}) => {
+  // If it has a slash, then we don't bother searching the pathenv.
+  // just check the file itself, and that's it.
+  const pathEnv = cmd.match(rSlash) ? [''] : [
+    // windows always checks the cwd first
+    ...(isWindows ? [process.cwd()] : []),
+    ...(optPath || /* istanbul ignore next: very unusual */ '').split(optDelimiter),
+  ];
+
+  if (isWindows) {
+    const pathExtExe = optPathExt || ['.EXE', '.CMD', '.BAT', '.COM'].join(optDelimiter);
+    const pathExt = pathExtExe.split(optDelimiter);
+    if (cmd.includes('.') && pathExt[0] !== '') {
+      pathExt.unshift('');
+    }
+    return { pathEnv, pathExt, pathExtExe }
+  }
+
+  return { pathEnv, pathExt: [''] }
+};
+
+const getPathPart = (raw, cmd) => {
+  const pathPart = /^".*"$/.test(raw) ? raw.slice(1, -1) : raw;
+  const prefix = !pathPart && rRel.test(cmd) ? cmd.slice(0, 2) : '';
+  return prefix + join(pathPart, cmd)
+};
+
+const which = async (cmd, opt = {}) => {
+  const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+  const found = [];
+
+  for (const envPart of pathEnv) {
+    const p = getPathPart(envPart, cmd);
+
+    for (const ext of pathExt) {
+      const withExt = p + ext;
+      const is = await isexe(withExt, { pathExt: pathExtExe, ignoreErrors: true });
+      if (is) {
+        if (!opt.all) {
+          return withExt
+        }
+        found.push(withExt);
+      }
+    }
+  }
+
+  if (opt.all && found.length) {
+    return found
+  }
+
+  if (opt.nothrow) {
+    return null
+  }
+
+  throw getNotFoundError(cmd)
+};
+
+const whichSync = (cmd, opt = {}) => {
+  const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+  const found = [];
+
+  for (const pathEnvPart of pathEnv) {
+    const p = getPathPart(pathEnvPart, cmd);
+
+    for (const ext of pathExt) {
+      const withExt = p + ext;
+      const is = isexe.sync(withExt, { pathExt: pathExtExe, ignoreErrors: true });
+      if (is) {
+        if (!opt.all) {
+          return withExt
+        }
+        found.push(withExt);
+      }
+    }
+  }
+
+  if (opt.all && found.length) {
+    return found
+  }
+
+  if (opt.nothrow) {
+    return null
+  }
+
+  throw getNotFoundError(cmd)
+};
+
+var lib$4 = which;
+which.sync = whichSync;
+
 var errorExports = {};
 var error = {
   get exports(){ return errorExports; },
@@ -655,7 +953,7 @@ internals$8.base = function (obj, baseProto, options) {
 
 var cache = {};
 
-var common = {};
+var common$1 = {};
 
 const name = "joi";
 const description = "Object schema validation";
@@ -663,7 +961,7 @@ const version = "17.7.0";
 const repository = "git://github.com/hapijs/joi";
 const main = "lib/index.js";
 const types$1 = "lib/index.d.ts";
-const browser = "dist/joi-browser.min.js";
+const browser$1 = "dist/joi-browser.min.js";
 const files = [
 	"lib/**/*",
 	"dist/*"
@@ -700,7 +998,7 @@ const _package = {
 	repository: repository,
 	main: main,
 	types: types$1,
-	browser: browser,
+	browser: browser$1,
 	files: files,
 	keywords: keywords,
 	dependencies: dependencies,
@@ -710,21 +1008,21 @@ const _package = {
 };
 
 const _package$1 = {
-  __proto__: null,
-  browser: browser,
-  default: _package,
-  dependencies: dependencies,
-  description: description,
-  devDependencies: devDependencies,
-  files: files,
-  keywords: keywords,
-  license: license,
-  main: main,
-  name: name,
-  repository: repository,
-  scripts: scripts,
-  types: types$1,
-  version: version
+	__proto__: null,
+	browser: browser$1,
+	default: _package,
+	dependencies: dependencies,
+	description: description,
+	devDependencies: devDependencies,
+	files: files,
+	keywords: keywords,
+	license: license,
+	main: main,
+	name: name,
+	repository: repository,
+	scripts: scripts,
+	types: types$1,
+	version: version
 };
 
 const require$$2 = /*@__PURE__*/getAugmentedNamespace(_package$1);
@@ -1606,7 +1904,7 @@ function requireAnnotate () {
 
 	const Clone = clone;
 
-	const Common = requireCommon();
+	const Common = requireCommon$1();
 
 
 	const internals = {
@@ -1788,7 +2086,7 @@ function requireErrors () {
 	(function (exports) {
 
 		const Annotate = requireAnnotate();
-		const Common = requireCommon();
+		const Common = requireCommon$1();
 		const Template = requireTemplate();
 
 
@@ -2070,7 +2368,7 @@ function requireRef () {
 		const Clone = clone;
 		const Reach = reach;
 
-		const Common = requireCommon();
+		const Common = requireCommon$1();
 
 		let Template;
 
@@ -2494,7 +2792,7 @@ function requireTemplate () {
 		const EscapeHtml = escapeHtml;
 		const Formula = lib$3;
 
-		const Common = requireCommon();
+		const Common = requireCommon$1();
 		const Errors = requireErrors();
 		const Ref = requireRef();
 
@@ -3116,11 +3414,11 @@ function requireMessages () {
 	return messages;
 }
 
-var hasRequiredCommon;
+var hasRequiredCommon$1;
 
-function requireCommon () {
-	if (hasRequiredCommon) return common;
-	hasRequiredCommon = 1;
+function requireCommon$1 () {
+	if (hasRequiredCommon$1) return common$1;
+	hasRequiredCommon$1 = 1;
 	(function (exports) {
 
 		const Assert = assert$1;
@@ -3337,8 +3635,8 @@ function requireCommon () {
 		        Assert(!Array.isArray(arg), 'Method no longer accepts array arguments:', method);
 		    }
 		};
-} (common));
-	return common;
+} (common$1));
+	return common$1;
 }
 
 var hasRequiredCache;
@@ -3350,7 +3648,7 @@ function requireCache () {
 	const Assert = assert$1;
 	const Clone = clone;
 
-	const Common = requireCommon();
+	const Common = requireCommon$1();
 
 
 	const internals = {
@@ -3502,7 +3800,7 @@ function requireCompile () {
 
 		const Assert = assert$1;
 
-		const Common = requireCommon();
+		const Common = requireCommon$1();
 		const Ref = requireRef();
 
 
@@ -3796,7 +4094,7 @@ function requireExtend () {
 	const Assert = assert$1;
 	const Clone = clone;
 
-	const Common = requireCommon();
+	const Common = requireCommon$1();
 	const Messages = requireMessages();
 
 
@@ -4117,7 +4415,7 @@ function requireManifest () {
 	const Assert = assert$1;
 	const Clone = clone;
 
-	const Common = requireCommon();
+	const Common = requireCommon$1();
 	const Messages = requireMessages();
 	const Ref = requireRef();
 	const Template = requireTemplate();
@@ -5369,7 +5667,7 @@ function requireModify () {
 
 		const Assert = assert$1;
 
-		const Common = requireCommon();
+		const Common = requireCommon$1();
 		const Ref = requireRef();
 
 
@@ -5650,7 +5948,7 @@ function requireState$1 () {
 	const Clone = clone;
 	const Reach = reach;
 
-	const Common = requireCommon();
+	const Common = requireCommon$1();
 
 
 	const internals = {
@@ -5812,7 +6110,7 @@ function requireValidator () {
 		const Ignore = ignore;
 		const Reach = reach;
 
-		const Common = requireCommon();
+		const Common = requireCommon$1();
 		const Errors = requireErrors();
 		const State = requireState$1();
 
@@ -6472,7 +6770,7 @@ function requireValues () {
 	const Assert = assert$1;
 	const DeepEqual = deepEqual;
 
-	const Common = requireCommon();
+	const Common = requireCommon$1();
 
 
 	const internals = {};
@@ -6746,7 +7044,7 @@ function requireBase () {
 	const Merge = merge$6;
 
 	const Cache = requireCache();
-	const Common = requireCommon();
+	const Common = requireCommon$1();
 	const Compile = requireCompile();
 	const Errors = requireErrors();
 	const Extend = requireExtend();
@@ -7820,7 +8118,7 @@ function requireAny () {
 	const Assert = assert$1;
 
 	const Base = requireBase();
-	const Common = requireCommon();
+	const Common = requireCommon$1();
 	const Messages = requireMessages();
 
 
@@ -8000,7 +8298,7 @@ function requireAlternatives () {
 	const Merge = merge$6;
 
 	const Any = requireAny();
-	const Common = requireCommon();
+	const Common = requireCommon$1();
 	const Compile = requireCompile();
 	const Errors = requireErrors();
 	const Ref = requireRef();
@@ -8364,7 +8662,7 @@ function requireArray () {
 	const Reach = reach;
 
 	const Any = requireAny();
-	const Common = requireCommon();
+	const Common = requireCommon$1();
 	const Compile = requireCompile();
 
 
@@ -9176,7 +9474,7 @@ function requireBoolean () {
 	const Assert = assert$1;
 
 	const Any = requireAny();
-	const Common = requireCommon();
+	const Common = requireCommon$1();
 	const Values = requireValues();
 
 
@@ -9334,7 +9632,7 @@ function requireDate () {
 	const Assert = assert$1;
 
 	const Any = requireAny();
-	const Common = requireCommon();
+	const Common = requireCommon$1();
 	const Template = requireTemplate();
 
 
@@ -9905,7 +10203,7 @@ function requireKeys () {
 	const Topo = lib$1;
 
 	const Any = requireAny();
-	const Common = requireCommon();
+	const Common = requireCommon$1();
 	const Compile = requireCompile();
 	const Errors = requireErrors();
 	const Ref = requireRef();
@@ -11075,7 +11373,7 @@ function requireLink () {
 	const Assert = assert$1;
 
 	const Any = requireAny();
-	const Common = requireCommon();
+	const Common = requireCommon$1();
 	const Compile = requireCompile();
 	const Errors = requireErrors();
 
@@ -11251,7 +11549,7 @@ function requireNumber () {
 	const Assert = assert$1;
 
 	const Any = requireAny();
-	const Common = requireCommon();
+	const Common = requireCommon$1();
 
 
 	const internals = {
@@ -11649,7 +11947,7 @@ var errors = {};
 
 (function (exports) {
 
-	const Url = require$$0;
+	const Url = require$$0$1;
 
 	const Errors = errors;
 
@@ -11774,7 +12072,7 @@ var errors = {};
 
 var email = {};
 
-const Util = require$$0$1;
+const Util = require$$1;
 
 const Domain = domain;
 const Errors = errors;
@@ -13736,7 +14034,7 @@ function requireString () {
 	const Uri = uri;
 
 	const Any = requireAny();
-	const Common = requireCommon();
+	const Common = requireCommon$1();
 
 
 	const internals = {
@@ -14676,7 +14974,7 @@ function requireBinary () {
 	const Assert = assert$1;
 
 	const Any = requireAny();
-	const Common = requireCommon();
+	const Common = requireCommon$1();
 
 
 	binary = Any.extend({
@@ -14780,7 +15078,7 @@ function requireLib () {
 	const Clone = clone;
 
 	const Cache = requireCache();
-	const Common = requireCommon();
+	const Common = requireCommon$1();
 	const Compile = requireCompile();
 	const Errors = requireErrors();
 	const Extend = requireExtend();
@@ -16393,6 +16691,1204 @@ var followRedirects = {
   set exports(v){ followRedirectsExports = v; },
 };
 
+var srcExports = {};
+var src = {
+  get exports(){ return srcExports; },
+  set exports(v){ srcExports = v; },
+};
+
+var browserExports = {};
+var browser = {
+  get exports(){ return browserExports; },
+  set exports(v){ browserExports = v; },
+};
+
+/**
+ * Helpers.
+ */
+
+var ms;
+var hasRequiredMs;
+
+function requireMs () {
+	if (hasRequiredMs) return ms;
+	hasRequiredMs = 1;
+	var s = 1000;
+	var m = s * 60;
+	var h = m * 60;
+	var d = h * 24;
+	var w = d * 7;
+	var y = d * 365.25;
+
+	/**
+	 * Parse or format the given `val`.
+	 *
+	 * Options:
+	 *
+	 *  - `long` verbose formatting [false]
+	 *
+	 * @param {String|Number} val
+	 * @param {Object} [options]
+	 * @throws {Error} throw an error if val is not a non-empty string or a number
+	 * @return {String|Number}
+	 * @api public
+	 */
+
+	ms = function(val, options) {
+	  options = options || {};
+	  var type = typeof val;
+	  if (type === 'string' && val.length > 0) {
+	    return parse(val);
+	  } else if (type === 'number' && isFinite(val)) {
+	    return options.long ? fmtLong(val) : fmtShort(val);
+	  }
+	  throw new Error(
+	    'val is not a non-empty string or a valid number. val=' +
+	      JSON.stringify(val)
+	  );
+	};
+
+	/**
+	 * Parse the given `str` and return milliseconds.
+	 *
+	 * @param {String} str
+	 * @return {Number}
+	 * @api private
+	 */
+
+	function parse(str) {
+	  str = String(str);
+	  if (str.length > 100) {
+	    return;
+	  }
+	  var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+	    str
+	  );
+	  if (!match) {
+	    return;
+	  }
+	  var n = parseFloat(match[1]);
+	  var type = (match[2] || 'ms').toLowerCase();
+	  switch (type) {
+	    case 'years':
+	    case 'year':
+	    case 'yrs':
+	    case 'yr':
+	    case 'y':
+	      return n * y;
+	    case 'weeks':
+	    case 'week':
+	    case 'w':
+	      return n * w;
+	    case 'days':
+	    case 'day':
+	    case 'd':
+	      return n * d;
+	    case 'hours':
+	    case 'hour':
+	    case 'hrs':
+	    case 'hr':
+	    case 'h':
+	      return n * h;
+	    case 'minutes':
+	    case 'minute':
+	    case 'mins':
+	    case 'min':
+	    case 'm':
+	      return n * m;
+	    case 'seconds':
+	    case 'second':
+	    case 'secs':
+	    case 'sec':
+	    case 's':
+	      return n * s;
+	    case 'milliseconds':
+	    case 'millisecond':
+	    case 'msecs':
+	    case 'msec':
+	    case 'ms':
+	      return n;
+	    default:
+	      return undefined;
+	  }
+	}
+
+	/**
+	 * Short format for `ms`.
+	 *
+	 * @param {Number} ms
+	 * @return {String}
+	 * @api private
+	 */
+
+	function fmtShort(ms) {
+	  var msAbs = Math.abs(ms);
+	  if (msAbs >= d) {
+	    return Math.round(ms / d) + 'd';
+	  }
+	  if (msAbs >= h) {
+	    return Math.round(ms / h) + 'h';
+	  }
+	  if (msAbs >= m) {
+	    return Math.round(ms / m) + 'm';
+	  }
+	  if (msAbs >= s) {
+	    return Math.round(ms / s) + 's';
+	  }
+	  return ms + 'ms';
+	}
+
+	/**
+	 * Long format for `ms`.
+	 *
+	 * @param {Number} ms
+	 * @return {String}
+	 * @api private
+	 */
+
+	function fmtLong(ms) {
+	  var msAbs = Math.abs(ms);
+	  if (msAbs >= d) {
+	    return plural(ms, msAbs, d, 'day');
+	  }
+	  if (msAbs >= h) {
+	    return plural(ms, msAbs, h, 'hour');
+	  }
+	  if (msAbs >= m) {
+	    return plural(ms, msAbs, m, 'minute');
+	  }
+	  if (msAbs >= s) {
+	    return plural(ms, msAbs, s, 'second');
+	  }
+	  return ms + ' ms';
+	}
+
+	/**
+	 * Pluralization helper.
+	 */
+
+	function plural(ms, msAbs, n, name) {
+	  var isPlural = msAbs >= n * 1.5;
+	  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
+	}
+	return ms;
+}
+
+var common;
+var hasRequiredCommon;
+
+function requireCommon () {
+	if (hasRequiredCommon) return common;
+	hasRequiredCommon = 1;
+	/**
+	 * This is the common logic for both the Node.js and web browser
+	 * implementations of `debug()`.
+	 */
+
+	function setup(env) {
+		createDebug.debug = createDebug;
+		createDebug.default = createDebug;
+		createDebug.coerce = coerce;
+		createDebug.disable = disable;
+		createDebug.enable = enable;
+		createDebug.enabled = enabled;
+		createDebug.humanize = requireMs();
+		createDebug.destroy = destroy;
+
+		Object.keys(env).forEach(key => {
+			createDebug[key] = env[key];
+		});
+
+		/**
+		* The currently active debug mode names, and names to skip.
+		*/
+
+		createDebug.names = [];
+		createDebug.skips = [];
+
+		/**
+		* Map of special "%n" handling functions, for the debug "format" argument.
+		*
+		* Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
+		*/
+		createDebug.formatters = {};
+
+		/**
+		* Selects a color for a debug namespace
+		* @param {String} namespace The namespace string for the debug instance to be colored
+		* @return {Number|String} An ANSI color code for the given namespace
+		* @api private
+		*/
+		function selectColor(namespace) {
+			let hash = 0;
+
+			for (let i = 0; i < namespace.length; i++) {
+				hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
+				hash |= 0; // Convert to 32bit integer
+			}
+
+			return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+		}
+		createDebug.selectColor = selectColor;
+
+		/**
+		* Create a debugger with the given `namespace`.
+		*
+		* @param {String} namespace
+		* @return {Function}
+		* @api public
+		*/
+		function createDebug(namespace) {
+			let prevTime;
+			let enableOverride = null;
+			let namespacesCache;
+			let enabledCache;
+
+			function debug(...args) {
+				// Disabled?
+				if (!debug.enabled) {
+					return;
+				}
+
+				const self = debug;
+
+				// Set `diff` timestamp
+				const curr = Number(new Date());
+				const ms = curr - (prevTime || curr);
+				self.diff = ms;
+				self.prev = prevTime;
+				self.curr = curr;
+				prevTime = curr;
+
+				args[0] = createDebug.coerce(args[0]);
+
+				if (typeof args[0] !== 'string') {
+					// Anything else let's inspect with %O
+					args.unshift('%O');
+				}
+
+				// Apply any `formatters` transformations
+				let index = 0;
+				args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+					// If we encounter an escaped % then don't increase the array index
+					if (match === '%%') {
+						return '%';
+					}
+					index++;
+					const formatter = createDebug.formatters[format];
+					if (typeof formatter === 'function') {
+						const val = args[index];
+						match = formatter.call(self, val);
+
+						// Now we need to remove `args[index]` since it's inlined in the `format`
+						args.splice(index, 1);
+						index--;
+					}
+					return match;
+				});
+
+				// Apply env-specific formatting (colors, etc.)
+				createDebug.formatArgs.call(self, args);
+
+				const logFn = self.log || createDebug.log;
+				logFn.apply(self, args);
+			}
+
+			debug.namespace = namespace;
+			debug.useColors = createDebug.useColors();
+			debug.color = createDebug.selectColor(namespace);
+			debug.extend = extend;
+			debug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release.
+
+			Object.defineProperty(debug, 'enabled', {
+				enumerable: true,
+				configurable: false,
+				get: () => {
+					if (enableOverride !== null) {
+						return enableOverride;
+					}
+					if (namespacesCache !== createDebug.namespaces) {
+						namespacesCache = createDebug.namespaces;
+						enabledCache = createDebug.enabled(namespace);
+					}
+
+					return enabledCache;
+				},
+				set: v => {
+					enableOverride = v;
+				}
+			});
+
+			// Env-specific initialization logic for debug instances
+			if (typeof createDebug.init === 'function') {
+				createDebug.init(debug);
+			}
+
+			return debug;
+		}
+
+		function extend(namespace, delimiter) {
+			const newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
+			newDebug.log = this.log;
+			return newDebug;
+		}
+
+		/**
+		* Enables a debug mode by namespaces. This can include modes
+		* separated by a colon and wildcards.
+		*
+		* @param {String} namespaces
+		* @api public
+		*/
+		function enable(namespaces) {
+			createDebug.save(namespaces);
+			createDebug.namespaces = namespaces;
+
+			createDebug.names = [];
+			createDebug.skips = [];
+
+			let i;
+			const split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
+			const len = split.length;
+
+			for (i = 0; i < len; i++) {
+				if (!split[i]) {
+					// ignore empty strings
+					continue;
+				}
+
+				namespaces = split[i].replace(/\*/g, '.*?');
+
+				if (namespaces[0] === '-') {
+					createDebug.skips.push(new RegExp('^' + namespaces.slice(1) + '$'));
+				} else {
+					createDebug.names.push(new RegExp('^' + namespaces + '$'));
+				}
+			}
+		}
+
+		/**
+		* Disable debug output.
+		*
+		* @return {String} namespaces
+		* @api public
+		*/
+		function disable() {
+			const namespaces = [
+				...createDebug.names.map(toNamespace),
+				...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace)
+			].join(',');
+			createDebug.enable('');
+			return namespaces;
+		}
+
+		/**
+		* Returns true if the given mode name is enabled, false otherwise.
+		*
+		* @param {String} name
+		* @return {Boolean}
+		* @api public
+		*/
+		function enabled(name) {
+			if (name[name.length - 1] === '*') {
+				return true;
+			}
+
+			let i;
+			let len;
+
+			for (i = 0, len = createDebug.skips.length; i < len; i++) {
+				if (createDebug.skips[i].test(name)) {
+					return false;
+				}
+			}
+
+			for (i = 0, len = createDebug.names.length; i < len; i++) {
+				if (createDebug.names[i].test(name)) {
+					return true;
+				}
+			}
+
+			return false;
+		}
+
+		/**
+		* Convert regexp to namespace
+		*
+		* @param {RegExp} regxep
+		* @return {String} namespace
+		* @api private
+		*/
+		function toNamespace(regexp) {
+			return regexp.toString()
+				.substring(2, regexp.toString().length - 2)
+				.replace(/\.\*\?$/, '*');
+		}
+
+		/**
+		* Coerce `val`.
+		*
+		* @param {Mixed} val
+		* @return {Mixed}
+		* @api private
+		*/
+		function coerce(val) {
+			if (val instanceof Error) {
+				return val.stack || val.message;
+			}
+			return val;
+		}
+
+		/**
+		* XXX DO NOT USE. This is a temporary stub function.
+		* XXX It WILL be removed in the next major release.
+		*/
+		function destroy() {
+			console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+		}
+
+		createDebug.enable(createDebug.load());
+
+		return createDebug;
+	}
+
+	common = setup;
+	return common;
+}
+
+/* eslint-env browser */
+
+var hasRequiredBrowser;
+
+function requireBrowser () {
+	if (hasRequiredBrowser) return browserExports;
+	hasRequiredBrowser = 1;
+	(function (module, exports) {
+		/**
+		 * This is the web browser implementation of `debug()`.
+		 */
+
+		exports.formatArgs = formatArgs;
+		exports.save = save;
+		exports.load = load;
+		exports.useColors = useColors;
+		exports.storage = localstorage();
+		exports.destroy = (() => {
+			let warned = false;
+
+			return () => {
+				if (!warned) {
+					warned = true;
+					console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+				}
+			};
+		})();
+
+		/**
+		 * Colors.
+		 */
+
+		exports.colors = [
+			'#0000CC',
+			'#0000FF',
+			'#0033CC',
+			'#0033FF',
+			'#0066CC',
+			'#0066FF',
+			'#0099CC',
+			'#0099FF',
+			'#00CC00',
+			'#00CC33',
+			'#00CC66',
+			'#00CC99',
+			'#00CCCC',
+			'#00CCFF',
+			'#3300CC',
+			'#3300FF',
+			'#3333CC',
+			'#3333FF',
+			'#3366CC',
+			'#3366FF',
+			'#3399CC',
+			'#3399FF',
+			'#33CC00',
+			'#33CC33',
+			'#33CC66',
+			'#33CC99',
+			'#33CCCC',
+			'#33CCFF',
+			'#6600CC',
+			'#6600FF',
+			'#6633CC',
+			'#6633FF',
+			'#66CC00',
+			'#66CC33',
+			'#9900CC',
+			'#9900FF',
+			'#9933CC',
+			'#9933FF',
+			'#99CC00',
+			'#99CC33',
+			'#CC0000',
+			'#CC0033',
+			'#CC0066',
+			'#CC0099',
+			'#CC00CC',
+			'#CC00FF',
+			'#CC3300',
+			'#CC3333',
+			'#CC3366',
+			'#CC3399',
+			'#CC33CC',
+			'#CC33FF',
+			'#CC6600',
+			'#CC6633',
+			'#CC9900',
+			'#CC9933',
+			'#CCCC00',
+			'#CCCC33',
+			'#FF0000',
+			'#FF0033',
+			'#FF0066',
+			'#FF0099',
+			'#FF00CC',
+			'#FF00FF',
+			'#FF3300',
+			'#FF3333',
+			'#FF3366',
+			'#FF3399',
+			'#FF33CC',
+			'#FF33FF',
+			'#FF6600',
+			'#FF6633',
+			'#FF9900',
+			'#FF9933',
+			'#FFCC00',
+			'#FFCC33'
+		];
+
+		/**
+		 * Currently only WebKit-based Web Inspectors, Firefox >= v31,
+		 * and the Firebug extension (any Firefox version) are known
+		 * to support "%c" CSS customizations.
+		 *
+		 * TODO: add a `localStorage` variable to explicitly enable/disable colors
+		 */
+
+		// eslint-disable-next-line complexity
+		function useColors() {
+			// NB: In an Electron preload script, document will be defined but not fully
+			// initialized. Since we know we're in Chrome, we'll just detect this case
+			// explicitly
+			if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
+				return true;
+			}
+
+			// Internet Explorer and Edge do not support colors.
+			if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+				return false;
+			}
+
+			// Is webkit? http://stackoverflow.com/a/16459606/376773
+			// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
+			return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
+				// Is firebug? http://stackoverflow.com/a/398120/376773
+				(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
+				// Is firefox >= v31?
+				// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+				(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
+				// Double check webkit in userAgent just in case we are in a worker
+				(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
+		}
+
+		/**
+		 * Colorize log arguments if enabled.
+		 *
+		 * @api public
+		 */
+
+		function formatArgs(args) {
+			args[0] = (this.useColors ? '%c' : '') +
+				this.namespace +
+				(this.useColors ? ' %c' : ' ') +
+				args[0] +
+				(this.useColors ? '%c ' : ' ') +
+				'+' + module.exports.humanize(this.diff);
+
+			if (!this.useColors) {
+				return;
+			}
+
+			const c = 'color: ' + this.color;
+			args.splice(1, 0, c, 'color: inherit');
+
+			// The final "%c" is somewhat tricky, because there could be other
+			// arguments passed either before or after the %c, so we need to
+			// figure out the correct index to insert the CSS into
+			let index = 0;
+			let lastC = 0;
+			args[0].replace(/%[a-zA-Z%]/g, match => {
+				if (match === '%%') {
+					return;
+				}
+				index++;
+				if (match === '%c') {
+					// We only are interested in the *last* %c
+					// (the user may have provided their own)
+					lastC = index;
+				}
+			});
+
+			args.splice(lastC, 0, c);
+		}
+
+		/**
+		 * Invokes `console.debug()` when available.
+		 * No-op when `console.debug` is not a "function".
+		 * If `console.debug` is not available, falls back
+		 * to `console.log`.
+		 *
+		 * @api public
+		 */
+		exports.log = console.debug || console.log || (() => {});
+
+		/**
+		 * Save `namespaces`.
+		 *
+		 * @param {String} namespaces
+		 * @api private
+		 */
+		function save(namespaces) {
+			try {
+				if (namespaces) {
+					exports.storage.setItem('debug', namespaces);
+				} else {
+					exports.storage.removeItem('debug');
+				}
+			} catch (error) {
+				// Swallow
+				// XXX (@Qix-) should we be logging these?
+			}
+		}
+
+		/**
+		 * Load `namespaces`.
+		 *
+		 * @return {String} returns the previously persisted debug modes
+		 * @api private
+		 */
+		function load() {
+			let r;
+			try {
+				r = exports.storage.getItem('debug');
+			} catch (error) {
+				// Swallow
+				// XXX (@Qix-) should we be logging these?
+			}
+
+			// If debug isn't set in LS, and we're in Electron, try to load $DEBUG
+			if (!r && typeof process !== 'undefined' && 'env' in process) {
+				r = process.env.DEBUG;
+			}
+
+			return r;
+		}
+
+		/**
+		 * Localstorage attempts to return the localstorage.
+		 *
+		 * This is necessary because safari throws
+		 * when a user disables cookies/localstorage
+		 * and you attempt to access it.
+		 *
+		 * @return {LocalStorage}
+		 * @api private
+		 */
+
+		function localstorage() {
+			try {
+				// TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
+				// The Browser also has localStorage in the global context.
+				return localStorage;
+			} catch (error) {
+				// Swallow
+				// XXX (@Qix-) should we be logging these?
+			}
+		}
+
+		module.exports = requireCommon()(exports);
+
+		const {formatters} = module.exports;
+
+		/**
+		 * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
+		 */
+
+		formatters.j = function (v) {
+			try {
+				return JSON.stringify(v);
+			} catch (error) {
+				return '[UnexpectedJSONParseError]: ' + error.message;
+			}
+		};
+} (browser, browserExports));
+	return browserExports;
+}
+
+var nodeExports = {};
+var node = {
+  get exports(){ return nodeExports; },
+  set exports(v){ nodeExports = v; },
+};
+
+var hasFlag;
+var hasRequiredHasFlag;
+
+function requireHasFlag () {
+	if (hasRequiredHasFlag) return hasFlag;
+	hasRequiredHasFlag = 1;
+	hasFlag = (flag, argv) => {
+		argv = argv || process.argv;
+		const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
+		const pos = argv.indexOf(prefix + flag);
+		const terminatorPos = argv.indexOf('--');
+		return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
+	};
+	return hasFlag;
+}
+
+var supportsColor_1;
+var hasRequiredSupportsColor;
+
+function requireSupportsColor () {
+	if (hasRequiredSupportsColor) return supportsColor_1;
+	hasRequiredSupportsColor = 1;
+	const os = require$$1$1;
+	const hasFlag = requireHasFlag();
+
+	const env = process.env;
+
+	let forceColor;
+	if (hasFlag('no-color') ||
+		hasFlag('no-colors') ||
+		hasFlag('color=false')) {
+		forceColor = false;
+	} else if (hasFlag('color') ||
+		hasFlag('colors') ||
+		hasFlag('color=true') ||
+		hasFlag('color=always')) {
+		forceColor = true;
+	}
+	if ('FORCE_COLOR' in env) {
+		forceColor = env.FORCE_COLOR.length === 0 || parseInt(env.FORCE_COLOR, 10) !== 0;
+	}
+
+	function translateLevel(level) {
+		if (level === 0) {
+			return false;
+		}
+
+		return {
+			level,
+			hasBasic: true,
+			has256: level >= 2,
+			has16m: level >= 3
+		};
+	}
+
+	function supportsColor(stream) {
+		if (forceColor === false) {
+			return 0;
+		}
+
+		if (hasFlag('color=16m') ||
+			hasFlag('color=full') ||
+			hasFlag('color=truecolor')) {
+			return 3;
+		}
+
+		if (hasFlag('color=256')) {
+			return 2;
+		}
+
+		if (stream && !stream.isTTY && forceColor !== true) {
+			return 0;
+		}
+
+		const min = forceColor ? 1 : 0;
+
+		if (process.platform === 'win32') {
+			// Node.js 7.5.0 is the first version of Node.js to include a patch to
+			// libuv that enables 256 color output on Windows. Anything earlier and it
+			// won't work. However, here we target Node.js 8 at minimum as it is an LTS
+			// release, and Node.js 7 is not. Windows 10 build 10586 is the first Windows
+			// release that supports 256 colors. Windows 10 build 14931 is the first release
+			// that supports 16m/TrueColor.
+			const osRelease = os.release().split('.');
+			if (
+				Number(process.versions.node.split('.')[0]) >= 8 &&
+				Number(osRelease[0]) >= 10 &&
+				Number(osRelease[2]) >= 10586
+			) {
+				return Number(osRelease[2]) >= 14931 ? 3 : 2;
+			}
+
+			return 1;
+		}
+
+		if ('CI' in env) {
+			if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
+				return 1;
+			}
+
+			return min;
+		}
+
+		if ('TEAMCITY_VERSION' in env) {
+			return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+		}
+
+		if (env.COLORTERM === 'truecolor') {
+			return 3;
+		}
+
+		if ('TERM_PROGRAM' in env) {
+			const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+
+			switch (env.TERM_PROGRAM) {
+				case 'iTerm.app':
+					return version >= 3 ? 3 : 2;
+				case 'Apple_Terminal':
+					return 2;
+				// No default
+			}
+		}
+
+		if (/-256(color)?$/i.test(env.TERM)) {
+			return 2;
+		}
+
+		if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+			return 1;
+		}
+
+		if ('COLORTERM' in env) {
+			return 1;
+		}
+
+		if (env.TERM === 'dumb') {
+			return min;
+		}
+
+		return min;
+	}
+
+	function getSupportLevel(stream) {
+		const level = supportsColor(stream);
+		return translateLevel(level);
+	}
+
+	supportsColor_1 = {
+		supportsColor: getSupportLevel,
+		stdout: getSupportLevel(process.stdout),
+		stderr: getSupportLevel(process.stderr)
+	};
+	return supportsColor_1;
+}
+
+/**
+ * Module dependencies.
+ */
+
+var hasRequiredNode;
+
+function requireNode () {
+	if (hasRequiredNode) return nodeExports;
+	hasRequiredNode = 1;
+	(function (module, exports) {
+		const tty = require$$0$2;
+		const util = require$$1;
+
+		/**
+		 * This is the Node.js implementation of `debug()`.
+		 */
+
+		exports.init = init;
+		exports.log = log;
+		exports.formatArgs = formatArgs;
+		exports.save = save;
+		exports.load = load;
+		exports.useColors = useColors;
+		exports.destroy = util.deprecate(
+			() => {},
+			'Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.'
+		);
+
+		/**
+		 * Colors.
+		 */
+
+		exports.colors = [6, 2, 3, 4, 5, 1];
+
+		try {
+			// Optional dependency (as in, doesn't need to be installed, NOT like optionalDependencies in package.json)
+			// eslint-disable-next-line import/no-extraneous-dependencies
+			const supportsColor = requireSupportsColor();
+
+			if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
+				exports.colors = [
+					20,
+					21,
+					26,
+					27,
+					32,
+					33,
+					38,
+					39,
+					40,
+					41,
+					42,
+					43,
+					44,
+					45,
+					56,
+					57,
+					62,
+					63,
+					68,
+					69,
+					74,
+					75,
+					76,
+					77,
+					78,
+					79,
+					80,
+					81,
+					92,
+					93,
+					98,
+					99,
+					112,
+					113,
+					128,
+					129,
+					134,
+					135,
+					148,
+					149,
+					160,
+					161,
+					162,
+					163,
+					164,
+					165,
+					166,
+					167,
+					168,
+					169,
+					170,
+					171,
+					172,
+					173,
+					178,
+					179,
+					184,
+					185,
+					196,
+					197,
+					198,
+					199,
+					200,
+					201,
+					202,
+					203,
+					204,
+					205,
+					206,
+					207,
+					208,
+					209,
+					214,
+					215,
+					220,
+					221
+				];
+			}
+		} catch (error) {
+			// Swallow - we only care if `supports-color` is available; it doesn't have to be.
+		}
+
+		/**
+		 * Build up the default `inspectOpts` object from the environment variables.
+		 *
+		 *   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
+		 */
+
+		exports.inspectOpts = Object.keys(process.env).filter(key => {
+			return /^debug_/i.test(key);
+		}).reduce((obj, key) => {
+			// Camel-case
+			const prop = key
+				.substring(6)
+				.toLowerCase()
+				.replace(/_([a-z])/g, (_, k) => {
+					return k.toUpperCase();
+				});
+
+			// Coerce string value into JS value
+			let val = process.env[key];
+			if (/^(yes|on|true|enabled)$/i.test(val)) {
+				val = true;
+			} else if (/^(no|off|false|disabled)$/i.test(val)) {
+				val = false;
+			} else if (val === 'null') {
+				val = null;
+			} else {
+				val = Number(val);
+			}
+
+			obj[prop] = val;
+			return obj;
+		}, {});
+
+		/**
+		 * Is stdout a TTY? Colored output is enabled when `true`.
+		 */
+
+		function useColors() {
+			return 'colors' in exports.inspectOpts ?
+				Boolean(exports.inspectOpts.colors) :
+				tty.isatty(process.stderr.fd);
+		}
+
+		/**
+		 * Adds ANSI color escape codes if enabled.
+		 *
+		 * @api public
+		 */
+
+		function formatArgs(args) {
+			const {namespace: name, useColors} = this;
+
+			if (useColors) {
+				const c = this.color;
+				const colorCode = '\u001B[3' + (c < 8 ? c : '8;5;' + c);
+				const prefix = `  ${colorCode};1m${name} \u001B[0m`;
+
+				args[0] = prefix + args[0].split('\n').join('\n' + prefix);
+				args.push(colorCode + 'm+' + module.exports.humanize(this.diff) + '\u001B[0m');
+			} else {
+				args[0] = getDate() + name + ' ' + args[0];
+			}
+		}
+
+		function getDate() {
+			if (exports.inspectOpts.hideDate) {
+				return '';
+			}
+			return new Date().toISOString() + ' ';
+		}
+
+		/**
+		 * Invokes `util.format()` with the specified arguments and writes to stderr.
+		 */
+
+		function log(...args) {
+			return process.stderr.write(util.format(...args) + '\n');
+		}
+
+		/**
+		 * Save `namespaces`.
+		 *
+		 * @param {String} namespaces
+		 * @api private
+		 */
+		function save(namespaces) {
+			if (namespaces) {
+				process.env.DEBUG = namespaces;
+			} else {
+				// If you set a process.env field to null or undefined, it gets cast to the
+				// string 'null' or 'undefined'. Just delete instead.
+				delete process.env.DEBUG;
+			}
+		}
+
+		/**
+		 * Load `namespaces`.
+		 *
+		 * @return {String} returns the previously persisted debug modes
+		 * @api private
+		 */
+
+		function load() {
+			return process.env.DEBUG;
+		}
+
+		/**
+		 * Init logic for `debug` instances.
+		 *
+		 * Create a new `inspectOpts` object in case `useColors` is set
+		 * differently for a particular `debug` instance.
+		 */
+
+		function init(debug) {
+			debug.inspectOpts = {};
+
+			const keys = Object.keys(exports.inspectOpts);
+			for (let i = 0; i < keys.length; i++) {
+				debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+			}
+		}
+
+		module.exports = requireCommon()(exports);
+
+		const {formatters} = module.exports;
+
+		/**
+		 * Map %o to `util.inspect()`, all on a single line.
+		 */
+
+		formatters.o = function (v) {
+			this.inspectOpts.colors = this.useColors;
+			return util.inspect(v, this.inspectOpts)
+				.split('\n')
+				.map(str => str.trim())
+				.join(' ');
+		};
+
+		/**
+		 * Map %O to `util.inspect()`, allowing multiple lines if needed.
+		 */
+
+		formatters.O = function (v) {
+			this.inspectOpts.colors = this.useColors;
+			return util.inspect(v, this.inspectOpts);
+		};
+} (node, nodeExports));
+	return nodeExports;
+}
+
+/**
+ * Detect Electron renderer / nwjs process, which is node, but we should
+ * treat as a browser.
+ */
+
+var hasRequiredSrc;
+
+function requireSrc () {
+	if (hasRequiredSrc) return srcExports;
+	hasRequiredSrc = 1;
+	(function (module) {
+		if (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) {
+			module.exports = requireBrowser();
+		} else {
+			module.exports = requireNode();
+		}
+} (src));
+	return srcExports;
+}
+
 var debug$1;
 
 var debug_1 = function () {
@@ -16409,12 +17905,12 @@ var debug_1 = function () {
   debug$1.apply(null, arguments);
 };
 
-var url$1 = require$$0;
+var url$1 = require$$0$1;
 var URL$1 = url$1.URL;
-var http$1 = require$$1;
+var http$1 = require$$1$2;
 var https$2 = require$$2$1;
-var Writable = require$$0$2.Writable;
-var assert = require$$0$3;
+var Writable = require$$0$3.Writable;
+var assert = require$$4;
 var debug = debug_1;
 
 // Create handlers that pass events from native requests
@@ -17039,11 +18535,11 @@ var utils$6 = utils$c;
 var settle = settle$1;
 var buildFullPath$1 = buildFullPath$2;
 var buildURL$1 = buildURL$2;
-var http = require$$1;
+var http = require$$1$2;
 var https$1 = require$$2$1;
 var httpFollow = followRedirectsExports.http;
 var httpsFollow = followRedirectsExports.https;
-var url = require$$0;
+var url = require$$0$1;
 var zlib = require$$0$4;
 var VERSION$1 = data.version;
 var transitionalDefaults$1 = transitional;
@@ -17468,8 +18964,8 @@ var hasRequiredDelayed_stream;
 function requireDelayed_stream () {
 	if (hasRequiredDelayed_stream) return delayed_stream;
 	hasRequiredDelayed_stream = 1;
-	var Stream = require$$0$2.Stream;
-	var util = require$$0$1;
+	var Stream = require$$0$3.Stream;
+	var util = require$$1;
 
 	delayed_stream = DelayedStream;
 	function DelayedStream() {
@@ -17584,8 +19080,8 @@ var hasRequiredCombined_stream;
 function requireCombined_stream () {
 	if (hasRequiredCombined_stream) return combined_stream;
 	hasRequiredCombined_stream = 1;
-	var util = require$$0$1;
-	var Stream = require$$0$2.Stream;
+	var util = require$$1;
+	var Stream = require$$0$3.Stream;
 	var DelayedStream = requireDelayed_stream();
 
 	combined_stream = CombinedStream;
@@ -28556,7 +30052,7 @@ function requireMimeTypes () {
 		 */
 
 		var db = requireMimeDb();
-		var extname = require$$1$1.extname;
+		var extname = require$$0.extname;
 
 		/**
 		 * Module variables.
@@ -29225,13 +30721,13 @@ function requireForm_data () {
 	if (hasRequiredForm_data) return form_data;
 	hasRequiredForm_data = 1;
 	var CombinedStream = requireCombined_stream();
-	var util = require$$0$1;
-	var path = require$$1$1;
-	var http = require$$1;
+	var util = require$$1;
+	var path = require$$0;
+	var http = require$$1$2;
 	var https = require$$2$1;
-	var parseUrl = require$$0.parse;
-	var fs = require$$0__default;
-	var Stream = require$$0$2.Stream;
+	var parseUrl = require$$0$1.parse;
+	var fs = fs__default;
+	var Stream = require$$0$3.Stream;
 	var mime = requireMimeTypes();
 	var asynckit = requireAsynckit();
 	var populate = requirePopulate();
@@ -39667,12 +41163,12 @@ race$1.race = race;
 	
 } (operators));
 
-const fs = require$$0__default;
-const { promisify } = require$$0$1;
+const fs = fs__default;
+const { promisify } = require$$1;
 const Joi = requireLib();
 const https = require$$2$1;
-const net = require$$0$5;
-const util = require$$0$1;
+const net = require$$3;
+const util = require$$1;
 const axiosPkg = axiosExports$1.default;
 const axiosHttpAdapter = http_1;
 const { isBoolean, isEmpty, negate, noop, once, partial, pick, zip } = fp;
@@ -40073,7 +41569,9 @@ async function setup(nuxt, _functions, options) {
   let url = `http://localhost:${port}`;
   let loaded = false;
   let promise = null;
-  async function start() {
+  const mode = options?.mode || "local-serve";
+  const computerHostName = options.tunnel?.name || hostname().split(".").join("");
+  async function startCodeServer() {
     if (options?.reuseExistingServer && !await checkPort(port)) {
       loaded = true;
       url = `http://localhost:${port}/?folder=${encodeURIComponent(nuxt.options.rootDir)}`;
@@ -40100,6 +41598,34 @@ async function setup(nuxt, _functions, options) {
     await new Promise((resolve) => setTimeout(resolve, 2e3));
     loaded = true;
   }
+  async function startCodeTunnel() {
+    const { stdout: currentDir } = await execa("pwd");
+    url = `https://vscode.dev/tunnel/${computerHostName}${currentDir}`;
+    logger.info(LOG_PREFIX, `Starting VS Code tunnel at ${url} ...`);
+    const command = execa("code", [
+      "tunnel",
+      "--accept-server-license-terms",
+      "--name",
+      `${computerHostName}`
+    ]);
+    command.stderr?.pipe(process.stderr);
+    command.stdout?.pipe(process.stdout);
+    nuxt.hook("close", () => {
+      command.kill();
+    });
+    await waitOn_1({
+      resources: [url],
+      timeout: 2e4
+    });
+    await new Promise((resolve) => setTimeout(resolve, 2e3));
+    loaded = true;
+  }
+  async function start() {
+    if (mode === "tunnel")
+      await startCodeTunnel();
+    else
+      await startCodeServer();
+  }
   nuxt.hook("devtools:customTabs", (tabs) => {
     tabs.push({
       name: "builtin-vscode",