@gesslar/toolkit 3.14.0 → 3.14.1

package/package.json

@@ -5,7 +5,7 @@
     "name": "gesslar",
     "url": "https://gesslar.dev"
   },
-  "version": "3.14.0",
+  "version": "3.14.1",
   "license": "Unlicense",
   "homepage": "https://github.com/gesslar/toolkit#readme",
   "repository": {
@@ -24,27 +24,28 @@
     "browser",
     "node"
   ],
-  "main": "./src/index.js",
+  "main": "./src/node/index.js",
   "type": "module",
-  "types": "./src/types/index.d.ts",
+  "types": "./types/node/index.d.ts",
   "exports": {
     ".": {
-      "types": "./src/types/index.d.ts",
+      "types": "./types/node/index.d.ts",
       "browser": "./src/browser/index.js",
-      "node": "./src/index.js",
-      "default": "./src/index.js"
+      "node": "./src/node/index.js",
+      "default": "./src/node/index.js"
     },
     "./browser": {
-      "types": "./src/types/index.d.ts",
+      "types": "./types/browser/index.d.ts",
       "default": "./src/browser/index.js"
     },
     "./node": {
-      "types": "./src/types/index.d.ts",
-      "default": "./src/index.js"
+      "types": "./types/node/index.d.ts",
+      "default": "./src/node/index.js"
     }
   },
   "files": [
     "src/",
+    "types/",
     "UNLICENSE.txt"
   ],
   "engines": {

package/types/browser/index.d.ts

@@ -0,0 +1,13 @@
+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/types/browser/index.d.ts.map

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

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

@@ -0,0 +1,248 @@
+/**
+ * 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/types/browser/lib/Collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Collection.d.ts","sourceRoot":"","sources":["../../../src/browser/lib/Collection.js"],"names":[],"mappings":"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"}

package/types/browser/lib/Data.d.ts

@@ -0,0 +1,250 @@
+export default class Data {
+    /**
+     * Array of JavaScript primitive type names.
+     * Includes basic types and object categories from the typeof operator.
+     *
+     * @type {Array<string>}
+     */
+    static primitives: Array<string>;
+    /**
+     * Array of JavaScript constructor names for built-in objects.
+     * Includes common object types and typed arrays.
+     *
+     * @type {Array<string>}
+     */
+    static constructors: Array<string>;
+    /**
+     * Combined array of all supported data types (primitives and constructors in
+     * lowercase).
+     *
+     * Used for type validation throughout the utility functions.
+     *
+     * @type {Array<string>}
+     */
+    static dataTypes: Array<string>;
+    /**
+     * Array of type names that can be checked for emptiness.
+     * These types have meaningful empty states that can be tested.
+     *
+     * @type {Array<string>}
+     */
+    static emptyableTypes: Array<string>;
+    /**
+     * Appends a string to another string if it does not already end with it.
+     *
+     * @param {string} string - The string to append to
+     * @param {string} append - The string to append
+     * @returns {string} The appended string
+     */
+    static append(string: string, append: string): string;
+    /**
+     * Prepends a string to another string if it does not already start with it.
+     *
+     * @param {string} string - The string to prepend to
+     * @param {string} prepend - The string to prepend
+     * @returns {string} The prepended string
+     */
+    static prepend(string: string, prepend: string): string;
+    /**
+     * Remove a suffix from the end of a string if present.
+     *
+     * @param {string} string - The string to process
+     * @param {string} toChop - The suffix to remove from the end
+     * @param {boolean} [caseInsensitive=false] - Whether to perform case-insensitive matching
+     * @returns {string} The string with suffix removed, or original if suffix not found
+     * @example
+     * Data.chopRight("hello.txt", ".txt") // "hello"
+     * Data.chopRight("Hello", "o") // "Hell"
+     * Data.chopRight("HELLO", "lo", true) // "HEL"
+     */
+    static chopRight(string: string, toChop: string, caseInsensitive?: boolean): string;
+    /**
+     * Remove a prefix from the beginning of a string if present.
+     *
+     * @param {string} string - The string to process
+     * @param {string} toChop - The prefix to remove from the beginning
+     * @param {boolean} [caseInsensitive=false] - Whether to perform case-insensitive matching
+     * @returns {string} The string with prefix removed, or original if prefix not found
+     * @example
+     * Data.chopLeft("hello.txt", "hello") // ".txt"
+     * Data.chopLeft("Hello", "H") // "ello"
+     * Data.chopLeft("HELLO", "he", true) // "LLO"
+     */
+    static chopLeft(string: string, toChop: string, caseInsensitive?: boolean): string;
+    /**
+     * Chop a string after the first occurence of another string.
+     *
+     * @param {string} string - The string to search
+     * @param {string} needle - The bit to chop after
+     * @param {boolean} caseInsensitive - Whether to search insensitive to case
+     * @returns {string} The remaining string
+     */
+    static chopAfter(string: string, needle: string, caseInsensitive?: boolean): string;
+    /**
+     * Chop a string before the first occurrence of another string.
+     *
+     * @param {string} string - The string to search
+     * @param {string} needle - The bit to chop before
+     * @param {boolean} caseInsensitive - Whether to search insensitive to case
+     * @returns {string} The remaining string
+     */
+    static chopBefore(string: string, needle: string, caseInsensitive?: boolean): string;
+    /**
+     * Creates a type spec from a string. A type spec is an array of objects
+     * defining the type of a value and whether an array is expected.
+     *
+     * @param {string} string - The string to parse into a type spec.
+     * @param {object} options - Additional options for parsing.
+     * @returns {Array<object>} An array of type specs.
+     */
+    static newTypeSpec(string: string, options: object): Array<object>;
+    /**
+     * Checks if a value is of a specified type
+     *
+     * @param {unknown} value The value to check
+     * @param {string|TypeSpec} type The type to check for
+     * @param {object} options Additional options for checking
+     * @returns {boolean} Whether the value is of the specified type
+     */
+    static isType(value: unknown, type: string | TypeSpec, options?: object): boolean;
+    /**
+     * Checks if a type is valid
+     *
+     * @param {string} type - The type to check
+     * @returns {boolean} Whether the type is valid
+     */
+    static isValidType(type: string): boolean;
+    /**
+     * Checks if a value is of a specified type. Unlike the type function, this
+     * function does not parse the type string, and only checks for primitive
+     * or constructor types.
+     *
+     * @param {unknown} value - The value to check
+     * @param {string} type - The type to check for
+     * @returns {boolean} Whether the value is of the specified type
+     */
+    static isBaseType(value: unknown, type: string): boolean;
+    /**
+     * Returns the type of a value, whether it be a primitive, object, or function.
+     *
+     * @param {unknown} value - The value to check
+     * @returns {string} The type of the value
+     */
+    static typeOf(value: unknown): string;
+    /**
+     * Checks a value is undefined or null.
+     *
+     * @param {unknown} value The value to check
+     * @returns {boolean} Whether the value is undefined or null
+     */
+    static isNothing(value: unknown): boolean;
+    /**
+     * Checks if a value is empty. This function is used to check if an object,
+     * array, or string is empty. Null and undefined values are considered empty.
+     *
+     * @param {unknown} value The value to check
+     * @param {boolean} checkForNothing Whether to check for null or undefined
+     *                                  values
+     * @returns {boolean} Whether the value is empty
+     */
+    static isEmpty(value: unknown, checkForNothing?: boolean): boolean;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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) => 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) => Promise<boolean>): Promise<Array<unknown>>;
+    /**
+     * Ensures a value is within a specified range.
+     *
+     * @param {number} val - The value to check.
+     * @param {number} min - The minimum value.
+     * @param {number} max - The maximum value.
+     * @returns {number} The value, constrained within the range of `min` to `max`.
+     */
+    static clamp(val: number, min: number, max: number): number;
+    /**
+     * Checks if a value is within a specified range (inclusive).
+     *
+     * @param {number} val - The value to check.
+     * @param {number} min - The minimum value (inclusive).
+     * @param {number} max - The maximum value (inclusive).
+     * @returns {boolean} True if the value is within the range, false otherwise.
+     */
+    static clamped(val: number, min: number, max: number): boolean;
+    /**
+     * Checks if a value is a plain object - created with object literals {},
+     * new Object(), or Object.create(null).
+     *
+     * Distinguishes plain objects from objects created by custom constructors, built-ins,
+     * or primitives. Plain objects only have Object.prototype or null in their prototype chain.
+     *
+     * @param {unknown} value - The value to check
+     * @returns {boolean} True if the value is a plain object, false otherwise
+     *
+     * @example
+     * isPlainObject({}) // true
+     * isPlainObject(new Object()) // true
+     * isPlainObject(Object.create(null)) // true
+     * isPlainObject([]) // false
+     * isPlainObject(new Date()) // false
+     * isPlainObject(null) // false
+     * isPlainObject("string") // false
+     * isPlainObject(class Person{}) // false
+     */
+    static isPlainObject(value: unknown): boolean;
+    /**
+     * Checks if a value is binary data.
+     * Returns true for ArrayBuffer, TypedArrays (Uint8Array, Int16Array, etc.),
+     * Blob, and Node Buffer instances.
+     *
+     * @param {unknown} value - The value to check
+     * @returns {boolean} True if the value is binary data, false otherwise
+     * @example
+     * Data.isBinary(new Uint8Array([1, 2, 3])) // true
+     * Data.isBinary(new ArrayBuffer(10)) // true
+     * Data.isBinary(Buffer.from('hello')) // true
+     * Data.isBinary(new Blob(['text'])) // true
+     * Data.isBinary('string') // false
+     * Data.isBinary({}) // false
+     * Data.isBinary(undefined) // false
+     */
+    static isBinary(value: unknown): boolean;
+}
+import TypeSpec from "./TypeSpec.js";
+//# sourceMappingURL=Data.d.ts.map

