react-easy-wall 1.2.8 → 1.3.2

package/dist/cjs/node_modules/mime-db/db.json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"db.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/node_modules/mime-db/index.js

@@ -0,0 +1,27 @@
+'use strict';
+
+var db = require('./db.json.js');
+
+/*!
+ * mime-db
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2015-2022 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+var mimeDb;
+var hasRequiredMimeDb;
+
+function requireMimeDb () {
+	if (hasRequiredMimeDb) return mimeDb;
+	hasRequiredMimeDb = 1;
+	/**
+	 * Module exports.
+	 */
+
+	mimeDb = db.default;
+	return mimeDb;
+}
+
+exports.__require = requireMimeDb;
+//# sourceMappingURL=index.js.map

package/dist/cjs/node_modules/mime-db/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../node_modules/mime-db/index.js"],"sourcesContent":["/*!\n * mime-db\n * Copyright(c) 2014 Jonathan Ong\n * Copyright(c) 2015-2022 Douglas Christopher Wilson\n * MIT Licensed\n */\n\n/**\n * Module exports.\n */\n\nmodule.exports = require('./db.json')\n"],"names":["require$$0"],"mappings":";;;;;;;;;;;;;;;;;AAOA;AACA;AACA;;AAEA,CAAA,MAAc,GAAGA;;;;;;","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/mime-types/index.js

@@ -0,0 +1,205 @@
+'use strict';
+
+var index = require('../../_virtual/index14.js');
+var index$1 = require('../mime-db/index.js');
+var _path_commonjsExternal = require('../../_virtual/_path.js');
+
+/*!
+ * mime-types
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+var hasRequiredMimeTypes;
+
+function requireMimeTypes () {
+	if (hasRequiredMimeTypes) return index.__exports;
+	hasRequiredMimeTypes = 1;
+	(function (exports$1) {
+
+		/**
+		 * Module dependencies.
+		 * @private
+		 */
+
+		var db = index$1.__require();
+		var extname = _path_commonjsExternal.default.extname;
+
+		/**
+		 * Module variables.
+		 * @private
+		 */
+
+		var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/;
+		var TEXT_TYPE_REGEXP = /^text\//i;
+
+		/**
+		 * Module exports.
+		 * @public
+		 */
+
+		exports$1.charset = charset;
+		exports$1.charsets = { lookup: charset };
+		exports$1.contentType = contentType;
+		exports$1.extension = extension;
+		exports$1.extensions = Object.create(null);
+		exports$1.lookup = lookup;
+		exports$1.types = Object.create(null);
+
+		// Populate the extensions/types maps
+		populateMaps(exports$1.extensions, exports$1.types);
+
+		/**
+		 * Get the default charset for a MIME type.
+		 *
+		 * @param {string} type
+		 * @return {boolean|string}
+		 */
+
+		function charset (type) {
+		  if (!type || typeof type !== 'string') {
+		    return false
+		  }
+
+		  // TODO: use media-typer
+		  var match = EXTRACT_TYPE_REGEXP.exec(type);
+		  var mime = match && db[match[1].toLowerCase()];
+
+		  if (mime && mime.charset) {
+		    return mime.charset
+		  }
+
+		  // default text/* to utf-8
+		  if (match && TEXT_TYPE_REGEXP.test(match[1])) {
+		    return 'UTF-8'
+		  }
+
+		  return false
+		}
+
+		/**
+		 * Create a full Content-Type header given a MIME type or extension.
+		 *
+		 * @param {string} str
+		 * @return {boolean|string}
+		 */
+
+		function contentType (str) {
+		  // TODO: should this even be in this module?
+		  if (!str || typeof str !== 'string') {
+		    return false
+		  }
+
+		  var mime = str.indexOf('/') === -1
+		    ? exports$1.lookup(str)
+		    : str;
+
+		  if (!mime) {
+		    return false
+		  }
+
+		  // TODO: use content-type or other module
+		  if (mime.indexOf('charset') === -1) {
+		    var charset = exports$1.charset(mime);
+		    if (charset) mime += '; charset=' + charset.toLowerCase();
+		  }
+
+		  return mime
+		}
+
+		/**
+		 * Get the default extension for a MIME type.
+		 *
+		 * @param {string} type
+		 * @return {boolean|string}
+		 */
+
+		function extension (type) {
+		  if (!type || typeof type !== 'string') {
+		    return false
+		  }
+
+		  // TODO: use media-typer
+		  var match = EXTRACT_TYPE_REGEXP.exec(type);
+
+		  // get extensions
+		  var exts = match && exports$1.extensions[match[1].toLowerCase()];
+
+		  if (!exts || !exts.length) {
+		    return false
+		  }
+
+		  return exts[0]
+		}
+
+		/**
+		 * Lookup the MIME type for a file path/extension.
+		 *
+		 * @param {string} path
+		 * @return {boolean|string}
+		 */
+
+		function lookup (path) {
+		  if (!path || typeof path !== 'string') {
+		    return false
+		  }
+
+		  // get the extension ("ext" or ".ext" or full path)
+		  var extension = extname('x.' + path)
+		    .toLowerCase()
+		    .substr(1);
+
+		  if (!extension) {
+		    return false
+		  }
+
+		  return exports$1.types[extension] || false
+		}
+
+		/**
+		 * Populate the extensions and types maps.
+		 * @private
+		 */
+
+		function populateMaps (extensions, types) {
+		  // source preference (least -> most)
+		  var preference = ['nginx', 'apache', undefined, 'iana'];
+
+		  Object.keys(db).forEach(function forEachMimeType (type) {
+		    var mime = db[type];
+		    var exts = mime.extensions;
+
+		    if (!exts || !exts.length) {
+		      return
+		    }
+
+		    // mime -> extensions
+		    extensions[type] = exts;
+
+		    // extension -> mime
+		    for (var i = 0; i < exts.length; i++) {
+		      var extension = exts[i];
+
+		      if (types[extension]) {
+		        var from = preference.indexOf(db[types[extension]].source);
+		        var to = preference.indexOf(mime.source);
+
+		        if (types[extension] !== 'application/octet-stream' &&
+		          (from > to || (from === to && types[extension].substr(0, 12) === 'application/'))) {
+		          // skip the remapping
+		          continue
+		        }
+		      }
+
+		      // set the extension -> mime
+		      types[extension] = type;
+		    }
+		  });
+		} 
+	} (index.__exports));
+	return index.__exports;
+}
+
+exports.__require = requireMimeTypes;
+//# sourceMappingURL=index.js.map

