url: replace var with let in lib/url.js

xefimx · targos · commit 1413377bd3bd · 2019-12-01T16:59:47.000+01:00
PR-URL: #30281 Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de> Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
diff --git a/lib/url.js b/lib/url.js
@@ -157,13 +157,13 @@ Url.prototype.parse = function parse(url, parseQueryString, slashesDenoteHost) {
 // 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 hasHash = false;
- var start = -1;
- var end = -1;
- var rest = '';
- var lastPos = 0;
- var i = 0;
- for (var inWs = false, split = false; i < url.length; ++i) {
+ let hasHash = false;
+ let start = -1;
+ let end = -1;
+ let rest = '';
+ let lastPos = 0;
+ let i = 0;
+ for (let inWs = false, split = false; i < url.length; ++i) {
 const code = url.charCodeAt(i);
 
 // Find first and last non-whitespace characters for trimming
@@ -292,9 +292,9 @@ Url.prototype.parse = function parse(url, parseQueryString, slashesDenoteHost) {
 // http://a@b@c/ => user:a@b host:c
 // http://a@b?@c => user:a host:b path:/?@c
 
- var hostEnd = -1;
- var atSign = -1;
- var nonHost = -1;
+ let hostEnd = -1;
+ let atSign = -1;
+ let nonHost = -1;
 for (i = 0; i < rest.length; ++i) {
 switch (rest.charCodeAt(i)) {
 case CHAR_TAB:
@@ -356,11 +356,11 @@ Url.prototype.parse = function parse(url, parseQueryString, slashesDenoteHost) {
 if (typeof this.hostname !== 'string')
 this.hostname = '';
 
- var hostname = this.hostname;
+ const hostname = this.hostname;
 
 // If hostname begins with [ and ends with ]
 // assume that it's an IPv6 address.
- var ipv6Hostname = hostname.charCodeAt(0) === CHAR_LEFT_SQUARE_BRACKET &&
+ const ipv6Hostname = hostname.charCodeAt(0) === CHAR_LEFT_SQUARE_BRACKET &&
 hostname.charCodeAt(hostname.length - 1) === CHAR_RIGHT_SQUARE_BRACKET;
 
 // validate a little.
@@ -386,8 +386,8 @@ Url.prototype.parse = function parse(url, parseQueryString, slashesDenoteHost) {
 this.hostname = toASCII(this.hostname, true);
 }
 
- var p = this.port ? ':' + this.port : '';
- var h = this.hostname || '';
+ const p = this.port ? ':' + this.port : '';
+ const h = this.hostname || '';
 this.host = h + p;
 
 // strip [ and ] from the hostname
@@ -409,8 +409,8 @@ Url.prototype.parse = function parse(url, parseQueryString, slashesDenoteHost) {
 rest = autoEscapeStr(rest);
 }
 
- var questionIdx = -1;
- var hashIdx = -1;
+ let questionIdx = -1;
+ let hashIdx = -1;
 for (i = 0; i < rest.length; ++i) {
 const code = rest.charCodeAt(i);
 if (code === CHAR_HASH) {
@@ -467,7 +467,7 @@ Url.prototype.parse = function parse(url, parseQueryString, slashesDenoteHost) {
 };
 
 function getHostname(self, rest, hostname) {
- for (var i = 0; i < hostname.length; ++i) {
+ for (let i = 0; i < hostname.length; ++i) {
 const code = hostname.charCodeAt(i);
 const isValid = (code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z) ||
 code === CHAR_DOT ||
@@ -509,11 +509,11 @@ const escapedCodes = [
 // Also escape single quotes in case of an XSS attack.
 // Return the escaped string.
 function autoEscapeStr(rest) {
- var escaped = '';
- var lastEscapedPos = 0;
- for (var i = 0; i < rest.length; ++i) {
+ let escaped = '';
+ let lastEscapedPos = 0;
+ for (let i = 0; i < rest.length; ++i) {
 // `escaped` contains substring up to the last escaped character.
- var escapedChar = escapedCodes[rest.charCodeAt(i)];
+ const escapedChar = escapedCodes[rest.charCodeAt(i)];
 if (escapedChar) {
 // Concat if there are ordinary characters in the middle.
 if (i > lastEscapedPos)
@@ -544,7 +544,7 @@ function urlFormat(urlObject, options) {
 throw new ERR_INVALID_ARG_TYPE('urlObject',
 ['Object', 'string'], urlObject);
 } else if (!(urlObject instanceof Url)) {
- var format = urlObject[formatSymbol];
+ const format = urlObject[formatSymbol];
 return format ?
 format.call(urlObject, options) :
 Url.prototype.format.call(urlObject);
@@ -570,17 +570,17 @@ const noEscapeAuth = [
 ];
 
 Url.prototype.format = function format() {
- var auth = this.auth || '';
+ let auth = this.auth || '';
 if (auth) {
 auth = encodeStr(auth, noEscapeAuth, hexTable);
 auth += '@';
 }
 
- var protocol = this.protocol || '';
- var pathname = this.pathname || '';
- var hash = this.hash || '';
- var host = '';
- var query = '';
+ let protocol = this.protocol || '';
+ let pathname = this.pathname || '';
+ let hash = this.hash || '';
+ let host = '';
+ let query = '';
 
 if (this.host) {
 host = auth + this.host;
@@ -600,14 +600,14 @@ Url.prototype.format = function format() {
 query = querystring.stringify(this.query);
 }
 
- var search = this.search || (query && ('?' + query)) || '';
+ let search = this.search || (query && ('?' + query)) || '';
 
 if (protocol && protocol.charCodeAt(protocol.length - 1) !== 58/* : */)
 protocol += ':';
 
- var newPathname = '';
- var lastPos = 0;
- for (var i = 0; i < pathname.length; ++i) {
+ let newPathname = '';
+ let lastPos = 0;
+ for (let i = 0; i < pathname.length; ++i) {
 switch (pathname.charCodeAt(i)) {
 case CHAR_HASH:
 if (i - lastPos > 0)
@@ -671,15 +671,15 @@ function urlResolveObject(source, relative) {
 
 Url.prototype.resolveObject = function resolveObject(relative) {
 if (typeof relative === 'string') {
- var rel = new Url();
+ const rel = new Url();
 rel.parse(relative, false, true);
 relative = rel;
 }
 
 const result = new Url();
 const tkeys = Object.keys(this);
- for (var tk = 0; tk < tkeys.length; tk++) {
- var tkey = tkeys[tk];
+ for (let tk = 0; tk < tkeys.length; tk++) {
+ const tkey = tkeys[tk];
 result[tkey] = this[tkey];
 }
 
@@ -696,9 +696,9 @@ Url.prototype.resolveObject = function resolveObject(relative) {
 // 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];
+ const rkeys = Object.keys(relative);
+ for (let rk = 0; rk < rkeys.length; rk++) {
+ const rkey = rkeys[rk];
 if (rkey !== 'protocol')
 result[rkey] = relative[rkey];
 }
@@ -723,9 +723,9 @@ Url.prototype.resolveObject = function resolveObject(relative) {
 // because that's known to be hostless.
 // anything else is assumed to be absolute.
 if (!slashedProtocol.has(relative.protocol)) {
- var keys = Object.keys(relative);
- for (var v = 0; v < keys.length; v++) {
- var k = keys[v];
+ const keys = Object.keys(relative);
+ for (let v = 0; v < keys.length; v++) {
+ const k = keys[v];
 result[k] = relative[k];
 }
 result.href = result.format();
@@ -754,8 +754,8 @@ Url.prototype.resolveObject = function resolveObject(relative) {
 result.port = relative.port;
 // To support http.request
 if (result.pathname || result.search) {
- var p = result.pathname || '';
- var s = result.search || '';
+ const p = result.pathname || '';
+ const s = result.search || '';
 result.path = p + s;
 }
 result.slashes = result.slashes || relative.slashes;
@@ -767,10 +767,10 @@ Url.prototype.resolveObject = function resolveObject(relative) {
 const isRelAbs = (
 relative.host || (relative.pathname && relative.pathname.charAt(0) === '/')
 );
- var mustEndAbs = (isRelAbs || isSourceAbs ||
+ let mustEndAbs = (isRelAbs || isSourceAbs ||
 (result.host && relative.pathname));
 const removeAllDots = mustEndAbs;
- var srcPath = (result.pathname && result.pathname.split('/')) || [];
+ let srcPath = (result.pathname && result.pathname.split('/')) || [];
 const relPath = (relative.pathname && relative.pathname.split('/')) || [];
 const noLeadingSlashes = result.protocol &&
 !slashedProtocol.has(result.protocol);
@@ -867,15 +867,15 @@ Url.prototype.resolveObject = function resolveObject(relative) {
 // 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];
+ let last = srcPath.slice(-1)[0];
 const 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 - 1; i >= 0; i--) {
+ let up = 0;
+ for (let i = srcPath.length - 1; i >= 0; i--) {
 last = srcPath[i];
 if (last === '.') {
 spliceOne(srcPath, i);
@@ -947,8 +947,8 @@ Url.prototype.resolveObject = function resolveObject(relative) {
 };
 
 Url.prototype.parseHost = function parseHost() {
- var host = this.host;
- var port = portPattern.exec(host);
+ let host = this.host;
+ let port = portPattern.exec(host);
 if (port) {
 port = port[0];
 if (port !== ':') {

-Original file line number
+Diff line change
 // 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
 -varhasHash=false;
 -varstart=-1;
 -varend=-1;
 -varrest='';
 -varlastPos=0;
 -vari=0;
 -for(varinWs=false,split=false;i<url.length;++i){
 +lethasHash=false;
 +letstart=-1;
 +letend=-1;
 +letrest='';
 +letlastPos=0;
 +leti=0;
 +for(letinWs=false,split=false;i<url.length;++i){
 constcode=url.charCodeAt(i);
 // Find first and last non-whitespace characters for trimming
 // http://a@b@c/ => user:a@b host:c
 // http://a@b?@c => user:a host:b path:/?@c
 -varhostEnd=-1;
 -varatSign=-1;
 -varnonHost=-1;
 +lethostEnd=-1;
 +letatSign=-1;
 +letnonHost=-1;
 for(i=0;i<rest.length;++i){
 switch(rest.charCodeAt(i)){
 caseCHAR_TAB:
 if(typeofthis.hostname!=='string')
 this.hostname='';
 -varhostname=this.hostname;
 +consthostname=this.hostname;
 // If hostname begins with [ and ends with ]
 // assume that it's an IPv6 address.
 -varipv6Hostname=hostname.charCodeAt(0)===CHAR_LEFT_SQUARE_BRACKET&&
 +constipv6Hostname=hostname.charCodeAt(0)===CHAR_LEFT_SQUARE_BRACKET&&
 hostname.charCodeAt(hostname.length-1)===CHAR_RIGHT_SQUARE_BRACKET;
 // validate a little.
 this.hostname=toASCII(this.hostname,true);
+}
 -varp=this.port ? ':'+this.port : '';
 -varh=this.hostname||'';
 +constp=this.port ? ':'+this.port : '';
 +consth=this.hostname||'';
 this.host=h+p;
 // strip [ and ] from the hostname
 rest=autoEscapeStr(rest);
+}
 -varquestionIdx=-1;
 -varhashIdx=-1;
 +letquestionIdx=-1;
 +lethashIdx=-1;
 for(i=0;i<rest.length;++i){
 constcode=rest.charCodeAt(i);
 if(code===CHAR_HASH){
 };
 functiongetHostname(self,rest,hostname){
 -for(vari=0;i<hostname.length;++i){
 +for(leti=0;i<hostname.length;++i){
 constcode=hostname.charCodeAt(i);
 constisValid=(code>=CHAR_LOWERCASE_A&&code<=CHAR_LOWERCASE_Z)||
 code===CHAR_DOT||
 // Also escape single quotes in case of an XSS attack.
 // Return the escaped string.
 functionautoEscapeStr(rest){
 -varescaped='';
 -varlastEscapedPos=0;
 -for(vari=0;i<rest.length;++i){
 +letescaped='';
 +letlastEscapedPos=0;
 +for(leti=0;i<rest.length;++i){
 // `escaped` contains substring up to the last escaped character.
 -varescapedChar=escapedCodes[rest.charCodeAt(i)];
 +constescapedChar=escapedCodes[rest.charCodeAt(i)];
 if(escapedChar){
 // Concat if there are ordinary characters in the middle.
 if(i>lastEscapedPos)
 thrownewERR_INVALID_ARG_TYPE('urlObject',
 ['Object','string'],urlObject);
 }elseif(!(urlObjectinstanceofUrl)){
 -varformat=urlObject[formatSymbol];
 +constformat=urlObject[formatSymbol];
 returnformat ?
 format.call(urlObject,options) :
 Url.prototype.format.call(urlObject);
 ];
 Url.prototype.format=functionformat(){
 -varauth=this.auth||'';
 +letauth=this.auth||'';
 if(auth){
 auth=encodeStr(auth,noEscapeAuth,hexTable);
 auth+='@';
+}
 -varprotocol=this.protocol||'';
 -varpathname=this.pathname||'';
 -varhash=this.hash||'';
 -varhost='';
 -varquery='';
 +letprotocol=this.protocol||'';
 +letpathname=this.pathname||'';
 +lethash=this.hash||'';
 +lethost='';
 +letquery='';
 if(this.host){
 host=auth+this.host;
 query=querystring.stringify(this.query);
+}
 -varsearch=this.search||(query&&('?'+query))||'';
 +letsearch=this.search||(query&&('?'+query))||'';
 if(protocol&&protocol.charCodeAt(protocol.length-1)!==58/* : */)
 protocol+=':';
 -varnewPathname='';
 -varlastPos=0;
 -for(vari=0;i<pathname.length;++i){
 +letnewPathname='';
 +letlastPos=0;
 +for(leti=0;i<pathname.length;++i){
 switch(pathname.charCodeAt(i)){
 caseCHAR_HASH:
 if(i-lastPos>0)
 Url.prototype.resolveObject=functionresolveObject(relative){
 if(typeofrelative==='string'){
 -varrel=newUrl();
 +constrel=newUrl();
 rel.parse(relative,false,true);
 relative=rel;
+}
 constresult=newUrl();
 consttkeys=Object.keys(this);
 -for(vartk=0;tk<tkeys.length;tk++){
 -vartkey=tkeys[tk];
 +for(lettk=0;tk<tkeys.length;tk++){
 +consttkey=tkeys[tk];
 result[tkey]=this[tkey];
+}
 // Hrefs like //foo/bar always cut to the protocol.
 if(relative.slashes&&!relative.protocol){
 // Take everything except the protocol from relative
 -varrkeys=Object.keys(relative);
 -for(varrk=0;rk<rkeys.length;rk++){
 -varrkey=rkeys[rk];
 +constrkeys=Object.keys(relative);
 +for(letrk=0;rk<rkeys.length;rk++){
 +constrkey=rkeys[rk];
 if(rkey!=='protocol')
 result[rkey]=relative[rkey];
+}
 // because that's known to be hostless.
 // anything else is assumed to be absolute.
 if(!slashedProtocol.has(relative.protocol)){
 -varkeys=Object.keys(relative);
 -for(varv=0;v<keys.length;v++){
 -vark=keys[v];
 +constkeys=Object.keys(relative);
 +for(letv=0;v<keys.length;v++){
 +constk=keys[v];
 result[k]=relative[k];
+}
 result.href=result.format();
 result.port=relative.port;
 // To support http.request
 if(result.pathname||result.search){
 -varp=result.pathname||'';
 -vars=result.search||'';
 +constp=result.pathname||'';
 +consts=result.search||'';
 result.path=p+s;
+}
 result.slashes=result.slashes||relative.slashes;
 constisRelAbs=(
 relative.host||(relative.pathname&&relative.pathname.charAt(0)==='/')
 );
 -varmustEndAbs=(isRelAbs||isSourceAbs||
 +letmustEndAbs=(isRelAbs||isSourceAbs||
 (result.host&&relative.pathname));
 constremoveAllDots=mustEndAbs;
 -varsrcPath=(result.pathname&&result.pathname.split('/'))||[];
 +letsrcPath=(result.pathname&&result.pathname.split('/'))||[];
 constrelPath=(relative.pathname&&relative.pathname.split('/'))||[];
 constnoLeadingSlashes=result.protocol&&
 !slashedProtocol.has(result.protocol);
 // 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.
 -varlast=srcPath.slice(-1)[0];
 +letlast=srcPath.slice(-1)[0];
 consthasTrailingSlash=(
 ((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
 -varup=0;
 -for(vari=srcPath.length-1;i>=0;i--){
 +letup=0;
 +for(leti=srcPath.length-1;i>=0;i--){
 last=srcPath[i];
 if(last==='.'){
 spliceOne(srcPath,i);
 };
 Url.prototype.parseHost=functionparseHost(){
 -varhost=this.host;
 -varport=portPattern.exec(host);
 +lethost=this.host;
 +letport=portPattern.exec(host);
 if(port){
 port=port[0];
 if(port!==':'){