package/types/browser/lib/Data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Data.d.ts","sourceRoot":"","sources":["../../../src/browser/lib/Data.js"],"names":[],"mappings":"AAUA;IACA;;;;;OAKG;IACD,mBAFQ,KAAK,CAAC,MAAM,CAAC,CAgBnB;IAEF;;;;;OAKG;IACH,qBAFU,KAAK,CAAC,MAAM,CAAC,CAmBrB;IAEF;;;;;;;OAOG;IACH,kBAFU,KAAK,CAAC,MAAM,CAAC,CAKrB;IAEF;;;;;OAKG;IACH,uBAFU,KAAK,CAAC,MAAM,CAAC,CAE2D;IAElF;;;;;;OAMG;IACH,sBAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAMlB;IAED;;;;;;OAMG;IACH,uBAJW,MAAM,WACN,MAAM,GACJ,MAAM,CAMlB;IAED;;;;;;;;;;;OAWG;IACH,yBATW,MAAM,UACN,MAAM,oBACN,OAAO,GACL,MAAM,CAWlB;IAED;;;;;;;;;;;OAWG;IACH,wBATW,MAAM,UACN,MAAM,oBACN,OAAO,GACL,MAAM,CAWlB;IAED;;;;;;;OAOG;IACH,yBALW,MAAM,UACN,MAAM,oBACN,OAAO,GACL,MAAM,CAWlB;IAED;;;;;;;OAOG;IACH,0BALW,MAAM,UACN,MAAM,oBACN,OAAO,GACL,MAAM,CAYlB;IAED;;;;;;;OAOG;IACH,2BAJW,MAAM,WACN,MAAM,GACJ,KAAK,CAAC,MAAM,CAAC,CAIzB;IAED;;;;;;;OAOG;IACH,qBALW,OAAO,QACP,MAAM,GAAC,QAAQ,YACf,MAAM,GACJ,OAAO,CAQnB;IAED;;;;;OAKG;IACH,yBAHW,MAAM,GACJ,OAAO,CASnB;IAED;;;;;;;;OAQG;IACH,yBAJW,OAAO,QACP,MAAM,GACJ,OAAO,CAwBnB;IAED;;;;;OAKG;IACH,qBAHW,OAAO,GACL,MAAM,CAclB;IAED;;;;;OAKG;IACH,wBAHW,OAAO,GACL,OAAO,CAInB;IAED;;;;;;;;OAQG;IACH,sBALW,OAAO,oBACP,OAAO,GAEL,OAAO,CA8BnB;IAED;;;;;OAKG;IACH,6BAHW,MAAM,GACJ,MAAM,CAmBlB;IAED;;;;;;;OAOG;IACH,6BAJW,MAAM,QACN,KAAK,CAAC,MAAM,CAAC,GACX,MAAM,CAiBlB;IAED;;;;;;;OAOG;IACH,2BAJW,MAAM,QACN,KAAK,CAAC,MAAM,CAAC,SACb,OAAO,QAMjB;IAED;;;;;OAKG;IACH,+BAHc,MAAM,EAAA,GACP,MAAM,CAqBlB;IAED;;;;;;;OAOG;IACH,wBAJW,KAAK,CAAC,OAAO,CAAC,aACd,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,GAClC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAMnC;IAED;;;;;;;OAOG;IACH,kBALW,MAAM,OACN,MAAM,OACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;OAOG;IACH,oBALW,MAAM,OACN,MAAM,OACN,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,4BAbW,OAAO,GACL,OAAO,CA+BnB;IAED;;;;;;;;;;;;;;;OAeG;IACH,uBAXW,OAAO,GACL,OAAO,CAgBnB;CACF;qBAhgBoB,eAAe"}