package/dist/cjs/node_modules/mime-types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../node_modules/mime-types/index.js"],"sourcesContent":["/*!\n * mime-types\n * Copyright(c) 2014 Jonathan Ong\n * Copyright(c) 2015 Douglas Christopher Wilson\n * MIT Licensed\n */\n\n'use strict'\n\n/**\n * Module dependencies.\n * @private\n */\n\nvar db = require('mime-db')\nvar extname = require('path').extname\n\n/**\n * Module variables.\n * @private\n */\n\nvar EXTRACT_TYPE_REGEXP = /^\\s*([^;\\s]*)(?:;|\\s|$)/\nvar TEXT_TYPE_REGEXP = /^text\\//i\n\n/**\n * Module exports.\n * @public\n */\n\nexports.charset = charset\nexports.charsets = { lookup: charset }\nexports.contentType = contentType\nexports.extension = extension\nexports.extensions = Object.create(null)\nexports.lookup = lookup\nexports.types = Object.create(null)\n\n// Populate the extensions/types maps\npopulateMaps(exports.extensions, exports.types)\n\n/**\n * Get the default charset for a MIME type.\n *\n * @param {string} type\n * @return {boolean|string}\n */\n\nfunction charset (type) {\n  if (!type || typeof type !== 'string') {\n    return false\n  }\n\n  // TODO: use media-typer\n  var match = EXTRACT_TYPE_REGEXP.exec(type)\n  var mime = match && db[match[1].toLowerCase()]\n\n  if (mime && mime.charset) {\n    return mime.charset\n  }\n\n  // default text/* to utf-8\n  if (match && TEXT_TYPE_REGEXP.test(match[1])) {\n    return 'UTF-8'\n  }\n\n  return false\n}\n\n/**\n * Create a full Content-Type header given a MIME type or extension.\n *\n * @param {string} str\n * @return {boolean|string}\n */\n\nfunction contentType (str) {\n  // TODO: should this even be in this module?\n  if (!str || typeof str !== 'string') {\n    return false\n  }\n\n  var mime = str.indexOf('/') === -1\n    ? exports.lookup(str)\n    : str\n\n  if (!mime) {\n    return false\n  }\n\n  // TODO: use content-type or other module\n  if (mime.indexOf('charset') === -1) {\n    var charset = exports.charset(mime)\n    if (charset) mime += '; charset=' + charset.toLowerCase()\n  }\n\n  return mime\n}\n\n/**\n * Get the default extension for a MIME type.\n *\n * @param {string} type\n * @return {boolean|string}\n */\n\nfunction extension (type) {\n  if (!type || typeof type !== 'string') {\n    return false\n  }\n\n  // TODO: use media-typer\n  var match = EXTRACT_TYPE_REGEXP.exec(type)\n\n  // get extensions\n  var exts = match && exports.extensions[match[1].toLowerCase()]\n\n  if (!exts || !exts.length) {\n    return false\n  }\n\n  return exts[0]\n}\n\n/**\n * Lookup the MIME type for a file path/extension.\n *\n * @param {string} path\n * @return {boolean|string}\n */\n\nfunction lookup (path) {\n  if (!path || typeof path !== 'string') {\n    return false\n  }\n\n  // get the extension (\"ext\" or \".ext\" or full path)\n  var extension = extname('x.' + path)\n    .toLowerCase()\n    .substr(1)\n\n  if (!extension) {\n    return false\n  }\n\n  return exports.types[extension] || false\n}\n\n/**\n * Populate the extensions and types maps.\n * @private\n */\n\nfunction populateMaps (extensions, types) {\n  // source preference (least -> most)\n  var preference = ['nginx', 'apache', undefined, 'iana']\n\n  Object.keys(db).forEach(function forEachMimeType (type) {\n    var mime = db[type]\n    var exts = mime.extensions\n\n    if (!exts || !exts.length) {\n      return\n    }\n\n    // mime -> extensions\n    extensions[type] = exts\n\n    // extension -> mime\n    for (var i = 0; i < exts.length; i++) {\n      var extension = exts[i]\n\n      if (types[extension]) {\n        var from = preference.indexOf(db[types[extension]].source)\n        var to = preference.indexOf(mime.source)\n\n        if (types[extension] !== 'application/octet-stream' &&\n          (from > to || (from === to && types[extension].substr(0, 12) === 'application/'))) {\n          // skip the remapping\n          continue\n        }\n      }\n\n      // set the extension -> mime\n      types[extension] = type\n    }\n  })\n}\n"],"names":["require$$0","require$$1","exports"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/ms/index.js

