@gesslar/toolkit 3.22.0 → 3.22.2

package/package.json

@@ -5,7 +5,7 @@
     "name": "gesslar",
     "url": "https://gesslar.dev"
   },
-  "version": "3.22.0",
+  "version": "3.22.2",
   "license": "Unlicense",
   "homepage": "https://github.com/gesslar/toolkit#readme",
   "repository": {

package/src/node/lib/DirectoryObject.js

@@ -93,16 +93,17 @@ export default class DirectoryObject extends FS {
    * Constructs a DirectoryObject instance.
    *
    * @param {string?} [supplied="."] - The directory path (defaults to current directory)
+   * @param {DirectoryObject?} [parent] - Optional parent directory (ignored by DirectoryObject, used by subclasses)
    */
   constructor(supplied) {
+    super()
+
     const fixedDir = supplied || "."
 
     Valid.type(fixedDir, "String")
 
-    super()
-
     const normalizedDir = FS.fixSlashes(fixedDir)
-    const resolved = path.resolve(normalizedDir)
+    const resolved = FS.resolvePath(DirectoryObject.cwd, normalizedDir)
     const {dir, name, root} = FS.pathParts(resolved)
     const url = new URL(FS.pathToUrl(resolved))
     const trail = resolved.split(path.sep)
@@ -131,7 +132,7 @@ export default class DirectoryObject extends FS {
    * console.log(projectRoot.path) // process.cwd()
    */
   static fromCwd() {
-    return new this(process.cwd())
+    return new this(FS.cwd)
   }
 
   /**
@@ -560,6 +561,26 @@ export default class DirectoryObject extends FS {
     return normalized
   }
 
+  /**
+   * Gets the parent directory object for a given virtual path.
+   * Returns the cap if the path is at the cap root.
+   *
+   * @private
+   * @param {string} virtualPath - The virtual path
+   * @returns {VDirectoryObject} The parent directory object
+   */
+  #getParentDirectoryForPath(virtualPath) {
+    const {dir} = FS.pathParts(virtualPath)
+
+    // If at cap root, return cap
+    if(dir === this.cap.path || dir === this.sep) {
+      return this.cap
+    }
+
+    // Create parent directory object (recursive - it will get its own parent)
+    return new this.constructor(dir, this.cap)
+  }
+
   /**
    * Validates that a resolved virtual path stays within the cap boundary.
    *
@@ -578,7 +599,12 @@ export default class DirectoryObject extends FS {
       relativeFromCap
     )
 
-    if(!FS.pathContains(this.cap.real.path, resolvedRealPath)) {
+    // Check if resolved path is within cap (handles case where path equals cap root)
+    const capRealPath = this.cap.real.path
+    const isWithinCap = resolvedRealPath === capRealPath
+      || FS.pathContains(capRealPath, resolvedRealPath)
+
+    if(!isWithinCap) {
       throw Sass.new(`${normalized} would be out of bounds (cap: ${this.cap.path}).`)
     }
 
@@ -609,34 +635,28 @@ export default class DirectoryObject extends FS {
   getDirectory(dir) {
     Valid.type(dir, "String", {allowEmpty: false})
 
-    // Handle VDirectoryObject with absolute virtual paths (starting with "/")
-    if(this.isVirtual && dir.startsWith(this.sep)) {
-      const normalized = this.#resolveAndValidateFromCap(dir)
+    // Validate boundaries before passing raw input to constructor
+    if(this.isVirtual) {
+      // VDO: validate cap boundary, then pass raw input to constructor
+      if(dir.startsWith(this.sep)) {
+      // Absolute path: validate from cap root
+        this.#resolveAndValidateFromCap(dir)
+      } else {
+      // Relative path: resolve and validate stays within cap
+        const newPath = FS.resolvePath(this.path, dir)
+        this.#validateCapBoundary(newPath)
+      }
 
-      return new this.constructor(normalized, this)
+      // Pass raw input; constructor handles resolution and parent determination
+      return new this.constructor(dir, this)
     }
 
-    // Regular resolution
+    // Regular DO: validate local-only constraint
     const newPath = FS.resolvePath(this.path, dir)
+    Valid.assert(this.#isLocal(newPath), `${newPath} would be out of bounds.`)
 
-    // Validate bounds
-    if(!this.isVirtual) {
-      // Regular DO: enforce local-only constraint
-      Valid.assert(this.#isLocal(newPath), `${newPath} would be out of bounds.`)
-
-      return new this.constructor(newPath, this)
-    }
-
-    // VDO relative paths: only allow nested if explicitly prefixed with ./
-    // This maintains security while allowing explicit relative navigation
-    if(dir.includes(this.sep) && !dir.startsWith(`.${this.sep}`)) {
-      throw Sass.new(`${dir} would be out of bounds. Use "./${dir}" for nested paths or chain getDirectory() calls.`)
-    }
-
-    // VDO relative paths: validate cap boundary and pass resolved path
-    const normalized = this.#validateCapBoundary(newPath)
-
-    return new this.constructor(normalized, this)
+    // Pass raw input; constructor will resolve it to cwd
+    return new this.constructor(newPath)
   }
 
   /**
@@ -671,33 +691,24 @@ export default class DirectoryObject extends FS {
   getFile(file) {
     Valid.type(file, "String", {allowEmpty: false})
 
-    // Handle VDirectoryObject with absolute virtual paths (starting with "/")
-    if(this.isVirtual && file.startsWith(this.sep)) {
-      const normalized = this.#resolveAndValidateFromCap(file)
-
-      return new VFileObject(normalized, this)
-    }
-
-    // Regular resolution
-    const resolvedPath = FS.resolvePath(this.path, file)
-
-    // Validate bounds
+    // Validate boundaries - check what the resolved path would be
     if(!this.isVirtual) {
-      // Regular DO: enforce local-only constraint
+      // Regular DO: validate local-only constraint
+      const resolvedPath = FS.resolvePath(this.path, file)
       Valid.assert(this.#isLocal(resolvedPath), `${resolvedPath} would be out of bounds.`)
-
-      return new FileObject(file, this)
-    }
-
-    // VDO relative paths: only allow nested if explicitly prefixed with ./
-    // This maintains security while allowing explicit relative navigation
-    if(file.includes(this.sep) && !file.startsWith(`.${this.sep}`)) {
-      throw Sass.new(`${file} would be out of bounds. Use "./${file}" for nested paths or chain getFile() calls.`)
+    } else {
+      // VDO: validate cap boundary
+      if(file.startsWith(this.sep)) {
+        this.#resolveAndValidateFromCap(file)
+      } else {
+        const resolvedPath = FS.resolvePath(this.path, file)
+        this.#validateCapBoundary(resolvedPath)
+      }
     }
 
-    // VDO relative paths: validate cap boundary and pass resolved path
-    const normalized = this.#validateCapBoundary(resolvedPath)
-
-    return new VFileObject(normalized, this)
+    // Pass raw input to constructor - it handles resolution and parent determination
+    return this.isVirtual
+      ? new VFileObject(file, this)
+      : new FileObject(file, this)
   }
 }

package/src/node/lib/FileSystem.js

@@ -206,8 +206,8 @@ export default class FileSystem {
     if(path.isAbsolute(to))
       return path.resolve(to)
 
-    // Strategy 2: If 'to' contains relative navigation
-    if(to.startsWith(this.fixSlashes("../")))
+    // Strategy 2: If 'to' contains relative navigation (../ or ..)
+    if(to.startsWith(this.fixSlashes("../")) || to === "..")
       return path.resolve(from, to)
 
     // Strategy 3: Try overlap-based merging, which will default to a basic
@@ -375,4 +375,13 @@ export default class FileSystem {
 
     return this.resolvePath(cap, target)
   }
+
+  /**
+   * Returns the current working directory as a string.
+   *
+   * @returns {string} The current working directory
+   */
+  static get cwd() {
+    return process.cwd()
+  }
 }

package/src/node/lib/VFileObject.js

@@ -35,7 +35,7 @@ export default class VFileObject extends FileObject {
   /**
    * Constructs a VFileObject instance.
    *
-   * @param {string} virtualPath - The virtual file path (already resolved, can be nested like "/path/to/file.ext")
+   * @param {string} virtualPath - The virtual file path (can be absolute like "/path/to/file.ext" or relative like "file.txt")
    * @param {VDirectoryObject} parent - The parent virtual directory (required, used for cap reference)
    */
   constructor(virtualPath, parent) {
@@ -44,9 +44,23 @@ export default class VFileObject extends FileObject {
 
     // Normalize the virtual path
     const normalizedVirtual = FS.fixSlashes(virtualPath)
+    const isAbsolute = normalizedVirtual.startsWith("/")
 
-    // Extract the directory and filename from the virtual path
-    const {dir: virtualDir, base} = FS.pathParts(normalizedVirtual)
+    // If absolute path, it's already resolved from cap root (from getFile())
+    // If relative path, resolve from parent directory (from hasFile(), read(), etc.)
+    let resolvedVirtualPath
+    if(isAbsolute) {
+      // Absolute path is already resolved - use as-is
+      resolvedVirtualPath = normalizedVirtual
+    } else {
+      // Relative path: resolve from parent directory (not cap root!)
+      resolvedVirtualPath = FS.resolvePath(parent.path, normalizedVirtual)
+    }
+
+    const normalized = FS.fixSlashes(resolvedVirtualPath)
+
+    // Extract the directory and filename from the resolved virtual path
+    const {dir: virtualDir, base} = FS.pathParts(normalized)
 
     // Determine the virtual parent directory
     // If virtualDir is "/" or empty or equals cap path, use the cap root
@@ -67,13 +81,13 @@ export default class VFileObject extends FileObject {
     super(base, virtualParent)
 
     // Convert virtual path to real path
-    // The virtual path is relative to the cap root, so we resolve it relative to cap's real path
+    // The resolved virtual path is relative to the cap root, so we resolve it relative to cap's real path
     const capRealPath = parent.cap.real.path
 
-    // Strip leading "/" from virtual path if present to make it relative
-    const relativeFromCap = normalizedVirtual.startsWith("/")
-      ? normalizedVirtual.slice(1)
-      : normalizedVirtual
+    // Strip leading "/" from resolved virtual path if present to make it relative
+    const relativeFromCap = normalized.startsWith("/")
+      ? normalized.slice(1)
+      : normalized
 
     // Resolve the real filesystem path
     const realPath = FS.resolvePath(capRealPath, relativeFromCap)

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

@@ -60,6 +60,7 @@ export default class DirectoryObject extends FS {
      * Constructs a DirectoryObject instance.
      *
      * @param {string?} [supplied="."] - The directory path (defaults to current directory)
+     * @param {DirectoryObject?} [parent] - Optional parent directory (ignored by DirectoryObject, used by subclasses)
      */
     constructor(supplied?: string | null);
     /**

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH;IA2DE;;;;;;;;;OASG;IACH,kBALa,eAAe,CAO3B;IA3CD;;;;OAIG;IACH,uBAFW,MAAM,OAAC,EA0BjB;IA2BD;;;;OAIG;IACH,cAFa,OAAO,CAAC,OAAO,CAAC,CAI5B;IAED;;;;OAIG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,GAAG,CAIf;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,cAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,MAAM,CAIlB;IAED;;;;;;;OAOG;IACH,aALa,KAAK,CAAC,MAAM,CAAC,CAOzB;IAED;;;;;;;;;;;;OAYG;IACH,cARa,eAAe,GAAC,IAAI,CAsBhC;IAED;;;;OAIG;IACH,mBAFa,OAAO,CAInB;IAmBD;;;;;;;;;;;;;;;;;;OAkBG;IACH,WAZW,MAAM,GACJ,OAAO,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC,UAAU,GAAC,WAAW,CAAC,CAAC;QAAC,WAAW,EAAE,KAAK,CAAC,eAAe,GAAC,gBAAgB,CAAC,CAAA;KAAC,CAAC,CA0CjH;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,WAZW,MAAM,GACJ,OAAO,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC,UAAU,GAAC,WAAW,CAAC,CAAC;QAAC,WAAW,EAAE,KAAK,CAAC,eAAe,GAAC,gBAAgB,CAAC,CAAA;KAAC,CAAC,CAgDjH;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,CAQ5B;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAO5B;IAgED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,kBAdW,MAAM,GACJ,eAAe,CA4C3B;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,cAfW,MAAM,GACJ,UAAU,GAAC,WAAW,CA6ClC;;CACF;eAlrBc,iBAAiB;uBADT,iBAAiB;wBAIhB,kBAAkB"}
+{"version":3,"file":"DirectoryObject.d.ts","sourceRoot":"","sources":["../../../src/node/lib/DirectoryObject.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH;IA4DE;;;;;;;;;OASG;IACH,kBALa,eAAe,CAO3B;IA5CD;;;;;OAKG;IACH,uBAHW,MAAM,OAAC,EA2BjB;IA2BD;;;;OAIG;IACH,cAFa,OAAO,CAAC,OAAO,CAAC,CAI5B;IAED;;;;OAIG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,GAAG,CAIf;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,cAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,MAAM,CAIlB;IAED;;;;;;;OAOG;IACH,aALa,KAAK,CAAC,MAAM,CAAC,CAOzB;IAED;;;;;;;;;;;;OAYG;IACH,cARa,eAAe,GAAC,IAAI,CAsBhC;IAED;;;;OAIG;IACH,mBAFa,OAAO,CAInB;IAmBD;;;;;;;;;;;;;;;;;;OAkBG;IACH,WAZW,MAAM,GACJ,OAAO,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC,UAAU,GAAC,WAAW,CAAC,CAAC;QAAC,WAAW,EAAE,KAAK,CAAC,eAAe,GAAC,gBAAgB,CAAC,CAAA;KAAC,CAAC,CA0CjH;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,WAZW,MAAM,GACJ,OAAO,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC,UAAU,GAAC,WAAW,CAAC,CAAC;QAAC,WAAW,EAAE,KAAK,CAAC,eAAe,GAAC,gBAAgB,CAAC,CAAA;KAAC,CAAC,CAgDjH;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,CAQ5B;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAO5B;IAyFD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,kBAdW,MAAM,GACJ,eAAe,CAsC3B;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,cAfW,MAAM,GACJ,UAAU,GAAC,WAAW,CAoClC;;CACF;eA7rBc,iBAAiB;uBADT,iBAAiB;wBAIhB,kBAAkB"}

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

@@ -168,6 +168,12 @@ export default class FileSystem {
      * FS.virtualToRealPath(regular) // "/home/user/file.txt"
      */
     static virtualToRealPath(fileOrDirectoryObject: FileObject | DirectoryObject): string;
+    /**
+     * Returns the current working directory as a string.
+     *
+     * @returns {string} The current working directory
+     */
+    static get cwd(): string;
     /**
      * Compute the relative path from another file or directory to this instance.
      *

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

@@ -1 +1 @@
-{"version":3,"file":"FileSystem.d.ts","sourceRoot":"","sources":["../../../src/node/lib/FileSystem.js"],"names":[],"mappings":"AA0BA;;GAEG;AACH;IACE,kCAAwB;IACxB,uCAAkC;IAClC,mBAAsB;IAsBtB;;;;;;OAMG;IACH,4BAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,2BAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;;;;OAMG;IACH,2BAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;;;;;;;;OAUG;IACH,gCAJW,UAAU,GAAC,eAAe,MAC1B,UAAU,GAAC,eAAe,GACxB,MAAM,CAYlB;IAED;;;;;;;;;;OAUG;IACH,oCAJW,MAAM,MACN,MAAM,GACJ,MAAM,CAQlB;IAED;;;;;;;;;OASG;IACH,oCALW,MAAM,SACN,MAAM,QACN,MAAM,GACJ,MAAM,CA0BlB;IAED;;;;;;;;OAQG;IACH,6BAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAmClB;IAED;;;;;;;;;;;;OAYG;IACH,+BATW,MAAM,aACN,MAAM,GACJ,OAAO,CAcnB;IAED;;;;;;;;;;;;;;OAcG;IACH,4BATW,MAAM,MACN,MAAM,QACN,MAAM,GACJ,MAAM,GAAC,IAAI,CAwBvB;IAED;;;;;;;;;;;;;;;OAeG;IACH,+BAXW,MAAM,MACN,MAAM,QACN,MAAM,GACJ,MAAM,GAAC,IAAI,CA+BvB;IAED;;;;;OAKG;IAEH;;;;;;;OAOG;IACH,2BAJW,MAAM;;;;cATH,MAAM;;;;aACN,MAAM;;;;aACN,MAAM;MAenB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,gDAZW,UAAU,GAAC,eAAe,GACxB,MAAM,CAiClB;IAtVD;;;;;;;;;OASG;IACH,kCAJW,UAAU,GAAC,eAAe,GACxB,MAAM,CAWlB;CAqUF;yBAxWa,OAAO,iBAAiB,EAAE,OAAO;8BACjC,OAAO,sBAAsB,EAAE,OAAO"}
+{"version":3,"file":"FileSystem.d.ts","sourceRoot":"","sources":["../../../src/node/lib/FileSystem.js"],"names":[],"mappings":"AA0BA;;GAEG;AACH;IACE,kCAAwB;IACxB,uCAAkC;IAClC,mBAAsB;IAsBtB;;;;;;OAMG;IACH,4BAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,2BAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;;;;OAMG;IACH,2BAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;;;;;;;;OAUG;IACH,gCAJW,UAAU,GAAC,eAAe,MAC1B,UAAU,GAAC,eAAe,GACxB,MAAM,CAYlB;IAED;;;;;;;;;;OAUG;IACH,oCAJW,MAAM,MACN,MAAM,GACJ,MAAM,CAQlB;IAED;;;;;;;;;OASG;IACH,oCALW,MAAM,SACN,MAAM,QACN,MAAM,GACJ,MAAM,CA0BlB;IAED;;;;;;;;OAQG;IACH,6BAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAmClB;IAED;;;;;;;;;;;;OAYG;IACH,+BATW,MAAM,aACN,MAAM,GACJ,OAAO,CAcnB;IAED;;;;;;;;;;;;;;OAcG;IACH,4BATW,MAAM,MACN,MAAM,QACN,MAAM,GACJ,MAAM,GAAC,IAAI,CAwBvB;IAED;;;;;;;;;;;;;;;OAeG;IACH,+BAXW,MAAM,MACN,MAAM,QACN,MAAM,GACJ,MAAM,GAAC,IAAI,CA+BvB;IAED;;;;;OAKG;IAEH;;;;;;;OAOG;IACH,2BAJW,MAAM;;;;cATH,MAAM;;;;aACN,MAAM;;;;aACN,MAAM;MAenB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,gDAZW,UAAU,GAAC,eAAe,GACxB,MAAM,CAiClB;IAED;;;;OAIG;IACH,kBAFa,MAAM,CAIlB;IA/VD;;;;;;;;;OASG;IACH,kCAJW,UAAU,GAAC,eAAe,GACxB,MAAM,CAWlB;CA8UF;yBAjXa,OAAO,iBAAiB,EAAE,OAAO;8BACjC,OAAO,sBAAsB,EAAE,OAAO"}

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

@@ -21,7 +21,7 @@ export default class VFileObject extends FileObject {
     /**
      * Constructs a VFileObject instance.
      *
-     * @param {string} virtualPath - The virtual file path (already resolved, can be nested like "/path/to/file.ext")
+     * @param {string} virtualPath - The virtual file path (can be absolute like "/path/to/file.ext" or relative like "file.txt")
      * @param {VDirectoryObject} parent - The parent virtual directory (required, used for cap reference)
      */
     constructor(virtualPath: string, parent: VDirectoryObject);

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

@@ -1 +1 @@
-{"version":3,"file":"VFileObject.d.ts","sourceRoot":"","sources":["../../../src/node/lib/VFileObject.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;GAkBG;AAEH;IAGE;;;;;OAKG;IACH,yBAHW,MAAM,UACN,gBAAgB,EAgD1B;IAED,yBAEC;IAED,uBAEC;;CACF;uBAxFsB,iBAAiB"}
+{"version":3,"file":"VFileObject.d.ts","sourceRoot":"","sources":["../../../src/node/lib/VFileObject.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;GAkBG;AAEH;IAGE;;;;;OAKG;IACH,yBAHW,MAAM,UACN,gBAAgB,EA8D1B;IAED,yBAEC;IAED,uBAEC;;CACF;uBAtGsB,iBAAiB"}