alinea/dist/core/util/Paths.js

Headless git-based CMS

import "../../chunks/chunk-NZLE2WMY.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) {
  const res = [];
  for (let i = 0; i < parts.length; i++) {
    const 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, "/");
  const absolute = isAbsolute(path);
  const 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) {
  const result = posixSplitPath(path);
  const root = result[0];
  let dir = result[1];
  if (!root && !dir) {
    return ".";
  }
  if (dir) {
    dir = dir.substr(0, dir.length - 1);
  }
  return root + dir;
}
function basename(path, ext) {
  let 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) {
  let path = "";
  for (let i = 0; i < args.length; i++) {
    const 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) {
  const lastIndex = arr.length - 1;
  let start = 0;
  for (; start <= lastIndex; start++) {
    if (arr[start]) break;
  }
  let 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) {
  let resolvedPath = "";
  let resolvedAbsolute = false;
  for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
    const path = i >= 0 ? args[i] : process.cwd();
    if (typeof path !== "string") {
      throw new TypeError("Arguments to path.resolve must be strings");
    }
    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);
  const fromParts = trimArray(from.split("/"));
  const toParts = trimArray(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("/");
}
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
};