vite-plugin-php 2.0.3 → 3.0.0-beta.1

package/dist/index.cjs

@@ -3,29 +3,31 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 const node_child_process = require('node:child_process');
-const url = require('url');
+const node_url = require('node:url');
 const node_path = require('node:path');
-const tcpPortUsed = require('tcp-port-used');
-const require$$0 = require('os');
-const require$$0$1 = require('path');
-const require$$0$2 = require('util');
-const require$$0$3 = require('stream');
-const require$$0$5 = require('events');
-const require$$0$4 = require('fs');
+const require$$1 = require('net');
+const require$$0 = require('util');
+const require$$0$1 = require('tty');
+const require$$0$2 = require('os');
+const require$$0$3 = require('path');
+const require$$0$4 = require('stream');
+const require$$0$6 = require('events');
+const require$$0$5 = require('fs');
 const node_fs = require('node:fs');
-const http = require('node:http');
 const vite = require('vite');
+const http = require('node:http');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
-const tcpPortUsed__default = /*#__PURE__*/_interopDefaultCompat(tcpPortUsed);
+const require$$1__default = /*#__PURE__*/_interopDefaultCompat(require$$1);
 const require$$0__default = /*#__PURE__*/_interopDefaultCompat(require$$0);
 const require$$0__default$1 = /*#__PURE__*/_interopDefaultCompat(require$$0$1);
 const require$$0__default$2 = /*#__PURE__*/_interopDefaultCompat(require$$0$2);
 const require$$0__default$3 = /*#__PURE__*/_interopDefaultCompat(require$$0$3);
-const require$$0__default$5 = /*#__PURE__*/_interopDefaultCompat(require$$0$5);
 const require$$0__default$4 = /*#__PURE__*/_interopDefaultCompat(require$$0$4);
