in src/js/node/url.ts [110:401]
Url.prototype.parse = function (url, parseQueryString, slashesDenoteHost) {
if (typeof url !== "string") {
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 = new URLSearchParams(this.search.substr(1)).toJSON();
} 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();
}
/*
* 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.
*/
if (this.hostname) {
this.hostname = new URL("http://" + this.hostname).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) {
const query = this.query;
this.query = new URLSearchParams(query).toJSON();
}
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;
};