@gesslar/toolkit 3.16.1 → 3.19.0

package/package.json

@@ -5,7 +5,7 @@
     "name": "gesslar",
     "url": "https://gesslar.dev"
   },
-  "version": "3.16.1",
+  "version": "3.19.0",
   "license": "Unlicense",
   "homepage": "https://github.com/gesslar/toolkit#readme",
   "repository": {
@@ -60,7 +60,7 @@
   "devDependencies": {
     "@gesslar/uglier": "^0.6.0",
     "eslint": "^9.39.2",
-    "happy-dom": "^20.0.11",
+    "happy-dom": "^20.1.0",
     "typescript": "^5.9.3"
   },
   "scripts": {

package/src/node/index.js

@@ -17,7 +17,7 @@ export {default as Util} from "./lib/Util.js"
 export {default as Cache} from "./lib/Cache.js"
 export {default as DirectoryObject} from "./lib/DirectoryObject.js"
 export {default as FileObject} from "./lib/FileObject.js"
-export {default as FS} from "./lib/FileSystem.js"
+export {default as FileSystem} from "./lib/FileSystem.js"
 export {default as Glog} from "./lib/Glog.js"
 export {default as Notify} from "./lib/Notify.js"
 export {default as TempDirectoryObject} from "./lib/TempDirectoryObject.js"

package/src/node/lib/DirectoryObject.js

@@ -318,13 +318,6 @@ export default class DirectoryObject extends FS {
         glob(pat, {
           cwd: this.isVirtual ? this.real?.path : this.path,
           withFileTypes,
-          // exclude: candidate => {
-          // // Only allow entries within this directory's URL
-          //   const candidateHref = candidate.url.href
-
-          //   // Must start with our URL + path separator, or be exactly our URL
-          //   return !candidateHref.startsWith(href + "/") && candidateHref !== href
-          // }
         })
       )
 
@@ -343,6 +336,65 @@ export default class DirectoryObject extends FS {
     return {files, directories}
   }
 
+  /**
+   * Recursively searches directory tree for files and directories matching a glob pattern.
+   * Unlike read(), this method searches recursively through subdirectories.
+   *
+   * Returns FileObject and DirectoryObject instances for regular directories.
+   * Returns VFileObject and VDirectoryObject instances when called on virtual directories.
+   *
+   * @async
+   * @param {string} [pat=""] - Glob pattern to filter results
+   * @returns {Promise<{files: Array<FileObject|VFileObject>, directories: Array<DirectoryObject|VDirectoryObject>}>} Object containing arrays of matching files and directories
+   * @throws {Sass} If an entry is neither a file nor directory
+   * @example
+   * const dir = new DirectoryObject("./src")
+   * const {files} = await dir.glob("**\/*.test.js")
+   * console.log(files) // All .test.js files in ./src and subdirectories
+   *
+   * @example
+   * // Find all package.json files recursively
+   * const {files} = await dir.glob("**\/package.json")
+   */
+  async glob(pat="") {
+    const withFileTypes = true
+    const found = await Array.fromAsync(
+      glob(pat, {
+        cwd: this.isVirtual ? this.real?.path : this.path,
+        withFileTypes,
+      })
+    )
+
+    const files = [], directories = []
+    const virtual = this.isVirtual
+
+    for(const e of found) {
+      if(e.isFile()) {
+        const {name, parentPath} = e
+        const resolved = FS.resolvePath(parentPath, name)
+
+        const file = virtual
+          ? new VFileObject(path.relative(this.real.path, resolved), this)
+          : new FileObject(resolved, this)
+
+        files.push(file)
+      } else if(e.isDirectory()) {
+        const {name, parentPath} = e
+        const resolved = FS.resolvePath(parentPath, name)
+        const relativePath = virtual
+          ? path.relative(this.real.path, resolved)
+          : resolved
+        const directory = new this.constructor(relativePath, this)
+
+        directories.push(directory)
+      } else {
+        throw Sass.new(`wtf is this? ${e}`)
+      }
+    }
+
+    return {files, directories}
+  }
+
   /**
    * Ensures a directory exists, creating it if necessary.
    * Gracefully handles the case where the directory already exists.

package/src/node/lib/FileObject.js

@@ -69,6 +69,24 @@ export default class FileObject extends FS {
     parentPath: null,
   })
 
+  /**
+   * Strip root from absolute path to make it relative.
+   * Used for virtual filesystem path resolution.
+   *
+   * @private
+   * @static
+   * @param {string} pathName - The path to convert
+   * @returns {string} Path with root stripped, or original if already relative
+   */
+  static #absoluteToRelative(pathName) {
+    if(!path.isAbsolute(pathName))
+      return pathName
+
+    const {root} = FS.pathParts(pathName)
+
+    return Data.chopLeft(pathName, root)
+  }
+
   /**
    * Constructs a FileObject instance.
    *
@@ -82,40 +100,41 @@ export default class FileObject extends FS {
     Valid.type(parent, "Null|String|DirectoryObject", {allowEmpty: false})
 
     const normalizedFile = FS.fixSlashes(submitted)
-    const absOrRel = path.isAbsolute(normalizedFile) && parent
-      ? FS.absoluteToRelative(normalizedFile, true)
+    const absOrRelPath = path.isAbsolute(normalizedFile) && parent
+      ? FileObject.#absoluteToRelative(normalizedFile)
       : normalizedFile
-    const {dir, base, ext, name} = FS.pathParts(absOrRel)
+    const {dir, base, ext, name} = FS.pathParts(absOrRelPath)
 
     const [parentObject, fullPath] = (() => {
       if(Data.isType(parent, "String")) {
-        const joined = FS.resolvePath(parent, absOrRel)
-        const {dir} = FS.pathParts(joined)
+        const resolved = FS.resolvePath(parent, absOrRelPath)
+        const {dir} = FS.pathParts(resolved)
 
         return [
           new DirectoryObject(dir),
-          joined,
+          resolved,
         ]
       }
 
       if(Data.isType(parent, "DirectoryObject")) {
-        const joined = FS.resolvePath(parent.path, absOrRel)
-        const {dir} = FS.pathParts(joined)
+        const parentPath = parent.path
+        const resolved = FS.resolvePath(parentPath, absOrRelPath)
+        const parts = FS.pathParts(resolved)
 
         return [
-          parent.path === dir
+          parent.path === parts.dir
             ? parent
-            : new DirectoryObject(dir),
-          joined,
+            : new parent.constructor(parts.dir, parent),
+          resolved,
         ]
       }
 
       const directory = new DirectoryObject(dir)
-      const joined = FS.resolvePath(directory.path, absOrRel)
+      const resolved = FS.resolvePath(directory.path, absOrRelPath)
 
       return [
         directory,
-        joined,
+        resolved,
       ]
     })()
 
@@ -236,6 +255,11 @@ export default class FileObject extends FS {
     return this.#meta.parent
   }
 
+  /**
+   * Returns the absolute path of the parent directory.
+   *
+   * @returns {string} The parent directory path
+   */
   get parentPath() {
     return this.#meta.parentPath
   }

package/src/node/lib/FileSystem.js

@@ -49,7 +49,7 @@ export default class FileSystem {
       1
     )
 
-    return FileSystem.relativeOrAbsolutePath(fileOrDirectoryObject, this)
+    return FileSystem.relativeOrAbsolute(fileOrDirectoryObject, this)
   }
 
   /**
@@ -104,7 +104,7 @@ export default class FileSystem {
    * @param {FileObject|DirectoryObject} to - The target file or directory object
    * @returns {string} The relative path from `from` to `to`, or the absolute path if not reachable
    */
