@gesslar/toolkit 1.9.1 → 1.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gesslar/toolkit",
-  "version": "1.9.1",
+  "version": "1.10.0",
   "description": "Get in, bitches, we're going toolkitting.",
   "main": "./src/index.js",
   "type": "module",

package/src/index.js

@@ -13,8 +13,10 @@ export {default as Util} from "./lib/Util.js"
 
 // Node-specific exports
 export {default as Cache} from "./lib/Cache.js"
+export {default as CappedDirectoryObject} from "./lib/CappedDirectoryObject.js"
 export {default as Contract} from "./lib/Contract.js"
 export {default as DirectoryObject} from "./lib/DirectoryObject.js"
+export {default as TempDirectoryObject} from "./lib/TempDirectoryObject.js"
 export {default as FileObject} from "./lib/FileObject.js"
 export {default as FS} from "./lib/FS.js"
 export {default as Glog} from "./lib/Glog.js"

package/src/lib/CappedDirectoryObject.js

@@ -0,0 +1,237 @@
+/**
+ * @file CappedDirectoryObject.js
+ * @description Abstract base class for directory objects that are constrained
+ * to a specific directory tree (the "cap"). This provides security by ensuring
+ * all operations remain within the capped directory hierarchy.
+ *
+ * This class is not intended to be instantiated directly. Use subclasses like
+ * TempDirectoryObject that define specific caps.
+ */
+
+import path from "node:path"
+
+import {Data, Valid} from "../browser/index.js"
+import DirectoryObject from "./DirectoryObject.js"
+import FileObject from "./FileObject.js"
+import Sass from "./Sass.js"
+
+/**
+ * CappedDirectoryObject extends DirectoryObject with constraints that ensure
+ * all operations are restricted to a specific directory tree (the "cap").
+ *
+ * All path operations are validated to ensure they remain within the
+ * cap directory hierarchy for security.
+ *
+ * @augments DirectoryObject
+ */
+export default class CappedDirectoryObject extends DirectoryObject {
+  #cap
+
+  /**
+   * Constructs a CappedDirectoryObject instance.
+   *
+   * This is an abstract base class - use subclasses like TempDirectoryObject
+   * that define specific caps.
+   *
+   * @param {string?} name - Base name for the directory (if empty/null, uses cap root)
+   * @param {string} cap - The root path that constrains this directory tree
+   * @param {CappedDirectoryObject?} [parent] - Optional parent capped directory
+   * @param {boolean} [temporary=false] - Whether this is a temporary directory
+   * @throws {Sass} If name is absolute
+   * @throws {Sass} If name is empty (when parent is provided)
+   * @throws {Sass} If name contains path separators
+   * @throws {Sass} If parent is not a capped directory
+   * @throws {Sass} If parent's lineage does not trace back to the cap
+   * @throws {Sass} If the resulting path would escape the cap
+   */
+  constructor(name, cap, parent=null, temporary=false) {
+    Valid.type(cap, "String")
+
+    // Validate parent using instanceof since TypeSpec doesn't understand inheritance
+    if(parent !== null && !(parent instanceof CappedDirectoryObject)) {
+      throw Sass.new(`Parent must be null or a CappedDirectoryObject instance, got ${Data.typeOf(parent)}`)
+    }
+
+    let dirPath
+
+    // Special case: empty name with no parent means use cap root
+    if(!name && !parent) {
+      dirPath = cap
+    } else {
+      Valid.type(name, "String")
+
+      // Security: Validate name before any processing
+      Valid.assert(
+        !path.isAbsolute(name),
+        "Capped directory name must not be an absolute path.",
+      )
+      Valid.assert(
+        name.length > 0,
+        "Capped directory name must not be empty.",
+      )
+      Valid.assert(
+        !name.includes("/") && !name.includes("\\") && !name.includes(path.sep),
+        "Capped directory name must not contain path separators.",
+      )
+
+      if(parent) {
+        // Ensure parent is capped
+        Valid.assert(parent.capped, "Parent must be a capped DirectoryObject.")
+
+        // Ensure parent has same cap
+        Valid.assert(
+          parent.cap === cap,
+          "Parent must have the same cap as this directory.",
+        )
+
+        const parentPath = parent.path
+
+        // Validate parent's lineage traces back to the cap
+        let found = false
+        if(parent.trail) {
+          for(const p of parent.walkUp) {
+            if(p.path === cap) {
+              found = true
+              break
+            }
+          }
+        }
+
+        Valid.assert(
+          found,
+          `The lineage of this directory must trace back to the cap '${cap}'.`,
+        )
+
+        dirPath = path.join(parentPath, name)
+      } else {
+        // No parent - this is a root-level capped directory
+        dirPath = path.join(cap, name)
+      }
+    }
+
+    // Call parent constructor with the path
+    // Pass through the temporary flag (subclasses control this)
+    super(dirPath, temporary)
+
+    // Store the cap AFTER calling super()
+    this.#cap = cap
+
+    // Validate that this path is within the cap
+    this.#validateCapPath()
+  }
+
+  /**
+   * Validates that the directory path is within the cap directory tree.
+   *
+   * @private
+   * @throws {Sass} If the path is not within the cap directory
+   */
+  #validateCapPath() {
+    const cap = this.#cap
+    const resolved = path.resolve(this.path)
+    const capResolved = path.resolve(cap)
+
+    // Check if the resolved path starts with the cap directory
+    if(!resolved.startsWith(capResolved)) {
+      throw Sass.new(
+        `Path '${this.path}' is not within the cap directory '${cap}'`
+      )
+    }
+  }
+
+  /**
+   * Returns the cap path for this directory.
+   *
+   * @returns {string} The cap directory path
+   */
+  get cap() {
+    return this.#cap
+  }
+
+  /**
+   * Returns whether this directory is capped.
+   *
+   * @returns {boolean} Always true for CappedDirectoryObject instances
+   */
+  get capped() {
+    return true
+  }
+
+  /**
+   * Creates a new CappedDirectoryObject by extending this directory's path.
+   *
+   * Validates that the resulting path remains within the cap directory tree.
+   *
+   * @param {string} newPath - The path segment to append
+   * @returns {CappedDirectoryObject} A new CappedDirectoryObject with the extended path
+   * @throws {Sass} If the path would escape the cap directory
+   * @throws {Sass} If the path is absolute
+   * @throws {Sass} If the path contains traversal (..)
+   * @example
+   * const capped = new TempDirectoryObject("myapp")
+   * const subDir = capped.addDirectory("data")
+   * console.log(subDir.path) // "/tmp/myapp-ABC123/data"
+   */
+  addDirectory(newPath) {
+    Valid.type(newPath, "String")
+
+    // Prevent absolute paths
+    if(path.isAbsolute(newPath)) {
+      throw Sass.new("Absolute paths are not allowed in capped directories")
+    }
+
+    // Prevent path traversal attacks
+    const normalized = path.normalize(newPath)
+    if(normalized.includes("..")) {
+      throw Sass.new("Path traversal (..) is not allowed in capped directories")
+    }
+
+    // Use the constructor of the current class (supports subclassing)
+    // Pass this as parent so the child inherits the same cap
+    return new this.constructor(newPath, this)
+  }
+
+  /**
+   * Creates a new FileObject by extending this directory's path.
+   *
+   * Validates that the resulting path remains within the cap directory tree.
+   *
+   * @param {string} filename - The filename to append
+   * @returns {FileObject} A new FileObject with the extended path
+   * @throws {Sass} If the path would escape the cap directory
+   * @throws {Sass} If the path is absolute
+   * @throws {Sass} If the path contains traversal (..)
+   * @example
+   * const capped = new TempDirectoryObject("myapp")
+   * const file = capped.addFile("config.json")
+   * console.log(file.path) // "/tmp/myapp-ABC123/config.json"
+   */
+  addFile(filename) {
+    Valid.type(filename, "String")
+
+    // Prevent absolute paths
+    if(path.isAbsolute(filename)) {
+      throw Sass.new("Absolute paths are not allowed in capped directories")
+    }
+
+    // Prevent path traversal attacks
+    const normalized = path.normalize(filename)
+    if(normalized.includes("..")) {
+      throw Sass.new("Path traversal (..) is not allowed in capped directories")
+    }
+
+    // Create the file path by joining this directory with the filename
+    const filePath = path.join(this.path, filename)
+
+    return new FileObject(filePath)
+  }
+
+  /**
+   * Returns a string representation of the CappedDirectoryObject.
+   *
+   * @returns {string} string representation of the CappedDirectoryObject
+   */
+  toString() {
+    return `[CappedDirectoryObject: ${this.path}]`
+  }
+}