+const require$$0__default$6 = /*#__PURE__*/_interopDefaultCompat(require$$0$6);
+const require$$0__default$5 = /*#__PURE__*/_interopDefaultCompat(require$$0$5);
 const http__default = /*#__PURE__*/_interopDefaultCompat(http);
 
 const EPHPError = {
@@ -49,6 +51,7 @@ const EPHPError = {
 
 const internalParam = "__314159265359__";
 const shared = {
+  projectRoot: process.cwd(),
   viteConfig: void 0,
   devConfig: {
     cleanup: true,
@@ -64,6 +67,31 @@ function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
 
+function getAugmentedNamespace(n) {
+  if (Object.prototype.hasOwnProperty.call(n, '__esModule')) return n;
+  var f = n.default;
+	if (typeof f == "function") {
+		var a = function a () {
+			if (this instanceof a) {
+        return Reflect.construct(f, arguments, this.constructor);
+			}
+			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;
+}
+
 var picocolors = {exports: {}};
 
 var hasRequiredPicocolors;
@@ -92,130 +120,3156 @@ function requirePicocolors () {
 		return result + string.substring(cursor)
 	};
 
-	let createColors = (enabled = isColorSupported) => {
-		let f = enabled ? formatter : () => String;
-		return {
-			isColorSupported: enabled,
-			reset: f("\x1b[0m", "\x1b[0m"),
-			bold: f("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m"),
-			dim: f("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m"),
-			italic: f("\x1b[3m", "\x1b[23m"),
-			underline: f("\x1b[4m", "\x1b[24m"),
-			inverse: f("\x1b[7m", "\x1b[27m"),
-			hidden: f("\x1b[8m", "\x1b[28m"),
-			strikethrough: f("\x1b[9m", "\x1b[29m"),
+	let createColors = (enabled = isColorSupported) => {
+		let f = enabled ? formatter : () => String;
+		return {
+			isColorSupported: enabled,
+			reset: f("\x1b[0m", "\x1b[0m"),
+			bold: f("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m"),
+			dim: f("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m"),
+			italic: f("\x1b[3m", "\x1b[23m"),
+			underline: f("\x1b[4m", "\x1b[24m"),
+			inverse: f("\x1b[7m", "\x1b[27m"),
+			hidden: f("\x1b[8m", "\x1b[28m"),
+			strikethrough: f("\x1b[9m", "\x1b[29m"),
+
+			black: f("\x1b[30m", "\x1b[39m"),
+			red: f("\x1b[31m", "\x1b[39m"),
+			green: f("\x1b[32m", "\x1b[39m"),
+			yellow: f("\x1b[33m", "\x1b[39m"),
+			blue: f("\x1b[34m", "\x1b[39m"),
+			magenta: f("\x1b[35m", "\x1b[39m"),
+			cyan: f("\x1b[36m", "\x1b[39m"),
+			white: f("\x1b[37m", "\x1b[39m"),
+			gray: f("\x1b[90m", "\x1b[39m"),
+
+			bgBlack: f("\x1b[40m", "\x1b[49m"),
+			bgRed: f("\x1b[41m", "\x1b[49m"),
+			bgGreen: f("\x1b[42m", "\x1b[49m"),
+			bgYellow: f("\x1b[43m", "\x1b[49m"),
+			bgBlue: f("\x1b[44m", "\x1b[49m"),
+			bgMagenta: f("\x1b[45m", "\x1b[49m"),
+			bgCyan: f("\x1b[46m", "\x1b[49m"),
+			bgWhite: f("\x1b[47m", "\x1b[49m"),
+
+			blackBright: f("\x1b[90m", "\x1b[39m"),
+			redBright: f("\x1b[91m", "\x1b[39m"),
+			greenBright: f("\x1b[92m", "\x1b[39m"),
+			yellowBright: f("\x1b[93m", "\x1b[39m"),
+			blueBright: f("\x1b[94m", "\x1b[39m"),
+			magentaBright: f("\x1b[95m", "\x1b[39m"),
+			cyanBright: f("\x1b[96m", "\x1b[39m"),
+			whiteBright: f("\x1b[97m", "\x1b[39m"),
+
+			bgBlackBright: f("\x1b[100m", "\x1b[49m"),
+			bgRedBright: f("\x1b[101m", "\x1b[49m"),
+			bgGreenBright: f("\x1b[102m", "\x1b[49m"),
+			bgYellowBright: f("\x1b[103m", "\x1b[49m"),
+			bgBlueBright: f("\x1b[104m", "\x1b[49m"),
+			bgMagentaBright: f("\x1b[105m", "\x1b[49m"),
+			bgCyanBright: f("\x1b[106m", "\x1b[49m"),
+			bgWhiteBright: f("\x1b[107m", "\x1b[49m"),
+		}
+	};
+
+	picocolors.exports = createColors();
+	picocolors.exports.createColors = createColors;
+	return picocolors.exports;
+}
+
+var picocolorsExports = /*@__PURE__*/ requirePicocolors();
+const colors = /*@__PURE__*/getDefaultExportFromCjs(picocolorsExports);
+
+function hasViteConfig(input) {
+  if (!input) {
+    throw new Error("Vite config not initialized!");
+  }
+}
+
+function log(message, { type = "info", prefix = true, ...options } = {}) {
+  hasViteConfig(shared.viteConfig);
+  let output = "";
+  if (prefix) {
+    output += colors.bgMagenta(colors.white("\u2009php\u2009")) + " ";
+  }
+  output += message;
+  shared.viteConfig.logger[type](output, options);
+}
+log.error = function(json, options = {}) {
+  let output = json;
+  let type = "info";
+  try {
+    const data = JSON.parse(json);
+    output = "";
+    switch (data.code) {
+      case EPHPError.PARSE:
+      case EPHPError.ERROR:
+      case EPHPError.CORE_ERROR:
+      case EPHPError.COMPILE_ERROR:
+      case EPHPError.USER_ERROR:
+        type = "error";
+        output += colors.bgRedBright(colors.white("Fatal Error"));
+        break;
+      case EPHPError.WARNING:
+      case EPHPError.USER_WARNING:
+      case EPHPError.COMPILE_WARNING:
+      case EPHPError.RECOVERABLE_ERROR:
+        type = "warn";
+        output += colors.yellowBright("Warning");
+        break;
+      case EPHPError.NOTICE:
+      case EPHPError.USER_NOTICE:
+        type = "info";
+        output += colors.bgWhite(colors.black("Notice"));
+        break;
+      case EPHPError.STRICT:
+        type = "info";
+        output += colors.yellow("Strict");
+        break;
+      case EPHPError.DEPRECATED:
+      case EPHPError.USER_DEPRECATED:
+        type = "info";
+        output += colors.cyan("Deprecated");
+        break;
+      default:
+        break;
+    }
+    output += " " + data.message + "\r\n";
+    output += "	In: " + data.file.replace(
+      node_path.resolve(shared.tempDir),
+      shared.viteConfig?.root
+    ) + "\r\n";
+    output += "	On line: " + data.line;
+  } catch (error) {
+  }
+  log(output, { ...options, type });
+};
+
+var tcpPortUsed$1 = {};
+
+var is2 = {};
+
+var deepIs = {exports: {}};
+
+var hasRequiredDeepIs;
+
+function requireDeepIs () {
+	if (hasRequiredDeepIs) return deepIs.exports;
+	hasRequiredDeepIs = 1;
+	var pSlice = Array.prototype.slice;
+	var Object_keys = typeof Object.keys === 'function'
+	    ? Object.keys
+	    : function (obj) {
+	        var keys = [];
+	        for (var key in obj) keys.push(key);
+	        return keys;
+	    }
+	;
+
+	var deepEqual = deepIs.exports = function (actual, expected) {
+	  // enforce Object.is +0 !== -0
+	  if (actual === 0 && expected === 0) {
+	    return areZerosEqual(actual, expected);
+
+	  // 7.1. All identical values are equivalent, as determined by ===.
+	  } else if (actual === expected) {
+	    return true;
+
+	  } else if (actual instanceof Date && expected instanceof Date) {
+	    return actual.getTime() === expected.getTime();
+
+	  } else if (isNumberNaN(actual)) {
+	    return isNumberNaN(expected);
+
+	  // 7.3. Other pairs that do not both pass typeof value == 'object',
+	  // equivalence is determined by ==.
+	  } else if (typeof actual != 'object' && typeof expected != 'object') {
+	    return actual == expected;
+
+	  // 7.4. For all other Object pairs, including Array objects, equivalence is
+	  // determined by having the same number of owned properties (as verified
+	  // with Object.prototype.hasOwnProperty.call), the same set of keys
+	  // (although not necessarily the same order), equivalent values for every
+	  // corresponding key, and an identical 'prototype' property. Note: this
+	  // accounts for both named and indexed properties on Arrays.
+	  } else {
+	    return objEquiv(actual, expected);
+	  }
+	};
+
+	function isUndefinedOrNull(value) {
+	  return value === null || value === undefined;
+	}
+
+	function isArguments(object) {
+	  return Object.prototype.toString.call(object) == '[object Arguments]';
+	}
+
+	function isNumberNaN(value) {
+	  // NaN === NaN -> false
+	  return typeof value == 'number' && value !== value;
+	}
+
+	function areZerosEqual(zeroA, zeroB) {
+	  // (1 / +0|0) -> Infinity, but (1 / -0) -> -Infinity and (Infinity !== -Infinity)
+	  return (1 / zeroA) === (1 / zeroB);
+	}
+
+	function objEquiv(a, b) {
+	  if (isUndefinedOrNull(a) || isUndefinedOrNull(b))
+	    return false;
+
+	  // an identical 'prototype' property.
+	  if (a.prototype !== b.prototype) return false;
+	  //~~~I've managed to break Object.keys through screwy arguments passing.
+	  //   Converting to array solves the problem.
+	  if (isArguments(a)) {
+	    if (!isArguments(b)) {
+	      return false;
+	    }
+	    a = pSlice.call(a);
+	    b = pSlice.call(b);
+	    return deepEqual(a, b);
+	  }
+	  try {
+	    var ka = Object_keys(a),
+	        kb = Object_keys(b),
+	        key, i;
+	  } catch (e) {//happens when one is a string literal and the other isn't
+	    return false;
+	  }
+	  // having the same number of owned properties (keys incorporates
+	  // hasOwnProperty)
+	  if (ka.length != kb.length)
+	    return false;
+	  //the same set of keys (although not necessarily the same order),
+	  ka.sort();
+	  kb.sort();
+	  //~~~cheap key test
+	  for (i = ka.length - 1; i >= 0; i--) {
+	    if (ka[i] != kb[i])
+	      return false;
+	  }
+	  //equivalent values for every corresponding key, and
+	  //~~~possibly expensive deep test
+	  for (i = ka.length - 1; i >= 0; i--) {
+	    key = ka[i];
+	    if (!deepEqual(a[key], b[key])) return false;
+	  }
+	  return true;
+	}
+	return deepIs.exports;
+}
+
+var ipRegex;
+var hasRequiredIpRegex;
+
+function requireIpRegex () {
+	if (hasRequiredIpRegex) return ipRegex;
+	hasRequiredIpRegex = 1;
+
+	const word = '[a-fA-F\\d:]';
+	const b = options => options && options.includeBoundaries ?
+		`(?:(?<=\\s|^)(?=${word})|(?<=${word})(?=\\s|$))` :
+		'';
+
+	const v4 = '(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}';
+
+	const v6seg = '[a-fA-F\\d]{1,4}';
+	const v6 = `
+(?:
+(?:${v6seg}:){7}(?:${v6seg}|:)|                                    // 1:2:3:4:5:6:7::  1:2:3:4:5:6:7:8
+(?:${v6seg}:){6}(?:${v4}|:${v6seg}|:)|                             // 1:2:3:4:5:6::    1:2:3:4:5:6::8   1:2:3:4:5:6::8  1:2:3:4:5:6::1.2.3.4
+(?:${v6seg}:){5}(?::${v4}|(?::${v6seg}){1,2}|:)|                   // 1:2:3:4:5::      1:2:3:4:5::7:8   1:2:3:4:5::8    1:2:3:4:5::7:1.2.3.4
+(?:${v6seg}:){4}(?:(?::${v6seg}){0,1}:${v4}|(?::${v6seg}){1,3}|:)| // 1:2:3:4::        1:2:3:4::6:7:8   1:2:3:4::8      1:2:3:4::6:7:1.2.3.4
+(?:${v6seg}:){3}(?:(?::${v6seg}){0,2}:${v4}|(?::${v6seg}){1,4}|:)| // 1:2:3::          1:2:3::5:6:7:8   1:2:3::8        1:2:3::5:6:7:1.2.3.4
+(?:${v6seg}:){2}(?:(?::${v6seg}){0,3}:${v4}|(?::${v6seg}){1,5}|:)| // 1:2::            1:2::4:5:6:7:8   1:2::8          1:2::4:5:6:7:1.2.3.4
+(?:${v6seg}:){1}(?:(?::${v6seg}){0,4}:${v4}|(?::${v6seg}){1,6}|:)| // 1::              1::3:4:5:6:7:8   1::8            1::3:4:5:6:7:1.2.3.4
+(?::(?:(?::${v6seg}){0,5}:${v4}|(?::${v6seg}){1,7}|:))             // ::2:3:4:5:6:7:8  ::2:3:4:5:6:7:8  ::8             ::1.2.3.4
+)(?:%[0-9a-zA-Z]{1,})?                                             // %eth0            %1
+`.replace(/\s*\/\/.*$/gm, '').replace(/\n/g, '').trim();
+
+	// Pre-compile only the exact regexes because adding a global flag make regexes stateful
+	const v46Exact = new RegExp(`(?:^${v4}$)|(?:^${v6}$)`);
+	const v4exact = new RegExp(`^${v4}$`);
+	const v6exact = new RegExp(`^${v6}$`);
+
+	const ip = options => options && options.exact ?
+		v46Exact :
+		new RegExp(`(?:${b(options)}${v4}${b(options)})|(?:${b(options)}${v6}${b(options)})`, 'g');
+
+	ip.v4 = options => options && options.exact ? v4exact : new RegExp(`${b(options)}${v4}${b(options)}`, 'g');
+	ip.v6 = options => options && options.exact ? v6exact : new RegExp(`${b(options)}${v6}${b(options)}`, 'g');
+
+	ipRegex = ip;
+	return ipRegex;
+}
+
+const name = "is2";
+const version = "2.0.9";
+const description = "A type checking library where each exported function returns either true or false and does not throw. Also added tests.";
+const license = "MIT";
+const tags = [
+	"type",
+	"check",
+	"checker",
+	"checking",
+	"utilities",
+	"network",
+	"networking",
+	"credit",
+	"card",
+	"validation"
+];
+const keywords = [
+	"type",
+	"check",
+	"checker",
+	"checking",
+	"utilities",
+	"network",
+	"networking",
+	"credit",
+	"card",
+	"validation"
+];
+const author = "Enrico Marino <enrico.marino@email.com>";
+const maintainers = "Edmond Meinfelder <edmond@stdarg.com>, Chris Oyler <christopher.oyler@gmail.com>";
+const homepage = "http://github.com/stdarg/is2";
+const repository = {
+	type: "git",
+	url: "git@github.com:stdarg/is2.git"
+};
+const bugs = {
+	url: "http://github.com/stdarg/is/issues"
+};
+const main = "./index.js";
+const scripts = {
+	test: "./node_modules/.bin/mocha -C --reporter list tests.js"
+};
+const engines = {
+	node: ">=v0.10.0"
+};
+const dependencies = {
+	"deep-is": "^0.1.3",
+	"ip-regex": "^4.1.0",
+	"is-url": "^1.2.4"
+};
+const devDependencies = {
+	mocha: "6.2.3",
+	mongodb: "3.2.4"
+};
+const _package = {
+	name: name,
+	version: version,
+	description: description,
+	license: license,
+	tags: tags,
+	keywords: keywords,
+	author: author,
+	maintainers: maintainers,
+	homepage: homepage,
+	repository: repository,
+	bugs: bugs,
+	main: main,
+	scripts: scripts,
+	engines: engines,
+	dependencies: dependencies,
+	devDependencies: devDependencies
+};
+
+const _package$1 = {
+	__proto__: null,
+	author: author,
+	bugs: bugs,
+	default: _package,
+	dependencies: dependencies,
+	description: description,
+	devDependencies: devDependencies,
+	engines: engines,
+	homepage: homepage,
+	keywords: keywords,
+	license: license,
+	main: main,
+	maintainers: maintainers,
+	name: name,
+	repository: repository,
+	scripts: scripts,
+	tags: tags,
+	version: version
+};
+
+const require$$2 = /*@__PURE__*/getAugmentedNamespace(_package$1);
+
+var isUrl_1;
+var hasRequiredIsUrl;
+
+function requireIsUrl () {
+	if (hasRequiredIsUrl) return isUrl_1;
+	hasRequiredIsUrl = 1;
+	/**
+	 * Expose `isUrl`.
+	 */
+
+	isUrl_1 = isUrl;
+
+	/**
+	 * RegExps.
+	 * A URL must match #1 and then at least one of #2/#3.
+	 * Use two levels of REs to avoid REDOS.
+	 */
+
+	var protocolAndDomainRE = /^(?:\w+:)?\/\/(\S+)$/;
+
+	var localhostDomainRE = /^localhost[\:?\d]*(?:[^\:?\d]\S*)?$/;
+	var nonLocalhostDomainRE = /^[^\s\.]+\.\S{2,}$/;
+
+	/**
+	 * Loosely validate a URL `string`.
+	 *
+	 * @param {String} string
+	 * @return {Boolean}
+	 */
+
+	function isUrl(string){
+	  if (typeof string !== 'string') {
+	    return false;
+	  }
+
+	  var match = string.match(protocolAndDomainRE);
+	  if (!match) {
+	    return false;
+	  }
+
+	  var everythingAfterProtocol = match[1];
+	  if (!everythingAfterProtocol) {
+	    return false;
+	  }
+
+	  if (localhostDomainRE.test(everythingAfterProtocol) ||
+	      nonLocalhostDomainRE.test(everythingAfterProtocol)) {
+	    return true;
+	  }
+
+	  return false;
+	}
+	return isUrl_1;
+}
+
+/**
+ * @fileOverview
+ * is2 derived from is by Enrico Marino, adapted for Node.js.
+ * Slightly modified by Edmond Meinfelder
+ *
+ * is
+ * the definitive JavaScript type testing library
+ * Copyright(c) 2013,2014 Edmond Meinfelder <edmond@stdarg.com>
+ * Copyright(c) 2011 Enrico Marino <enrico.marino@email.com>
+ * MIT license
+ */
+
+var hasRequiredIs2;
+
+function requireIs2 () {
+	if (hasRequiredIs2) return is2;
+	hasRequiredIs2 = 1;
+	(function (exports) {
+		const owns = {}.hasOwnProperty;
+		const toString = {}.toString;
+		const is = exports;
+		const deepIs = requireDeepIs();
+		const ipRegEx =  requireIpRegex();
+		is.version = require$$2.version;
+
+		////////////////////////////////////////////////////////////////////////////////
+		// Environment
+
+		/**
+		 * Tests if is is running under a browser.
+		 * @return {Boolean} true if the environment has process, process.version and process.versions.
+		 */
+		is.browser = function() {
+		    return (!is.node() && typeof window !== 'undefined' && toString.call(window) === '[object global]');
+		};
+
+		/**
+		 * Test if 'value' is defined.
+		 * Alias: def
+		 * @param {Any} value The value to test.
+		 * @return {Boolean} true if 'value' is defined, false otherwise.
+		 */
+		is.defined = function(value) {
+		    return typeof value !== 'undefined';
+		};
+		is.def = is.defined;
+
+		/**
+		 * Tests if is is running under node.js
+		 * @return {Boolean} true if the environment has process, process.version and process.versions.
+		 */
+		is.nodejs = function() {
+		    return (process && process.hasOwnProperty('version') &&
+		            process.hasOwnProperty('versions'));
+		};
+		is.node = is.nodejs;
+
+		/**
+		 * Test if 'value' is undefined.
+		 * Aliases: undef, udef
+		 * @param {Any} value value to test.
+		 * @return {Boolean} true if 'value' is undefined, false otherwise.
+		 */
+		is.undefined = function(value) {
+		    return value === undefined;
+		};
+		is.udef = is.undef = is.undefined;
+
+
+		////////////////////////////////////////////////////////////////////////////////
+		// Types
+
+		/**
+		 * Test if 'value' is an array.
+		 * Alias: ary, arry
+		 * @param {Any} value value to test.
+		 * @return {Boolean} true if 'value' is an array, false otherwise.
+		 */
+		is.array = function(value) {
+		    return '[object Array]' === toString.call(value);
+		};
+		is.arr = is.ary = is.arry = is.array;
+
+		/**
+		 * Test if 'value' is an arraylike object (i.e. it has a length property with a valid value)
+		 * Aliases: arraylike, arryLike, aryLike
+		 * @param {Any} value value to test.
+		 * @return {Boolean} true if 'value' is an arguments object, false otherwise.
+		 */
+		is.arrayLike = function(value) {
+		    if (is.nullOrUndef(value))
+		        return false;
+		    return value !== undefined &&
+		        owns.call(value, 'length') &&
+		        isFinite(value.length);
+		};
+		is.arrLike = is.arryLike = is.aryLike = is.arraylike = is.arrayLike;
+
+		/**
+		 * Test if 'value' is an arguments object.
+		 * Alias: args
+		 * @param {Any} value value to test
+		 * @return {Boolean} true if 'value' is an arguments object, false otherwise
+		 */
+		is.arguments = function(value) {
+		    return '[object Arguments]' === toString.call(value);
+		};
+		is.args = is.arguments;
+
+		/**
+		 * Test if 'value' is a boolean.
+		 * Alias: bool
+		 * @param {Any} value value to test.
+		 * @return {Boolean} true if 'value' is a boolean, false otherwise.
+		 */
+		is.boolean = function(value) {
+		    return '[object Boolean]' === toString.call(value);
+		};
+		is.bool = is.boolean;
+
+		/**
+		 * Test if 'value' is an instance of Buffer.
+		 * Aliases: instOf, instanceof
+		 * @param {Any} value value to test.
+		 * @return {Boolean} true if 'value' is an instance of 'constructor'.
+		 */
+		is.buffer = function(value) {
+		    return is.nodejs() && Buffer && Buffer.hasOwnProperty('isBuffer') && Buffer.isBuffer(value);
+		};
+		is.buff = is.buf = is.buffer;
+
+		/**
+		 * Test if 'value' is a date.
+		 * @param {Any} value value to test.
+		 * @return {Boolean} true if 'value' is a date, false otherwise.
+		 */
+		is.date = function(value) {
+		    return '[object Date]' === toString.call(value);
+		};
+
+		/**
+		 * Test if 'value' is an error object.
+		 * Alias: err
+		 * @param value value to test.
+		 * @return {Boolean} true if 'value' is an error object, false otherwise.
+		 */
+		is.error = function(value) {
+		    return '[object Error]' === toString.call(value);
+		};
+		is.err = is.error;
+
+		/**
+		 * Test if 'value' is false.
+		 * @param {Any} value value to test.
+		 * @return {Boolean} true if 'value' is false, false otherwise
+		 */
+		is.false = function(value) {
+		    return value === false;
+		};
+
+		/**
+		 * Test if 'value' is a function or async function.
+		 * Alias: func
+		 * @param {Any} value value to test.
+		 * @return {Boolean} true if 'value' is a function, false otherwise.
+		 */
+		is.function = function(value) {
+		    return is.syncFunction(value) || is.asyncFunction(value)
+		};
+		is.fun = is.func = is.function;
+
+		/**
+		 * Test if 'value' is an async function using `async () => {}` or `async function () {}`.
+		 * Alias: func
+		 * @param {Any} value value to test.
+		 * @return {Boolean} true if 'value' is a function, false otherwise.
+		 */
+		is.asyncFunction = function(value) {
+		  return '[object AsyncFunction]' === toString.call(value);
+		};
+		is.asyncFun = is.asyncFunc = is.asyncFunction;
+
+		/**
+		 * Test if 'value' is a synchronous function.
+		 * Alias: syncFunc
+		 * @param {Any} value value to test.
+		 * @return {Boolean} true if 'value' is a function, false otherwise.
+		 */
+		is.syncFunction = function (value) {
+		  return '[object Function]' === toString.call(value);
+		};
+		is.syncFun = is.syncFunc = is.syncFunction;
+		/**
+		 * Test if 'value' is null.
+		 * @param {Any} value to test.
+		 * @return {Boolean} true if 'value' is null, false otherwise.
+		 */
+		is.null = function(value) {
+		    return value === null;
+		};
+
+		/**
+		 * Test is 'value' is either null or undefined.
+		 * Alias: nullOrUndef
+		 * @param {Any} value value to test.
+		 * @return {Boolean} True if value is null or undefined, false otherwise.
+		 */
+		is.nullOrUndefined = function(value) {
+		    return value === null || typeof value === 'undefined';
+		};
+		is.nullOrUndef = is.nullOrUndefined;
+
+		/**
+		 * Test if 'value' is a number.
+		 * Alias: num
+		 * @param {Any} value to test.
+		 * @return {Boolean} true if 'value' is a number, false otherwise.
+		 */
+		is.number = function(value) {
+		    return '[object Number]' === toString.call(value);
+		};
+		is.num = is.number;
+
+		/**
+		 * Test if 'value' is an object. Note: Arrays, RegExps, Date, Error, etc all return false.
+		 * Alias: obj
+		 * @param {Any} value to test.
+		 * @return {Boolean} true if 'value' is an object, false otherwise.
+		 */
+		is.object = function(value) {
+		    return '[object Object]' === toString.call(value);
+		};
+		is.obj = is.object;
+
+		/**
+		 * Test if 'value' is a regular expression.
+		 * Alias: regexp
+		 * @param {Any} value to test.
+		 * @return {Boolean} true if 'value' is a regexp, false otherwise.
+		 */
+		is.regExp = function(value) {
+		    return '[object RegExp]' === toString.call(value);
+		};
+		is.re = is.regexp = is.regExp;
+
+		/**
+		 * Test if 'value' is a string.
+		 * Alias: str
+		 * @param {Any} value to test.
+		 * @return {Boolean} true if 'value' is a string, false otherwise.
+		 */
+		is.string = function(value) {
+		    return '[object String]' === toString.call(value);
+		};
+		is.str = is.string;
+
+		/**
+		 * Test if 'value' is true.
+		 * @param {Any} value to test.
+		 * @return {Boolean} true if 'value' is true, false otherwise.
+		 */
+		is.true = function(value) {
+		    return value === true;
+		};
+
+		/**
+		 * Test if 'value' is a uuid (v1-v5)
+		 * @param {Any} value to test.
+		 * @return {Boolean} true if 'value is a valid RFC4122 UUID. Case non-specific.
+		 */
+		var uuidRegExp = new RegExp('[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab]'+
+		                            '[0-9a-f]{3}-[0-9a-f]{12}', 'i');
+		is.uuid = function(value) {
+		    return uuidRegExp.test(value);
+		};
+
+		////////////////////////////////////////////////////////////////////////////////
+		// Object Relationships
+
+		/**
+		 * Test if 'value' is equal to 'other'. Works for objects and arrays and will do deep comparisions,
+		 * using recursion.
+		 * Alias: eq
+		 * @param {Any} value value.
+		 * @param {Any} other value to compare with.
+		 * @return {Boolean} true if 'value' is equal to 'other', false otherwise
+		 */
+		is.equal = function(value, other) {
+		    var type = toString.call(value);
+
+		    if (typeof value !== typeof other) {
+		        return false;
+		    }
+
+		    if (type !== toString.call(other)) {
+		        return false;
+		    }
+
+		    if ('[object Object]' === type || '[object Array]' === type) {
+		        return deepIs(value, other);
+		    } else if ('[object Function]' === type) {
+		        return value.prototype === other.prototype;
+		    } else if ('[object Date]' === type) {
+		        return value.getTime() === other.getTime();
+		    }
+
+		    return value === other;
+		};
+		is.objEquals = is.eq = is.equal;
+
+		/**
+		 * JS Type definitions which cannot host values.
+		 * @api private
+		 */
+		var NON_HOST_TYPES = {
+		    'boolean': 1,
+		    'number': 1,
+		    'string': 1,
+		    'undefined': 1
+		};
+
+		/**
+		 * Test if 'key' in host is an object. To be hosted means host[value] is an object.
+		 * @param {Any} value The value to test.
+		 * @param {Any} host Host that may contain value.
+		 * @return {Boolean} true if 'value' is hosted by 'host', false otherwise.
+		 */
+		is.hosted = function(value, host) {
+		    if (is.nullOrUndef(value))
+		        return false;
+		    var type = typeof host[value];
+		    return type === 'object' ? !!host[value] : !NON_HOST_TYPES[type];
+		};
+
+		/**
+		 * Test if 'value' is an instance of 'constructor'.
+		 * Aliases: instOf, instanceof
+		 * @param {Any} value value to test.
+		 * @return {Boolean} true if 'value' is an instance of 'constructor'.
+		 */
+		is.instanceOf = function(value, constructor) {
+		    if (is.nullOrUndef(value) || is.nullOrUndef(constructor))
+		        return false;
+		    return (value instanceof constructor);
+		};
+		is.instOf = is.instanceof = is.instanceOf;
+
+		/**
+		 * Test if 'value' is an instance type objType.
+		 * Aliases: objInstOf, objectinstanceof, instOf, instanceOf
+		 * @param {object} objInst an object to testfor type.
+		 * @param {object} objType an object type to compare.
+		 * @return {Boolean} true if 'value' is an object, false otherwise.
+		 */
+		is.objectInstanceOf = function(objInst, objType) {
+		    try {
+		        return '[object Object]' === toString.call(objInst) && (objInst instanceof objType);
+		    } catch(err) {
+		        return false;
+		    }
+		};
+		is.instOf = is.instanceOf = is.objInstOf = is.objectInstanceOf;
+
+		/**
+		 * Test if 'value' is a type of 'type'.
+		 * Alias: a
+		 * @param value value to test.
+		 * @param {String} type The name of the type.
+		 * @return {Boolean} true if 'value' is an arguments object, false otherwise.
+		 */
+		is.type = function(value, type) {
+		    return typeof value === type;
+		};
+		is.a = is.type;
+
+		////////////////////////////////////////////////////////////////////////////////
+		// Object State
+
+		/**
+		 * Test if 'value' is empty. To be empty means to be an array, object or string with nothing contained.
+		 * @param {Any} value value to test.
+		 * @return {Boolean} true if 'value' is empty, false otherwise.
+		 */
+		is.empty = function(value) {
+		    var type = toString.call(value);
+
+		    if ('[object Array]' === type || '[object Arguments]' === type) {
+		        return value.length === 0;
+		    }
+
+		    if ('[object Object]' === type) {
+		        for (var key in value) if (owns.call(value, key)) return false;
+		        return true;
+		    }
+
+		    if ('[object String]' === type) {
+		        return value === '';
+		    }
+
+		    return false;
+		};
+
+		/**
+		 * Test if 'value' is an arguments object that is empty.
+		 * Alias: args
+		 * @param {Any} value value to test
+		 * @return {Boolean} true if 'value' is an arguments object with no args, false otherwise
+		 */
+		is.emptyArguments = function(value) {
+		    return '[object Arguments]' === toString.call(value) && value.length === 0;
+		};
+		is.noArgs = is.emptyArgs = is.emptyArguments;
+
+		/**
+		 * Test if 'value' is an array containing no entries.
+		 * Aliases: emptyArry, emptyAry
+		 * @param {Any} value The value to test.
+		 * @return {Boolean} true if 'value' is an array with no elemnets.
+		 */
+		is.emptyArray = function(value) {
+		    return '[object Array]' === toString.call(value) && value.length === 0;
+		};
+		is.emptyArry = is.emptyAry = is.emptyArray;
+
+		/**
+		 * Test if 'value' is an empty array(like) object.
+		 * Aliases: arguents.empty, args.empty, ary.empty, arry.empty
+		 * @param {Any} value value to test.
+		 * @return {Boolean} true if 'value' is an empty array(like), false otherwise.
+		 */
+		is.emptyArrayLike = function(value) {
+		    return value.length === 0;
+		};
+		is.emptyArrLike = is.emptyArrayLike;
+
+		/**
+		 * Test if 'value' is an empty string.
+		 * Alias: emptyStr
+		 * @param {Any} value to test.
+		 * @return {Boolean} true if 'value' is am empty string, false otherwise.
+		 */
+		is.emptyString = function(value) {
+		    return is.string(value) && value.length === 0;
+		};
+		is.emptyStr = is.emptyString;
+
+		/**
+		 * Test if 'value' is an array containing at least 1 entry.
+		 * Aliases: nonEmptyArry, nonEmptyAry
+		 * @param {Any} value The value to test.
+		 * @return {Boolean} true if 'value' is an array with at least 1 value, false otherwise.
+		 */
+		is.nonEmptyArray = function(value) {
+		    return '[object Array]' === toString.call(value) && value.length > 0;
+		};
+		is.nonEmptyArr = is.nonEmptyArry = is.nonEmptyAry = is.nonEmptyArray;
+
+		/**
+		 * Test if 'value' is an object with properties. Note: Arrays are objects.
+		 * Alias: nonEmptyObj
+		 * @param {Any} value to test.
+		 * @return {Boolean} true if 'value' is an object, false otherwise.
+		 */
+		is.nonEmptyObject = function(value) {
+		    return '[object Object]' === toString.call(value) && Object.keys(value).length > 0;
+		};
+		is.nonEmptyObj = is.nonEmptyObject;
+
+		/**
+		 * Test if 'value' is an object with no properties. Note: Arrays are objects.
+		 * Alias: nonEmptyObj
+		 * @param {Any} value to test.
+		 * @return {Boolean} true if 'value' is an object, false otherwise.
+		 */
+		is.emptyObject = function(value) {
+		    return '[object Object]' === toString.call(value) && Object.keys(value).length === 0;
+		};
+		is.emptyObj = is.emptyObject;
+
+		/**
+		 * Test if 'value' is a non-empty string.
+		 * Alias: nonEmptyStr
+		 * @param {Any} value to test.
+		 * @return {Boolean} true if 'value' is a non-empty string, false otherwise.
+		 */
+		is.nonEmptyString = function(value) {
+		    return is.string(value) && value.length > 0;
+		};
+		is.nonEmptyStr = is.nonEmptyString;
+
+		////////////////////////////////////////////////////////////////////////////////
+		// Numeric Types within Number
+
+		/**
+		 * Test if 'value' is an even number.
+		 * @param {Number} value to test.
+		 * @return {Boolean} true if 'value' is an even number, false otherwise.
+		 */
+		is.even = function(value) {
+		    return '[object Number]' === toString.call(value) && value % 2 === 0;
+		};
+
+		/**
+		 * Test if 'value' is a decimal number.
+		 * Aliases: decimalNumber, decNum
+		 * @param {Any} value value to test.
+		 * @return {Boolean} true if 'value' is a decimal number, false otherwise.
+		 */
+		is.decimal = function(value) {
+		    return '[object Number]' === toString.call(value) && value % 1 !== 0;
+		};
+		is.dec = is.decNum = is.decimal;
+
+		/**
+		 * Test if 'value' is an integer.
+		 * Alias: integer
+		 * @param {Any} value to test.
+		 * @return {Boolean} true if 'value' is an integer, false otherwise.
+		 */
+		is.integer = function(value) {
+		    return '[object Number]' === toString.call(value) && value % 1 === 0;
+		};
+		is.int = is.integer;
+
+		/**
+		 * is.nan
+		 * Test if `value` is not a number.
+		 *
+		 * @param {Mixed} value value to test
+		 * @return {Boolean} true if `value` is not a number, false otherwise
+		 * @api public
+		 */
+		is.notANumber = function(value) {
+		    return !is.num(value) || value !== value;
+		};
+		is.nan = is.notANum = is.notANumber;
+
+		/**
+		 * Test if 'value' is an odd number.
+		 * @param {Number} value to test.
+		 * @return {Boolean} true if 'value' is an odd number, false otherwise.
+		 */
+		is.odd = function(value) {
+		    return !is.decimal(value) && '[object Number]' === toString.call(value) && value % 2 !== 0;
+		};
+		is.oddNumber = is.oddNum = is.odd;
+
+		////////////////////////////////////////////////////////////////////////////////
+		// Numeric Type & State
+
+		/**
+		 * Test if 'value' is a positive number.
+		 * Alias: positiveNum, posNum
+		 * @param {Any} value to test.
+		 * @return {Boolean} true if 'value' is a number, false otherwise.
+		 */
+		is.positiveNumber = function(value) {
+		    return '[object Number]' === toString.call(value) && value > 0;
+		};
+		is.pos = is.positive = is.posNum = is.positiveNum = is.positiveNumber;
+
+		/**
+		 * Test if 'value' is a negative number.
+		 * Aliases: negNum, negativeNum
+		 * @param {Any} value to test.
+		 * @return {Boolean} true if 'value' is a number, false otherwise.
+		 */
+		is.negativeNumber = function(value) {
+		    return '[object Number]' === toString.call(value) && value < 0;
+		};
+		is.neg = is.negNum = is.negativeNum = is.negativeNumber;
+
+		/**
+		 * Test if 'value' is a negative integer.
+		 * Aliases: negInt, negativeInteger
+		 * @param {Any} value to test.
+		 * @return {Boolean} true if 'value' is a negative integer, false otherwise.
+		 */
+		is.negativeInteger = function(value) {
+		    return '[object Number]' === toString.call(value) && value % 1 === 0 && value < 0;
+		};
+		is.negativeInt = is.negInt = is.negativeInteger;
+
+		/**
+		 * Test if 'value' is a positive integer.
+		 * Alias: posInt
+		 * @param {Any} value to test.
+		 * @return {Boolean} true if 'value' is a positive integer, false otherwise.
+		 */
+		is.positiveInteger = function(value) {
+		    return '[object Number]' === toString.call(value) && value % 1 === 0 && value > 0;
+		};
+		is.posInt = is.positiveInt = is.positiveInteger;
+
+		////////////////////////////////////////////////////////////////////////////////
+		// Numeric Relationships
+
+		/**
+		 * Test if 'value' is divisible by 'n'.
+		 * Alias: divisBy
+		 * @param {Number} value value to test.
+		 * @param {Number} n dividend.
+		 * @return {Boolean} true if 'value' is divisible by 'n', false otherwise.
+		 */
+		is.divisibleBy = function(value, n) {
+		    if (value === 0)
+		        return false;
+		    return '[object Number]' === toString.call(value) &&
+		        n !== 0 &&
+		        value % n === 0;
+		};
+		is.divBy = is.divisBy = is.divisibleBy;
+
+		/**
+		 * Test if 'value' is greater than or equal to 'other'.
+		 * Aliases: greaterOrEq, greaterOrEqual
+		 * @param {Number} value value to test.
+		 * @param {Number} other value to compare with.
+		 * @return {Boolean} true, if value is greater than or equal to other, false otherwise.
+		 */
+		is.greaterOrEqualTo = function(value, other) {
+		    return value >= other;
+		};
+		is.greaterOrEqual = is.ge = is.greaterOrEqualTo;
+
+		/**
+		 * Test if 'value' is greater than 'other'.
+		 * Aliases: greaterThan
+		 * @param {Number} value value to test.
+		 * @param {Number} other value to compare with.
+		 * @return {Boolean} true, if value is greater than other, false otherwise.
+		 */
+		is.greaterThan = function(value, other) {
+		    return value > other;
+		};
+		is.gt = is.greaterThan;
+
+		/**
+		 * Test if 'value' is less than or equal to 'other'.
+		 * Alias: lessThanOrEq, lessThanOrEqual
+		 * @param {Number} value value to test
+		 * @param {Number} other value to compare with
+		 * @return {Boolean} true, if 'value' is less than or equal to 'other', false otherwise.
+		 */
+		is.lessThanOrEqualTo = function(value, other) {
+		    return value <= other;
+		};
+		is.lessThanOrEq = is.lessThanOrEqual = is.le = is.lessThanOrEqualTo;
+
+		/**
+		 * Test if 'value' is less than 'other'.
+		 * Alias: lessThan
+		 * @param {Number} value value to test
+		 * @param {Number} other value to compare with
+		 * @return {Boolean} true, if 'value' is less than 'other', false otherwise.
+		 */
+		is.lessThan = function(value, other) {
+		    return value < other;
+		};
+		is.lt = is.lessThan;
+
+		/**
+		 * Test if 'value' is greater than 'others' values.
+		 * Alias: max
+		 * @param {Number} value value to test.
+		 * @param {Array} others values to compare with.
+		 * @return {Boolean} true if 'value' is greater than 'others' values.
+		 */
+		is.maximum = function(value, others) {
+		    if (!is.arrayLike(others) || !is.number(value))
+		        return false;
+
+		    var len = others.length;
+		    while (--len > -1) {
+		        if (value < others[len]) {
+		            return false;
+		        }
+		    }
+
+		    return true;
+		};
+		is.max = is.maximum;
+
+		/**
+		 * Test if 'value' is less than 'others' values.
+		 * Alias: min
+		 * @param {Number} value value to test.
+		 * @param {Array} others values to compare with.
+		 * @return {Boolean} true if 'value' is less than 'others' values.
+		 */
+		is.minimum = function(value, others) {
+		    if (!is.arrayLike(others) || !is.number(value))
+		        return false;
+
+		    var len = others.length;
+		    while (--len > -1) {
+		        if (value > others[len]) {
+		            return false;
+		        }
+		    }
+
+		    return true;
+		};
+		is.min = is.minimum;
+
+		/**
+		 * Test if 'value' is within 'start' and 'finish'.
+		 * Alias: withIn
+		 * @param {Number} value value to test.
+		 * @param {Number} start lower bound.
+		 * @param {Number} finish upper bound.
+		 * @return {Boolean} true if 'value' is is within 'start' and 'finish', false otherwise.
+		 */
+		is.within = function(value, start, finish) {
+		    return value >= start && value <= finish;
+		};
+		is.withIn = is.within;
+
+		/**
+		 * Test if 'value' is within 'precision' decimal places from 'comparitor'.
+		 * Alias: closish, near.
+		 * @param {Number} value value to test
+		 * @param {Number} comparitor value to test 'value' against
+		 * @param {Number} precision number of decimals to compare floating points, defaults to 2
+		 * @return {Boolean} true if 'value' is within 'precision' decimal places from 'comparitor', false otherwise.
+		 */
+		is.prettyClose = function(value, comparitor, precision) {
+		  if (!is.number(value) || !is.number(comparitor)) return false;
+		  if (is.defined(precision) && !is.posInt(precision)) return false;
+		  if (is.undefined(precision)) precision = 2;
+
+		  return value.toFixed(precision) === comparitor.toFixed(precision);
+		};
+		is.closish = is.near = is.prettyClose;
+		////////////////////////////////////////////////////////////////////////////////
+		// Networking
+
+		/**
+		 * Test if a value is a valid DNS address. eg www.stdarg.com is true while
+		 * 127.0.0.1 is false.
+		 * @param {Any} value to test if a DNS address.
+		 * @return {Boolean} true if a DNS address, false otherwise.
+		 * DNS Address is made up of labels separated by '.'
+		 * Each label must be between 1 and 63 characters long
+		 * The entire hostname (including the delimiting dots) has a maximum of 255 characters.
+		 * Hostname may not contain other characters, such as the underscore character (_)
+		 * other DNS names may contain the underscore.
+		 */
+		is.dnsAddress = function(value) {
+		    if (!is.nonEmptyStr(value))  return false;
+		    if (value.length > 255)  return false;
+		    if (numbersLabel.test(value))  return false;
+		    if (!dnsLabel.test(value))  return false;
+		    return true;
+		    //var names = value.split('.');
+		    //if (!is.array(names) || !names.length)  return false;
+		    //if (names[0].indexOf('_') > -1)  return false;
+		    //for (var i=0; i<names.length; i++) {
+		        //if (!dnsLabel.test(names[i]))  return false;
+		    //}
+		    //return true;
+		};
+		is.dnsAddr = is.dns = is.dnsAddress;
+		var dnsLabel = /^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])(\.([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]{0,61}[a-zA-Z0-9]))*$/;
+		var numbersLabel = /^([0-9]|[0-9][0-9\-]{0,61}[0-9])(\.([0-9]|[0-9][0-9\-]{0,61}[0-9]))*$/;
+
+		/**
+		 * Test if value is a valid email address.
+		 * @param {Any} value to test if an email address.
+		 * @return {Boolean} true if an email address, false otherwise.
+		 */
+		is.emailAddress = function(value) {
+		    if (!is.nonEmptyStr(value))
+		        return false;
+		    return emailRegexp.test(value);
+		};
+		is.email = is.emailAddr = is.emailAddress;
+		var emailRegexp = /^([^\x00-\x20\x22\x28\x29\x2c\x2e\x3a-\x3c\x3e\x40\x5b-\x5d\x7f-\xff]+|\x22([^\x0d\x22\x5c\x80-\xff]|\x5c[\x00-\x7f])*\x22)(\x2e([^\x00-\x20\x22\x28\x29\x2c\x2e\x3a-\x3c\x3e\x40\x5b-\x5d\x7f-\xff]+|\x22([^\x0d\x22\x5c\x80-\xff]|\x5c[\x00-\x7f])*\x22))*\x40([^\x00-\x20\x22\x28\x29\x2c\x2e\x3a-\x3c\x3e\x40\x5b-\x5d\x7f-\xff]+|\x5b([^\x0d\x5b-\x5d\x80-\xff]|\x5c[\x00-\x7f])*\x5d)(\x2e([^\x00-\x20\x22\x28\x29\x2c\x2e\x3a-\x3c\x3e\x40\x5b-\x5d\x7f-\xff]+|\x5b([^\x0d\x5b-\x5d\x80-\xff]|\x5c[\x00-\x7f])*\x5d))*$/;
+
+		/**
+		 * Test if a value is either an IPv4 numeric IP address.
+		 * The rules are:
+		 * must be a string
+		 * length must be 15 characters or less
+		 * There must be four octets separated by a '.'
+		 * No octet can be less than 0 or greater than 255.
+		 * @param {Any} value to test if an ip address.
+		 * @return {Boolean} true if an ip address, false otherwise.
+		 */
+		is.ipv4Address = function(value) {
+		    if (!is.nonEmptyStr(value))  return false;
+		    if (value.length > 15)  return false;
+		    var octets = value.split('.');
+		    if (!is.array(octets) || octets.length !== 4)  return false;
+		    for (var i=0; i<octets.length; i++) {
+		        var val = parseInt(octets[i], 10);
+		        if (isNaN(val))  return false;
+		        if (val < 0 || val > 255)  return false;
+		    }
+		    return true;
+		};
+		is.ipv4 = is.ipv4Addr = is.ipv4Address;
+
+		/**
+		 * Test if a value is either an IPv6 numeric IP address.
+		 * @param {Any} value to test if an ip address.
+		 * @return {Boolean} true if an ip address, false otherwise.
+		 */
+		is.ipv6Address = function(value) {
+		    if (!is.nonEmptyStr(value))  return false;
+		    return ipRegEx.v6({extract: true}).test(value);
+		};
+		is.ipv6 = is.ipv6Addr = is.ipv6Address;
+
+		/**
+		 * Test if a value is either an IPv4 or IPv6 numeric IP address.
+		 * @param {Any} value to test if an ip address.
+		 * @return {Boolean} true if an ip address, false otherwise.
+		 */
+		is.ipAddress = function(value) {
+		    if (!is.nonEmptyStr(value)) return false;
+		    return is.ipv4Address(value) || is.ipv6Address(value)
+		};
+		is.ip = is.ipAddr = is.ipAddress;
+
+		/**
+		 * Test is a value is a valid ipv4, ipv6 or DNS name.
+		 * Aliases: host, hostAddr, hostAddress.
+		 * @param {Any} value to test if a host address.
+		 * @return {Boolean} true if a host address, false otherwise.
+		 */
+		is.hostAddress = function(value) {
+		    if (!is.nonEmptyStr(value)) return false;
+		    return is.dns(value) || is.ipv4(value) || is.ipv6(value);
+		};
+		is.host = is.hostIp = is.hostAddr = is.hostAddress;
+
+		/**
+		 * Test if a number is a valid TCP port
+		 * @param {Any} value to test if its a valid TCP port
+		 */
+		is.port = function(value) {
+		    if (!is.num(value) || is.negativeInt(value) || value > 65535)
+		        return false;
+		    return true;
+		};
+
+		/**
+		 * Test if a number is a valid TCP port in the range 0-1023.
+		 * Alias: is.sysPort.
+		 * @param {Any} value to test if its a valid TCP port
+		 */
+		is.systemPort = function(value) {
+		    if (is.port(value) && value < 1024)
+		        return true;
+		    return false;
+		};
+		is.sysPort = is.systemPort;
+
+		/**
+		 * Test if a number is a valid TCP port in the range 1024-65535.
+		 * @param {Any} value to test if its a valid TCP port
+		 */
+		is.userPort = function(value) {
+		    if (is.port(value) && value > 1023)
+		        return true;
+		    return false;
+		};
+
+		/*
+		function sumDigits(num) {
+		    var str = num.toString();
+		    var sum = 0;
+		    for (var i = 0; i < str.length; i++)
+		        sum += (str[i]-0);
+		    return sum;
+		}
+		*/
+
+		/**
+		 * Test if a string is a credit card.
+		 * From http://en.wikipedia.org/wiki/Luhn_algorithm
+		 * @param {String} value to test if a credit card.
+		 * @return true if the string is the correct format, false otherwise
+		 */
+		is.creditCardNumber = function(str) {
+		    if (!is.str(str))
+		        return false;
+
+		    var ary = str.split('');
+		    var i, cnt;
+		    // From the rightmost digit, which is the check digit, moving left, double
+		    // the value of every second digit;
+		    for (i=ary.length-1, cnt=1; i>-1; i--, cnt++) {
+		        if (cnt%2 === 0)
+		            ary[i] *= 2;
+		    }
+
+		    str = ary.join('');
+		    var sum = 0;
+		    // if the product of the previous doubling operation is greater than 9
+		    // (e.g., 7 * 2 = 14), then sum the digits of the products (e.g., 10: 1 + 0
+		    // = 1, 14: 1 + 4 = 5).  We do the this by joining the array of numbers and
+		    // add adding the int value of all the characters in the string.
+		    for (i=0; i<str.length; i++)
+		        sum += Math.floor(str[i]);
+
+		    // If the total (sum) modulo 10 is equal to 0 (if the total ends in zero)
+		    // then the number is valid according to the Luhn formula; else it is not
+		    // valid.
+		    return sum % 10 === 0;
+		};
+		is.creditCard = is.creditCardNum = is.creditCardNumber;
+
+
+		////////////////////////////////////////////////////////////////////////////////
+		// The following credit card info is from:
+		// http://en.wikipedia.org/wiki/Bank_card_number#Issuer_identification_number_.28IIN.29
+
+		/**
+		 * Test if card number is an American Express card.
+		 * @param {String} the credit card number string to test.
+		 * @return true if the string is the correct format, false otherwise
+		 */
+		is.americanExpressCardNumber = function(str) {
+		    if (!is.str(str) || str.length !== 15)
+		        return false;
+
+		    var prefix = Math.floor(str.slice(0,2));
+		    if (prefix !== 34 && prefix !== 37)
+		        return false;
+
+		    if (!is.creditCardNumber(str))
+		        return false;
+
+		    return true;
+		};
+		is.amexCard = is.amexCardNum = is.americanExpressCardNumber;
+
+		/**
+		 * Test if card number is a China UnionPay card.
+		 * @param {String} the credit card number string to test.
+		 * @return true if the string is the correct format, false otherwise
+		 */
+		is.chinaUnionPayCardNumber = function(str) {
+		    if (!is.str(str) || (str.length < 16 && str.length > 19))
+		        return false;
+
+		    var prefix = Math.floor(str.slice(0,2));
+		    if (prefix !== 62 && prefix !== 88)
+		        return false;
+
+		    // no validation for this card
+		    return true;
+		};
+		is.chinaUnion = is.chinaUnionPayCard = is.chinaUnionPayCardNumber;
+
+		/**
+		 * Test if card number is a Diner's Club Carte Blance card.
+		 * @param {String} the credit card number string to test.
+		 * @return true if the string is the correct format, false otherwise
+		 */
+		is.dinersClubCarteBlancheCardNumber = function(str) {
+		    if (!is.str(str) || str.length !== 14)
+		        return false;
+
+		    var prefix = Math.floor(str.slice(0,3));
+		    if (prefix < 300 || prefix > 305)
+		        return false;
+
+		    if (!is.creditCardNumber(str))
+		        return false;
+
+		    return true;
+		};
+		is.dinersClubCB = is.dinersClubCarteBlancheCard =
+		    is.dinersClubCarteBlancheCardNumber;
+
+		/**
+		 * Test if card number is a Diner's Club International card.
+		 * @param {String} the credit card number string to test.
+		 * @return true if the string is the correct format, false otherwise
+		 */
+		is.dinersClubInternationalCardNumber = function(str) {
+		    if (!is.str(str) || str.length !== 14)
+		        return false;
+		    var prefix = Math.floor(str.slice(0,3));
+		    var prefix2 = Math.floor(str.slice(0,2));
+
+		    // 300-305, 309, 36, 38-39
+		    if ((prefix < 300 || prefix > 305) && prefix !== 309 && prefix2 !== 36 &&
+		        (prefix2 < 38 || prefix2 > 39)) {
+		        return false;
+		    }
+
+		    if (!is.creditCardNumber(str))
+		        return false;
+
+		    return true;
+		};
+		is.dinersClubInt = is.dinersClubInternationalCard =
+		    is.dinersClubInternationalCardNumber;
+
+		/**
+		 * Test if card number is a Diner's Club USA & CA card.
+		 * @param {String} the credit card number string to test.
+		 * @return true if the string is the correct format, false otherwise
+		 */
+		is.dinersClubUSACanadaCardNumber = function(str) {
+		    if (!is.str(str) || str.length !== 16)
+		        return false;
+		    var prefix = Math.floor(str.slice(0,2));
+
+		    if (prefix !== 54 && prefix !== 55)
+		        return false;
+
+		    if (!is.creditCardNumber(str))
+		        return false;
+
+		    return true;
+		};
+		is.dinersClub = is.dinersClubUSACanCard = is.dinersClubUSACanadaCardNumber;
+
+		/**
+		 * Test if card number is a Diner's Club USA/CA card.
+		 * @param {String} the credit card number string to test.
+		 * @return true if the string is the correct format, false otherwise
+		 */
+		is.discoverCardNumber = function(str) {
+		    if (!is.str(str) || str.length !== 16)
+		        return false;
+
+		    var prefix = Math.floor(str.slice(0,6));
+		    var prefix2 = Math.floor(str.slice(0,3));
+
+		    if (str.slice(0,4) !== '6011' && (prefix < 622126 || prefix > 622925) &&
+		        (prefix2 < 644 || prefix2 > 649) && str.slice(0,2) !== '65') {
+		        return false;
+		    }
+
+		    if (!is.creditCardNumber(str))
+		        return false;
+
+		    return true;
+		};
+		is.discover = is.discoverCard = is.discoverCardNumber;
+
+		/**
+		 * Test if card number is an InstaPayment card number
+		 * @param {String} the credit card number string to test.
+		 * @return true if the string is the correct format, false otherwise
+		 */
+		is.instaPaymentCardNumber = function(str) {
+		    if (!is.str(str) || str.length !== 16)
+		        return false;
+
+		    var prefix = Math.floor(str.slice(0,3));
+		    if (prefix < 637 || prefix > 639)
+		        return false;
+
+		    if (!is.creditCardNumber(str))
+		        return false;
+
+		    return true;
+		};
+		is.instaPayment = is.instaPaymentCardNumber;
+
+		/**
+		 * Test if card number is a JCB card number
+		 * @param {String} the credit card number string to test.
+		 * @return true if the string is the correct format, false otherwise
+		 */
+		is.jcbCardNumber = function(str) {
+		    if (!is.str(str) || str.length !== 16)
+		        return false;
+
+		    var prefix = Math.floor(str.slice(0,4));
+		    if (prefix < 3528 || prefix > 3589)
+		        return false;
+
+		    if (!is.creditCardNumber(str))
+		        return false;
+
+		    return true;
+		};
+		is.jcb = is.jcbCard = is.jcbCardNumber;
+
+		/**
+		 * Test if card number is a Laser card number
+		 * @param {String} the credit card number string to test.
+		 * @return true if the string is the correct format, false otherwise
+		 */
+		is.laserCardNumber = function(str) {
+		    if (!is.str(str) || (str.length < 16 && str.length > 19))
+		        return false;
+
+		    var prefix = Math.floor(str.slice(0,4));
+		    var valid = [ 6304, 6706, 6771, 6709 ];
+		    if (valid.indexOf(prefix) === -1)
+		        return false;
+
+		    if (!is.creditCardNumber(str))
+		        return false;
+
+		    return true;
+		};
+		is.laser = is.laserCard = is.laserCardNumber;
+
+		/**
+		 * Test if card number is a Maestro card number
+		 * @param {String} the credit card number string to test.
+		 * @return true if the string is the correct format, false otherwise
+		 */
+		is.maestroCardNumber = function(str) {
+		    if (!is.str(str) || str.length < 12 || str.length > 19)
+		        return false;
+
+		    var prefix = str.slice(0,4);
+		    var valid = [ '5018', '5020', '5038', '5612', '5893', '6304', '6759',
+		        '6761', '6762', '6763', '0604', '6390' ];
+
+		    if (valid.indexOf(prefix) === -1)
+		        return false;
+
+		    if (!is.creditCardNumber(str))
+		        return false;
+
+		    return true;
+		};
+		is.maestro = is.maestroCard = is.maestroCardNumber;
+
+		/**
+		 * Test if card number is a Dankort card number
+		 * @param {String} the credit card number string to test.
+		 * @return true if the string is the correct format, false otherwise
+		 */
+		is.dankortCardNumber = function(str) {
+		    if (!is.str(str) || str.length !== 16)
+		        return false;
+
+		    if (str.slice(0,4) !== '5019')
+		        return false;
+
+		    if (!is.creditCardNumber(str))
+		        return false;
+
+		    return true;
+		};
+		is.dankort = is.dankortCard = is.dankortCardNumber;
+
+		/**
+		 * Test if card number is a MasterCard card number
+		 * @param {String} the credit card number string to test.
+		 * @return true if the string is the correct format, false otherwise
+		 */
+		is.masterCardCardNumber = function(str) {
+		    if (!is.str(str) || str.length !== 16)
+		        return false;
+
+		    var prefix = Math.floor(str.slice(0,2));
+		    if (prefix < 50 || prefix > 55)
+		        return false;
+
+		    if (!is.creditCardNumber(str))
+		        return false;
+
+		    return true;
+		};
+		is.masterCard = is.masterCardCard = is.masterCardCardNumber;
+
+		/**
+		 * Test if card number is a Visa card number
+		 * @param {String} the credit card number string to test.
+		 * @return true if the string is the correct format, false otherwise
+		 */
+		is.visaCardNumber = function(str) {
+		    if (!is.str(str) || (str.length !== 13 && str.length !== 16))
+		        return false;
+
+		    if ('4' !== str.slice(0,1))
+		        return false;
+
+		    if (!is.creditCardNumber(str))
+		        return false;
+
+		    return true;
+		};
+
+		is.visa = is.visaCard = is.visaCardNumber;
+
+		/**
+		 * Test if card number is a Visa card number
+		 * @param {String} the credit card number string to test.
+		 * @return true if the string is the correct format, false otherwise
+		 */
+		is.visaElectronCardNumber = function(str) {
+		    if (!is.str(str) || str.length !== 16)
+		        return false;
+
+		    var prefix = Math.floor(str.slice(0,4));
+		    var valid = [ 4026, 4405, 4508, 4844, 4913, 4917 ];
+		    if ('417500' !== str.slice(0,6) && valid.indexOf(prefix) === -1)
+		        return false;
+
+		    if (!is.creditCardNumber(str))
+		        return false;
+
+		    return false;
+		};
+
+		is.visaElectron = is.visaElectronCard = is.visaElectronCardNumber;
+
+		/**
+		 * Test if the input is a valid MongoDB id.
+		 * @param {String|Object} Either a mongodb object id or a string representation.
+		 * @return true if the string is the correct format, false otherwise
+		 * Thanks to Jason Denizac (https://github.com/jden) for pointing this out.
+		 * https://github.com/jden/objectid/blob/master/index.js#L7-L10
+		 */
+		var objIdPattern = /^[0-9a-fA-F]{24}$/;
+		is.mongoId = is.objectId = is.objId = function(id) {
+		  return (Boolean(id) && !Array.isArray(id) && objIdPattern.test(String(id)));
+		};
+
+		/**
+		 * Test is the first argument is structly equal to any of the subsequent args.
+		 * @param Value to test against subsequent arguments.
+		 * @return true if the first value matches any of subsequent values.
+		 */
+		is.matching = is.match = is.inArgs = function(val) {
+		    if (arguments.length < 2)
+		        return false;
+		    var result = false;
+		    for (var i=1; i<arguments.length; i++) {
+		        var eq = is.equal(val, arguments[i]);
+		        result = result || eq;
+		    }
+		    return result;
+		};
+
+
+
+		// US Address components
+		/**********************************
+		***Definitely a work in progress***
+		**********************************/
+		/**
+		 * Test if a string contains a US street address
+		 * @param {String} the string to search
+		 * @return true if an address is present, false otherwise
+		 */
+		is.streetAddress = function(str) {
+		  if (!is.str(str))
+		      return false;
+
+		  var regex = /\b\d+[\s](?:[A-Za-z0-9.-]+[\s]+)+\b(ALLEY|ALY|AVENUE|AVE|BEND|BND|BLUFFS?|BLFS?|BOULEVARD|BLVD|BRANCH|BR|CENTERS?|CTRS?|CIRCLES?|CIRS?|CLIFFS?|CLFS?|COURTS?|CTS?|COVES?|CVS?|CREEK|CRK|CRESCENT|CRES|CREST|CRST|CROSSING|XING|DRIVES?|DRS?|EXPRESSWAY|EXPY|FREEWAY|FWY|HEIGHTS|HTS|HIGHWAY|HWY|HILLS?|HLS?|LANE|LN|LOOP|MANORS?|MNRS?|MOTORWAY|MTWY|MOUNT|MT|PARKS?|PARKWAYS?|PKWY|PASS|PLACE|PL|PLAZA|PLZ|POINTS?|PTS?|RIDGES?|RDGS?|ROADS?|RDS?|ROUTE|RTE?|SHOALS?|SHLS?|SHORES?|SHRS?|SPRINGS?|SPGS?|SPURS?|STREETS?|STS?|SUMMIT|SMT|TERRACE|TER|THROUGHWAY|TRWY|TRAFFICWAY|TRFY|TRAIL|TRL|TURNPIKE|TPKE|VALLEYS?|VLYS?|WAYS?)+(?:[\.\-\s\,]?)*((APARTMENT|APT|APPT|#|NUMBER|NUM|FLOOR|FL|\s)?(\d)*)\b/ig;
+
+		  return regex.test(str);
+		};
+		is.street = is.address = is.streetAddress;
+
+		/**
+		 * Test if a string resembles a US Zip code,
+		 * no regular expression will be perfect for this,
+		 * as there are many numbers that aren't valid zip codes
+		 * @param {String || Number} the string or number literal to test
+		 * @return true if zipcode like, false otherwise
+		 */
+		is.zipCode = function(str) {
+		  if (is.undefined(str) || !(is.string(str) || is.number(str)))
+		    return false;
+
+		  var zip = /^\d{5}(?:-\d{4})?$/;
+		  return zip.test(str);
+		};
+		is.zip = is.zipCode;
+
+		/**
+		 * Test if a string contains a US phone number
+		 * @param {String} the string to search
+		 * @return true if str contains a phone number, false otherwise.
+		 */
+		 is.phoneNumber = function(str){
+		   if (!is.string(str))
+		    return false;
+		   var nums = /(?:(?:\+?1\s*(?:[.-]\s*)?)?(?:(\(?)(?:(\s*([2-9]1[02-9]|[2-9][02-8]1|[2-9][02-8][02-9]‌​)\s*)|([2-9]1[02-9]|[2-9][02-8]1|[2-9][02-8][02-9]))\)?)\s*(?:[.-]\s*)?)?([2-9]1[02-‌​9]|[2-9][02-9]1|[2-9][02-9]{2})\s*(?:[.-]\s*)?([0-9]{4})/g;
+		   return nums.test(str);
+		 };
+		 is.phone = is.phoneNumber;
+
+		/**
+		 * Test is a string is a valid URL
+		 * @param {string} val - the possible url to check
+		 * @return true if str contains a phone number, false otherwise.
+		 */
+		var isUrl = requireIsUrl();
+		is.url = function(val) {
+		    return isUrl(val);
+		};
+		is.uri = is.url;
+
+		is.enumerator = function(val, ary){
+		  var value = false;
+
+		  if (!is.defined(val) || !is.defined(ary) || !is.arrayLike(ary))
+		    return value;
+
+		  for (var i = 0, len = ary.length; i < len; i++) {
+		    if (is.equal(val, ary[i])) {
+		      value = true;
+		      break;
+		    }
+		  }
+		  return value;
+		};
+		is.enum = is.inArray = is.enumerator; 
+	} (is2));
+	return is2;
+}
+
+var src = {exports: {}};
+
+var browser = {exports: {}};
+
+/**
+ * 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$2;
+var hasRequiredCommon$2;
+
+function requireCommon$2 () {
+	if (hasRequiredCommon$2) return common$2;
+	hasRequiredCommon$2 = 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 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;
+
+			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: () => enableOverride === null ? createDebug.enabled(namespace) : enableOverride,
+				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.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.substr(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$2 = setup;
+	return common$2;
+}
+
+/* eslint-env browser */
+
+var hasRequiredBrowser;
+
+function requireBrowser () {
+	if (hasRequiredBrowser) return browser.exports;
+	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$2()(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, browser.exports));
+	return browser.exports;
+}
+
+var node = {exports: {}};
+
+/**
+ * Module dependencies.
+ */
+
+var hasRequiredNode;
+
+function requireNode () {
+	if (hasRequiredNode) return node.exports;
+	hasRequiredNode = 1;
+	(function (module, exports) {
+		const tty = require$$0__default$1;
+		const util = require$$0__default;
+
+		/**
+		 * 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 = require('supports-color');
+
+			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$2()(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, node.exports));
+	return node.exports;
+}
+
+/**
+ * Detect Electron renderer / nwjs process, which is node, but we should
+ * treat as a browser.
+ */
+
+var hasRequiredSrc;
+
+function requireSrc () {
+	if (hasRequiredSrc) return src.exports;
+	hasRequiredSrc = 1;
+	if (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) {
+		src.exports = requireBrowser();
+	} else {
+		src.exports = requireNode();
+	}
+	return src.exports;
+}
+
+/**
+ * @fileOverview
+ * A simple promises-based check to see if a TCP port is already in use.
+ */
+
+var hasRequiredTcpPortUsed;
+
+function requireTcpPortUsed () {
+	if (hasRequiredTcpPortUsed) return tcpPortUsed$1;
+	hasRequiredTcpPortUsed = 1;
+
+	// define the exports first to avoid cyclic dependencies.
+	tcpPortUsed$1.check = check;
+	tcpPortUsed$1.waitUntilFreeOnHost = waitUntilFreeOnHost;
+	tcpPortUsed$1.waitUntilFree = waitUntilFree;
+	tcpPortUsed$1.waitUntilUsedOnHost = waitUntilUsedOnHost;
+	tcpPortUsed$1.waitUntilUsed = waitUntilUsed;
+	tcpPortUsed$1.waitForStatus = waitForStatus;
+
+	var is = requireIs2();
+	var net = require$$1__default;
+	var util = require$$0__default;
+	var debug = requireSrc()('tcp-port-used');
+
+	// Global Values
+	var TIMEOUT = 2000;
+	var RETRYTIME = 250;
+
+	function getDeferred() {
+	    var resolve, reject, promise = new Promise(function(res, rej) {
+	        resolve = res;
+	        reject = rej;
+	    });
+
+	    return {
+	        resolve: resolve,
+	        reject: reject,
+	        promise: promise
+	    };
+	}
+
+	/**
+	 * Creates an options object from all the possible arguments
+	 * @private
+	 * @param {Number} port a valid TCP port number
+	 * @param {String} host The DNS name or IP address.
+	 * @param {Boolean} status The desired in use status to wait for: false === not in use, true === in use
+	 * @param {Number} retryTimeMs the retry interval in milliseconds - defaultis is 200ms
+	 * @param {Number} timeOutMs the amount of time to wait until port is free default is 1000ms
+	 * @return {Object} An options object with all the above parameters as properties.
+	 */
+	function makeOptionsObj(port, host, inUse, retryTimeMs, timeOutMs) {
+	    var opts = {};
+	    opts.port = port;
+	    opts.host = host;
+	    opts.inUse = inUse;
+	    opts.retryTimeMs = retryTimeMs;
+	    opts.timeOutMs = timeOutMs;
+	    return opts;
+	}
+
+	/**
+	 * Checks if a TCP port is in use by creating the socket and binding it to the
+	 * target port. Once bound, successfully, it's assume the port is availble.
+	 * After the socket is closed or in error, the promise is resolved.
+	 * Note: you have to be super user to correctly test system ports (0-1023).
+	 * @param {Number|Object} port The port you are curious to see if available. If an object, must have the parameters as properties.
+	 * @param {String} [host] May be a DNS name or IP address. Default '127.0.0.1'
+	 * @return {Object} A deferred Q promise.
+	 *
+	 * Example usage:
+	 *
+	 * var tcpPortUsed = require('tcp-port-used');
+	 * tcpPortUsed.check(22, '127.0.0.1')
+	 * .then(function(inUse) {
+	 *    debug('Port 22 usage: '+inUse);
+	 * }, function(err) {
+	 *    console.error('Error on check: '+util.inspect(err));
+	 * });
+	 */
+	function check(port, host) {
+
+	    var deferred = getDeferred();
+	    var inUse = true;
+	    var client;
+
+	    var opts;
+	    if (!is.obj(port)) {
+	        opts = makeOptionsObj(port, host);
+	    } else {
+	        opts = port;
+	    }
+
+	    if (!is.port(opts.port)) {
+	        debug('Error invalid port: '+util.inspect(opts.port));
+	        deferred.reject(new Error('invalid port: '+util.inspect(opts.port)));
+	        return deferred.promise;
+	    }
+
+	    if (is.nullOrUndefined(opts.host)) {
+	        debug('set host address to default 127.0.0.1');
+	        opts.host = '127.0.0.1';
+	    }
+
+	    function cleanUp() {
+	        if (client) {
+	            client.removeAllListeners('connect');
+	            client.removeAllListeners('error');
+	            client.end();
+	            client.destroy();
+	            client.unref();
+	        }
+	        //debug('listeners removed from client socket');
+	    }
+
+	    function onConnectCb() {
+	        //debug('check - promise resolved - in use');
+	        deferred.resolve(inUse);
+	        cleanUp();
+	    }
+
+	    function onErrorCb(err) {
+	        if (err.code !== 'ECONNREFUSED') {
+	            //debug('check - promise rejected, error: '+err.message);
+	            deferred.reject(err);
+	        } else {
+	            //debug('ECONNREFUSED');
+	            inUse = false;
+	            //debug('check - promise resolved - not in use');
+	            deferred.resolve(inUse);
+	        }
+	        cleanUp();
+	    }
+
+	    client = new net.Socket();
+	    client.once('connect', onConnectCb);
+	    client.once('error', onErrorCb);
+	    client.connect({port: opts.port, host: opts.host}, function() {});
+
+	    return deferred.promise;
+	}
+
+	/**
+	 * Creates a deferred promise and fulfills it only when the socket's usage
+	 * equals status in terms of 'in use' (false === not in use, true === in use).
+	 * Will retry on an interval specified in retryTimeMs.  Note: you have to be
+	 * super user to correctly test system ports (0-1023).
+	 * @param {Number|Object} port a valid TCP port number, if an object, has all the parameters described as properties.
+	 * @param {String} host The DNS name or IP address.
+	 * @param {Boolean} status The desired in use status to wait for false === not in use, true === in use
+	 * @param {Number} [retryTimeMs] the retry interval in milliseconds - defaultis is 200ms
+	 * @param {Number} [timeOutMs] the amount of time to wait until port is free default is 1000ms
+	 * @return {Object} A deferred promise from the Q library.
+	 *
+	 * Example usage:
+	 *
+	 * var tcpPortUsed = require('tcp-port-used');
+	 * tcpPortUsed.waitForStatus(44204, 'some.host.com', true, 500, 4000)
+	 * .then(function() {
+	 *     console.log('Port 44204 is now in use.');
+	 * }, function(err) {
+	 *     console.log('Error: ', error.message);
+	 * });
+	 */
+	function waitForStatus(port, host, inUse, retryTimeMs, timeOutMs) {
+
+	    var deferred = getDeferred();
+	    var timeoutId;
+	    var timedout = false;
+	    var retryId;
+
+	    // the first arument may be an object, if it is not, make an object
+	    var opts;
+	    if (is.obj(port)) {
+	        opts = port;
+	    } else {
+	        opts = makeOptionsObj(port, host, inUse, retryTimeMs, timeOutMs);
+	    }
+
+	    //debug('opts:'+util.inspect(opts);
+
+	    if (!is.bool(opts.inUse)) {
+	        deferred.reject(new Error('inUse must be a boolean'));
+	        return deferred.promise;
+	    }
+
+	    if (!is.positiveInt(opts.retryTimeMs)) {
+	        opts.retryTimeMs = RETRYTIME;
+	        debug('set retryTime to default '+RETRYTIME+'ms');
+	    }
+
+	    if (!is.positiveInt(opts.timeOutMs)) {
+	        opts.timeOutMs = TIMEOUT;
+	        debug('set timeOutMs to default '+TIMEOUT+'ms');
+	    }
+
+	    function cleanUp() {
+	        if (timeoutId) {
+	            clearTimeout(timeoutId);
+	        }
+	        if (retryId) {
+	            clearTimeout(retryId);
+	        }
+	    }
+
+	    function timeoutFunc() {
+	        timedout = true;
+	        cleanUp();
+	        deferred.reject(new Error('timeout'));
+	    }
+	    timeoutId = setTimeout(timeoutFunc, opts.timeOutMs);
+
+	    function doCheck() {
+	        check(opts.port, opts.host)
+	        .then(function(inUse) {
+	            if (timedout) {
+	                return;
+	            }
+	            //debug('doCheck inUse: '+inUse);
+	            //debug('doCheck opts.inUse: '+opts.inUse);
+	            if (inUse === opts.inUse) {
+	                deferred.resolve();
+	                cleanUp();
+	                return;
+	            } else {
+	                retryId = setTimeout(function() { doCheck(); }, opts.retryTimeMs);
+	                return;
+	            }
+	        }, function(err) {
+	            if (timedout) {
+	                return;
+	            }
+	            deferred.reject(err);
+	            cleanUp();
+	        });
+	    }
+
+	    doCheck();
+	    return deferred.promise;
+	}
+
+	/**
+	 * Creates a deferred promise and fulfills it only when the socket is free.
+	 * Will retry on an interval specified in retryTimeMs.
+	 * Note: you have to be super user to correctly test system ports (0-1023).
+	 * @param {Number} port a valid TCP port number
+	 * @param {String} [host] The hostname or IP address of where the socket is.
+	 * @param {Number} [retryTimeMs] the retry interval in milliseconds - defaultis is 100ms.
+	 * @param {Number} [timeOutMs] the amount of time to wait until port is free. Default 300ms.
+	 * @return {Object} A deferred promise from the q library.
+	 *
+	 * Example usage:
+	 *
+	 * var tcpPortUsed = require('tcp-port-used');
+	 * tcpPortUsed.waitUntilFreeOnHost(44203, 'some.host.com', 500, 4000)
+	 * .then(function() {
+	 *     console.log('Port 44203 is now free.');
+	 *  }, function(err) {
+	 *     console.loh('Error: ', error.message);
+	 *  });
+	 */
+	function waitUntilFreeOnHost(port, host, retryTimeMs, timeOutMs) {
+
+	    // the first arument may be an object, if it is not, make an object
+	    var opts;
+	    if (is.obj(port)) {
+	        opts = port;
+	        opts.inUse = false;
+	    } else {
+	        opts = makeOptionsObj(port, host, false, retryTimeMs, timeOutMs);
+	    }
+
+	    return waitForStatus(opts);
+	}
 
-			black: f("\x1b[30m", "\x1b[39m"),
-			red: f("\x1b[31m", "\x1b[39m"),
-			green: f("\x1b[32m", "\x1b[39m"),
-			yellow: f("\x1b[33m", "\x1b[39m"),
-			blue: f("\x1b[34m", "\x1b[39m"),
-			magenta: f("\x1b[35m", "\x1b[39m"),
-			cyan: f("\x1b[36m", "\x1b[39m"),
-			white: f("\x1b[37m", "\x1b[39m"),
-			gray: f("\x1b[90m", "\x1b[39m"),
+	/**
+	 * For compatibility with previous version of the module, that did not provide
+	 * arguements for hostnames. The host is set to the localhost '127.0.0.1'.
+	 * @param {Number|Object} port a valid TCP port number. If an object, must contain all the parameters as properties.
+	 * @param {Number} [retryTimeMs] the retry interval in milliseconds - defaultis is 100ms.
+	 * @param {Number} [timeOutMs] the amount of time to wait until port is free. Default 300ms.
+	 * @return {Object} A deferred promise from the q library.
+	 *
+	 * Example usage:
+	 *
+	 * var tcpPortUsed = require('tcp-port-used');
+	 * tcpPortUsed.waitUntilFree(44203, 500, 4000)
+	 * .then(function() {
+	 *     console.log('Port 44203 is now free.');
+	 *  }, function(err) {
+	 *     console.loh('Error: ', error.message);
+	 *  });
+	 */
+	function waitUntilFree(port, retryTimeMs, timeOutMs) {
+
+	    // the first arument may be an object, if it is not, make an object
+	    var opts;
+	    if (is.obj(port)) {
+	        opts = port;
+	        opts.host = '127.0.0.1';
+	        opts.inUse = false;
+	    } else {
+	        opts = makeOptionsObj(port, '127.0.0.1', false, retryTimeMs, timeOutMs);
+	    }
 
-			bgBlack: f("\x1b[40m", "\x1b[49m"),
-			bgRed: f("\x1b[41m", "\x1b[49m"),
-			bgGreen: f("\x1b[42m", "\x1b[49m"),
-			bgYellow: f("\x1b[43m", "\x1b[49m"),
-			bgBlue: f("\x1b[44m", "\x1b[49m"),
-			bgMagenta: f("\x1b[45m", "\x1b[49m"),
-			bgCyan: f("\x1b[46m", "\x1b[49m"),
-			bgWhite: f("\x1b[47m", "\x1b[49m"),
+	    return waitForStatus(opts);
+	}
 
-			blackBright: f("\x1b[90m", "\x1b[39m"),
-			redBright: f("\x1b[91m", "\x1b[39m"),
-			greenBright: f("\x1b[92m", "\x1b[39m"),
-			yellowBright: f("\x1b[93m", "\x1b[39m"),
-			blueBright: f("\x1b[94m", "\x1b[39m"),
-			magentaBright: f("\x1b[95m", "\x1b[39m"),
-			cyanBright: f("\x1b[96m", "\x1b[39m"),
-			whiteBright: f("\x1b[97m", "\x1b[39m"),
+	/**
+	 * Creates a deferred promise and fulfills it only when the socket is used.
+	 * Will retry on an interval specified in retryTimeMs.
+	 * Note: you have to be super user to correctly test system ports (0-1023).
+	 * @param {Number|Object} port a valid TCP port number. If an object, must contain all the parameters as properties.
+	 * @param {Number} [retryTimeMs] the retry interval in milliseconds - defaultis is 500ms
+	 * @param {Number} [timeOutMs] the amount of time to wait until port is free
+	 * @return {Object} A deferred promise from the q library.
+	 *
+	 * Example usage:
+	 *
+	 * var tcpPortUsed = require('tcp-port-used');
+	 * tcpPortUsed.waitUntilUsedOnHost(44204, 'some.host.com', 500, 4000)
+	 * .then(function() {
+	 *     console.log('Port 44204 is now in use.');
+	 * }, function(err) {
+	 *     console.log('Error: ', error.message);
+	 * });
+	 */
+	function waitUntilUsedOnHost(port, host, retryTimeMs, timeOutMs) {
 
-			bgBlackBright: f("\x1b[100m", "\x1b[49m"),
-			bgRedBright: f("\x1b[101m", "\x1b[49m"),
-			bgGreenBright: f("\x1b[102m", "\x1b[49m"),
-			bgYellowBright: f("\x1b[103m", "\x1b[49m"),
-			bgBlueBright: f("\x1b[104m", "\x1b[49m"),
-			bgMagentaBright: f("\x1b[105m", "\x1b[49m"),
-			bgCyanBright: f("\x1b[106m", "\x1b[49m"),
-			bgWhiteBright: f("\x1b[107m", "\x1b[49m"),
-		}
-	};
+	    // the first arument may be an object, if it is not, make an object
+	    var opts;
+	    if (is.obj(port)) {
+	        opts = port;
+	        opts.inUse = true;
+	    } else {
+	        opts = makeOptionsObj(port, host, true, retryTimeMs, timeOutMs);
+	    }
 
-	picocolors.exports = createColors();
-	picocolors.exports.createColors = createColors;
-	return picocolors.exports;
-}
+	    return waitForStatus(opts);
+	}
 
-var picocolorsExports = /*@__PURE__*/ requirePicocolors();
-const colors = /*@__PURE__*/getDefaultExportFromCjs(picocolorsExports);
+	/**
+	 * For compatibility to previous version of module which did not have support
+	 * for host addresses. This function works only for localhost.
+	 * @param {Number} port a valid TCP port number. If an Object, must contain all the parameters as properties.
+	 * @param {Number} [retryTimeMs] the retry interval in milliseconds - defaultis is 500ms
+	 * @param {Number} [timeOutMs] the amount of time to wait until port is free
+	 * @return {Object} A deferred promise from the q library.
+	 *
+	 * Example usage:
+	 *
+	 * var tcpPortUsed = require('tcp-port-used');
+	 * tcpPortUsed.waitUntilUsed(44204, 500, 4000)
+	 * .then(function() {
+	 *     console.log('Port 44204 is now in use.');
+	 * }, function(err) {
+	 *     console.log('Error: ', error.message);
+	 * });
+	 */
+	function waitUntilUsed(port, retryTimeMs, timeOutMs) {
+
+	    // the first arument may be an object, if it is not, make an object
+	    var opts;
+	    if (is.obj(port)) {
+	        opts = port;
+	        opts.host = '127.0.0.1';
+	        opts.inUse = true;
+	    } else {
+	        opts = makeOptionsObj(port, '127.0.0.1', true, retryTimeMs, timeOutMs);
+	    }
 
-function hasViteConfig(input) {
-  if (!input) {
-    throw new Error("Vite config not initialized!");
-  }
+	    return waitUntilUsedOnHost(opts);
+	}
+	return tcpPortUsed$1;
 }
 
-function log(message, { type = "info", prefix = true, ...options } = {}) {
-  hasViteConfig(shared.viteConfig);
-  let output = "";
-  if (prefix) {
-    output += colors.bgMagenta(colors.white("\u2009php\u2009")) + " ";
-  }
-  output += message;
-  shared.viteConfig.logger[type](output, options);
-}
-log.error = function(json, options = {}) {
-  let output = json;
-  let type = "info";
-  try {
-    const data = JSON.parse(json);
-    output = "";
-    switch (data.code) {
-      case EPHPError.PARSE:
-      case EPHPError.ERROR:
-      case EPHPError.CORE_ERROR:
-      case EPHPError.COMPILE_ERROR:
-      case EPHPError.USER_ERROR:
-        type = "error";
-        output += colors.bgRedBright(colors.white("Fatal Error"));
-        break;
-      case EPHPError.WARNING:
-      case EPHPError.USER_WARNING:
-      case EPHPError.COMPILE_WARNING:
-      case EPHPError.RECOVERABLE_ERROR:
-        type = "warn";
-        output += colors.yellowBright("Warning");
-        break;
-      case EPHPError.NOTICE:
-      case EPHPError.USER_NOTICE:
-        type = "info";
-        output += colors.bgWhite(colors.black("Notice"));
-        break;
-      case EPHPError.STRICT:
-        type = "info";
-        output += colors.yellow("Strict");
-        break;
-      case EPHPError.DEPRECATED:
-      case EPHPError.USER_DEPRECATED:
-        type = "info";
-        output += colors.cyan("Deprecated");
-        break;
-      default:
-        break;
-    }
-    output += " " + data.message + "\r\n";
-    output += "	In: " + data.file.replace(
-      node_path.resolve(shared.tempDir),
-      shared.viteConfig?.root
-    ) + "\r\n";
-    output += "	On line: " + data.line;
-  } catch (error) {
-  }
-  log(output, { ...options, type });
-};
+var tcpPortUsedExports = requireTcpPortUsed();
+const tcpPortUsed = /*@__PURE__*/getDefaultExportFromCjs(tcpPortUsedExports);
 
 const PHP_Server = {
   binary: "php",
@@ -225,11 +3279,11 @@ const PHP_Server = {
   start,
   stop
 };
-async function start(root) {
+async function start(root = shared.projectRoot) {
   if (!PHP_Server.process?.pid) {
     await new Promise(async (resolve, reject) => {
       const routerFileUrl = new URL("./router.php", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
-      while (await tcpPortUsed__default.check(PHP_Server.port, PHP_Server.host)) {
+      while (await tcpPortUsed.check(PHP_Server.port, PHP_Server.host)) {
         PHP_Server.port++;
       }
       PHP_Server.process = node_child_process.spawn(PHP_Server.binary, [
@@ -237,7 +3291,7 @@ async function start(root) {
         `${PHP_Server.host}:${PHP_Server.port}`,
         "-t",
         root,
-        url.fileURLToPath(routerFileUrl)
+        node_url.fileURLToPath(routerFileUrl)
       ]).once("spawn", () => {
         log(`Server started (PID: ${PHP_Server.process?.pid})`);
         resolve(PHP_Server.process?.pid);
@@ -373,8 +3427,8 @@ function requirePath () {
 	hasRequiredPath = 1;
 	Object.defineProperty(path, "__esModule", { value: true });
 	path.convertPosixPathToPattern = path.convertWindowsPathToPattern = path.convertPathToPattern = path.escapePosixPath = path.escapeWindowsPath = path.escape = path.removeLeadingDotSegment = path.makeAbsolute = path.unixify = void 0;
-	const os = require$$0__default;
-	const path$1 = require$$0__default$1;
+	const os = require$$0__default$2;
+	const path$1 = require$$0__default$3;
 	const IS_WINDOWS_PLATFORM = os.platform() === 'win32';
 	const LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2; // ./ or .\\
 	/**
@@ -639,8 +3693,8 @@ function requireGlobParent () {
 	hasRequiredGlobParent = 1;
 
 	var isGlob = requireIsGlob();
-	var pathPosixDirname = require$$0__default$1.posix.dirname;
-	var isWin32 = require$$0__default.platform() === 'win32';
+	var pathPosixDirname = require$$0__default$3.posix.dirname;
+	var isWin32 = require$$0__default$2.platform() === 'win32';
 
 	var slash = '/';
 	var backslash = /\\/g;
@@ -1189,7 +4243,7 @@ function requireFillRange () {
 	if (hasRequiredFillRange) return fillRange;
 	hasRequiredFillRange = 1;
 
-	const util = require$$0__default$2;
+	const util = require$$0__default;
 	const toRegexRange = requireToRegexRange();
 
 	const isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
@@ -2211,7 +5265,7 @@ function requireConstants$1 () {
 	if (hasRequiredConstants$1) return constants$1;
 	hasRequiredConstants$1 = 1;
 
-	const path = require$$0__default$1;
+	const path = require$$0__default$3;
 	const WIN_SLASH = '\\\\/';
 	const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
 
@@ -2398,7 +5452,7 @@ function requireUtils$2 () {
 	hasRequiredUtils$2 = 1;
 	(function (exports) {
 
-		const path = require$$0__default$1;
+		const path = require$$0__default$3;
 		const win32 = process.platform === 'win32';
 		const {
 		  REGEX_BACKSLASH,
@@ -3969,7 +7023,7 @@ function requirePicomatch$1 () {
 	if (hasRequiredPicomatch$1) return picomatch_1;
 	hasRequiredPicomatch$1 = 1;
 
-	const path = require$$0__default$1;
+	const path = require$$0__default$3;
 	const scan = requireScan();
 	const parse = requireParse();
 	const utils = requireUtils$2();
@@ -4330,7 +7384,7 @@ function requireMicromatch () {
 	if (hasRequiredMicromatch) return micromatch_1;
 	hasRequiredMicromatch = 1;
 
-	const util = require$$0__default$2;
+	const util = require$$0__default;
 	const braces = requireBraces();
 	const picomatch = requirePicomatch();
 	const utils = requireUtils$2();
@@ -4812,7 +7866,7 @@ function requirePattern () {
 	hasRequiredPattern = 1;
 	Object.defineProperty(pattern, "__esModule", { value: true });
 	pattern.isAbsolute = pattern.partitionAbsoluteAndRelative = pattern.removeDuplicateSlashes = pattern.matchAny = pattern.convertPatternsToRe = pattern.makeRe = pattern.getPatternParts = pattern.expandBraceExpansion = pattern.expandPatternsWithBraceExpansion = pattern.isAffectDepthOfReadingPattern = pattern.endsWithSlashGlobStar = pattern.hasGlobStar = pattern.getBaseDirectory = pattern.isPatternRelatedToParentDirectory = pattern.getPatternsOutsideCurrentDirectory = pattern.getPatternsInsideCurrentDirectory = pattern.getPositivePatterns = pattern.getNegativePatterns = pattern.isPositivePattern = pattern.isNegativePattern = pattern.convertToNegativePattern = pattern.convertToPositivePattern = pattern.isDynamicPattern = pattern.isStaticPattern = void 0;
-	const path = require$$0__default$1;
+	const path = require$$0__default$3;
 	const globParent = requireGlobParent();
 	const micromatch = requireMicromatch();
 	const GLOBSTAR = '**';
@@ -5033,7 +8087,7 @@ function requireMerge2 () {
 	 * Copyright (c) 2014-2020 Teambition
 	 * Licensed under the MIT license.
 	 */
-	const Stream = require$$0__default$3;
+	const Stream = require$$0__default$4;
 	const PassThrough = Stream.PassThrough;
 	const slice = Array.prototype.slice;
 
@@ -5462,7 +8516,7 @@ function requireFs$2 () {
 	(function (exports) {
 		Object.defineProperty(exports, "__esModule", { value: true });
 		exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
-		const fs = require$$0__default$4;
+		const fs = require$$0__default$5;
 		exports.FILE_SYSTEM_ADAPTER = {
 		    lstat: fs.lstat,
 		    stat: fs.stat,
@@ -5892,7 +8946,7 @@ function requireFs () {
 	(function (exports) {
 		Object.defineProperty(exports, "__esModule", { value: true });
 		exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
-		const fs = require$$0__default$4;
+		const fs = require$$0__default$5;
 		exports.FILE_SYSTEM_ADAPTER = {
 		    lstat: fs.lstat,
 		    stat: fs.stat,
@@ -5918,7 +8972,7 @@ function requireSettings$2 () {
 	if (hasRequiredSettings$2) return settings$2;
 	hasRequiredSettings$2 = 1;
 	Object.defineProperty(settings$2, "__esModule", { value: true });
-	const path = require$$0__default$1;
+	const path = require$$0__default$3;
 	const fsStat = requireOut$3();
 	const fs = requireFs();
 	class Settings {
@@ -6403,7 +9457,7 @@ function requireAsync$3 () {
 	if (hasRequiredAsync$3) return async$2;
 	hasRequiredAsync$3 = 1;
 	Object.defineProperty(async$2, "__esModule", { value: true });
-	const events_1 = require$$0__default$5;
+	const events_1 = require$$0__default$6;
 	const fsScandir = requireOut$2();
 	const fastq = requireQueue();
 	const common = requireCommon();
@@ -6546,7 +9600,7 @@ function requireStream$2 () {
 	if (hasRequiredStream$2) return stream$2;
 	hasRequiredStream$2 = 1;
 	Object.defineProperty(stream$2, "__esModule", { value: true });
-	const stream_1 = require$$0__default$3;
+	const stream_1 = require$$0__default$4;
 	const async_1 = requireAsync$3();
 	class StreamProvider {
 	    constructor(_root, _settings) {
@@ -6680,7 +9734,7 @@ function requireSettings$1 () {
 	if (hasRequiredSettings$1) return settings$1;
 	hasRequiredSettings$1 = 1;
 	Object.defineProperty(settings$1, "__esModule", { value: true });
-	const path = require$$0__default$1;
+	const path = require$$0__default$3;
 	const fsScandir = requireOut$2();
 	class Settings {
 	    constructor(_options = {}) {
@@ -6756,7 +9810,7 @@ function requireReader () {
 	if (hasRequiredReader) return reader;
 	hasRequiredReader = 1;
 	Object.defineProperty(reader, "__esModule", { value: true });
-	const path = require$$0__default$1;
+	const path = require$$0__default$3;
 	const fsStat = requireOut$3();
 	const utils = requireUtils$1();
 	class Reader {
@@ -6798,7 +9852,7 @@ function requireStream$1 () {
 	if (hasRequiredStream$1) return stream$1;
 	hasRequiredStream$1 = 1;
 	Object.defineProperty(stream$1, "__esModule", { value: true });
-	const stream_1 = require$$0__default$3;
+	const stream_1 = require$$0__default$4;
 	const fsStat = requireOut$3();
 	const fsWalk = requireOut$1();
 	const reader_1 = requireReader();
@@ -7229,7 +10283,7 @@ function requireProvider () {
 	if (hasRequiredProvider) return provider;
 	hasRequiredProvider = 1;
 	Object.defineProperty(provider, "__esModule", { value: true });
-	const path = require$$0__default$1;
+	const path = require$$0__default$3;
 	const deep_1 = requireDeep();
 	const entry_1 = requireEntry$1();
 	const error_1 = requireError();
@@ -7316,7 +10370,7 @@ function requireStream () {
 	if (hasRequiredStream) return stream;
 	hasRequiredStream = 1;
 	Object.defineProperty(stream, "__esModule", { value: true });
-	const stream_1 = require$$0__default$3;
+	const stream_1 = require$$0__default$4;
 	const stream_2 = requireStream$1();
 	const provider_1 = requireProvider();
 	class ProviderStream extends provider_1.default {
@@ -7442,8 +10496,8 @@ function requireSettings () {
 	(function (exports) {
 		Object.defineProperty(exports, "__esModule", { value: true });
 		exports.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
-		const fs = require$$0__default$4;
-		const os = require$$0__default;
+		const fs = require$$0__default$5;
+		const os = require$$0__default$2;
 		/**
 		 * The `os.cpus` method can return zero. We expect the number of cores to be greater than zero.
 		 * https://github.com/nodejs/node/blob/7faeddf23a98c53896f8b574a6e66589e8fb1eb8/lib/os.js#L106-L107
@@ -7613,23 +10667,6 @@ function requireOut () {
 var outExports = requireOut();
 const fastGlob = /*@__PURE__*/getDefaultExportFromCjs(outExports);
 
-function consoleHijack() {
-  const entries = shared.entries;
-  ["log", "info", "warn", "error"].forEach((command) => {
-    const cx = console[command];
-    console[command] = function(...args) {
-      cx.apply(
-        this,
-        args.map(
-          (arg) => typeof arg === "string" ? entries.reduce((acc, entry) => {
-            return acc.replace(entry + ".html", entry);
-          }, arg) : arg
-        )
-      );
-    };
-  });
-}
-
 function readFile(file) {
   return node_fs.readFileSync(file, "utf-8").toString();
 }
@@ -7637,6 +10674,9 @@ function writeFile(file, data) {
   node_fs.mkdirSync(node_path.dirname(file), { recursive: true });
   node_fs.writeFileSync(file, data);
 }
+function tempName(entry) {
+  return `${shared.tempDir}/${entry}`;
+}
 
 function makeID() {
   return Date.now().toString(36) + Math.random() * 100;
@@ -7795,164 +10835,106 @@ const handleExit = {
   }
 };
 
-const serve = {
-  rewriteUrl: (url) => url
-};
-function tempName(entry) {
-  return `${shared.tempDir}/${entry}`;
-}
-const servePlugin = {
-  name: "serve-php",
-  apply: "serve",
-  enforce: "post",
-  configResolved() {
-    handleExit.register();
-    const gitIgnoreFile = node_path.resolve(`${shared.tempDir}/.gitignore`);
-    if (!node_fs.existsSync(gitIgnoreFile)) {
-      writeFile(gitIgnoreFile, "*\r\n**/*");
-    }
-    shared.entries.forEach((entry) => {
-      PHP_Code.fromFile(entry).applyEnv().write(tempName(entry));
-    });
-  },
-  async configureServer(server) {
-    server.restart = /* @__PURE__ */ ((originalRestart) => {
-      return async function(...args) {
-        handleExit.unregister();
-        return originalRestart.apply(null, args);
-      };
-    })(server.restart);
-    if (!PHP_Server.process) {
-      await PHP_Server.start(server?.config.root);
-    }
-    server.middlewares.use(async (req, res, next) => {
-      try {
-        if (req.url && !["/@vite", "/@fs", "/@id/__x00__", "/node_modules"].some(
-          (path) => req.url.startsWith(path)
-        )) {
-          req.on("error", (error) => {
-            throw error;
-          });
-          const url = new URL(req.url, "http://localhost");
-          if (shared.viteConfig?.server.port) {
-            url.port = shared.viteConfig.server.port.toString();
-          }
-          const requestUrl = url.pathname;
-          if (url.pathname.endsWith("/")) {
-            url.pathname += "index.php";
-          }
-          const routedUrl = serve.rewriteUrl(url);
-          if (routedUrl) {
-            url.pathname = routedUrl.pathname;
-            url.search = routedUrl.search;
-            url.hash = routedUrl.hash;
-          }
-          const entryPathname = url.pathname.substring(1);
-          const entry = shared.entries.find((file) => {
-            return file === entryPathname || file.substring(0, file.lastIndexOf(".")) === entryPathname;
-          });
-          if (entry) {
-            const tempFile = tempName(entry);
-            if (node_fs.existsSync(node_path.resolve(tempFile))) {
-              url.pathname = tempFile;
-              url.host = PHP_Server.host;
-              url.port = PHP_Server.port.toString();
-              url.searchParams.set(
-                internalParam,
-                new URLSearchParams({
-                  $REQUEST_URI: requestUrl,
-                  $PHP_SELF: "/" + entry,
-                  temp_dir: shared.tempDir,
-                  error_levels: shared.devConfig.errorLevels.toString()
-                }).toString()
-              );
-              const body = await new Promise(
-                (resolve2, reject) => {
-                  let data = [];
-                  req.on("data", (chunk) => {
-                    data.push(chunk);
-                  }).on("end", () => {
-                    resolve2(Buffer.concat(data));
-                  });
+const phpProxy = async (req, res, next) => {
+  try {
+    if (req.url && !["/@vite", "/@fs", "/@id/__x00__", "/node_modules"].some(
+      (path) => req.url.startsWith(path)
+    )) {
+      req.on("error", (error) => {
+        throw error;
+      });
+      const url = new URL(req.url, "http://localhost");
+      if (shared.viteConfig?.server.port) {
+        url.port = shared.viteConfig.server.port.toString();
+      }
+      const requestUrl = url.pathname;
+      if (url.pathname.endsWith("/")) {
+        url.pathname += "index.php";
+      }
+      const routedUrl = serve.rewriteUrl(url);
+      if (routedUrl) {
+        url.pathname = routedUrl.pathname;
+        url.search = routedUrl.search;
+        url.hash = routedUrl.hash;
+      }
+      const entryPathname = url.pathname.substring(1);
+      const entry = shared.entries.find((file) => {
+        return file === entryPathname || file.substring(0, file.lastIndexOf(".")) === entryPathname;
+      });
+      if (entry) {
+        const tempFile = tempName(entry);
+        if (node_fs.existsSync(node_path.resolve(tempFile))) {
+          url.pathname = tempFile;
+          url.host = PHP_Server.host;
+          url.port = PHP_Server.port.toString();
+          url.searchParams.set(
+            internalParam,
+            new URLSearchParams({
+              $REQUEST_URI: requestUrl,
+              $PHP_SELF: "/" + entry,
+              temp_dir: shared.tempDir,
+              error_levels: shared.devConfig.errorLevels.toString()
+            }).toString()
+          );
+          const body = await new Promise(
+            (resolve2, reject) => {
+              let data = [];
+              req.on("data", (chunk) => {
+                data.push(chunk);
+              }).on("end", () => {
+                resolve2(Buffer.concat(data));
+              });
+            }
+          );
+          const phpResult = await new Promise(async (resolve2, reject) => {
+            const chunks = [];
+            let statusCode;
+            let incomingHeaders = {};
+            const request = http__default.request(
+              url.toString(),
+              {
+                method: req.method,
+                headers: {
+                  ...req.headers,
+                  "content-length": Buffer.byteLength(body)
                 }
-              );
-              const phpResult = await new Promise(async (resolve2, reject) => {
-                const chunks = [];
-                let statusCode;
-                let incomingHeaders = {};
-                const request = http__default.request(
-                  url.toString(),
-                  {
-                    method: req.method,
-                    headers: {
-                      ...req.headers,
-                      "content-length": Buffer.byteLength(body)
-                    }
-                  },
-                  (msg) => {
-                    statusCode = msg.statusCode;
-                    incomingHeaders = msg.headers;
-                    msg.on("data", (data) => {
-                      chunks.push(data);
-                    });
-                  }
-                ).on("error", (error) => {
-                  reject(error);
-                }).on("close", () => {
-                  const content = Buffer.concat(chunks).toString(
-                    "utf8"
-                  );
-                  resolve2({
-                    statusCode,
-                    headers: incomingHeaders,
-                    content
-                  });
-                });
-                request.write(body, (error) => {
-                  if (error) {
-                    reject(error);
-                  }
+              },
+              (msg) => {
+                statusCode = msg.statusCode;
+                incomingHeaders = msg.headers;
+                msg.on("data", (data) => {
+                  chunks.push(data);
                 });
-                request.end();
+              }
+            ).on("error", (error) => {
+              reject(error);
+            }).on("close", () => {
+              const content = Buffer.concat(chunks).toString("utf8");
+              resolve2({
+                statusCode,
+                headers: incomingHeaders,
+                content
               });
-              let out = phpResult.content;
-              if (phpResult.headers["content-type"]?.includes(
-                "html"
-              )) {
-                out = await server.transformIndexHtml(
-                  `/${entry}.html:${requestUrl}`,
-                  out,
-                  requestUrl
-                );
+            });
+            request.write(body, (error) => {
+              if (error) {
+                reject(error);
               }
-              res.writeHead(
-                phpResult.statusCode || 200,
-                phpResult.headers
-              ).end(out);
-              return;
-            }
-          }
+            });
+            request.end();
+          });
+          res.writeHead(
+            phpResult.statusCode || 200,
+            phpResult.headers
+          ).end(phpResult.content);
+          return;
         }
-      } catch (error) {
-        console.error("Vite-PHP Error: " + error);
       }
-      next();
-    });
-  },
-  handleHotUpdate({ server, file }) {
-    const entry = shared.entries.find(
-      (entryFile) => node_path.resolve(entryFile) === node_path.resolve(file)
-    );
-    if (entry) {
-      PHP_Code.fromFile(entry).applyEnv().write(tempName(entry));
-      server.moduleGraph.invalidateAll();
-    }
-    if (entry || !file.startsWith(node_path.resolve(shared.tempDir)) && file.includes(".php")) {
-      server.ws.send({
-        type: "full-reload"
-      });
     }
+  } catch (error) {
+    console.error("Vite-PHP Error: " + error);
   }
+  next();
 };
 
 const assetsPattern = new RegExp(
@@ -7991,69 +10973,295 @@ function fixAssetsInjection(input) {
   return out;
 }
 
-const buildPlugin = {
-  name: "build-php",
-  apply: "build",
-  enforce: "pre",
-  resolveId(source, importer, options) {
-    if (shared.entries.includes(source)) {
-      return {
-        // Rename ids because Vite transforms only .html files: https://github.com/vitejs/vite/blob/0cde495ebeb48bcfb5961784a30bfaed997790a0/packages/vite/src/node/plugins/html.ts#L330
-        id: `${source}.html`,
-        resolvedBy: "vite-plugin-php",
-        meta: {
-          originalId: source
+const serve = {
+  rewriteUrl: (url) => url
+};
+let devServer = void 0;
+let entryMatcher = new RegExp(``, "gs");
+const codeMap$1 = /* @__PURE__ */ new Map();
+const servePlugin = [
+  {
+    name: "php:serve-load",
+    apply: "serve",
+    configResolved: {
+      handler(config) {
+        handleExit.register();
+        const gitIgnoreFile = node_path.resolve(`${shared.tempDir}/.gitignore`);
+        if (!node_fs.existsSync(gitIgnoreFile)) {
+          writeFile(gitIgnoreFile, "*\r\n**/*");
+        }
+        entryMatcher = new RegExp(
+          `(${shared.entries.join("|")}).html`,
+          "gs"
+        );
+      }
+    },
+    configureServer: {
+      async handler(server) {
+        devServer = server;
+        server.restart = /* @__PURE__ */ ((originalRestart) => {
+          return async function(...args) {
+            handleExit.unregister();
+            return originalRestart.apply(null, args);
+          };
+        })(server.restart);
+        if (!PHP_Server.process) {
+          await PHP_Server.start(server.config.root);
+        }
+        server.middlewares.use(phpProxy);
+      }
+    },
+    // `rollupOptions.input` entries not arriving in `resolveId(source, importer, options)` -> force file loading with buildStart
+    buildStart: {
+      async handler(options) {
+        await Promise.allSettled(
+          shared.entries.map(async (entry) => {
+            await this.load({
+              id: entry
+            });
+          })
+        );
+      }
+    },
+    load: {
+      handler(id, options) {
+        if (shared.entries.includes(id)) {
+          const php = PHP_Code.fromFile(id);
+          return {
+            code: php.code
+          };
+        }
+      }
+    }
+  },
+  {
+    name: "php:serve-escape",
+    apply: "serve",
+    transform: {
+      async handler(code, id, options) {
+        if (shared.entries.includes(id) && devServer) {
+          let ogWarnLogger = () => {
+          };
+          if (shared.viteConfig) {
+            const warnings = /* @__PURE__ */ new Set();
+            ogWarnLogger = shared.viteConfig.logger.warn;
+            shared.viteConfig.logger.warn = /* @__PURE__ */ ((fn) => function(...args) {
+              const ser = args.toString().replace(entryMatcher, (match, p1) => p1);
+              if (warnings.has(ser)) {
+                return;
+              }
+              warnings.add(ser);
+              return fn.apply(null, args);
+            })(shared.viteConfig.logger.warn);
+          }
+          const res = {
+            code: await devServer.transformIndexHtml(
+              // Rename ids because Vite transforms only .html files: https://github.com/vitejs/vite/blob/0cde495ebeb48bcfb5961784a30bfaed997790a0/packages/vite/src/node/plugins/html.ts#L330
+              `/${id}.html`,
+              code
+            )
+          };
+          if (shared.viteConfig) {
+            shared.viteConfig.logger.warn = ogWarnLogger;
+          }
+          return res;
+        }
+      }
+    },
+    transformIndexHtml: {
+      order: "pre",
+      handler(html, ctx) {
+        const entry = ctx.path.substring(
+          1,
+          ctx.path.length - ".html".length
+        );
+        if (shared.entries.includes(entry)) {
+          const php = new PHP_Code(html);
+          php.file = entry;
+          php.applyEnv();
+          php.escape();
+          codeMap$1.set(entry, php.mapping);
+          return php.code;
+        }
+      }
+    }
+  },
+  {
+    name: "php:serve-unescape",
+    apply: "serve",
+    enforce: "post",
+    transform: {
+      order: "post",
+      handler(code, id, options) {
+        let entry = "";
+        if (id.includes("html-proxy") && shared.entries.some((entryItem) => {
+          const res = id.startsWith(`\0/${entryItem}.html?`);
+          if (res) {
+            entry = entryItem;
+            return true;
+          }
+        })) {
+          const escapes = codeMap$1.get(entry);
+          if (escapes) {
+            return {
+              code: PHP_Code.unescape(code, escapes)
+            };
+          }
+        }
+      }
+    },
+    transformIndexHtml: {
+      order: "post",
+      handler(html, ctx) {
+        const entry = ctx.path.substring(
+          1,
+          ctx.path.length - ".html".length
+        );
+        if (shared.entries.includes(entry)) {
+          const escapes = codeMap$1.get(entry);
+          let php = new PHP_Code(html);
+          php.file = entry;
+          if (escapes) {
+            php.code = PHP_Code.unescape(php.code, escapes);
+          }
+          php.code = fixAssetsInjection(php.code);
+          php.write(tempName(entry));
+          return php.code;
+        }
+      }
+    }
+  },
+  {
+    name: "php:serve-watch",
+    apply: "serve",
+    async watchChange(id, change) {
+      const entry = shared.entries.find(
+        (entryFile) => node_path.resolve(entryFile) === node_path.resolve(id)
+      );
+      if (entry) {
+        try {
+          await this.load({
+            id: entry
+          });
+        } catch (error) {
+        }
+      }
+    },
+    handleHotUpdate({ server, file }) {
+      const entry = shared.entries.find(
+        (entryFile) => node_path.resolve(entryFile) === node_path.resolve(file)
+      );
+      if (entry || !file.startsWith(node_path.resolve(shared.tempDir)) && file.includes(".php")) {
+        server.ws.send({
+          type: "full-reload"
+        });
+      }
+      if (entry) {
+        server.moduleGraph.invalidateAll();
+      }
+    }
+  }
+];
+
+const entryMap = /* @__PURE__ */ new Map();
+const codeMap = /* @__PURE__ */ new Map();
+const buildPlugin = [
+  {
+    name: "php:build-load",
+    apply: "build",
+    enforce: "pre",
+    resolveId: {
+      handler(source, importer, options) {
+        if (shared.entries.includes(source)) {
+          const id = `${source}.html`;
+          entryMap.set(id, source);
+          return {
+            id,
+            resolvedBy: "vite-plugin-php"
+          };
+        }
+      }
+    },
+    load: {
+      handler(id, options) {
+        const entry = entryMap.get(id);
+        if (entry) {
+          const php = PHP_Code.fromFile(entry);
+          return {
+            code: php.code
+          };
         }
-      };
+      }
     }
   },
-  load(id, options) {
-    const moduleInfo = this.getModuleInfo(id);
-    const entry = moduleInfo?.meta.originalId;
-    if (entry) {
-      const php = PHP_Code.fromFile(entry).applyEnv().escape();
-      return {
-        code: php.code,
-        meta: { phpMapping: php.mapping }
-      };
+  {
+    name: "php:build-escape",
+    apply: "build",
+    transformIndexHtml: {
+      order: "pre",
+      handler(html, ctx) {
+        const entry = entryMap.get(ctx.filename);
+        if (entry) {
+          ctx.filename = entry;
+          const php = new PHP_Code(html);
+          php.file = entry;
+          php.applyEnv();
+          php.escape();
+          codeMap.set(entry, php.mapping);
+          return php.code;
+        }
+      }
     }
   },
-  generateBundle: {
-    order: "post",
-    handler(options, bundle, isWrite) {
-      Object.entries(bundle).forEach(([key, item]) => {
-        if (item.type === "asset") {
-          const moduleInfo = this.getModuleInfo(item.fileName);
-          if (moduleInfo?.meta.originalId) {
-            const meta = moduleInfo.meta;
-            item.fileName = meta.originalId;
-            if (meta.phpMapping) {
-              item.source = PHP_Code.unescape(
-                item.source.toString(),
-                meta.phpMapping
-              );
-            }
-            item.source = fixAssetsInjection(
-              item.source.toString()
-            );
+  {
+    name: "php:build-unescape",
+    apply: "build",
+    enforce: "post",
+    transformIndexHtml: {
+      order: "post",
+      handler(html, ctx) {
+        const entry = entryMap.get(ctx.filename);
+        if (entry) {
+          const escapes = codeMap.get(entry);
+          if (escapes) {
+            let php = PHP_Code.unescape(html, escapes);
+            php = fixAssetsInjection(php);
+            return php;
           }
-        } else if (item.type === "chunk" && item.facadeModuleId) {
-          const moduleInfo = this.getModuleInfo(item.facadeModuleId);
-          if (moduleInfo) {
-            const meta = moduleInfo.meta;
-            if (meta.phpMapping) {
-              item.code = PHP_Code.unescape(
-                item.code,
-                meta.phpMapping
-              );
+        }
+      }
+    }
+  },
+  {
+    name: "php:build-bundle",
+    apply: "build",
+    enforce: "post",
+    generateBundle: {
+      order: "post",
+      handler(options, bundle, isWrite) {
+        Object.entries(bundle).forEach(([key, item]) => {
+          if (item.type === "asset") {
+            const entry = entryMap.get(item.fileName);
+            if (entry) {
+              item.fileName = entry;
+            }
+          } else if (item.type === "chunk" && item.facadeModuleId) {
+            const entry = entryMap.get(item.facadeModuleId);
+            if (entry) {
+              const escapes = codeMap.get(entry);
+              if (escapes) {
+                item.code = PHP_Code.unescape(
+                  item.code,
+                  escapes
+                );
+              }
             }
-            item.code = fixAssetsInjection(item.code);
           }
-        }
-      });
+        });
+      }
     }
   }
-};
+];
 
 function usePHP(cfg = {}) {
   const { entry = "index.php" } = cfg;
@@ -8068,7 +11276,7 @@ function usePHP(cfg = {}) {
   };
   return [
     {
-      name: "init-php",
+      name: "php:init",
       enforce: "post",
       config(config, env) {
         shared.entries = [
@@ -8086,7 +11294,6 @@ function usePHP(cfg = {}) {
             )
           )
         ];
-        consoleHijack();
         return {
           server: {
             watch: {
@@ -8094,17 +11301,21 @@ function usePHP(cfg = {}) {
             }
           },
           build: {
-            rollupOptions: { input: shared.entries }
+            rollupOptions: {
+              input: shared.entries
+            }
           },
-          optimizeDeps: { entries: shared.entries }
+          optimizeDeps: {
+            entries: shared.entries
+          }
         };
       },
       configResolved(_config) {
         shared.viteConfig = _config;
       }
     },
-    servePlugin,
-    buildPlugin
+    ...servePlugin,
+    ...buildPlugin
   ];
 }