2399 lines
84 KiB
JavaScript
2399 lines
84 KiB
JavaScript
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;
|
|
|
|
}));
|