package/src/lib/DirectoryObject.js

@@ -9,10 +9,10 @@ import path from "node:path"
 import {URL} from "node:url"
 import util from "node:util"
 
+import {Data, Valid} from "../browser/index.js"
 import FS from "./FS.js"
 import FileObject from "./FileObject.js"
 import Sass from "./Sass.js"
-import {Data, Valid} from "../browser/index.js"
 
 /**
  * DirectoryObject encapsulates metadata and operations for a directory,
@@ -64,10 +64,10 @@ export default class DirectoryObject extends FS {
   constructor(directory=null, temporary=false) {
     super()
 
-    Valid.type(directory, "String|DirectoryObject|Null")
+    Valid.type(directory, "String|TempDirectoryObject|DirectoryObject|Null")
 
     // If passed a DirectoryObject, extract its path
-    if(Data.isType(directory, "DirectoryObject"))
+    if(Data.isType(directory, "DirectoryObject") || Data.isType(directory, "TempDirectoryObject"))
       directory = directory.path
 
     const fixedDir = FS.fixSlashes(directory ?? ".")
@@ -231,7 +231,8 @@ export default class DirectoryObject extends FS {
    * @throws {Sass} If the directory is not marked as temporary
    * @throws {Sass} If the directory deletion fails
    * @example
-   * const tempDir = await FS.tempDirectory("my-temp")
+   * const tempDir = new TempDirectoryObject("my-temp")
+   * await tempDir.assureExists()
    * // ... use the directory ...
    * await tempDir.remove() // Recursively deletes everything
    */
@@ -440,20 +441,19 @@ export default class DirectoryObject extends FS {
   }
 
   /**
-   * Creates a new DirectoryObject by merging this directory's path with a new
-   * path.
+   * Creates a new DirectoryObject by extending this directory's path.
    *
    * Uses overlapping path segment detection to intelligently combine paths.
    * Preserves the temporary flag from the current directory.
    *
-   * @param {string} newPath - The path to merge with this directory's path.
-   * @returns {DirectoryObject} A new DirectoryObject with the merged path.
+   * @param {string} newPath - The path to append to this directory's path.
+   * @returns {DirectoryObject} A new DirectoryObject with the extended path.
    * @example
    * const dir = new DirectoryObject("/projects/git/toolkit")
-   * const subDir = dir.to("toolkit/src/lib")
+   * const subDir = dir.addDirectory("src/lib")
    * console.log(subDir.path) // "/projects/git/toolkit/src/lib"
    */
