@gesslar/toolkit 5.2.0 → 5.4.0

package/package.json

@@ -5,7 +5,7 @@
     "name": "gesslar",
     "url": "https://gesslar.dev"
   },
-  "version": "5.2.0",
+  "version": "5.4.0",
   "license": "0BSD",
   "homepage": "https://github.com/gesslar/toolkit#readme",
   "repository": {
@@ -77,17 +77,17 @@
   },
   "dependencies": {
     "@gesslar/colours": "^1.0.0",
-    "ajv": "^8.18.0",
+    "ajv": "^8.20.0",
     "json5": "^2.2.3",
     "supports-color": "^10.2.2",
-    "yaml": "^2.8.3"
+    "yaml": "^2.9.0"
   },
   "devDependencies": {
     "@gesslar/uglier": "^2.4.1",
     "@rollup/plugin-node-resolve": "^16.0.3",
-    "eslint": "^10.2.0",
+    "eslint": "^10.3.0",
     "happy-dom": "^20.9.0",
-    "rollup": "^4.60.1",
+    "rollup": "^4.60.3",
     "typescript": "^6.0.3"
   }
 }

package/src/browser/lib/Sass.js

@@ -89,17 +89,15 @@ export default class Sass extends Error {
       )
     }
 
-    if(this.cause) {
+    if(this.cause && nerdMode) {
       if(typeof this.cause.report === "function") {
-        if(nerdMode) {
-          console.error(
-            "\n" +
-            `[error] Caused By`
-          )
-        }
+        console.error(
+          "\n" +
+          `[error] Caused By`
+        )
 
         this.cause.report(nerdMode, true)
-      } else if(nerdMode && this.cause.stack) {
+      } else if(this.cause.stack) {
         console.error()
         console.group()
         console.error(

package/src/browser/lib/Util.js

@@ -166,25 +166,37 @@ export default class Util {
       Valid.type(supplied, "String", {allowEmpty: false})
       Valid.type(target, "String", {allowEmpty: false})
 
-      const suppliedSemver = supplied.split(".").filter(Boolean).map(Number).filter(e => !isNaN(e))
-      const targetSemver = target.split(".").filter(Boolean).map(Number).filter(e => !isNaN(e))
+      const {major: sMajor, minor: sMinor, patch: sPatch} =
+        this.semver.basic.exec(supplied)?.groups ?? {}
+      const {major: tMajor, minor: tMinor, patch: tPatch} =
+        this.semver.basic.exec(target)?.groups ?? {}
 
-      Valid.assert(suppliedSemver.length === 3, "Invalid format for supplied semver.")
-      Valid.assert(targetSemver.length === 3, "Invalid format for target semver.")
+      Valid.assert(Boolean(sMajor && sMinor && sPatch), "Invalid format for supplied semver.")
+      Valid.assert(Boolean(tMajor && tMinor && tPatch), "Invalid format for target semver.")
 
-      if(suppliedSemver[0] < targetSemver[0])
+      const isMajor = Number(sMajor)
+      const itMajor = Number(tMajor)
+      if(isMajor < itMajor)
         return false
 
-      if(suppliedSemver[0] === targetSemver[0]) {
-        if(suppliedSemver[1] < targetSemver[1])
+      if(isMajor === itMajor) {
+        const isMinor = Number(sMinor)
+        const itMinor = Number(tMinor)
+        if(isMinor < itMinor)
           return false
 
-        if(suppliedSemver[1] === targetSemver[1])
-          if(suppliedSemver[2] < targetSemver[2])
+        if(isMinor === itMinor) {
+          const isPatch = Number(sPatch)
+          const itPatch = Number(tPatch)
+          if(isPatch < itPatch)
             return false
+        }
       }
 
       return true
-    }
+    },
+
+    basic: /^(?<major>0|(?:[1-9]\d*))\.(?<minor>0|(?:[1-9]\d*))\.(?<patch>0|(?:[1-9]\d*))$/,
+    enhanced: /^(?<major>0|(?:[1-9]\d*))\.(?<minor>0|(?:[1-9]\d*))\.(?<patch>0|(?:[1-9]\d*))(?:-(?<prerelease>(?:0|(?:[1-9A-Za-z-][0-9A-Za-z-]*))(?:\.(?:0|(?:[1-9A-Za-z-][0-9A-Za-z-]*)))*))?(?:\+(?<build>(?:0|(?:[1-9A-Za-z-][0-9A-Za-z-]*))(?:\.(?:0|(?:[1-9A-Za-z-][0-9A-Za-z-]*)))*))?$/
   }
 }

package/src/node/lib/DirectoryObject.js

@@ -4,7 +4,7 @@
  * resolution and existence checks.
  */
 
-import {glob, mkdir, readdir, rmdir, stat} from "node:fs/promises"
+import {glob, lstat, mkdir, readdir, rmdir, stat} from "node:fs/promises"
 import path, {relative} from "node:path"
 import {URL} from "node:url"
 import {inspect} from "node:util"
@@ -59,6 +59,7 @@ import Valid from "./Valid.js"
  * @property {boolean} isDirectory - Always true
  * @property {DirectoryObject|null} parent - The parent directory (null if root)
  * @property {Promise<boolean>} exists - Whether the directory exists (async getter)
+ * @property {Promise<("none"|"symbolic"|null)>} linkType - The link kind at this path (async)
  *
  * @example
  * // Basic usage
@@ -225,6 +226,28 @@ export default class DirectoryObject extends FS {
     return this.#directoryExists()
   }
 
+  /**
+   * Reports the link kind at this path. Reads the filesystem on every
+   * access, like {@link DirectoryObject#exists}, and throws under the
+   * same conditions: if the path exists but is not a directory (broken
+   * symlink, symlink to a non-directory, or a regular file), this throws
+   * a {@link Sass} error rather than returning a misleading value.
+   *
+   * - `"symbolic"` - a symlink whose target is a directory that exists
+   * - `"none"` - a regular directory
+   * - `null` - the path does not exist at all
+   *
+   * Hard links are not reported for directories: most filesystems do not
+   * allow hard-linked directories at all, and `nlink` on a directory is
+   * not a usable signal (it counts `.` and each subdirectory's `..`).
+   *
+   * @returns {Promise<"none"|"symbolic"|null>} The link kind
+   * @throws {Sass} If the path exists but does not resolve to a directory
+   */
+  get linkType() {
+    return this.#directoryLinkType()
+  }
+
   /**
    * Return the path as passed to the constructor.
    *
@@ -363,13 +386,47 @@ export default class DirectoryObject extends FS {
     }
   }
 
+  /**
+   * Resolves the link kind at this path.
+   *
+   * @private
+   * @returns {Promise<"none"|"symbolic"|null>} The link kind
+   */
+  async #directoryLinkType() {
+    try {
+      const linkStats = await lstat(this.path).catch(error => error.code === "ENOENT" ? null : error)
+
+      if(linkStats instanceof Error)
+        throw linkStats
+
+      if(linkStats === null)
+        return null
+
+      if(linkStats.isSymbolicLink()) {
+        const targetStats = await stat(this.path)
+
+        if(!targetStats.isDirectory())
+          throw Sass.new(`Path exists but is not a directory: '${this.path}'`)
+
+        return "symbolic"
+      }
+
+      if(!linkStats.isDirectory())
+        throw Sass.new(`Path exists but is not a directory: '${this.path}'`)
+
+      return "none"
+    } catch(error) {
+      throw Sass.new(`Determining link type of '${this.path}'`, error)
+    }
+  }
+
   /**
    * Lists the contents of a directory, optionally filtered by a glob pattern.
    *
    * Returns FileObject and DirectoryObject instances. Symbolic links are
    * resolved to their target type: links to files appear in `files`, links
-   * to directories appear in `directories`. Broken symlinks propagate the
-   * stat error to the caller.
+   * to directories appear in `directories`. Broken symlinks (where the
+   * target does not exist) appear in `files` so they can be unlinked.
    *
    * @async
    * @param {string} [pat=""] - Optional glob pattern to filter results (e.g., "*.txt", "test-*")
@@ -415,8 +472,8 @@ export default class DirectoryObject extends FS {
    *
    * Returns FileObject and DirectoryObject instances. Symbolic links are
    * resolved to their target type: links to files appear in `files`, links
-   * to directories appear in `directories`. Broken symlinks propagate the
-   * stat error to the caller.
+   * to directories appear in `directories`. Broken symlinks (where the
+   * target does not exist) appear in `files` so they can be unlinked.
    *
    * @async
    * @param {string} [pat=""] - Glob pattern to filter results
@@ -451,7 +508,8 @@ export default class DirectoryObject extends FS {
   /**
    * Categorizes an array of Dirent objects into files and directories.
    * Resolves symbolic links to their target type via `fs.stat()`. Broken
-   * symlinks propagate the stat error to the caller.
+   * symlinks (where the target does not exist) are categorized as files
+   * so they can be unlinked.
    *
    * @private
    * @param {Array<import("node:fs").Dirent>} dirents - Directory entries to categorize
@@ -471,12 +529,19 @@ export default class DirectoryObject extends FS {
       } else if(dirent.isDirectory()) {
         result.directories.push(new this.constructor(fullPath))
       } else if(dirent.isSymbolicLink()) {
-        const stats = await stat(fullPath)
-
-        if(stats.isFile())
-          result.files.push(new FileObject(fullPath, this))
-        else if(stats.isDirectory())
-          result.directories.push(new this.constructor(fullPath))
+        try {
+          const stats = await stat(fullPath)
+
+          if(stats.isFile())
+            result.files.push(new FileObject(fullPath, this))
+          else if(stats.isDirectory())
+            result.directories.push(new this.constructor(fullPath))
+        } catch(error) {
+          if(error.code === "ENOENT")
+            result.files.push(new FileObject(fullPath, this))
+          else
+            throw error
+        }
       }
     }
 

package/src/node/lib/FileObject.js

@@ -29,6 +29,7 @@ import Valid from "./Valid.js"
  * @property {boolean} isFile - Always true for files
  * @property {DirectoryObject} parent - The parent directory object
  * @property {Promise<boolean>} exists - Whether the file exists (async)
+ * @property {Promise<("none"|"symbolic"|"broken"|"hard"|null)>} linkType - The link kind at this path (async)
  */
 
 export default class FileObject extends FS {
@@ -200,6 +201,24 @@ export default class FileObject extends FS {
     return this.#fileExists()
   }
 
+  /**
+   * Reports the link kind at this path. Reads the filesystem on every
+   * access, like {@link FileObject#exists}.
+   *
+   * - `"symbolic"` - a symlink whose target exists
+   * - `"broken"` - a symlink whose target does not exist
+   * - `"hard"` - a regular file with additional hard links (`nlink > 1`).
+   *   Hard links are inode-level and indistinguishable from each other,
+   *   so this only reports that *some* other entry shares the inode.
+   * - `"none"` - a regular file with no links
+   * - `null` - the path does not exist
+   *
+   * @returns {Promise<"none"|"symbolic"|"broken"|"hard"|null>} The link kind
+   */
+  get linkType() {
+    return this.#fileLinkType()
+  }
+
   /**
    * Return the normalized path that was provided to the constructor.
    *
@@ -328,7 +347,7 @@ export default class FileObject extends FS {
    */
   async #fileExists() {
     try {
-      const stats = await fs.stat(this.path).catch(error => error.code === "ENOENT" ? null : error)
+      const stats = await fs.lstat(this.path).catch(error => error.code === "ENOENT" ? null : error)
 
       if(stats instanceof Error)
         throw stats
@@ -336,7 +355,7 @@ export default class FileObject extends FS {
       if(stats === null)
         return false
 
-      if(!stats.isFile())
+      if(!stats.isFile() && !stats.isSymbolicLink())
         throw Sass.new(`Path exists but is not a file: '${this.path}'`)
 
       return true
@@ -345,6 +364,47 @@ export default class FileObject extends FS {
     }
   }
 
+  /**
+   * Resolves the link kind at this path.
+   *
+   * @private
+   * @returns {Promise<"none"|"symbolic"|"broken"|"hard"|null>} The link kind
+   */
+  async #fileLinkType() {
+    try {
+      const stats = await fs.lstat(this.path).catch(error => error.code === "ENOENT" ? null : error)
+
+      if(stats instanceof Error)
+        throw stats
+
+      if(stats === null)
+        return null
+
+      if(stats.isSymbolicLink()) {
+        try {
+          await fs.stat(this.path)
+
+          return "symbolic"
+        } catch(error) {
+          if(error.code === "ENOENT")
+            return "broken"
+
+          throw error
+        }
+      }
+
+      if(!stats.isFile())
+        throw Sass.new(`Path exists but is not a file: '${this.path}'`)
+
+      if(stats.nlink > 1)
+        return "hard"
+
+      return "none"
+    } catch(error) {
+      throw Sass.new(`Determining link type of '${this.path}'`, error)
+    }
+  }
+
   /**
    * Determines the size of a file.
    *

package/src/node/lib/Sass.js

@@ -40,17 +40,15 @@ export default class Sass extends BrowserSass {
       )
     }
 
-    if(this.cause) {
+    if(this.cause && nerdMode) {
       if(typeof this.cause.report === "function") {
-        if(nerdMode) {
-          Term.error(
-            "\n" +
-            `${Term.terminalBracket(["error", "Caused By"])}`
-          )
-        }
+        Term.error(
+          "\n" +
+          `${Term.terminalBracket(["error", "Caused By"])}`
+        )
 
         this.cause.report(nerdMode, true)
-      } else if(nerdMode && this.cause.stack) {
+      } else if(this.cause.stack) {
         Term.error()
         Term.group()
         Term.error(

package/types/browser/lib/Sass.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Sass.d.ts","sourceRoot":"","sources":["../../../src/browser/lib/Sass.js"],"names":[],"mappings":"AAeA;;;GAGG;AACH;IAgIE;;;;;;;;OAQG;IACH,mBALW,KAAK,WACL,MAAM,GACJ,IAAI,CAahB;IAED;;;;;;;;OAQG;IACH,sBAJW,MAAM,UACN,KAAK,GAAC,IAAI,GAAC,OAAO,GAChB,IAAI,CAchB;IAvKD;;;;;OAKG;IACH,qBAHW,MAAM,WACH,OAAO,EAAA,EAMpB;IAWD;;;;OAIG;IACH,mBAFW,MAAM,EAIhB;IAhBD;;;;OAIG;IACH,aAFa,KAAK,CAAC,MAAM,CAAC,CAIzB;IAWD;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,IAAI,CAShB;IAED;;;;;;OAMG;IACH,kBAHW,OAAO,aACP,OAAO,QAyCjB;;CA6EF;oBAjLmB,cAAc"}
+{"version":3,"file":"Sass.d.ts","sourceRoot":"","sources":["../../../src/browser/lib/Sass.js"],"names":[],"mappings":"AAeA;;;GAGG;AACH;IA8HE;;;;;;;;OAQG;IACH,mBALW,KAAK,WACL,MAAM,GACJ,IAAI,CAahB;IAED;;;;;;;;OAQG;IACH,sBAJW,MAAM,UACN,KAAK,GAAC,IAAI,GAAC,OAAO,GAChB,IAAI,CAchB;IArKD;;;;;OAKG;IACH,qBAHW,MAAM,WACH,OAAO,EAAA,EAMpB;IAWD;;;;OAIG;IACH,mBAFW,MAAM,EAIhB;IAhBD;;;;OAIG;IACH,aAFa,KAAK,CAAC,MAAM,CAAC,CAIzB;IAWD;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,IAAI,CAShB;IAED;;;;;;OAMG;IACH,kBAHW,OAAO,aACP,OAAO,QAuCjB;;CA6EF;oBA/KmB,cAAc"}

package/types/browser/lib/Util.d.ts

@@ -60,6 +60,8 @@ export default class Util {
     static regexify(input: any, trim?: boolean, flags?: any[]): RegExp;
     static semver: {
         meetsOrExceeds: (supplied: any, target: any) => boolean;
+        basic: RegExp;
+        enhanced: RegExp;
     };
 }
 //# sourceMappingURL=Util.d.ts.map

package/types/browser/lib/Util.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Util.d.ts","sourceRoot":"","sources":["../../../src/browser/lib/Util.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH;IACE;;;;;OAKG;IACH,wBAHW,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;;OAMG;IACH,YAJa,CAAC,MACH,MAAM,OAAO,CAAC,CAAC,CAAC,GACd,OAAO,CAAC;QAAC,MAAM,EAAE,CAAC,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC,CAQ9C;IAED;;;;;;;OAOG;IACH,4BAJW,MAAM,GAAC,MAAM,UACb,MAAM,GACJ,MAAM,CAWlB;IAED;;;;;;;OAOG;IACH,6BAJW,MAAM,GAAC,MAAM,UACb,MAAM,GACJ,MAAM,CAalB;IAED;;;;;;OAMG;IACH,8BAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAsBlB;IAED;;;;;;;;OAQG;IACH,+BALW,MAAM,iBACN,KAAK,CAAC,MAAM,CAAC,cACb,MAAM,GACJ,MAAM,CAwBlB;IAED,mEAkBC;IAED;;MAyBC;CACF"}
+{"version":3,"file":"Util.d.ts","sourceRoot":"","sources":["../../../src/browser/lib/Util.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH;IACE;;;;;OAKG;IACH,wBAHW,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;;OAMG;IACH,YAJa,CAAC,MACH,MAAM,OAAO,CAAC,CAAC,CAAC,GACd,OAAO,CAAC;QAAC,MAAM,EAAE,CAAC,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC,CAQ9C;IAED;;;;;;;OAOG;IACH,4BAJW,MAAM,GAAC,MAAM,UACb,MAAM,GACJ,MAAM,CAWlB;IAED;;;;;;;OAOG;IACH,6BAJW,MAAM,GAAC,MAAM,UACb,MAAM,GACJ,MAAM,CAalB;IAED;;;;;;OAMG;IACH,8BAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAsBlB;IAED;;;;;;;;OAQG;IACH,+BALW,MAAM,iBACN,KAAK,CAAC,MAAM,CAAC,cACb,MAAM,GACJ,MAAM,CAwBlB;IAED,mEAkBC;IAED;;;;MAqCC;CACF"}

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

@@ -40,6 +40,7 @@
  * @property {boolean} isDirectory - Always true
  * @property {DirectoryObject|null} parent - The parent directory (null if root)
  * @property {Promise<boolean>} exists - Whether the directory exists (async getter)
+ * @property {Promise<("none"|"symbolic"|null)>} linkType - The link kind at this path (async)
  *
  * @example
  * // Basic usage
@@ -100,6 +101,25 @@ export default class DirectoryObject extends FS {
      * @returns {Promise<boolean>} - A Promise that resolves to true or false
      */
     get exists(): Promise<boolean>;
+    /**
+     * Reports the link kind at this path. Reads the filesystem on every
+     * access, like {@link DirectoryObject#exists}, and throws under the
+     * same conditions: if the path exists but is not a directory (broken
+     * symlink, symlink to a non-directory, or a regular file), this throws
+     * a {@link Sass} error rather than returning a misleading value.
+     *
+     * - `"symbolic"` - a symlink whose target is a directory that exists
+     * - `"none"` - a regular directory
+     * - `null` - the path does not exist at all
+     *
+     * Hard links are not reported for directories: most filesystems do not
+     * allow hard-linked directories at all, and `nlink` on a directory is
+     * not a usable signal (it counts `.` and each subdirectory's `..`).
+     *
+     * @returns {Promise<"none"|"symbolic"|null>} The link kind
+     * @throws {Sass} If the path exists but does not resolve to a directory
+     */
+    get linkType(): Promise<"none" | "symbolic" | null>;
     /**
      * Return the path as passed to the constructor.
      *
@@ -176,8 +196,8 @@ export default class DirectoryObject extends FS {
      *
      * Returns FileObject and DirectoryObject instances. Symbolic links are
      * resolved to their target type: links to files appear in `files`, links
-     * to directories appear in `directories`. Broken symlinks propagate the
-     * stat error to the caller.
+     * to directories appear in `directories`. Broken symlinks (where the
+     * target does not exist) appear in `files` so they can be unlinked.
      *
      * @async
      * @param {string} [pat=""] - Optional glob pattern to filter results (e.g., "*.txt", "test-*")
@@ -202,8 +222,8 @@ export default class DirectoryObject extends FS {
      *
      * Returns FileObject and DirectoryObject instances. Symbolic links are
      * resolved to their target type: links to files appear in `files`, links
-     * to directories appear in `directories`. Broken symlinks propagate the
-     * stat error to the caller.
+     * to directories appear in `directories`. Broken symlinks (where the
+     * target does not exist) appear in `files` so they can be unlinked.
      *
      * @async
      * @param {string} [pat=""] - Glob pattern to filter results

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;;;;GAIG;AAEH;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH;yBAoGa,MAAM,WACN,MAAM,oBAEJ,MAAM;IAhDnB;;;;;;;;;OASG;IACH,kBALa,eAAe,CAO3B;IA7CD;;;;OAIG;IACH,uBAFW,MAAM,OAAC,EA4BjB;IAyBD;;;;OAIG;IACH,UAFa,MAAM,CAclB;IA8BD;;;;OAIG;IACH,WAFa,MAAM,CAIlB;IAED;;;;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;IA2BD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,WAZW,MAAM,iBACJ,OAAO,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;QAAC,WAAW,EAAE,KAAK,CAAC,eAAe,CAAC,CAAA;KAAC,CAAC,CAkCpF;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,WAXW,MAAM,iBACJ,OAAO,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;QAAC,WAAW,EAAE,KAAK,CAAC,eAAe,CAAC,CAAA;KAAC,CAAC,CA0BpF;IAqCD;;;;;;;;;;;;OAYG;IACH,uBARW,MAAM,GACJ,OAAO,CAAC,SAAS,CAAC,CAuB9B;IAyBD;;;;;;;;;;;;;;;OAeG;IACH,cAZa,eAAe,CAc3B;IAED;;;;;;;;;;;;;;OAcG;IACH,UARa,OAAO,CAAC,SAAS,CAAC,CAkB9B;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAM5B;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAM5B;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,sBAbW,MAAM,GACJ,eAAe,CAgC3B;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,kBAbW,MAAM,GACJ,UAAU,CAgCtB;IA/fD;;;;;;;OAOG;IACH,2BAHW,QAAQ,GAAC,QAAQ,GAAC,SAAS,GACzB,MAAM,GAAC,MAAM,CAQzB;;CAkfF;;UA9qBa,MAAY;QAAC,KAAK,EAAE,eAAe,CAAC;QAAC,IAAI,EAAE,OAAO,CAAA;KAAC;eACnD,MAAY,aAAa;;;;;;iBAMzB,OAAO;;;;eACP,MAAM,GAAC,IAAI;;;;YACX,MAAM,GAAC,IAAI;;;;UACX,MAAM,GAAC,IAAI;;;;YACX,eAAe,GAAC,SAAS;;;;gBACzB,MAAM,GAAC,IAAI;;;;UACX,MAAM,GAAC,IAAI;;;;SACX,MAAM,GAAC,IAAI;;;;cACX,MAAM,GAAC,IAAI;;;;WACX,KAAK,CAAC,MAAM,CAAC,GAAC,IAAI;;;;SAClB,GAAG,GAAC,IAAI;;eAvBP,iBAAiB;uBADT,iBAAiB"}
+{"version":3,"file":"DirectoryObject.d.ts","sourceRoot":"","sources":["../../../src/node/lib/DirectoryObject.js"],"names":[],"mappings":"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"}

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

@@ -11,6 +11,7 @@
  * @property {boolean} isFile - Always true for files
  * @property {DirectoryObject} parent - The parent directory object
  * @property {Promise<boolean>} exists - Whether the file exists (async)
+ * @property {Promise<("none"|"symbolic"|"broken"|"hard"|null)>} linkType - The link kind at this path (async)
  */
 export default class FileObject extends FS {
     [x: number]: (depth: number, options: object, ins: Function) => string;
@@ -52,6 +53,21 @@ export default class FileObject extends FS {
      * @returns {Promise<boolean>} - A Promise that resolves to true or false
      */
     get exists(): Promise<boolean>;
+    /**
+     * Reports the link kind at this path. Reads the filesystem on every
+     * access, like {@link FileObject#exists}.
+     *
+     * - `"symbolic"` - a symlink whose target exists
+     * - `"broken"` - a symlink whose target does not exist
+     * - `"hard"` - a regular file with additional hard links (`nlink > 1`).
+     *   Hard links are inode-level and indistinguishable from each other,
+     *   so this only reports that *some* other entry shares the inode.
+     * - `"none"` - a regular file with no links
+     * - `null` - the path does not exist
+     *
+     * @returns {Promise<"none"|"symbolic"|"broken"|"hard"|null>} The link kind
+     */
+    get linkType(): Promise<"none" | "symbolic" | "broken" | "hard" | null>;
     /**
      * Return the normalized path that was provided to the constructor.
      *

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;yBA8Ha,MAAM,WACN,MAAM,oBAEJ,MAAM;IAggBnB;;;;;;;;;;;OAWG;IACH,kBAPa,UAAU,CAsCtB;IAjpBD;;;;;OAKG;IACH,uBAHW,MAAM,WACN,eAAe,GAAC,MAAM,GAAC,IAAI,EA+DrC;IAWD;;;;OAIG;IACH,UAFa,MAAM,CAalB;IA8BD;;;;OAIG;IACH,WAFa,MAAM,CAIlB;IAED;;;;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;IA2BD;;;;OAIG;IACH,QAFa,OAAO,CAAC,MAAM,OAAC,CAAC,CAU5B;IAED;;;;;OAKG;IACH,YAFa,OAAO,CAAC,IAAI,OAAC,CAAC,CAU1B;IAED;;;;OAIG;IACH,cAFa,OAAO,CAInB;IAED;;;;;;;OAOG;IACH,kBAJW,KAAK,GACH,UAAU,CAYtB;IAED;;;;OAIG;IACH,eAFa,UAAU,CAOtB;IAED;;;;OAIG;IACH,cAFa,UAAU,CAMtB;IAED;;;;;;;OAOG;IACH,+BAJG;QAAyB,QAAQ,GAAzB,MAAM;QACY,SAAS,GAA3B,OAAO;KACf,GAAU,OAAO,CAAC,MAAM,CAAC,CAa3B;IAED;;;;;;;;;;;OAWG;IACH,cARa,OAAO,CAAC,MAAM,CAAC,CAe3B;IAED;;;;;;;;;;;OAWG;IACH,eARW,MAAM,aACN,MAAM,GACJ,OAAO,CAAC,SAAS,CAAC,CAiB9B;IAED;;;;;;;;;;;;;;;OAeG;IACH,kBAXW,WAAW,GAAC,IAAI,GAAC,MAAM,GACrB,OAAO,CAAC,SAAS,CAAC,CAwB9B;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,yCAZG;QAAyB,IAAI,GAArB,MAAM;QACW,QAAQ,GAAzB,MAAM;QACY,SAAS,GAA3B,OAAO;KACf,GAAU,OAAO,CAAC,OAAO,CAAC,CAqB5B;IAED;;;;OAIG;IACH,UAFa,OAAO,CAAC,MAAM,CAAC,CAS3B;IAED;;;;;;;;;;;;OAYG;IACH,kBATW,MAAM,GACJ,OAAO,CAAC,UAAU,CAAC,CAyB/B;IAED;;;;;;;;;;;;;OAaG;IACH,kBATW,MAAM,GACJ,OAAO,CAAC,UAAU,CAAC,CA0C/B;IAED;;;;;;;;;OASG;IACH,UAPa,OAAO,CAAC,SAAS,CAAC,CAc9B;IAxfD;;;;;;;OAOG;IACH,2BAHW,QAAQ,GAAC,QAAQ,GAAC,SAAS,GACzB,MAAM,GAAC,MAAM,CAQzB;;CAwhBF;eAhsBc,iBAAiB;4BADJ,sBAAsB;kBAFhC,YAAY"}
+{"version":3,"file":"FileObject.d.ts","sourceRoot":"","sources":["../../../src/node/lib/FileObject.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;GAcG;AAEH;yBA8Ha,MAAM,WACN,MAAM,oBAEJ,MAAM;IA2jBnB;;;;;;;;;;;OAWG;IACH,kBAPa,UAAU,CAsCtB;IA5sBD;;;;;OAKG;IACH,uBAHW,MAAM,WACN,eAAe,GAAC,MAAM,GAAC,IAAI,EA+DrC;IAWD;;;;OAIG;IACH,UAFa,MAAM,CAalB;IA8BD;;;;OAIG;IACH,WAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,cAFa,OAAO,CAAC,OAAO,CAAC,CAI5B;IAED;;;;;;;;;;;;;OAaG;IACH,gBAFa,OAAO,CAAC,MAAM,GAAC,UAAU,GAAC,QAAQ,GAAC,MAAM,GAAC,IAAI,CAAC,CAI3D;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;IAoED;;;;OAIG;IACH,QAFa,OAAO,CAAC,MAAM,OAAC,CAAC,CAU5B;IAED;;;;;OAKG;IACH,YAFa,OAAO,CAAC,IAAI,OAAC,CAAC,CAU1B;IAED;;;;OAIG;IACH,cAFa,OAAO,CAInB;IAED;;;;;;;OAOG;IACH,kBAJW,KAAK,GACH,UAAU,CAYtB;IAED;;;;OAIG;IACH,eAFa,UAAU,CAOtB;IAED;;;;OAIG;IACH,cAFa,UAAU,CAMtB;IAED;;;;;;;OAOG;IACH,+BAJG;QAAyB,QAAQ,GAAzB,MAAM;QACY,SAAS,GAA3B,OAAO;KACf,GAAU,OAAO,CAAC,MAAM,CAAC,CAa3B;IAED;;;;;;;;;;;OAWG;IACH,cARa,OAAO,CAAC,MAAM,CAAC,CAe3B;IAED;;;;;;;;;;;OAWG;IACH,eARW,MAAM,aACN,MAAM,GACJ,OAAO,CAAC,SAAS,CAAC,CAiB9B;IAED;;;;;;;;;;;;;;;OAeG;IACH,kBAXW,WAAW,GAAC,IAAI,GAAC,MAAM,GACrB,OAAO,CAAC,SAAS,CAAC,CAwB9B;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,yCAZG;QAAyB,IAAI,GAArB,MAAM;QACW,QAAQ,GAAzB,MAAM;QACY,SAAS,GAA3B,OAAO;KACf,GAAU,OAAO,CAAC,OAAO,CAAC,CAqB5B;IAED;;;;OAIG;IACH,UAFa,OAAO,CAAC,MAAM,CAAC,CAS3B;IAED;;;;;;;;;;;;OAYG;IACH,kBATW,MAAM,GACJ,OAAO,CAAC,UAAU,CAAC,CAyB/B;IAED;;;;;;;;;;;;;OAaG;IACH,kBATW,MAAM,GACJ,OAAO,CAAC,UAAU,CAAC,CA0C/B;IAED;;;;;;;;;OASG;IACH,UAPa,OAAO,CAAC,SAAS,CAAC,CAc9B;IAnjBD;;;;;;;OAOG;IACH,2BAHW,QAAQ,GAAC,QAAQ,GAAC,SAAS,GACzB,MAAM,GAAC,MAAM,CAQzB;;CAmlBF;eA5vBc,iBAAiB;4BADJ,sBAAsB;kBAFhC,YAAY"}

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

@@ -1 +1 @@
-{"version":3,"file":"Sass.d.ts","sourceRoot":"","sources":["../../../src/node/lib/Sass.js"],"names":[],"mappings":"AAgBA;;;GAGG;AACH;IACE;;;;;OAKG;IACH,kBAFW,OAAO,QAuCjB;;CAiCF;wBApFuB,2BAA2B"}
+{"version":3,"file":"Sass.d.ts","sourceRoot":"","sources":["../../../src/node/lib/Sass.js"],"names":[],"mappings":"AAgBA;;;GAGG;AACH;IACE;;;;;OAKG;IACH,kBAFW,OAAO,QAqCjB;;CAiCF;wBAlFuB,2BAA2B"}

package/vendor/toolkit.esm.js

@@ -1,4 +1,4 @@
-// @gesslar/toolkit v5.2.0 - ES module bundle
+// @gesslar/toolkit v5.4.0 - ES module bundle
 /**
  * @file Tantrum.js
  *
@@ -208,17 +208,15 @@ class Sass extends Error {
       );
     }
 
-    if(this.cause) {
+    if(this.cause && nerdMode) {
       if(typeof this.cause.report === "function") {
-        if(nerdMode) {
-          console.error(
-            "\n" +
-            `[error] Caused By`
-          );
-        }
+        console.error(
+          "\n" +
+          `[error] Caused By`
+        );
 
         this.cause.report(nerdMode, true);
-      } else if(nerdMode && this.cause.stack) {
+      } else if(this.cause.stack) {
         console.error();
         console.group();
         console.error(
@@ -561,26 +559,38 @@ class Util {
       Valid.type(supplied, "String", {allowEmpty: false});
       Valid.type(target, "String", {allowEmpty: false});
 
-      const suppliedSemver = supplied.split(".").filter(Boolean).map(Number).filter(e => !isNaN(e));
-      const targetSemver = target.split(".").filter(Boolean).map(Number).filter(e => !isNaN(e));
+      const {major: sMajor, minor: sMinor, patch: sPatch} =
+        this.semver.basic.exec(supplied)?.groups ?? {};
+      const {major: tMajor, minor: tMinor, patch: tPatch} =
+        this.semver.basic.exec(target)?.groups ?? {};
 
-      Valid.assert(suppliedSemver.length === 3, "Invalid format for supplied semver.");
-      Valid.assert(targetSemver.length === 3, "Invalid format for target semver.");
+      Valid.assert(Boolean(sMajor && sMinor && sPatch), "Invalid format for supplied semver.");
+      Valid.assert(Boolean(tMajor && tMinor && tPatch), "Invalid format for target semver.");
 
-      if(suppliedSemver[0] < targetSemver[0])
+      const isMajor = Number(sMajor);
+      const itMajor = Number(tMajor);
+      if(isMajor < itMajor)
         return false
 
-      if(suppliedSemver[0] === targetSemver[0]) {
-        if(suppliedSemver[1] < targetSemver[1])
+      if(isMajor === itMajor) {
+        const isMinor = Number(sMinor);
+        const itMinor = Number(tMinor);
+        if(isMinor < itMinor)
           return false
 
-        if(suppliedSemver[1] === targetSemver[1])
-          if(suppliedSemver[2] < targetSemver[2])
+        if(isMinor === itMinor) {
+          const isPatch = Number(sPatch);
+          const itPatch = Number(tPatch);
+          if(isPatch < itPatch)
             return false
+        }
       }
 
       return true
-    }
+    },
+
+    basic: /^(?<major>0|(?:[1-9]\d*))\.(?<minor>0|(?:[1-9]\d*))\.(?<patch>0|(?:[1-9]\d*))$/,
+    enhanced: /^(?<major>0|(?:[1-9]\d*))\.(?<minor>0|(?:[1-9]\d*))\.(?<patch>0|(?:[1-9]\d*))(?:-(?<prerelease>(?:0|(?:[1-9A-Za-z-][0-9A-Za-z-]*))(?:\.(?:0|(?:[1-9A-Za-z-][0-9A-Za-z-]*)))*))?(?:\+(?<build>(?:0|(?:[1-9A-Za-z-][0-9A-Za-z-]*))(?:\.(?:0|(?:[1-9A-Za-z-][0-9A-Za-z-]*)))*))?$/
   }
 }
 

package/vendor/toolkit.umd.js

@@ -1,4 +1,4 @@
-// @gesslar/toolkit v5.2.0 - UMD bundle
+// @gesslar/toolkit v5.4.0 - UMD bundle
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
   typeof define === 'function' && define.amd ? define(['exports'], factory) :
@@ -214,17 +214,15 @@
         );
       }
 
-      if(this.cause) {
+      if(this.cause && nerdMode) {
         if(typeof this.cause.report === "function") {
-          if(nerdMode) {
-            console.error(
-              "\n" +
-              `[error] Caused By`
-            );
-          }
+          console.error(
+            "\n" +
+            `[error] Caused By`
+          );
 
           this.cause.report(nerdMode, true);
-        } else if(nerdMode && this.cause.stack) {
+        } else if(this.cause.stack) {
           console.error();
           console.group();
           console.error(
@@ -567,26 +565,38 @@
         Valid.type(supplied, "String", {allowEmpty: false});
         Valid.type(target, "String", {allowEmpty: false});
 
-        const suppliedSemver = supplied.split(".").filter(Boolean).map(Number).filter(e => !isNaN(e));
-        const targetSemver = target.split(".").filter(Boolean).map(Number).filter(e => !isNaN(e));
+        const {major: sMajor, minor: sMinor, patch: sPatch} =
+          this.semver.basic.exec(supplied)?.groups ?? {};
+        const {major: tMajor, minor: tMinor, patch: tPatch} =
+          this.semver.basic.exec(target)?.groups ?? {};
 
-        Valid.assert(suppliedSemver.length === 3, "Invalid format for supplied semver.");
-        Valid.assert(targetSemver.length === 3, "Invalid format for target semver.");
+        Valid.assert(Boolean(sMajor && sMinor && sPatch), "Invalid format for supplied semver.");
+        Valid.assert(Boolean(tMajor && tMinor && tPatch), "Invalid format for target semver.");
 
-        if(suppliedSemver[0] < targetSemver[0])
+        const isMajor = Number(sMajor);
+        const itMajor = Number(tMajor);
+        if(isMajor < itMajor)
           return false
 
-        if(suppliedSemver[0] === targetSemver[0]) {
-          if(suppliedSemver[1] < targetSemver[1])
+        if(isMajor === itMajor) {
+          const isMinor = Number(sMinor);
+          const itMinor = Number(tMinor);
+          if(isMinor < itMinor)
             return false
 
-          if(suppliedSemver[1] === targetSemver[1])
-            if(suppliedSemver[2] < targetSemver[2])
+          if(isMinor === itMinor) {
+            const isPatch = Number(sPatch);
+            const itPatch = Number(tPatch);
+            if(isPatch < itPatch)
               return false
+          }
         }
 
         return true
-      }
+      },
+
+      basic: /^(?<major>0|(?:[1-9]\d*))\.(?<minor>0|(?:[1-9]\d*))\.(?<patch>0|(?:[1-9]\d*))$/,
+      enhanced: /^(?<major>0|(?:[1-9]\d*))\.(?<minor>0|(?:[1-9]\d*))\.(?<patch>0|(?:[1-9]\d*))(?:-(?<prerelease>(?:0|(?:[1-9A-Za-z-][0-9A-Za-z-]*))(?:\.(?:0|(?:[1-9A-Za-z-][0-9A-Za-z-]*)))*))?(?:\+(?<build>(?:0|(?:[1-9A-Za-z-][0-9A-Za-z-]*))(?:\.(?:0|(?:[1-9A-Za-z-][0-9A-Za-z-]*)))*))?$/
     }
   }