@gesslar/toolkit 3.13.0 → 3.14.0

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

@@ -1,42 +0,0 @@
-/**
- * Utility class for timing operations and promise-based delays.
- * Provides methods for creating cancellable timeout promises.
- */
-export default class Time {
-    /**
-     * Creates a promise that resolves after a specified delay.
-     * The returned promise includes a timerId property that can be used with cancel().
-     *
-     * @param {number} delay - Delay in milliseconds before resolving (must be >= 0)
-     * @param {unknown} [value] - Optional value to resolve with after the delay
-     * @returns {Promise<unknown> & {timerId: number}} Promise that resolves with the value after delay, extended with timerId property
-     * @throws {Sass} If delay is not a number or is negative
-     * @example
-     * // Wait 1 second then continue
-     * await Time.after(1000)
-     *
-     * // Wait 1 second then get a value
-     * const result = await Time.after(1000, 'done')
-     *
-     * // Create a cancellable delay
-     * const promise = Time.after(5000, 'data')
-     * Time.cancel(promise) // Cancel before it resolves
-     */
-    static after(delay: number, value?: unknown): Promise<unknown> & {
-        timerId: number;
-    };
-    /**
-     * Cancels a promise created by Time.after() by clearing its timeout.
-     * If the promise has already resolved or is not a Time.after() promise, this is a no-op.
-     *
-     * @param {Promise<unknown> & {timerId?: number}} promise - Promise returned from Time.after() to cancel
-     * @returns {void}
-     * @example
-     * const promise = Time.after(5000, 'data')
-     * Time.cancel(promise) // Prevents the promise from resolving
-     */
-    static cancel(promise: Promise<unknown> & {
-        timerId?: number;
-    }): void;
-}
-//# sourceMappingURL=Time.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Time.d.ts","sourceRoot":"","sources":["../../../browser/lib/Time.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH;IACE;;;;;;;;;;;;;;;;;;OAkBG;IACH,oBAfW,MAAM,UACN,OAAO,GACL,OAAO,CAAC,OAAO,CAAC,GAAG;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,CAwBhD;IAED;;;;;;;;;OASG;IACH,uBANW,OAAO,CAAC,OAAO,CAAC,GAAG;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAC,GACnC,IAAI,CAQhB;CACF"}

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