-  static relativeOrAbsolutePath(from, to) {
+  static relativeOrAbsolute(from, to) {
     const fromBasePath = from.isDirectory
       ? from.path
       : from.parent?.path ?? path.dirname(from.path)
@@ -116,6 +116,25 @@ export default class FileSystem {
       : relative
   }
 
+  /**
+   * Computes the relative path from one file or directory to another.
+   *
+   * If the target is outside the source (i.e., the relative path starts with
+   * ".."), returns the absolute path to the target instead.
+   *
+   * @static
+   * @param {string} from - The source file or directory object
+   * @param {string} to - The target file or directory object
+   * @returns {string} The relative path from `from` to `to`, or the absolute path if not reachable
+   */
+  static relativeOrAbsolutePath(from, to) {
+    const relative = path.relative(from, to)
+
+    return relative.startsWith("..")
+      ? to
+      : relative
+  }
+
   /**
    * Merge two paths by finding overlapping segments and combining them
    * efficiently
@@ -356,32 +375,4 @@ export default class FileSystem {
 
     return this.resolvePath(cap, target)
   }
-
-  /**
-   * Convert an absolute path to a relative format by removing the root component.
-   * By default, keeps a leading separator (making it "absolute-like relative").
-   * Use forceActuallyRelative to get a truly relative path without leading separator.
-   *
-   * @static
-   * @param {string} pathToCheck - The path to convert (returned unchanged if already relative)
-   * @param {boolean} [forceActuallyRelative=false] - If true, removes leading separator for truly relative path
-   * @returns {string} The relative path (with or without leading separator based on forceActuallyRelative)
-   * @example
-   * FS.absoluteToRelative("/home/user/docs") // "/home/user/docs" (with leading /)
-   * FS.absoluteToRelative("/home/user/docs", true) // "home/user/docs" (truly relative)
-   * FS.absoluteToRelative("relative/path") // "relative/path" (unchanged)
-   */
-  static absoluteToRelative(pathToCheck, forceActuallyRelative=false) {
-    if(!path.isAbsolute(pathToCheck))
-      return pathToCheck
-
-    const {root} = this.pathParts(pathToCheck)
-    const sep = path.sep
-    const chopped = Data.chopLeft(pathToCheck, root)
-    const absolute = forceActuallyRelative
-      ? chopped
-      : Data.prepend(chopped, sep)
-
-    return absolute
-  }
 }

package/src/node/lib/VFileObject.js

@@ -44,11 +44,10 @@ export default class VFileObject extends FileObject {
     super(fileName, parent)
 
     const parentRealPath = this.parent.real.path
-    const relative = FS.absoluteToRelative(this.path, true)
-    const resolved = FS.resolvePath(parentRealPath, relative)
-    const {base, dir} = FS.pathParts(resolved)
+    const resolved = FS.resolvePath(this.parent.path, fileName)
+    const {base} = FS.pathParts(resolved)
 
-    this.#real = new FileObject(base, dir)
+    this.#real = new FileObject(base, parentRealPath)
   }
 
   get isVirtual() {

package/types/node/index.d.ts

@@ -10,7 +10,7 @@ export { default as Util } from "./lib/Util.js";
 export { default as Cache } from "./lib/Cache.js";
 export { default as DirectoryObject } from "./lib/DirectoryObject.js";
 export { default as FileObject } from "./lib/FileObject.js";
-export { default as FS } from "./lib/FileSystem.js";
+export { default as FileSystem } from "./lib/FileSystem.js";
 export { default as Glog } from "./lib/Glog.js";
 export { default as Notify } from "./lib/Notify.js";
 export { default as TempDirectoryObject } from "./lib/TempDirectoryObject.js";

package/types/node/lib/DirectoryObject.d.ts

@@ -162,6 +162,30 @@ export default class DirectoryObject extends FS {
         files: Array<FileObject | VFileObject>;
         directories: Array<DirectoryObject | VDirectoryObject>;
     }>;
+    /**
+     * Recursively searches directory tree for files and directories matching a glob pattern.
+     * Unlike read(), this method searches recursively through subdirectories.
+     *
+     * Returns FileObject and DirectoryObject instances for regular directories.
+     * Returns VFileObject and VDirectoryObject instances when called on virtual directories.
+     *
+     * @async
+     * @param {string} [pat=""] - Glob pattern to filter results
+     * @returns {Promise<{files: Array<FileObject|VFileObject>, directories: Array<DirectoryObject|VDirectoryObject>}>} Object containing arrays of matching files and directories
+     * @throws {Sass} If an entry is neither a file nor directory
+     * @example
+     * const dir = new DirectoryObject("./src")
+     * const {files} = await dir.glob("**\/*.test.js")
+     * console.log(files) // All .test.js files in ./src and subdirectories
+     *
+     * @example
+     * // Find all package.json files recursively
+     * const {files} = await dir.glob("**\/package.json")
+     */
+    glob(pat?: string): Promise<{
+        files: Array<FileObject | VFileObject>;
+        directories: Array<DirectoryObject | VDirectoryObject>;
+    }>;
     /**
      * Ensures a directory exists, creating it if necessary.
      * Gracefully handles the case where the directory already exists.

package/types/node/lib/DirectoryObject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DirectoryObject.d.ts","sourceRoot":"","sources":["../../../src/node/lib/DirectoryObject.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH;IA2DE;;;;;;;;;OASG;IACH,kBALa,eAAe,CAO3B;IA3CD;;;;OAIG;IACH,uBAFW,MAAM,OAAC,EA0BjB;IA2BD;;;;OAIG;IACH,cAFa,OAAO,CAAC,OAAO,CAAC,CAI5B;IAED;;;;OAIG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,GAAG,CAIf;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,cAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,MAAM,CAIlB;IAED;;;;;;;OAOG;IACH,aALa,KAAK,CAAC,MAAM,CAAC,CAOzB;IAED;;;;;;;;;;;;OAYG;IACH,cARa,eAAe,GAAC,IAAI,CAsBhC;IAED;;;;OAIG;IACH,mBAFa,OAAO,CAInB;IAmBD;;;;;;;;;;;;;;;;;;OAkBG;IACH,WAZW,MAAM,GACJ,OAAO,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC,UAAU,GAAC,WAAW,CAAC,CAAC;QAAC,WAAW,EAAE,KAAK,CAAC,eAAe,GAAC,gBAAgB,CAAC,CAAA;KAAC,CAAC,CAiDjH;IAED;;;;;;;;;;;;OAYG;IACH,uBARW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAuBzB;IAyBD;;;;;;;;;;;;;;;OAeG;IACH,cAZa,eAAe,CAc3B;IAED;;;;;;;;;;;;;;OAcG;IACH,UARa,OAAO,CAAC,IAAI,CAAC,CAkBzB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAQ5B;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAO5B;IAUD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,kBAdW,MAAM,GACJ,eAAe,CAqB3B;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAbW,MAAM,GACJ,UAAU,GAAC,WAAW,CAsBlC;;CACF;eAvhBc,iBAAiB;uBACT,iBAAiB;wBAGhB,kBAAkB"}
+{"version":3,"file":"DirectoryObject.d.ts","sourceRoot":"","sources":["../../../src/node/lib/DirectoryObject.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH;IA2DE;;;;;;;;;OASG;IACH,kBALa,eAAe,CAO3B;IA3CD;;;;OAIG;IACH,uBAFW,MAAM,OAAC,EA0BjB;IA2BD;;;;OAIG;IACH,cAFa,OAAO,CAAC,OAAO,CAAC,CAI5B;IAED;;;;OAIG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,GAAG,CAIf;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,cAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,MAAM,CAIlB;IAED;;;;;;;OAOG;IACH,aALa,KAAK,CAAC,MAAM,CAAC,CAOzB;IAED;;;;;;;;;;;;OAYG;IACH,cARa,eAAe,GAAC,IAAI,CAsBhC;IAED;;;;OAIG;IACH,mBAFa,OAAO,CAInB;IAmBD;;;;;;;;;;;;;;;;;;OAkBG;IACH,WAZW,MAAM,GACJ,OAAO,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC,UAAU,GAAC,WAAW,CAAC,CAAC;QAAC,WAAW,EAAE,KAAK,CAAC,eAAe,GAAC,gBAAgB,CAAC,CAAA;KAAC,CAAC,CA0CjH;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,WAZW,MAAM,GACJ,OAAO,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC,UAAU,GAAC,WAAW,CAAC,CAAC;QAAC,WAAW,EAAE,KAAK,CAAC,eAAe,GAAC,gBAAgB,CAAC,CAAA;KAAC,CAAC,CAgDjH;IAED;;;;;;;;;;;;OAYG;IACH,uBARW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAuBzB;IAyBD;;;;;;;;;;;;;;;OAeG;IACH,cAZa,eAAe,CAc3B;IAED;;;;;;;;;;;;;;OAcG;IACH,UARa,OAAO,CAAC,IAAI,CAAC,CAkBzB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAQ5B;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAO5B;IAUD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,kBAdW,MAAM,GACJ,eAAe,CAqB3B;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAbW,MAAM,GACJ,UAAU,GAAC,WAAW,CAsBlC;;CACF;eA3kBc,iBAAiB;uBACT,iBAAiB;wBAGhB,kBAAkB"}

package/types/node/lib/FileObject.d.ts

@@ -22,6 +22,16 @@ export default class FileObject extends FS {
     static dataLoaderConfig: {
         [key: string]: Array<typeof JSON5 | typeof YAML>;
     };
+    /**
+     * Strip root from absolute path to make it relative.
+     * Used for virtual filesystem path resolution.
+     *
+     * @private
+     * @static
+     * @param {string} pathName - The path to convert
+     * @returns {string} Path with root stripped, or original if already relative
+     */
+    private static "__#private@#absoluteToRelative";
     /**
      * Constructs a FileObject instance.
      *
@@ -93,7 +103,12 @@ export default class FileObject extends FS {
      * @returns {DirectoryObject} The parent directory object
      */
     get parent(): DirectoryObject;
-    get parentPath(): any;
+    /**
+     * Returns the absolute path of the parent directory.
+     *
+     * @returns {string} The parent directory path
+     */
+    get parentPath(): string;
     /**
      * Check if a file can be read. Returns true if the file can be read, false
      *

package/types/node/lib/FileObject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FileObject.d.ts","sourceRoot":"","sources":["../../../src/node/lib/FileObject.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;GAaG;AAEH;IACE;;;;;OAKG;IACH,yBAFU;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC,OAAO,KAAK,GAAG,OAAO,IAAI,CAAC,CAAA;KAAC,CAO1D;IA0BF;;;;;OAKG;IACH,uBAHW,MAAM,WACN,eAAe,GAAC,MAAM,GAAC,IAAI,EA4DrC;IAaD;;;;OAIG;IACH,cAFa,OAAO,CAAC,OAAO,CAAC,CAI5B;IAED;;;;OAIG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,GAAG,CAIf;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,cAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAFa,MAAM,CAIlB;IACD;;;;OAIG;IACH,cAFa,OAAO,CAInB;IAED;;;;;;;;;;;;;;OAcG;IACH,cAFa,eAAe,CAI3B;IAED,sBAEC;IAED;;;;OAIG;IACH,WAFa,OAAO,CAAC,OAAO,CAAC,CAU5B;IAED;;;;OAIG;IACH,YAFa,OAAO,CAAC,OAAO,CAAC,CAU5B;IAiBD;;;;OAIG;IACH,QAFa,OAAO,CAAC,MAAM,OAAC,CAAC,CAU5B;IAED;;;;;OAKG;IACH,YAFa,OAAO,CAAC,IAAI,OAAC,CAAC,CAU1B;IAED;;;;;OAKG;IACH,gBAHW,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CAS3B;IAED;;;;;;;;;;;OAWG;IACH,cARa,OAAO,CAAC,MAAM,CAAC,CAe3B;IAED;;;;;;;;;;;OAWG;IACH,eARW,MAAM,aACN,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAiBzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,kBAXW,WAAW,GAAC,IAAI,GAAC,MAAM,GACrB,OAAO,CAAC,IAAI,CAAC,CAwBzB;IAED;;;;;;;;;;;;;;OAcG;IACH,gBAXW,MAAM,aACN,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAkC5B;IAED;;;;OAIG;IACH,UAFa,OAAO,CAAC,MAAM,CAAC,CAS3B;IAED;;;;;;;;;OASG;IACH,UAPa,OAAO,CAAC,IAAI,CAAC,CAczB;;CACF;eAvdc,iBAAiB;4BADJ,sBAAsB"}
+{"version":3,"file":"FileObject.d.ts","sourceRoot":"","sources":["../../../src/node/lib/FileObject.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;GAaG;AAEH;IACE;;;;;OAKG;IACH,yBAFU;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC,OAAO,KAAK,GAAG,OAAO,IAAI,CAAC,CAAA;KAAC,CAO1D;IA0BF;;;;;;;;OAQG;IACH,gDAOC;IAED;;;;;OAKG;IACH,uBAHW,MAAM,WACN,eAAe,GAAC,MAAM,GAAC,IAAI,EA6DrC;IAaD;;;;OAIG;IACH,cAFa,OAAO,CAAC,OAAO,CAAC,CAI5B;IAED;;;;OAIG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,GAAG,CAIf;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,cAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAFa,MAAM,CAIlB;IACD;;;;OAIG;IACH,cAFa,OAAO,CAInB;IAED;;;;;;;;;;;;;;OAcG;IACH,cAFa,eAAe,CAI3B;IAED;;;;OAIG;IACH,kBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,OAAO,CAAC,OAAO,CAAC,CAU5B;IAED;;;;OAIG;IACH,YAFa,OAAO,CAAC,OAAO,CAAC,CAU5B;IAiBD;;;;OAIG;IACH,QAFa,OAAO,CAAC,MAAM,OAAC,CAAC,CAU5B;IAED;;;;;OAKG;IACH,YAFa,OAAO,CAAC,IAAI,OAAC,CAAC,CAU1B;IAED;;;;;OAKG;IACH,gBAHW,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CAS3B;IAED;;;;;;;;;;;OAWG;IACH,cARa,OAAO,CAAC,MAAM,CAAC,CAe3B;IAED;;;;;;;;;;;OAWG;IACH,eARW,MAAM,aACN,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAiBzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,kBAXW,WAAW,GAAC,IAAI,GAAC,MAAM,GACrB,OAAO,CAAC,IAAI,CAAC,CAwBzB;IAED;;;;;;;;;;;;;;OAcG;IACH,gBAXW,MAAM,aACN,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAkC5B;IAED;;;;OAIG;IACH,UAFa,OAAO,CAAC,MAAM,CAAC,CAS3B;IAED;;;;;;;;;OASG;IACH,UAPa,OAAO,CAAC,IAAI,CAAC,CAczB;;CACF;eA/ec,iBAAiB;4BADJ,sBAAsB"}

package/types/node/lib/FileSystem.d.ts

@@ -40,7 +40,19 @@ export default class FileSystem {
      * @param {FileObject|DirectoryObject} to - The target file or directory object
      * @returns {string} The relative path from `from` to `to`, or the absolute path if not reachable
      */
-    static relativeOrAbsolutePath(from: FileObject | DirectoryObject, to: FileObject | DirectoryObject): string;
+    static relativeOrAbsolute(from: FileObject | DirectoryObject, to: FileObject | DirectoryObject): string;
+    /**
+     * Computes the relative path from one file or directory to another.
+     *
+     * If the target is outside the source (i.e., the relative path starts with
+     * ".."), returns the absolute path to the target instead.
+     *
+     * @static
+     * @param {string} from - The source file or directory object
+     * @param {string} to - The target file or directory object
+     * @returns {string} The relative path from `from` to `to`, or the absolute path if not reachable
+     */
+    static relativeOrAbsolutePath(from: string, to: string): string;
     /**
      * Merge two paths by finding overlapping segments and combining them
      * efficiently
@@ -156,21 +168,6 @@ export default class FileSystem {
      * FS.virtualToRealPath(regular) // "/home/user/file.txt"
      */
     static virtualToRealPath(fileOrDirectoryObject: FileObject | DirectoryObject): string;
-    /**
-     * Convert an absolute path to a relative format by removing the root component.
-     * By default, keeps a leading separator (making it "absolute-like relative").
-     * Use forceActuallyRelative to get a truly relative path without leading separator.
-     *
-     * @static
-     * @param {string} pathToCheck - The path to convert (returned unchanged if already relative)
-     * @param {boolean} [forceActuallyRelative=false] - If true, removes leading separator for truly relative path
-     * @returns {string} The relative path (with or without leading separator based on forceActuallyRelative)
-     * @example
-     * FS.absoluteToRelative("/home/user/docs") // "/home/user/docs" (with leading /)
-     * FS.absoluteToRelative("/home/user/docs", true) // "home/user/docs" (truly relative)
-     * FS.absoluteToRelative("relative/path") // "relative/path" (unchanged)
-     */
-    static absoluteToRelative(pathToCheck: string, forceActuallyRelative?: boolean): string;
     /**
      * Compute the relative path from another file or directory to this instance.
      *

package/types/node/lib/FileSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FileSystem.d.ts","sourceRoot":"","sources":["../../../src/node/lib/FileSystem.js"],"names":[],"mappings":"AA0BA;;GAEG;AACH;IACE,kCAAwB;IACxB,uCAAkC;IAClC,mBAAsB;IAsBtB;;;;;;OAMG;IACH,4BAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,2BAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;;;;OAMG;IACH,2BAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;;;;;;;;OAUG;IACH,oCAJW,UAAU,GAAC,eAAe,MAC1B,UAAU,GAAC,eAAe,GACxB,MAAM,CAYlB;IAED;;;;;;;;;OASG;IACH,oCALW,MAAM,SACN,MAAM,QACN,MAAM,GACJ,MAAM,CA0BlB;IAED;;;;;;;;OAQG;IACH,6BAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAmClB;IAED;;;;;;;;;;;;OAYG;IACH,+BATW,MAAM,aACN,MAAM,GACJ,OAAO,CAcnB;IAED;;;;;;;;;;;;;;OAcG;IACH,4BATW,MAAM,MACN,MAAM,QACN,MAAM,GACJ,MAAM,GAAC,IAAI,CAwBvB;IAED;;;;;;;;;;;;;;;OAeG;IACH,+BAXW,MAAM,MACN,MAAM,QACN,MAAM,GACJ,MAAM,GAAC,IAAI,CA+BvB;IAED;;;;;OAKG;IAEH;;;;;;;OAOG;IACH,2BAJW,MAAM;;;;cATH,MAAM;;;;aACN,MAAM;;;;aACN,MAAM;MAenB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,gDAZW,UAAU,GAAC,eAAe,GACxB,MAAM,CAiClB;IAED;;;;;;;;;;;;;OAaG;IACH,uCARW,MAAM,0BACN,OAAO,GACL,MAAM,CAkBlB;IA/VD;;;;;;;;;OASG;IACH,kCAJW,UAAU,GAAC,eAAe,GACxB,MAAM,CAWlB;CA8UF;yBAjXa,OAAO,iBAAiB,EAAE,OAAO;8BACjC,OAAO,sBAAsB,EAAE,OAAO"}
+{"version":3,"file":"FileSystem.d.ts","sourceRoot":"","sources":["../../../src/node/lib/FileSystem.js"],"names":[],"mappings":"AA0BA;;GAEG;AACH;IACE,kCAAwB;IACxB,uCAAkC;IAClC,mBAAsB;IAsBtB;;;;;;OAMG;IACH,4BAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,2BAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;;;;OAMG;IACH,2BAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;;;;;;;;OAUG;IACH,gCAJW,UAAU,GAAC,eAAe,MAC1B,UAAU,GAAC,eAAe,GACxB,MAAM,CAYlB;IAED;;;;;;;;;;OAUG;IACH,oCAJW,MAAM,MACN,MAAM,GACJ,MAAM,CAQlB;IAED;;;;;;;;;OASG;IACH,oCALW,MAAM,SACN,MAAM,QACN,MAAM,GACJ,MAAM,CA0BlB;IAED;;;;;;;;OAQG;IACH,6BAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAmClB;IAED;;;;;;;;;;;;OAYG;IACH,+BATW,MAAM,aACN,MAAM,GACJ,OAAO,CAcnB;IAED;;;;;;;;;;;;;;OAcG;IACH,4BATW,MAAM,MACN,MAAM,QACN,MAAM,GACJ,MAAM,GAAC,IAAI,CAwBvB;IAED;;;;;;;;;;;;;;;OAeG;IACH,+BAXW,MAAM,MACN,MAAM,QACN,MAAM,GACJ,MAAM,GAAC,IAAI,CA+BvB;IAED;;;;;OAKG;IAEH;;;;;;;OAOG;IACH,2BAJW,MAAM;;;;cATH,MAAM;;;;aACN,MAAM;;;;aACN,MAAM;MAenB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,gDAZW,UAAU,GAAC,eAAe,GACxB,MAAM,CAiClB;IAtVD;;;;;;;;;OASG;IACH,kCAJW,UAAU,GAAC,eAAe,GACxB,MAAM,CAWlB;CAqUF;yBAxWa,OAAO,iBAAiB,EAAE,OAAO;8BACjC,OAAO,sBAAsB,EAAE,OAAO"}

package/types/node/lib/VFileObject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VFileObject.d.ts","sourceRoot":"","sources":["../../../src/node/lib/VFileObject.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;GAkBG;AAEH;IAGE;;;;;OAKG;IACH,sBAHW,MAAM,UACN,gBAAgB,EAc1B;IAED,yBAEC;IAED,uBAEC;;CACF;uBAtDsB,iBAAiB"}
+{"version":3,"file":"VFileObject.d.ts","sourceRoot":"","sources":["../../../src/node/lib/VFileObject.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;GAkBG;AAEH;IAGE;;;;;OAKG;IACH,sBAHW,MAAM,UACN,gBAAgB,EAa1B;IAED,yBAEC;IAED,uBAEC;;CACF;uBArDsB,iBAAiB"}