@gesslar/toolkit 3.9.0 → 3.13.0

package/src/types/browser/lib/Data.d.ts

@@ -36,7 +36,7 @@ export default class Data {
      * @param {string} append - The string to append
      * @returns {string} The appended string
      */
-    static appendString(string: string, append: string): string;
+    static append(string: string, append: string): string;
     /**
      * Prepends a string to another string if it does not already start with it.
      *
@@ -44,7 +44,51 @@ export default class Data {
      * @param {string} prepend - The string to prepend
      * @returns {string} The prepended string
      */
-    static prependString(string: string, prepend: string): string;
+    static prepend(string: string, prepend: string): string;
+    /**
+     * Remove a suffix from the end of a string if present.
+     *
+     * @param {string} string - The string to process
+     * @param {string} toChop - The suffix to remove from the end
+     * @param {boolean} [caseInsensitive=false] - Whether to perform case-insensitive matching
+     * @returns {string} The string with suffix removed, or original if suffix not found
+     * @example
+     * Data.chopRight("hello.txt", ".txt") // "hello"
+     * Data.chopRight("Hello", "o") // "Hell"
+     * Data.chopRight("HELLO", "lo", true) // "HEL"
+     */
+    static chopRight(string: string, toChop: string, caseInsensitive?: boolean): string;
+    /**
+     * Remove a prefix from the beginning of a string if present.
+     *
+     * @param {string} string - The string to process
+     * @param {string} toChop - The prefix to remove from the beginning
+     * @param {boolean} [caseInsensitive=false] - Whether to perform case-insensitive matching
+     * @returns {string} The string with prefix removed, or original if prefix not found
+     * @example
+     * Data.chopLeft("hello.txt", "hello") // ".txt"
+     * Data.chopLeft("Hello", "H") // "ello"
+     * Data.chopLeft("HELLO", "he", true) // "LLO"
+     */
+    static chopLeft(string: string, toChop: string, caseInsensitive?: boolean): string;
+    /**
+     * Chop a string after the first occurence of another string.
+     *
+     * @param {string} string - The string to search
+     * @param {string} needle - The bit to chop after
+     * @param {boolean} caseInsensitive - Whether to search insensitive to case
+     * @returns {string} The remaining string
+     */
+    static chopAfter(string: string, needle: string, caseInsensitive?: boolean): string;
+    /**
+     * Chop a string before the first occurrence of another string.
+     *
+     * @param {string} string - The string to search
+     * @param {string} needle - The bit to chop before
+     * @param {boolean} caseInsensitive - Whether to search insensitive to case
+     * @returns {string} The remaining string
+     */
+    static chopBefore(string: string, needle: string, caseInsensitive?: boolean): string;
     /**
      * Creates a type spec from a string. A type spec is an array of objects
      * defining the type of a value and whether an array is expected.

package/src/types/browser/lib/Data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Data.d.ts","sourceRoot":"","sources":["../../../browser/lib/Data.js"],"names":[],"mappings":"AAUA;IACA;;;;;OAKG;IACD,mBAFQ,KAAK,CAAC,MAAM,CAAC,CAgBnB;IAEF;;;;;OAKG;IACH,qBAFU,KAAK,CAAC,MAAM,CAAC,CAmBrB;IAEF;;;;;;;OAOG;IACH,kBAFU,KAAK,CAAC,MAAM,CAAC,CAKrB;IAEF;;;;;OAKG;IACH,uBAFU,KAAK,CAAC,MAAM,CAAC,CAE6C;IAEpE;;;;;;OAMG;IACH,4BAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,6BAJW,MAAM,WACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;OAOG;IACH,2BAJW,MAAM,WACN,MAAM,GACJ,KAAK,CAAC,MAAM,CAAC,CAIzB;IAED;;;;;;;OAOG;IACH,qBALW,OAAO,QACP,MAAM,GAAC,QAAQ,YACf,MAAM,GACJ,OAAO,CAQnB;IAED;;;;;OAKG;IACH,yBAHW,MAAM,GACJ,OAAO,CASnB;IAED;;;;;;;;OAQG;IACH,yBAJW,OAAO,QACP,MAAM,GACJ,OAAO,CAwBnB;IAED;;;;;OAKG;IACH,qBAHW,OAAO,GACL,MAAM,CAclB;IAED;;;;;OAKG;IACH,wBAHW,OAAO,GACL,OAAO,CAInB;IAED;;;;;;;;OAQG;IACH,sBALW,OAAO,oBACP,OAAO,GAEL,OAAO,CA2BnB;IAED;;;;;OAKG;IACH,6BAHW,MAAM,GACJ,MAAM,CAmBlB;IAED;;;;;;;OAOG;IACH,6BAJW,MAAM,QACN,KAAK,CAAC,MAAM,CAAC,GACX,MAAM,CAiBlB;IAED;;;;;;;OAOG;IACH,2BAJW,MAAM,QACN,KAAK,CAAC,MAAM,CAAC,SACb,OAAO,QAMjB;IAED;;;;;OAKG;IACH,+BAHc,MAAM,EAAA,GACP,MAAM,CAqBlB;IAED;;;;;;;OAOG;IACH,wBAJW,KAAK,CAAC,OAAO,CAAC,aACd,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,GAClC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAMnC;IAED;;;;;;;OAOG;IACH,kBALW,MAAM,OACN,MAAM,OACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;OAOG;IACH,oBALW,MAAM,OACN,MAAM,OACN,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,4BAbW,OAAO,GACL,OAAO,CA+BnB;IAED;;;;;;;;;;;;;;;OAeG;IACH,uBAXW,OAAO,GACL,OAAO,CAgBnB;CACF;qBA5aoB,eAAe"}
+{"version":3,"file":"Data.d.ts","sourceRoot":"","sources":["../../../browser/lib/Data.js"],"names":[],"mappings":"AAUA;IACA;;;;;OAKG;IACD,mBAFQ,KAAK,CAAC,MAAM,CAAC,CAgBnB;IAEF;;;;;OAKG;IACH,qBAFU,KAAK,CAAC,MAAM,CAAC,CAmBrB;IAEF;;;;;;;OAOG;IACH,kBAFU,KAAK,CAAC,MAAM,CAAC,CAKrB;IAEF;;;;;OAKG;IACH,uBAFU,KAAK,CAAC,MAAM,CAAC,CAE2D;IAElF;;;;;;OAMG;IACH,sBAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAMlB;IAED;;;;;;OAMG;IACH,uBAJW,MAAM,WACN,MAAM,GACJ,MAAM,CAMlB;IAED;;;;;;;;;;;OAWG;IACH,yBATW,MAAM,UACN,MAAM,oBACN,OAAO,GACL,MAAM,CAWlB;IAED;;;;;;;;;;;OAWG;IACH,wBATW,MAAM,UACN,MAAM,oBACN,OAAO,GACL,MAAM,CAWlB;IAED;;;;;;;OAOG;IACH,yBALW,MAAM,UACN,MAAM,oBACN,OAAO,GACL,MAAM,CAWlB;IAED;;;;;;;OAOG;IACH,0BALW,MAAM,UACN,MAAM,oBACN,OAAO,GACL,MAAM,CAYlB;IAED;;;;;;;OAOG;IACH,2BAJW,MAAM,WACN,MAAM,GACJ,KAAK,CAAC,MAAM,CAAC,CAIzB;IAED;;;;;;;OAOG;IACH,qBALW,OAAO,QACP,MAAM,GAAC,QAAQ,YACf,MAAM,GACJ,OAAO,CAQnB;IAED;;;;;OAKG;IACH,yBAHW,MAAM,GACJ,OAAO,CASnB;IAED;;;;;;;;OAQG;IACH,yBAJW,OAAO,QACP,MAAM,GACJ,OAAO,CAwBnB;IAED;;;;;OAKG;IACH,qBAHW,OAAO,GACL,MAAM,CAclB;IAED;;;;;OAKG;IACH,wBAHW,OAAO,GACL,OAAO,CAInB;IAED;;;;;;;;OAQG;IACH,sBALW,OAAO,oBACP,OAAO,GAEL,OAAO,CA8BnB;IAED;;;;;OAKG;IACH,6BAHW,MAAM,GACJ,MAAM,CAmBlB;IAED;;;;;;;OAOG;IACH,6BAJW,MAAM,QACN,KAAK,CAAC,MAAM,CAAC,GACX,MAAM,CAiBlB;IAED;;;;;;;OAOG;IACH,2BAJW,MAAM,QACN,KAAK,CAAC,MAAM,CAAC,SACb,OAAO,QAMjB;IAED;;;;;OAKG;IACH,+BAHc,MAAM,EAAA,GACP,MAAM,CAqBlB;IAED;;;;;;;OAOG;IACH,wBAJW,KAAK,CAAC,OAAO,CAAC,aACd,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,GAClC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAMnC;IAED;;;;;;;OAOG;IACH,kBALW,MAAM,OACN,MAAM,OACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;OAOG;IACH,oBALW,MAAM,OACN,MAAM,OACN,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,4BAbW,OAAO,GACL,OAAO,CA+BnB;IAED;;;;;;;;;;;;;;;OAeG;IACH,uBAXW,OAAO,GACL,OAAO,CAgBnB;CACF;qBAhgBoB,eAAe"}

package/src/types/browser/lib/TypeSpec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TypeSpec.d.ts","sourceRoot":"","sources":["../../../browser/lib/TypeSpec.js"],"names":[],"mappings":"AAWA;;;GAGG;AACH;IAGE;;;;;OAKG;IACH,oBAHW,MAAM,WACN,OAAO,EAUjB;IAJC,aAAwB;IACxB,eAAgC;IAChC,6BAA2C;IAI7C;;;;OAIG;IACH,YAFa,MAAM,CAQlB;IAED;;;;OAIG;IACH,UAFa,OAAO,CASnB;IAED;;;;OAIG;IACH,kBAFW,CAAS,IAAO,EAAP,OAAO,KAAG,IAAI,QAIjC;IAED;;;;;OAKG;IACH,gBAHW,CAAS,IAAO,EAAP,OAAO,KAAG,OAAO,GACxB,OAAO,CAInB;IAED;;;;;OAKG;IACH,eAHW,CAAS,IAAO,EAAP,OAAO,KAAG,OAAO,GACxB,OAAO,CAInB;IAED;;;;;OAKG;IACH,iBAHW,CAAS,IAAO,EAAP,OAAO,KAAG,OAAO,GACxB,KAAK,CAAC,OAAO,CAAC,CAI1B;IAED;;;;;OAKG;IACH,cAHW,CAAS,IAAO,EAAP,OAAO,KAAG,OAAO,GACxB,KAAK,CAAC,OAAO,CAAC,CAI1B;IAED;;;;;;OAMG;IACH,iBAJW,CAAS,IAAO,EAAP,OAAO,EAAE,IAAO,EAAP,OAAO,KAAG,OAAO,gBACnC,OAAO,GACL,OAAO,CAInB;IAED;;;;;OAKG;IACH,eAHW,CAAS,IAAO,EAAP,OAAO,KAAG,OAAO,GACxB,MAAM,GAAC,SAAS,CAI5B;IAED;;;;;;;;OAQG;IACH,eALW,OAAO,WACP,OAAO,GAEL,OAAO,CAInB;IAED,2CA2DC;;CAmDF"}
+{"version":3,"file":"TypeSpec.d.ts","sourceRoot":"","sources":["../../../browser/lib/TypeSpec.js"],"names":[],"mappings":"AAWA;;;GAGG;AACH;IAGE;;;;;OAKG;IACH,oBAHW,MAAM,WACN,OAAO,EAUjB;IAJC,aAAwB;IACxB,eAAgC;IAChC,6BAA2C;IAI7C;;;;OAIG;IACH,YAFa,MAAM,CAQlB;IAED;;;;OAIG;IACH,UAFa,OAAO,CASnB;IAED;;;;OAIG;IACH,kBAFW,CAAS,IAAO,EAAP,OAAO,KAAG,IAAI,QAIjC;IAED;;;;;OAKG;IACH,gBAHW,CAAS,IAAO,EAAP,OAAO,KAAG,OAAO,GACxB,OAAO,CAInB;IAED;;;;;OAKG;IACH,eAHW,CAAS,IAAO,EAAP,OAAO,KAAG,OAAO,GACxB,OAAO,CAInB;IAED;;;;;OAKG;IACH,iBAHW,CAAS,IAAO,EAAP,OAAO,KAAG,OAAO,GACxB,KAAK,CAAC,OAAO,CAAC,CAI1B;IAED;;;;;OAKG;IACH,cAHW,CAAS,IAAO,EAAP,OAAO,KAAG,OAAO,GACxB,KAAK,CAAC,OAAO,CAAC,CAI1B;IAED;;;;;;OAMG;IACH,iBAJW,CAAS,IAAO,EAAP,OAAO,EAAE,IAAO,EAAP,OAAO,KAAG,OAAO,gBACnC,OAAO,GACL,OAAO,CAInB;IAED;;;;;OAKG;IACH,eAHW,CAAS,IAAO,EAAP,OAAO,KAAG,OAAO,GACxB,MAAM,GAAC,SAAS,CAI5B;IAED;;;;;;;;OAQG;IACH,eALW,OAAO,WACP,OAAO,GAEL,OAAO,CAInB;IAED,2CA6DC;;CAmDF"}

package/src/types/lib/CappedDirectoryObject.d.ts

@@ -28,9 +28,8 @@ export default class CappedDirectoryObject extends DirectoryObject {
      * (virtual root). With a parent, the path is resolved relative to the parent's
      * cap using virtual path semantics (absolute paths treated as cap-relative).
      *
-     * @param {string} [dirPath="."] - Directory path (becomes cap if no parent, else relative to parent's cap, defaults to current directory)
+     * @param {string} [directory="."] - Directory path (becomes cap if no parent, else relative to parent's cap, defaults to current directory)
      * @param {CappedDirectoryObject?} [parent] - Optional parent capped directory
-     * @param {boolean} [temporary=false] - Whether this is a temporary directory
      * @throws {Sass} If parent is provided but not a CappedDirectoryObject
      * @throws {Sass} If the resulting path would escape the cap
      * @example
@@ -53,33 +52,34 @@ export default class CappedDirectoryObject extends DirectoryObject {
      * const config = new CappedDirectoryObject("/etc/config", cache)
      * // path: /home/user/.cache/etc/config, cap: /home/user/.cache
      */
-    constructor(dirPath?: string, parent?: CappedDirectoryObject | null, temporary?: boolean);
+    constructor(directory?: string, source?: any);
     /**
-     * Re-caps this directory to itself, making it the new root of the capped tree.
-     * This is a protected method intended for use by subclasses like TempDirectoryObject.
+     * Indicates whether this directory is capped (constrained to a specific tree).
+     * Always returns true for CappedDirectoryObject instances.
      *
-     * @protected
-     */
-    protected _recapToSelf(): void;
-    /**
-     * Returns the cap path for this directory.
+     * @returns {boolean} True for all CappedDirectoryObject instances
+     * @example
+     * const capped = new TempDirectoryObject("myapp")
+     * console.log(capped.isCapped) // true
      *
-     * @returns {string} The cap directory path
+     * const regular = new DirectoryObject("/tmp")
+     * console.log(regular.isCapped) // false
      */
-    get cap(): string;
+    get isCapped(): boolean;
     /**
-     * Returns whether this directory is capped.
+     * Returns the cap (root) of the capped directory tree.
+     * For root CappedDirectoryObject instances, returns itself.
+     * For children, returns the inherited cap from the parent chain.
      *
-     * @returns {boolean} Always true for CappedDirectoryObject instances
-     */
-    get capped(): boolean;
-    /**
-     * Returns the real filesystem path (for internal and subclass use).
+     * @returns {CappedDirectoryObject} The cap directory object (root of the capped tree)
+     * @example
+     * const temp = new TempDirectoryObject("myapp")
+     * console.log(temp.cap === temp) // true (root is its own cap)
      *
-     * @protected
-     * @returns {string} The actual filesystem path
+     * const subdir = temp.getDirectory("data")
+     * console.log(subdir.cap === temp) // true (child inherits parent's cap)
      */
-    protected get realPath(): string;
+    get cap(): CappedDirectoryObject;
     /**
      * Returns a plain DirectoryObject representing the actual filesystem location.
      * This provides an "escape hatch" from the capped environment to interact
@@ -115,50 +115,25 @@ export default class CappedDirectoryObject extends DirectoryObject {
      */
     get parent(): CappedDirectoryObject | null;
     /**
-     * Returns the URL with virtual path (cap-relative).
-     *
-     * @returns {URL} Virtual URL
-     */
-    get url(): URL;
-    /**
-     * Returns a generator that walks up to the cap.
-     *
-     * @returns {Generator<DirectoryObject>} Generator yielding parent directories
-     */
-    get walkUp(): Generator<DirectoryObject>;
-    /**
-     * Creates a new CappedDirectoryObject by extending this directory's path.
-     *
-     * All paths are coerced to remain within the cap directory tree:
-     * - Absolute paths (e.g., "/foo") are treated as relative to the cap
-     * - Parent traversal ("..") is allowed but clamped at the cap boundary
-     * - The cap acts as the virtual root directory
+     * Returns the path of the parent directory.
+     * Returns null if this directory is at the cap root (no parent).
      *
-     * @param {string} newPath - The path to resolve (can be absolute or contain ..)
-     * @returns {CappedDirectoryObject} A new CappedDirectoryObject with the coerced path
+     * @returns {string|null} The parent directory path, or null if at cap root
      * @example
-     * const capped = new TempDirectoryObject("myapp")
-     * const subDir = capped.getDirectory("data")
-     * console.log(subDir.path) // "/tmp/myapp-ABC123/data"
-     *
-     * @example
-     * // Absolute paths are relative to cap
-     * const abs = capped.getDirectory("/foo/bar")
-     * console.log(abs.path) // "/tmp/myapp-ABC123/foo/bar"
+     * const temp = new TempDirectoryObject("myapp")
+     * console.log(temp.parentPath) // null (at cap root)
      *
-     * @example
-     * // Excessive .. traversal clamps to cap
-     * const up = capped.getDirectory("../../../etc/passwd")
-     * console.log(up.path) // "/tmp/myapp-ABC123" (clamped to cap)
+     * const subdir = temp.getDirectory("data")
+     * console.log(subdir.parentPath) // "/data" or similar (parent's virtual path)
      */
-    getDirectory(newPath: string): CappedDirectoryObject;
+    get parentPath(): string | null;
     /**
      * Override read to use real filesystem path and return capped objects.
      *
      * @param {string} [pat=""] - Optional glob pattern
      * @returns {Promise<{files: Array<FileObject>, directories: Array}>} Directory contents
      */
-    read(pat?: string): Promise<{
+    read(...arg: any[]): Promise<{
         files: Array<FileObject>;
         directories: any[];
     }>;

package/src/types/lib/CappedDirectoryObject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CappedDirectoryObject.d.ts","sourceRoot":"","sources":["../../lib/CappedDirectoryObject.js"],"names":[],"mappings":"AAkBA;;;;;;;;GAQG;AACH;IA2FE;;;;;;;;;;;OAWG;IACH,kBAPa,qBAAqB,CASjC;IAtGD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,sBAzBW,MAAM,WACN,qBAAqB,OAAC,cACtB,OAAO,EA6EjB;IAqCD;;;;;OAKG;IACH,+BAEC;IAED;;;;OAIG;IACH,WAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,cAFa,OAAO,CAInB;IAED;;;;;OAKG;IACH,0BAFa,MAAM,CAIlB;IAqCD;;;;;;;;;;;;;;;;;OAiBG;IACH,YAba,eAAe,CAe3B;IAED;;;;;;;;;;;;;OAaG;IACH,cAPa,qBAAqB,GAAC,IAAI,CA0BtC;IAED;;;;OAIG;IACH,WAFa,GAAG,CAIf;IAqFD;;;;OAIG;IACH,cAFa,SAAS,CAAC,eAAe,CAAC,CAItC;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,sBAjBW,MAAM,GACJ,qBAAqB,CAiEjC;IAsID;;;;;OAKG;IACH,WAHW,MAAM,GACJ,OAAO,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;QAAC,WAAW,QAAO;KAAC,CAAC,CAgBnE;;CA8DF;4BArpB2B,sBAAsB;uBAC3B,iBAAiB"}
+{"version":3,"file":"CappedDirectoryObject.d.ts","sourceRoot":"","sources":["../../lib/CappedDirectoryObject.js"],"names":[],"mappings":"AAiBA;;;;;;;;GAQG;AACH;IAoEE;;;;;;;;;;;OAWG;IACH,kBAPa,qBAAqB,CASjC;IA5ED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,wBAxBW,MAAM,gBAqDhB;IAkBD;;;;;;;;;;;OAWG;IACH,gBARa,OAAO,CAUnB;IAED;;;;;;;;;;;;OAYG;IACH,WARa,qBAAqB,CAUjC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,YAba,eAAe,CAe3B;IAED;;;;;;;;;;;;;OAaG;IACH,cAPa,qBAAqB,GAAC,IAAI,CAStC;IAED;;;;;;;;;;;OAWG;IACH,kBARa,MAAM,GAAC,IAAI,CAUvB;IAWD;;;;;OAKG;IACH,qBAFa,OAAO,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;QAAC,WAAW,QAAO;KAAC,CAAC,CAUnE;;CA8BF;4BAhP2B,sBAAsB;uBAC3B,iBAAiB"}

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

@@ -8,7 +8,6 @@
  * - Pattern-based content filtering with glob support
  * - Path traversal via walkUp generator
  * - Intelligent path merging for subdirectories and files
- * - Support for temporary directory management
  *
  * @property {string} supplied - The original directory path as supplied to constructor
  * @property {string} path - The absolute resolved directory path
@@ -18,7 +17,6 @@
  * @property {string} extension - The directory extension (typically empty string)
  * @property {string} sep - Platform-specific path separator ('/' or '\\')
  * @property {Array<string>} trail - Path segments split by separator
- * @property {boolean} temporary - Whether this is marked as a temporary directory
  * @property {boolean} isFile - Always false (this is a directory)
  * @property {boolean} isDirectory - Always true
  * @property {DirectoryObject|null} parent - The parent directory (null if root)
@@ -48,7 +46,6 @@
  * const file = dir.getFile("package.json")
  */
 export default class DirectoryObject extends FS {
-    [x: number]: () => object;
     /**
      * Creates a DirectoryObject from the current working directory.
      * Useful when working with pnpx or other tools where the project root
@@ -63,16 +60,9 @@ export default class DirectoryObject extends FS {
     /**
      * Constructs a DirectoryObject instance.
      *
-     * @param {string? | DirectoryObject?} [directory="."] - The directory path or DirectoryObject (defaults to current directory)
-     * @param {boolean} [temporary] - Whether this is a temporary directory.
+     * @param {string?} [directory="."] - The directory path or DirectoryObject (defaults to current directory)
      */
-    constructor(directory?: string, temporary?: boolean);
-    /**
-     * Returns a JSON representation of the DirectoryObject.
-     *
-     * @returns {object} JSON representation of the DirectoryObject
-     */
-    toJSON(): object;
+    constructor(directory?: string | null);
     /**
      * Checks if the directory exists (async).
      *
@@ -130,12 +120,6 @@ export default class DirectoryObject extends FS {
      * console.log(dir.trail) // ['', 'path', 'to', 'directory']
      */
     get trail(): Array<string>;
-    /**
-     * Returns whether this directory is marked as temporary.
-     *
-     * @returns {boolean} True if this is a temporary directory, false otherwise
-     */
-    get temporary(): boolean;
     /**
      * Returns the parent directory of this directory.
      * Returns null if this directory is the root directory.
@@ -150,42 +134,6 @@ export default class DirectoryObject extends FS {
      * console.log(root.parent) // null
      */
     get parent(): DirectoryObject | null;
-    /**
-     * Returns the root directory of the filesystem.
-     *
-     * For DirectoryObject, this walks up to the filesystem root.
-     * For CappedDirectoryObject, this returns the cap root.
-     *
-     * @returns {DirectoryObject} The root directory
-     * @example
-     * const dir = new DirectoryObject("/usr/local/bin")
-     * console.log(dir.root.path)  // "/"
-     *
-     * @example
-     * const capped = new CappedDirectoryObject("/projects/myapp")
-     * const sub = capped.getDirectory("src/lib")
-     * console.log(sub.root.path)  // "/" (virtual, cap root)
-     * console.log(sub.root.real.path)  // "/projects/myapp"
-     */
-    get root(): DirectoryObject;
-    /**
-     * Recursively removes a temporary directory and all its contents.
-     *
-     * This method will delete all files and subdirectories within this directory,
-     * then delete the directory itself. It only works on directories explicitly
-     * marked as temporary for safety.
-     *
-     * @async
-     * @returns {Promise<void>}
-     * @throws {Sass} If the directory is not marked as temporary
-     * @throws {Sass} If the directory deletion fails
-     * @example
-     * const tempDir = new TempDirectoryObject("my-temp")
-     * await tempDir.assureExists()
-     * // ... use the directory ...
-     * await tempDir.remove() // Recursively deletes everything
-     */
-    remove(): Promise<void>;
     /**
      * Returns false. Because this is a directory.
      *
@@ -236,7 +184,7 @@ export default class DirectoryObject extends FS {
      * Generator that walks up the directory tree, yielding each parent directory.
      * Starts from the current directory and yields each parent until reaching the root.
      *
-     * @returns {object} Generator yielding parent DirectoryObject instances
+     * @returns {DirectoryObject} Generator yielding parent DirectoryObject instances
      * @example
      * const dir = new DirectoryObject('/path/to/deep/directory')
      * for(const parent of dir.walkUp) {
@@ -248,7 +196,7 @@ export default class DirectoryObject extends FS {
      *   // /
      * }
      */
-    get walkUp(): object;
+    get walkUp(): DirectoryObject;
     /**
      * Deletes an empty directory from the filesystem.
      *
@@ -286,7 +234,7 @@ export default class DirectoryObject extends FS {
      * duplication (e.g., "/projects/toolkit" + "toolkit/src" = "/projects/toolkit/src").
      * The temporary flag is preserved from the parent directory.
      *
-     * @param {string} newPath - The subdirectory path to append (can be nested like "src/lib")
+     * @param {string} dir - The subdirectory path to append (can be nested like "src/lib")
      * @returns {DirectoryObject} A new DirectoryObject instance with the combined path
      * @throws {Sass} If newPath is not a string
      * @example
@@ -300,7 +248,7 @@ export default class DirectoryObject extends FS {
      * const subDir = dir.getDirectory("toolkit/src")
      * console.log(subDir.path) // "/projects/toolkit/src" (not /projects/toolkit/toolkit/src)
      */
-    getDirectory(newPath: string): DirectoryObject;
+    getDirectory(dir: string): DirectoryObject;
     /**
      * Creates a new FileObject by extending this directory's path.
      *
@@ -308,7 +256,7 @@ export default class DirectoryObject extends FS {
      * duplication. The resulting FileObject can be used for reading, writing,
      * and other file operations.
      *
-     * @param {string} filename - The filename to append (can include subdirectories like "src/index.js")
+     * @param {string} file - The filename to append (can include subdirectories like "src/index.js")
      * @returns {FileObject} A new FileObject instance with the combined path
      * @throws {Sass} If filename is not a string
      * @example
@@ -321,7 +269,7 @@ export default class DirectoryObject extends FS {
      * const file = dir.getFile("src/index.js")
      * const data = await file.read()
      */
-    getFile(filename: string): FileObject;
+    getFile(file: string): FileObject;
     #private;
 }
 import FS from "./FS.js";

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

@@ -1 +1 @@
-{"version":3,"file":"DirectoryObject.d.ts","sourceRoot":"","sources":["../../lib/DirectoryObject.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH;uBAoHe,MAAM;IA9CnB;;;;;;;;;OASG;IACH,kBALa,eAAe,CAO3B;IA/CD;;;;;OAKG;IACH,4CAFW,OAAO,EA6BjB;IAyBD;;;;OAIG;IACH,UAFa,MAAM,CAelB;IAWD;;;;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;;;;OAIG;IACH,iBAFa,OAAO,CAInB;IAED;;;;;;;;;;;;OAYG;IACH,cARa,eAAe,GAAC,IAAI,CAwBhC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,YAXa,eAAe,CAoB3B;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,UATa,OAAO,CAAC,IAAI,CAAC,CA0BzB;IAED;;;;OAIG;IACH,cAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,mBAFa,OAAO,CAInB;IAiBD;;;;;;;;;;;;;;;OAeG;IACH,WAZW,MAAM,GACJ,OAAO,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;QAAC,WAAW,EAAE,KAAK,CAAC,eAAe,CAAC,CAAA;KAAC,CAAC,CAoCpF;IAED;;;;;;;;;;;;OAYG;IACH,uBARW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAqBzB;IA8BD;;;;;;;;;;;;;;;OAeG;IACH,cAZa,MAAM,CAclB;IAED;;;;;;;;;;;;;;OAcG;IACH,UARa,OAAO,CAAC,IAAI,CAAC,CAkBzB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAM5B;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAO5B;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,sBAdW,MAAM,GACJ,eAAe,CAoB3B;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,kBAbW,MAAM,GACJ,UAAU,CAkBtB;;CACF;eAjnBc,SAAS;uBACD,iBAAiB"}
+{"version":3,"file":"DirectoryObject.d.ts","sourceRoot":"","sources":["../../lib/DirectoryObject.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH;IAmEE;;;;;;;;;OASG;IACH,kBALa,eAAe,CAO3B;IA/CD;;;;OAIG;IACH,wBAFW,MAAM,OAAC,EA8BjB;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,cAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,mBAFa,OAAO,CAInB;IAqBD;;;;;;;;;;;;;;;OAeG;IACH,WAZW,MAAM,GACJ,OAAO,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;QAAC,WAAW,EAAE,KAAK,CAAC,eAAe,CAAC,CAAA;KAAC,CAAC,CAiDpF;IAED;;;;;;;;;;;;OAYG;IACH,uBARW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAqBzB;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,CAM5B;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAO5B;IAUD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,kBAdW,MAAM,GACJ,eAAe,CAqB3B;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,cAbW,MAAM,GACJ,UAAU,CAoBtB;;CACF;eA9hBc,SAAS;uBACD,iBAAiB"}

package/src/types/lib/FS.d.ts

@@ -20,7 +20,7 @@ export default class FS {
      * @param {string} pathName - The path to convert
      * @returns {string} The URI
      */
-    static pathToUri(pathName: string): string;
+    static pathToUrl(pathName: string): string;
     /**
      * Convert a URI to a path
      *
@@ -28,22 +28,12 @@ export default class FS {
      * @param {string} pathName - The URI to convert
      * @returns {string} The path
      */
-    static uriToPath(pathName: string): string;
-    /**
-     * Retrieve all files matching a specific glob pattern.
-     *
-     * @static
-     * @param {string|Array<string>} glob - The glob pattern(s) to search.
-     * @returns {Promise<Array<FileObject>>} A promise that resolves to an array of file objects
-     * @throws {Sass} If the input is not a string or array of strings.
-     * @throws {Sass} If the glob pattern array is empty or for other search failures.
-     */
-    static getFiles(glob: string | Array<string>): Promise<Array<FileObject>>;
+    static urlToPath(pathName: string): 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.
+     * If the target is outside the source (i.e., the relative path starts with
+     * ".."), returns the absolute path to the target instead.
      *
      * @static
      * @param {FileObject|DirectoryObject} from - The source file or directory object
@@ -52,7 +42,8 @@ export default class FS {
      */
     static relativeOrAbsolutePath(from: FileObject | DirectoryObject, to: FileObject | DirectoryObject): string;
     /**
-     * Merge two paths by finding overlapping segments and combining them efficiently
+     * Merge two paths by finding overlapping segments and combining them
+     * efficiently
      *
      * @static
      * @param {string} path1 - The first path
@@ -71,6 +62,115 @@ export default class FS {
      * @returns {string} The resolved path
      */
     static resolvePath(fromPath: string, toPath: string): string;
+    /**
+     * Check if a candidate path is contained within a container path.
+     *
+     * @static
+     * @param {string} container - The container path to check against
+     * @param {string} candidate - The candidate path that might be contained
+     * @returns {boolean} True if candidate is within container, false otherwise
+     * @throws {Sass} If container is not a non-empty string
+     * @throws {Sass} If candidate is not a non-empty string
+     * @example
+     * FS.pathContains("/home/user", "/home/user/docs") // true
+     * FS.pathContains("/home/user", "/home/other") // false
+     */
+    static pathContains(container: string, candidate: string): boolean;
+    /**
+     * Convert an absolute path to a relative path by finding overlapping segments.
+     * Returns the relative portion of the 'to' path after the last occurrence
+     * of the final segment from the 'from' path.
+     *
+     * @static
+     * @param {string} from - The base path to calculate relative from
+     * @param {string} to - The target path to make relative
+     * @param {string} [sep=path.sep] - The path separator to use (defaults to system separator)
+     * @returns {string|null} The relative path, empty string if paths are identical, or null if no overlap found
+     * @example
+     * FS.toRelativePath("/projects/toolkit", "/projects/toolkit/src") // "src"
+     * FS.toRelativePath("/home/user", "/home/user") // ""
+     * FS.toRelativePath("/projects/app", "/other/path") // null
+     */
+    static toRelativePath(from: string, to: string, sep?: string): string | null;
+    /**
+     * Find the common root path between two paths by identifying overlapping segments.
+     * Returns the portion of 'from' that matches up to the overlap point in 'to'.
+     *
+     * @static
+     * @param {string} from - The first path to compare
+     * @param {string} to - The second path to find common root with
+     * @param {string} [sep=path.sep] - The path separator to use (defaults to system separator)
+     * @returns {string|null} The common root path, the original path if identical, or null if no overlap found
+     * @throws {Sass} If from is not a non-empty string
+     * @throws {Sass} If to is not a non-empty string
+     * @example
+     * FS.getCommonRootPath("/projects/toolkit/src", "/projects/toolkit/tests") // "/projects/toolkit"
+     * FS.getCommonRootPath("/home/user", "/home/user") // "/home/user"
+     * FS.getCommonRootPath("/projects/app", "/other/path") // null
+     */
+    static getCommonRootPath(from: string, to: string, sep?: string): string | null;
+    /**
+     * @typedef {object} PathParts
+     * @property {string} base - The file name with extension
+     * @property {string} dir - The directory path
+     * @property {string} ext - The file extension (including dot)
+     */
+    /**
+     * Deconstruct a file or directory name into parts.
+     *
+     * @static
+     * @param {string} pathName - The file/directory name to deconstruct
+     * @returns {PathParts} The filename parts
+     * @throws {Sass} If not a string of more than 1 character
+     */
+    static pathParts(pathName: string): {
+        /**
+         * - The file name with extension
+         */
+        base: string;
+        /**
+         * - The directory path
+         */
+        dir: string;
+        /**
+         * - The file extension (including dot)
+         */
+        ext: string;
+    };
+    /**
+     * Convert a virtual capped path to its real filesystem path.
+     * For capped objects, resolves the virtual path relative to the cap's real path.
+     * For uncapped objects, returns the path unchanged.
+     *
+     * @static
+     * @param {FileObject|DirectoryObject} fileOrDirectoryObject - The file or directory object to convert
+     * @returns {string} The real filesystem path
+     * @throws {Sass} If parameter is not a FileObject or DirectoryObject
+     * @example
+     * const temp = new TempDirectoryObject("myapp")
+     * const file = temp.getFile("/config.json")
+     * FS.virtualToRealPath(file) // "/tmp/myapp-ABC123/config.json"
+     *
+     * @example
+     * const regular = new FileObject("/home/user/file.txt")
+     * 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/src/types/lib/FS.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FS.d.ts","sourceRoot":"","sources":["../../lib/FS.js"],"names":[],"mappings":"AAwBA;;GAEG;AACH;IACE,kCAAwB;IACxB,uCAAkC;IAClC,mBAAsB;IAsBtB;;;;;;OAMG;IACH,4BAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,2BAHW,MAAM,GACJ,MAAM,CAUlB;IAED;;;;;;OAMG;IACH,2BAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;;;;;;OAQG;IACH,sBALW,MAAM,GAAC,KAAK,CAAC,MAAM,CAAC,GAClB,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAmCtC;IAED;;;;;;;;;;OAUG;IACH,oCAJW,UAAU,GAAC,eAAe,MAC1B,UAAU,GAAC,eAAe,GACxB,MAAM,CAYlB;IAED;;;;;;;;OAQG;IACH,oCALW,MAAM,SACN,MAAM,QACN,MAAM,GACJ,MAAM,CA0BlB;IAED;;;;;;;;OAQG;IACH,6BAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAgClB;IA1MD;;;;;;;;;OASG;IACH,kCAJW,UAAU,GAAC,eAAe,GACxB,MAAM,CAWlB;CAyLF;yBA5Na,OAAO,iBAAiB,EAAE,OAAO;8BACjC,OAAO,sBAAsB,EAAE,OAAO"}
+{"version":3,"file":"FS.d.ts","sourceRoot":"","sources":["../../lib/FS.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"}

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

@@ -14,7 +14,6 @@
  * @property {Promise<boolean>} exists - Whether the file exists (async)
  */
 export default class FileObject extends FS {
-    [x: number]: () => object;
     /**
      * Configuration mapping data types to their respective parser modules for loadData method.
      * Each parser module must have a .parse() method that accepts a string and returns parsed data.
@@ -27,16 +26,10 @@ export default class FileObject extends FS {
     /**
      * Constructs a FileObject instance.
      *
-     * @param {string | FileObject} fileName - The file path or FileObject
+     * @param {string} fileName - The file path
      * @param {DirectoryObject|string|null} [parent] - The parent directory (object or string)
      */
-    constructor(fileName: string | FileObject, parent?: DirectoryObject | string | null);
-    /**
-     * Returns a JSON representation of the FileObject.
-     *
-     * @returns {object} JSON representation of the FileObject
-     */
-    toJSON(): object;
+    constructor(fileName: string, parent?: DirectoryObject | string | null);
     /**
      * Checks if the file exists (async).
      *
@@ -51,7 +44,9 @@ export default class FileObject extends FS {
     get supplied(): string;
     /**
      * Returns the file path. If the parent is a capped directory, returns the
-     * virtual path relative to the cap. Otherwise returns the real filesystem path.
+     * virtual path relative to the cap. Otherwise returns the real filesystem
+     * path.
+     *
      * Use `.real.path` to always get the actual filesystem path.
      *
      * @returns {string} The file path (virtual if parent is capped, real otherwise)
@@ -110,6 +105,7 @@ export default class FileObject extends FS {
      * @returns {DirectoryObject} The parent directory object
      */
     get parent(): DirectoryObject;
+    get parentPath(): any;
     /**
      * Returns a plain FileObject representing the actual filesystem location.
      * This provides an "escape hatch" when working with capped directories,

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

@@ -1 +1 @@
-{"version":3,"file":"FileObject.d.ts","sourceRoot":"","sources":["../../lib/FileObject.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;GAcG;AAEH;uBAmIe,MAAM;IAlInB;;;;;OAKG;IACH,yBAFU;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC,OAAO,KAAK,GAAG,OAAO,IAAI,CAAC,CAAA;KAAC,CAO1D;IA2BF;;;;;OAKG;IACH,sBAHW,MAAM,GAAG,UAAU,WACnB,eAAe,GAAC,MAAM,GAAC,IAAI,EAuDrC;IAWD;;;;OAIG;IACH,UAFa,MAAM,CAclB;IAWD;;;;OAIG;IACH,cAFa,OAAO,CAAC,OAAO,CAAC,CAI5B;IAED;;;;OAIG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,YAFa,MAAM,CAkBlB;IAED;;;;;OAKG;IACH,WAFa,GAAG,CAWf;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;;;;OAIG;IACH,mBAFa,OAAO,CAInB;IAED;;;;;;;;;;;;;;OAcG;IACH,cAFa,eAAe,CAI3B;IAED;;;;;;;;;;;;;;;OAeG;IACH,YAXa,UAAU,CAatB;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;IAsBD;;;;;OAKG;IACH,gBAHW,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CAY3B;IAED;;;;;;;;;;;OAWG;IACH,cARa,OAAO,CAAC,MAAM,CAAC,CAkB3B;IAED;;;;;;;;;;;OAWG;IACH,eARW,MAAM,aACN,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAezB;IAED;;;;;;;;;;;;;;;OAeG;IACH,kBAXW,WAAW,GAAC,IAAI,GAAC,MAAM,GACrB,OAAO,CAAC,IAAI,CAAC,CAyBzB;IAED;;;;;;;;;;;;;;OAcG;IACH,gBAXW,MAAM,aACN,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAkC5B;IAED;;;;OAIG;IACH,UAFa,OAAO,CAAC,MAAM,CAAC,CAY3B;IAED;;;;;;;;;OASG;IACH,UAPa,OAAO,CAAC,IAAI,CAAC,CAiBzB;;CACF;eA9jBc,SAAS;4BADI,sBAAsB"}
+{"version":3,"file":"FileObject.d.ts","sourceRoot":"","sources":["../../lib/FileObject.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;GAcG;AAEH;IACE;;;;;OAKG;IACH,yBAFU;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC,OAAO,KAAK,GAAG,OAAO,IAAI,CAAC,CAAA;KAAC,CAO1D;IA4BF;;;;;OAKG;IACH,sBAHW,MAAM,WACN,eAAe,GAAC,MAAM,GAAC,IAAI,EAkDrC;IAaD;;;;OAIG;IACH,cAFa,OAAO,CAAC,OAAO,CAAC,CAI5B;IAED;;;;OAIG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;;;;;OAQG;IACH,YAFa,MAAM,CAmBlB;IAED;;;;;OAKG;IACH,WAFa,GAAG,CAQf;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;;;;OAIG;IACH,mBAFa,OAAO,CAInB;IAED;;;;;;;;;;;;;;OAcG;IACH,cAFa,eAAe,CAI3B;IAED,sBAEC;IAED;;;;;;;;;;;;;;;OAeG;IACH,YAXa,UAAU,CAatB;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,CAY3B;IAED;;;;;;;;;;;OAWG;IACH,cARa,OAAO,CAAC,MAAM,CAAC,CAkB3B;IAED;;;;;;;;;;;OAWG;IACH,eARW,MAAM,aACN,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CA+BzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,kBAXW,WAAW,GAAC,IAAI,GAAC,MAAM,GACrB,OAAO,CAAC,IAAI,CAAC,CAyBzB;IAED;;;;;;;;;;;;;;OAcG;IACH,gBAXW,MAAM,aACN,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAkC5B;IAED;;;;OAIG;IACH,UAFa,OAAO,CAAC,MAAM,CAAC,CAY3B;IAED;;;;;;;;;OASG;IACH,UAPa,OAAO,CAAC,IAAI,CAAC,CAiBzB;;CACF;eAhiBc,SAAS;4BADI,sBAAsB"}