@@ -1,90 +0,0 @@
-/**
- * Type specification class for parsing and validating complex type definitions.
- * Supports union types, array types, and validation options.
- */
-export default class TypeSpec {
-    /**
-     * Creates a new TypeSpec instance.
-     *
-     * @param {string} string - The type specification string (e.g., "string|number", "object[]")
-     * @param {unknown} options - Additional parsing options
-     */
-    constructor(string: string, options: unknown);
-    specs: any[];
-    length: number;
-    stringRepresentation: string;
-    /**
-     * Returns a string representation of the type specification.
-     *
-     * @returns {string} The type specification as a string (e.g., "string|number[]")
-     */
-    toString(): string;
-    /**
-     * Returns a JSON representation of the TypeSpec.
-     *
-     * @returns {unknown} Object containing specs, length, and string representation
-     */
-    toJSON(): unknown;
-    /**
-     * Executes a provided function once for each type specification.
-     *
-     * @param {function(unknown): void} callback - Function to execute for each spec
-     */
-    forEach(callback: (arg0: unknown) => void): void;
-    /**
-     * Tests whether all type specifications pass the provided test function.
-     *
-     * @param {function(unknown): boolean} callback - Function to test each spec
-     * @returns {boolean} True if all specs pass the test
-     */
-    every(callback: (arg0: unknown) => boolean): boolean;
-    /**
-     * Tests whether at least one type specification passes the provided test function.
-     *
-     * @param {function(unknown): boolean} callback - Function to test each spec
-     * @returns {boolean} True if at least one spec passes the test
-     */
-    some(callback: (arg0: unknown) => boolean): boolean;
-    /**
-     * Creates a new array with all type specifications that pass the provided test function.
-     *
-     * @param {function(unknown): boolean} callback - Function to test each spec
-     * @returns {Array<unknown>} New array with filtered specs
-     */
-    filter(callback: (arg0: unknown) => boolean): Array<unknown>;
-    /**
-     * Creates a new array populated with the results of calling the provided function on every spec.
-     *
-     * @param {function(unknown): unknown} callback - Function to call on each spec
-     * @returns {Array<unknown>} New array with mapped values
-     */
-    map(callback: (arg0: unknown) => unknown): Array<unknown>;
-    /**
-     * Executes a reducer function on each spec, resulting in a single output value.
-     *
-     * @param {function(unknown, unknown): unknown} callback - Function to execute on each spec
-     * @param {unknown} initialValue - Initial value for the accumulator
-     * @returns {unknown} The final accumulated value
-     */
-    reduce(callback: (arg0: unknown, arg1: unknown) => unknown, initialValue: unknown): unknown;
-    /**
-     * Returns the first type specification that satisfies the provided testing function.
-     *
-     * @param {function(unknown): boolean} callback - Function to test each spec
-     * @returns {object|undefined} The first spec that matches, or undefined
-     */
-    find(callback: (arg0: unknown) => boolean): object | undefined;
-    /**
-     * Tests whether a value matches any of the type specifications.
-     * Handles array types, union types, and empty value validation.
-     *
-     * @param {unknown} value - The value to test against the type specifications
-     * @param {unknown} options - Validation options
-     * @param {boolean} options.allowEmpty - Whether empty values are allowed
-     * @returns {boolean} True if the value matches any type specification
-     */
-    matches(value: unknown, options: unknown): boolean;
-    match(value: any, options: any): unknown[];
-    #private;
-}
-//# sourceMappingURL=TypeSpec.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"TypeSpec.d.ts","sourceRoot":"","sources":["../../../browser/lib/TypeSpec.js"],"names":[],"mappings":"AAWA;;;GAGG;AACH;IAGE;;;;;OAKG;IACH,oBAHW,MAAM,WACN,OAAO,EAUjB;IAJC,aAAwB;IACxB,eAAgC;IAChC,6BAA2C;IAI7C;;;;OAIG;IACH,YAFa,MAAM,CAQlB;IAED;;;;OAIG;IACH,UAFa,OAAO,CASnB;IAED;;;;OAIG;IACH,kBAFW,CAAS,IAAO,EAAP,OAAO,KAAG,IAAI,QAIjC;IAED;;;;;OAKG;IACH,gBAHW,CAAS,IAAO,EAAP,OAAO,KAAG,OAAO,GACxB,OAAO,CAInB;IAED;;;;;OAKG;IACH,eAHW,CAAS,IAAO,EAAP,OAAO,KAAG,OAAO,GACxB,OAAO,CAInB;IAED;;;;;OAKG;IACH,iBAHW,CAAS,IAAO,EAAP,OAAO,KAAG,OAAO,GACxB,KAAK,CAAC,OAAO,CAAC,CAI1B;IAED;;;;;OAKG;IACH,cAHW,CAAS,IAAO,EAAP,OAAO,KAAG,OAAO,GACxB,KAAK,CAAC,OAAO,CAAC,CAI1B;IAED;;;;;;OAMG;IACH,iBAJW,CAAS,IAAO,EAAP,OAAO,EAAE,IAAO,EAAP,OAAO,KAAG,OAAO,gBACnC,OAAO,GACL,OAAO,CAInB;IAED;;;;;OAKG;IACH,eAHW,CAAS,IAAO,EAAP,OAAO,KAAG,OAAO,GACxB,MAAM,GAAC,SAAS,CAI5B;IAED;;;;;;;;OAQG;IACH,eALW,OAAO,WACP,OAAO,GAEL,OAAO,CAInB;IAED,2CA6DC;;CAmDF"}

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