package/types/browser/lib/Disposer.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Simple lifecycle helper that tracks disposer callbacks.
+ * Register any teardown functions and call dispose() to run them in reverse.
+ */
+export class Disposer {
+    /**
+     * Registers a disposer callback to be executed when disposed.
+     *
+     * Accepts one or more callbacks (or a single array) and returns matching
+     * unregisters. A single disposer returns a single unregister for
+     * convenience.
+     *
+     * @param {...(() => void)|Array<() => void>} disposers - Cleanup callbacks.
+     * @returns {(() => void)|Array<() => void>} Unregister function(s).
+     */
+    register(...disposers: ((() => void) | Array<() => void>)[]): (() => void) | Array<() => void>;
+    /**
+     * Runs all registered disposers in reverse order.
+     *
+     * @returns {void}
+     */
+    dispose(): void;
+    /**
+     * Read-only list of registered disposers.
+     *
+     * @returns {Array<() => void>} Snapshot of disposer callbacks.
+     */
+    get disposers(): Array<() => void>;
+    #private;
+}
+declare const _default: Disposer;
+export default _default;
+//# sourceMappingURL=Disposer.d.ts.map

package/types/browser/lib/Disposer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Disposer.d.ts","sourceRoot":"","sources":["../../../src/browser/lib/Disposer.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH;IAGE;;;;;;;;;OASG;IACH,uBAHW,CAAG,CAAC,MAAM,IAAI,CAAC,GAAC,KAAK,CAAC,MAAM,IAAI,CAAC,GAAA,GAC/B,CAAC,MAAM,IAAI,CAAC,GAAC,KAAK,CAAC,MAAM,IAAI,CAAC,CAS1C;IAWD;;;;OAIG;IACH,WAFa,IAAI,CAehB;IAcD;;;;OAIG;IACH,iBAFa,KAAK,CAAC,MAAM,IAAI,CAAC,CAI7B;;CAQF"}