-  to(newPath) {
+  addDirectory(newPath) {
     Valid.type(newPath, "String")
 
     const thisPath = this.path
@@ -461,4 +461,25 @@ export default class DirectoryObject extends FS {
 
     return new this.constructor(merged, this.temporary)
   }
+
+  /**
+   * Creates a new FileObject by extending this directory's path.
+   *
+   * Uses overlapping path segment detection to intelligently combine paths.
+   *
+   * @param {string} filename - The filename to append to this directory's path.
+   * @returns {FileObject} A new FileObject with the extended path.
+   * @example
+   * const dir = new DirectoryObject("/projects/git/toolkit")
+   * const file = dir.addFile("package.json")
+   * console.log(file.path) // "/projects/git/toolkit/package.json"
+   */
+  addFile(filename) {
+    Valid.type(filename, "String")
+
+    const thisPath = this.path
+    const merged = FS.mergeOverlappingPaths(thisPath, filename)
+
+    return new FileObject(merged)
+  }
 }

package/src/lib/FS.js

@@ -8,13 +8,10 @@
 import {globby} from "globby"
 import path from "node:path"
 import url from "node:url"
-import fs from "node:fs/promises"
-import os from "node:os"
 
 import Collection from "../browser/lib/Collection.js"
 import Sass from "./Sass.js"
 import Valid from "./Valid.js"
-import DirectoryObject from "./DirectoryObject.js"
 
 /** @typedef {import("./FileObject.js").default} FileObject */
 /** @typedef {import("./DirectoryObject.js").default} DirectoryObject */
@@ -217,88 +214,4 @@ export default class FS {
     // join if no overlap
     return FS.mergeOverlappingPaths(from, normalizedTo)
   }
-
-  /**
-   * Creates a new temporary directory and wraps it in a DirectoryObject.
-   *
-   * When called without a parent, creates a new temporary directory in the OS
-   * temp folder with a unique name. When called with a parent DirectoryObject,
-   * creates a subdirectory within that parent.
-   *
-   * The parent directory (if provided) must:
-   * - Be marked as temporary
-   * - Actually exist on the filesystem
-   * - Have lineage tracing back to the OS temp directory
-   *
-   * These validations ensure that only legitimately temporary directories can
-   * be created and later removed with the remove() method.
-   *
-   * @static
-   * @async
-   * @param {string} name - The base name for the temporary directory. When creating a root temp directory, a random suffix will be appended for uniqueness.
-   * @param {DirectoryObject|null} [parent] - Optional parent DirectoryObject to create this directory within. Must be a temporary directory itself.
-   * @returns {Promise<DirectoryObject>} A DirectoryObject representing the created temporary directory, with the temporary flag set to true.
-   * @throws {Sass} If name is not a string
-   * @throws {Sass} If parent is provided but is not a DirectoryObject
-   * @throws {Sass} If parent is not marked as temporary
-   * @throws {Sass} If parent does not exist
-   * @throws {Sass} If parent's lineage does not trace back to the OS temp directory
-   * @example
-   * // Create a standalone temporary directory
-   * const tempDir = await FS.tempDirectory("my-temp")
-   * console.log(tempDir.temporary) // true
-   * console.log(tempDir.path) // /tmp/my-temp-abc123 (on Unix)
-   *
-   * @example
-   * // Create nested temporary directories
-   * const parent = await FS.tempDirectory("parent")
-   * const child = await FS.tempDirectory("child", parent)
-   * console.log(child.path.startsWith(parent.path)) // true
-   * await parent.remove() // Removes both parent and child
-   */
-  static async tempDirectory(name, parent=null) {
-    Valid.type(name, "String")
-    Valid.type(parent, "Null|DirectoryObject")
-
-    const temp = os.tmpdir()
-
-    if(parent) {
-      Valid.assert(parent.temporary, "Parent must be a temporary DirectoryObject.")
-      Valid.assert(await parent.exists, "Parent must exist.")
-
-      let found = false
-      for(const p of parent.walkUp) {
-        if(p.path === temp) {
-          found = true
-          break
-        }
-      }
-
-      Valid.assert(found, "The lineage of this directory must be the OS temp directory.")
-
-      // Security: Reject absolute paths, path traversal, and path separators
-      Valid.assert(
-        !path.isAbsolute(name),
-        "Temporary directory name must not be an absolute path."
-      )
-      Valid.assert(
-        !name.includes("/") && !name.includes("\\") && !name.includes(path.sep),
-        "Temporary directory name must not contain path separators."
-      )
-      Valid.assert(
-        name.length > 0,
-        "Temporary directory name must not be empty."
-      )
-
-      const dir = new DirectoryObject(path.join(parent.path, name), true)
-      await dir.assureExists()
-
-      return dir
-    }
-
-    const prefix = name.endsWith("-") ? name : `${name}-`
-    const dir = await fs.mkdtemp(path.join(temp, prefix))
-
-    return new DirectoryObject(dir, true)
-  }
 }

package/src/lib/FileObject.js

