@gesslar/toolkit 3.25.0 → 3.27.0

package/package.json

@@ -5,7 +5,7 @@
     "name": "gesslar",
     "url": "https://gesslar.dev"
   },
-  "version": "3.25.0",
+  "version": "3.27.0",
   "license": "Unlicense",
   "homepage": "https://github.com/gesslar/toolkit#readme",
   "repository": {
@@ -52,22 +52,17 @@
     "node": ">=24.13.0"
   },
   "dependencies": {
-    "@eslint/js": "^9.39.2",
     "@gesslar/colours": "^0.8.0",
-    "@stylistic/eslint-plugin": "^5.7.0",
     "ajv": "^8.17.1",
-    "globals": "^17.0.0",
     "json5": "^2.2.3",
-    "types": "^0.1.1",
+    "supports-color": "^10.2.2",
     "yaml": "^2.8.2"
   },
   "devDependencies": {
     "@gesslar/uglier": "^1.2.0",
     "eslint": "^9.39.2",
-    "eslint-plugin-jsdoc": "^62.3.0",
-    "happy-dom": "^20.3.4",
-    "typescript": "^5.9.3",
-    "typescript-eslint": "^8.53.1"
+    "happy-dom": "^20.3.7",
+    "typescript": "^5.9.3"
   },
   "scripts": {
     "types": "node -e \"require('fs').rmSync('types',{recursive:true,force:true});\" && tsc -p tsconfig.types.json",

package/src/node/index.js

@@ -18,6 +18,7 @@ export {default as Cache} from "./lib/Cache.js"
 export {default as DirectoryObject} from "./lib/DirectoryObject.js"
 export {default as FileObject} from "./lib/FileObject.js"
 export {default as FileSystem} from "./lib/FileSystem.js"
+export {default as Font} from "./lib/Font.js"
 export {default as Glog} from "./lib/Glog.js"
 export {default as Notify} from "./lib/Notify.js"
 export {default as Term} from "./lib/Term.js"

package/src/node/lib/DirectoryObject.js

@@ -315,7 +315,10 @@ export default class DirectoryObject extends FS {
    * const {files} = await dir.read("*.js")
    * console.log(files) // Only .js files in ./src
    */
-  async read(pat="") {
+  async read(pat="", options={}) {
+    Valid.type(pat, "String")
+    Valid.type(options, "Object")
+
     const withFileTypes = true
     const url = this.url
 
@@ -325,10 +328,13 @@ export default class DirectoryObject extends FS {
     const found = !pat
       ? await readdir(url, {withFileTypes})
       : await Array.fromAsync(
-        glob(pat, {
-          cwd: this.path,
-          withFileTypes,
-        })
+        glob(pat, Object.assign({},
+          options,
+          { // nice try overwriting my options, tho
+            cwd: this.path,
+            withFileTypes,
+          })
+        )
       )
 
     const files = found
@@ -365,13 +371,19 @@ export default class DirectoryObject extends FS {
    * // Find all package.json files recursively
    * const {files} = await dir.glob("**\/package.json")
    */
-  async glob(pat="") {
+  async glob(pat="", options={}) {
+    Valid.type(pat, "String")
+    Valid.type(options, "Object")
+
     const withFileTypes = true
     const found = await Array.fromAsync(
-      glob(pat, {
-        cwd: this.path,
-        withFileTypes,
-      })
+      glob(pat, Object.assign({},
+        options,
+        { // teeheeheeeee
+          cwd: this.path,
+          withFileTypes,
+        })
+      )
     )
 
     const files = [], directories = []
@@ -392,7 +404,7 @@ export default class DirectoryObject extends FS {
 
         directories.push(directory)
       } else {
-        throw Sass.new(`wtf is this? ${e}`)
+        throw Sass.new(`wtf is this? ${JSON.stringify(e)}`)
       }
     }
 

package/src/node/lib/Font.js

@@ -0,0 +1,263 @@
+/**
+ * @file Font.js
+ * @description Utility class for detecting Nerd Fonts installed on the system.
+ */
+
+import os from "os"
+import {promisify} from "node:util"
+import child_process from "node:child_process"
+
+import DirectoryObject from "./DirectoryObject.js"
+import FS from "./FileSystem.js"
+
+/**
+ * @import {FileObject} from "./FileObject.js"
+ */
+
+const execFile = promisify(child_process.execFile)
+
+/**
+ * Utility class for detecting and identifying Nerd Fonts installed on the system.
+ * Supports Windows, macOS, and Linux platforms.
+ *
+ * Nerd Fonts are patched fonts that include additional glyphs such as icons,
+ * file type symbols, and powerline characters commonly used in terminal applications.
+ *
+ * @example
+ * // Check if any Nerd Fonts are installed
+ * const hasNerd = await Font.hasNerdFonts()
+ *
+ * @example
+ * // Get list of installed Nerd Fonts
+ * const fonts = await Font.findNerdFonts()
+ * console.log(fonts) // ["FiraCode", "JetBrainsMono", ...]
+ */
+export default class Font {
+  static #cache = new Map()
+
+  /**
+   * Finds all Nerd Fonts installed on the system.
+   * Detects the current platform and uses platform-specific methods
+   * to locate font files or query the font database.
+   *
+   * @returns {Promise<Array<string>>} Array of Nerd Font family names, or empty array if none found.
+   * @example
+   * const nerdFonts = await Font.findNerdFonts()
+   * console.log(nerdFonts) // ["FiraCode Nerd Font", "JetBrains Mono NF", ...]
+   */
+  static async findNerdFonts() {
+    if(!this.#cache.has("nerdFonts")) {
+      const platform = os.platform()
+
+      if(platform === "win32")
+        this.#cache.set("nerdFonts", this.#findNerdFontsWindows())
+      else if(platform === "darwin")
+        this.#cache.set("nerdFonts", this.#findNerdFontsMac())
+      else if(platform === "linux")
+        this.#cache.set("nerdFonts", this.#findNerdFontsLinux())
+      else
+        this.#cache.set("nerdFonts", [])
+    }
+
+    return this.#cache.get("nerdFonts")
+  }
+
+  /**
+   * Checks whether any Nerd Fonts are installed on the system.
+   *
+   * @returns {Promise<boolean>} True if at least one Nerd Font is installed.
+   * @example
+   * if(await Font.hasNerdFonts()) {
+   *   console.log("Nerd Fonts available - using fancy icons!")
+   * }
+   */
+  static async hasNerdFonts() {
+    return (await this.findNerdFonts()).length > 0
+  }
+
+  /**
+   * Gets the base family names of installed Nerd Fonts.
+   * Strips the "NF" or "Nerd Font" suffix to return the core font name.
+   *
+   * @returns {Promise<Array<string>>} Array of base font family names.
+   * @example
+   * const families = await Font.getNerdFontFamilies()
+   * console.log(families) // ["FiraCode", "JetBrains Mono", ...]
+   */
+  static async getNerdFontFamilies() {
+    const fonts = await this.findNerdFonts()
+
+    // Strip the NF or Nerd Font suffix to get base name
+    return fonts.map(f => f.replace(/\s*(NF|Nerd\s*Font.*)$/i, "").trim())
+  }
+
+  /**
+   * Strips font style suffixes from a font name.
+   *
+   * @param {string} fontName - The font name to clean.
+   * @returns {string} The font name without style suffixes.
+   * @private
+   */
+  static #stripStyles(fontName) {
+    return fontName.replace(/[_-]?(Bold|Italic|Regular|Light|Medium|SemiBold|Black|Thin|ExtraLight|ExtraBold|Heavy)(Italic)?$/i, "").trim()
+  }
+
+  /**
+   * Tests if a font name matches any Nerd Font naming patterns.
+   *
+   * @param {string} fontName - The font name to test.
+   * @param {Array<RegExp>} tests - Array of regex patterns to match against.
+   * @returns {boolean} True if the font name matches any pattern.
+   * @private
+   */
+  static #isNerdFontName(fontName, tests) {
+    return tests.some(e => e.test(fontName))
+  }
+
+  /**
+   * Finds Nerd Fonts on Windows by scanning system and user font directories.
+   *
+   * @returns {Promise<Array<string>>} Array of Nerd Font family names.
+   * @private
+   */
+  static async #findNerdFontsWindows() {
+    const fontDirs = [
+      new DirectoryObject(FS.resolvePath(
+        process.env.WINDIR || "C:/Windows",
+        "/Fonts"
+      ))
+    ]
+
+    if(process.env.LOCALAPPDATA)
+      fontDirs.push(new DirectoryObject(FS.resolvePath(
+        process.env.LOCALAPPDATA,
+        "Microsoft/Windows/Fonts"
+      )))
+
+    const fontFiles = []
+
+    for(const fontDir of fontDirs) {
+      try {
+        if(!await fontDir.exists)
+          continue
+
+        const {files} = await fontDir.read("*.{ttf,otf}")
+
+        fontFiles.push(...files)
+      } catch {
+        // Directory doesn't exist or isn't accessible
+      }
+    }
+
+    this.#cache.set("nerdFonts", this.#identifyNerdFonts(fontFiles))
+
+    return this.#cache.get("nerdFonts")
+  }
+
+  /**
+   * Finds Nerd Fonts on macOS by scanning system and user font directories.
+   *
+   * @returns {Promise<Array<string>>} Array of Nerd Font family names.
+   * @private
+   */
+  static async #findNerdFontsMac() {
+    const fontDirs = [
+      new DirectoryObject("/Library/Fonts")
+    ]
+
+    if(process.env.HOME) {
+      fontDirs.push(new DirectoryObject(FS.resolvePath(process.env.HOME, "Library/Fonts")))
+    }
+
+    const fontFiles = []
+
+    for(const fontDir of fontDirs) {
+      try {
+        if(!await fontDir.exists)
+          continue
+
+        const {files} = await fontDir.glob("**/*.{ttf,otf}")
+
+        fontFiles.push(...files)
+      } catch {
+        // Directory doesn't exist or isn't accessible
+      }
+    }
+
+    return this.#identifyNerdFonts(fontFiles)
+  }
+
+  /**
+   * Finds Nerd Fonts on Linux using the fc-list command.
+   *
+   * @returns {Promise<Array<string>>} Array of Nerd Font family names.
+   * @private
+   */
+  static async #findNerdFontsLinux() {
+    try {
+      const {stdout: fonts} = await execFile(
+        "fc-list",
+        [":", "family"],
+        {encoding: "utf8"}
+      )
+
+      const nerdFonts = fonts
+        .split("\n")
+        .filter(line => line.trim())
+        .filter(f => this.#isNerdFontName(f, this.#nerdTestsLinux))
+        .map(line => line.split(",")[0].trim())
+        .filter((font, idx, arr) => arr.indexOf(font) === idx)
+        .sort()
+
+      return nerdFonts
+    } catch {
+      return []
+    }
+  }
+
+  /** @type {Array<RegExp>} Patterns to identify Nerd Fonts by filename */
+  static #nerdTests = [/nerd/i, / nf[_\s.-]/i]
+
+  /** @type {Array<RegExp>} Patterns to identify Nerd Fonts in fc-list output */
+  static #nerdTestsLinux = [/nerd font/i, /\bnf\b/i]
+
+  /**
+   * Identifies Nerd Fonts from a list of font file objects.
+   *
+   * @param {Array<FileObject>} fileObjects - Array of FileObject instances representing font files.
+   * @returns {Array<string>} Sorted array of unique Nerd Font family names.
+   * @private
+   */
+  static #identifyNerdFonts(fileObjects) {
+    const nerdFonts = new Set()
+
+    for(const file of fileObjects) {
+      const name = file.module
+
+      if(this.#isNerdFontName(name, this.#nerdTests)) {
+        nerdFonts.add(this.#stripStyles(name))
+      }
+    }
+
+    return Array.from(nerdFonts).sort()
+  }
+
+  /**
+   * Gets spinner animation frames appropriate for the current font environment.
+   * Returns Unicode braille characters if Nerd Fonts are available,
+   * otherwise returns ASCII fallback characters.
+   *
+   * @returns {Promise<Array<string>>} Promise resolving to array of spinner frame characters.
+   * @example
+   * const frames = await Font.spinFrames
+   * // With Nerd Fonts: ["⠋", "⠙", "⠹", ...]
+   * // Without: ["|", "/", "-", "\\"]
+   */
+  static get spinFrames() {
+    return this.hasNerdFonts().then(has =>
+      has
+        ? ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+        : ["|", "/", "-", "\\"]
+    )
+  }
+}

package/src/node/lib/Sass.js

@@ -11,7 +11,7 @@
  * debugging.
  */
 
-import {Sass as BrowserSass} from "../../browser/index.js"
+import BrowserSass from "../../browser/lib/Sass.js"
 import Term from "./Term.js"
 
 /**

package/src/node/lib/Tantrum.js

@@ -9,7 +9,7 @@
  * multiple error scenarios.
  */
 
-import {Tantrum as BrowserTantrum} from "../../browser/index.js"
+import BrowserTantrum from "../../browser/lib/Tantrum.js"
 import Sass from "./Sass.js"
 import Term from "./Term.js"
 

package/src/node/lib/Term.js

@@ -1,11 +1,69 @@
-import console from "node:console"
+import console, {Console} from "node:console"
 import process from "node:process"
-import {Console} from "node:console"
 import {Writable} from "node:stream"
+import supportsColor from "supports-color"
+import {stripVTControlCharacters} from "node:util"
 
 import Sass from "./Sass.js"
 
 export default class Term {
+  static #cache = new Map()
+
+  static #preformat(text) {
+    return this.hasColor
+      ? text
+      : stripVTControlCharacters(text)
+  }
+
+  /**
+   * Terminal width in columns.
+   *
+   * @type {number | undefined}
+   */
+  static get columns() {
+    return process.stdout.columns
+  }
+
+  /**
+   * Terminal height in rows.
+   *
+   * @type {number | undefined}
+   */
+  static get rows() {
+    return process.stdout.rows
+  }
+
+  /**
+   * Terminal dimensions as an object.
+   *
+   * @type {{columns: number | undefined, rows: number | undefined}}
+   */
+  static get dim() {
+    return {columns: this.columns, rows: this.rows}
+  }
+
+  /**
+   * Whether the terminal is interactive (TTY and not in CI).
+   *
+   * @type {boolean}
+   */
+  static get isInteractive() {
+    return this.#cache.has("isInteractive")
+      ? this.#cache.get("isInteractive")
+      : this.#cache.set("isInteractive", Boolean(process.stdout.isTTY && !process.env.CI)).get("isInteractive")
+  }
+
+  /**
+   * Whether the terminal supports color output.
+   *
+   * @type {boolean}
+   */
+  static get hasColor() {
+    return this.#cache.has("hasColor")
+      ? this.#cache.get("hasColor")
+      : this.#cache.set("hasColor", Boolean(supportsColor.stdout)).get("hasColor")
+  }
+
   /**
    * Log an informational message.
    *
@@ -126,13 +184,13 @@ export default class Term {
       // Keep: top border (line 0), data rows (line 3+)
       const modified = [lines[0], ...lines.slice(3)]
 
-      process.stdout.write(modified.join("\n"))
+      this.write(modified.join("\n"))
     } else if(showHeader) {
       // Keep header but remove quotes if requested
-      process.stdout.write(processed)
+      this.write(processed)
     } else {
       // Fallback: just output as-is if format unexpected
-      process.stdout.write(processed)
+      this.write(processed)
     }
   }
 
@@ -241,18 +299,301 @@ export default class Term {
     return `${brackets[0]}${text}${brackets[1]}`
   }
 
-  static async resetTerminal() {
-    await Term.directWrite("\x1b[?25h")
-    process.stdin.setRawMode(false)
+  /**
+   * ANSI escape sequence to move cursor to start of line.
+   *
+   * @type {string}
+   */
+  static get start() {
+    return `\r`
+  }
+
+  /**
+   * Move cursor to start of line (interactive terminals only).
+   *
+   * @returns {typeof Term} The Term class for chaining.
+   */
+  static moveStart() {
+    this.isInteractive && this.write(this.start)
+
+    return this
   }
 
-  static async clearLines(num) {
-    await Term.directWrite(`${"\r\x1b[2K\x1b[1A".repeat(num)}`)
+  /**
+   * ANSI escape sequence to move cursor to end of line.
+   *
+   * @type {string}
+   */
+  static get end() {
+    return `\x1b[${this.columns}G`
   }
 
+  /**
+   * Move cursor to end of line (interactive terminals only).
+   *
+   * @returns {typeof Term} The Term class for chaining.
+   */
+  static moveEnd() {
+    this.isInteractive && this.write(this.end)
+
+    return this
+  }
+
+  /**
+   * ANSI escape sequence to move cursor up one line.
+   *
+   * @type {string}
+   */
+  static get up() {
+    return `\x1b[1A`
+  }
+
+  /**
+   * Move cursor up by specified number of lines (interactive terminals only).
+   *
+   * @param {number} num - Number of lines to move up.
+   * @returns {typeof Term} The Term class for chaining.
+   */
+  static moveUp(num) {
+    this.isInteractive && this.write(this.up.repeat(num))
+
+    return this
+  }
+
+  /**
+   * Hide the terminal cursor (interactive terminals only).
+   *
+   * @returns {typeof Term} The Term class for chaining.
+   */
+  static hideCursor() {
+    this.isInteractive && this.write("\x1b[?25l")
+
+    return this
+  }
+
+  /**
+   * Show the terminal cursor (interactive terminals only).
+   *
+   * @returns {typeof Term} The Term class for chaining.
+   */
+  static showCursor() {
+    this.isInteractive && this.write("\x1b[?25h")
+
+    return this
+  }
+
+  /**
+   * Whether the terminal is in character (raw) input mode.
+   *
+   * @type {boolean}
+   */
+  static get isCharMode() {
+    if(!this.isInteractive)
+      return false
+
+    return process.stdin.isRaw
+  }
+
+  /**
+   * Whether the terminal is in line (buffered) input mode.
+   *
+   * @type {boolean}
+   */
+  static get isLineMode() {
+    if(!this.isInteractive)
+      return false
+
+    return !this.isCharMode
+  }
+
+  /**
+   * Set terminal to character mode (raw input, interactive terminals only).
+   *
+   * @returns {typeof Term} The Term class for chaining.
+   */
+  static setCharMode() {
+    this.isInteractive && process.stdin.setRawMode(true)
+
+    return this
+  }
+
+  /**
+   * Set terminal to line mode (buffered input, interactive terminals only).
+   *
+   * @returns {typeof Term} The Term class for chaining.
+   */
+  static setLineMode() {
+    this.isInteractive && process.stdin.setRawMode(false)
+
+    return this
+  }
+
+  /**
+   * Clear the current line (interactive terminals only).
+   *
+   * @returns {typeof Term} The Term class for chaining.
+   */
+  static clearLine() {
+    this.isInteractive && this.write(`\x1b[2K`)
+
+    return this
+  }
+
+  /**
+   * Clear multiple lines by moving up and clearing each (interactive terminals only).
+   *
+   * @param {number} num - Number of lines to clear.
+   * @returns {typeof Term} The Term class for chaining.
+   */
+  static clearLines(num) {
+    while(num--)
+      this.clearLine().moveUp()
+
+    return this
+  }
+
+  /**
+   * Write output to stdout asynchronously (fire-and-forget).
+   *
+   * @param {string} output - The string to write.
+   * @returns {typeof Term} The Term class for chaining.
+   */
+  static write(output) {
+    this.directWrite(output).catch(console.error)
+
+    return this
+  }
+
+  /**
+   * Returns a promise that resolves with the next chunk of data from stdin.
+   * If in Char Mode, it resolves on Enter, Ctrl+D, or the ANSI 'R' terminator.
+   *
+   * @param {(text: string) => boolean} [terminator] - Optional callback to check if input is complete.
+   * @returns {Promise<string>} Resolves with the input data.
+   */
+  static data(terminator = () => false) {
+    process.stdin.resume()
+
+    return new Promise((resolve, reject) => {
+      const chunks = []
+
+      function onData(chunk) {
+        const s = chunk.toString()
+        chunks.push(chunk)
+
+        const result = terminator(s)
+
+        if(result)
+          return onEnd()
+
+        if(Term.isCharMode) {
+          // Resolve on Enter, Ctrl+D
+          if(s === "\r" || s === "\n" || s === "\u0004")
+            return onEnd()
+
+          // Standard CLI escape: Ctrl+C
+          if(s === "\u0003")
+            process.exit()
+        }
+      }
+
+      function onEnd() {
+        cleanup()
+
+        const result = (chunks.length > 0 && typeof chunks[0] === "string")
+          ? chunks.join("")
+          : Buffer.concat(chunks).toString()
+
+        resolve(result)
+      }
+
+      function onError(err) {
+        cleanup()
+        reject(err)
+      }
+
+      function cleanup() {
+        process.stdin.off("data", onData)
+        process.stdin.off("end", onEnd)
+        process.stdin.off("error", onError)
+
+        // ALWAYS pause when the specific task is done.
+        // It can be resumed by the next caller.
+        process.stdin.pause()
+      }
+
+      process.stdin.on("data", onData)
+      process.stdin.once("end", onEnd)
+      process.stdin.once("error", onError)
+    })
+  }
+
+  /**
+   * Gets the current cursor position in the terminal.
+   *
+   * @returns {Promise<[number, number]>} Resolves with [x, y] cursor position.
+   */
+  static async getCursorPosition() {
+    const result = [0, 0]
+
+    if(!this.isInteractive)
+      return result
+
+    const prevRawMode = this.isCharMode
+
+    // 1. Force Raw Mode so the terminal sends the report immediately
+    this.setCharMode()
+    process.stdin.setEncoding("utf8")
+
+    // 2. Start the listener FIRST (do not await yet)
+    const dataPromise = this.data((text => {
+      return this.isCharMode && text.endsWith("R")
+    }).bind(this))
+
+    // 3. Write to stdout AFTER the listener is ready
+    this.write("\x1b[6n")
+
+    // 4. Now await the response
+    const positionData = await dataPromise
+
+    // 5. Restore the previous mode
+    prevRawMode ? this.setCharMode() : this.setLineMode()
+
+    const match = /\x1b\[(?<y>\d+);(?<x>\d+)R/.exec(positionData)
+
+    if(!match)
+      return result
+
+    const {x, y} = match.groups
+
+    // ANSI returns [row;col], which is [y;x]
+    return [parseInt(x, 10), parseInt(y, 10)]
+  }
+
+  /**
+   * Write output to stdout and return a promise that resolves when complete.
+   *
+   * @param {string} output - The string to write.
+   * @returns {Promise<void>} Resolves when write completes.
+   */
   static directWrite(output) {
     return new Promise(resolve => {
       process.stdout.write(output, () => resolve())
     })
   }
+
+  // Spinner frames - using Braille patterns (widely supported)
+  // Falls back to ASCII when spinimate is implemented with proper detection
+  static #spinFrames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+
+  // static async spinimate(delay=300, options = {position: {x: 0,y: 0}}) {
+  //   const spinFrames = await this.#spinFrames
+  //   const {x, y} = options?.position ?? {}
+
+  //   if(!isNaN(shiftX) && !isNaN(shiftY)) {
+  //     setTimeout(delay, () => {
+
+  //     })
+  //   }
+  // }
 }

package/src/node/lib/Util.js

@@ -1,6 +1,6 @@
 import {createHash} from "node:crypto"
 import {EventEmitter} from "node:events"
-import {Util as BrowserUtil} from "../../browser/index.js"
+import BrowserUtil from "../../browser/lib/Util.js"
 import Sass from "./Sass.js"
 import process from "node:process"
 import JSON5 from "json5"

package/types/node/index.d.ts

@@ -11,6 +11,7 @@ export { default as Cache } from "./lib/Cache.js";
 export { default as DirectoryObject } from "./lib/DirectoryObject.js";
 export { default as FileObject } from "./lib/FileObject.js";
 export { default as FileSystem } from "./lib/FileSystem.js";
+export { default as Font } from "./lib/Font.js";
 export { default as Glog } from "./lib/Glog.js";
 export { default as Notify } from "./lib/Notify.js";
 export { default as Term } from "./lib/Term.js";

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

@@ -175,7 +175,7 @@ export default class DirectoryObject extends FS {
      * const {files} = await dir.read("*.js")
      * console.log(files) // Only .js files in ./src
      */
-    read(pat?: string): Promise<{
+    read(pat?: string, options?: {}): Promise<{
         files: Array<FileObject>;
         directories: Array<DirectoryObject>;
     }>;
@@ -198,7 +198,7 @@ export default class DirectoryObject extends FS {
      * // Find all package.json files recursively
      * const {files} = await dir.glob("**\/package.json")
      */
-    glob(pat?: string): Promise<{
+    glob(pat?: string, options?: {}): Promise<{
         files: Array<FileObject | FileObject>;
         directories: Array<DirectoryObject>;
     }>;

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":"AAgBA;;;;GAIG;AAEH;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH;IAuDE;;;;;;;;;OASG;IACH,kBALa,eAAe,CAO3B;IA7CD;;;;OAIG;IACH,uBAFW,MAAM,OAAC,EA4BjB;IAyBD;;;;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;;;;;;;;;;;;;;;;;OAiBG;IACH,WAZW,MAAM,GACJ,OAAO,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;QAAC,WAAW,EAAE,KAAK,CAAC,eAAe,CAAC,CAAA;KAAC,CAAC,CAwCpF;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,WAZW,MAAM,GACJ,OAAO,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC,UAAU,GAAC,UAAU,CAAC,CAAC;QAAC,WAAW,EAAE,KAAK,CAAC,eAAe,CAAC,CAAA;KAAC,CAAC,CA2C/F;IAED;;;;;;;;;;;;OAYG;IACH,uBARW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAuBzB;IAyBD;;;;;;;;;;;;;;;OAeG;IACH,cAZa,eAAe,CAc3B;IAED;;;;;;;;;;;;;;OAcG;IACH,UARa,OAAO,CAAC,IAAI,CAAC,CAkBzB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAM5B;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAO5B;IAED;;;;;;;;;;;;OAYG;IACH,sBAPW,MAAM,GACJ,eAAe,CA6B3B;IAED;;;;;;;;;;;OAWG;IACH,kBAPW,MAAM,GACJ,UAAU,CA6BtB;;CACF;;UAvkBa,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":"AAgBA;;;;GAIG;AAEH;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH;IAuDE;;;;;;;;;OASG;IACH,kBALa,eAAe,CAO3B;IA7CD;;;;OAIG;IACH,uBAFW,MAAM,OAAC,EA4BjB;IAyBD;;;;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;;;;;;;;;;;;;;;;;OAiBG;IACH,WAZW,MAAM,iBACJ,OAAO,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;QAAC,WAAW,EAAE,KAAK,CAAC,eAAe,CAAC,CAAA;KAAC,CAAC,CA8CpF;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,WAZW,MAAM,iBACJ,OAAO,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC,UAAU,GAAC,UAAU,CAAC,CAAC;QAAC,WAAW,EAAE,KAAK,CAAC,eAAe,CAAC,CAAA;KAAC,CAAC,CAiD/F;IAED;;;;;;;;;;;;OAYG;IACH,uBARW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAuBzB;IAyBD;;;;;;;;;;;;;;;OAeG;IACH,cAZa,eAAe,CAc3B;IAED;;;;;;;;;;;;;;OAcG;IACH,UARa,OAAO,CAAC,IAAI,CAAC,CAkBzB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAM5B;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAO5B;IAED;;;;;;;;;;;;OAYG;IACH,sBAPW,MAAM,GACJ,eAAe,CA6B3B;IAED;;;;;;;;;;;OAWG;IACH,kBAPW,MAAM,GACJ,UAAU,CA6BtB;;CACF;;UAnlBa,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/Font.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Utility class for detecting and identifying Nerd Fonts installed on the system.
+ * Supports Windows, macOS, and Linux platforms.
+ *
+ * Nerd Fonts are patched fonts that include additional glyphs such as icons,
+ * file type symbols, and powerline characters commonly used in terminal applications.
+ *
+ * @example
+ * // Check if any Nerd Fonts are installed
+ * const hasNerd = await Font.hasNerdFonts()
+ *
+ * @example
+ * // Get list of installed Nerd Fonts
+ * const fonts = await Font.findNerdFonts()
+ * console.log(fonts) // ["FiraCode", "JetBrainsMono", ...]
+ */
+export default class Font {
+    static "__#private@#cache": Map<any, any>;
+    /**
+     * Finds all Nerd Fonts installed on the system.
+     * Detects the current platform and uses platform-specific methods
+     * to locate font files or query the font database.
+     *
+     * @returns {Promise<Array<string>>} Array of Nerd Font family names, or empty array if none found.
+     * @example
+     * const nerdFonts = await Font.findNerdFonts()
+     * console.log(nerdFonts) // ["FiraCode Nerd Font", "JetBrains Mono NF", ...]
+     */
+    static findNerdFonts(): Promise<Array<string>>;
+    /**
+     * Checks whether any Nerd Fonts are installed on the system.
+     *
+     * @returns {Promise<boolean>} True if at least one Nerd Font is installed.
+     * @example
+     * if(await Font.hasNerdFonts()) {
+     *   console.log("Nerd Fonts available - using fancy icons!")
+     * }
+     */
+    static hasNerdFonts(): Promise<boolean>;
+    /**
+     * Gets the base family names of installed Nerd Fonts.
+     * Strips the "NF" or "Nerd Font" suffix to return the core font name.
+     *
+     * @returns {Promise<Array<string>>} Array of base font family names.
+     * @example
+     * const families = await Font.getNerdFontFamilies()
+     * console.log(families) // ["FiraCode", "JetBrains Mono", ...]
+     */
+    static getNerdFontFamilies(): Promise<Array<string>>;
+    /**
+     * Strips font style suffixes from a font name.
+     *
+     * @param {string} fontName - The font name to clean.
+     * @returns {string} The font name without style suffixes.
+     * @private
+     */
+    private static "__#private@#stripStyles";
+    /**
+     * Tests if a font name matches any Nerd Font naming patterns.
+     *
+     * @param {string} fontName - The font name to test.
+     * @param {Array<RegExp>} tests - Array of regex patterns to match against.
+     * @returns {boolean} True if the font name matches any pattern.
+     * @private
+     */
+    private static "__#private@#isNerdFontName";
+    /**
+     * Finds Nerd Fonts on Windows by scanning system and user font directories.
+     *
+     * @returns {Promise<Array<string>>} Array of Nerd Font family names.
+     * @private
+     */
+    private static "__#private@#findNerdFontsWindows";
+    /**
+     * Finds Nerd Fonts on macOS by scanning system and user font directories.
+     *
+     * @returns {Promise<Array<string>>} Array of Nerd Font family names.
+     * @private
+     */
+    private static "__#private@#findNerdFontsMac";
+    /**
+     * Finds Nerd Fonts on Linux using the fc-list command.
+     *
+     * @returns {Promise<Array<string>>} Array of Nerd Font family names.
+     * @private
+     */
+    private static "__#private@#findNerdFontsLinux";
+    /** @type {Array<RegExp>} Patterns to identify Nerd Fonts by filename */
+    static "__#private@#nerdTests": Array<RegExp>;
+    /** @type {Array<RegExp>} Patterns to identify Nerd Fonts in fc-list output */
+    static "__#private@#nerdTestsLinux": Array<RegExp>;
+    /**
+     * Identifies Nerd Fonts from a list of font file objects.
+     *
+     * @param {Array<FileObject>} fileObjects - Array of FileObject instances representing font files.
+     * @returns {Array<string>} Sorted array of unique Nerd Font family names.
+     * @private
+     */
+    private static "__#private@#identifyNerdFonts";
+    /**
+     * Gets spinner animation frames appropriate for the current font environment.
+     * Returns Unicode braille characters if Nerd Fonts are available,
+     * otherwise returns ASCII fallback characters.
+     *
+     * @returns {Promise<Array<string>>} Promise resolving to array of spinner frame characters.
+     * @example
+     * const frames = await Font.spinFrames
+     * // With Nerd Fonts: ["⠋", "⠙", "⠹", ...]
+     * // Without: ["|", "/", "-", "\\"]
+     */
+    static get spinFrames(): Promise<Array<string>>;
+}
+//# sourceMappingURL=Font.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Font.d.ts","sourceRoot":"","sources":["../../../src/node/lib/Font.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;GAeG;AACH;IACE,0CAAyB;IAEzB;;;;;;;;;OASG;IACH,wBALa,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAoBlC;IAED;;;;;;;;OAQG;IACH,uBANa,OAAO,CAAC,OAAO,CAAC,CAQ5B;IAED;;;;;;;;OAQG;IACH,8BALa,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAUlC;IAED;;;;;;OAMG;IACH,yCAEC;IAED;;;;;;;OAOG;IACH,4CAEC;IAED;;;;;OAKG;IACH,kDAgCC;IAED;;;;;OAKG;IACH,8CAyBC;IAED;;;;;OAKG;IACH,gDAoBC;IAED,wEAAwE;IACxE,gCADW,KAAK,CAAC,MAAM,CAAC,CACoB;IAE5C,8EAA8E;IAC9E,qCADW,KAAK,CAAC,MAAM,CAAC,CAC0B;IAElD;;;;;;OAMG;IACH,+CAYC;IAED;;;;;;;;;;OAUG;IACH,yBANa,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAYlC;CACF"}

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

@@ -5,5 +5,5 @@
 export default class Sass extends BrowserSass {
     #private;
 }
-import { Sass as BrowserSass } from "../../browser/index.js";
+import BrowserSass from "../../browser/lib/Sass.js";
 //# sourceMappingURL=Sass.d.ts.map

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;;CAgFC;oCAvFiC,wBAAwB"}
+{"version":3,"file":"Sass.d.ts","sourceRoot":"","sources":["../../../src/node/lib/Sass.js"],"names":[],"mappings":"AAgBA;;;GAGG;AACH;;CAgFC;wBAvFuB,2BAA2B"}

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

@@ -5,5 +5,5 @@
 export default class Tantrum extends BrowserTantrum {
     constructor(message: any, errors?: any[]);
 }
-import { Tantrum as BrowserTantrum } from "../../browser/index.js";
+import BrowserTantrum from "../../browser/lib/Tantrum.js";
 //# sourceMappingURL=Tantrum.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Tantrum.d.ts","sourceRoot":"","sources":["../../../src/node/lib/Tantrum.js"],"names":[],"mappings":"AAeA;;;GAGG;AACH;IACE,0CAEC;CA0BF;0CArCuC,wBAAwB"}
+{"version":3,"file":"Tantrum.d.ts","sourceRoot":"","sources":["../../../src/node/lib/Tantrum.js"],"names":[],"mappings":"AAeA;;;GAGG;AACH;IACE,0CAEC;CA0BF;2BArC0B,8BAA8B"}

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

@@ -1,4 +1,39 @@
 export default class Term {
+    static "__#private@#cache": Map<any, any>;
+    static "__#private@#preformat"(text: any): any;
+    /**
+     * Terminal width in columns.
+     *
+     * @type {number | undefined}
+     */
+    static get columns(): number | undefined;
+    /**
+     * Terminal height in rows.
+     *
+     * @type {number | undefined}
+     */
+    static get rows(): number | undefined;
+    /**
+     * Terminal dimensions as an object.
+     *
+     * @type {{columns: number | undefined, rows: number | undefined}}
+     */
+    static get dim(): {
+        columns: number | undefined;
+        rows: number | undefined;
+    };
+    /**
+     * Whether the terminal is interactive (TTY and not in CI).
+     *
+     * @type {boolean}
+     */
+    static get isInteractive(): boolean;
+    /**
+     * Whether the terminal supports color output.
+     *
+     * @type {boolean}
+     */
+    static get hasColor(): boolean;
     /**
      * Log an informational message.
      *
@@ -120,8 +155,120 @@ export default class Term {
      * @throws {Sass} If any element of `parts` is not a string.
      */
     static terminalBracket([level, text, brackets]: Array<string>): string;
-    static resetTerminal(): Promise<void>;
-    static clearLines(num: any): Promise<void>;
-    static directWrite(output: any): Promise<any>;
+    /**
+     * ANSI escape sequence to move cursor to start of line.
+     *
+     * @type {string}
+     */
+    static get start(): string;
+    /**
+     * Move cursor to start of line (interactive terminals only).
+     *
+     * @returns {typeof Term} The Term class for chaining.
+     */
+    static moveStart(): typeof Term;
+    /**
+     * ANSI escape sequence to move cursor to end of line.
+     *
+     * @type {string}
+     */
+    static get end(): string;
+    /**
+     * Move cursor to end of line (interactive terminals only).
+     *
+     * @returns {typeof Term} The Term class for chaining.
+     */
+    static moveEnd(): typeof Term;
+    /**
+     * ANSI escape sequence to move cursor up one line.
+     *
+     * @type {string}
+     */
+    static get up(): string;
+    /**
+     * Move cursor up by specified number of lines (interactive terminals only).
+     *
+     * @param {number} num - Number of lines to move up.
+     * @returns {typeof Term} The Term class for chaining.
+     */
+    static moveUp(num: number): typeof Term;
+    /**
+     * Hide the terminal cursor (interactive terminals only).
+     *
+     * @returns {typeof Term} The Term class for chaining.
+     */
+    static hideCursor(): typeof Term;
+    /**
+     * Show the terminal cursor (interactive terminals only).
+     *
+     * @returns {typeof Term} The Term class for chaining.
+     */
+    static showCursor(): typeof Term;
+    /**
+     * Whether the terminal is in character (raw) input mode.
+     *
+     * @type {boolean}
+     */
+    static get isCharMode(): boolean;
+    /**
+     * Whether the terminal is in line (buffered) input mode.
+     *
+     * @type {boolean}
+     */
+    static get isLineMode(): boolean;
+    /**
+     * Set terminal to character mode (raw input, interactive terminals only).
+     *
+     * @returns {typeof Term} The Term class for chaining.
+     */
+    static setCharMode(): typeof Term;
+    /**
+     * Set terminal to line mode (buffered input, interactive terminals only).
+     *
+     * @returns {typeof Term} The Term class for chaining.
+     */
+    static setLineMode(): typeof Term;
+    /**
+     * Clear the current line (interactive terminals only).
+     *
+     * @returns {typeof Term} The Term class for chaining.
+     */
+    static clearLine(): typeof Term;
+    /**
+     * Clear multiple lines by moving up and clearing each (interactive terminals only).
+     *
+     * @param {number} num - Number of lines to clear.
+     * @returns {typeof Term} The Term class for chaining.
+     */
+    static clearLines(num: number): typeof Term;
+    /**
+     * Write output to stdout asynchronously (fire-and-forget).
+     *
+     * @param {string} output - The string to write.
+     * @returns {typeof Term} The Term class for chaining.
+     */
+    static write(output: string): typeof Term;
+    /**
+     * Returns a promise that resolves with the next chunk of data from stdin.
+     * If in Char Mode, it resolves on Enter, Ctrl+D, or the ANSI 'R' terminator.
+     *
+     * @param {(text: string) => boolean} [terminator] - Optional callback to check if input is complete.
+     * @returns {Promise<string>} Resolves with the input data.
+     */
+    static data(terminator?: (text: string) => boolean): Promise<string>;
+    /**
+     * Gets the current cursor position in the terminal.
+     *
+     * @returns {Promise<[number, number]>} Resolves with [x, y] cursor position.
+     */
+    static getCursorPosition(): Promise<[number, number]>;
+    /**
+     * Write output to stdout and return a promise that resolves when complete.
+     *
+     * @param {string} output - The string to write.
+     * @returns {Promise<void>} Resolves when write completes.
+     */
+    static directWrite(output: string): Promise<void>;
+    static "__#private@#spinFrames": string[];
 }
 //# sourceMappingURL=Term.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Term.d.ts","sourceRoot":"","sources":["../../../src/node/lib/Term.js"],"names":[],"mappings":"AAOA;IACE;;;;OAIG;IACH,oBAFc,OAAO,EAAA,QAIpB;IAED;;;;OAIG;IACH,qBAFc,OAAO,EAAA,QAIpB;IAED;;;;OAIG;IACH,qBAFc,OAAO,EAAA,QAIpB;IAED;;;;OAIG;IACH,sBAFc,OAAO,EAAA,QAIpB;IAED;;;;OAIG;IACH,sBAFc,OAAO,EAAA,QAIpB;IAED;;;;OAIG;IACH,sBAFc,OAAO,EAAA,QAIpB;IAED;;OAEG;IACH,wBAEC;IAED;;;;;;;;OAQG;IACH,0BANW,MAAM,QAAQ,YAEtB;QAAgC,UAAU,GAAlC,KAAK,CAAC,MAAM,CAAC;QACK,UAAU,GAA5B,OAAO;QACW,aAAa,GAA/B,OAAO;KACjB,QA2DA;IAED;;;;;;;;;;;;;;OAcG;IACH,oBALW,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,eAEjD;QAAyB,MAAM,EAAvB,OAAO;KACf,GAAU,IAAI,CAOhB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,gCAHW,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,GAClE,IAAI,CA4BhB;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,gDAJW,KAAK,CAAC,MAAM,CAAC,GACX,MAAM,CASlB;IAED,sCAGC;IAED,2CAEC;IAED,8CAIC;CACF"}
+{"version":3,"file":"Term.d.ts","sourceRoot":"","sources":["../../../src/node/lib/Term.js"],"names":[],"mappings":"AAQA;IACE,0CAAyB;IAEzB,+CAIC;IAED;;;;OAIG;IACH,sBAFU,MAAM,GAAG,SAAS,CAI3B;IAED;;;;OAIG;IACH,mBAFU,MAAM,GAAG,SAAS,CAI3B;IAED;;;;OAIG;IACH,kBAFU;QAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;QAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAA;KAAC,CAIhE;IAED;;;;OAIG;IACH,4BAFU,OAAO,CAMhB;IAED;;;;OAIG;IACH,uBAFU,OAAO,CAMhB;IAED;;;;OAIG;IACH,oBAFc,OAAO,EAAA,QAIpB;IAED;;;;OAIG;IACH,qBAFc,OAAO,EAAA,QAIpB;IAED;;;;OAIG;IACH,qBAFc,OAAO,EAAA,QAIpB;IAED;;;;OAIG;IACH,sBAFc,OAAO,EAAA,QAIpB;IAED;;;;OAIG;IACH,sBAFc,OAAO,EAAA,QAIpB;IAED;;;;OAIG;IACH,sBAFc,OAAO,EAAA,QAIpB;IAED;;OAEG;IACH,wBAEC;IAED;;;;;;;;OAQG;IACH,0BANW,MAAM,QAAQ,YAEtB;QAAgC,UAAU,GAAlC,KAAK,CAAC,MAAM,CAAC;QACK,UAAU,GAA5B,OAAO;QACW,aAAa,GAA/B,OAAO;KACjB,QA2DA;IAED;;;;;;;;;;;;;;OAcG;IACH,oBALW,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,eAEjD;QAAyB,MAAM,EAAvB,OAAO;KACf,GAAU,IAAI,CAOhB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,gCAHW,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,GAClE,IAAI,CA4BhB;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,gDAJW,KAAK,CAAC,MAAM,CAAC,GACX,MAAM,CASlB;IAED;;;;OAIG;IACH,oBAFU,MAAM,CAIf;IAED;;;;OAIG;IACH,oBAFa,OAAO,IAAI,CAMvB;IAED;;;;OAIG;IACH,kBAFU,MAAM,CAIf;IAED;;;;OAIG;IACH,kBAFa,OAAO,IAAI,CAMvB;IAED;;;;OAIG;IACH,iBAFU,MAAM,CAIf;IAED;;;;;OAKG;IACH,mBAHW,MAAM,GACJ,OAAO,IAAI,CAMvB;IAED;;;;OAIG;IACH,qBAFa,OAAO,IAAI,CAMvB;IAED;;;;OAIG;IACH,qBAFa,OAAO,IAAI,CAMvB;IAED;;;;OAIG;IACH,yBAFU,OAAO,CAOhB;IAED;;;;OAIG;IACH,yBAFU,OAAO,CAOhB;IAED;;;;OAIG;IACH,sBAFa,OAAO,IAAI,CAMvB;IAED;;;;OAIG;IACH,sBAFa,OAAO,IAAI,CAMvB;IAED;;;;OAIG;IACH,oBAFa,OAAO,IAAI,CAMvB;IAED;;;;;OAKG;IACH,uBAHW,MAAM,GACJ,OAAO,IAAI,CAOvB;IAED;;;;;OAKG;IACH,qBAHW,MAAM,GACJ,OAAO,IAAI,CAMvB;IAED;;;;;;OAMG;IACH,yBAHW,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,GACvB,OAAO,CAAC,MAAM,CAAC,CAyD3B;IAED;;;;OAIG;IACH,4BAFa,OAAO,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAqCrC;IAED;;;;;OAKG;IACH,2BAHW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAMzB;IAID,0CAAuE;CAYxE"}

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

@@ -96,5 +96,5 @@ export default class Util extends BrowserUtil {
      */
     static getEnv(ev: string, def?: unknown): unknown;
 }
-import { Util as BrowserUtil } from "../../browser/index.js";
+import BrowserUtil from "../../browser/lib/Util.js";
 //# sourceMappingURL=Util.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Util.d.ts","sourceRoot":"","sources":["../../../src/node/lib/Util.js"],"names":[],"mappings":"AAQA;;;GAGG;AACH;IACE;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,mCAHW,MAAM,GACJ,KAAK,CAAC,MAAM,CAAC,CAazB;IAED;;;;;;;;OAQG;IACH,+CALW,MAAM,SACN,MAAM,WACH,OAAO,EAAA,GACR,OAAO,CAAC,IAAI,CAAC,CAmBzB;IAED;;;;;;;;;;;;OAYG;IACH,0BALW,YAAY,SACZ,MAAM,WACH,OAAO,EAAA,GACR,OAAO,CAAC,IAAI,CAAC,CAgBzB;IAED;;;;;;;;;;OAUG;IACH,+BALW,MAAM,SACN,MAAM,WACH,OAAO,EAAA,GACR,OAAO,CAAC,IAAI,CAAC,CAoBzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,kBALW,MAAM,QACN,OAAO,GACL,OAAO,CAmBnB;CACF;oCA1LiC,wBAAwB"}
+{"version":3,"file":"Util.d.ts","sourceRoot":"","sources":["../../../src/node/lib/Util.js"],"names":[],"mappings":"AAQA;;;GAGG;AACH;IACE;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,mCAHW,MAAM,GACJ,KAAK,CAAC,MAAM,CAAC,CAazB;IAED;;;;;;;;OAQG;IACH,+CALW,MAAM,SACN,MAAM,WACH,OAAO,EAAA,GACR,OAAO,CAAC,IAAI,CAAC,CAmBzB;IAED;;;;;;;;;;;;OAYG;IACH,0BALW,YAAY,SACZ,MAAM,WACH,OAAO,EAAA,GACR,OAAO,CAAC,IAAI,CAAC,CAgBzB;IAED;;;;;;;;;;OAUG;IACH,+BALW,MAAM,SACN,MAAM,WACH,OAAO,EAAA,GACR,OAAO,CAAC,IAAI,CAAC,CAoBzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,kBALW,MAAM,QACN,OAAO,GACL,OAAO,CAmBnB;CACF;wBA1LuB,2BAA2B"}