lib/url.js

   1 'use strict';
   2
   3 const punycode = require('punycode');
   4
   5 exports.parse = urlParse;
   6 exports.resolve = urlResolve;
   7 exports.resolveObject = urlResolveObject;
   8 exports.format = urlFormat;
   9
  10 exports.Url = Url;
  11
  12 function Url() {
  13   this.protocol = null;
  14   this.slashes = null;
  15   this.auth = null;
  16   this.host = null;
  17   this.port = null;
  18   this.hostname = null;
  19   this.hash = null;
  20   this.search = null;
  21   this.query = null;
  22   this.pathname = null;
  23   this.path = null;
  24   this.href = null;
  25 }
  26
  27 // Reference: RFC 3986, RFC 1808, RFC 2396
  28
  29 // define these here so at least they only have to be
  30 // compiled once on the first module load.
  31 const protocolPattern = /^([a-z0-9.+-]+:)/i;
  32 const portPattern = /:[0-9]*$/;
  33
  34 // Special case for a simple path URL
  35 const simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/;
  36
  37 // RFC 2396: characters reserved for delimiting URLs.
  38 // We actually just auto-escape these.
  39 const delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t'];
  40
  41 // RFC 2396: characters not allowed for various reasons.
  42 const unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims);
  43
  44 // Allowed by RFCs, but cause of XSS attacks.  Always escape these.
  45 const autoEscape = ['\''].concat(unwise);
  46
  47 // Characters that are never ever allowed in a hostname.
  48 // Note that any invalid chars are also handled, but these
  49 // are the ones that are *expected* to be seen, so we fast-path them.
  50 const nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape);
  51 const hostEndingChars = ['/', '?', '#'];
  52 const hostnameMaxLen = 255;
  53 const hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/;
  54 const hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/;
  55 // protocols that can allow "unsafe" and "unwise" chars.
  56 const unsafeProtocol = {
  57   'javascript': true,
  58   'javascript:': true
  59 };
  60 // protocols that never have a hostname.
  61 const hostlessProtocol = {
  62   'javascript': true,
  63   'javascript:': true
  64 };
  65 // protocols that always contain a // bit.
  66 const slashedProtocol = {
  67   'http': true,
  68   'https': true,
  69   'ftp': true,
  70   'gopher': true,
  71   'file': true,
  72   'http:': true,
  73   'https:': true,
  74   'ftp:': true,
  75   'gopher:': true,
  76   'file:': true
  77 };
  78 const querystring = require('querystring');
  79
  80 function urlParse(url, parseQueryString, slashesDenoteHost) {
  81   if (url instanceof Url) return url;
  82
  83   var u = new Url();
  84   u.parse(url, parseQueryString, slashesDenoteHost);
  85   return u;
  86 }
  87
  88 Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {
  89   if (typeof url !== 'string') {
  90     throw new TypeError("Parameter 'url' must be a string, not " + typeof url);
  91   }
  92
  93   // Copy chrome, IE, opera backslash-handling behavior.
  94   // Back slashes before the query string get converted to forward slashes
  95   // See: https://code.google.com/p/chromium/issues/detail?id=25916
  96   var queryIndex = url.indexOf('?'),
  97       splitter =
  98           (queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#',
  99       uSplit = url.split(splitter),
 100       slashRegex = /\\/g;
 101   uSplit[0] = uSplit[0].replace(slashRegex, '/');
 102   url = uSplit.join(splitter);
 103
 104   var rest = url;
 105
 106   // trim before proceeding.
 107   // This is to support parse stuff like "  http://foo.com  \n"
 108   rest = rest.trim();
 109
 110   if (!slashesDenoteHost && url.split('#').length === 1) {
 111     // Try fast path regexp
 112     var simplePath = simplePathPattern.exec(rest);
 113     if (simplePath) {
 114       this.path = rest;
 115       this.href = rest;
 116       this.pathname = simplePath[1];
 117       if (simplePath[2]) {
 118         this.search = simplePath[2];
 119         if (parseQueryString) {
 120           this.query = querystring.parse(this.search.substr(1));
 121         } else {
 122           this.query = this.search.substr(1);
 123         }
 124       } else if (parseQueryString) {
 125         this.search = '';
 126         this.query = {};
 127       }
 128       return this;
 129     }
 130   }
 131
 132   var proto = protocolPattern.exec(rest);
 133   if (proto) {
 134     proto = proto[0];
 135     var lowerProto = proto.toLowerCase();
 136     this.protocol = lowerProto;
 137     rest = rest.substr(proto.length);
 138   }
 139
 140   // figure out if it's got a host
 141   // user@server is *always* interpreted as a hostname, and url
 142   // resolution will treat //foo/bar as host=foo,path=bar because that's
 143   // how the browser resolves relative URLs.
 144   if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
 145     var slashes = rest.substr(0, 2) === '//';
 146     if (slashes && !(proto && hostlessProtocol[proto])) {
 147       rest = rest.substr(2);
 148       this.slashes = true;
 149     }
 150   }
 151
 152   if (!hostlessProtocol[proto] &&
 153       (slashes || (proto && !slashedProtocol[proto]))) {
 154
 155     // there's a hostname.
 156     // the first instance of /, ?, ;, or # ends the host.
 157     //
 158     // If there is an @ in the hostname, then non-host chars *are* allowed
 159     // to the left of the last @ sign, unless some host-ending character
 160     // comes *before* the @-sign.
 161     // URLs are obnoxious.
 162     //
 163     // ex:
 164     // http://a@b@c/ => user:a@b host:c
 165     // http://a@b?@c => user:a host:b path:/?@c
 166
 167     // v0.12 TODO(isaacs): This is not quite how Chrome does things.
 168     // Review our test case against browsers more comprehensively.
 169
 170     // find the first instance of any hostEndingChars
 171     var hostEnd = -1;
 172     for (var i = 0; i < hostEndingChars.length; i++) {
 173       var hec = rest.indexOf(hostEndingChars[i]);
 174       if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
 175         hostEnd = hec;
 176     }
 177
 178     // at this point, either we have an explicit point where the
 179     // auth portion cannot go past, or the last @ char is the decider.
 180     var auth, atSign;
 181     if (hostEnd === -1) {
 182       // atSign can be anywhere.
 183       atSign = rest.lastIndexOf('@');
 184     } else {
 185       // atSign must be in auth portion.
 186       // http://a@b/c@d => host:b auth:a path:/c@d
 187       atSign = rest.lastIndexOf('@', hostEnd);
 188     }
 189
 190     // Now we have a portion which is definitely the auth.
 191     // Pull that off.
 192     if (atSign !== -1) {
 193       auth = rest.slice(0, atSign);
 194       rest = rest.slice(atSign + 1);
 195       this.auth = decodeURIComponent(auth);
 196     }
 197
 198     // the host is the remaining to the left of the first non-host char
 199     hostEnd = -1;
 200     for (var i = 0; i < nonHostChars.length; i++) {
 201       var hec = rest.indexOf(nonHostChars[i]);
 202       if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
 203         hostEnd = hec;
 204     }
 205     // if we still have not hit it, then the entire thing is a host.
 206     if (hostEnd === -1)
 207       hostEnd = rest.length;
 208
 209     this.host = rest.slice(0, hostEnd);
 210     rest = rest.slice(hostEnd);
 211
 212     // pull out port.
 213     this.parseHost();
 214
 215     // we've indicated that there is a hostname,
 216     // so even if it's empty, it has to be present.
 217     this.hostname = this.hostname || '';
 218
 219     // if hostname begins with [ and ends with ]
 220     // assume that it's an IPv6 address.
 221     var ipv6Hostname = this.hostname[0] === '[' &&
 222         this.hostname[this.hostname.length - 1] === ']';
 223
 224     // validate a little.
 225     if (!ipv6Hostname) {
 226       var hostparts = this.hostname.split(/\./);
 227       for (var i = 0, l = hostparts.length; i < l; i++) {
 228         var part = hostparts[i];
 229         if (!part) continue;
 230         if (!part.match(hostnamePartPattern)) {
 231           var newpart = '';
 232           for (var j = 0, k = part.length; j < k; j++) {
 233             if (part.charCodeAt(j) > 127) {
 234               // we replace non-ASCII char with a temporary placeholder
 235               // we need this to make sure size of hostname is not
 236               // broken by replacing non-ASCII by nothing
 237               newpart += 'x';
 238             } else {
 239               newpart += part[j];
 240             }
 241           }
 242           // we test again with ASCII char only
 243           if (!newpart.match(hostnamePartPattern)) {
 244             var validParts = hostparts.slice(0, i);
 245             var notHost = hostparts.slice(i + 1);
 246             var bit = part.match(hostnamePartStart);
 247             if (bit) {
 248               validParts.push(bit[1]);
 249               notHost.unshift(bit[2]);
 250             }
 251             if (notHost.length) {
 252               rest = '/' + notHost.join('.') + rest;
 253             }
 254             this.hostname = validParts.join('.');
 255             break;
 256           }
 257         }
 258       }
 259     }
 260
 261     if (this.hostname.length > hostnameMaxLen) {
 262       this.hostname = '';
 263     } else {
 264       // hostnames are always lower case.
 265       this.hostname = this.hostname.toLowerCase();
 266     }
 267
 268     if (!ipv6Hostname) {
 269       // IDNA Support: Returns a punycoded representation of "domain".
 270       // It only converts parts of the domain name that
 271       // have non-ASCII characters, i.e. it doesn't matter if
 272       // you call it with a domain that already is ASCII-only.
 273       this.hostname = punycode.toASCII(this.hostname);
 274     }
 275
 276     var p = this.port ? ':' + this.port : '';
 277     var h = this.hostname || '';
 278     this.host = h + p;
 279
 280     // strip [ and ] from the hostname
 281     // the host field still retains them, though
 282     if (ipv6Hostname) {
 283       this.hostname = this.hostname.substr(1, this.hostname.length - 2);
 284       if (rest[0] !== '/') {
 285         rest = '/' + rest;
 286       }
 287     }
 288   }
 289
 290   // now rest is set to the post-host stuff.
 291   // chop off any delim chars.
 292   if (!unsafeProtocol[lowerProto]) {
 293
 294     // First, make 100% sure that any "autoEscape" chars get
 295     // escaped, even if encodeURIComponent doesn't think they
 296     // need to be.
 297     for (var i = 0, l = autoEscape.length; i < l; i++) {
 298       var ae = autoEscape[i];
 299       if (rest.indexOf(ae) === -1)
 300         continue;
 301       var esc = encodeURIComponent(ae);
 302       if (esc === ae) {
 303         esc = escape(ae);
 304       }
 305       rest = rest.split(ae).join(esc);
 306     }
 307   }
 308
 309
 310   // chop off from the tail first.
 311   var hash = rest.indexOf('#');
 312   if (hash !== -1) {
 313     // got a fragment string.
 314     this.hash = rest.substr(hash);
 315     rest = rest.slice(0, hash);
 316   }
 317   var qm = rest.indexOf('?');
 318   if (qm !== -1) {
 319     this.search = rest.substr(qm);
 320     this.query = rest.substr(qm + 1);
 321     if (parseQueryString) {
 322       this.query = querystring.parse(this.query);
 323     }
 324     rest = rest.slice(0, qm);
 325   } else if (parseQueryString) {
 326     // no query string, but parseQueryString still requested
 327     this.search = '';
 328     this.query = {};
 329   }
 330   if (rest) this.pathname = rest;
 331   if (slashedProtocol[lowerProto] &&
 332       this.hostname && !this.pathname) {
 333     this.pathname = '/';
 334   }
 335
 336   //to support http.request
 337   if (this.pathname || this.search) {
 338     var p = this.pathname || '';
 339     var s = this.search || '';
 340     this.path = p + s;
 341   }
 342
 343   // finally, reconstruct the href based on what has been validated.
 344   this.href = this.format();
 345   return this;
 346 };
 347
 348 // format a parsed object into a url string
 349 function urlFormat(obj) {
 350   // ensure it's an object, and not a string url.
 351   // If it's an obj, this is a no-op.
 352   // this way, you can call url_format() on strings
 353   // to clean up potentially wonky urls.
 354   if (typeof obj === 'string') obj = urlParse(obj);
 355
 356   else if (typeof obj !== 'object' || obj === null)
 357     throw new TypeError("Parameter 'urlObj' must be an object, not " +
 358                         obj === null ? 'null' : typeof obj);
 359
 360   else if (!(obj instanceof Url)) return Url.prototype.format.call(obj);
 361
 362   return obj.format();
 363 }
 364
 365 Url.prototype.format = function() {
 366   var auth = this.auth || '';
 367   if (auth) {
 368     auth = encodeURIComponent(auth);
 369     auth = auth.replace(/%3A/i, ':');
 370     auth += '@';
 371   }
 372
 373   var protocol = this.protocol || '',
 374       pathname = this.pathname || '',
 375       hash = this.hash || '',
 376       host = false,
 377       query = '';
 378
 379   if (this.host) {
 380     host = auth + this.host;
 381   } else if (this.hostname) {
 382     host = auth + (this.hostname.indexOf(':') === -1 ?
 383         this.hostname :
 384         '[' + this.hostname + ']');
 385     if (this.port) {
 386       host += ':' + this.port;
 387     }
 388   }
 389
 390   if (this.query !== null &&
 391       typeof this.query === 'object' &&
 392       Object.keys(this.query).length) {
 393     query = querystring.stringify(this.query);
 394   }
 395
 396   var search = this.search || (query && ('?' + query)) || '';
 397
 398   if (protocol && protocol.substr(-1) !== ':') protocol += ':';
 399
 400   // only the slashedProtocols get the //.  Not mailto:, xmpp:, etc.
 401   // unless they had them to begin with.
 402   if (this.slashes ||
 403       (!protocol || slashedProtocol[protocol]) && host !== false) {
 404     host = '//' + (host || '');
 405     if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;
 406   } else if (!host) {
 407     host = '';
 408   }
 409
 410   if (hash && hash.charAt(0) !== '#') hash = '#' + hash;
 411   if (search && search.charAt(0) !== '?') search = '?' + search;
 412
 413   pathname = pathname.replace(/[?#]/g, function(match) {
 414     return encodeURIComponent(match);
 415   });
 416   search = search.replace('#', '%23');
 417
 418   return protocol + host + pathname + search + hash;
 419 };
 420
 421 function urlResolve(source, relative) {
 422   return urlParse(source, false, true).resolve(relative);
 423 }
 424
 425 Url.prototype.resolve = function(relative) {
 426   return this.resolveObject(urlParse(relative, false, true)).format();
 427 };
 428
 429 function urlResolveObject(source, relative) {
 430   if (!source) return relative;
 431   return urlParse(source, false, true).resolveObject(relative);
 432 }
 433
 434 Url.prototype.resolveObject = function(relative) {
 435   if (typeof relative === 'string') {
 436     var rel = new Url();
 437     rel.parse(relative, false, true);
 438     relative = rel;
 439   }
 440
 441   var result = new Url();
 442   var tkeys = Object.keys(this);
 443   for (var tk = 0; tk < tkeys.length; tk++) {
 444     var tkey = tkeys[tk];
 445     result[tkey] = this[tkey];
 446   }
 447
 448   // hash is always overridden, no matter what.
 449   // even href="" will remove it.
 450   result.hash = relative.hash;
 451
 452   // if the relative url is empty, then there's nothing left to do here.
 453   if (relative.href === '') {
 454     result.href = result.format();
 455     return result;
 456   }
 457
 458   // hrefs like //foo/bar always cut to the protocol.
 459   if (relative.slashes && !relative.protocol) {
 460     // take everything except the protocol from relative
 461     var rkeys = Object.keys(relative);
 462     for (var rk = 0; rk < rkeys.length; rk++) {
 463       var rkey = rkeys[rk];
 464       if (rkey !== 'protocol')
 465         result[rkey] = relative[rkey];
 466     }
 467
 468     //urlParse appends trailing / to urls like http://www.example.com
 469     if (slashedProtocol[result.protocol] &&
 470         result.hostname && !result.pathname) {
 471       result.path = result.pathname = '/';
 472     }
 473
 474     result.href = result.format();
 475     return result;
 476   }
 477
 478   if (relative.protocol && relative.protocol !== result.protocol) {
 479     // if it's a known url protocol, then changing
 480     // the protocol does weird things
 481     // first, if it's not file:, then we MUST have a host,
 482     // and if there was a path
 483     // to begin with, then we MUST have a path.
 484     // if it is file:, then the host is dropped,
 485     // because that's known to be hostless.
 486     // anything else is assumed to be absolute.
 487     if (!slashedProtocol[relative.protocol]) {
 488       var keys = Object.keys(relative);
 489       for (var v = 0; v < keys.length; v++) {
 490         var k = keys[v];
 491         result[k] = relative[k];
 492       }
 493       result.href = result.format();
 494       return result;
 495     }
 496
 497     result.protocol = relative.protocol;
 498     if (!relative.host &&
 499         !/^file:?$/.test(relative.protocol) &&
 500         !hostlessProtocol[relative.protocol]) {
 501       var relPath = (relative.pathname || '').split('/');
 502       while (relPath.length && !(relative.host = relPath.shift()));
 503       if (!relative.host) relative.host = '';
 504       if (!relative.hostname) relative.hostname = '';
 505       if (relPath[0] !== '') relPath.unshift('');
 506       if (relPath.length < 2) relPath.unshift('');
 507       result.pathname = relPath.join('/');
 508     } else {
 509       result.pathname = relative.pathname;
 510     }
 511     result.search = relative.search;
 512     result.query = relative.query;
 513     result.host = relative.host || '';
 514     result.auth = relative.auth;
 515     result.hostname = relative.hostname || relative.host;
 516     result.port = relative.port;
 517     // to support http.request
 518     if (result.pathname || result.search) {
 519       var p = result.pathname || '';
 520       var s = result.search || '';
 521       result.path = p + s;
 522     }
 523     result.slashes = result.slashes || relative.slashes;
 524     result.href = result.format();
 525     return result;
 526   }
 527
 528   var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),
 529       isRelAbs = (
 530           relative.host ||
 531           relative.pathname && relative.pathname.charAt(0) === '/'
 532       ),
 533       mustEndAbs = (isRelAbs || isSourceAbs ||
 534                     (result.host && relative.pathname)),
 535       removeAllDots = mustEndAbs,
 536       srcPath = result.pathname && result.pathname.split('/') || [],
 537       relPath = relative.pathname && relative.pathname.split('/') || [],
 538       psychotic = result.protocol && !slashedProtocol[result.protocol];
 539
 540   // if the url is a non-slashed url, then relative
 541   // links like ../.. should be able
 542   // to crawl up to the hostname, as well.  This is strange.
 543   // result.protocol has already been set by now.
 544   // Later on, put the first path part into the host field.
 545   if (psychotic) {
 546     result.hostname = '';
 547     result.port = null;
 548     if (result.host) {
 549       if (srcPath[0] === '') srcPath[0] = result.host;
 550       else srcPath.unshift(result.host);
 551     }
 552     result.host = '';
 553     if (relative.protocol) {
 554       relative.hostname = null;
 555       relative.port = null;
 556       if (relative.host) {
 557         if (relPath[0] === '') relPath[0] = relative.host;
 558         else relPath.unshift(relative.host);
 559       }
 560       relative.host = null;
 561     }
 562     mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');
 563   }
 564
 565   if (isRelAbs) {
 566     // it's absolute.
 567     result.host = (relative.host || relative.host === '') ?
 568                   relative.host : result.host;
 569     result.hostname = (relative.hostname || relative.hostname === '') ?
 570                       relative.hostname : result.hostname;
 571     result.search = relative.search;
 572     result.query = relative.query;
 573     srcPath = relPath;
 574     // fall through to the dot-handling below.
 575   } else if (relPath.length) {
 576     // it's relative
 577     // throw away the existing file, and take the new path instead.
 578     if (!srcPath) srcPath = [];
 579     srcPath.pop();
 580     srcPath = srcPath.concat(relPath);
 581     result.search = relative.search;
 582     result.query = relative.query;
 583   } else if (relative.search !== null && relative.search !== undefined) {
 584     // just pull out the search.
 585     // like href='?foo'.
 586     // Put this after the other two cases because it simplifies the booleans
 587     if (psychotic) {
 588       result.hostname = result.host = srcPath.shift();
 589       //occasionally the auth can get stuck only in host
 590       //this especially happens in cases like
 591       //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
 592       var authInHost = result.host && result.host.indexOf('@') > 0 ?
 593                        result.host.split('@') : false;
 594       if (authInHost) {
 595         result.auth = authInHost.shift();
 596         result.host = result.hostname = authInHost.shift();
 597       }
 598     }
 599     result.search = relative.search;
 600     result.query = relative.query;
 601     //to support http.request
 602     if (result.pathname !== null || result.search !== null) {
 603       result.path = (result.pathname ? result.pathname : '') +
 604                     (result.search ? result.search : '');
 605     }
 606     result.href = result.format();
 607     return result;
 608   }
 609
 610   if (!srcPath.length) {
 611     // no path at all.  easy.
 612     // we've already handled the other stuff above.
 613     result.pathname = null;
 614     //to support http.request
 615     if (result.search) {
 616       result.path = '/' + result.search;
 617     } else {
 618       result.path = null;
 619     }
 620     result.href = result.format();
 621     return result;
 622   }
 623
 624   // if a url ENDs in . or .., then it must get a trailing slash.
 625   // however, if it ends in anything else non-slashy,
 626   // then it must NOT get a trailing slash.
 627   var last = srcPath.slice(-1)[0];
 628   var hasTrailingSlash = (
 629       (result.host || relative.host || srcPath.length > 1) &&
 630       (last === '.' || last === '..') || last === '');
 631
 632   // strip single dots, resolve double dots to parent dir
 633   // if the path tries to go above the root, `up` ends up > 0
 634   var up = 0;
 635   for (var i = srcPath.length; i >= 0; i--) {
 636     last = srcPath[i];
 637     if (last === '.') {
 638       spliceOne(srcPath, i);
 639     } else if (last === '..') {
 640       spliceOne(srcPath, i);
 641       up++;
 642     } else if (up) {
 643       spliceOne(srcPath, i);
 644       up--;
 645     }
 646   }
 647
 648   // if the path is allowed to go above the root, restore leading ..s
 649   if (!mustEndAbs && !removeAllDots) {
 650     for (; up--; up) {
 651       srcPath.unshift('..');
 652     }
 653   }
 654
 655   if (mustEndAbs && srcPath[0] !== '' &&
 656       (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {
 657     srcPath.unshift('');
 658   }
 659
 660   if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {
 661     srcPath.push('');
 662   }
 663
 664   var isAbsolute = srcPath[0] === '' ||
 665       (srcPath[0] && srcPath[0].charAt(0) === '/');
 666
 667   // put the host back
 668   if (psychotic) {
 669     result.hostname = result.host = isAbsolute ? '' :
 670                                     srcPath.length ? srcPath.shift() : '';
 671     //occasionally the auth can get stuck only in host
 672     //this especially happens in cases like
 673     //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
 674     var authInHost = result.host && result.host.indexOf('@') > 0 ?
 675                      result.host.split('@') : false;
 676     if (authInHost) {
 677       result.auth = authInHost.shift();
 678       result.host = result.hostname = authInHost.shift();
 679     }
 680   }
 681
 682   mustEndAbs = mustEndAbs || (result.host && srcPath.length);
 683
 684   if (mustEndAbs && !isAbsolute) {
 685     srcPath.unshift('');
 686   }
 687
 688   if (!srcPath.length) {
 689     result.pathname = null;
 690     result.path = null;
 691   } else {
 692     result.pathname = srcPath.join('/');
 693   }
 694
 695   //to support request.http
 696   if (result.pathname !== null || result.search !== null) {
 697     result.path = (result.pathname ? result.pathname : '') +
 698                   (result.search ? result.search : '');
 699   }
 700   result.auth = relative.auth || result.auth;
 701   result.slashes = result.slashes || relative.slashes;
 702   result.href = result.format();
 703   return result;
 704 };
 705
 706 Url.prototype.parseHost = function() {
 707   var host = this.host;
 708   var port = portPattern.exec(host);
 709   if (port) {
 710     port = port[0];
 711     if (port !== ':') {
 712       this.port = port.substr(1);
 713     }
 714     host = host.substr(0, host.length - port.length);
 715   }
 716   if (host) this.hostname = host;
 717 };
 718
 719 // About 1.5x faster than the two-arg version of Array#splice().
 720 function spliceOne(list, index) {
 721   for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1)
 722     list[i] = list[k];
 723   list.pop();
 724 }