if (!window.define) {
    const modules = {};
    window.__modules = modules;
    const modulePromises = {};

    const thisScriptSource = document.currentScript.getAttribute('src');
    const srcDir = thisScriptSource.substring(0, thisScriptSource.lastIndexOf('/'));

    const load = (id) => {
        if (modules[id]) return modules[id];
        if (modulePromises[id]) return modulePromises[id];
        return modulePromises[id] = new Promise((resolve, reject) => {
            const script = document.createElement('script');
            script.src = srcDir + '/' + id + '.js';
            script.onload = () => modules[id].then(resolve);
            script.onerror = err => reject(new Error('failed to load ' + id));
            script.dataset.id = id;
            document.head.append(script);
        });
    };

    const require = (ids, callback) => {
        Promise.all(ids.map(load)).then(items => {
            if (items.length === 1) callback(items[0]);
            else callback(items);
        });
    };
    window.require = require;

    require.context = (dir, useSubdirs) => {
        if ((dir === "../../images/emoji" || dir === "../images/emoji") && !useSubdirs) {
            const data = {"chunks.png":"f59b84127fa7b6c48b6c.png","eggbug-classic.png":"41454e429d62b5cb7963.png","eggbug.png":"17aa2d48956926005de9.png","sixty.png":"9a6014af31fb1ca65a1f.png","unyeah.png":"5cf84d596a2c422967de.png","yeah.png":"014b0a8cc35206ef151d.png"};
            const f = (n) => data[n];
            f.keys = () => Object.keys(data);
            return f;
        } else if ((dir === "../../images/plus-emoji" || dir === "../images/plus-emoji") && !useSubdirs) {
            const data = {"eggbug-asleep.png":"ebbf360236a95b62bdfc.png","eggbug-devious.png":"c4f3f2c6b9ffb85934e7.png","eggbug-heart-sob.png":"b59709333449a01e3e0a.png","eggbug-nervous.png":"d2753b632211c395538e.png","eggbug-pensive.png":"ae53a8b5de7c919100e6.png","eggbug-pleading.png":"11c5493261064ffa82c0.png","eggbug-relieved.png":"3633c116f0941d94d237.png","eggbug-shocked.png":"b25a9fdf230219087003.png","eggbug-smile-hearts.png":"d7ec7f057e6fb15a94cc.png","eggbug-sob.png":"9559ff8058a895328d76.png","eggbug-tuesday.png":"90058099e741e483208a.png","eggbug-uwu.png":"228d3a13bd5f7796b434.png","eggbug-wink.png":"3bc3a1c5272e2ceb8712.png","host-aww.png":"9bb403f3822c6457baf6.png","host-cry.png":"530f8cf75eac87716702.png","host-evil.png":"cb9a5640d7ef7b361a1a.png","host-frown.png":"99c7fbf98de865cc9726.png","host-joy.png":"53635f5fe850274b1a7d.png","host-love.png":"c45b6d8f9de20f725b98.png","host-nervous.png":"e5d55348f39c65a20148.png","host-plead.png":"fa883e2377fea8945237.png","host-shock.png":"bfa6d6316fd95ae76803.png","host-stare.png":"a09d966cd188c9ebaa4c.png"};
            const f = (n) => data[n];
            f.keys = () => Object.keys(data);
            return f;
        }
        throw new Error('not supported: require.context for ' + dir);
    };

    window.define = (imports, exec) => {
        if (typeof imports === 'function') {
            exec = imports;
            imports = [];
        }
        const id = document.currentScript.dataset.id
            ?? './' + document.currentScript.getAttribute('src').split('/').pop().replace(/\.js$/i, '');
        if (modules[id]) return;
        const exports = {};
        modules[id] = Promise.resolve().then(function() {
            const imported = [];
            for (const id of imports) {
                if (id === 'require') imported.push(Promise.resolve(require));
                else if (id === 'exports') imported.push(Promise.resolve(exports));
                else imported.push(load(id));
            }
            return Promise.all(imported);
        }).then(function(imported) {
            const result = exec.apply(window, imported);
            if (!('default' in exports)) exports.default = result;
            return exports;
        });
    };

    window.process = { env: { NODE_ENV: 'production' } };
}

