one/dist/cjs/platform/file-system/paths.native.cjs

One is a React framework for web, iOS, and Android apps.

"use strict";

var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
	for (var name in all) __defProp(target, name, {
		get: all[name],
		enumerable: true
	});
};
var __copyProps = (to, from, except, desc) => {
	if (from && typeof from === "object" || typeof from === "function") {
		for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
			get: () => from[key],
			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
		});
	}
	return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var paths_exports = {};
__export(paths_exports, { PathUtilities: () => PathUtilities });
module.exports = __toCommonJS(paths_exports);
function _class_call_check(instance, Constructor) {
	if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
}
function _defineProperties(target, props) {
	for (var i = 0; i < props.length; i++) {
		var descriptor = props[i];
		descriptor.enumerable = descriptor.enumerable || false;
		descriptor.configurable = true;
		if ("value" in descriptor) descriptor.writable = true;
		Object.defineProperty(target, descriptor.key, descriptor);
	}
}
function _create_class(Constructor, protoProps, staticProps) {
	if (protoProps) _defineProperties(Constructor.prototype, protoProps);
	if (staticProps) _defineProperties(Constructor, staticProps);
	return Constructor;
}
function uriObjectToString(path) {
	return typeof path === "string" ? path : path.uri;
}
function isPathSeparator(code) {
	return code === "/";
}
function normalizeString(path, allowAboveRoot, separator) {
	var res = "";
	var lastSegmentLength = 0;
	var lastSlash = -1;
	var dots = 0;
	var code = "";
	for (var i = 0; i <= path.length; ++i) {
		if (i < path.length) code = path.charAt(i);
		else if (isPathSeparator(code)) break;
		else code = "/";
		if (isPathSeparator(code)) {
			if (lastSlash === i - 1 || dots === 1) {} else if (dots === 2) {
				if (res.length < 2 || lastSegmentLength !== 2 || res.charAt(res.length - 1) !== "." || res.charAt(res.length - 2) !== ".") {
					if (res.length > 2) {
						var lastSlashIndex = res.lastIndexOf(separator);
						if (lastSlashIndex === -1) {
							res = "";
							lastSegmentLength = 0;
						} else {
							res = res.slice(0, lastSlashIndex);
							lastSegmentLength = res.length - 1 - res.lastIndexOf(separator);
						}
						lastSlash = i;
						dots = 0;
						continue;
					} else if (res.length !== 0) {
						res = "";
						lastSegmentLength = 0;
						lastSlash = i;
						dots = 0;
						continue;
					}
				}
				if (allowAboveRoot) {
					res += res.length > 0 ? `${separator}..` : "..";
					lastSegmentLength = 2;
				}
			} else {
				if (res.length > 0) res += `${separator}${path.slice(lastSlash + 1, i)}`;
				else res = path.slice(lastSlash + 1, i);
				lastSegmentLength = i - lastSlash - 1;
			}
			lastSlash = i;
			dots = 0;
		} else if (code === "." && dots !== -1) {
			++dots;
		} else {
			dots = -1;
		}
	}
	return res;
}
function resolvePath() {
	for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
		args[_key] = arguments[_key];
	}
	var resolvedPath = "";
	var resolvedAbsolute = false;
	for (var i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
		var path = i >= 0 ? args[i] : "";
		if (!path || path.length === 0) continue;
		resolvedPath = `${path}/${resolvedPath}`;
		resolvedAbsolute = !!(path && path.charAt(0) === "/");
	}
	resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute, "/");
	if (resolvedAbsolute) return `/${resolvedPath}`;
	return resolvedPath.length > 0 ? resolvedPath : ".";
}
function normalizePath(path) {
	if (path.length === 0) return ".";
	var isAbsolute = path.charAt(0) === "/";
	var trailingSeparator = path.charAt(path.length - 1) === "/";
	path = normalizeString(path, !isAbsolute, "/");
	if (path.length === 0) {
		if (isAbsolute) return "/";
		return trailingSeparator ? "./" : ".";
	}
	if (trailingSeparator) path += "/";
	return isAbsolute ? `/${path}` : path;
}
function isAbsolutePath(path) {
	return path.length > 0 && path.charAt(0) === "/";
}
function joinPaths() {
	for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
		args[_key] = arguments[_key];
	}
	if (args.length === 0) return ".";
	var path = [];
	var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
	try {
		for (var _iterator = args[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
			var arg = _step.value;
			if (arg && arg.length > 0) path.push(arg);
		}
	} catch (err) {
		_didIteratorError = true;
		_iteratorError = err;
	} finally {
		try {
			if (!_iteratorNormalCompletion && _iterator.return != null) {
				_iterator.return();
			}
		} finally {
			if (_didIteratorError) {
				throw _iteratorError;
			}
		}
	}
	if (path.length === 0) return ".";
	return normalizePath(path.join("/"));
}
function relativePaths(from, to) {
	if (from === to) return "";
	from = resolvePath(from);
	to = resolvePath(to);
	if (from === to) return "";
	var fromStart = 1;
	var fromEnd = from.length;
	var fromLen = fromEnd - fromStart;
	var toStart = 1;
	var toLen = to.length - toStart;
	var length = fromLen < toLen ? fromLen : toLen;
	var lastCommonSep = -1;
	var i = 0;
	for (; i < length; i++) {
		var fromChar = from.charAt(fromStart + i);
		if (fromChar !== to.charAt(toStart + i)) break;
		else if (fromChar === "/") lastCommonSep = i;
	}
	if (i === length) {
		if (toLen > length) {
			if (to.charAt(toStart + i) === "/") return to.slice(toStart + i + 1);
			if (i === 0) return to.slice(toStart + i);
		} else if (fromLen > length) {
			if (from.charAt(fromStart + i) === "/") lastCommonSep = i;
			else if (i === 0) lastCommonSep = 0;
		}
	}
	var out = "";
	for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
		if (i === fromEnd || from.charAt(i) === "/") {
			out += out.length === 0 ? ".." : "/..";
		}
	}
	return `${out}${to.slice(toStart + lastCommonSep)}`;
}
function dirnamePath(path) {
	if (path.length === 0) return ".";
	var hasRoot = path.charAt(0) === "/";
	var end = -1;
	var matchedSlash = true;
	for (var i = path.length - 1; i >= 1; --i) {
		if (path.charAt(i) === "/") {
			if (!matchedSlash) {
				end = i;
				break;
			}
		} else {
			matchedSlash = false;
		}
	}
	if (end === -1) return hasRoot ? "/" : ".";
	if (hasRoot && end === 1) return "//";
	return path.slice(0, end);
}
function basenamePath(path, suffix) {
	var start = 0;
	var end = -1;
	var matchedSlash = true;
	if (suffix !== void 0 && suffix.length > 0 && suffix.length <= path.length) {
		if (suffix === path) return "";
		var extIdx = suffix.length - 1;
		var firstNonSlashEnd = -1;
		for (var i = path.length - 1; i >= 0; --i) {
			var code = path.charAt(i);
			if (code === "/") {
				if (!matchedSlash) {
					start = i + 1;
					break;
				}
			} else {
				if (firstNonSlashEnd === -1) {
					matchedSlash = false;
					firstNonSlashEnd = i + 1;
				}
				if (extIdx >= 0) {
					if (code === suffix.charAt(extIdx)) {
						if (--extIdx === -1) end = i;
					} else {
						extIdx = -1;
						end = firstNonSlashEnd;
					}
				}
			}
		}
		if (start === end) end = firstNonSlashEnd;
		else if (end === -1) end = path.length;
		return path.slice(start, end);
	}
	for (var i1 = path.length - 1; i1 >= 0; --i1) {
		if (path.charAt(i1) === "/") {
			if (!matchedSlash) {
				start = i1 + 1;
				break;
			}
		} else if (end === -1) {
			matchedSlash = false;
			end = i1 + 1;
		}
	}
	if (end === -1) return "";
	return path.slice(start, end);
}
function extnamePath(path) {
	var startDot = -1;
	var startPart = 0;
	var end = -1;
	var matchedSlash = true;
	var preDotState = 0;
	for (var i = path.length - 1; i >= 0; --i) {
		var code = path.charAt(i);
		if (code === "/") {
			if (!matchedSlash) {
				startPart = i + 1;
				break;
			}
			continue;
		}
		if (end === -1) {
			matchedSlash = false;
			end = i + 1;
		}
		if (code === ".") {
			if (startDot === -1) startDot = i;
			else if (preDotState !== 1) preDotState = 1;
		} else if (startDot !== -1) {
			preDotState = -1;
		}
	}
	if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
		return "";
	}
	return path.slice(startDot, end);
}
function parsePath(path) {
	var ret = {
		root: "",
		dir: "",
		base: "",
		ext: "",
		name: ""
	};
	if (path.length === 0) return ret;
	var isAbsolute = path.charAt(0) === "/";
	var start;
	if (isAbsolute) {
		ret.root = "/";
		start = 1;
	} else {
		start = 0;
	}
	var startDot = -1;
	var startPart = 0;
	var end = -1;
	var matchedSlash = true;
	var i = path.length - 1;
	var preDotState = 0;
	for (; i >= start; --i) {
		var code = path.charAt(i);
		if (code === "/") {
			if (!matchedSlash) {
				startPart = i + 1;
				break;
			}
			continue;
		}
		if (end === -1) {
			matchedSlash = false;
			end = i + 1;
		}
		if (code === ".") {
			if (startDot === -1) startDot = i;
			else if (preDotState !== 1) preDotState = 1;
		} else if (startDot !== -1) {
			preDotState = -1;
		}
	}
	if (end !== -1) {
		var baseStart = startPart === 0 && isAbsolute ? 1 : startPart;
		if (startDot === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
			ret.base = ret.name = path.slice(baseStart, end);
		} else {
			ret.name = path.slice(baseStart, startDot);
			ret.base = path.slice(baseStart, end);
			ret.ext = path.slice(startDot, end);
		}
	}
	if (startPart > 0) ret.dir = path.slice(0, startPart - 1);
	else if (isAbsolute) ret.dir = "/";
	return ret;
}
var percentRegEx = /%/g;
var backslashRegEx = /\\/g;
var newlineRegEx = /\n/g;
var carriageReturnRegEx = /\r/g;
var tabRegEx = /\t/g;
var questionRegex = /\?/g;
var hashRegex = /#/g;
var spaceRegEx = / /g;
function encodePathChars(filepath) {
	if (filepath.indexOf("%") !== -1) filepath = filepath.replace(percentRegEx, "%25");
	if (filepath.indexOf("\\") !== -1) filepath = filepath.replace(backslashRegEx, "%5C");
	if (filepath.indexOf("\n") !== -1) filepath = filepath.replace(newlineRegEx, "%0A");
	if (filepath.indexOf("\r") !== -1) filepath = filepath.replace(carriageReturnRegEx, "%0D");
	if (filepath.indexOf("	") !== -1) filepath = filepath.replace(tabRegEx, "%09");
	if (filepath.indexOf(" ") !== -1) filepath = filepath.replace(spaceRegEx, "%20");
	return filepath;
}
function encodeURLChars(path) {
	var resolved = resolvePath(path);
	var filePathLast = path.charAt(path.length - 1);
	if (filePathLast === "/" && resolved[resolved.length - 1] !== "/") resolved += "/";
	resolved = encodePathChars(resolved);
	if (resolved.indexOf("?") !== -1) resolved = resolved.replace(questionRegex, "%3F");
	if (resolved.indexOf("#") !== -1) resolved = resolved.replace(hashRegex, "%23");
	return resolved;
}
function isUrl(url) {
	try {
		return !!new URL(url);
	} catch (unused) {
		return false;
	}
}
function asUrl(url) {
	try {
		var parsed = new URL(url);
		parsed.hash = "";
		return parsed;
	} catch (unused) {
		return null;
	}
}
var PathUtilities = /* @__PURE__ */ (function() {
	"use strict";
	function PathUtilities2() {
		_class_call_check(this, PathUtilities2);
	}
	_create_class(PathUtilities2, null, [
		{
			key: "join",
			value: function join() {
				for (var _len = arguments.length, paths = new Array(_len), _key = 0; _key < _len; _key++) {
					paths[_key] = arguments[_key];
				}
				var [firstSegment = "", ...rest] = paths.map(uriObjectToString);
				var pathAsUrl = asUrl(firstSegment);
				if (pathAsUrl) {
					pathAsUrl.pathname = joinPaths(pathAsUrl.pathname, ...rest.map(encodeURLChars));
					return pathAsUrl.toString();
				}
				return joinPaths(firstSegment, ...rest.map(encodeURLChars));
			}
		},
		{
			key: "relative",
			value: function relative(from, to) {
				var _ref, _ref1;
				var _asUrl, _asUrl1;
				var fromString = uriObjectToString(from);
				var toString = uriObjectToString(to);
				var fromPath = isUrl(fromString) ? (_ref = (_asUrl = asUrl(fromString)) === null || _asUrl === void 0 ? void 0 : _asUrl.pathname) !== null && _ref !== void 0 ? _ref : fromString : fromString;
				var toPath = isUrl(toString) ? (_ref1 = (_asUrl1 = asUrl(toString)) === null || _asUrl1 === void 0 ? void 0 : _asUrl1.pathname) !== null && _ref1 !== void 0 ? _ref1 : toString : toString;
				return relativePaths(fromPath, toPath);
			}
		},
		{
			key: "isAbsolute",
			value: function isAbsolute(path) {
				var pathString = uriObjectToString(path);
				if (isUrl(pathString)) return true;
				return isAbsolutePath(pathString);
			}
		},
		{
			key: "normalize",
			value: function normalize(path) {
				var pathString = uriObjectToString(path);
				var pathURL = asUrl(encodeURLChars(pathString));
				if (pathURL) {
					pathURL.pathname = encodeURLChars(normalizePath(decodeURIComponent(pathURL.pathname)));
					return pathURL.toString();
				}
				return normalizePath(pathString);
			}
		},
		{
			key: "dirname",
			value: function dirname(path) {
				var pathString = uriObjectToString(path);
				var pathURL = asUrl(pathString);
				if (pathURL) {
					pathURL.pathname = encodeURLChars(dirnamePath(decodeURIComponent(pathURL.pathname)));
					return pathURL.toString();
				}
				return dirnamePath(pathString);
			}
		},
		{
			key: "basename",
			value: function basename(path, ext) {
				var pathString = uriObjectToString(path);
				var pathURL = asUrl(pathString);
				if (pathURL) return basenamePath(decodeURIComponent(pathURL.pathname));
				return basenamePath(pathString, ext);
			}
		},
		{
			key: "extname",
			value: function extname(path) {
				var pathString = uriObjectToString(path);
				var pathURL = asUrl(pathString);
				if (pathURL) return extnamePath(decodeURIComponent(pathURL.pathname));
				return extnamePath(pathString);
			}
		},
		{
			key: "parse",
			value: function parse(path) {
				var pathString = uriObjectToString(path);
				var pathURL = asUrl(pathString);
				if (pathURL) return parsePath(decodeURIComponent(pathURL.pathname));
				return parsePath(pathString);
			}
		}
	]);
	return PathUtilities2;
})();