@gesslar/toolkit 5.0.1 → 5.2.0

package/README.md

@@ -47,7 +47,6 @@ Includes all browser functionality plus Node.js-specific modules for file I/O, l
 | Valid | Validation and assertion methods |
 | Watcher | File and directory change watcher with debounce protection |
 
-
 ## Installation
 
 ```shell
@@ -151,7 +150,7 @@ Sincerely, Senator Yabba of the Dabba (Doo)
 
 ## License
 
-`@gesslar/toolkit` is released into the public domain under the [0BSD](LICENSE.txt).
+`@gesslar/toolkit` is released under the [0BSD](LICENSE.txt).
 
 This package includes or depends on third-party components under their own
 licenses:

package/package.json

@@ -5,7 +5,7 @@
     "name": "gesslar",
     "url": "https://gesslar.dev"
   },
-  "version": "5.0.1",
+  "version": "5.2.0",
   "license": "0BSD",
   "homepage": "https://github.com/gesslar/toolkit#readme",
   "repository": {
@@ -55,7 +55,7 @@
     "LICENSE.txt"
   ],
   "engines": {
-    "node": ">=24.11.0"
+    "node": ">=24"
   },
   "scripts": {
     "preinstall": "node ./scripts/check-node-version.mjs",
@@ -83,11 +83,11 @@
     "yaml": "^2.8.3"
   },
   "devDependencies": {
-    "@gesslar/uglier": "^2.4.0",
+    "@gesslar/uglier": "^2.4.1",
     "@rollup/plugin-node-resolve": "^16.0.3",
     "eslint": "^10.2.0",
-    "happy-dom": "^20.8.9",
+    "happy-dom": "^20.9.0",
     "rollup": "^4.60.1",
-    "typescript": "^6.0.2"
+    "typescript": "^6.0.3"
   }
 }

package/src/browser/lib/TypeSpec.js

@@ -193,7 +193,7 @@ export default class TypeSpec {
       // Handle non-array values
       if(!isArray && !allowedArray) {
         if(valueType === allowedType)
-          return allowEmpty || !empty
+          return Data.isBaseType(value, allowedType) && (allowEmpty || !empty)
 
         if(valueType === "Null" || valueType === "Undefined")
           return false

package/src/browser/lib/Valid.js

@@ -9,21 +9,36 @@ import Sass from "./Sass.js"
 import Data from "./Data.js"
 import Collection from "./Collection.js"
 
+/**
+ * Options for type validation methods.
+ *
+ * @typedef {object} TypeValidationOptions
+ * @property {boolean} [allowEmpty=true] - Whether empty values are allowed
+ */
+
 /**
  * Validation utility class providing type checking and assertion methods.
  */
 export default class Valid {
+  /** @type {typeof Sass} */
+  static _Sass = Sass
+
   /**
    * Validates a value against a type. Uses Data.isType.
    *
    * @param {unknown} value - The value to validate
    * @param {string} type - The expected type in the form of "object", "object[]", "object|object[]"
-   * @param {object} [options] - Additional options for validation.
+   * @param {TypeValidationOptions} [options] - Additional options for validation.
    */
   static type(value, type, options) {
-    Valid.assert(
+    const expected = [type]
+
+    if(options?.allowEmpty !== true)
+      expected.push("[no empty values]")
+
+    this.assert(
       Data.isType(value, type, options),
-      `Invalid type. Expected ${type}, got ${Data.typeOf(value)}`
+      `Invalid type. Expected ${expected.join(" ")}, got ${Data.typeOf(value)}`
     )
   }
 
@@ -37,23 +52,20 @@ export default class Valid {
    *                         met (optional)
    */
   static assert(condition, message, arg = null) {
-    if(!Data.isType(condition, "boolean")) {
-      throw Sass.new(`Condition must be a boolean, got ${condition}`)
-    }
+    if(!Data.isType(condition, "boolean"))
+      throw this._Sass.new(`Condition must be a boolean, got ${condition}`)
 
-    if(!Data.isType(message, "string")) {
-      throw Sass.new(`Message must be a string, got ${message}`)
-    }
+    if(!Data.isType(message, "string"))
+      throw this._Sass.new(`Message must be a string, got ${message}`)
 
-    if(!(arg === null || arg === undefined || typeof arg === "number")) {
-      throw Sass.new(`Arg must be a number, got ${arg}`)
-    }
+    if(!(arg === null || arg === undefined || typeof arg === "number"))
+      throw this._Sass.new(`Arg must be a number, got ${arg}`)
 
     if(!condition)
-      throw Sass.new(`${message}${arg ? `: ${arg}` : ""}`)
+      throw this._Sass.new(`${message}${arg ? `: ${arg}` : ""}`)
   }
 
-  static #restrictedProto = ["__proto__", "constructor", "prototype"]
+  static #restrictedProto = Object.freeze(["__proto__", "constructor", "prototype"])
 
   /**
    * Protects against prototype pollution by checking keys for dangerous property names.
@@ -63,11 +75,13 @@ export default class Valid {
    * @throws {Sass} If any key matches restricted prototype properties (__proto__, constructor, prototype)
    */
   static prototypePollutionProtection(keys) {
-    Valid.type(keys, "String[]")
+    this.type(keys, "String[]")
 
-    const oopsIDidItAgain = Collection.intersection(this.#restrictedProto, keys)
+    const oopsIDidItAgain = Collection.intersection(
+      Valid.#restrictedProto, keys
+    )
 
-    Valid.assert(
+    this.assert(
       oopsIDidItAgain.length === 0,
       `We don't pee in your pool, don't pollute ours with your ${String(oopsIDidItAgain)}`
     )

package/src/node/lib/Cache.js

@@ -1,4 +1,4 @@
-import Valid from "../../browser/lib/Valid.js"
+import Valid from "./Valid.js"
 import Data from "./Data.js"
 import Sass from "./Sass.js"
 

package/src/node/lib/DirectoryObject.js

@@ -4,7 +4,7 @@
  * resolution and existence checks.
  */
 
-import {glob, mkdir, opendir, readdir, rmdir, stat} from "node:fs/promises"
+import {glob, mkdir, readdir, rmdir, stat} from "node:fs/promises"
 import path, {relative} from "node:path"
 import {URL} from "node:url"
 import {inspect} from "node:util"
@@ -342,16 +342,24 @@ export default class DirectoryObject extends FS {
    * Check if a directory exists
    *
    * @returns {Promise<boolean>} Whether the directory exists
+   * @throws {Sass} If the path exists but is not a directory
    */
   async #directoryExists() {
-    const path = this.path
-
     try {
-      (await opendir(path)).close()
+      const stats = await stat(this.path).catch(error => error.code === "ENOENT" ? null : error)
+
+      if(stats instanceof Error)
+        throw stats
+
+      if(stats === null)
+        return false
+
+      if(!stats.isDirectory())
+        throw Sass.new(`Path exists but is not a directory: '${this.path}'`)
 
       return true
-    } catch {
-      return false
+    } catch(error) {
+      throw Sass.new(`Determining status of '${this.path}'`, error)
     }
   }
 
@@ -583,9 +591,9 @@ export default class DirectoryObject extends FS {
    * @returns {Promise<boolean>} True if the file exists, false otherwise
    */
   async hasFile(filename) {
-    const file = new FileObject(filename, this)
+    const file = this.getFile(filename)
 
-    return await file.exists
+    return await file.exists.catch(() => false)
   }
 
   /**
@@ -595,10 +603,9 @@ export default class DirectoryObject extends FS {
    * @returns {Promise<boolean>} True if the directory exists, false otherwise
    */
   async hasDirectory(dirname) {
-    const dir = FS.resolvePath(this.path, dirname)
-    const directory = new DirectoryObject(dir)
+    const dir = this.getDirectory(dirname)
 
-    return await directory.exists
+    return await dir.exists.catch(() => false)
   }
 
   /**

package/src/node/lib/FileObject.js

@@ -324,14 +324,24 @@ export default class FileObject extends FS {
    * Check if a file exists
    *
    * @returns {Promise<boolean>} Whether the file exists
+   * @throws {Sass} If the path exists but is not a file
    */
   async #fileExists() {
     try {
-      await fs.access(this.path, fs.constants.F_OK)
+      const stats = await fs.stat(this.path).catch(error => error.code === "ENOENT" ? null : error)
+
+      if(stats instanceof Error)
+        throw stats
+
+      if(stats === null)
+        return false
+
+      if(!stats.isFile())
+        throw Sass.new(`Path exists but is not a file: '${this.path}'`)
 
       return true
-    } catch {
-      return false
+    } catch(error) {
+      throw Sass.new(`Determining status of '${this.path}'`, error)
     }
   }
 

package/src/node/lib/Valid.js

@@ -2,85 +2,17 @@
  * @file Valid.js
  *
  * Node-flavoured validation utilities that throw the Node Sass error type.
- * Mirrors the browser Valid API so browser and Node callers behave the same.
+ * Extends the browser Valid, swapping in the Node Sass for richer reporting.
  */
 
+import BrowserValid from "../../browser/lib/Valid.js"
 import Sass from "./Sass.js"
-import Data from "../../browser/lib/Data.js"
-import Collection from "../../browser/lib/Collection.js"
-
-/**
- * Options for type validation methods.
- *
- * @typedef {object} TypeValidationOptions
- * @property {boolean} [allowEmpty=true] - Whether empty values are allowed
- */
 
 /**
  * Validation utility class providing type checking and assertion methods.
+ * Inherits all behaviour from browser Valid; only the Sass class differs.
  */
-export default class Valid {
-  static #restrictedProto = ["__proto__", "constructor", "prototype"]
-
-  /**
-   * Validates a value against a type. Uses Data.isType.
-   *
-   * @param {unknown} value - The value to validate
-   * @param {string} type - The expected type in the form of "object", "object[]", "object|object[]"
-   * @param {TypeValidationOptions} [options] - Additional options for validation.
-   */
-  static type(value, type, options) {
-    const expected = [type]
-
-    if(options?.allowEmpty !== true)
-      expected.push("[no empty values]")
-
-    Valid.assert(
-      Data.isType(value, type, options),
-      `Invalid type. Expected ${expected.join(" ")}, got ${Data.typeOf(value)}`
-    )
-  }
-
-  /**
-   * Asserts a condition
-   *
-   * @param {boolean} condition - The condition to assert
-   * @param {string} message - The message to display if the condition is not
-   *                           met
-   * @param {number} [arg] - The argument to display if the condition is not
-   *                         met (optional)
-   */
-  static assert(condition, message, arg = null) {
-    if(!Data.isType(condition, "boolean"))
-      throw Sass.new(`Condition must be a boolean, got ${condition}`)
-
-    if(!Data.isType(message, "string"))
-      throw Sass.new(`Message must be a string, got ${message}`)
-
-    if(!(arg === null || arg === undefined || typeof arg === "number"))
-      throw Sass.new(`Arg must be a number, got ${arg}`)
-
-    if(!condition)
-      throw Sass.new(`${message}${arg ? `: ${arg}` : ""}`)
-  }
-
-  /**
-   * Protects against prototype pollution by checking keys for dangerous
-   * property names.
-   *
-   * Throws if any restricted prototype properties are found in the keys array.
-   *
-   * @param {Array<string>} keys - Array of property keys to validate
-   * @throws {Sass} If any key matches restricted prototype properties (__proto__, constructor, prototype)
-   */
-  static prototypePollutionProtection(keys) {
-    Valid.type(keys, "String[]")
-
-    const oopsIDidItAgain = Collection.intersection(this.#restrictedProto, keys)
-
-    Valid.assert(
-      oopsIDidItAgain.length === 0,
-      `We don't pee in your pool, don't pollute ours with your ${String(oopsIDidItAgain)}`
-    )
-  }
+export default class Valid extends BrowserValid {
+  /** @type {typeof Sass} */
+  static _Sass = Sass
 }

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

@@ -1,15 +1,23 @@
+/**
+ * Options for type validation methods.
+ *
+ * @typedef {object} TypeValidationOptions
+ * @property {boolean} [allowEmpty=true] - Whether empty values are allowed
+ */
 /**
  * Validation utility class providing type checking and assertion methods.
  */
 export default class Valid {
+    /** @type {typeof Sass} */
+    static _Sass: typeof Sass;
     /**
      * Validates a value against a type. Uses Data.isType.
      *
      * @param {unknown} value - The value to validate
      * @param {string} type - The expected type in the form of "object", "object[]", "object|object[]"
-     * @param {object} [options] - Additional options for validation.
+     * @param {TypeValidationOptions} [options] - Additional options for validation.
      */
-    static type(value: unknown, type: string, options?: object): void;
+    static type(value: unknown, type: string, options?: TypeValidationOptions): void;
     /**
      * Asserts a condition
      *
@@ -20,7 +28,7 @@ export default class Valid {
      *                         met (optional)
      */
     static assert(condition: boolean, message: string, arg?: number): void;
-    static #restrictedProto: string[];
+    static #restrictedProto: readonly string[];
     /**
      * Protects against prototype pollution by checking keys for dangerous property names.
      * Throws if any restricted prototype properties are found in the keys array.
@@ -30,4 +38,14 @@ export default class Valid {
      */
     static prototypePollutionProtection(keys: Array<string>): void;
 }
+/**
+ * Options for type validation methods.
+ */
+export type TypeValidationOptions = {
+    /**
+     * - Whether empty values are allowed
+     */
+    allowEmpty?: boolean;
+};
+import Sass from "./Sass.js";
 //# sourceMappingURL=Valid.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Valid.d.ts","sourceRoot":"","sources":["../../../src/browser/lib/Valid.js"],"names":[],"mappings":"AAWA;;GAEG;AACH;IACE;;;;;;OAMG;IACH,mBAJW,OAAO,QACP,MAAM,YACN,MAAM,QAOhB;IAED;;;;;;;;OAQG;IACH,yBANW,OAAO,WACP,MAAM,QAEN,MAAM,QAkBhB;IAED,kCAAmE;IAEnE;;;;;;OAMG;IACH,0CAHW,KAAK,CAAC,MAAM,CAAC,QAYvB;CACF"}
+{"version":3,"file":"Valid.d.ts","sourceRoot":"","sources":["../../../src/browser/lib/Valid.js"],"names":[],"mappings":"AAWA;;;;;GAKG;AAEH;;GAEG;AACH;IACE,0BAA0B;IAC1B,cADW,OAAO,IAAI,CACH;IAEnB;;;;;;OAMG;IACH,mBAJW,OAAO,QACP,MAAM,YACN,qBAAqB,QAY/B;IAED;;;;;;;;OAQG;IACH,yBANW,OAAO,WACP,MAAM,QAEN,MAAM,QAehB;IAED,2CAAkF;IAElF;;;;;;OAMG;IACH,0CAHW,KAAK,CAAC,MAAM,CAAC,QAcvB;CACF;;;;;;;;iBAzEa,OAAO;;iBARJ,WAAW"}

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;IAmBD;;;;;;;;;;;;;;;;;;;;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,CAO5B;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,sBAbW,MAAM,GACJ,eAAe,CAgC3B;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,kBAbW,MAAM,GACJ,UAAU,CAgCtB;IAxfD;;;;;;;OAOG;IACH,2BAHW,QAAQ,GAAC,QAAQ,GAAC,SAAS,GACzB,MAAM,GAAC,MAAM,CAQzB;;CA2eF;;UAvqBa,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":"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"}

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;IAsfnB;;;;;;;;;;;OAWG;IACH,kBAPa,UAAU,CAsCtB;IAvoBD;;;;;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;IAiBD;;;;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;IA9eD;;;;;;;OAOG;IACH,2BAHW,QAAQ,GAAC,QAAQ,GAAC,SAAS,GACzB,MAAM,GAAC,MAAM,CAQzB;;CA8gBF;eAtrBc,iBAAiB;4BADJ,sBAAsB;kBAFhC,YAAY"}
+{"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"}

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

@@ -1,50 +1,11 @@
-/**
- * Options for type validation methods.
- *
- * @typedef {object} TypeValidationOptions
- * @property {boolean} [allowEmpty=true] - Whether empty values are allowed
- */
 /**
  * Validation utility class providing type checking and assertion methods.
+ * Inherits all behaviour from browser Valid; only the Sass class differs.
  */
-export default class Valid {
-    static #restrictedProto: string[];
-    /**
-     * Validates a value against a type. Uses Data.isType.
-     *
-     * @param {unknown} value - The value to validate
-     * @param {string} type - The expected type in the form of "object", "object[]", "object|object[]"
-     * @param {TypeValidationOptions} [options] - Additional options for validation.
-     */
-    static type(value: unknown, type: string, options?: TypeValidationOptions): void;
-    /**
-     * Asserts a condition
-     *
-     * @param {boolean} condition - The condition to assert
-     * @param {string} message - The message to display if the condition is not
-     *                           met
-     * @param {number} [arg] - The argument to display if the condition is not
-     *                         met (optional)
-     */
-    static assert(condition: boolean, message: string, arg?: number): void;
-    /**
-     * Protects against prototype pollution by checking keys for dangerous
-     * property names.
-     *
-     * Throws if any restricted prototype properties are found in the keys array.
-     *
-     * @param {Array<string>} keys - Array of property keys to validate
-     * @throws {Sass} If any key matches restricted prototype properties (__proto__, constructor, prototype)
-     */
-    static prototypePollutionProtection(keys: Array<string>): void;
+export default class Valid extends BrowserValid {
+    /** @type {typeof Sass} */
+    static _Sass: typeof Sass;
 }
-/**
- * Options for type validation methods.
- */
-export type TypeValidationOptions = {
-    /**
-     * - Whether empty values are allowed
-     */
-    allowEmpty?: boolean;
-};
+import BrowserValid from "../../browser/lib/Valid.js";
+import Sass from "./Sass.js";
 //# sourceMappingURL=Valid.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Valid.d.ts","sourceRoot":"","sources":["../../../src/node/lib/Valid.js"],"names":[],"mappings":"AAWA;;;;;GAKG;AAEH;;GAEG;AACH;IACE,kCAAmE;IAEnE;;;;;;OAMG;IACH,mBAJW,OAAO,QACP,MAAM,YACN,qBAAqB,QAY/B;IAED;;;;;;;;OAQG;IACH,yBANW,OAAO,WACP,MAAM,QAEN,MAAM,QAehB;IAED;;;;;;;;OAQG;IACH,0CAHW,KAAK,CAAC,MAAM,CAAC,QAYvB;CACF;;;;;;;;iBAtEa,OAAO"}
+{"version":3,"file":"Valid.d.ts","sourceRoot":"","sources":["../../../src/node/lib/Valid.js"],"names":[],"mappings":"AAUA;;;GAGG;AACH;IACE,0BAA0B;IAC1B,cADW,OAAO,IAAI,CACH;CACpB;yBAVwB,4BAA4B;iBACpC,WAAW"}

package/vendor/toolkit.esm.js

@@ -1,4 +1,4 @@
-// @gesslar/toolkit v5.0.1 - ES module bundle
+// @gesslar/toolkit v5.2.0 - ES module bundle
 /**
  * @file Tantrum.js
  *
@@ -317,21 +317,36 @@ class Sass extends Error {
  */
 
 
+/**
+ * Options for type validation methods.
+ *
+ * @typedef {object} TypeValidationOptions
+ * @property {boolean} [allowEmpty=true] - Whether empty values are allowed
+ */
+
 /**
  * Validation utility class providing type checking and assertion methods.
  */
 class Valid {
+  /** @type {typeof Sass} */
+  static _Sass = Sass
+
   /**
    * Validates a value against a type. Uses Data.isType.
    *
    * @param {unknown} value - The value to validate
    * @param {string} type - The expected type in the form of "object", "object[]", "object|object[]"
-   * @param {object} [options] - Additional options for validation.
+   * @param {TypeValidationOptions} [options] - Additional options for validation.
    */
   static type(value, type, options) {
-    Valid.assert(
+    const expected = [type];
+
+    if(options?.allowEmpty !== true)
+      expected.push("[no empty values]");
+
+    this.assert(
       Data.isType(value, type, options),
-      `Invalid type. Expected ${type}, got ${Data.typeOf(value)}`
+      `Invalid type. Expected ${expected.join(" ")}, got ${Data.typeOf(value)}`
     );
   }
 
@@ -345,23 +360,20 @@ class Valid {
    *                         met (optional)
    */
   static assert(condition, message, arg = null) {
-    if(!Data.isType(condition, "boolean")) {
-      throw Sass.new(`Condition must be a boolean, got ${condition}`)
-    }
+    if(!Data.isType(condition, "boolean"))
+      throw this._Sass.new(`Condition must be a boolean, got ${condition}`)
 
-    if(!Data.isType(message, "string")) {
-      throw Sass.new(`Message must be a string, got ${message}`)
-    }
+    if(!Data.isType(message, "string"))
+      throw this._Sass.new(`Message must be a string, got ${message}`)
 
-    if(!(arg === null || arg === undefined || typeof arg === "number")) {
-      throw Sass.new(`Arg must be a number, got ${arg}`)
-    }
+    if(!(arg === null || arg === undefined || typeof arg === "number"))
+      throw this._Sass.new(`Arg must be a number, got ${arg}`)
 
     if(!condition)
-      throw Sass.new(`${message}${arg ? `: ${arg}` : ""}`)
+      throw this._Sass.new(`${message}${arg ? `: ${arg}` : ""}`)
   }
 
-  static #restrictedProto = ["__proto__", "constructor", "prototype"]
+  static #restrictedProto = Object.freeze(["__proto__", "constructor", "prototype"])
 
   /**
    * Protects against prototype pollution by checking keys for dangerous property names.
@@ -371,11 +383,13 @@ class Valid {
    * @throws {Sass} If any key matches restricted prototype properties (__proto__, constructor, prototype)
    */
   static prototypePollutionProtection(keys) {
-    Valid.type(keys, "String[]");
+    this.type(keys, "String[]");
 
-    const oopsIDidItAgain = Collection.intersection(this.#restrictedProto, keys);
+    const oopsIDidItAgain = Collection.intersection(
+      Valid.#restrictedProto, keys
+    );
 
-    Valid.assert(
+    this.assert(
       oopsIDidItAgain.length === 0,
       `We don't pee in your pool, don't pollute ours with your ${String(oopsIDidItAgain)}`
     );
@@ -761,7 +775,7 @@ class TypeSpec {
       // Handle non-array values
       if(!isArray && !allowedArray) {
         if(valueType === allowedType)
-          return allowEmpty || !empty
+          return Data.isBaseType(value, allowedType) && (allowEmpty || !empty)
 
         if(valueType === "Null" || valueType === "Undefined")
           return false

package/vendor/toolkit.umd.js

@@ -1,4 +1,4 @@
-// @gesslar/toolkit v5.0.1 - UMD bundle
+// @gesslar/toolkit v5.2.0 - UMD bundle
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
   typeof define === 'function' && define.amd ? define(['exports'], factory) :
@@ -323,21 +323,36 @@
    */
 
 
+  /**
+   * Options for type validation methods.
+   *
+   * @typedef {object} TypeValidationOptions
+   * @property {boolean} [allowEmpty=true] - Whether empty values are allowed
+   */
+
   /**
    * Validation utility class providing type checking and assertion methods.
    */
   class Valid {
+    /** @type {typeof Sass} */
+    static _Sass = Sass
+
     /**
      * Validates a value against a type. Uses Data.isType.
      *
      * @param {unknown} value - The value to validate
      * @param {string} type - The expected type in the form of "object", "object[]", "object|object[]"
-     * @param {object} [options] - Additional options for validation.
+     * @param {TypeValidationOptions} [options] - Additional options for validation.
      */
     static type(value, type, options) {
-      Valid.assert(
+      const expected = [type];
+
+      if(options?.allowEmpty !== true)
+        expected.push("[no empty values]");
+
+      this.assert(
         Data.isType(value, type, options),
-        `Invalid type. Expected ${type}, got ${Data.typeOf(value)}`
+        `Invalid type. Expected ${expected.join(" ")}, got ${Data.typeOf(value)}`
       );
     }
 
@@ -351,23 +366,20 @@
      *                         met (optional)
      */
     static assert(condition, message, arg = null) {
-      if(!Data.isType(condition, "boolean")) {
-        throw Sass.new(`Condition must be a boolean, got ${condition}`)
-      }
+      if(!Data.isType(condition, "boolean"))
+        throw this._Sass.new(`Condition must be a boolean, got ${condition}`)
 
-      if(!Data.isType(message, "string")) {
-        throw Sass.new(`Message must be a string, got ${message}`)
-      }
+      if(!Data.isType(message, "string"))
+        throw this._Sass.new(`Message must be a string, got ${message}`)
 
-      if(!(arg === null || arg === undefined || typeof arg === "number")) {
-        throw Sass.new(`Arg must be a number, got ${arg}`)
-      }
+      if(!(arg === null || arg === undefined || typeof arg === "number"))
+        throw this._Sass.new(`Arg must be a number, got ${arg}`)
 
       if(!condition)
-        throw Sass.new(`${message}${arg ? `: ${arg}` : ""}`)
+        throw this._Sass.new(`${message}${arg ? `: ${arg}` : ""}`)
     }
 
-    static #restrictedProto = ["__proto__", "constructor", "prototype"]
+    static #restrictedProto = Object.freeze(["__proto__", "constructor", "prototype"])
 
     /**
      * Protects against prototype pollution by checking keys for dangerous property names.
@@ -377,11 +389,13 @@
      * @throws {Sass} If any key matches restricted prototype properties (__proto__, constructor, prototype)
      */
     static prototypePollutionProtection(keys) {
-      Valid.type(keys, "String[]");
+      this.type(keys, "String[]");
 
-      const oopsIDidItAgain = Collection.intersection(this.#restrictedProto, keys);
+      const oopsIDidItAgain = Collection.intersection(
+        Valid.#restrictedProto, keys
+      );
 
-      Valid.assert(
+      this.assert(
         oopsIDidItAgain.length === 0,
         `We don't pee in your pool, don't pollute ours with your ${String(oopsIDidItAgain)}`
       );
@@ -767,7 +781,7 @@
         // Handle non-array values
         if(!isArray && !allowedArray) {
           if(valueType === allowedType)
-            return allowEmpty || !empty
+            return Data.isBaseType(value, allowedType) && (allowEmpty || !empty)
 
           if(valueType === "Null" || valueType === "Undefined")
             return false