The Tor Browser / file revision

 // Copyright Joyent, Inc. and other Node contributors.

 //

 // Permission is hereby granted, free of charge, to any person obtaining a

 // copy of this software and associated documentation files (the

 // "Software"), to deal in the Software without restriction, including

 // without limitation the rights to use, copy, modify, merge, publish,

 // distribute, sublicense, and/or sell copies of the Software, and to permit

 // persons to whom the Software is furnished to do so, subject to the

 // following conditions:

 //

 // The above copyright notice and this permission notice shall be included

 // in all copies or substantial portions of the Software.

 //

 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN

 // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE

 // USE OR OTHER DEALINGS IN THE SOFTWARE.

 // Adapted version of:

 // https://github.com/joyent/node/blob/v0.11.3/lib/path.js

 // Shim process global from node.

 var process = Object.create(require('../system'));

 process.cwd = process.pathFor.bind(process, 'CurProcD');

 // Update original check in node `process.platform === 'win32'` since in SDK it's `winnt`.

 var isWindows = process.platform.indexOf('win') === 0;

 // resolves . and .. elements in a path array with directory names there

 // must be no slashes, empty elements, or device names (c:\) in the array

 // (so also no leading and trailing slashes - it does not distinguish

 // relative and absolute paths)

 function normalizeArray(parts, allowAboveRoot) {

   // if the path tries to go above the root, `up` ends up > 0

   var up = 0;

   for (var i = parts.length - 1; i >= 0; i--) {

     var last = parts[i];

     if (last === '.') {

       parts.splice(i, 1);

     } else if (last === '..') {

       parts.splice(i, 1);

       up++;

     } else if (up) {

       parts.splice(i, 1);

       up--;

     }

   }

   // if the path is allowed to go above the root, restore leading ..s

   if (allowAboveRoot) {

     for (; up--; up) {

       parts.unshift('..');

     }

   }

   return parts;

 }

 if (isWindows) {

   // Regex to split a windows path into three parts: [*, device, slash,

   // tail] windows-only

   var splitDeviceRe =

       /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;

   // Regex to split the tail part of the above into [*, dir, basename, ext]

   var splitTailRe =

       /^([\s\S]*?)((?:\.{1,2}|[^\\\/]+?|)(\.[^.\/\\]*|))(?:[\\\/]*)$/;

   // Function to split a filename into [root, dir, basename, ext]

   // windows version

   var splitPath = function(filename) {

     // Separate device+slash from tail

     var result = splitDeviceRe.exec(filename),

         device = (result[1] || '') + (result[2] || ''),

         tail = result[3] || '';

     // Split the tail into dir, basename and extension

     var result2 = splitTailRe.exec(tail),

         dir = result2[1],

         basename = result2[2],

         ext = result2[3];

     return [device, dir, basename, ext];

   };

   var normalizeUNCRoot = function(device) {

     return '\\\\' + device.replace(/^[\\\/]+/, '').replace(/[\\\/]+/g, '\\');

   };

   // path.resolve([from ...], to)

   // windows version

   exports.resolve = function() {

     var resolvedDevice = '',

         resolvedTail = '',

         resolvedAbsolute = false;

     for (var i = arguments.length - 1; i >= -1; i--) {

       var path;

       if (i >= 0) {

         path = arguments[i];

       } else if (!resolvedDevice) {

         path = process.cwd();

       } else {

         // Windows has the concept of drive-specific current working

         // directories. If we've resolved a drive letter but not yet an

         // absolute path, get cwd for that drive. We're sure the device is not

         // an unc path at this points, because unc paths are always absolute.

         path = process.env['=' + resolvedDevice];

         // Verify that a drive-local cwd was found and that it actually points

         // to our drive. If not, default to the drive's root.

         if (!path || path.substr(0, 3).toLowerCase() !==

             resolvedDevice.toLowerCase() + '\\') {

           path = resolvedDevice + '\\';

         }

       }

       // Skip empty and invalid entries

       if (typeof path !== 'string') {

         throw new TypeError('Arguments to path.resolve must be strings');

       } else if (!path) {

         continue;

       }

       var result = splitDeviceRe.exec(path),

           device = result[1] || '',

           isUnc = device && device.charAt(1) !== ':',

           isAbsolute = exports.isAbsolute(path),

           tail = result[3];

       if (device &&

           resolvedDevice &&

           device.toLowerCase() !== resolvedDevice.toLowerCase()) {

         // This path points to another device so it is not applicable

         continue;

       }

       if (!resolvedDevice) {

         resolvedDevice = device;

       }

       if (!resolvedAbsolute) {

         resolvedTail = tail + '\\' + resolvedTail;

         resolvedAbsolute = isAbsolute;

       }

       if (resolvedDevice && resolvedAbsolute) {

         break;

       }

     }

     // Convert slashes to backslashes when `resolvedDevice` points to an UNC

     // root. Also squash multiple slashes into a single one where appropriate.

     if (isUnc) {

       resolvedDevice = normalizeUNCRoot(resolvedDevice);

     }

     // At this point the path should be resolved to a full absolute path,

     // but handle relative paths to be safe (might happen when process.cwd()

     // fails)

     // Normalize the tail path

     function f(p) {

       return !!p;

     }

     resolvedTail = normalizeArray(resolvedTail.split(/[\\\/]+/).filter(f),

                                   !resolvedAbsolute).join('\\');

     return (resolvedDevice + (resolvedAbsolute ? '\\' : '') + resolvedTail) ||

            '.';

   };

   // windows version

   exports.normalize = function(path) {

     var result = splitDeviceRe.exec(path),

         device = result[1] || '',

         isUnc = device && device.charAt(1) !== ':',

         isAbsolute = exports.isAbsolute(path),

         tail = result[3],

         trailingSlash = /[\\\/]$/.test(tail);

     // If device is a drive letter, we'll normalize to lower case.

     if (device && device.charAt(1) === ':') {

       device = device[0].toLowerCase() + device.substr(1);

     }

     // Normalize the tail path

     tail = normalizeArray(tail.split(/[\\\/]+/).filter(function(p) {

       return !!p;

     }), !isAbsolute).join('\\');

     if (!tail && !isAbsolute) {

       tail = '.';

     }

     if (tail && trailingSlash) {

       tail += '\\';

     }

     // Convert slashes to backslashes when `device` points to an UNC root.

     // Also squash multiple slashes into a single one where appropriate.

     if (isUnc) {

       device = normalizeUNCRoot(device);

     }

     return device + (isAbsolute ? '\\' : '') + tail;

   };

   // windows version

   exports.isAbsolute = function(path) {

     var result = splitDeviceRe.exec(path),

         device = result[1] || '',

         isUnc = device && device.charAt(1) !== ':';

     // UNC paths are always absolute

     return !!result[2] || isUnc;

   };

   // windows version

   exports.join = function() {

     function f(p) {

       if (typeof p !== 'string') {

         throw new TypeError('Arguments to path.join must be strings');

       }

       return p;

     }

     var paths = Array.prototype.filter.call(arguments, f);

     var joined = paths.join('\\');

     // Make sure that the joined path doesn't start with two slashes, because

     // normalize() will mistake it for an UNC path then.

     //

     // This step is skipped when it is very clear that the user actually

     // intended to point at an UNC path. This is assumed when the first

     // non-empty string arguments starts with exactly two slashes followed by

     // at least one more non-slash character.

     //

     // Note that for normalize() to treat a path as an UNC path it needs to

     // have at least 2 components, so we don't filter for that here.

     // This means that the user can use join to construct UNC paths from

     // a server name and a share name; for example:

     //   path.join('//server', 'share') -> '\\\\server\\share\')

     if (!/^[\\\/]{2}[^\\\/]/.test(paths[0])) {

       joined = joined.replace(/^[\\\/]{2,}/, '\\');

     }

     return exports.normalize(joined);

   };

   // path.relative(from, to)

   // it will solve the relative path from 'from' to 'to', for instance:

   // from = 'C:\\orandea\\test\\aaa'

   // to = 'C:\\orandea\\impl\\bbb'

   // The output of the function should be: '..\\..\\impl\\bbb'

   // windows version

   exports.relative = function(from, to) {

     from = exports.resolve(from);

     to = exports.resolve(to);

     // windows is not case sensitive

     var lowerFrom = from.toLowerCase();

     var lowerTo = to.toLowerCase();

     function trim(arr) {

       var start = 0;

       for (; start < arr.length; start++) {

         if (arr[start] !== '') break;

       }

       var end = arr.length - 1;

       for (; end >= 0; end--) {

         if (arr[end] !== '') break;

       }

       if (start > end) return [];

       return arr.slice(start, end - start + 1);

     }

     var toParts = trim(to.split('\\'));

     var lowerFromParts = trim(lowerFrom.split('\\'));

     var lowerToParts = trim(lowerTo.split('\\'));

     var length = Math.min(lowerFromParts.length, lowerToParts.length);

     var samePartsLength = length;

     for (var i = 0; i < length; i++) {

       if (lowerFromParts[i] !== lowerToParts[i]) {

         samePartsLength = i;

         break;

       }

     }

     if (samePartsLength == 0) {

       return to;

     }

     var outputParts = [];

     for (var i = samePartsLength; i < lowerFromParts.length; i++) {

       outputParts.push('..');

     }

     outputParts = outputParts.concat(toParts.slice(samePartsLength));

     return outputParts.join('\\');

   };

   exports.sep = '\\';

   exports.delimiter = ';';

 } else /* posix */ {

   // Split a filename into [root, dir, basename, ext], unix version

   // 'root' is just a slash, or nothing.

   var splitPathRe =

       /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;

   var splitPath = function(filename) {

     return splitPathRe.exec(filename).slice(1);

   };

   // path.resolve([from ...], to)

   // posix version

   exports.resolve = function() {

     var resolvedPath = '',

         resolvedAbsolute = false;

     for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {

       var path = (i >= 0) ? arguments[i] : process.cwd();

       // Skip empty and invalid entries

       if (typeof path !== 'string') {

         throw new TypeError('Arguments to path.resolve must be strings');

       } else if (!path) {

         continue;

       }

       resolvedPath = path + '/' + resolvedPath;

       resolvedAbsolute = path.charAt(0) === '/';

     }

     // At this point the path should be resolved to a full absolute path, but

     // handle relative paths to be safe (might happen when process.cwd() fails)

     // Normalize the path

     resolvedPath = normalizeArray(resolvedPath.split('/').filter(function(p) {

       return !!p;

     }), !resolvedAbsolute).join('/');

     return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';

   };

   // path.normalize(path)

   // posix version

   exports.normalize = function(path) {

     var isAbsolute = exports.isAbsolute(path),

         trailingSlash = path.substr(-1) === '/';

     // Normalize the path

     path = normalizeArray(path.split('/').filter(function(p) {

       return !!p;

     }), !isAbsolute).join('/');

     if (!path && !isAbsolute) {

       path = '.';

     }

     if (path && trailingSlash) {

       path += '/';

     }

     return (isAbsolute ? '/' : '') + path;

   };

   // posix version

   exports.isAbsolute = function(path) {

     return path.charAt(0) === '/';

   };

   // posix version

   exports.join = function() {

     var paths = Array.prototype.slice.call(arguments, 0);

     return exports.normalize(paths.filter(function(p, index) {

       if (typeof p !== 'string') {

         throw new TypeError('Arguments to path.join must be strings');

       }

       return p;

     }).join('/'));

   };

   // path.relative(from, to)

   // posix version

   exports.relative = function(from, to) {

     from = exports.resolve(from).substr(1);

     to = exports.resolve(to).substr(1);

     function trim(arr) {

       var start = 0;

       for (; start < arr.length; start++) {

         if (arr[start] !== '') break;

       }

       var end = arr.length - 1;

       for (; end >= 0; end--) {

         if (arr[end] !== '') break;

       }

       if (start > end) return [];

       return arr.slice(start, end - start + 1);

     }

     var fromParts = trim(from.split('/'));

     var toParts = trim(to.split('/'));

     var length = Math.min(fromParts.length, toParts.length);

     var samePartsLength = length;

     for (var i = 0; i < length; i++) {

       if (fromParts[i] !== toParts[i]) {

         samePartsLength = i;

         break;

       }

     }

     var outputParts = [];

     for (var i = samePartsLength; i < fromParts.length; i++) {

       outputParts.push('..');

     }

     outputParts = outputParts.concat(toParts.slice(samePartsLength));

     return outputParts.join('/');

   };

   exports.sep = '/';

   exports.delimiter = ':';

 }

 exports.dirname = function(path) {

   var result = splitPath(path),

       root = result[0],

       dir = result[1];

   if (!root && !dir) {

     // No dirname whatsoever

     return '.';

   }

   if (dir) {

     // It has a dirname, strip trailing slash

     dir = dir.substr(0, dir.length - 1);

   }

   return root + dir;

 };

 exports.basename = function(path, ext) {

   var f = splitPath(path)[2];

   // TODO: make this comparison case-insensitive on windows?

   if (ext && f.substr(-1 * ext.length) === ext) {

     f = f.substr(0, f.length - ext.length);

   }

   return f;

 };

 exports.extname = function(path) {

   return splitPath(path)[3];

 };

 if (isWindows) {

   exports._makeLong = function(path) {

     // Note: this will *probably* throw somewhere.

     if (typeof path !== 'string')

       return path;

     if (!path) {

       return '';

     }

     var resolvedPath = exports.resolve(path);

     if (/^[a-zA-Z]\:\\/.test(resolvedPath)) {

       // path is local filesystem path, which needs to be converted

       // to long UNC path.

       return '\\\\?\\' + resolvedPath;

     } else if (/^\\\\[^?.]/.test(resolvedPath)) {

       // path is network UNC path, which needs to be converted

       // to long UNC path.

       return '\\\\?\\UNC\\' + resolvedPath.substring(2);

     }

     return path;

   };

 } else {

   exports._makeLong = function(path) {

     return path;

   };

 }