@@ -1,62 +0,0 @@
-/**
- * Utility class providing common helper functions for string manipulation,
- * timing, and option parsing.
- */
-export default class Util {
-    /**
-     * Capitalizes the first letter of a string.
-     *
-     * @param {string} text - The text to capitalize
-     * @returns {string} Text with first letter capitalized
-     */
-    static capitalize(text: string): string;
-    /**
-     * Measure wall-clock time for an async function.
-     *
-     * @template T
-     * @param {() => Promise<T>} fn - Thunk returning a promise.
-     * @returns {Promise<{result: T, cost: number}>} Object containing result and elapsed ms (number, 1 decimal).
-     */
-    static time<T>(fn: () => Promise<T>): Promise<{
-        result: T;
-        cost: number;
-    }>;
-    /**
-     * Right-align a string inside a fixed width (left pad with spaces).
-     * If the string exceeds width it is returned unchanged.
-     *
-     * @param {string|number} text - Text to align.
-     * @param {number} width - Target field width (default 80).
-     * @returns {string} Padded string.
-     */
-    static rightAlignText(text: string | number, width?: number): string;
-    /**
-     * Centre-align a string inside a fixed width (pad with spaces on left).
-     * If the string exceeds width it is returned unchanged.
-     *
-     * @param {string|number} text - Text to align.
-     * @param {number} width - Target field width (default 80).
-     * @returns {string} Padded string with text centred.
-     */
-    static centreAlignText(text: string | number, width?: number): string;
-    /**
-     * Determine the Levenshtein distance between two string values
-     *
-     * @param {string} a The first value for comparison.
-     * @param {string} b The second value for comparison.
-     * @returns {number} The Levenshtein distance
-     */
-    static levenshteinDistance(a: string, b: string): number;
-    /**
-     * Determine the closest match between a string and allowed values
-     * from the Levenshtein distance.
-     *
-     * @param {string} input The input string to resolve
-     * @param {Array<string>} allowedValues The values which are permitted
-     * @param {number} [threshold] Max edit distance for a "close match"
-     * @returns {string} Suggested, probable match.
-     */
-    static findClosestMatch(input: string, allowedValues: Array<string>, threshold?: number): string;
-    static regexify(input: any, trim?: boolean, flags?: any[]): RegExp;
-}
-//# sourceMappingURL=Util.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Util.d.ts","sourceRoot":"","sources":["../../../browser/lib/Util.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH;IACE;;;;;OAKG;IACH,wBAHW,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;;OAMG;IACH,YAJa,CAAC,MACH,MAAM,OAAO,CAAC,CAAC,CAAC,GACd,OAAO,CAAC;QAAC,MAAM,EAAE,CAAC,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC,CAQ9C;IAED;;;;;;;OAOG;IACH,4BAJW,MAAM,GAAC,MAAM,UACb,MAAM,GACJ,MAAM,CAWlB;IAED;;;;;;;OAOG;IACH,6BAJW,MAAM,GAAC,MAAM,UACb,MAAM,GACJ,MAAM,CAalB;IAED;;;;;;OAMG;IACH,8BAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAsBlB;IAED;;;;;;;;OAQG;IACH,+BALW,MAAM,iBACN,KAAK,CAAC,MAAM,CAAC,cACb,MAAM,GACJ,MAAM,CAwBlB;IAED,mEAiBC;CACF"}

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

@@ -1,33 +0,0 @@
-/**
- * Validation utility class providing type checking and assertion methods.
- */
-export default class Valid {
-    /**
-     * Validates a value against a type. Uses Data.isType.
-     *
-     * @param {unknown} value - The value to validate
-     * @param {string} type - The expected type in the form of "object", "object[]", "object|object[]"
-     * @param {object} [options] - Additional options for validation.
-     */
-    static type(value: unknown, type: string, options?: object): void;
-    /**
-     * Asserts a condition
-     *
-     * @param {boolean} condition - The condition to assert
-     * @param {string} message - The message to display if the condition is not
-     *                           met
-     * @param {number} [arg] - The argument to display if the condition is not
-     *                         met (optional)
-     */
-    static assert(condition: boolean, message: string, arg?: number): void;
-    static "__#private@#restrictedProto": string[];
-    /**
-     * Protects against prototype pollution by checking keys for dangerous property names.
-     * Throws if any restricted prototype properties are found in the keys array.
-     *
-     * @param {Array<string>} keys - Array of property keys to validate
-     * @throws {Sass} If any key matches restricted prototype properties (__proto__, constructor, prototype)
-     */
-    static prototypePollutionProtection(keys: Array<string>): void;
-}
-//# sourceMappingURL=Valid.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Valid.d.ts","sourceRoot":"","sources":["../../../browser/lib/Valid.js"],"names":[],"mappings":"AAWA;;GAEG;AACH;IACE;;;;;;OAMG;IACH,mBAJW,OAAO,QACP,MAAM,YACN,MAAM,QAQhB;IAED;;;;;;;;OAQG;IACH,yBANW,OAAO,WACP,MAAM,QAEN,MAAM,QAkBhB;IAED,+CAAmE;IAEnE;;;;;;OAMG;IACH,0CAHW,KAAK,CAAC,MAAM,CAAC,QAYvB;CACF"}

package/src/types/browser/lib/vendor/dompurify.esm.d.ts