@@ -0,0 +1,175 @@
+'use strict';
+
+/**
+ * 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;
+}
+
+exports.__require = requireMs;
+//# sourceMappingURL=index.js.map

package/dist/cjs/node_modules/ms/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../node_modules/ms/index.js"],"sourcesContent":["/**\n * Helpers.\n */\n\nvar s = 1000;\nvar m = s * 60;\nvar h = m * 60;\nvar d = h * 24;\nvar w = d * 7;\nvar y = d * 365.25;\n\n/**\n * Parse or format the given `val`.\n *\n * Options:\n *\n *  - `long` verbose formatting [false]\n *\n * @param {String|Number} val\n * @param {Object} [options]\n * @throws {Error} throw an error if val is not a non-empty string or a number\n * @return {String|Number}\n * @api public\n */\n\nmodule.exports = function (val, options) {\n  options = options || {};\n  var type = typeof val;\n  if (type === 'string' && val.length > 0) {\n    return parse(val);\n  } else if (type === 'number' && isFinite(val)) {\n    return options.long ? fmtLong(val) : fmtShort(val);\n  }\n  throw new Error(\n    'val is not a non-empty string or a valid number. val=' +\n      JSON.stringify(val)\n  );\n};\n\n/**\n * Parse the given `str` and return milliseconds.\n *\n * @param {String} str\n * @return {Number}\n * @api private\n */\n\nfunction parse(str) {\n  str = String(str);\n  if (str.length > 100) {\n    return;\n  }\n  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(\n    str\n  );\n  if (!match) {\n    return;\n  }\n  var n = parseFloat(match[1]);\n  var type = (match[2] || 'ms').toLowerCase();\n  switch (type) {\n    case 'years':\n    case 'year':\n    case 'yrs':\n    case 'yr':\n    case 'y':\n      return n * y;\n    case 'weeks':\n    case 'week':\n    case 'w':\n      return n * w;\n    case 'days':\n    case 'day':\n    case 'd':\n      return n * d;\n    case 'hours':\n    case 'hour':\n    case 'hrs':\n    case 'hr':\n    case 'h':\n      return n * h;\n    case 'minutes':\n    case 'minute':\n    case 'mins':\n    case 'min':\n    case 'm':\n      return n * m;\n    case 'seconds':\n    case 'second':\n    case 'secs':\n    case 'sec':\n    case 's':\n      return n * s;\n    case 'milliseconds':\n    case 'millisecond':\n    case 'msecs':\n    case 'msec':\n    case 'ms':\n      return n;\n    default:\n      return undefined;\n  }\n}\n\n/**\n * Short format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtShort(ms) {\n  var msAbs = Math.abs(ms);\n  if (msAbs >= d) {\n    return Math.round(ms / d) + 'd';\n  }\n  if (msAbs >= h) {\n    return Math.round(ms / h) + 'h';\n  }\n  if (msAbs >= m) {\n    return Math.round(ms / m) + 'm';\n  }\n  if (msAbs >= s) {\n    return Math.round(ms / s) + 's';\n  }\n  return ms + 'ms';\n}\n\n/**\n * Long format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtLong(ms) {\n  var msAbs = Math.abs(ms);\n  if (msAbs >= d) {\n    return plural(ms, msAbs, d, 'day');\n  }\n  if (msAbs >= h) {\n    return plural(ms, msAbs, h, 'hour');\n  }\n  if (msAbs >= m) {\n    return plural(ms, msAbs, m, 'minute');\n  }\n  if (msAbs >= s) {\n    return plural(ms, msAbs, s, 'second');\n  }\n  return ms + ' ms';\n}\n\n/**\n * Pluralization helper.\n */\n\nfunction plural(ms, msAbs, n, name) {\n  var isPlural = msAbs >= n * 1.5;\n  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');\n}\n"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/prop-types/index.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var index$1 = require('../../_virtual/index4.js');
+var index$1 = require('../../_virtual/index7.js');
 var index = require('./node_modules/react-is/index.js');
 var factoryWithTypeCheckers = require('./factoryWithTypeCheckers.js');
 var factoryWithThrowingShims = require('./factoryWithThrowingShims.js');

package/dist/cjs/node_modules/prop-types/node_modules/react-is/index.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('../../../../_virtual/index7.js');
+var index = require('../../../../_virtual/index12.js');
 var reactIs_production_min = require('./cjs/react-is.production.min.js');
 var reactIs_development = require('./cjs/react-is.development.js');
 

package/dist/cjs/node_modules/proxy-from-env/index.js

@@ -0,0 +1,122 @@
+'use strict';
+
+var index = require('../../_virtual/index11.js');
+var _url_commonjsExternal = require('../../_virtual/_url.js');
+
+var hasRequiredProxyFromEnv;
+
+function requireProxyFromEnv () {
+	if (hasRequiredProxyFromEnv) return index.__exports;
+	hasRequiredProxyFromEnv = 1;
+
+	var parseUrl = _url_commonjsExternal.default.parse;
+
+	var DEFAULT_PORTS = {
+	  ftp: 21,
+	  gopher: 70,
+	  http: 80,
+	  https: 443,
+	  ws: 80,
+	  wss: 443,
+	};
+
+	var stringEndsWith = String.prototype.endsWith || function(s) {
+	  return s.length <= this.length &&
+	    this.indexOf(s, this.length - s.length) !== -1;
+	};
+
+	/**
+	 * @param {string|object} url - The URL, or the result from url.parse.
+	 * @return {string} The URL of the proxy that should handle the request to the
+	 *  given URL. If no proxy is set, this will be an empty string.
+	 */
+	function getProxyForUrl(url) {
+	  var parsedUrl = typeof url === 'string' ? parseUrl(url) : url || {};
+	  var proto = parsedUrl.protocol;
+	  var hostname = parsedUrl.host;
+	  var port = parsedUrl.port;
+	  if (typeof hostname !== 'string' || !hostname || typeof proto !== 'string') {
+	    return '';  // Don't proxy URLs without a valid scheme or host.
+	  }
+
+	  proto = proto.split(':', 1)[0];
+	  // Stripping ports in this way instead of using parsedUrl.hostname to make
+	  // sure that the brackets around IPv6 addresses are kept.
+	  hostname = hostname.replace(/:\d*$/, '');
+	  port = parseInt(port) || DEFAULT_PORTS[proto] || 0;
+	  if (!shouldProxy(hostname, port)) {
+	    return '';  // Don't proxy URLs that match NO_PROXY.
+	  }
+
+	  var proxy =
+	    getEnv('npm_config_' + proto + '_proxy') ||
+	    getEnv(proto + '_proxy') ||
+	    getEnv('npm_config_proxy') ||
+	    getEnv('all_proxy');
+	  if (proxy && proxy.indexOf('://') === -1) {
+	    // Missing scheme in proxy, default to the requested URL's scheme.
+	    proxy = proto + '://' + proxy;
+	  }
+	  return proxy;
+	}
+
+	/**
+	 * Determines whether a given URL should be proxied.
+	 *
+	 * @param {string} hostname - The host name of the URL.
+	 * @param {number} port - The effective port of the URL.
+	 * @returns {boolean} Whether the given URL should be proxied.
+	 * @private
+	 */
+	function shouldProxy(hostname, port) {
+	  var NO_PROXY =
+	    (getEnv('npm_config_no_proxy') || getEnv('no_proxy')).toLowerCase();
+	  if (!NO_PROXY) {
+	    return true;  // Always proxy if NO_PROXY is not set.
+	  }
+	  if (NO_PROXY === '*') {
+	    return false;  // Never proxy if wildcard is set.
+	  }
+
+	  return NO_PROXY.split(/[,\s]/).every(function(proxy) {
+	    if (!proxy) {
+	      return true;  // Skip zero-length hosts.
+	    }
+	    var parsedProxy = proxy.match(/^(.+):(\d+)$/);
+	    var parsedProxyHostname = parsedProxy ? parsedProxy[1] : proxy;
+	    var parsedProxyPort = parsedProxy ? parseInt(parsedProxy[2]) : 0;
+	    if (parsedProxyPort && parsedProxyPort !== port) {
+	      return true;  // Skip if ports don't match.
+	    }
+
+	    if (!/^[.*]/.test(parsedProxyHostname)) {
+	      // No wildcards, so stop proxying if there is an exact match.
+	      return hostname !== parsedProxyHostname;
+	    }
+
+	    if (parsedProxyHostname.charAt(0) === '*') {
+	      // Remove leading wildcard.
+	      parsedProxyHostname = parsedProxyHostname.slice(1);
+	    }
+	    // Stop proxying if the hostname ends with the no_proxy host.
+	    return !stringEndsWith.call(hostname, parsedProxyHostname);
+	  });
+	}
+
+	/**
+	 * Get the value for an environment variable.
+	 *
+	 * @param {string} key - The name of the environment variable.
+	 * @return {string} The value of the environment variable.
+	 * @private
+	 */
+	function getEnv(key) {
+	  return process.env[key.toLowerCase()] || process.env[key.toUpperCase()] || '';
+	}
+
+	index.__exports.getProxyForUrl = getProxyForUrl;
+	return index.__exports;
+}
+
+exports.__require = requireProxyFromEnv;
+//# sourceMappingURL=index.js.map

package/dist/cjs/node_modules/proxy-from-env/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../node_modules/proxy-from-env/index.js"],"sourcesContent":["'use strict';\n\nvar parseUrl = require('url').parse;\n\nvar DEFAULT_PORTS = {\n  ftp: 21,\n  gopher: 70,\n  http: 80,\n  https: 443,\n  ws: 80,\n  wss: 443,\n};\n\nvar stringEndsWith = String.prototype.endsWith || function(s) {\n  return s.length <= this.length &&\n    this.indexOf(s, this.length - s.length) !== -1;\n};\n\n/**\n * @param {string|object} url - The URL, or the result from url.parse.\n * @return {string} The URL of the proxy that should handle the request to the\n *  given URL. If no proxy is set, this will be an empty string.\n */\nfunction getProxyForUrl(url) {\n  var parsedUrl = typeof url === 'string' ? parseUrl(url) : url || {};\n  var proto = parsedUrl.protocol;\n  var hostname = parsedUrl.host;\n  var port = parsedUrl.port;\n  if (typeof hostname !== 'string' || !hostname || typeof proto !== 'string') {\n    return '';  // Don't proxy URLs without a valid scheme or host.\n  }\n\n  proto = proto.split(':', 1)[0];\n  // Stripping ports in this way instead of using parsedUrl.hostname to make\n  // sure that the brackets around IPv6 addresses are kept.\n  hostname = hostname.replace(/:\\d*$/, '');\n  port = parseInt(port) || DEFAULT_PORTS[proto] || 0;\n  if (!shouldProxy(hostname, port)) {\n    return '';  // Don't proxy URLs that match NO_PROXY.\n  }\n\n  var proxy =\n    getEnv('npm_config_' + proto + '_proxy') ||\n    getEnv(proto + '_proxy') ||\n    getEnv('npm_config_proxy') ||\n    getEnv('all_proxy');\n  if (proxy && proxy.indexOf('://') === -1) {\n    // Missing scheme in proxy, default to the requested URL's scheme.\n    proxy = proto + '://' + proxy;\n  }\n  return proxy;\n}\n\n/**\n * Determines whether a given URL should be proxied.\n *\n * @param {string} hostname - The host name of the URL.\n * @param {number} port - The effective port of the URL.\n * @returns {boolean} Whether the given URL should be proxied.\n * @private\n */\nfunction shouldProxy(hostname, port) {\n  var NO_PROXY =\n    (getEnv('npm_config_no_proxy') || getEnv('no_proxy')).toLowerCase();\n  if (!NO_PROXY) {\n    return true;  // Always proxy if NO_PROXY is not set.\n  }\n  if (NO_PROXY === '*') {\n    return false;  // Never proxy if wildcard is set.\n  }\n\n  return NO_PROXY.split(/[,\\s]/).every(function(proxy) {\n    if (!proxy) {\n      return true;  // Skip zero-length hosts.\n    }\n    var parsedProxy = proxy.match(/^(.+):(\\d+)$/);\n    var parsedProxyHostname = parsedProxy ? parsedProxy[1] : proxy;\n    var parsedProxyPort = parsedProxy ? parseInt(parsedProxy[2]) : 0;\n    if (parsedProxyPort && parsedProxyPort !== port) {\n      return true;  // Skip if ports don't match.\n    }\n\n    if (!/^[.*]/.test(parsedProxyHostname)) {\n      // No wildcards, so stop proxying if there is an exact match.\n      return hostname !== parsedProxyHostname;\n    }\n\n    if (parsedProxyHostname.charAt(0) === '*') {\n      // Remove leading wildcard.\n      parsedProxyHostname = parsedProxyHostname.slice(1);\n    }\n    // Stop proxying if the hostname ends with the no_proxy host.\n    return !stringEndsWith.call(hostname, parsedProxyHostname);\n  });\n}\n\n/**\n * Get the value for an environment variable.\n *\n * @param {string} key - The name of the environment variable.\n * @return {string} The value of the environment variable.\n * @private\n */\nfunction getEnv(key) {\n  return process.env[key.toLowerCase()] || process.env[key.toUpperCase()] || '';\n}\n\nexports.getProxyForUrl = getProxyForUrl;\n"],"names":["require$$0","proxyFromEnv"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/react-giphy-searchbox/es/assets/PoweredByGiphyLogo.js

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+
+var PoweredByGiphyLogo = function PoweredByGiphyLogo() {
+		return React.createElement(
+				"svg",
+				{
+						version: "1.1",
+						xmlns: "http://www.w3.org/2000/svg",
+						xmlnsXlink: "http://www.w3.org/1999/xlink",
+						x: "0px",
+						y: "0px",
+						viewBox: "0 0 581.5 67.1",
+						xmlSpace: "preserve"
+				},
+				React.createElement("path", {
+						fill: "#898989",
+						d: "M327.2,26.7h29.7v8c0,5.7,0,11.4,0,17.1c0,1.4-0.4,2.5-1.2,3.6c-2.3,3.2-5.3,5.4-8.8,6.9 c-10.6,4.2-21.3,4.5-31.9,0.2c-7.5-3-12.6-8.6-15.3-16.2c-3.3-9.3-3.1-18.6,1.1-27.7c3.9-8.3,10.5-13.5,19.2-16 c6.1-1.7,12.4-1.8,18.7-0.7c5.6,1,11.6,4.5,15.9,9.1c-1.6,1.6-3.2,3.2-4.8,4.9c-1.6,1.7-3.2,3.4-4.8,5.1c-0.7-0.5-1.2-0.9-1.6-1.2 c-5.2-3.9-11-5-17.3-3.7c-5,1.1-8.6,4.2-10.3,9c-1.9,5.4-2,10.9,0.2,16.3c2.3,5.6,6.6,8.6,12.6,9.2c3.6,0.3,7.1,0,10.5-1.3 c1.1-0.4,2.2-1,3.3-1.5v-7.9h-15.2C327.1,35.6,327.2,31.2,327.2,26.7 M453.6,63.9h17.1V41.3h21.9v22.6h16.9c0-20.3,0-40.4,0-60.6 h-17c-0.1,7.7,0.1,15.3-0.1,22.8h-21.8V3.3h-17.1V63.9z M411,63.8V47.5c4,0,8,0.1,12,0c2.7-0.1,5.3-0.4,7.9-1 c5.1-1.2,9.4-3.7,12.5-8c3-4.2,4.1-8.9,3.9-13.9c-0.2-6.5-2.5-12-7.6-16.1c-4.4-3.6-9.6-5.1-15.1-5.2h-31.1v60.6H411 M410.7,17.9 c0.6,0,8.3,0,12.1,0c5.5,0,7.9,4.7,7.2,9c-0.6,3.6-2.8,5.9-6.3,6.1c-4.2,0.2-8.5,0-13,0V17.9z M546.8,23.9 c-4.3-7.2-8.4-13.9-12.5-20.7h-19.8c7.9,12.4,15.7,24.4,23.5,36.6v23.9h17.1V39.7c8-11.8,24.4-36.2,24.6-36.5h-0.6h-19.2 C555.6,10,551.3,16.8,546.8,23.9 M382.4,63.9c0-20.4,0-40.5,0-60.8h-17.1v60.8H382.4"
+				}),
+				React.createElement("path", {
+						fill: "#C1C1C1",
+						d: "M1.7,19.3H15c6.3,0,9.9,4.1,9.9,8.9c0,4.8-3.6,8.9-9.9,8.9H7v10.6H1.7V19.3z M14.2,23.7H7v9.1h7.2 c3,0,5.2-1.8,5.2-4.5S17.2,23.7,14.2,23.7z M43.3,18.8c9.1,0,15.4,6.2,15.4,14.7c0,8.5-6.4,14.7-15.4,14.7 c-9.1,0-15.4-6.2-15.4-14.7C27.9,25,34.2,18.8,43.3,18.8z M43.3,23.2c-6.1,0-10,4.4-10,10.3c0,5.8,3.9,10.3,10,10.3 c6.1,0,10-4.4,10-10.3C53.3,27.6,49.4,23.2,43.3,23.2z M80.1,26.7l-5.8,21h-5.7L60,19.3h5.9l5.9,21.9L78,19.3h4.2l6.2,21.9l5.8-21.9 h5.9l-8.6,28.5H86L80.1,26.7z M103.8,19.3h20.7v4.4h-15.4v7.4h15.1v4.4h-15.1v7.9h15.4v4.4h-20.7V19.3z M140.4,37.1h-5.2v10.6h-5.3 V19.3h13.3c6,0,9.9,3.7,9.9,8.9c0,5.1-3.5,7.8-7.2,8.4l7.4,11.2h-6.1L140.4,37.1z M142.4,23.7h-7.2v9.1h7.2c3,0,5.2-1.8,5.2-4.5 S145.4,23.7,142.4,23.7z M158.3,19.3H179v4.4h-15.4v7.4h15.1v4.4h-15.1v7.9H179v4.4h-20.7V19.3z M184.4,19.3h11.2 c9.4,0,15.8,5.9,15.8,14.3c0,8.4-6.4,14.2-15.8,14.2h-11.2V19.3z M195.6,43.4c6.6,0,10.4-4.4,10.4-9.8c0-5.5-3.6-9.9-10.4-9.9h-5.9 v19.7H195.6z M228.2,19.3H243c5.5,0,8.6,3.2,8.6,7.3c0,3.6-2.4,6-5.2,6.5c3.2,0.5,5.8,3.5,5.8,7c0,4.4-3.1,7.7-8.8,7.7h-15.3V19.3z M241.9,31.1c2.7,0,4.3-1.5,4.3-3.7s-1.5-3.7-4.3-3.7h-8.5v7.4H241.9z M242.2,43.4c2.9,0,4.6-1.5,4.6-4c0-2.1-1.6-3.9-4.6-3.9h-8.7 v7.9H242.2z M264.7,35.9L253,19.3h6.1l8.3,12.2l8.2-12.2h6.1L270,35.9v11.8h-5.3V35.9z"
+				})
+		);
+};
+
+exports.default = PoweredByGiphyLogo;
+//# sourceMappingURL=PoweredByGiphyLogo.js.map

package/dist/cjs/node_modules/react-giphy-searchbox/es/assets/PoweredByGiphyLogo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PoweredByGiphyLogo.js","sources":["../../../../../../node_modules/react-giphy-searchbox/es/assets/PoweredByGiphyLogo.js"],"sourcesContent":["import React from 'react';\n\nvar PoweredByGiphyLogo = function PoweredByGiphyLogo() {\n\t\treturn React.createElement(\n\t\t\t\t\"svg\",\n\t\t\t\t{\n\t\t\t\t\t\tversion: \"1.1\",\n\t\t\t\t\t\txmlns: \"http://www.w3.org/2000/svg\",\n\t\t\t\t\t\txmlnsXlink: \"http://www.w3.org/1999/xlink\",\n\t\t\t\t\t\tx: \"0px\",\n\t\t\t\t\t\ty: \"0px\",\n\t\t\t\t\t\tviewBox: \"0 0 581.5 67.1\",\n\t\t\t\t\t\txmlSpace: \"preserve\"\n\t\t\t\t},\n\t\t\t\tReact.createElement(\"path\", {\n\t\t\t\t\t\tfill: \"#898989\",\n\t\t\t\t\t\td: \"M327.2,26.7h29.7v8c0,5.7,0,11.4,0,17.1c0,1.4-0.4,2.5-1.2,3.6c-2.3,3.2-5.3,5.4-8.8,6.9 c-10.6,4.2-21.3,4.5-31.9,0.2c-7.5-3-12.6-8.6-15.3-16.2c-3.3-9.3-3.1-18.6,1.1-27.7c3.9-8.3,10.5-13.5,19.2-16 c6.1-1.7,12.4-1.8,18.7-0.7c5.6,1,11.6,4.5,15.9,9.1c-1.6,1.6-3.2,3.2-4.8,4.9c-1.6,1.7-3.2,3.4-4.8,5.1c-0.7-0.5-1.2-0.9-1.6-1.2 c-5.2-3.9-11-5-17.3-3.7c-5,1.1-8.6,4.2-10.3,9c-1.9,5.4-2,10.9,0.2,16.3c2.3,5.6,6.6,8.6,12.6,9.2c3.6,0.3,7.1,0,10.5-1.3 c1.1-0.4,2.2-1,3.3-1.5v-7.9h-15.2C327.1,35.6,327.2,31.2,327.2,26.7 M453.6,63.9h17.1V41.3h21.9v22.6h16.9c0-20.3,0-40.4,0-60.6 h-17c-0.1,7.7,0.1,15.3-0.1,22.8h-21.8V3.3h-17.1V63.9z M411,63.8V47.5c4,0,8,0.1,12,0c2.7-0.1,5.3-0.4,7.9-1 c5.1-1.2,9.4-3.7,12.5-8c3-4.2,4.1-8.9,3.9-13.9c-0.2-6.5-2.5-12-7.6-16.1c-4.4-3.6-9.6-5.1-15.1-5.2h-31.1v60.6H411 M410.7,17.9 c0.6,0,8.3,0,12.1,0c5.5,0,7.9,4.7,7.2,9c-0.6,3.6-2.8,5.9-6.3,6.1c-4.2,0.2-8.5,0-13,0V17.9z M546.8,23.9 c-4.3-7.2-8.4-13.9-12.5-20.7h-19.8c7.9,12.4,15.7,24.4,23.5,36.6v23.9h17.1V39.7c8-11.8,24.4-36.2,24.6-36.5h-0.6h-19.2 C555.6,10,551.3,16.8,546.8,23.9 M382.4,63.9c0-20.4,0-40.5,0-60.8h-17.1v60.8H382.4\"\n\t\t\t\t}),\n\t\t\t\tReact.createElement(\"path\", {\n\t\t\t\t\t\tfill: \"#C1C1C1\",\n\t\t\t\t\t\td: \"M1.7,19.3H15c6.3,0,9.9,4.1,9.9,8.9c0,4.8-3.6,8.9-9.9,8.9H7v10.6H1.7V19.3z M14.2,23.7H7v9.1h7.2 c3,0,5.2-1.8,5.2-4.5S17.2,23.7,14.2,23.7z M43.3,18.8c9.1,0,15.4,6.2,15.4,14.7c0,8.5-6.4,14.7-15.4,14.7 c-9.1,0-15.4-6.2-15.4-14.7C27.9,25,34.2,18.8,43.3,18.8z M43.3,23.2c-6.1,0-10,4.4-10,10.3c0,5.8,3.9,10.3,10,10.3 c6.1,0,10-4.4,10-10.3C53.3,27.6,49.4,23.2,43.3,23.2z M80.1,26.7l-5.8,21h-5.7L60,19.3h5.9l5.9,21.9L78,19.3h4.2l6.2,21.9l5.8-21.9 h5.9l-8.6,28.5H86L80.1,26.7z M103.8,19.3h20.7v4.4h-15.4v7.4h15.1v4.4h-15.1v7.9h15.4v4.4h-20.7V19.3z M140.4,37.1h-5.2v10.6h-5.3 V19.3h13.3c6,0,9.9,3.7,9.9,8.9c0,5.1-3.5,7.8-7.2,8.4l7.4,11.2h-6.1L140.4,37.1z M142.4,23.7h-7.2v9.1h7.2c3,0,5.2-1.8,5.2-4.5 S145.4,23.7,142.4,23.7z M158.3,19.3H179v4.4h-15.4v7.4h15.1v4.4h-15.1v7.9H179v4.4h-20.7V19.3z M184.4,19.3h11.2 c9.4,0,15.8,5.9,15.8,14.3c0,8.4-6.4,14.2-15.8,14.2h-11.2V19.3z M195.6,43.4c6.6,0,10.4-4.4,10.4-9.8c0-5.5-3.6-9.9-10.4-9.9h-5.9 v19.7H195.6z M228.2,19.3H243c5.5,0,8.6,3.2,8.6,7.3c0,3.6-2.4,6-5.2,6.5c3.2,0.5,5.8,3.5,5.8,7c0,4.4-3.1,7.7-8.8,7.7h-15.3V19.3z M241.9,31.1c2.7,0,4.3-1.5,4.3-3.7s-1.5-3.7-4.3-3.7h-8.5v7.4H241.9z M242.2,43.4c2.9,0,4.6-1.5,4.6-4c0-2.1-1.6-3.9-4.6-3.9h-8.7 v7.9H242.2z M264.7,35.9L253,19.3h6.1l8.3,12.2l8.2-12.2h6.1L270,35.9v11.8h-5.3V35.9z\"\n\t\t\t\t})\n\t\t);\n};\n\nexport default PoweredByGiphyLogo;"],"names":[],"mappings":";;;;;;AAEG,IAAC,kBAAkB,GAAG,SAAS,kBAAkB,GAAG;AACvD,EAAE,OAAO,KAAK,CAAC,aAAa;AAC5B,IAAI,KAAK;AACT,IAAI;AACJ,MAAM,OAAO,EAAE,KAAK;AACpB,MAAM,KAAK,EAAE,4BAA4B;AACzC,MAAM,UAAU,EAAE,8BAA8B;AAChD,MAAM,CAAC,EAAE,KAAK;AACd,MAAM,CAAC,EAAE,KAAK;AACd,MAAM,OAAO,EAAE,gBAAgB;AAC/B,MAAM,QAAQ,EAAE;AAChB,KAAK;AACL,IAAI,KAAK,CAAC,aAAa,CAAC,MAAM,EAAE;AAChC,MAAM,IAAI,EAAE,SAAS;AACrB,MAAM,CAAC,EAAE;AACT,KAAK,CAAC;AACN,IAAI,KAAK,CAAC,aAAa,CAAC,MAAM,EAAE;AAChC,MAAM,IAAI,EAAE,SAAS;AACrB,MAAM,CAAC,EAAE;AACT,KAAK;AACL,GAAG;AACH;;;;","x_google_ignoreList":[0]}