package/types/browser/lib/HTML.d.ts

@@ -0,0 +1,40 @@
+export class HTML {
+    /**
+     * Lightweight HTML helper utilities for browser contexts.
+     *
+     * @param {object|(() => unknown)} domPurify - Optional DOMPurify instance or factory.
+     */
+    constructor(domPurify?: object | (() => unknown));
+    /**
+     * Fetches an HTML fragment and returns the contents inside the <body> tag when present.
+     *
+     * @param {string} url - Location of the HTML resource to load.
+     * @param {boolean} filterBodyContent - If true, returns only content found between the <body> tags. Defaults to false.
+     * @returns {Promise<string>} Sanitized HTML string or empty string on missing content.
+     */
+    loadHTML(url: string, filterBodyContent?: boolean): Promise<string>;
+    /**
+     * Sanitizes arbitrary HTML using DOMPurify.
+     *
+     * @param {string} text - HTML string to sanitize. Defaults to "".
+     * @returns {string} Sanitized HTML.
+     */
+    sanitise(text?: string): string;
+    /**
+     * Sanitizes an HTML string and replaces the element's children with the result.
+     *
+     * @param {Element} element - Target element to replace content within.
+     * @param {string} htmlString - HTML string to sanitize and insert.
+     */
+    setHTMLContent(element: Element, htmlString: string): void;
+    /**
+     * Removes all child nodes from the given element.
+     *
+     * @param {Element} element - Element to clear.
+     */
+    clearHTMLContent(element: Element): void;
+    #private;
+}
+declare const _default: HTML;
+export default _default;
+//# sourceMappingURL=HTML.d.ts.map

package/types/browser/lib/HTML.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HTML.d.ts","sourceRoot":"","sources":["../../../src/browser/lib/HTML.js"],"names":[],"mappings":"AAGA;IAGE;;;;OAIG;IACH,wBAFW,MAAM,GAAC,CAAC,MAAM,OAAO,CAAC,EAIhC;IAED;;;;;;OAMG;IACH,cAJW,MAAM,sBACN,OAAO,GACL,OAAO,CAAC,MAAM,CAAC,CAmB3B;IAED;;;;;OAKG;IACH,gBAHW,MAAM,GACJ,MAAM,CAMlB;IAED;;;;;OAKG;IACH,wBAHW,OAAO,cACP,MAAM,QA+BhB;IAED;;;;OAIG;IACH,0BAFW,OAAO,QAmBjB;;CAwBF"}