@@ -1,29 +0,0 @@
-export { purify as default };
-declare function purify(root: any): {
-    (root: any): /*elided*/ any;
-    version: string;
-    removed: any[];
-    isSupported: boolean;
-    sanitize(dirty: any, ...args: any[]): any;
-    setConfig(...args: any[]): void;
-    clearConfig(): void;
-    isValidAttribute(tag: any, attr: any, value: any): boolean;
-    addHook(entryPoint: any, hookFunction: any): void;
-    removeHook(entryPoint: any, hookFunction: any): any;
-    removeHooks(entryPoint: any): void;
-    removeAllHooks(): void;
-};
-declare namespace purify {
-    let version: string;
-    let removed: any[];
-    let isSupported: boolean;
-    function sanitize(dirty: any, ...args: any[]): any;
-    function setConfig(...args: any[]): void;
-    function clearConfig(): void;
-    function isValidAttribute(tag: any, attr: any, value: any): boolean;
-    function addHook(entryPoint: any, hookFunction: any): void;
-    function removeHook(entryPoint: any, hookFunction: any): any;
-    function removeHooks(entryPoint: any): void;
-    function removeAllHooks(): void;
-}
-//# sourceMappingURL=dompurify.esm.d.ts.map

package/src/types/browser/lib/vendor/dompurify.esm.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dompurify.esm.d.ts","sourceRoot":"","sources":["../../../../browser/lib/vendor/dompurify.esm.js"],"names":[],"mappings":";AA0UE;;;;;;;;;;;;;EAA+C;;;;;IA+9B/C,mDAiJC;IACD,yCAIC;IACD,6BAGC;IACD,oEAUC;IACD,2DAMC;IACD,6DAQC;IACD,4CAEC;IACD,gCAEC"}

package/src/types/index.d.ts

@@ -1,20 +0,0 @@
-export { default as Collection } from "./browser/lib/Collection.js";
-export { default as Data } from "./browser/lib/Data.js";
-export { default as Promised } from "./browser/lib/Promised.js";
-export { default as Time } from "./browser/lib/Time.js";
-export { default as Type } from "./browser/lib/TypeSpec.js";
-export { default as Valid } from "./lib/Valid.js";
-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 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";
-export { default as Notify } from "./lib/Notify.js";
-export { default as Term } from "./lib/Term.js";
-export { default as Disposer, Disposer as DisposerClass } from "./browser/lib/Disposer.js";
-//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -1,27 +0,0 @@
-/**
- * File system cache with automatic invalidation based on modification time.
- * Provides intelligent caching of parsed JSON5/YAML files with mtime-based
- * cache invalidation to optimize performance for repeated file access.
- *
- * The cache eliminates redundant file reads and parsing when multiple processes
- * access the same dependency files, while ensuring data freshness through
- * modification time checking.
- */
-export default class Cache {
-    /**
-     * Loads and caches parsed file data with automatic invalidation based on
-     * modification time.
-     *
-     * Implements a sophisticated caching strategy that checks file modification
-     * times to determine whether cached data is still valid, ensuring data
-     * freshness while optimizing performance for repeated file access during
-     * parallel processing.
-     *
-     * @param {import("./FileObject.js").FileObject} fileObject - The file object to load and cache
-     * @returns {Promise<unknown>} The parsed file data (JSON5 or YAML)
-     * @throws {Sass} If the file cannot be found or accessed
-     */
-    loadCachedData(fileObject: import("./FileObject.js").FileObject): Promise<unknown>;
-    #private;
-}
-//# sourceMappingURL=Cache.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Cache.d.ts","sourceRoot":"","sources":["../../lib/Cache.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH;IAoBE;;;;;;;;;;;;OAYG;IACH,2BAJW,OAAO,iBAAiB,EAAE,UAAU,GAClC,OAAO,CAAC,OAAO,CAAC,CA6B5B;;CACF"}

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

