alinea/dist/core/util/Paths.js

[](https://npmjs.org/package/alinea) [](https://packagephobia.com/result?p=alinea)

import "../../chunks/chunk-U5RRZUYZ.js";

// src/core/util/Paths.ts
var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
function posixSplitPath(filename) {
  return splitPathRe.exec(filename).slice(1);
}
function normalizeArray(parts, allowAboveRoot) {
  var res = [];
  for (var i = 0; i < parts.length; i++) {
    var p = parts[i];
    if (!p || p === ".")
      continue;
    if (p === "..") {
      if (res.length && res[res.length - 1] !== "..") {
        res.pop();
      } else if (allowAboveRoot) {
        res.push("..");
      }
    } else {
      res.push(p);
    }
  }
  return res;
}
function isAbsolute(path) {
  return path.charAt(0) === "/";
}
function normalize(path) {
  path = path.replace(/\\/g, "/");
  var absolute = isAbsolute(path), trailingSlash = path && path[path.length - 1] === "/";
  path = normalizeArray(path.split("/"), !absolute).join("/");
  if (!path && !absolute) {
    path = ".";
  }
  if (path && trailingSlash) {
    path += "/";
  }
  return (absolute ? "/" : "") + path;
}
function dirname(path) {
  var result = posixSplitPath(path), root = result[0], dir = result[1];
  if (!root && !dir) {
    return ".";
  }
  if (dir) {
    dir = dir.substr(0, dir.length - 1);
  }
  return root + dir;
}
function basename(path, ext) {
  var f = posixSplitPath(path)[2];
  if (ext && f.substr(-1 * ext.length) === ext) {
    f = f.substr(0, f.length - ext.length);
  }
  return f;
}
function join(...args) {
  var path = "";
  for (var i = 0; i < args.length; i++) {
    var segment = args[i];
    if (typeof segment !== "string") {
      continue;
    }
    if (segment) {
      if (!path) {
        path += segment;
      } else {
        path += "/" + segment;
      }
    }
  }
  return normalize(path);
}
function extname(path) {
  return posixSplitPath(path)[3];
}
function trimArray(arr) {
  var lastIndex = arr.length - 1;
  var start = 0;
  for (; start <= lastIndex; start++) {
    if (arr[start])
      break;
  }
  var end = lastIndex;
  for (; end >= 0; end--) {
    if (arr[end])
      break;
  }
  if (start === 0 && end === lastIndex)
    return arr;
  if (start > end)
    return [];
  return arr.slice(start, end + 1);
}
function resolve(...args) {
  var resolvedPath = "", resolvedAbsolute = false;
  for (var i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
    var path = i >= 0 ? args[i] : process.cwd();
    if (typeof path !== "string") {
      throw new TypeError("Arguments to path.resolve must be strings");
    } else if (!path) {
      continue;
    }
    resolvedPath = path + "/" + resolvedPath;
    resolvedAbsolute = path[0] === "/";
  }
  resolvedPath = normalizeArray(
    resolvedPath.split("/"),
    !resolvedAbsolute
  ).join("/");
  return (resolvedAbsolute ? "/" : "") + resolvedPath || ".";
}
function relative(from, to) {
  from = resolve(from).substr(1);
  to = resolve(to).substr(1);
  var fromParts = trimArray(from.split("/"));
  var toParts = trimArray(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("/");
}
function contains(parent, child) {
  parent = normalize(parent);
  child = normalize(child);
  const asRelative = relative(parent, child);
  const isSubdir = asRelative && !asRelative.startsWith("..") && !isAbsolute(asRelative);
  return Boolean(isSubdir);
}
export {
  basename,
  contains,
  dirname,
  extname,
  isAbsolute,
  join,
  normalize,
  relative,
  resolve
};