213 lines
5.6 KiB
JavaScript
213 lines
5.6 KiB
JavaScript
// Slightly modified (no IE8 support, ES6) and transcribed to TypeScript
|
|
// https://github.com/calvinmetcalf/rollup-plugin-node-builtins/blob/63ab8aacd013767445ca299e468d9a60a95328d7/src/es6/path.js
|
|
//
|
|
// 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.
|
|
|
|
/** JSDoc */
|
|
function normalizeArray(parts, allowAboveRoot) {
|
|
// if the path tries to go above the root, `up` ends up > 0
|
|
let up = 0;
|
|
for (let i = parts.length - 1; i >= 0; i--) {
|
|
const 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;
|
|
}
|
|
|
|
// Split a filename into [root, dir, basename, ext], unix version
|
|
// 'root' is just a slash, or nothing.
|
|
const splitPathRe = /^(\S+:\\|\/?)([\s\S]*?)((?:\.{1,2}|[^/\\]+?|)(\.[^./\\]*|))(?:[/\\]*)$/;
|
|
/** JSDoc */
|
|
function splitPath(filename) {
|
|
// Truncate files names greater than 1024 characters to avoid regex dos
|
|
// https://github.com/getsentry/sentry-javascript/pull/8737#discussion_r1285719172
|
|
const truncated = filename.length > 1024 ? `<truncated>${filename.slice(-1024)}` : filename;
|
|
const parts = splitPathRe.exec(truncated);
|
|
return parts ? parts.slice(1) : [];
|
|
}
|
|
|
|
// path.resolve([from ...], to)
|
|
// posix version
|
|
/** JSDoc */
|
|
function resolve(...args) {
|
|
let resolvedPath = '';
|
|
let resolvedAbsolute = false;
|
|
|
|
for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
|
|
const path = i >= 0 ? args[i] : '/';
|
|
|
|
// Skip empty entries
|
|
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(p => !!p),
|
|
!resolvedAbsolute,
|
|
).join('/');
|
|
|
|
return (resolvedAbsolute ? '/' : '') + resolvedPath || '.';
|
|
}
|
|
|
|
/** JSDoc */
|
|
function trim(arr) {
|
|
let start = 0;
|
|
for (; start < arr.length; start++) {
|
|
if (arr[start] !== '') {
|
|
break;
|
|
}
|
|
}
|
|
|
|
let end = arr.length - 1;
|
|
for (; end >= 0; end--) {
|
|
if (arr[end] !== '') {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (start > end) {
|
|
return [];
|
|
}
|
|
return arr.slice(start, end - start + 1);
|
|
}
|
|
|
|
// path.relative(from, to)
|
|
// posix version
|
|
/** JSDoc */
|
|
function relative(from, to) {
|
|
/* eslint-disable no-param-reassign */
|
|
from = resolve(from).slice(1);
|
|
to = resolve(to).slice(1);
|
|
/* eslint-enable no-param-reassign */
|
|
|
|
const fromParts = trim(from.split('/'));
|
|
const toParts = trim(to.split('/'));
|
|
|
|
const length = Math.min(fromParts.length, toParts.length);
|
|
let samePartsLength = length;
|
|
for (let i = 0; i < length; i++) {
|
|
if (fromParts[i] !== toParts[i]) {
|
|
samePartsLength = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
let outputParts = [];
|
|
for (let i = samePartsLength; i < fromParts.length; i++) {
|
|
outputParts.push('..');
|
|
}
|
|
|
|
outputParts = outputParts.concat(toParts.slice(samePartsLength));
|
|
|
|
return outputParts.join('/');
|
|
}
|
|
|
|
// path.normalize(path)
|
|
// posix version
|
|
/** JSDoc */
|
|
function normalizePath(path) {
|
|
const isPathAbsolute = isAbsolute(path);
|
|
const trailingSlash = path.slice(-1) === '/';
|
|
|
|
// Normalize the path
|
|
let normalizedPath = normalizeArray(
|
|
path.split('/').filter(p => !!p),
|
|
!isPathAbsolute,
|
|
).join('/');
|
|
|
|
if (!normalizedPath && !isPathAbsolute) {
|
|
normalizedPath = '.';
|
|
}
|
|
if (normalizedPath && trailingSlash) {
|
|
normalizedPath += '/';
|
|
}
|
|
|
|
return (isPathAbsolute ? '/' : '') + normalizedPath;
|
|
}
|
|
|
|
// posix version
|
|
/** JSDoc */
|
|
function isAbsolute(path) {
|
|
return path.charAt(0) === '/';
|
|
}
|
|
|
|
// posix version
|
|
/** JSDoc */
|
|
function join(...args) {
|
|
return normalizePath(args.join('/'));
|
|
}
|
|
|
|
/** JSDoc */
|
|
function dirname(path) {
|
|
const result = splitPath(path);
|
|
const root = result[0];
|
|
let dir = result[1];
|
|
|
|
if (!root && !dir) {
|
|
// No dirname whatsoever
|
|
return '.';
|
|
}
|
|
|
|
if (dir) {
|
|
// It has a dirname, strip trailing slash
|
|
dir = dir.slice(0, dir.length - 1);
|
|
}
|
|
|
|
return root + dir;
|
|
}
|
|
|
|
/** JSDoc */
|
|
function basename(path, ext) {
|
|
let f = splitPath(path)[2];
|
|
if (ext && f.slice(ext.length * -1) === ext) {
|
|
f = f.slice(0, f.length - ext.length);
|
|
}
|
|
return f;
|
|
}
|
|
|
|
export { basename, dirname, isAbsolute, join, normalizePath, relative, resolve };
|
|
//# sourceMappingURL=path.js.map
|