@@ -1,144 +0,0 @@
-/**
- * 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 {
-    /**
-     * Creates a CappedDirectoryObject 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
-     * @example
-     * // When using pnpx or similar tools
-     * const projectRoot = CappedDirectoryObject.fromCwd()
-     * const srcDir = projectRoot.getDirectory("src")
-     * // srcDir is capped at the project root
-     */
-    static fromCwd(): CappedDirectoryObject;
-    /**
-     * Constructs a CappedDirectoryObject 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).
-     *
-     * @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
-     * @example
-     * // Create new capped directory at current directory
-     * const cwd = new CappedDirectoryObject()
-     * // path: process.cwd(), cap: process.cwd()
-     *
-     * @example
-     * // Create new capped directory
-     * const cache = new CappedDirectoryObject("/home/user/.cache")
-     * // path: /home/user/.cache, cap: /home/user/.cache
-     *
-     * @example
-     * // Create subdirectory with parent
-     * const data = new CappedDirectoryObject("data", cache)
-     * // path: /home/user/.cache/data, cap: /home/user/.cache
-     *
-     * @example
-     * // Virtual absolute path with parent
-     * const config = new CappedDirectoryObject("/etc/config", cache)
-     * // path: /home/user/.cache/etc/config, cap: /home/user/.cache
-     */
-    constructor(directory?: string, source?: any);
-    /**
-     * Indicates whether this directory is capped (constrained to a specific tree).
-     * Always returns true for CappedDirectoryObject instances.
-     *
-     * @returns {boolean} True for all CappedDirectoryObject instances
-     * @example
-     * const capped = new TempDirectoryObject("myapp")
-     * console.log(capped.isCapped) // true
-     *
-     * const regular = new DirectoryObject("/tmp")
-     * console.log(regular.isCapped) // false
-     */
-    get isCapped(): boolean;
-    /**
-     * Returns the cap (root) of the capped directory tree.
-     * For root CappedDirectoryObject instances, returns itself.
-     * For children, returns the inherited cap from the parent chain.
-     *
-     * @returns {CappedDirectoryObject} 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)
-     *
-     * const subdir = temp.getDirectory("data")
-     * console.log(subdir.cap === temp) // true (child inherits parent's cap)
-     */
-    get cap(): CappedDirectoryObject;
-    /**
-     * Returns a plain DirectoryObject representing the actual filesystem location.
-     * This provides an "escape hatch" from the capped environment to interact
-     * with the real filesystem when needed.
-     *
-     * @returns {DirectoryObject} Uncapped directory object at the real filesystem path
-     * @example
-     * const temp = new TempDirectoryObject("myapp")
-     * const subdir = temp.getDirectory("data")
-     *
-     * // Work within the capped environment (virtual paths)
-     * console.log(subdir.path)        // "/data" (virtual)
-     * subdir.getFile("config.json")   // Stays within cap
-     *
-     * // Break out to real filesystem when needed
-     * console.log(subdir.real.path)   // "/tmp/myapp-ABC123/data" (real)
-     * subdir.real.parent              // Can traverse outside the cap
-     */
-    get real(): 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.
-     * This maintains the capping behavior throughout the directory hierarchy.
-     *
-     * @returns {CappedDirectoryObject|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(capped.parent) // null (at cap root)
-     */
-    get parent(): CappedDirectoryObject | null;
-    /**
-     * Returns the path of the parent directory.
-     * Returns null if this directory is at the cap root (no parent).
-     *
-     * @returns {string|null} The parent directory path, or null if at cap root
-     * @example
-     * const temp = new TempDirectoryObject("myapp")
-     * console.log(temp.parentPath) // null (at cap root)
-     *
-     * const subdir = temp.getDirectory("data")
-     * console.log(subdir.parentPath) // "/data" or similar (parent's virtual path)
-     */
-    get parentPath(): string | null;
-    /**
-     * 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
-     */
-    read(...arg: any[]): Promise<{
-        files: Array<FileObject>;
-        directories: any[];
-    }>;
-    #private;
-}
-import DirectoryObject from "./DirectoryObject.js";
-import FileObject from "./FileObject.js";
-//# sourceMappingURL=CappedDirectoryObject.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"CappedDirectoryObject.d.ts","sourceRoot":"","sources":["../../lib/CappedDirectoryObject.js"],"names":[],"mappings":"AAiBA;;;;;;;;GAQG;AACH;IAoEE;;;;;;;;;;;OAWG;IACH,kBAPa,qBAAqB,CASjC;IA5ED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,wBAxBW,MAAM,gBAqDhB;IAkBD;;;;;;;;;;;OAWG;IACH,gBARa,OAAO,CAUnB;IAED;;;;;;;;;;;;OAYG;IACH,WARa,qBAAqB,CAUjC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,YAba,eAAe,CAe3B;IAED;;;;;;;;;;;;;OAaG;IACH,cAPa,qBAAqB,GAAC,IAAI,CAStC;IAED;;;;;;;;;;;OAWG;IACH,kBARa,MAAM,GAAC,IAAI,CAUvB;IAWD;;;;;OAKG;IACH,qBAFa,OAAO,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;QAAC,WAAW,QAAO;KAAC,CAAC,CAUnE;;CA8BF;4BAhP2B,sBAAsB;uBAC3B,iBAAiB"}