define(['exports', './post-page', './artist-alley-listing-Dn2_eERZ', './styled-input-CUFbgPOn'], (function (exports, postPage, artistAlleyListing, styledInput) { 'use strict';

	var normalizeUrl$2 = {exports: {}};

	var url = {};

	var punycode = {exports: {}};

	/*! https://mths.be/punycode v1.3.2 by @mathias */
	punycode.exports;

	var hasRequiredPunycode;

	function requirePunycode () {
		if (hasRequiredPunycode) return punycode.exports;
		hasRequiredPunycode = 1;
		(function (module, exports) {
	(function(root) {

				/** Detect free variables */
				var freeExports = exports &&
					!exports.nodeType && exports;
				var freeModule = module &&
					!module.nodeType && module;
				var freeGlobal = typeof postPage.commonjsGlobal == 'object' && postPage.commonjsGlobal;
				if (
					freeGlobal.global === freeGlobal ||
					freeGlobal.window === freeGlobal ||
					freeGlobal.self === freeGlobal
				) {
					root = freeGlobal;
				}

				/**
				 * The `punycode` object.
				 * @name punycode
				 * @type Object
				 */
				var punycode,

				/** Highest positive signed 32-bit float value */
				maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1

				/** Bootstring parameters */
				base = 36,
				tMin = 1,
				tMax = 26,
				skew = 38,
				damp = 700,
				initialBias = 72,
				initialN = 128, // 0x80
				delimiter = '-', // '\x2D'

				/** Regular expressions */
				regexPunycode = /^xn--/,
				regexNonASCII = /[^\x20-\x7E]/, // unprintable ASCII chars + non-ASCII chars
				regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, // RFC 3490 separators

				/** Error messages */
				errors = {
					'overflow': 'Overflow: input needs wider integers to process',
					'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
					'invalid-input': 'Invalid input'
				},

				/** Convenience shortcuts */
				baseMinusTMin = base - tMin,
				floor = Math.floor,
				stringFromCharCode = String.fromCharCode,

				/** Temporary variable */
				key;

				/*--------------------------------------------------------------------------*/

				/**
				 * A generic error utility function.
				 * @private
				 * @param {String} type The error type.
				 * @returns {Error} Throws a `RangeError` with the applicable error message.
				 */
				function error(type) {
					throw RangeError(errors[type]);
				}

				/**
				 * A generic `Array#map` utility function.
				 * @private
				 * @param {Array} array The array to iterate over.
				 * @param {Function} callback The function that gets called for every array
				 * item.
				 * @returns {Array} A new array of values returned by the callback function.
				 */
				function map(array, fn) {
					var length = array.length;
					var result = [];
					while (length--) {
						result[length] = fn(array[length]);
					}
					return result;
				}

				/**
				 * A simple `Array#map`-like wrapper to work with domain name strings or email
				 * addresses.
				 * @private
				 * @param {String} domain The domain name or email address.
				 * @param {Function} callback The function that gets called for every
				 * character.
				 * @returns {Array} A new string of characters returned by the callback
				 * function.
				 */
				function mapDomain(string, fn) {
					var parts = string.split('@');
					var result = '';
					if (parts.length > 1) {
						// In email addresses, only the domain name should be punycoded. Leave
						// the local part (i.e. everything up to `@`) intact.
						result = parts[0] + '@';
						string = parts[1];
					}
					// Avoid `split(regex)` for IE8 compatibility. See #17.
					string = string.replace(regexSeparators, '\x2E');
					var labels = string.split('.');
					var encoded = map(labels, fn).join('.');
					return result + encoded;
				}

				/**
				 * Creates an array containing the numeric code points of each Unicode
				 * character in the string. While JavaScript uses UCS-2 internally,
				 * this function will convert a pair of surrogate halves (each of which
				 * UCS-2 exposes as separate characters) into a single code point,
				 * matching UTF-16.
				 * @see `punycode.ucs2.encode`
				 * @see <https://mathiasbynens.be/notes/javascript-encoding>
				 * @memberOf punycode.ucs2
				 * @name decode
				 * @param {String} string The Unicode input string (UCS-2).
				 * @returns {Array} The new array of code points.
				 */
				function ucs2decode(string) {
					var output = [],
					    counter = 0,
					    length = string.length,
					    value,
					    extra;
					while (counter < length) {
						value = string.charCodeAt(counter++);
						if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
							// high surrogate, and there is a next character
							extra = string.charCodeAt(counter++);
							if ((extra & 0xFC00) == 0xDC00) { // low surrogate
								output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
							} else {
								// unmatched surrogate; only append this code unit, in case the next
								// code unit is the high surrogate of a surrogate pair
								output.push(value);
								counter--;
							}
						} else {
							output.push(value);
						}
					}
					return output;
				}

				/**
				 * Creates a string based on an array of numeric code points.
				 * @see `punycode.ucs2.decode`
				 * @memberOf punycode.ucs2
				 * @name encode
				 * @param {Array} codePoints The array of numeric code points.
				 * @returns {String} The new Unicode string (UCS-2).
				 */
				function ucs2encode(array) {
					return map(array, function(value) {
						var output = '';
						if (value > 0xFFFF) {
							value -= 0x10000;
							output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
							value = 0xDC00 | value & 0x3FF;
						}
						output += stringFromCharCode(value);
						return output;
					}).join('');
				}

				/**
				 * Converts a basic code point into a digit/integer.
				 * @see `digitToBasic()`
				 * @private
				 * @param {Number} codePoint The basic numeric code point value.
				 * @returns {Number} The numeric value of a basic code point (for use in
				 * representing integers) in the range `0` to `base - 1`, or `base` if
				 * the code point does not represent a value.
				 */
				function basicToDigit(codePoint) {
					if (codePoint - 48 < 10) {
						return codePoint - 22;
					}
					if (codePoint - 65 < 26) {
						return codePoint - 65;
					}
					if (codePoint - 97 < 26) {
						return codePoint - 97;
					}
					return base;
				}

				/**
				 * Converts a digit/integer into a basic code point.
				 * @see `basicToDigit()`
				 * @private
				 * @param {Number} digit The numeric value of a basic code point.
				 * @returns {Number} The basic code point whose value (when used for
				 * representing integers) is `digit`, which needs to be in the range
				 * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
				 * used; else, the lowercase form is used. The behavior is undefined
				 * if `flag` is non-zero and `digit` has no uppercase form.
				 */
				function digitToBasic(digit, flag) {
					//  0..25 map to ASCII a..z or A..Z
					// 26..35 map to ASCII 0..9
					return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
				}

				/**
				 * Bias adaptation function as per section 3.4 of RFC 3492.
				 * http://tools.ietf.org/html/rfc3492#section-3.4
				 * @private
				 */
				function adapt(delta, numPoints, firstTime) {
					var k = 0;
					delta = firstTime ? floor(delta / damp) : delta >> 1;
					delta += floor(delta / numPoints);
					for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {
						delta = floor(delta / baseMinusTMin);
					}
					return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
				}

				/**
				 * Converts a Punycode string of ASCII-only symbols to a string of Unicode
				 * symbols.
				 * @memberOf punycode
				 * @param {String} input The Punycode string of ASCII-only symbols.
				 * @returns {String} The resulting string of Unicode symbols.
				 */
				function decode(input) {
					// Don't use UCS-2
					var output = [],
					    inputLength = input.length,
					    out,
					    i = 0,
					    n = initialN,
					    bias = initialBias,
					    basic,
					    j,
					    index,
					    oldi,
					    w,
					    k,
					    digit,
					    t,
					    /** Cached calculation results */
					    baseMinusT;

					// Handle the basic code points: let `basic` be the number of input code
					// points before the last delimiter, or `0` if there is none, then copy
					// the first basic code points to the output.

					basic = input.lastIndexOf(delimiter);
					if (basic < 0) {
						basic = 0;
					}

					for (j = 0; j < basic; ++j) {
						// if it's not a basic code point
						if (input.charCodeAt(j) >= 0x80) {
							error('not-basic');
						}
						output.push(input.charCodeAt(j));
					}

					// Main decoding loop: start just after the last delimiter if any basic code
					// points were copied; start at the beginning otherwise.

					for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {

						// `index` is the index of the next character to be consumed.
						// Decode a generalized variable-length integer into `delta`,
						// which gets added to `i`. The overflow checking is easier
						// if we increase `i` as we go, then subtract off its starting
						// value at the end to obtain `delta`.
						for (oldi = i, w = 1, k = base; /* no condition */; k += base) {

							if (index >= inputLength) {
								error('invalid-input');
							}

							digit = basicToDigit(input.charCodeAt(index++));

							if (digit >= base || digit > floor((maxInt - i) / w)) {
								error('overflow');
							}

							i += digit * w;
							t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);

							if (digit < t) {
								break;
							}

							baseMinusT = base - t;
							if (w > floor(maxInt / baseMinusT)) {
								error('overflow');
							}

							w *= baseMinusT;

						}

						out = output.length + 1;
						bias = adapt(i - oldi, out, oldi == 0);

						// `i` was supposed to wrap around from `out` to `0`,
						// incrementing `n` each time, so we'll fix that now:
						if (floor(i / out) > maxInt - n) {
							error('overflow');
						}

						n += floor(i / out);
						i %= out;

						// Insert `n` at position `i` of the output
						output.splice(i++, 0, n);

					}

					return ucs2encode(output);
				}

				/**
				 * Converts a string of Unicode symbols (e.g. a domain name label) to a
				 * Punycode string of ASCII-only symbols.
				 * @memberOf punycode
				 * @param {String} input The string of Unicode symbols.
				 * @returns {String} The resulting Punycode string of ASCII-only symbols.
				 */
				function encode(input) {
					var n,
					    delta,
					    handledCPCount,
					    basicLength,
					    bias,
					    j,
					    m,
					    q,
					    k,
					    t,
					    currentValue,
					    output = [],
					    /** `inputLength` will hold the number of code points in `input`. */
					    inputLength,
					    /** Cached calculation results */
					    handledCPCountPlusOne,
					    baseMinusT,
					    qMinusT;

					// Convert the input in UCS-2 to Unicode
					input = ucs2decode(input);

					// Cache the length
					inputLength = input.length;

					// Initialize the state
					n = initialN;
					delta = 0;
					bias = initialBias;

					// Handle the basic code points
					for (j = 0; j < inputLength; ++j) {
						currentValue = input[j];
						if (currentValue < 0x80) {
							output.push(stringFromCharCode(currentValue));
						}
					}

					handledCPCount = basicLength = output.length;

					// `handledCPCount` is the number of code points that have been handled;
					// `basicLength` is the number of basic code points.

					// Finish the basic string - if it is not empty - with a delimiter
					if (basicLength) {
						output.push(delimiter);
					}

					// Main encoding loop:
					while (handledCPCount < inputLength) {

						// All non-basic code points < n have been handled already. Find the next
						// larger one:
						for (m = maxInt, j = 0; j < inputLength; ++j) {
							currentValue = input[j];
							if (currentValue >= n && currentValue < m) {
								m = currentValue;
							}
						}

						// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
						// but guard against overflow
						handledCPCountPlusOne = handledCPCount + 1;
						if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
							error('overflow');
						}

						delta += (m - n) * handledCPCountPlusOne;
						n = m;

						for (j = 0; j < inputLength; ++j) {
							currentValue = input[j];

							if (currentValue < n && ++delta > maxInt) {
								error('overflow');
							}

							if (currentValue == n) {
								// Represent delta as a generalized variable-length integer
								for (q = delta, k = base; /* no condition */; k += base) {
									t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
									if (q < t) {
										break;
									}
									qMinusT = q - t;
									baseMinusT = base - t;
									output.push(
										stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
									);
									q = floor(qMinusT / baseMinusT);
								}

								output.push(stringFromCharCode(digitToBasic(q, 0)));
								bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
								delta = 0;
								++handledCPCount;
							}
						}

						++delta;
						++n;

					}
					return output.join('');
				}

				/**
				 * Converts a Punycode string representing a domain name or an email address
				 * to Unicode. Only the Punycoded parts of the input will be converted, i.e.
				 * it doesn't matter if you call it on a string that has already been
				 * converted to Unicode.
				 * @memberOf punycode
				 * @param {String} input The Punycoded domain name or email address to
				 * convert to Unicode.
				 * @returns {String} The Unicode representation of the given Punycode
				 * string.
				 */
				function toUnicode(input) {
					return mapDomain(input, function(string) {
						return regexPunycode.test(string)
							? decode(string.slice(4).toLowerCase())
							: string;
					});
				}

				/**
				 * Converts a Unicode string representing a domain name or an email address to
				 * Punycode. Only the non-ASCII parts of the domain name will be converted,
				 * i.e. it doesn't matter if you call it with a domain that's already in
				 * ASCII.
				 * @memberOf punycode
				 * @param {String} input The domain name or email address to convert, as a
				 * Unicode string.
				 * @returns {String} The Punycode representation of the given domain name or
				 * email address.
				 */
				function toASCII(input) {
					return mapDomain(input, function(string) {
						return regexNonASCII.test(string)
							? 'xn--' + encode(string)
							: string;
					});
				}

				/*--------------------------------------------------------------------------*/

				/** Define the public API */
				punycode = {
					/**
					 * A string representing the current Punycode.js version number.
					 * @memberOf punycode
					 * @type String
					 */
					'version': '1.3.2',
					/**
					 * An object of methods to convert from JavaScript's internal character
					 * representation (UCS-2) to Unicode code points, and back.
					 * @see <https://mathiasbynens.be/notes/javascript-encoding>
					 * @memberOf punycode
					 * @type Object
					 */
					'ucs2': {
						'decode': ucs2decode,
						'encode': ucs2encode
					},
					'decode': decode,
					'encode': encode,
					'toASCII': toASCII,
					'toUnicode': toUnicode
				};

				/** Expose `punycode` */
				// Some AMD build optimizers, like r.js, check for specific condition patterns
				// like the following:
				if (freeExports && freeModule) {
					if (module.exports == freeExports) { // in Node.js or RingoJS v0.8.0+
						freeModule.exports = punycode;
					} else { // in Narwhal or RingoJS v0.7.0-
						for (key in punycode) {
							punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);
						}
					}
				} else { // in Rhino or a web browser
					root.punycode = punycode;
				}

			}(postPage.commonjsGlobal)); 
		} (punycode, punycode.exports));
		return punycode.exports;
	}

	var util;
	var hasRequiredUtil;

	function requireUtil () {
		if (hasRequiredUtil) return util;
		hasRequiredUtil = 1;

		util = {
		  isString: function(arg) {
		    return typeof(arg) === 'string';
		  },
		  isObject: function(arg) {
		    return typeof(arg) === 'object' && arg !== null;
		  },
		  isNull: function(arg) {
		    return arg === null;
		  },
		  isNullOrUndefined: function(arg) {
		    return arg == null;
		  }
		};
		return util;
	}

	var querystring = {};

	var decode;
	var hasRequiredDecode;

	function requireDecode () {
		if (hasRequiredDecode) return decode;
		hasRequiredDecode = 1;

		// If obj.hasOwnProperty has been overridden, then calling
		// obj.hasOwnProperty(prop) will break.
		// See: https://github.com/joyent/node/issues/1707
		function hasOwnProperty(obj, prop) {
		  return Object.prototype.hasOwnProperty.call(obj, prop);
		}

		decode = function(qs, sep, eq, options) {
		  sep = sep || '&';
		  eq = eq || '=';
		  var obj = {};

		  if (typeof qs !== 'string' || qs.length === 0) {
		    return obj;
		  }

		  var regexp = /\+/g;
		  qs = qs.split(sep);

		  var maxKeys = 1000;
		  if (options && typeof options.maxKeys === 'number') {
		    maxKeys = options.maxKeys;
		  }

		  var len = qs.length;
		  // maxKeys <= 0 means that we should not limit keys count
		  if (maxKeys > 0 && len > maxKeys) {
		    len = maxKeys;
		  }

		  for (var i = 0; i < len; ++i) {
		    var x = qs[i].replace(regexp, '%20'),
		        idx = x.indexOf(eq),
		        kstr, vstr, k, v;

		    if (idx >= 0) {
		      kstr = x.substr(0, idx);
		      vstr = x.substr(idx + 1);
		    } else {
		      kstr = x;
		      vstr = '';
		    }

		    k = decodeURIComponent(kstr);
		    v = decodeURIComponent(vstr);

		    if (!hasOwnProperty(obj, k)) {
		      obj[k] = v;
		    } else if (Array.isArray(obj[k])) {
		      obj[k].push(v);
		    } else {
		      obj[k] = [obj[k], v];
		    }
		  }

		  return obj;
		};
		return decode;
	}

	var encode;
	var hasRequiredEncode;

	function requireEncode () {
		if (hasRequiredEncode) return encode;
		hasRequiredEncode = 1;

		var stringifyPrimitive = function(v) {
		  switch (typeof v) {
		    case 'string':
		      return v;

		    case 'boolean':
		      return v ? 'true' : 'false';

		    case 'number':
		      return isFinite(v) ? v : '';

		    default:
		      return '';
		  }
		};

		encode = function(obj, sep, eq, name) {
		  sep = sep || '&';
		  eq = eq || '=';
		  if (obj === null) {
		    obj = undefined;
		  }

		  if (typeof obj === 'object') {
		    return Object.keys(obj).map(function(k) {
		      var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;
		      if (Array.isArray(obj[k])) {
		        return obj[k].map(function(v) {
		          return ks + encodeURIComponent(stringifyPrimitive(v));
		        }).join(sep);
		      } else {
		        return ks + encodeURIComponent(stringifyPrimitive(obj[k]));
		      }
		    }).join(sep);

		  }

		  if (!name) return '';
		  return encodeURIComponent(stringifyPrimitive(name)) + eq +
		         encodeURIComponent(stringifyPrimitive(obj));
		};
		return encode;
	}

	var hasRequiredQuerystring;

	function requireQuerystring () {
		if (hasRequiredQuerystring) return querystring;
		hasRequiredQuerystring = 1;

		querystring.decode = querystring.parse = requireDecode();
		querystring.encode = querystring.stringify = requireEncode();
		return querystring;
	}

	var hasRequiredUrl;

	function requireUrl () {
		if (hasRequiredUrl) return url;
		hasRequiredUrl = 1;

		var punycode = requirePunycode();
		var util = requireUtil();

		url.parse = urlParse;
		url.resolve = urlResolve;
		url.resolveObject = urlResolveObject;
		url.format = urlFormat;

		url.Url = Url;

		function Url() {
		  this.protocol = null;
		  this.slashes = null;
		  this.auth = null;
		  this.host = null;
		  this.port = null;
		  this.hostname = null;
		  this.hash = null;
		  this.search = null;
		  this.query = null;
		  this.pathname = null;
		  this.path = null;
		  this.href = null;
		}

		// Reference: RFC 3986, RFC 1808, RFC 2396

		// define these here so at least they only have to be
		// compiled once on the first module load.
		var protocolPattern = /^([a-z0-9.+-]+:)/i,
		    portPattern = /:[0-9]*$/,

		    // Special case for a simple path URL
		    simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/,

		    // RFC 2396: characters reserved for delimiting URLs.
		    // We actually just auto-escape these.
		    delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t'],

		    // RFC 2396: characters not allowed for various reasons.
		    unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims),

		    // Allowed by RFCs, but cause of XSS attacks.  Always escape these.
		    autoEscape = ['\''].concat(unwise),
		    // Characters that are never ever allowed in a hostname.
		    // Note that any invalid chars are also handled, but these
		    // are the ones that are *expected* to be seen, so we fast-path
		    // them.
		    nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),
		    hostEndingChars = ['/', '?', '#'],
		    hostnameMaxLen = 255,
		    hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,
		    hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,
		    // protocols that can allow "unsafe" and "unwise" chars.
		    unsafeProtocol = {
		      'javascript': true,
		      'javascript:': true
		    },
		    // protocols that never have a hostname.
		    hostlessProtocol = {
		      'javascript': true,
		      'javascript:': true
		    },
		    // protocols that always contain a // bit.
		    slashedProtocol = {
		      'http': true,
		      'https': true,
		      'ftp': true,
		      'gopher': true,
		      'file': true,
		      'http:': true,
		      'https:': true,
		      'ftp:': true,
		      'gopher:': true,
		      'file:': true
		    },
		    querystring = requireQuerystring();

		function urlParse(url, parseQueryString, slashesDenoteHost) {
		  if (url && util.isObject(url) && url instanceof Url) return url;

		  var u = new Url;
		  u.parse(url, parseQueryString, slashesDenoteHost);
		  return u;
		}

		Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {
		  if (!util.isString(url)) {
		    throw new TypeError("Parameter 'url' must be a string, not " + typeof url);
		  }

		  // Copy chrome, IE, opera backslash-handling behavior.
		  // Back slashes before the query string get converted to forward slashes
		  // See: https://code.google.com/p/chromium/issues/detail?id=25916
		  var queryIndex = url.indexOf('?'),
		      splitter =
		          (queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#',
		      uSplit = url.split(splitter),
		      slashRegex = /\\/g;
		  uSplit[0] = uSplit[0].replace(slashRegex, '/');
		  url = uSplit.join(splitter);

		  var rest = url;

		  // trim before proceeding.
		  // This is to support parse stuff like "  http://foo.com  \n"
		  rest = rest.trim();

		  if (!slashesDenoteHost && url.split('#').length === 1) {
		    // Try fast path regexp
		    var simplePath = simplePathPattern.exec(rest);
		    if (simplePath) {
		      this.path = rest;
		      this.href = rest;
		      this.pathname = simplePath[1];
		      if (simplePath[2]) {
		        this.search = simplePath[2];
		        if (parseQueryString) {
		          this.query = querystring.parse(this.search.substr(1));
		        } else {
		          this.query = this.search.substr(1);
		        }
		      } else if (parseQueryString) {
		        this.search = '';
		        this.query = {};
		      }
		      return this;
		    }
		  }

		  var proto = protocolPattern.exec(rest);
		  if (proto) {
		    proto = proto[0];
		    var lowerProto = proto.toLowerCase();
		    this.protocol = lowerProto;
		    rest = rest.substr(proto.length);
		  }

		  // figure out if it's got a host
		  // user@server is *always* interpreted as a hostname, and url
		  // resolution will treat //foo/bar as host=foo,path=bar because that's
		  // how the browser resolves relative URLs.
		  if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
		    var slashes = rest.substr(0, 2) === '//';
		    if (slashes && !(proto && hostlessProtocol[proto])) {
		      rest = rest.substr(2);
		      this.slashes = true;
		    }
		  }

		  if (!hostlessProtocol[proto] &&
		      (slashes || (proto && !slashedProtocol[proto]))) {

		    // there's a hostname.
		    // the first instance of /, ?, ;, or # ends the host.
		    //
		    // If there is an @ in the hostname, then non-host chars *are* allowed
		    // to the left of the last @ sign, unless some host-ending character
		    // comes *before* the @-sign.
		    // URLs are obnoxious.
		    //
		    // ex:
		    // http://a@b@c/ => user:a@b host:c
		    // http://a@b?@c => user:a host:c path:/?@c

		    // v0.12 TODO(isaacs): This is not quite how Chrome does things.
		    // Review our test case against browsers more comprehensively.

		    // find the first instance of any hostEndingChars
		    var hostEnd = -1;
		    for (var i = 0; i < hostEndingChars.length; i++) {
		      var hec = rest.indexOf(hostEndingChars[i]);
		      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
		        hostEnd = hec;
		    }

		    // at this point, either we have an explicit point where the
		    // auth portion cannot go past, or the last @ char is the decider.
		    var auth, atSign;
		    if (hostEnd === -1) {
		      // atSign can be anywhere.
		      atSign = rest.lastIndexOf('@');
		    } else {
		      // atSign must be in auth portion.
		      // http://a@b/c@d => host:b auth:a path:/c@d
		      atSign = rest.lastIndexOf('@', hostEnd);
		    }

		    // Now we have a portion which is definitely the auth.
		    // Pull that off.
		    if (atSign !== -1) {
		      auth = rest.slice(0, atSign);
		      rest = rest.slice(atSign + 1);
		      this.auth = decodeURIComponent(auth);
		    }

		    // the host is the remaining to the left of the first non-host char
		    hostEnd = -1;
		    for (var i = 0; i < nonHostChars.length; i++) {
		      var hec = rest.indexOf(nonHostChars[i]);
		      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
		        hostEnd = hec;
		    }
		    // if we still have not hit it, then the entire thing is a host.
		    if (hostEnd === -1)
		      hostEnd = rest.length;

		    this.host = rest.slice(0, hostEnd);
		    rest = rest.slice(hostEnd);

		    // pull out port.
		    this.parseHost();

		    // we've indicated that there is a hostname,
		    // so even if it's empty, it has to be present.
		    this.hostname = this.hostname || '';

		    // if hostname begins with [ and ends with ]
		    // assume that it's an IPv6 address.
		    var ipv6Hostname = this.hostname[0] === '[' &&
		        this.hostname[this.hostname.length - 1] === ']';

		    // validate a little.
		    if (!ipv6Hostname) {
		      var hostparts = this.hostname.split(/\./);
		      for (var i = 0, l = hostparts.length; i < l; i++) {
		        var part = hostparts[i];
		        if (!part) continue;
		        if (!part.match(hostnamePartPattern)) {
		          var newpart = '';
		          for (var j = 0, k = part.length; j < k; j++) {
		            if (part.charCodeAt(j) > 127) {
		              // we replace non-ASCII char with a temporary placeholder
		              // we need this to make sure size of hostname is not
		              // broken by replacing non-ASCII by nothing
		              newpart += 'x';
		            } else {
		              newpart += part[j];
		            }
		          }
		          // we test again with ASCII char only
		          if (!newpart.match(hostnamePartPattern)) {
		            var validParts = hostparts.slice(0, i);
		            var notHost = hostparts.slice(i + 1);
		            var bit = part.match(hostnamePartStart);
		            if (bit) {
		              validParts.push(bit[1]);
		              notHost.unshift(bit[2]);
		            }
		            if (notHost.length) {
		              rest = '/' + notHost.join('.') + rest;
		            }
		            this.hostname = validParts.join('.');
		            break;
		          }
		        }
		      }
		    }

		    if (this.hostname.length > hostnameMaxLen) {
		      this.hostname = '';
		    } else {
		      // hostnames are always lower case.
		      this.hostname = this.hostname.toLowerCase();
		    }

		    if (!ipv6Hostname) {
		      // IDNA Support: Returns a punycoded representation of "domain".
		      // It only converts parts of the domain name that
		      // have non-ASCII characters, i.e. it doesn't matter if
		      // you call it with a domain that already is ASCII-only.
		      this.hostname = punycode.toASCII(this.hostname);
		    }

		    var p = this.port ? ':' + this.port : '';
		    var h = this.hostname || '';
		    this.host = h + p;
		    this.href += this.host;

		    // strip [ and ] from the hostname
		    // the host field still retains them, though
		    if (ipv6Hostname) {
		      this.hostname = this.hostname.substr(1, this.hostname.length - 2);
		      if (rest[0] !== '/') {
		        rest = '/' + rest;
		      }
		    }
		  }

		  // now rest is set to the post-host stuff.
		  // chop off any delim chars.
		  if (!unsafeProtocol[lowerProto]) {

		    // First, make 100% sure that any "autoEscape" chars get
		    // escaped, even if encodeURIComponent doesn't think they
		    // need to be.
		    for (var i = 0, l = autoEscape.length; i < l; i++) {
		      var ae = autoEscape[i];
		      if (rest.indexOf(ae) === -1)
		        continue;
		      var esc = encodeURIComponent(ae);
		      if (esc === ae) {
		        esc = escape(ae);
		      }
		      rest = rest.split(ae).join(esc);
		    }
		  }


		  // chop off from the tail first.
		  var hash = rest.indexOf('#');
		  if (hash !== -1) {
		    // got a fragment string.
		    this.hash = rest.substr(hash);
		    rest = rest.slice(0, hash);
		  }
		  var qm = rest.indexOf('?');
		  if (qm !== -1) {
		    this.search = rest.substr(qm);
		    this.query = rest.substr(qm + 1);
		    if (parseQueryString) {
		      this.query = querystring.parse(this.query);
		    }
		    rest = rest.slice(0, qm);
		  } else if (parseQueryString) {
		    // no query string, but parseQueryString still requested
		    this.search = '';
		    this.query = {};
		  }
		  if (rest) this.pathname = rest;
		  if (slashedProtocol[lowerProto] &&
		      this.hostname && !this.pathname) {
		    this.pathname = '/';
		  }

		  //to support http.request
		  if (this.pathname || this.search) {
		    var p = this.pathname || '';
		    var s = this.search || '';
		    this.path = p + s;
		  }

		  // finally, reconstruct the href based on what has been validated.
		  this.href = this.format();
		  return this;
		};

		// format a parsed object into a url string
		function urlFormat(obj) {
		  // ensure it's an object, and not a string url.
		  // If it's an obj, this is a no-op.
		  // this way, you can call url_format() on strings
		  // to clean up potentially wonky urls.
		  if (util.isString(obj)) obj = urlParse(obj);
		  if (!(obj instanceof Url)) return Url.prototype.format.call(obj);
		  return obj.format();
		}

		Url.prototype.format = function() {
		  var auth = this.auth || '';
		  if (auth) {
		    auth = encodeURIComponent(auth);
		    auth = auth.replace(/%3A/i, ':');
		    auth += '@';
		  }

		  var protocol = this.protocol || '',
		      pathname = this.pathname || '',
		      hash = this.hash || '',
		      host = false,
		      query = '';

		  if (this.host) {
		    host = auth + this.host;
		  } else if (this.hostname) {
		    host = auth + (this.hostname.indexOf(':') === -1 ?
		        this.hostname :
		        '[' + this.hostname + ']');
		    if (this.port) {
		      host += ':' + this.port;
		    }
		  }

		  if (this.query &&
		      util.isObject(this.query) &&
		      Object.keys(this.query).length) {
		    query = querystring.stringify(this.query);
		  }

		  var search = this.search || (query && ('?' + query)) || '';

		  if (protocol && protocol.substr(-1) !== ':') protocol += ':';

		  // only the slashedProtocols get the //.  Not mailto:, xmpp:, etc.
		  // unless they had them to begin with.
		  if (this.slashes ||
		      (!protocol || slashedProtocol[protocol]) && host !== false) {
		    host = '//' + (host || '');
		    if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;
		  } else if (!host) {
		    host = '';
		  }

		  if (hash && hash.charAt(0) !== '#') hash = '#' + hash;
		  if (search && search.charAt(0) !== '?') search = '?' + search;

		  pathname = pathname.replace(/[?#]/g, function(match) {
		    return encodeURIComponent(match);
		  });
		  search = search.replace('#', '%23');

		  return protocol + host + pathname + search + hash;
		};

		function urlResolve(source, relative) {
		  return urlParse(source, false, true).resolve(relative);
		}

		Url.prototype.resolve = function(relative) {
		  return this.resolveObject(urlParse(relative, false, true)).format();
		};

		function urlResolveObject(source, relative) {
		  if (!source) return relative;
		  return urlParse(source, false, true).resolveObject(relative);
		}

		Url.prototype.resolveObject = function(relative) {
		  if (util.isString(relative)) {
		    var rel = new Url();
		    rel.parse(relative, false, true);
		    relative = rel;
		  }

		  var result = new Url();
		  var tkeys = Object.keys(this);
		  for (var tk = 0; tk < tkeys.length; tk++) {
		    var tkey = tkeys[tk];
		    result[tkey] = this[tkey];
		  }

		  // hash is always overridden, no matter what.
		  // even href="" will remove it.
		  result.hash = relative.hash;

		  // if the relative url is empty, then there's nothing left to do here.
		  if (relative.href === '') {
		    result.href = result.format();
		    return result;
		  }

		  // hrefs like //foo/bar always cut to the protocol.
		  if (relative.slashes && !relative.protocol) {
		    // take everything except the protocol from relative
		    var rkeys = Object.keys(relative);
		    for (var rk = 0; rk < rkeys.length; rk++) {
		      var rkey = rkeys[rk];
		      if (rkey !== 'protocol')
		        result[rkey] = relative[rkey];
		    }

		    //urlParse appends trailing / to urls like http://www.example.com
		    if (slashedProtocol[result.protocol] &&
		        result.hostname && !result.pathname) {
		      result.path = result.pathname = '/';
		    }

		    result.href = result.format();
		    return result;
		  }

		  if (relative.protocol && relative.protocol !== result.protocol) {
		    // if it's a known url protocol, then changing
		    // the protocol does weird things
		    // first, if it's not file:, then we MUST have a host,
		    // and if there was a path
		    // to begin with, then we MUST have a path.
		    // if it is file:, then the host is dropped,
		    // because that's known to be hostless.
		    // anything else is assumed to be absolute.
		    if (!slashedProtocol[relative.protocol]) {
		      var keys = Object.keys(relative);
		      for (var v = 0; v < keys.length; v++) {
		        var k = keys[v];
		        result[k] = relative[k];
		      }
		      result.href = result.format();
		      return result;
		    }

		    result.protocol = relative.protocol;
		    if (!relative.host && !hostlessProtocol[relative.protocol]) {
		      var relPath = (relative.pathname || '').split('/');
		      while (relPath.length && !(relative.host = relPath.shift()));
		      if (!relative.host) relative.host = '';
		      if (!relative.hostname) relative.hostname = '';
		      if (relPath[0] !== '') relPath.unshift('');
		      if (relPath.length < 2) relPath.unshift('');
		      result.pathname = relPath.join('/');
		    } else {
		      result.pathname = relative.pathname;
		    }
		    result.search = relative.search;
		    result.query = relative.query;
		    result.host = relative.host || '';
		    result.auth = relative.auth;
		    result.hostname = relative.hostname || relative.host;
		    result.port = relative.port;
		    // to support http.request
		    if (result.pathname || result.search) {
		      var p = result.pathname || '';
		      var s = result.search || '';
		      result.path = p + s;
		    }
		    result.slashes = result.slashes || relative.slashes;
		    result.href = result.format();
		    return result;
		  }

		  var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),
		      isRelAbs = (
		          relative.host ||
		          relative.pathname && relative.pathname.charAt(0) === '/'
		      ),
		      mustEndAbs = (isRelAbs || isSourceAbs ||
		                    (result.host && relative.pathname)),
		      removeAllDots = mustEndAbs,
		      srcPath = result.pathname && result.pathname.split('/') || [],
		      relPath = relative.pathname && relative.pathname.split('/') || [],
		      psychotic = result.protocol && !slashedProtocol[result.protocol];

		  // if the url is a non-slashed url, then relative
		  // links like ../.. should be able
		  // to crawl up to the hostname, as well.  This is strange.
		  // result.protocol has already been set by now.
		  // Later on, put the first path part into the host field.
		  if (psychotic) {
		    result.hostname = '';
		    result.port = null;
		    if (result.host) {
		      if (srcPath[0] === '') srcPath[0] = result.host;
		      else srcPath.unshift(result.host);
		    }
		    result.host = '';
		    if (relative.protocol) {
		      relative.hostname = null;
		      relative.port = null;
		      if (relative.host) {
		        if (relPath[0] === '') relPath[0] = relative.host;
		        else relPath.unshift(relative.host);
		      }
		      relative.host = null;
		    }
		    mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');
		  }

		  if (isRelAbs) {
		    // it's absolute.
		    result.host = (relative.host || relative.host === '') ?
		                  relative.host : result.host;
		    result.hostname = (relative.hostname || relative.hostname === '') ?
		                      relative.hostname : result.hostname;
		    result.search = relative.search;
		    result.query = relative.query;
		    srcPath = relPath;
		    // fall through to the dot-handling below.
		  } else if (relPath.length) {
		    // it's relative
		    // throw away the existing file, and take the new path instead.
		    if (!srcPath) srcPath = [];
		    srcPath.pop();
		    srcPath = srcPath.concat(relPath);
		    result.search = relative.search;
		    result.query = relative.query;
		  } else if (!util.isNullOrUndefined(relative.search)) {
		    // just pull out the search.
		    // like href='?foo'.
		    // Put this after the other two cases because it simplifies the booleans
		    if (psychotic) {
		      result.hostname = result.host = srcPath.shift();
		      //occationaly the auth can get stuck only in host
		      //this especially happens in cases like
		      //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
		      var authInHost = result.host && result.host.indexOf('@') > 0 ?
		                       result.host.split('@') : false;
		      if (authInHost) {
		        result.auth = authInHost.shift();
		        result.host = result.hostname = authInHost.shift();
		      }
		    }
		    result.search = relative.search;
		    result.query = relative.query;
		    //to support http.request
		    if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
		      result.path = (result.pathname ? result.pathname : '') +
		                    (result.search ? result.search : '');
		    }
		    result.href = result.format();
		    return result;
		  }

		  if (!srcPath.length) {
		    // no path at all.  easy.
		    // we've already handled the other stuff above.
		    result.pathname = null;
		    //to support http.request
		    if (result.search) {
		      result.path = '/' + result.search;
		    } else {
		      result.path = null;
		    }
		    result.href = result.format();
		    return result;
		  }

		  // if a url ENDs in . or .., then it must get a trailing slash.
		  // however, if it ends in anything else non-slashy,
		  // then it must NOT get a trailing slash.
		  var last = srcPath.slice(-1)[0];
		  var hasTrailingSlash = (
		      (result.host || relative.host || srcPath.length > 1) &&
		      (last === '.' || last === '..') || last === '');

		  // strip single dots, resolve double dots to parent dir
		  // if the path tries to go above the root, `up` ends up > 0
		  var up = 0;
		  for (var i = srcPath.length; i >= 0; i--) {
		    last = srcPath[i];
		    if (last === '.') {
		      srcPath.splice(i, 1);
		    } else if (last === '..') {
		      srcPath.splice(i, 1);
		      up++;
		    } else if (up) {
		      srcPath.splice(i, 1);
		      up--;
		    }
		  }

		  // if the path is allowed to go above the root, restore leading ..s
		  if (!mustEndAbs && !removeAllDots) {
		    for (; up--; up) {
		      srcPath.unshift('..');
		    }
		  }

		  if (mustEndAbs && srcPath[0] !== '' &&
		      (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {
		    srcPath.unshift('');
		  }

		  if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {
		    srcPath.push('');
		  }

		  var isAbsolute = srcPath[0] === '' ||
		      (srcPath[0] && srcPath[0].charAt(0) === '/');

		  // put the host back
		  if (psychotic) {
		    result.hostname = result.host = isAbsolute ? '' :
		                                    srcPath.length ? srcPath.shift() : '';
		    //occationaly the auth can get stuck only in host
		    //this especially happens in cases like
		    //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
		    var authInHost = result.host && result.host.indexOf('@') > 0 ?
		                     result.host.split('@') : false;
		    if (authInHost) {
		      result.auth = authInHost.shift();
		      result.host = result.hostname = authInHost.shift();
		    }
		  }

		  mustEndAbs = mustEndAbs || (result.host && srcPath.length);

		  if (mustEndAbs && !isAbsolute) {
		    srcPath.unshift('');
		  }

		  if (!srcPath.length) {
		    result.pathname = null;
		    result.path = null;
		  } else {
		    result.pathname = srcPath.join('/');
		  }

		  //to support request.http
		  if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
		    result.path = (result.pathname ? result.pathname : '') +
		                  (result.search ? result.search : '');
		  }
		  result.auth = relative.auth || result.auth;
		  result.slashes = result.slashes || relative.slashes;
		  result.href = result.format();
		  return result;
		};

		Url.prototype.parseHost = function() {
		  var host = this.host;
		  var port = portPattern.exec(host);
		  if (port) {
		    port = port[0];
		    if (port !== ':') {
		      this.port = port.substr(1);
		    }
		    host = host.substr(0, host.length - port.length);
		  }
		  if (host) this.hostname = host;
		};
		return url;
	}

	// TODO: Use the `URL` global when targeting Node.js 10
	const URLParser = typeof URL === 'undefined' ? requireUrl().URL : URL;

	// https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs
	const DATA_URL_DEFAULT_MIME_TYPE = 'text/plain';
	const DATA_URL_DEFAULT_CHARSET = 'us-ascii';

	const testParameter = (name, filters) => {
		return filters.some(filter => filter instanceof RegExp ? filter.test(name) : filter === name);
	};

	const normalizeDataURL = (urlString, {stripHash}) => {
		const parts = urlString.match(/^data:([^,]*?),([^#]*?)(?:#(.*))?$/);

		if (!parts) {
			throw new Error(`Invalid URL: ${urlString}`);
		}

		const mediaType = parts[1].split(';');
		const body = parts[2];
		const hash = stripHash ? '' : parts[3];

		let base64 = false;

		if (mediaType[mediaType.length - 1] === 'base64') {
			mediaType.pop();
			base64 = true;
		}

		// Lowercase MIME type
		const mimeType = (mediaType.shift() || '').toLowerCase();
		const attributes = mediaType
			.map(attribute => {
				let [key, value = ''] = attribute.split('=').map(string => string.trim());

				// Lowercase `charset`
				if (key === 'charset') {
					value = value.toLowerCase();

					if (value === DATA_URL_DEFAULT_CHARSET) {
						return '';
					}
				}

				return `${key}${value ? `=${value}` : ''}`;
			})
			.filter(Boolean);

		const normalizedMediaType = [
			...attributes
		];

		if (base64) {
			normalizedMediaType.push('base64');
		}

		if (normalizedMediaType.length !== 0 || (mimeType && mimeType !== DATA_URL_DEFAULT_MIME_TYPE)) {
			normalizedMediaType.unshift(mimeType);
		}

		return `data:${normalizedMediaType.join(';')},${base64 ? body.trim() : body}${hash ? `#${hash}` : ''}`;
	};

	const normalizeUrl = (urlString, options) => {
		options = {
			defaultProtocol: 'http:',
			normalizeProtocol: true,
			forceHttp: false,
			forceHttps: false,
			stripAuthentication: true,
			stripHash: false,
			stripWWW: true,
			removeQueryParameters: [/^utm_\w+/i],
			removeTrailingSlash: true,
			removeDirectoryIndex: false,
			sortQueryParameters: true,
			...options
		};

		// TODO: Remove this at some point in the future
		if (Reflect.has(options, 'normalizeHttps')) {
			throw new Error('options.normalizeHttps is renamed to options.forceHttp');
		}

		if (Reflect.has(options, 'normalizeHttp')) {
			throw new Error('options.normalizeHttp is renamed to options.forceHttps');
		}

		if (Reflect.has(options, 'stripFragment')) {
			throw new Error('options.stripFragment is renamed to options.stripHash');
		}

		urlString = urlString.trim();

		// Data URL
		if (/^data:/i.test(urlString)) {
			return normalizeDataURL(urlString, options);
		}

		const hasRelativeProtocol = urlString.startsWith('//');
		const isRelativeUrl = !hasRelativeProtocol && /^\.*\//.test(urlString);

		// Prepend protocol
		if (!isRelativeUrl) {
			urlString = urlString.replace(/^(?!(?:\w+:)?\/\/)|^\/\//, options.defaultProtocol);
		}

		const urlObj = new URLParser(urlString);

		if (options.forceHttp && options.forceHttps) {
			throw new Error('The `forceHttp` and `forceHttps` options cannot be used together');
		}

		if (options.forceHttp && urlObj.protocol === 'https:') {
			urlObj.protocol = 'http:';
		}

		if (options.forceHttps && urlObj.protocol === 'http:') {
			urlObj.protocol = 'https:';
		}

		// Remove auth
		if (options.stripAuthentication) {
			urlObj.username = '';
			urlObj.password = '';
		}

		// Remove hash
		if (options.stripHash) {
			urlObj.hash = '';
		}

		// Remove duplicate slashes if not preceded by a protocol
		if (urlObj.pathname) {
			// TODO: Use the following instead when targeting Node.js 10
			// `urlObj.pathname = urlObj.pathname.replace(/(?<!https?:)\/{2,}/g, '/');`
			urlObj.pathname = urlObj.pathname.replace(/((?!:).|^)\/{2,}/g, (_, p1) => {
				if (/^(?!\/)/g.test(p1)) {
					return `${p1}/`;
				}

				return '/';
			});
		}

		// Decode URI octets
		if (urlObj.pathname) {
			urlObj.pathname = decodeURI(urlObj.pathname);
		}

		// Remove directory index
		if (options.removeDirectoryIndex === true) {
			options.removeDirectoryIndex = [/^index\.[a-z]+$/];
		}

		if (Array.isArray(options.removeDirectoryIndex) && options.removeDirectoryIndex.length > 0) {
			let pathComponents = urlObj.pathname.split('/');
			const lastComponent = pathComponents[pathComponents.length - 1];

			if (testParameter(lastComponent, options.removeDirectoryIndex)) {
				pathComponents = pathComponents.slice(0, pathComponents.length - 1);
				urlObj.pathname = pathComponents.slice(1).join('/') + '/';
			}
		}

		if (urlObj.hostname) {
			// Remove trailing dot
			urlObj.hostname = urlObj.hostname.replace(/\.$/, '');

			// Remove `www.`
			if (options.stripWWW && /^www\.([a-z\-\d]{2,63})\.([a-z.]{2,5})$/.test(urlObj.hostname)) {
				// Each label should be max 63 at length (min: 2).
				// The extension should be max 5 at length (min: 2).
				// Source: https://en.wikipedia.org/wiki/Hostname#Restrictions_on_valid_host_names
				urlObj.hostname = urlObj.hostname.replace(/^www\./, '');
			}
		}

		// Remove query unwanted parameters
		if (Array.isArray(options.removeQueryParameters)) {
			for (const key of [...urlObj.searchParams.keys()]) {
				if (testParameter(key, options.removeQueryParameters)) {
					urlObj.searchParams.delete(key);
				}
			}
		}

		// Sort query parameters
		if (options.sortQueryParameters) {
			urlObj.searchParams.sort();
		}

		if (options.removeTrailingSlash) {
			urlObj.pathname = urlObj.pathname.replace(/\/$/, '');
		}

		// Take advantage of many of the Node `url` normalizations
		urlString = urlObj.toString();

		// Remove ending `/`
		if ((options.removeTrailingSlash || urlObj.pathname === '/') && urlObj.hash === '') {
			urlString = urlString.replace(/\/$/, '');
		}

		// Restore relative protocol, if applicable
		if (hasRelativeProtocol && !options.normalizeProtocol) {
			urlString = urlString.replace(/^http:\/\//, '//');
		}

		// Remove http/https
		if (options.stripProtocol) {
			urlString = urlString.replace(/^(?:https?:)?\/\//, '');
		}

		return urlString;
	};

	normalizeUrl$2.exports = normalizeUrl;
	// TODO: Remove this for the next major release
	normalizeUrl$2.exports.default = normalizeUrl;

	var normalizeUrlExports = normalizeUrl$2.exports;
	var normalizeUrl$1 = /*@__PURE__*/postPage.getDefaultExportFromCjs(normalizeUrlExports);

	const TokenMultiSelect = ({
	    options,
	    ...props
	}) => {
	    const { field } = postPage.useController(props);
	    const selectedOptions = field.value ;

	    return (
	        postPage.React.createElement('div', { className: "flex flex-row flex-wrap gap-2 px-3 py-2"     ,}
	            , options.map((option) => (
	                postPage.React.createElement('div', {
	                    key: `selected-token-${option}`,
	                    className: "group h-max cursor-pointer select-none"   ,}

	                    /* this weird nested div thing is to prevent a bug caused by having the default click handler and our removal handler on the same element */
	                    , postPage.React.createElement('button', {
	                        className: postPage.tw`co-token flex items-center justify-start gap-1 rounded-lg px-2 py-1 leading-none ${
                            selectedOptions.includes(option) ? "co-active" : ""
                        }`,
	                        onClick: (e) => {
	                            e.stopPropagation();
	                            selectedOptions.includes(option)
	                                ? field.onChange(
	                                      selectedOptions.filter(
	                                          (o) => o !== option
	                                      )
	                                  )
	                                : field.onChange([...selectedOptions, option]);
	                        },
	                        type: "button",}

	                        , postPage.React.createElement(postPage.ForwardRef, { className: "inline-block h-3.5" ,} )
	                        , postPage.React.createElement('span', { className: "block",}, option)
	                    )
	                )
	            ))
	        )
	    );
	};

	const BODY_LIMIT = 280;

	const InputRow

	 = ({ label, children, smallLabel }) => {
	    return (
	        postPage.React.createElement('label', { className: "flex flex-col gap-1"  ,}
	            , postPage.React.createElement('span', { className: "font-bold",}, label)
	            , children
	            , smallLabel ? postPage.React.createElement('span', { className: "text-sm",}, smallLabel) : null
	        )
	    );
	};













	const ArtistAlleyCreatePage = () => {
	    postPage.useRequiresLogin();

	    const createListingMutation = postPage.trpc.artistAlley.createListing.useMutation();

	    const {
	        control,
	        register,
	        handleSubmit,
	        trigger,
	        watch,
	        setValue,
	        setError,
	        formState,
	        clearErrors,
	        getValues,
	    } = postPage.useForm({
	        defaultValues: {
	            adult: false,
	            body: "",
	            ctaLink: "",
	            ctaText: "",
	            attachmentFiles: undefined,
	            attachmentAltText: "",
	            categories: [],
	            notes: "",
	            numWeeks: "1",
	        },
	    });

	    const [allCategories] = postPage.trpc.artistAlley.getCategories.useSuspenseQuery();

	    const bodyLength = watch("body").length;

	    const onSubmit = postPage.reactExports.useCallback(
	        async (data) => {
	            let attachment = undefined;

	            if (data.attachmentFiles && data.attachmentFiles[0]) {
	                console.log(data.attachmentFiles);
	                const file = data.attachmentFiles[0];
	                attachment = {
	                    filename: file.name,
	                    contentLength: file.size,
	                    contentType: file.type,
	                    altText: data.attachmentAltText ?? "",
	                };
	            }

	            const initialResult = await createListingMutation.mutateAsync({
	                body: data.body,
	                adult: data.adult,
	                cta: {
	                    text: data.ctaText,
	                    link: data.ctaLink,
	                },
	                categories: data.categories,
	                numWeeks: parseInt(data.numWeeks),
	                attachment,
	                notes: data.notes,
	            });

	            if (initialResult.attachmentDetails && data.attachmentFiles) {
	                const file = data.attachmentFiles[0];
	                const formData = new FormData();
	                for (const name in initialResult.attachmentDetails
	                    .requiredFields) {
	                    formData.append(
	                        name,
	                        initialResult.attachmentDetails.requiredFields[name]
	                    );
	                }
	                formData.append("file", file);
	                formData.append("Content-Type", file.type);
	                await postPage.axios.post(
	                    initialResult.attachmentDetails.url,
	                    formData,
	                    {
	                        withCredentials: false,
	                    }
	                );
	            }

	            window.location.href = initialResult.stripeRedirectUrl;
	        },
	        [createListingMutation]
	    );

	    const previewAttachment = watch("attachmentFiles")?.[0];

	    const currentProject = postPage.useCurrentProject();
	    const objectURL = previewAttachment
	        ? URL.createObjectURL(previewAttachment)
	        : "";

	    const previewListing = {
	        adultContent: watch("adult", false),
	        attachment: previewAttachment
	            ? {
	                  altText: watch("attachmentAltText") ?? "",
	                  fileURL: objectURL,
	                  previewURL: objectURL,
	              }
	            : null,
	        body: watch("body"),
	        categories: watch("categories"),
	        createdAt: new Date().toISOString(),
	        cta: {
	            link: watch("ctaLink"),
	            text: watch("ctaText"),
	        },
	        expiresAt: new Date().toISOString(),
	        projectId: currentProject.projectId,
	        id: postPage.ArtistAlleyAdId.parse("1"),
	    };

	    const theme = postPage.useDynamicTheme();

	    const siteConfig = postPage.useSiteConfig();
	    const hasCohostPlus = postPage.useHasCohostPlus();
	    const maxSize = hasCohostPlus
	        ? siteConfig.limits.attachmentSize.cohostPlus
	        : siteConfig.limits.attachmentSize.normal;

	    const validateAttachment = postPage.reactExports.useCallback(
	        (fileList) => {
	            if (fileList === undefined) {
	                return true;
	            }

	            console.log(fileList);

	            if (!fileList.length) {
	                return true;
	            } else if (fileList.length > 1) {
	                return `You can only choose one image!`;
	            } else if (fileList[0].size > maxSize) {
	                return `image must be less than ${Math.round(
                    maxSize / 1024 / 1024
                )}mb!`;
	            }

	            const contentTypeValidationResult = postPage.isValidAttachmentContentType(
	                siteConfig,
	                fileList[0].type
	            );
	            if (
	                !contentTypeValidationResult.valid ||
	                contentTypeValidationResult.kind !== "image"
	            ) {
	                return `must be an image!`;
	            }

	            return true;
	        },
	        [maxSize, siteConfig]
	    );

	    const handleFileDrop = postPage.reactExports.useCallback(
	        (files) => {
	            const validationResult = validateAttachment(files);

	            if (validationResult !== true) {
	                setError("attachmentFiles", {
	                    message: validationResult,
	                    type: "custom",
	                });
	                return;
	            }

	            clearErrors("attachmentFiles");
	            setValue("attachmentFiles", files);
	        },
	        [clearErrors, setError, setValue, validateAttachment]
	    );

	    return (
	        postPage.React.createElement('div', { className: "container mx-auto mt-12 grid grid-cols-1 gap-16 lg:grid-cols-4"      ,}
	            , postPage.React.createElement(postPage.Helmet, { title: "create a listing - artist alley"     ,} )
	            , postPage.React.createElement(postPage.SidebarMenu, null )
	            , postPage.React.createElement(postPage.LazyDnD, null
	                , postPage.React.createElement(postPage.DropZone, {
	                    handleFileDrop: handleFileDrop,
	                    className: "col-span-1 lg:col-span-2" ,}

	                    , postPage.React.createElement('div', {
	                        className: "co-themed-box co-settings flex flex-col gap-3 rounded-lg p-3"      ,
	                        'data-theme': theme.current,}

	                        , postPage.React.createElement('h1', { className: "co-settings-header",}, "create a listing"  )

	                        , postPage.React.createElement(postPage.InfoBox, { level: "post-box-info",}
	                            , postPage.React.createElement('div', { className: "co-prose prose prose-sm"  ,}
	                                , postPage.React.createElement('p', null, "artist alley listings are subject to the"
	                                          , " "
	                                    , postPage.React.createElement('a', {
	                                        href: postPage.sitemap.public
	                                            .staticContent({
	                                                slug: "community-guidelines",
	                                            })
	                                            .toString(),}
	, "standard cohost community guidelines"

	                                    ), ", as well as"
	                                       , " "
	                                    , postPage.React.createElement('a', { href: "https://help.antisoftware.club/support/solutions/articles/62000231419-artist-alley-community-guidelines",}, "an additional set specific to listings"

	                                    ), "."

	                                )
	                            )
	                        )

	                        , postPage.React.createElement('form', {
	                            onSubmit: handleSubmit(onSubmit),
	                            className: "flex flex-col gap-3"  ,}

	                            , postPage.React.createElement(InputRow, {
	                                label: "listing image" ,
	                                smallLabel: 
	                                    postPage.React.createElement(postPage.React.Fragment, null, "not required, but definitely recommended. this will be displayed at a resolution of 300x250. for best results on high-density screens, we recommend your image be at least 600x500."





	                                    )
	                                ,}

	                                , postPage.React.createElement(postPage.Controller, {
	                                    control: control,
	                                    name: "attachmentFiles",
	                                    render: ({ field, fieldState }) => (
	                                        postPage.React.createElement(postPage.FilePicker, {
	                                            onFilesPicked: (fileList) => {
	                                                const validationResult =
	                                                    validateAttachment(
	                                                        Array.from(fileList)
	                                                    );

	                                                if (validationResult !== true) {
	                                                    setError(
	                                                        "attachmentFiles",
	                                                        {
	                                                            message:
	                                                                validationResult,
	                                                            type: "custom",
	                                                        }
	                                                    );
	                                                    return;
	                                                }

	                                                clearErrors("attachmentFiles");
	                                                field.onChange(fileList);
	                                            },}

	                                            , postPage.React.createElement('button', {
	                                                type: "button",
	                                                className: "co-filled-button flex w-max flex-row items-center gap-1 rounded-lg px-3 py-2.5"        ,}

	                                                , postPage.React.createElement(postPage.ForwardRef$4, { className: "inline-block h-5 w-5"  ,} )
	                                                , previewAttachment
	                                                    ? "replace image"
	                                                    : "choose image"
	                                            )
	                                        )
	                                    ),}
	                                )
	                                , previewAttachment ? (
	                                    postPage.React.createElement('button', {
	                                        type: "button",
	                                        className: "underline",
	                                        onClick: (e) => {
	                                            setValue(
	                                                "attachmentFiles",
	                                                undefined
	                                            );
	                                            setValue(
	                                                "attachmentAltText",
	                                                undefined
	                                            );
	                                            clearErrors([
	                                                "attachmentFiles",
	                                                "attachmentAltText",
	                                            ]);
	                                            e.preventDefault();
	                                        },}
	, "remove image"

	                                    )
	                                ) : null
	                                , formState.errors.attachmentFiles && (
	                                    postPage.React.createElement('span', { className: "text-red",}
	                                        , 
	                                            // genuinely unsure why the typing is convinced this is an array
	                                            (
	                                                formState.errors
	                                                    .attachmentFiles 


	                                            )?.message
	                                        
	                                    )
	                                )
	                            )
	                            , previewAttachment ? (
	                                postPage.React.createElement(InputRow, {
	                                    label: "alt text" ,
	                                    smallLabel: "required if you're uploading an image"     ,}

	                                    , postPage.React.createElement(styledInput.StyledInput, {
	                                        control: control,
	                                        name: "attachmentAltText",
	                                        trigger: trigger,
	                                        type: "text",
	                                        style: "dynamic",
	                                        placeholder: "it's a picture of eggbug"    ,
	                                        rules: {
	                                            validate: {
	                                                required: (value) => {
	                                                    if (
	                                                        !value &&
	                                                        getValues(
	                                                            "attachmentFiles"
	                                                        )?.length
	                                                    ) {
	                                                        return "alt text is required";
	                                                    }
	                                                    return true;
	                                                },
	                                            },
	                                        },}
	                                    )
	                                    , formState.errors.attachmentAltText && (
	                                        postPage.React.createElement('span', { className: "text-red",}
	                                            , 
	                                                formState.errors
	                                                    .attachmentAltText?.message
	                                            
	                                        )
	                                    )
	                                )
	                            ) : null

	                            , postPage.React.createElement('hr', null )

	                            , postPage.React.createElement(InputRow, { label: "body",}
	                                , postPage.React.createElement('div', { className: "flex flex-row items-start"  ,}
	                                    , postPage.React.createElement(postPage.ControllableExpandingTextArea, {
	                                        control: control,
	                                        name: "body",
	                                        minRows: 4,
	                                        autoComplete: "off",
	                                        placeholder: "body goes here"  ,
	                                        className: "co-styled-input rounded-lg border-2"  ,
	                                        rules: {
	                                            maxLength: {
	                                                message: `must be under ${BODY_LIMIT} characters`,
	                                                value: BODY_LIMIT,
	                                            },
	                                            required: {
	                                                message: "required",
	                                                value: true,
	                                            },
	                                        },}
	                                    )
	                                    , bodyLength >= BODY_LIMIT * 0.75 ? (
	                                        postPage.React.createElement('span', {
	                                            className: `flex-shrink-0 p-2 tabular-nums ${
                                                bodyLength > BODY_LIMIT
                                                    ? "text-red"
                                                    : "text-gray-600"
                                            }`,}

	                                            , BODY_LIMIT - bodyLength
	                                        )
	                                    ) : null
	                                )
	                                , formState.errors.body && (
	                                    postPage.React.createElement('span', { className: "text-red",}
	                                        , formState.errors.body?.message
	                                    )
	                                )
	                                , postPage.React.createElement(postPage.InfoBox, { level: "post-box-info",}, "supports most markdown! does not support HTML, headers, or images. max 280 characters."



	                                )
	                            )

	                            , postPage.React.createElement('hr', null )

	                            , postPage.React.createElement(InputRow, {
	                                label: "button text" ,
	                                smallLabel: "35 characters max"  ,}

	                                , postPage.React.createElement(styledInput.StyledInput, {
	                                    control: control,
	                                    name: "ctaText",
	                                    trigger: trigger,
	                                    type: "text",
	                                    style: "dynamic",
	                                    placeholder: "it's eggbug" ,
	                                    rules: {
	                                        minLength: 1,
	                                        maxLength: {
	                                            message:
	                                                "must be under 35 characters",
	                                            value: 35,
	                                        },
	                                        required: {
	                                            message: "required",
	                                            value: true,
	                                        },
	                                    },}
	                                )
	                                , formState.errors.ctaText && (
	                                    postPage.React.createElement('span', { className: "text-red",}
	                                        , formState.errors.ctaText.message
	                                    )
	                                )
	                            )
	                            , postPage.React.createElement(InputRow, {
	                                label: "button link" ,
	                                smallLabel: "it's gotta be a URL"    ,}

	                                , postPage.React.createElement(styledInput.StyledInput, {
	                                    control: control,
	                                    name: "ctaLink",
	                                    trigger: trigger,
	                                    type: "text",
	                                    style: "dynamic",
	                                    placeholder: "https://cohost.org/eggbug",
	                                    rules: {
	                                        required: {
	                                            message: "required",
	                                            value: true,
	                                        },
	                                        validate: (value) => {
	                                            try {
	                                                const parseResult = postPage.mod
	                                                    .string()
	                                                    .url()
	                                                    .safeParse(value);

	                                                if (!parseResult.success) {
	                                                    return "invalid URL";
	                                                }

	                                                const result = postPage.validateUrl(
	                                                    normalizeUrl$1(
	                                                        parseResult.data,
	                                                        {
	                                                            stripAuthentication:
	                                                                true,
	                                                            // not removing query parameters here so people can set their own
	                                                            // UTM/etc. params
	                                                            stripWWW: false,
	                                                        }
	                                                    )
	                                                );

	                                                if (!result.valid) {
	                                                    return "invalid URL";
	                                                }

	                                                return true;
	                                            } catch (e) {
	                                                return "invalid URL";
	                                            }
	                                        },
	                                    },}
	                                )
	                                , formState.errors.ctaLink && (
	                                    postPage.React.createElement('span', { className: "text-red",}
	                                        , formState.errors.ctaLink.message
	                                    )
	                                )
	                            )

	                            , postPage.React.createElement('hr', null )

	                            , postPage.React.createElement(InputRow, { label: "listing categories" ,}
	                                , postPage.React.createElement(postPage.InfoBox, { level: "post-box-info",}, "these are the categories you ad will appear in. choose however many you want, but you need at least one."



	                                )
	                                , postPage.React.createElement(TokenMultiSelect, {
	                                    control: control,
	                                    name: "categories",
	                                    options: allCategories,
	                                    rules: {
	                                        validate: (value) => {
	                                            value = value ;

	                                            if (value.length === 0) {
	                                                return "you need at least one category";
	                                            }
	                                        },
	                                    },}
	                                )
	                                , formState.errors.categories && (
	                                    postPage.React.createElement('span', { className: "text-red",}
	                                        , 
	                                            (
	                                                formState.errors
	                                                    .categories 
	                                            ).message
	                                        
	                                    )
	                                )
	                            )

	                            , postPage.React.createElement('hr', null )

	                            , postPage.React.createElement('label', { className: "flex flex-row items-center justify-between"   ,}
	                                , postPage.React.createElement('span', { className: "font-bold",}, "this listing contains 18+ content"

	                                )
	                                , postPage.React.createElement('input', {
	                                    type: "checkbox",
	                                    ...register("adult"),
	                                    className: "rounded-checkbox",}
	                                )
	                            )

	                            , postPage.React.createElement('hr', null )

	                            , postPage.React.createElement('label', { className: "flex flex-row items-center justify-between"   ,}
	                                , postPage.React.createElement('div', { className: "flex flex-col gap-2"  ,}
	                                    , postPage.React.createElement('span', { className: "font-bold",}, "how many weeks should this listing run?"

	                                    )
	                                    , postPage.React.createElement('span', { className: "text-sm",}, "listings are $10/week"

	                                    )
	                                )
	                                , postPage.React.createElement(styledInput.StyledInput, {
	                                    type: "number",
	                                    style: "dynamic",
	                                    control: control,
	                                    trigger: trigger,
	                                    rules: {
	                                        min: 1,
	                                        max: 4,
	                                        required: true,
	                                    },
	                                    name: "numWeeks",
	                                    min: 1,
	                                    max: 4,
	                                    step: 1,}
	                                )
	                            )

	                            , postPage.React.createElement('hr', null )

	                            , postPage.React.createElement(InputRow, { label: "anything else to tell us?"    ,}
	                                , postPage.React.createElement(postPage.InfoBox, { level: "post-box-info",}
	                                    , postPage.React.createElement('div', { className: "co-prose prose prose-sm"  ,}
	                                        , postPage.React.createElement('p', null, "you can put any notes you want us to see here. these won't be publicly visible, but can be helpful for us during review."




	                                        )
	                                        , postPage.React.createElement('p', null, "we would especially appreciate any categories you think this listing fits in to that we don't already have! if we decide to add them, we'll apply them to your listing automatically."






	                                        )
	                                    )
	                                )
	                                , postPage.React.createElement(postPage.ControllableExpandingTextArea, {
	                                    minRows: 3,
	                                    control: control,
	                                    name: "notes",
	                                    autoComplete: "off",
	                                    placeholder: "thank you for inventing eggbug"    ,
	                                    className: "co-styled-input rounded-lg border-2"  ,}
	                                )
	                            )
	                            , postPage.React.createElement('button', {
	                                className: "co-filled-button w-max self-end rounded-lg px-3 py-2.5 font-bold"      ,
	                                type: "submit",
	                                disabled: formState.isSubmitting,}
	, "continue to payment"

	                            )
	                        )
	                        , null
	                    )
	                )
	            )
	            , postPage.React.createElement('div', null
	                , postPage.React.createElement('div', {
	                    className: "co-settings co-themed-box flex flex-col gap-4 rounded-lg p-3"      ,
	                    'data-theme': theme.current,}

	                    , postPage.React.createElement('h2', { className: "co-settings-header",}, "preview")
	                    , postPage.React.createElement(postPage.InfoBox, { level: "post-box-info",}, "this is what your listing will look like to others!"

	                    )
	                    , postPage.React.createElement('div', { className: "mx-auto w-full max-w-[300px]"  ,}
	                        , postPage.React.createElement(artistAlleyListing.ArtistAlleyListing, {
	                            listing: previewListing,
	                            project: currentProject,}
	                        )
	                    )
	                )
	            )
	        )
	    );
	};

	exports.ArtistAlleyCreatePage = ArtistAlleyCreatePage;
	exports.default = ArtistAlleyCreatePage;

}));