@@ -98,6 +98,7 @@ export default class FileObject extends FS {
         case "String":
           return new DirectoryObject(directory)
         case "DirectoryObject":
+        case "TempDirectoryObject":
           return directory
         default:
           return new DirectoryObject(dir)

package/src/lib/TempDirectoryObject.js

@@ -0,0 +1,148 @@
+/**
+ * @file TempDirectoryObject.js
+ * @description Class representing a temporary directory that is constrained
+ * to the OS's temporary directory tree.
+ */
+
+import fs from "node:fs"
+import os from "node:os"
+
+import CappedDirectoryObject from "./CappedDirectoryObject.js"
+import Sass from "./Sass.js"
+
+/**
+ * TempDirectoryObject extends CappedDirectoryObject with the cap set to
+ * the OS's temporary directory. Temporary directories are created
+ * synchronously during construction and exist immediately.
+ *
+ * All path operations are validated to ensure they remain within the temp
+ * directory hierarchy for security.
+ *
+ * @augments CappedDirectoryObject
+ */
+export default class TempDirectoryObject extends CappedDirectoryObject {
+
+  /**
+   * Constructs a TempDirectoryObject instance and creates the directory.
+   *
+   * The directory is created synchronously during construction, so it will
+   * exist immediately after the constructor returns.
+   *
+   * If no name is provided, uses the OS temp directory directly. If a name
+   * is provided without a parent, creates a new directory with a unique suffix.
+   * If a parent is provided, creates a subdirectory within that parent.
+   *
+   * @param {string?} [name] - Base name for the temp directory (if empty/null, uses OS temp dir)
+   * @param {TempDirectoryObject?} [parent] - Optional parent temporary directory
+   * @throws {Sass} If name is absolute
+   * @throws {Sass} If name is empty (when parent is provided)
+   * @throws {Sass} If name contains path separators
+   * @throws {Sass} If parent is provided but not a temporary directory
+   * @throws {Sass} If parent's lineage does not trace back to the OS temp directory
+   * @throws {Sass} If directory creation fails
+   * @example
+   * // Use OS temp directory directly
+   * const temp = new TempDirectoryObject()
+   * console.log(temp.path) // "/tmp"
+   *
+   * @example
+   * // Create with unique name
+   * const temp = new TempDirectoryObject("myapp")
+   * console.log(temp.path) // "/tmp/myapp-ABC123"
+   *
+   * @example
+   * // Nested temp directories
+   * const parent = new TempDirectoryObject("parent")
+   * const child = new TempDirectoryObject("child", parent)
+   * await parent.remove() // Removes both parent and child
+   */
+  constructor(name, parent=null) {
+    let finalName = name
+
+    // Only generate unique suffix if we have a name and no parent
+    if(name && !parent) {
+      const prefix = name.endsWith("-") ? name : `${name}-`
+      const uniqueSuffix =
+        Math.random()
+          .toString(36)
+          .substring(2, 8)
+          .toUpperCase()
+      finalName = `${prefix}${uniqueSuffix}`
+    }
+
+    // Call parent constructor with the cap set to OS temp directory
+    // Mark as temporary=true so remove() works
+    super(finalName, os.tmpdir(), parent, true)
+
+    // Temp-specific behavior: create directory immediately
+    this.#createDirectory()
+  }
+
+  /**
+   * Creates the directory synchronously on the filesystem.
+   *
+   * @private
+   * @throws {Sass} If directory creation fails
+   */
+  #createDirectory() {
+    try {
+      fs.mkdirSync(this.path)
+    } catch(e) {
+      // EEXIST is fine - directory already exists
+      if(e.code !== "EEXIST") {
+        throw Sass.new(
+          `Unable to create temporary directory '${this.path}': ${e.message}`
+        )
+      }
+    }
+  }
+
+  /**
+   * Creates a new TempDirectoryObject by extending this directory's path.
+   *
+   * Validates that the resulting path remains within the temp directory tree.
+   *
+   * @param {string} newPath - The path segment to append
+   * @returns {TempDirectoryObject} A new TempDirectoryObject with the extended path
+   * @throws {Sass} If the path would escape the temp directory
+   * @throws {Sass} If the path is absolute
+   * @throws {Sass} If the path contains traversal (..)
+   * @example
+   * const temp = new TempDirectoryObject("myapp")
+   * const subDir = temp.addDirectory("data")
+   * console.log(subDir.path) // "/tmp/myapp-ABC123/data"
+   */
+  addDirectory(newPath) {
+    // Delegate to base class addDirectory() which will call TempDirectoryObject constructor
+    return super.addDirectory(newPath)
+  }
+
+  /**
+   * Creates a new FileObject by extending this directory's path.
+   *
+   * Validates that the resulting path remains within the temp directory tree.
+   *
+   * @param {string} filename - The filename to append
+   * @returns {FileObject} A new FileObject with the extended path
+   * @throws {Sass} If the path would escape the temp directory
+   * @throws {Sass} If the path is absolute
+   * @throws {Sass} If the path contains traversal (..)
+   * @example
+   * const temp = new TempDirectoryObject("myapp")
+   * const file = temp.addFile("config.json")
+   * console.log(file.path) // "/tmp/myapp-ABC123/config.json"
+   */
+  addFile(filename) {
+    // Delegate to base class addFile() which handles security checks
+    return super.addFile(filename)
+  }
+
+  /**
+   * Returns a string representation of the TempDirectoryObject.
+   *
+   * @returns {string} string representation of the TempDirectoryObject
+   */
+  toString() {
+    return `[TempDirectoryObject: ${this.path}]`
+  }
+}

package/src/types/index.d.ts

@@ -6,8 +6,10 @@ export { default as Sass } from "./lib/Sass.js";
 export { default as Tantrum } from "./lib/Tantrum.js";
 export { default as Util } from "./lib/Util.js";
 export { default as Cache } from "./lib/Cache.js";
+export { default as CappedDirectoryObject } from "./lib/CappedDirectoryObject.js";
 export { default as Contract } from "./lib/Contract.js";
 export { default as DirectoryObject } from "./lib/DirectoryObject.js";
+export { default as TempDirectoryObject } from "./lib/TempDirectoryObject.js";
 export { default as FileObject } from "./lib/FileObject.js";
 export { default as FS } from "./lib/FS.js";
 export { default as Glog } from "./lib/Glog.js";

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

