You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
683 lines
20 KiB
683 lines
20 KiB
'use strict';
|
|
|
|
const n = /[^\0-\x7E]/;
|
|
const t = /[\x2E\u3002\uFF0E\uFF61]/g;
|
|
const o = {
|
|
overflow: "Overflow Error",
|
|
"not-basic": "Illegal Input",
|
|
"invalid-input": "Invalid Input"
|
|
};
|
|
const e = Math.floor;
|
|
const r = String.fromCharCode;
|
|
function s(n2) {
|
|
throw new RangeError(o[n2]);
|
|
}
|
|
const c = function(n2, t2) {
|
|
return n2 + 22 + 75 * (n2 < 26) - ((t2 != 0) << 5);
|
|
};
|
|
const u = function(n2, t2, o2) {
|
|
let r2 = 0;
|
|
for (n2 = o2 ? e(n2 / 700) : n2 >> 1, n2 += e(n2 / t2); n2 > 455; r2 += 36) {
|
|
n2 = e(n2 / 35);
|
|
}
|
|
return e(r2 + 36 * n2 / (n2 + 38));
|
|
};
|
|
function toASCII(o2) {
|
|
return function(n2, o3) {
|
|
const e2 = n2.split("@");
|
|
let r2 = "";
|
|
e2.length > 1 && (r2 = e2[0] + "@", n2 = e2[1]);
|
|
const s2 = function(n3, t2) {
|
|
const o4 = [];
|
|
let e3 = n3.length;
|
|
for (; e3--; ) {
|
|
o4[e3] = t2(n3[e3]);
|
|
}
|
|
return o4;
|
|
}((n2 = n2.replace(t, ".")).split("."), o3).join(".");
|
|
return r2 + s2;
|
|
}(o2, function(t2) {
|
|
return n.test(t2) ? "xn--" + function(n2) {
|
|
const t3 = [];
|
|
const o3 = (n2 = function(n3) {
|
|
const t4 = [];
|
|
let o4 = 0;
|
|
const e2 = n3.length;
|
|
for (; o4 < e2; ) {
|
|
const r2 = n3.charCodeAt(o4++);
|
|
if (r2 >= 55296 && r2 <= 56319 && o4 < e2) {
|
|
const e3 = n3.charCodeAt(o4++);
|
|
(64512 & e3) == 56320 ? t4.push(((1023 & r2) << 10) + (1023 & e3) + 65536) : (t4.push(r2), o4--);
|
|
} else {
|
|
t4.push(r2);
|
|
}
|
|
}
|
|
return t4;
|
|
}(n2)).length;
|
|
let f = 128;
|
|
let i = 0;
|
|
let l = 72;
|
|
for (const o4 of n2) {
|
|
o4 < 128 && t3.push(r(o4));
|
|
}
|
|
const h = t3.length;
|
|
let p = h;
|
|
for (h && t3.push("-"); p < o3; ) {
|
|
let o4 = 2147483647;
|
|
for (const t4 of n2) {
|
|
t4 >= f && t4 < o4 && (o4 = t4);
|
|
}
|
|
const a = p + 1;
|
|
o4 - f > e((2147483647 - i) / a) && s("overflow"), i += (o4 - f) * a, f = o4;
|
|
for (const o5 of n2) {
|
|
if (o5 < f && ++i > 2147483647 && s("overflow"), o5 == f) {
|
|
let n3 = i;
|
|
for (let o6 = 36; ; o6 += 36) {
|
|
const s2 = o6 <= l ? 1 : o6 >= l + 26 ? 26 : o6 - l;
|
|
if (n3 < s2) {
|
|
break;
|
|
}
|
|
const u2 = n3 - s2;
|
|
const f2 = 36 - s2;
|
|
t3.push(r(c(s2 + u2 % f2, 0))), n3 = e(u2 / f2);
|
|
}
|
|
t3.push(r(c(n3, 0))), l = u(i, a, p == h), i = 0, ++p;
|
|
}
|
|
}
|
|
++i, ++f;
|
|
}
|
|
return t3.join("");
|
|
}(t2) : t2;
|
|
});
|
|
}
|
|
|
|
const HASH_RE = /#/g;
|
|
const AMPERSAND_RE = /&/g;
|
|
const SLASH_RE = /\//g;
|
|
const EQUAL_RE = /=/g;
|
|
const IM_RE = /\?/g;
|
|
const PLUS_RE = /\+/g;
|
|
const ENC_CARET_RE = /%5e/gi;
|
|
const ENC_BACKTICK_RE = /%60/gi;
|
|
const ENC_CURLY_OPEN_RE = /%7b/gi;
|
|
const ENC_PIPE_RE = /%7c/gi;
|
|
const ENC_CURLY_CLOSE_RE = /%7d/gi;
|
|
const ENC_SPACE_RE = /%20/gi;
|
|
const ENC_SLASH_RE = /%2f/gi;
|
|
const ENC_ENC_SLASH_RE = /%252f/gi;
|
|
function encode(text) {
|
|
return encodeURI("" + text).replace(ENC_PIPE_RE, "|");
|
|
}
|
|
function encodeHash(text) {
|
|
return encode(text).replace(ENC_CURLY_OPEN_RE, "{").replace(ENC_CURLY_CLOSE_RE, "}").replace(ENC_CARET_RE, "^");
|
|
}
|
|
function encodeQueryValue(input) {
|
|
return encode(typeof input === "string" ? input : JSON.stringify(input)).replace(PLUS_RE, "%2B").replace(ENC_SPACE_RE, "+").replace(HASH_RE, "%23").replace(AMPERSAND_RE, "%26").replace(ENC_BACKTICK_RE, "`").replace(ENC_CARET_RE, "^").replace(SLASH_RE, "%2F");
|
|
}
|
|
function encodeQueryKey(text) {
|
|
return encodeQueryValue(text).replace(EQUAL_RE, "%3D");
|
|
}
|
|
function encodePath(text) {
|
|
return encode(text).replace(HASH_RE, "%23").replace(IM_RE, "%3F").replace(ENC_ENC_SLASH_RE, "%2F").replace(AMPERSAND_RE, "%26").replace(PLUS_RE, "%2B");
|
|
}
|
|
function encodeParam(text) {
|
|
return encodePath(text).replace(SLASH_RE, "%2F");
|
|
}
|
|
function decode(text = "") {
|
|
try {
|
|
return decodeURIComponent("" + text);
|
|
} catch {
|
|
return "" + text;
|
|
}
|
|
}
|
|
function decodePath(text) {
|
|
return decode(text.replace(ENC_SLASH_RE, "%252F"));
|
|
}
|
|
function decodeQueryKey(text) {
|
|
return decode(text.replace(PLUS_RE, " "));
|
|
}
|
|
function decodeQueryValue(text) {
|
|
return decode(text.replace(PLUS_RE, " "));
|
|
}
|
|
function encodeHost(name = "") {
|
|
return toASCII(name);
|
|
}
|
|
|
|
function parseQuery(parametersString = "") {
|
|
const object = {};
|
|
if (parametersString[0] === "?") {
|
|
parametersString = parametersString.slice(1);
|
|
}
|
|
for (const parameter of parametersString.split("&")) {
|
|
const s = parameter.match(/([^=]+)=?(.*)/) || [];
|
|
if (s.length < 2) {
|
|
continue;
|
|
}
|
|
const key = decodeQueryKey(s[1]);
|
|
if (key === "__proto__" || key === "constructor") {
|
|
continue;
|
|
}
|
|
const value = decodeQueryValue(s[2] || "");
|
|
if (object[key] === void 0) {
|
|
object[key] = value;
|
|
} else if (Array.isArray(object[key])) {
|
|
object[key].push(value);
|
|
} else {
|
|
object[key] = [object[key], value];
|
|
}
|
|
}
|
|
return object;
|
|
}
|
|
function encodeQueryItem(key, value) {
|
|
if (typeof value === "number" || typeof value === "boolean") {
|
|
value = String(value);
|
|
}
|
|
if (!value) {
|
|
return encodeQueryKey(key);
|
|
}
|
|
if (Array.isArray(value)) {
|
|
return value.map((_value) => `${encodeQueryKey(key)}=${encodeQueryValue(_value)}`).join("&");
|
|
}
|
|
return `${encodeQueryKey(key)}=${encodeQueryValue(value)}`;
|
|
}
|
|
function stringifyQuery(query) {
|
|
return Object.keys(query).filter((k) => query[k] !== void 0).map((k) => encodeQueryItem(k, query[k])).filter(Boolean).join("&");
|
|
}
|
|
|
|
const PROTOCOL_STRICT_REGEX = /^[\s\w\0+.-]{2,}:([/\\]{1,2})/;
|
|
const PROTOCOL_REGEX = /^[\s\w\0+.-]{2,}:([/\\]{2})?/;
|
|
const PROTOCOL_RELATIVE_REGEX = /^([/\\]\s*){2,}[^/\\]/;
|
|
const PROTOCOL_SCRIPT_RE = /^[\s\0]*(blob|data|javascript|vbscript):$/i;
|
|
const TRAILING_SLASH_RE = /\/$|\/\?|\/#/;
|
|
const JOIN_LEADING_SLASH_RE = /^\.?\//;
|
|
function isRelative(inputString) {
|
|
return ["./", "../"].some((string_) => inputString.startsWith(string_));
|
|
}
|
|
function hasProtocol(inputString, opts = {}) {
|
|
if (typeof opts === "boolean") {
|
|
opts = { acceptRelative: opts };
|
|
}
|
|
if (opts.strict) {
|
|
return PROTOCOL_STRICT_REGEX.test(inputString);
|
|
}
|
|
return PROTOCOL_REGEX.test(inputString) || (opts.acceptRelative ? PROTOCOL_RELATIVE_REGEX.test(inputString) : false);
|
|
}
|
|
function isScriptProtocol(protocol) {
|
|
return !!protocol && PROTOCOL_SCRIPT_RE.test(protocol);
|
|
}
|
|
function hasTrailingSlash(input = "", respectQueryAndFragment) {
|
|
if (!respectQueryAndFragment) {
|
|
return input.endsWith("/");
|
|
}
|
|
return TRAILING_SLASH_RE.test(input);
|
|
}
|
|
function withoutTrailingSlash(input = "", respectQueryAndFragment) {
|
|
if (!respectQueryAndFragment) {
|
|
return (hasTrailingSlash(input) ? input.slice(0, -1) : input) || "/";
|
|
}
|
|
if (!hasTrailingSlash(input, true)) {
|
|
return input || "/";
|
|
}
|
|
let path = input;
|
|
let fragment = "";
|
|
const fragmentIndex = input.indexOf("#");
|
|
if (fragmentIndex >= 0) {
|
|
path = input.slice(0, fragmentIndex);
|
|
fragment = input.slice(fragmentIndex);
|
|
}
|
|
const [s0, ...s] = path.split("?");
|
|
const cleanPath = s0.endsWith("/") ? s0.slice(0, -1) : s0;
|
|
return (cleanPath || "/") + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
|
|
}
|
|
function withTrailingSlash(input = "", respectQueryAndFragment) {
|
|
if (!respectQueryAndFragment) {
|
|
return input.endsWith("/") ? input : input + "/";
|
|
}
|
|
if (hasTrailingSlash(input, true)) {
|
|
return input || "/";
|
|
}
|
|
let path = input;
|
|
let fragment = "";
|
|
const fragmentIndex = input.indexOf("#");
|
|
if (fragmentIndex >= 0) {
|
|
path = input.slice(0, fragmentIndex);
|
|
fragment = input.slice(fragmentIndex);
|
|
if (!path) {
|
|
return fragment;
|
|
}
|
|
}
|
|
const [s0, ...s] = path.split("?");
|
|
return s0 + "/" + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
|
|
}
|
|
function hasLeadingSlash(input = "") {
|
|
return input.startsWith("/");
|
|
}
|
|
function withoutLeadingSlash(input = "") {
|
|
return (hasLeadingSlash(input) ? input.slice(1) : input) || "/";
|
|
}
|
|
function withLeadingSlash(input = "") {
|
|
return hasLeadingSlash(input) ? input : "/" + input;
|
|
}
|
|
function cleanDoubleSlashes(input = "") {
|
|
return input.split("://").map((string_) => string_.replace(/\/{2,}/g, "/")).join("://");
|
|
}
|
|
function withBase(input, base) {
|
|
if (isEmptyURL(base) || hasProtocol(input)) {
|
|
return input;
|
|
}
|
|
const _base = withoutTrailingSlash(base);
|
|
if (input.startsWith(_base)) {
|
|
return input;
|
|
}
|
|
return joinURL(_base, input);
|
|
}
|
|
function withoutBase(input, base) {
|
|
if (isEmptyURL(base)) {
|
|
return input;
|
|
}
|
|
const _base = withoutTrailingSlash(base);
|
|
if (!input.startsWith(_base)) {
|
|
return input;
|
|
}
|
|
const trimmed = input.slice(_base.length);
|
|
return trimmed[0] === "/" ? trimmed : "/" + trimmed;
|
|
}
|
|
function withQuery(input, query) {
|
|
const parsed = parseURL(input);
|
|
const mergedQuery = { ...parseQuery(parsed.search), ...query };
|
|
parsed.search = stringifyQuery(mergedQuery);
|
|
return stringifyParsedURL(parsed);
|
|
}
|
|
function getQuery(input) {
|
|
return parseQuery(parseURL(input).search);
|
|
}
|
|
function isEmptyURL(url) {
|
|
return !url || url === "/";
|
|
}
|
|
function isNonEmptyURL(url) {
|
|
return url && url !== "/";
|
|
}
|
|
function joinURL(base, ...input) {
|
|
let url = base || "";
|
|
for (const segment of input.filter((url2) => isNonEmptyURL(url2))) {
|
|
if (url) {
|
|
const _segment = segment.replace(JOIN_LEADING_SLASH_RE, "");
|
|
url = withTrailingSlash(url) + _segment;
|
|
} else {
|
|
url = segment;
|
|
}
|
|
}
|
|
return url;
|
|
}
|
|
function joinRelativeURL(..._input) {
|
|
const JOIN_SEGMENT_SPLIT_RE = /\/(?!\/)/;
|
|
const input = _input.filter(Boolean);
|
|
const segments = [];
|
|
let segmentsDepth = 0;
|
|
for (const i of input) {
|
|
if (!i || i === "/") {
|
|
continue;
|
|
}
|
|
for (const [sindex, s] of i.split(JOIN_SEGMENT_SPLIT_RE).entries()) {
|
|
if (!s || s === ".") {
|
|
continue;
|
|
}
|
|
if (s === "..") {
|
|
if (segments.length === 1 && hasProtocol(segments[0])) {
|
|
continue;
|
|
}
|
|
segments.pop();
|
|
segmentsDepth--;
|
|
continue;
|
|
}
|
|
if (sindex === 1 && segments[segments.length - 1]?.endsWith(":/")) {
|
|
segments[segments.length - 1] += "/" + s;
|
|
continue;
|
|
}
|
|
segments.push(s);
|
|
segmentsDepth++;
|
|
}
|
|
}
|
|
let url = segments.join("/");
|
|
if (segmentsDepth >= 0) {
|
|
if (input[0]?.startsWith("/") && !url.startsWith("/")) {
|
|
url = "/" + url;
|
|
} else if (input[0]?.startsWith("./") && !url.startsWith("./")) {
|
|
url = "./" + url;
|
|
}
|
|
} else {
|
|
url = "../".repeat(-1 * segmentsDepth) + url;
|
|
}
|
|
if (input[input.length - 1]?.endsWith("/") && !url.endsWith("/")) {
|
|
url += "/";
|
|
}
|
|
return url;
|
|
}
|
|
function withHttp(input) {
|
|
return withProtocol(input, "http://");
|
|
}
|
|
function withHttps(input) {
|
|
return withProtocol(input, "https://");
|
|
}
|
|
function withoutProtocol(input) {
|
|
return withProtocol(input, "");
|
|
}
|
|
function withProtocol(input, protocol) {
|
|
let match = input.match(PROTOCOL_REGEX);
|
|
if (!match) {
|
|
match = input.match(/^\/{2,}/);
|
|
}
|
|
if (!match) {
|
|
return protocol + input;
|
|
}
|
|
return protocol + input.slice(match[0].length);
|
|
}
|
|
function normalizeURL(input) {
|
|
const parsed = parseURL(input);
|
|
parsed.pathname = encodePath(decodePath(parsed.pathname));
|
|
parsed.hash = encodeHash(decode(parsed.hash));
|
|
parsed.host = encodeHost(decode(parsed.host));
|
|
parsed.search = stringifyQuery(parseQuery(parsed.search));
|
|
return stringifyParsedURL(parsed);
|
|
}
|
|
function resolveURL(base = "", ...inputs) {
|
|
if (typeof base !== "string") {
|
|
throw new TypeError(
|
|
`URL input should be string received ${typeof base} (${base})`
|
|
);
|
|
}
|
|
const filteredInputs = inputs.filter((input) => isNonEmptyURL(input));
|
|
if (filteredInputs.length === 0) {
|
|
return base;
|
|
}
|
|
const url = parseURL(base);
|
|
for (const inputSegment of filteredInputs) {
|
|
const urlSegment = parseURL(inputSegment);
|
|
if (urlSegment.pathname) {
|
|
url.pathname = withTrailingSlash(url.pathname) + withoutLeadingSlash(urlSegment.pathname);
|
|
}
|
|
if (urlSegment.hash && urlSegment.hash !== "#") {
|
|
url.hash = urlSegment.hash;
|
|
}
|
|
if (urlSegment.search && urlSegment.search !== "?") {
|
|
if (url.search && url.search !== "?") {
|
|
const queryString = stringifyQuery({
|
|
...parseQuery(url.search),
|
|
...parseQuery(urlSegment.search)
|
|
});
|
|
url.search = queryString.length > 0 ? "?" + queryString : "";
|
|
} else {
|
|
url.search = urlSegment.search;
|
|
}
|
|
}
|
|
}
|
|
return stringifyParsedURL(url);
|
|
}
|
|
function isSamePath(p1, p2) {
|
|
return decode(withoutTrailingSlash(p1)) === decode(withoutTrailingSlash(p2));
|
|
}
|
|
function isEqual(a, b, options = {}) {
|
|
if (!options.trailingSlash) {
|
|
a = withTrailingSlash(a);
|
|
b = withTrailingSlash(b);
|
|
}
|
|
if (!options.leadingSlash) {
|
|
a = withLeadingSlash(a);
|
|
b = withLeadingSlash(b);
|
|
}
|
|
if (!options.encoding) {
|
|
a = decode(a);
|
|
b = decode(b);
|
|
}
|
|
return a === b;
|
|
}
|
|
function withFragment(input, hash) {
|
|
if (!hash || hash === "#") {
|
|
return input;
|
|
}
|
|
const parsed = parseURL(input);
|
|
parsed.hash = hash === "" ? "" : "#" + encodeHash(hash);
|
|
return stringifyParsedURL(parsed);
|
|
}
|
|
function withoutFragment(input) {
|
|
return stringifyParsedURL({ ...parseURL(input), hash: "" });
|
|
}
|
|
function withoutHost(input) {
|
|
const parsed = parseURL(input);
|
|
return (parsed.pathname || "/") + parsed.search + parsed.hash;
|
|
}
|
|
|
|
const protocolRelative = Symbol.for("ufo:protocolRelative");
|
|
function parseURL(input = "", defaultProto) {
|
|
const _specialProtoMatch = input.match(
|
|
/^[\s\0]*(blob:|data:|javascript:|vbscript:)(.*)/i
|
|
);
|
|
if (_specialProtoMatch) {
|
|
const [, _proto, _pathname = ""] = _specialProtoMatch;
|
|
return {
|
|
protocol: _proto.toLowerCase(),
|
|
pathname: _pathname,
|
|
href: _proto + _pathname,
|
|
auth: "",
|
|
host: "",
|
|
search: "",
|
|
hash: ""
|
|
};
|
|
}
|
|
if (!hasProtocol(input, { acceptRelative: true })) {
|
|
return defaultProto ? parseURL(defaultProto + input) : parsePath(input);
|
|
}
|
|
const [, protocol = "", auth, hostAndPath = ""] = input.replace(/\\/g, "/").match(/^[\s\0]*([\w+.-]{2,}:)?\/\/([^/@]+@)?(.*)/) || [];
|
|
let [, host = "", path = ""] = hostAndPath.match(/([^#/?]*)(.*)?/) || [];
|
|
if (protocol === "file:") {
|
|
path = path.replace(/\/(?=[A-Za-z]:)/, "");
|
|
}
|
|
const { pathname, search, hash } = parsePath(path);
|
|
return {
|
|
protocol: protocol.toLowerCase(),
|
|
auth: auth ? auth.slice(0, Math.max(0, auth.length - 1)) : "",
|
|
host,
|
|
pathname,
|
|
search,
|
|
hash,
|
|
[protocolRelative]: !protocol
|
|
};
|
|
}
|
|
function parsePath(input = "") {
|
|
const [pathname = "", search = "", hash = ""] = (input.match(/([^#?]*)(\?[^#]*)?(#.*)?/) || []).splice(1);
|
|
return {
|
|
pathname,
|
|
search,
|
|
hash
|
|
};
|
|
}
|
|
function parseAuth(input = "") {
|
|
const [username, password] = input.split(":");
|
|
return {
|
|
username: decode(username),
|
|
password: decode(password)
|
|
};
|
|
}
|
|
function parseHost(input = "") {
|
|
const [hostname, port] = (input.match(/([^/:]*):?(\d+)?/) || []).splice(1);
|
|
return {
|
|
hostname: decode(hostname),
|
|
port
|
|
};
|
|
}
|
|
function stringifyParsedURL(parsed) {
|
|
const pathname = parsed.pathname || "";
|
|
const search = parsed.search ? (parsed.search.startsWith("?") ? "" : "?") + parsed.search : "";
|
|
const hash = parsed.hash || "";
|
|
const auth = parsed.auth ? parsed.auth + "@" : "";
|
|
const host = parsed.host || "";
|
|
const proto = parsed.protocol || parsed[protocolRelative] ? (parsed.protocol || "") + "//" : "";
|
|
return proto + auth + host + pathname + search + hash;
|
|
}
|
|
const FILENAME_STRICT_REGEX = /\/([^/]+\.[^/]+)$/;
|
|
const FILENAME_REGEX = /\/([^/]+)$/;
|
|
function parseFilename(input = "", { strict }) {
|
|
const { pathname } = parseURL(input);
|
|
const matches = strict ? pathname.match(FILENAME_STRICT_REGEX) : pathname.match(FILENAME_REGEX);
|
|
return matches ? matches[1] : void 0;
|
|
}
|
|
|
|
var __defProp = Object.defineProperty;
|
|
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
|
var __publicField = (obj, key, value) => {
|
|
__defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
|
|
return value;
|
|
};
|
|
class $URL {
|
|
constructor(input = "") {
|
|
__publicField(this, "protocol");
|
|
__publicField(this, "host");
|
|
__publicField(this, "auth");
|
|
__publicField(this, "pathname");
|
|
__publicField(this, "query", {});
|
|
__publicField(this, "hash");
|
|
if (typeof input !== "string") {
|
|
throw new TypeError(
|
|
`URL input should be string received ${typeof input} (${input})`
|
|
);
|
|
}
|
|
const parsed = parseURL(input);
|
|
this.protocol = decode(parsed.protocol);
|
|
this.host = decode(parsed.host);
|
|
this.auth = decode(parsed.auth);
|
|
this.pathname = decodePath(parsed.pathname);
|
|
this.query = parseQuery(parsed.search);
|
|
this.hash = decode(parsed.hash);
|
|
}
|
|
get hostname() {
|
|
return parseHost(this.host).hostname;
|
|
}
|
|
get port() {
|
|
return parseHost(this.host).port || "";
|
|
}
|
|
get username() {
|
|
return parseAuth(this.auth).username;
|
|
}
|
|
get password() {
|
|
return parseAuth(this.auth).password || "";
|
|
}
|
|
get hasProtocol() {
|
|
return this.protocol.length;
|
|
}
|
|
get isAbsolute() {
|
|
return this.hasProtocol || this.pathname[0] === "/";
|
|
}
|
|
get search() {
|
|
const q = stringifyQuery(this.query);
|
|
return q.length > 0 ? "?" + q : "";
|
|
}
|
|
get searchParams() {
|
|
const p = new URLSearchParams();
|
|
for (const name in this.query) {
|
|
const value = this.query[name];
|
|
if (Array.isArray(value)) {
|
|
for (const v of value) {
|
|
p.append(name, v);
|
|
}
|
|
} else {
|
|
p.append(
|
|
name,
|
|
typeof value === "string" ? value : JSON.stringify(value)
|
|
);
|
|
}
|
|
}
|
|
return p;
|
|
}
|
|
get origin() {
|
|
return (this.protocol ? this.protocol + "//" : "") + encodeHost(this.host);
|
|
}
|
|
get fullpath() {
|
|
return encodePath(this.pathname) + this.search + encodeHash(this.hash);
|
|
}
|
|
get encodedAuth() {
|
|
if (!this.auth) {
|
|
return "";
|
|
}
|
|
const { username, password } = parseAuth(this.auth);
|
|
return encodeURIComponent(username) + (password ? ":" + encodeURIComponent(password) : "");
|
|
}
|
|
get href() {
|
|
const auth = this.encodedAuth;
|
|
const originWithAuth = (this.protocol ? this.protocol + "//" : "") + (auth ? auth + "@" : "") + encodeHost(this.host);
|
|
return this.hasProtocol && this.isAbsolute ? originWithAuth + this.fullpath : this.fullpath;
|
|
}
|
|
append(url) {
|
|
if (url.hasProtocol) {
|
|
throw new Error("Cannot append a URL with protocol");
|
|
}
|
|
Object.assign(this.query, url.query);
|
|
if (url.pathname) {
|
|
this.pathname = withTrailingSlash(this.pathname) + withoutLeadingSlash(url.pathname);
|
|
}
|
|
if (url.hash) {
|
|
this.hash = url.hash;
|
|
}
|
|
}
|
|
toJSON() {
|
|
return this.href;
|
|
}
|
|
toString() {
|
|
return this.href;
|
|
}
|
|
}
|
|
function createURL(input) {
|
|
return new $URL(input);
|
|
}
|
|
|
|
exports.$URL = $URL;
|
|
exports.cleanDoubleSlashes = cleanDoubleSlashes;
|
|
exports.createURL = createURL;
|
|
exports.decode = decode;
|
|
exports.decodePath = decodePath;
|
|
exports.decodeQueryKey = decodeQueryKey;
|
|
exports.decodeQueryValue = decodeQueryValue;
|
|
exports.encode = encode;
|
|
exports.encodeHash = encodeHash;
|
|
exports.encodeHost = encodeHost;
|
|
exports.encodeParam = encodeParam;
|
|
exports.encodePath = encodePath;
|
|
exports.encodeQueryItem = encodeQueryItem;
|
|
exports.encodeQueryKey = encodeQueryKey;
|
|
exports.encodeQueryValue = encodeQueryValue;
|
|
exports.getQuery = getQuery;
|
|
exports.hasLeadingSlash = hasLeadingSlash;
|
|
exports.hasProtocol = hasProtocol;
|
|
exports.hasTrailingSlash = hasTrailingSlash;
|
|
exports.isEmptyURL = isEmptyURL;
|
|
exports.isEqual = isEqual;
|
|
exports.isNonEmptyURL = isNonEmptyURL;
|
|
exports.isRelative = isRelative;
|
|
exports.isSamePath = isSamePath;
|
|
exports.isScriptProtocol = isScriptProtocol;
|
|
exports.joinRelativeURL = joinRelativeURL;
|
|
exports.joinURL = joinURL;
|
|
exports.normalizeURL = normalizeURL;
|
|
exports.parseAuth = parseAuth;
|
|
exports.parseFilename = parseFilename;
|
|
exports.parseHost = parseHost;
|
|
exports.parsePath = parsePath;
|
|
exports.parseQuery = parseQuery;
|
|
exports.parseURL = parseURL;
|
|
exports.resolveURL = resolveURL;
|
|
exports.stringifyParsedURL = stringifyParsedURL;
|
|
exports.stringifyQuery = stringifyQuery;
|
|
exports.withBase = withBase;
|
|
exports.withFragment = withFragment;
|
|
exports.withHttp = withHttp;
|
|
exports.withHttps = withHttps;
|
|
exports.withLeadingSlash = withLeadingSlash;
|
|
exports.withProtocol = withProtocol;
|
|
exports.withQuery = withQuery;
|
|
exports.withTrailingSlash = withTrailingSlash;
|
|
exports.withoutBase = withoutBase;
|
|
exports.withoutFragment = withoutFragment;
|
|
exports.withoutHost = withoutHost;
|
|
exports.withoutLeadingSlash = withoutLeadingSlash;
|
|
exports.withoutProtocol = withoutProtocol;
|
|
exports.withoutTrailingSlash = withoutTrailingSlash;
|