@gesslar/toolkit 3.13.0 → 3.14.0

package/src/{lib/CappedDirectoryObject.js → node/lib/VDirectoryObject.js}

@@ -1,5 +1,5 @@
 /**
- * @file CappedDirectoryObject.js
+ * @file VDirectoryObject.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.
@@ -11,12 +11,11 @@
 import path from "node:path"
 
 import DirectoryObject from "./DirectoryObject.js"
-import FileObject from "./FileObject.js"
-import FS from "./FS.js"
+import FileSystem from "./FileSystem.js"
 import Valid from "./Valid.js"
 
 /**
- * CappedDirectoryObject extends DirectoryObject with constraints that ensure
+ * VDirectoryObject 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
@@ -24,45 +23,44 @@ import Valid from "./Valid.js"
  *
  * @augments DirectoryObject
  */
-export default class CappedDirectoryObject extends DirectoryObject {
+export default class VDirectoryObject extends DirectoryObject {
   #real
   #cap
   #cappedParentPath
   #cappedParent
 
   /**
-   * Constructs a CappedDirectoryObject instance.
+   * Constructs a VDirectoryObject instance.
    *
-   * Without a parent, the path becomes both the directory location and the cap
-   * (virtual root). With a parent, the path is resolved relative to the parent's
-   * cap using virtual path semantics (absolute paths treated as cap-relative).
+   * Without a parent, creates a new cap at the specified real directory location
+   * with virtual path "/". With a parent, the path is resolved relative to the
+   * parent's virtual path (absolute paths treated as cap-relative).
    *
-   * @param {string} [directory="."] - Directory path (becomes cap if no parent, else relative to parent's cap, defaults to current directory)
-   * @param {CappedDirectoryObject?} [parent] - Optional parent capped directory
-   * @throws {Sass} If parent is provided but not a CappedDirectoryObject
-   * @throws {Sass} If the resulting path would escape the cap
+   * @param {string} [directory="."] - Real directory path when no parent (becomes cap), or relative/absolute virtual path when parent provided
+   * @param {VDirectoryObject?} [parent] - Optional parent capped directory
+   * @throws {Sass} If parent is provided but not a VDirectoryObject
    * @example
    * // Create new capped directory at current directory
-   * const cwd = new CappedDirectoryObject()
-   * // path: process.cwd(), cap: process.cwd()
+   * const cwd = new VDirectoryObject()
+   * // Virtual path: "/", Real path: process.cwd(), Cap: itself
    *
    * @example
    * // Create new capped directory
-   * const cache = new CappedDirectoryObject("/home/user/.cache")
-   * // path: /home/user/.cache, cap: /home/user/.cache
+   * const cache = new VDirectoryObject("/home/user/.cache")
+   * // Virtual path: "/", Real path: /home/user/.cache, Cap: itself
    *
    * @example
    * // Create subdirectory with parent
-   * const data = new CappedDirectoryObject("data", cache)
-   * // path: /home/user/.cache/data, cap: /home/user/.cache
+   * const data = new VDirectoryObject("data", cache)
+   * // Virtual path: /data, Real path: /home/user/.cache/data, Cap: cache
    *
    * @example
-   * // Virtual absolute path with parent
-   * const config = new CappedDirectoryObject("/etc/config", cache)
-   * // path: /home/user/.cache/etc/config, cap: /home/user/.cache
+   * // Virtual absolute path with parent (treated as cap-relative)
+   * const config = new VDirectoryObject("/etc/config", cache)
+   * // Virtual path: /etc/config, Real path: /home/user/.cache/etc/config, Cap: cache
    */
   constructor(directory, source=null) {
-    Valid.type(source, "Null|CappedDirectoryObject")
+    Valid.type(source, "Null|VDirectoryObject")
 
     directory ||= "."
 
@@ -73,9 +71,9 @@ export default class CappedDirectoryObject extends DirectoryObject {
       directory = directory.slice(1)
 
     // Find out what directory means to the basePath
-    const realResolved = FS.resolvePath(baseRealPath, directory)
+    const realResolved = FileSystem.resolvePath(baseRealPath, directory)
     const localResolved = source
-      ? FS.resolvePath(baseLocalPath, directory)
+      ? FileSystem.resolvePath(baseLocalPath, directory)
       : path.parse(path.resolve("")).root
 
     super(localResolved)
@@ -93,14 +91,14 @@ export default class CappedDirectoryObject extends DirectoryObject {
   }
 
   /**
-   * Creates a CappedDirectoryObject from the current working directory.
+   * Creates a VDirectoryObject from the current working directory.
    * This is useful when working with pnpx or other tools where you need to
    * cap at the project's root directory determined at runtime.
    *
-   * @returns {CappedDirectoryObject} A CappedDirectoryObject capped at the current working directory
+   * @returns {VDirectoryObject} A VDirectoryObject capped at the current working directory
    * @example
    * // When using pnpx or similar tools
-   * const projectRoot = CappedDirectoryObject.fromCwd()
+   * const projectRoot = VDirectoryObject.fromCwd()
    * const srcDir = projectRoot.getDirectory("src")
    * // srcDir is capped at the project root
    */
@@ -110,26 +108,26 @@ export default class CappedDirectoryObject extends DirectoryObject {
 
   /**
    * Indicates whether this directory is capped (constrained to a specific tree).
-   * Always returns true for CappedDirectoryObject instances.
+   * Always returns true for VDirectoryObject instances.
    *
-   * @returns {boolean} True for all CappedDirectoryObject instances
+   * @returns {boolean} True for all VDirectoryObject instances
    * @example
    * const capped = new TempDirectoryObject("myapp")
-   * console.log(capped.isCapped) // true
+   * console.log(capped.isVirtual) // true
    *
    * const regular = new DirectoryObject("/tmp")
-   * console.log(regular.isCapped) // false
+   * console.log(regular.isVirtual) // false
    */
-  get isCapped() {
+  get isVirtual() {
     return true
   }
 
   /**
    * Returns the cap (root) of the capped directory tree.
-   * For root CappedDirectoryObject instances, returns itself.
+   * For root VDirectoryObject instances, returns itself.
    * For children, returns the inherited cap from the parent chain.
    *
-   * @returns {CappedDirectoryObject} The cap directory object (root of the capped tree)
+   * @returns {VDirectoryObject} The cap directory object (root of the capped tree)
    * @example
    * const temp = new TempDirectoryObject("myapp")
    * console.log(temp.cap === temp) // true (root is its own cap)
@@ -167,14 +165,14 @@ export default class CappedDirectoryObject extends DirectoryObject {
    * Returns the parent directory of this capped directory.
    * Returns null only if this directory is at the cap (the "root" of the capped tree).
    *
-   * Note: The returned parent is a CappedDirectoryObject with the same cap.
+   * Note: The returned parent is a VDirectoryObject with the same cap.
    * This maintains the capping behavior throughout the directory hierarchy.
    *
-   * @returns {CappedDirectoryObject|null} Parent directory or null if at cap root
+   * @returns {VDirectoryObject|null} Parent directory or null if at cap root
    * @example
    * const capped = new TempDirectoryObject("myapp")
    * const subdir = capped.getDirectory("data")
-   * console.log(subdir.parent.path) // Returns parent CappedDirectoryObject
+   * console.log(subdir.parent.path) // Returns parent VDirectoryObject
    * console.log(capped.parent) // null (at cap root)
    */
   get parent() {
@@ -191,63 +189,10 @@ export default class CappedDirectoryObject extends DirectoryObject {
    * console.log(temp.parentPath) // null (at cap root)
    *
    * const subdir = temp.getDirectory("data")
-   * console.log(subdir.parentPath) // "/data" or similar (parent's virtual path)
+   * console.log(subdir.parentPath) // "/" (parent's virtual path)
    */
   get parentPath() {
     return this.#cappedParentPath
   }
 
-  /**
-   * Override exists to use real filesystem path.
-   *
-   * @returns {Promise<boolean>} Whether the directory exists
-   */
-  get exists() {
-    return this.real.exists
-  }
-
-  /**
-   * Override read to use real filesystem path and return capped objects.
-   *
-   * @param {string} [pat=""] - Optional glob pattern
-   * @returns {Promise<{files: Array<FileObject>, directories: Array}>} Directory contents
-   */
-  async read(...arg) {
-    const {files, directories} = await this.real.read(...arg)
-
-    // we need to re-cast
-    const recastDirs = directories.map(e => this.getDirectory(e.name))
-    const recastFiles = files.map(f => new FileObject(f.name, this))
-
-    return {files: recastFiles, directories: recastDirs}
-  }
-
-  /**
-   * Override hasDirectory to use real filesystem path.
-   *
-   * @param {string} dirname - Directory name to check
-   * @returns {Promise<boolean>} True if directory exists
-   */
-  async hasDirectory(dirname) {
-    return await this.real.hasDirectory(dirname)
-  }
-
-  /**
-   * Override assureExists to use real filesystem path.
-   *
-   * @param {object} [options] - Options for mkdir
-   * @returns {Promise<void>}
-   */
-  async assureExists(options = {}) {
-    return await this.real.assureExists(options)
-  }
-
-  /**
-   * Override delete to use real filesystem path.
-   *
-   * @returns {Promise<void>}
-   */
-  async delete() {
-    return await this.real.delete()
-  }
 }

package/src/node/lib/VFileObject.js

@@ -0,0 +1,61 @@
+/**
+ * @file VFileObject.js
+ * @description Class representing a virtual file within a capped directory tree.
+ * Extends FileObject with virtual path support and real filesystem mapping.
+ */
+
+import FileObject from "./FileObject.js"
+import FS from "./FileSystem.js"
+import Valid from "./Valid.js"
+
+/**
+ * VFileObject extends FileObject with virtual path support, maintaining both
+ * a virtual path (relative to cap) and a real filesystem path.
+ *
+ * Virtual files must have a VDirectoryObject parent and cannot exist independently.
+ * All file operations use the real filesystem path while exposing clean virtual paths.
+ *
+ * @property {string} supplied - User-supplied path
+ * @property {string} path - The virtual file path (relative to cap)
+ * @property {URL} url - The file URL
+ * @property {string} name - The file name
+ * @property {string} module - The file name without extension
+ * @property {string} extension - The file extension
+ * @property {boolean} isFile - Always true for files
+ * @property {boolean} isVirtual - Always true for VFileObject instances
+ * @property {VDirectoryObject} parent - The parent virtual directory object
+ * @property {FileObject} real - The real filesystem FileObject
+ * @property {Promise<boolean>} exists - Whether the file exists (async)
+ */
+
+export default class VFileObject extends FileObject {
+  #real
+
+  /**
+   * Constructs a VFileObject instance.
+   *
+   * @param {string} fileName - The file path
+   * @param {VDirectoryObject} parent - The parent virtual directory (required)
+   */
+  constructor(fileName, parent) {
+    Valid.type(fileName, "String", {allowEmpty: false})
+    Valid.type(parent, "VDirectoryObject")
+
+    super(fileName, parent)
+
+    const parentRealPath = this.parent.real.path
+    const relative = FS.absoluteToRelative(this.path, true)
+    const resolved = FS.resolvePath(parentRealPath, relative)
+    const {base, dir} = FS.pathParts(resolved)
+
+    this.#real = new FileObject(base, dir)
+  }
+
+  get isVirtual() {
+    return true
+  }
+
+  get real() {
+    return this.#real
+  }
+}

package/src/{lib → node/lib}/Valid.js

@@ -6,8 +6,8 @@
  */
 
 import Sass from "./Sass.js"
-import Data from "../browser/lib/Data.js"
-import Collection from "../browser/lib/Collection.js"
+import Data from "../../browser/lib/Data.js"
+import Collection from "../../browser/lib/Collection.js"
 
 /**
  * Validation utility class providing type checking and assertion methods.
@@ -23,10 +23,14 @@ export default class Valid {
    * @param {object} [options] - Additional options for validation.
    */
   static type(value, type, options) {
+    const expected = [type]
+
+    if(options?.allowEmpty !== true)
+      expected.push("[no empty values]")
+
     Valid.assert(
       Data.isType(value, type, options),
-      `Invalid type. Expected ${type}, got ${Data.typeOf(value)}`,
-      1,
+      `Invalid type. Expected ${expected.join(" ")}, got ${Data.typeOf(value)}`
     )
   }
 
@@ -57,7 +61,9 @@ export default class Valid {
   }
 
   /**
-   * Protects against prototype pollution by checking keys for dangerous property names.
+   * Protects against prototype pollution by checking keys for dangerous
+   * property names.
+   *
    * Throws if any restricted prototype properties are found in the keys array.
    *
    * @param {Array<string>} keys - Array of property keys to validate

package/src/types/browser/index.d.ts

@@ -1,13 +0,0 @@
-export { default as Collection } from "./lib/Collection.js";
-export { default as Data } from "./lib/Data.js";
-export { default as Notify } from "./lib/Notify.js";
-export { default as Promised } from "./lib/Promised.js";
-export { default as Sass } from "./lib/Sass.js";
-export { default as Tantrum } from "./lib/Tantrum.js";
-export { default as Time } from "./lib/Time.js";
-export { default as Type } from "./lib/TypeSpec.js";
-export { default as Util } from "./lib/Util.js";
-export { default as Valid } from "./lib/Valid.js";
-export { default as Disposer, Disposer as DisposerClass } from "./lib/Disposer.js";
-export { default as HTML, HTML as HTMLClass } from "./lib/HTML.js";
-//# sourceMappingURL=index.d.ts.map

package/src/types/browser/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../browser/index.js"],"names":[],"mappings":""}

package/src/types/browser/lib/Collection.d.ts

@@ -1,248 +0,0 @@
-/**
- * Utility class for collection operations.
- * Provides static methods for working with arrays, objects, sets, and maps.
- */
-export default class Collection {
-    /**
-     * Evaluates an array with a predicate function, optionally in reverse order.
-     * Returns the first truthy result from the predicate.
-     *
-     * @param {Array<unknown>} collection - The array to evaluate
-     * @param {(value: unknown, index: number, array: Array<unknown>) => unknown} predicate - Function to evaluate each element
-     * @param {boolean} [forward] - Whether to iterate forward (true) or backward (false). Defaults to true
-     * @returns {unknown|undefined} The first truthy result from the predicate, or undefined
-     * @throws {Sass} If collection is not an array or predicate is not a function
-     */
-    static evalArray(collection: Array<unknown>, predicate: (value: unknown, index: number, array: Array<unknown>) => unknown, forward?: boolean): unknown | undefined;
-    /**
-     * Evaluates an object with a predicate function.
-     * Returns the first truthy result from the predicate.
-     *
-     * @param {object} collection - The object to evaluate
-     * @param {(value: unknown, key: string, object: object) => unknown} predicate - Function to evaluate each property
-     * @returns {unknown|undefined} The first truthy result from the predicate, or undefined
-     * @throws {Sass} If collection is not an object or predicate is not a function
-     */
-    static evalObject(collection: object, predicate: (value: unknown, key: string, object: object) => unknown): unknown | undefined;
-    /**
-     * Evaluates a Set with a predicate function.
-     * Returns the first truthy result from the predicate.
-     *
-     * @param {Set<unknown>} collection - The Set to evaluate
-     * @param {(value: unknown, set: Set<unknown>) => unknown} predicate - Function to evaluate each element
-     * @returns {unknown|undefined} The first truthy result from the predicate, or undefined
-     * @throws {Sass} If collection is not a Set or predicate is not a function
-     */
-    static evalSet(collection: Set<unknown>, predicate: (value: unknown, set: Set<unknown>) => unknown): unknown | undefined;
-    /**
-     * Evaluates a Map with a predicate function, optionally in reverse order.
-     * Returns the first truthy result from the predicate.
-     *
-     * @param {Map<unknown, unknown>} collection - The Map to evaluate
-     * @param {(value: unknown, key: unknown, map: Map<unknown, unknown>) => unknown} predicate - Function to evaluate each entry
-     * @param {boolean} [forward] - Whether to iterate forward (true) or backward (false). Defaults to true
-     * @returns {unknown|undefined} The first truthy result from the predicate, or undefined
-     * @throws {Sass} If collection is not a Map or predicate is not a function
-     */
-    static evalMap(collection: Map<unknown, unknown>, predicate: (value: unknown, key: unknown, map: Map<unknown, unknown>) => unknown, forward?: boolean): unknown | undefined;
-    /**
-     * Zips two arrays together into an array of pairs.
-     * The resulting array length equals the shorter input array.
-     *
-     * @param {Array<unknown>} array1 - The first array
-     * @param {Array<unknown>} array2 - The second array
-     * @returns {Array<[unknown, unknown]>} Array of paired elements
-     */
-    static zip(array1: Array<unknown>, array2: Array<unknown>): Array<[unknown, unknown]>;
-    /**
-     * Unzips an array of pairs into separate arrays.
-     * Transposes a 2D array structure.
-     *
-     * @param {Array<Array<unknown>>} array - Array of arrays to unzip
-     * @returns {Array<Array<unknown>>} Array of unzipped arrays, or empty array for invalid input
-     */
-    static unzip(array: Array<Array<unknown>>): Array<Array<unknown>>;
-    /**
-     * Maps an array using an async function, processing items sequentially.
-     * Unlike Promise.all(array.map()), this processes one item at a time.
-     *
-     * @param {Array<unknown>} array - The array to map
-     * @param {(item: unknown) => Promise<unknown>} asyncFn - Async function to apply to each element
-     * @returns {Promise<Array<unknown>>} Promise resolving to the mapped array
-     * @throws {Sass} If array is not an Array or asyncFn is not a function
-     */
-    static asyncMap(array: Array<unknown>, asyncFn: (item: unknown) => Promise<unknown>): Promise<Array<unknown>>;
-    /**
-     * Checks if all elements in an array are of a specified type
-     *
-     * @param {Array<unknown>} arr - The array to check
-     * @param {string} [type] - The type to check for (optional, defaults to the type of the first element)
-     * @param {unknown} options - Options for checking types
-     * @param {boolean} [options.strict] - Whether to use strict type or looser TypeSpec checking
-     * @returns {boolean} Whether all elements are of the specified type
-     */
-    static isArrayUniform(arr: Array<unknown>, type?: string, options?: unknown): boolean;
-    /**
-     * Checks if an array is unique
-     *
-     * @param {Array<unknown>} arr - The array of which to remove duplicates
-     * @returns {Array<unknown>} The unique elements of the array
-     */
-    static isArrayUnique(arr: Array<unknown>): Array<unknown>;
-    /**
-     * Returns the intersection of two arrays.
-     *
-     * @param {Array<unknown>} arr1 - The first array.
-     * @param {Array<unknown>} arr2 - The second array.
-     * @returns {Array<unknown>} The intersection of the two arrays.
-     */
-    static intersection(arr1: Array<unknown>, arr2: Array<unknown>): Array<unknown>;
-    /**
-     * Checks whether two arrays have any elements in common.
-     *
-     * This function returns `true` if at least one element from `arr1` exists in
-     * `arr2`, and `false` otherwise. It optimizes by iterating over the shorter
-     * array for efficiency.
-     *
-     * Example:
-     *   Collection.intersects([1, 2, 3], [3, 4, 5]) // returns true
-     *   Collection.intersects(["a", "b"], ["c", "d"]) // returns false
-     *
-     * @param {Array<unknown>} arr1 - The first array to check for intersection.
-     * @param {Array<unknown>} arr2 - The second array to check for intersection.
-     * @returns {boolean} True if any element is shared between the arrays, false otherwise.
-     */
-    static intersects(arr1: Array<unknown>, arr2: Array<unknown>): boolean;
-    /**
-     * Pads an array to a specified length with a value. This operation
-     * occurs in-place.
-     *
-     * @param {Array<unknown>} arr - The array to pad.
-     * @param {number} length - The length to pad the array to.
-     * @param {unknown} value - The value to pad the array with.
-     * @param {number} [position] - The position to pad the array at. Defaults to 0
-     * @returns {Array<unknown>} The padded array.
-     */
-    static arrayPad(arr: Array<unknown>, length: number, value: unknown, position?: number): Array<unknown>;
-    /**
-     * Filters an array asynchronously using a predicate function.
-     * Applies the predicate to all items in parallel and returns filtered results.
-     *
-     * @param {Array<unknown>} arr - The array to filter
-     * @param {(value: unknown, index: number, array: Array<unknown>) => Promise<boolean>} predicate - Async predicate function that returns a promise resolving to boolean
-     * @returns {Promise<Array<unknown>>} Promise resolving to the filtered array
-     */
-    static asyncFilter(arr: Array<unknown>, predicate: (value: unknown, index: number, array: Array<unknown>) => Promise<boolean>): Promise<Array<unknown>>;
-    /**
-     * Clones an object
-     *
-     * @param {object} obj - The object to clone
-     * @param {boolean} freeze - Whether to freeze the cloned object
-     * @returns {object} The cloned object
-     */
-    static cloneObject(obj: object, freeze?: boolean): object;
-    /**
-     * Checks if an object is empty
-     *
-     * @param {object} obj - The object to check
-     * @returns {boolean} Whether the object is empty
-     */
-    static isObjectEmpty(obj: object): boolean;
-    /**
-     * Ensures that a nested path of objects exists within the given object.
-     * Creates empty objects along the path if they don't exist.
-     *
-     * @param {object} obj - The object to check/modify
-     * @param {Array<string>} keys - Array of keys representing the path to ensure
-     * @returns {object} Reference to the deepest nested object in the path
-     */
-    static assureObjectPath(obj: object, keys: Array<string>): object;
-    /**
-     * Sets a value in a nested object structure using an array of keys; creating
-     * the structure if it does not exist.
-     *
-     * @param {object} obj - The target object to set the value in
-     * @param {Array<string>} keys - Array of keys representing the path to the target property
-     * @param {unknown} value - The value to set at the target location
-     */
-    static setNestedValue(obj: object, keys: Array<string>, value: unknown): void;
-    /**
-     * Deeply merges two or more objects. Arrays are replaced, not merged.
-     *
-     * @param {...object} sources - Objects to merge (left to right)
-     * @returns {object} The merged object
-     */
-    static mergeObject(...sources: object[]): object;
-    /**
-     * Freezes an object and all of its properties recursively.
-     *
-     * @param {object} obj The object to freeze.
-     * @returns {object} The frozen object.
-     */
-    static deepFreezeObject(obj: object): object;
-    /**
-     * Maps an object using a transformer function
-     *
-     * @param {object} original The original object
-     * @param {function(unknown): unknown} transformer The transformer function
-     * @param {boolean} mutate Whether to mutate the original object
-     * @returns {Promise<object>} The mapped object
-     */
-    static mapObject(original: object, transformer: (arg0: unknown) => unknown, mutate?: boolean): Promise<object>;
-    /**
-     * Allocates an object from a source array and a spec array or function.
-     *
-     * @param {Array<unknown>} source The source array
-     * @param {Array<unknown>|function(Array<unknown>): Promise<Array<unknown>>|Array<unknown>} spec The spec array or function
-     * @returns {Promise<object>} The allocated object
-     */
-    static allocateObject(source: Array<unknown>, spec: Array<unknown> | ((arg0: Array<unknown>) => Promise<Array<unknown>> | Array<unknown>)): Promise<object>;
-    /**
-     * Trims falsy values from both ends of an array (in-place).
-     * Optionally preserves specific falsy values.
-     *
-     * @param {Array<unknown>} arr - The array to trim
-     * @param {Array<unknown>} [except] - Values to preserve even if falsy. Defaults to empty array
-     * @returns {Array<unknown>} The trimmed array (same reference, modified in-place)
-     * @throws {Sass} If arr is not an Array or except is not an Array
-     */
-    static trimArray(arr: Array<unknown>, except?: Array<unknown>): Array<unknown>;
-    /**
-     * Trims falsy values from the right end of an array (in-place).
-     * Optionally preserves specific falsy values.
-     *
-     * @param {Array<unknown>} arr - The array to trim
-     * @param {Array<unknown>} [except] - Values to preserve even if falsy. Defaults to empty array
-     * @returns {Array<unknown>} The trimmed array (same reference, modified in-place)
-     * @throws {Sass} If arr is not an Array or except is not an Array
-     */
-    static trimArrayRight(arr: Array<unknown>, except?: Array<unknown>): Array<unknown>;
-    /**
-     * Trims falsy values from the left end of an array (in-place).
-     * Optionally preserves specific falsy values.
-     *
-     * @param {Array<unknown>} arr - The array to trim
-     * @param {Array<unknown>} [except] - Values to preserve even if falsy. Defaults to empty array
-     * @returns {Array<unknown>} The trimmed array (same reference, modified in-place)
-     * @throws {Sass} If arr is not an Array or except is not an Array
-     */
-    static trimArrayLeft(arr: Array<unknown>, except?: Array<unknown>): Array<unknown>;
-    /**
-     * Transposes an array of objects into an object of arrays.
-     * Collects values for each key across all objects into arrays.
-     *
-     * @param {Array<object>} objects - Array of plain objects to transpose
-     * @returns {object} Object with keys from input objects, values as arrays
-     * @throws {Sass} If objects is not an Array or contains non-plain objects
-     */
-    static transposeObjects(objects: Array<object>): object;
-    /**
-     * Flattens an array (or nested array) of objects and transposes them.
-     * Combines flat() and transposeObjects() operations.
-     *
-     * @param {Array<object>|Array<Array<object>>} input - Array or nested array of objects
-     * @returns {object} Transposed object with arrays of values
-     */
-    static flattenObjectArray(input: Array<object> | Array<Array<object>>): object;
-}
-//# sourceMappingURL=Collection.d.ts.map

package/src/types/browser/lib/Collection.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Collection.d.ts","sourceRoot":"","sources":["../../../browser/lib/Collection.js"],"names":[],"mappings":"AAcA;;;GAGG;AACH;IACE;;;;;;;;;OASG;IACH,6BANW,KAAK,CAAC,OAAO,CAAC,aACd,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK,OAAO,YACjE,OAAO,GACL,OAAO,GAAC,SAAS,CAqB7B;IAED;;;;;;;;OAQG;IACH,8BALW,MAAM,aACN,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,OAAO,GACtD,OAAO,GAAC,SAAS,CAmB7B;IAED;;;;;;;;OAQG;IACH,2BALW,GAAG,CAAC,OAAO,CAAC,aACZ,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,CAAC,OAAO,CAAC,KAAK,OAAO,GAC5C,OAAO,GAAC,SAAS,CAmB7B;IAED;;;;;;;;;OASG;IACH,2BANW,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,aACrB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,KAAK,OAAO,YACrE,OAAO,GACL,OAAO,GAAC,SAAS,CAqB7B;IAED;;;;;;;OAOG;IACH,mBAJW,KAAK,CAAC,OAAO,CAAC,UACd,KAAK,CAAC,OAAO,CAAC,GACZ,KAAK,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAMrC;IAED;;;;;;OAMG;IACH,oBAHW,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,GACnB,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAsBjC;IAED;;;;;;;;OAQG;IACH,uBALW,KAAK,CAAC,OAAO,CAAC,WACd,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,GACjC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAkBnC;IAED;;;;;;;;OAQG;IACH,2BANW,KAAK,CAAC,OAAO,CAAC,SACd,MAAM,YACN,OAAO,GAEL,OAAO,CAsBnB;IAED;;;;;OAKG;IACH,0BAHW,KAAK,CAAC,OAAO,CAAC,GACZ,KAAK,CAAC,OAAO,CAAC,CAS1B;IAED;;;;;;OAMG;IACH,0BAJW,KAAK,CAAC,OAAO,CAAC,QACd,KAAK,CAAC,OAAO,CAAC,GACZ,KAAK,CAAC,OAAO,CAAC,CAa1B;IAED;;;;;;;;;;;;;;OAcG;IACH,wBAJW,KAAK,CAAC,OAAO,CAAC,QACd,KAAK,CAAC,OAAO,CAAC,GACZ,OAAO,CAanB;IAED;;;;;;;;;OASG;IACH,qBANW,KAAK,CAAC,OAAO,CAAC,UACd,MAAM,SACN,OAAO,aACP,MAAM,GACJ,KAAK,CAAC,OAAO,CAAC,CAyB1B;IAED;;;;;;;OAOG;IACH,wBAJW,KAAK,CAAC,OAAO,CAAC,aACd,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,GACxE,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAanC;IAED;;;;;;OAMG;IACH,wBAJW,MAAM,WACN,OAAO,GACL,MAAM,CAqBlB;IAED;;;;;OAKG;IACH,0BAHW,MAAM,GACJ,OAAO,CASnB;IAED;;;;;;;OAOG;IACH,6BAJW,MAAM,QACN,KAAK,CAAC,MAAM,CAAC,GACX,MAAM,CA2BlB;IAED;;;;;;;OAOG;IACH,2BAJW,MAAM,QACN,KAAK,CAAC,MAAM,CAAC,SACb,OAAO,QAiBjB;IAED;;;;;OAKG;IACH,+BAHc,MAAM,EAAA,GACP,MAAM,CAqBlB;IAED;;;;;OAKG;IACH,6BAHW,MAAM,GACJ,MAAM,CAmBlB;IAED;;;;;;;OAOG;IACH,2BALW,MAAM,eACN,CAAS,IAAO,EAAP,OAAO,KAAG,OAAO,WAC1B,OAAO,GACL,OAAO,CAAC,MAAM,CAAC,CAe3B;IAED;;;;;;OAMG;IACH,8BAJW,KAAK,CAAC,OAAO,CAAC,QACd,KAAK,CAAC,OAAO,CAAC,IAAC,CAAS,IAAc,EAAd,KAAK,CAAC,OAAO,CAAC,KAAG,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,GAAC,KAAK,CAAC,OAAO,CAAC,CAAA,GAC7E,OAAO,CAAC,MAAM,CAAC,CA0C3B;IAED;;;;;;;;OAQG;IACH,sBALW,KAAK,CAAC,OAAO,CAAC,WACd,KAAK,CAAC,OAAO,CAAC,GACZ,KAAK,CAAC,OAAO,CAAC,CAW1B;IAED;;;;;;;;OAQG;IACH,2BALW,KAAK,CAAC,OAAO,CAAC,WACd,KAAK,CAAC,OAAO,CAAC,GACZ,KAAK,CAAC,OAAO,CAAC,CAY1B;IAED;;;;;;;;OAQG;IACH,0BALW,KAAK,CAAC,OAAO,CAAC,WACd,KAAK,CAAC,OAAO,CAAC,GACZ,KAAK,CAAC,OAAO,CAAC,CAiB1B;IAED;;;;;;;OAOG;IACH,iCAJW,KAAK,CAAC,MAAM,CAAC,GACX,MAAM,CA0BlB;IAED;;;;;;OAMG;IACH,iCAHW,KAAK,CAAC,MAAM,CAAC,GAAC,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,GAChC,MAAM,CAMlB;CACF"}