@@ -0,0 +1,60 @@
+/**
+ * CappedDirectoryObject extends DirectoryObject with constraints that ensure
+ * all operations are restricted to a specific directory tree (the "cap").
+ *
+ * All path operations are validated to ensure they remain within the
+ * cap directory hierarchy for security.
+ *
+ * @augments DirectoryObject
+ */
+export default class CappedDirectoryObject extends DirectoryObject {
+    /**
+     * Constructs a CappedDirectoryObject instance.
+     *
+     * This is an abstract base class - use subclasses like TempDirectoryObject
+     * that define specific caps.
+     *
+     * @param {string?} name - Base name for the directory (if empty/null, uses cap root)
+     * @param {string} cap - The root path that constrains this directory tree
+     * @param {CappedDirectoryObject?} [parent] - Optional parent capped directory
+     * @param {boolean} [temporary=false] - Whether this is a temporary directory
+     * @throws {Sass} If name is absolute
+     * @throws {Sass} If name is empty (when parent is provided)
+     * @throws {Sass} If name contains path separators
+     * @throws {Sass} If parent is not a capped directory
+     * @throws {Sass} If parent's lineage does not trace back to the cap
+     * @throws {Sass} If the resulting path would escape the cap
+     */
+    constructor(name: string | null, cap: string, parent?: CappedDirectoryObject | null, temporary?: boolean);
+    /**
+     * Returns the cap path for this directory.
+     *
+     * @returns {string} The cap directory path
+     */
+    get cap(): string;
+    /**
+     * Returns whether this directory is capped.
+     *
+     * @returns {boolean} Always true for CappedDirectoryObject instances
+     */
+    get capped(): boolean;
+    /**
+     * Creates a new CappedDirectoryObject by extending this directory's path.
+     *
+     * Validates that the resulting path remains within the cap directory tree.
+     *
+     * @param {string} newPath - The path segment to append
+     * @returns {CappedDirectoryObject} A new CappedDirectoryObject with the extended path
+     * @throws {Sass} If the path would escape the cap directory
+     * @throws {Sass} If the path is absolute
+     * @throws {Sass} If the path contains traversal (..)
+     * @example
+     * const capped = new TempDirectoryObject("myapp")
+     * const subDir = capped.addDirectory("data")
+     * console.log(subDir.path) // "/tmp/myapp-ABC123/data"
+     */
+    addDirectory(newPath: string): CappedDirectoryObject;
+    #private;
+}
+import DirectoryObject from "./DirectoryObject.js";
+//# sourceMappingURL=CappedDirectoryObject.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CappedDirectoryObject.d.ts","sourceRoot":"","sources":["../../lib/CappedDirectoryObject.js"],"names":[],"mappings":"AAiBA;;;;;;;;GAQG;AACH;IAGE;;;;;;;;;;;;;;;;OAgBG;IACH,kBAXW,MAAM,OAAC,OACP,MAAM,WACN,qBAAqB,OAAC,cACtB,OAAO,EAkFjB;IAqBD;;;;OAIG;IACH,WAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,cAFa,OAAO,CAInB;IAED;;;;;;;;;;;;;;OAcG;IACH,sBAVW,MAAM,GACJ,qBAAqB,CA0BjC;;CA6CF;4BA/N2B,sBAAsB"}

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

@@ -102,7 +102,8 @@ export default class DirectoryObject extends FS {
      * @throws {Sass} If the directory is not marked as temporary
      * @throws {Sass} If the directory deletion fails
      * @example
-     * const tempDir = await FS.tempDirectory("my-temp")
+     * const tempDir = new TempDirectoryObject("my-temp")
+     * await tempDir.assureExists()
      * // ... use the directory ...
      * await tempDir.remove() // Recursively deletes everything
      */
@@ -190,20 +191,32 @@ export default class DirectoryObject extends FS {
      */
     hasDirectory(dirname: string): Promise<boolean>;
     /**
-     * Creates a new DirectoryObject by merging this directory's path with a new
-     * path.
+     * Creates a new DirectoryObject by extending this directory's path.
      *
      * Uses overlapping path segment detection to intelligently combine paths.
      * Preserves the temporary flag from the current directory.
      *
-     * @param {string} newPath - The path to merge with this directory's path.
-     * @returns {DirectoryObject} A new DirectoryObject with the merged path.
+     * @param {string} newPath - The path to append to this directory's path.
+     * @returns {DirectoryObject} A new DirectoryObject with the extended path.
      * @example
      * const dir = new DirectoryObject("/projects/git/toolkit")
-     * const subDir = dir.to("toolkit/src/lib")
+     * const subDir = dir.addDirectory("src/lib")
      * console.log(subDir.path) // "/projects/git/toolkit/src/lib"
      */
-    to(newPath: string): DirectoryObject;
+    addDirectory(newPath: string): DirectoryObject;
+    /**
+     * Creates a new FileObject by extending this directory's path.
+     *
+     * Uses overlapping path segment detection to intelligently combine paths.
+     *
+     * @param {string} filename - The filename to append to this directory's path.
+     * @returns {FileObject} A new FileObject with the extended path.
+     * @example
+     * const dir = new DirectoryObject("/projects/git/toolkit")
+     * const file = dir.addFile("package.json")
+     * console.log(file.path) // "/projects/git/toolkit/package.json"
+     */
+    addFile(filename: string): FileObject;
     #private;
 }
 import FS from "./FS.js";

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

@@ -1 +1 @@
-{"version":3,"file":"DirectoryObject.d.ts","sourceRoot":"","sources":["../../lib/DirectoryObject.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;GAaG;AACH;uBA4Fe,MAAM;IAjEnB;;;;;OAKG;IACH,yCAFW,OAAO,EA6BjB;IAWD;;;;OAIG;IACH,UAFa,MAAM,CAalB;IAWD;;;;OAIG;IACH,cAFa,OAAO,CAAC,OAAO,CAAC,CAI5B;IAED;;;;OAIG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,GAAG,CAIf;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,cAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,MAAM,CAIlB;IAED;;;;;;;OAOG;IACH,aALa,KAAK,CAAC,MAAM,CAAC,CAOzB;IAED;;;;OAIG;IACH,iBAFa,OAAO,CAInB;IAED;;;;;;;;;;;;;;;OAeG;IACH,UARa,OAAO,CAAC,IAAI,CAAC,CAyBzB;IAED;;;;OAIG;IACH,cAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,mBAFa,OAAO,CAInB;IAiBD;;;;OAIG;IACH,QAFa,OAAO,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;QAAC,WAAW,EAAE,KAAK,CAAC,eAAe,CAAC,CAAA;KAAC,CAAC,CAkBpF;IAED;;;;;;;;;;;;OAYG;IACH,uBARW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAqBzB;IA8BD;;;;;;;;;;;;;;;OAeG;IACH,cAZa,MAAM,CAclB;IAED;;;;;;;;;;;;;;OAcG;IACH,UARa,OAAO,CAAC,IAAI,CAAC,CAkBzB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAM5B;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAO5B;IAED;;;;;;;;;;;;;OAaG;IACH,YAPW,MAAM,GACJ,eAAe,CAa3B;;CACF;eApcc,SAAS;uBACD,iBAAiB"}
+{"version":3,"file":"DirectoryObject.d.ts","sourceRoot":"","sources":["../../lib/DirectoryObject.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;GAaG;AACH;uBA4Fe,MAAM;IAjEnB;;;;;OAKG;IACH,yCAFW,OAAO,EA6BjB;IAWD;;;;OAIG;IACH,UAFa,MAAM,CAalB;IAWD;;;;OAIG;IACH,cAFa,OAAO,CAAC,OAAO,CAAC,CAI5B;IAED;;;;OAIG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,GAAG,CAIf;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,cAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,MAAM,CAIlB;IAED;;;;;;;OAOG;IACH,aALa,KAAK,CAAC,MAAM,CAAC,CAOzB;IAED;;;;OAIG;IACH,iBAFa,OAAO,CAInB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,UATa,OAAO,CAAC,IAAI,CAAC,CA0BzB;IAED;;;;OAIG;IACH,cAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,mBAFa,OAAO,CAInB;IAiBD;;;;OAIG;IACH,QAFa,OAAO,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;QAAC,WAAW,EAAE,KAAK,CAAC,eAAe,CAAC,CAAA;KAAC,CAAC,CAkBpF;IAED;;;;;;;;;;;;OAYG;IACH,uBARW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAqBzB;IA8BD;;;;;;;;;;;;;;;OAeG;IACH,cAZa,MAAM,CAclB;IAED;;;;;;;;;;;;;;OAcG;IACH,UARa,OAAO,CAAC,IAAI,CAAC,CAkBzB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAM5B;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAO5B;IAED;;;;;;;;;;;;OAYG;IACH,sBAPW,MAAM,GACJ,eAAe,CAa3B;IAED;;;;;;;;;;;OAWG;IACH,kBAPW,MAAM,GACJ,UAAU,CAatB;;CACF;eAxdc,SAAS;uBACD,iBAAiB"}

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

@@ -71,47 +71,7 @@ export default class FS {
      * @returns {string} The resolved path
      */
     static resolvePath(fromPath: string, toPath: string): string;
-    /**
-     * Creates a new temporary directory and wraps it in a DirectoryObject.
-     *
-     * When called without a parent, creates a new temporary directory in the OS
-     * temp folder with a unique name. When called with a parent DirectoryObject,
-     * creates a subdirectory within that parent.
-     *
-     * The parent directory (if provided) must:
-     * - Be marked as temporary
-     * - Actually exist on the filesystem
-     * - Have lineage tracing back to the OS temp directory
-     *
-     * These validations ensure that only legitimately temporary directories can
-     * be created and later removed with the remove() method.
-     *
-     * @static
-     * @async
-     * @param {string} name - The base name for the temporary directory. When creating a root temp directory, a random suffix will be appended for uniqueness.
-     * @param {DirectoryObject|null} [parent] - Optional parent DirectoryObject to create this directory within. Must be a temporary directory itself.
-     * @returns {Promise<DirectoryObject>} A DirectoryObject representing the created temporary directory, with the temporary flag set to true.
-     * @throws {Sass} If name is not a string
-     * @throws {Sass} If parent is provided but is not a DirectoryObject
-     * @throws {Sass} If parent is not marked as temporary
-     * @throws {Sass} If parent does not exist
-     * @throws {Sass} If parent's lineage does not trace back to the OS temp directory
-     * @example
-     * // Create a standalone temporary directory
-     * const tempDir = await FS.tempDirectory("my-temp")
-     * console.log(tempDir.temporary) // true
-     * console.log(tempDir.path) // /tmp/my-temp-abc123 (on Unix)
-     *
-     * @example
-     * // Create nested temporary directories
-     * const parent = await FS.tempDirectory("parent")
-     * const child = await FS.tempDirectory("child", parent)
-     * console.log(child.path.startsWith(parent.path)) // true
-     * await parent.remove() // Removes both parent and child
-     */
-    static tempDirectory(name: string, parent?: DirectoryObject | null): Promise<DirectoryObject>;
 }
 export type FileObject = import("./FileObject.js").default;
 export type DirectoryObject = import("./DirectoryObject.js").default;
-import DirectoryObject from "./DirectoryObject.js";
 //# sourceMappingURL=FS.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"FS.d.ts","sourceRoot":"","sources":["../../lib/FS.js"],"names":[],"mappings":"AA2BA;;GAEG;AACH;IACE,kCAAwB;IACxB,uCAAkC;IAClC,mBAAsB;IAEtB;;;;;;OAMG;IACH,4BAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,2BAHW,MAAM,GACJ,MAAM,CAUlB;IAED;;;;;;OAMG;IACH,2BAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;;;;;;OAQG;IACH,sBALW,MAAM,GAAC,KAAK,CAAC,MAAM,CAAC,GAClB,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAmCtC;IAED;;;;;;;;;;OAUG;IACH,oCAJW,UAAU,GAAC,eAAe,MAC1B,UAAU,GAAC,eAAe,GACxB,MAAM,CAYlB;IAED;;;;;;;;OAQG;IACH,oCALW,MAAM,SACN,MAAM,QACN,MAAM,GACJ,MAAM,CA2BlB;IAED;;;;;;;;OAQG;IACH,6BAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAgClB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACH,2BArBW,MAAM,WACN,eAAe,GAAC,IAAI,GAClB,OAAO,CAAC,eAAe,CAAC,CA+DpC;CACF;yBA7Ra,OAAO,iBAAiB,EAAE,OAAO;8BACjC,OAAO,sBAAsB,EAAE,OAAO;4BAHxB,sBAAsB"}
+{"version":3,"file":"FS.d.ts","sourceRoot":"","sources":["../../lib/FS.js"],"names":[],"mappings":"AAwBA;;GAEG;AACH;IACE,kCAAwB;IACxB,uCAAkC;IAClC,mBAAsB;IAEtB;;;;;;OAMG;IACH,4BAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,2BAHW,MAAM,GACJ,MAAM,CAUlB;IAED;;;;;;OAMG;IACH,2BAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;;;;;;OAQG;IACH,sBALW,MAAM,GAAC,KAAK,CAAC,MAAM,CAAC,GAClB,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAmCtC;IAED;;;;;;;;;;OAUG;IACH,oCAJW,UAAU,GAAC,eAAe,MAC1B,UAAU,GAAC,eAAe,GACxB,MAAM,CAYlB;IAED;;;;;;;;OAQG;IACH,oCALW,MAAM,SACN,MAAM,QACN,MAAM,GACJ,MAAM,CA2BlB;IAED;;;;;;;;OAQG;IACH,6BAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAgClB;CACF;yBAzMa,OAAO,iBAAiB,EAAE,OAAO;8BACjC,OAAO,sBAAsB,EAAE,OAAO"}

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

@@ -1 +1 @@
-{"version":3,"file":"FileObject.d.ts","sourceRoot":"","sources":["../../lib/FileObject.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;GAcG;AAEH;uBAsHe,MAAM;IArHnB;;;;;OAKG;IACH,yBAFU;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC,OAAO,KAAK,GAAG,OAAO,IAAI,CAAC,CAAA;KAAC,CAO1D;IA2BF;;;;;OAKG;IACH,sBAHW,MAAM,GAAG,UAAU,cACnB,eAAe,GAAC,MAAM,GAAC,IAAI,EA0CrC;IAWD;;;;OAIG;IACH,UAFa,MAAM,CAclB;IAWD;;;;OAIG;IACH,cAFa,OAAO,CAAC,OAAO,CAAC,CAI5B;IAED;;;;OAIG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,GAAG,CAIf;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,cAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAFa,MAAM,CAIlB;IACD;;;;OAIG;IACH,cAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,mBAFa,OAAO,CAInB;IAED;;;;;;;;;;;;;;OAcG;IACH,iBAFa,eAAe,CAI3B;IAED;;;;OAIG;IACH,WAFa,OAAO,CAAC,OAAO,CAAC,CAU5B;IAED;;;;OAIG;IACH,YAFa,OAAO,CAAC,OAAO,CAAC,CAU5B;IAiBD;;;;OAIG;IACH,QAFa,OAAO,CAAC,MAAM,OAAC,CAAC,CAU5B;IAED;;;;;OAKG;IACH,YAFa,OAAO,CAAC,IAAI,OAAC,CAAC,CAU1B;IAsBD;;;;;OAKG;IACH,gBAHW,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CAY3B;IAED;;;;;;;;;;;OAWG;IACH,cARa,OAAO,CAAC,MAAM,CAAC,CAkB3B;IAED;;;;;;;;;;;OAWG;IACH,eARW,MAAM,aACN,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAezB;IAED;;;;;;;;;;;;;;;OAeG;IACH,kBAXW,WAAW,GAAC,IAAI,GAAC,MAAM,GACrB,OAAO,CAAC,IAAI,CAAC,CAyBzB;IAED;;;;;;;;;;;;;;OAcG;IACH,gBAXW,MAAM,aACN,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAkC5B;IAED;;;;OAIG;IACH,UAFa,OAAO,CAAC,MAAM,CAAC,CAY3B;IAED;;;;;;;;;OASG;IACH,UAPa,OAAO,CAAC,IAAI,CAAC,CAiBzB;;CACF;eArgBc,SAAS;4BADI,sBAAsB;kBARhC,OAAO;iBAIR,MAAM"}
+{"version":3,"file":"FileObject.d.ts","sourceRoot":"","sources":["../../lib/FileObject.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;GAcG;AAEH;uBAuHe,MAAM;IAtHnB;;;;;OAKG;IACH,yBAFU;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC,OAAO,KAAK,GAAG,OAAO,IAAI,CAAC,CAAA;KAAC,CAO1D;IA2BF;;;;;OAKG;IACH,sBAHW,MAAM,GAAG,UAAU,cACnB,eAAe,GAAC,MAAM,GAAC,IAAI,EA2CrC;IAWD;;;;OAIG;IACH,UAFa,MAAM,CAclB;IAWD;;;;OAIG;IACH,cAFa,OAAO,CAAC,OAAO,CAAC,CAI5B;IAED;;;;OAIG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,GAAG,CAIf;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,cAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAFa,MAAM,CAIlB;IACD;;;;OAIG;IACH,cAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,mBAFa,OAAO,CAInB;IAED;;;;;;;;;;;;;;OAcG;IACH,iBAFa,eAAe,CAI3B;IAED;;;;OAIG;IACH,WAFa,OAAO,CAAC,OAAO,CAAC,CAU5B;IAED;;;;OAIG;IACH,YAFa,OAAO,CAAC,OAAO,CAAC,CAU5B;IAiBD;;;;OAIG;IACH,QAFa,OAAO,CAAC,MAAM,OAAC,CAAC,CAU5B;IAED;;;;;OAKG;IACH,YAFa,OAAO,CAAC,IAAI,OAAC,CAAC,CAU1B;IAsBD;;;;;OAKG;IACH,gBAHW,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CAY3B;IAED;;;;;;;;;;;OAWG;IACH,cARa,OAAO,CAAC,MAAM,CAAC,CAkB3B;IAED;;;;;;;;;;;OAWG;IACH,eARW,MAAM,aACN,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAezB;IAED;;;;;;;;;;;;;;;OAeG;IACH,kBAXW,WAAW,GAAC,IAAI,GAAC,MAAM,GACrB,OAAO,CAAC,IAAI,CAAC,CAyBzB;IAED;;;;;;;;;;;;;;OAcG;IACH,gBAXW,MAAM,aACN,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAkC5B;IAED;;;;OAIG;IACH,UAFa,OAAO,CAAC,MAAM,CAAC,CAY3B;IAED;;;;;;;;;OASG;IACH,UAPa,OAAO,CAAC,IAAI,CAAC,CAiBzB;;CACF;eAtgBc,SAAS;4BADI,sBAAsB;kBARhC,OAAO;iBAIR,MAAM"}

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

@@ -0,0 +1,82 @@
+/**
+ * TempDirectoryObject extends CappedDirectoryObject with the cap set to
+ * the OS's temporary directory. Temporary directories are created
+ * synchronously during construction and exist immediately.
+ *
+ * All path operations are validated to ensure they remain within the temp
+ * directory hierarchy for security.
+ *
+ * @augments CappedDirectoryObject
+ */
+export default class TempDirectoryObject extends CappedDirectoryObject {
+    /**
+     * Constructs a TempDirectoryObject instance and creates the directory.
+     *
+     * The directory is created synchronously during construction, so it will
+     * exist immediately after the constructor returns.
+     *
+     * If no name is provided, uses the OS temp directory directly. If a name
+     * is provided without a parent, creates a new directory with a unique suffix.
+     * If a parent is provided, creates a subdirectory within that parent.
+     *
+     * @param {string?} [name] - Base name for the temp directory (if empty/null, uses OS temp dir)
+     * @param {TempDirectoryObject?} [parent] - Optional parent temporary directory
+     * @throws {Sass} If name is absolute
+     * @throws {Sass} If name is empty (when parent is provided)
+     * @throws {Sass} If name contains path separators
+     * @throws {Sass} If parent is provided but not a temporary directory
+     * @throws {Sass} If parent's lineage does not trace back to the OS temp directory
+     * @throws {Sass} If directory creation fails
+     * @example
+     * // Use OS temp directory directly
+     * const temp = new TempDirectoryObject()
+     * console.log(temp.path) // "/tmp"
+     *
+     * @example
+     * // Create with unique name
+     * const temp = new TempDirectoryObject("myapp")
+     * console.log(temp.path) // "/tmp/myapp-ABC123"
+     *
+     * @example
+     * // Nested temp directories
+     * const parent = new TempDirectoryObject("parent")
+     * const child = new TempDirectoryObject("child", parent)
+     * await parent.remove() // Removes both parent and child
+     */
+    constructor(name?: string | null, parent?: TempDirectoryObject | null);
+    /**
+     * Creates a new TempDirectoryObject by extending this directory's path.
+     *
+     * Validates that the resulting path remains within the temp directory tree.
+     *
+     * @param {string} newPath - The path segment to append
+     * @returns {TempDirectoryObject} A new TempDirectoryObject with the extended path
+     * @throws {Sass} If the path would escape the temp directory
+     * @throws {Sass} If the path is absolute
+     * @throws {Sass} If the path contains traversal (..)
+     * @example
+     * const temp = new TempDirectoryObject("myapp")
+     * const subDir = temp.addDirectory("data")
+     * console.log(subDir.path) // "/tmp/myapp-ABC123/data"
+     */
+    addDirectory(newPath: string): TempDirectoryObject;
+    /**
+     * Creates a new FileObject by extending this directory's path.
+     *
+     * Validates that the resulting path remains within the temp directory tree.
+     *
+     * @param {string} filename - The filename to append
+     * @returns {FileObject} A new FileObject with the extended path
+     * @throws {Sass} If the path would escape the temp directory
+     * @throws {Sass} If the path is absolute
+     * @throws {Sass} If the path contains traversal (..)
+     * @example
+     * const temp = new TempDirectoryObject("myapp")
+     * const file = temp.addFile("config.json")
+     * console.log(file.path) // "/tmp/myapp-ABC123/config.json"
+     */
+    addFile(filename: string): FileObject;
+    #private;
+}
+import CappedDirectoryObject from "./CappedDirectoryObject.js";
+//# sourceMappingURL=TempDirectoryObject.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TempDirectoryObject.d.ts","sourceRoot":"","sources":["../../lib/TempDirectoryObject.js"],"names":[],"mappings":"AAYA;;;;;;;;;GASG;AACH;IAEE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,mBAxBW,MAAM,OAAC,WACP,mBAAmB,OAAC,EA2C9B;IAqBD;;;;;;;;;;;;;;OAcG;IACH,sBAVW,MAAM,GACJ,mBAAmB,CAY/B;IAED;;;;;;;;;;;;;;OAcG;IACH,kBAVW,MAAM,GACJ,UAAU,CAYtB;;CAUF;kCA1IiC,4BAA4B"}