@nejs/basic-extensions 2.21.0 → 2.22.6

package/dist/cjs/big.int.extension.js

@@ -1,165 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BigIntPrototypeExtensions = exports.BigIntExtensions = void 0;
-const extension_1 = require("@nejs/extension");
-/**
- * `BigIntExtensions` is a patch for the JavaScript built-in `BigInt` class.
- * It adds utility methods to the `BigInt` class without modifying the global
- * namespace directly. This patch includes methods for checking if a value is
- * a `BigInt` and conditionally returning a value based on whether the supplied
- * value is a `BigInt` or not.
- *
- * @type {Patch}
- * @example
- * import { BigIntExtensions } from 'big.int.extension.js'
- *
- * BigIntExtensions.apply()
- * // Now the `BigInt` class has additional methods available
- */
-exports.BigIntExtensions = new extension_1.Patch(BigInt, {
-    /**
-     * Determines if the supplied `value` is a `BigInt`. This check is
-     * performed by first checking the `typeof` the `value` and then
-     * checking to see if the `value` is an `instanceof` `BigInt`
-     *
-     * @param {*} value The value that needs to be checked to determine
-     * if it is a `BigInt` or not
-     * @returns {boolean} `true` if the supplied `value` is a `BigInt`,
-     * `false` otherwise
-     *
-     * @example
-     * const bigInt = 1234567890123456789012345678901234567890n
-     * isBigInt(bigInt) // true
-     * isBigInt(1234567890123456789012345678901234567890) // false
-     * isBigInt('1234567890123456789012345678901234567890') // false
-     * isBigInt(BigInt('1234567890123456789012345678901234567890')) // true
-     */
-    isBigInt(value) {
-        return typeof value === 'bigint' || value instanceof BigInt;
-    },
-    /**
-     * Conditionally returns a value based on whether the supplied
-     * `value` is a `BigInt` or not. If the `value` is a `BigInt`,
-     * the `thenValue` will be returned. If it is not a `BigInt`,
-     * the `elseValue` will be returned instead.
-     *
-     * @param {any} value The value to check to determine if it is a
-     * `BigInt`
-     * @param {any} thenValue The value to return if the supplied
-     * `value` is a `BigInt`
-     * @param {any} elseValue The value to return if the supplied
-     * `value` is not a `BigInt`
-     * @returns {any} Either the `thenValue` or `elseValue` depending
-     * on if the supplied `value` is a `BigInt`
-     *
-     * @example
-     * const bigInt = 1234567890123456789012345678901234567890n
-     * const num = 42
-     * ifBigInt(bigInt, 'is a BigInt', 'not a BigInt')
-     * // 'is a BigInt'
-     * ifBigInt(num, 'is a BigInt', 'not a BigInt')
-     * // 'not a BigInt'
-     */
-    ifBigInt(value, thenValue, elseValue) {
-        return isThenElse(this.isBigInt(value), thenValue, elseValue);
-    },
-});
-const { isBigInt: pIsBigInt, ifBigInt: pIfBigInt } = exports.BigIntExtensions.patches;
-/**
- * `BigIntPrototypeExtensions` is a patch for the JavaScript built-in
- * `BigInt.prototype`. It adds utility methods to the `BigInt` prototype
- * without modifying the global namespace directly. This patch includes
- * methods for checking if a value is a BigInt and conditionally returning
- * a value based on whether the supplied value is a BigInt or not.
- *
- * @type {Patch}
- * @example
- * import { BigIntPrototypeExtensions } from 'big.int.extension.js'
- *
- * BigIntPrototypeExtensions.apply()
- * // Now the `BigInt` prototype has additional methods available
- */
-exports.BigIntPrototypeExtensions = new extension_1.Patch(BigInt.prototype, {
-    /**
-     * A getter method that returns an object representation of the BigInt
-     * instance.
-     *
-     * This method wraps the BigInt instance in an object, allowing it to be
-     * treated as an object. The returned object is created using the `Object()`
-     * constructor, which takes the BigInt instance as its argument.
-     *
-     * @type {Object}
-     * @readonly
-     *
-     * @example
-     * const bigInt = 1234567890123456789012345678901234567890n
-     * console.log(typeof bigInt)           // 'bigint'
-     * console.log(typeof bigInt.instance)  // 'object'
-     */
-    get instance() {
-        return Object(this);
-    },
-    /**
-     * A getter method that checks if the current instance is a BigInt.
-     *
-     * This method uses the `pIsBigInt` function from the `BigIntExtensions`
-     * patch to determine if the current instance (`this`) is a BigInt.
-     *
-     * @type {boolean}
-     * @readonly
-     *
-     * @example
-     * const bigInt = 1234567890123456789012345678901234567890n
-     * console.log(bigInt.isBigInt) // Output: true
-     *
-     * const notBigInt = 42
-     * console.log(notBigInt.isBigInt) // Output: false
-     */
-    get isBigInt() {
-        return pIsBigInt(this);
-    },
-    /**
-     * Checks if the current object is a BigInt and returns the corresponding
-     * value based on the result.
-     *
-     * This method uses the `pIfBigInt` function from the `BigIntExtensions`
-     * patch to determine if the current object (`this`) is a BigInt. If it is
-     * a BigInt, the `thenValue` is returned. Otherwise, the `elseValue` is
-     * returned.
-     *
-     * @param {any} thenValue - The value to return if the current object
-     * is a BigInt.
-     * @param {any} elseValue - The value to return if the current object
-     * is not a BigInt.
-     * @returns {any} The `thenValue` if the current object is a BigInt, or
-     * the `elseValue` if it is not a BigInt.
-     *
-     * @example
-     * const bigInt = 1234567890123456789012345678901234567890n
-     * // 'Is a BigInt'
-     * console.log(bigInt.ifBigInt('Is a BigInt', 'Not a BigInt'))
-     *
-     * const notBigInt = 42
-     * // 'Not a BigInt'
-     * console.log(notBigInt.ifBigInt('Is a BigInt', 'Not a BigInt'))
-     */
-    ifBigInt(thenValue, elseValue) {
-        return pIfBigInt(this, thenValue, elseValue);
-    },
-});
-// NOTE to self; this is repeated here otherwise a circular reference from
-// Object<->Function<->Global occurs. See original source in global.this.js
-// {@see globalThis.isThenElse}
-function isThenElse(bv, tv, ev) {
-    function isFunction(value) { typeof value === 'function'; }
-    if (arguments.length > 1) {
-        var _then = isFunction(tv) ? tv(bv) : tv;
-        if (arguments.length > 2) {
-            var _else = isFunction(ev) ? tv(bv) : ev;
-            return bv ? _then : _else;
-        }
-        return bv || _then;
-    }
-    return bv;
-}
-//# sourceMappingURL=big.int.extension.js.map

package/dist/cjs/big.int.extension.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"big.int.extension.js","sourceRoot":"","sources":["../../src/big.int.extension.js"],"names":[],"mappings":";;;AAAA,+CAAuC;AAEvC;;;;;;;;;;;;;GAaG;AACU,QAAA,gBAAgB,GAAG,IAAI,iBAAK,CAAC,MAAM,EAAE;IAChD;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,KAAK;QACZ,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,YAAY,MAAM,CAAA;IAC7D,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,QAAQ,CAAC,KAAK,EAAE,SAAS,EAAE,SAAS;QAClC,OAAO,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,SAAS,CAAC,CAAA;IAC/D,CAAC;CACF,CAAC,CAAA;AAEF,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,GAAG,wBAAgB,CAAC,OAAO,CAAA;AAE7E;;;;;;;;;;;;;GAaG;AACU,QAAA,yBAAyB,GAAG,IAAI,iBAAK,CAAC,MAAM,CAAC,SAAS,EAAE;IACnE;;;;;;;;;;;;;;;OAeG;IACH,IAAI,QAAQ;QACV,OAAO,MAAM,CAAC,IAAI,CAAC,CAAA;IACrB,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACH,IAAI,QAAQ;QACV,OAAO,SAAS,CAAC,IAAI,CAAC,CAAA;IACxB,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,QAAQ,CAAC,SAAS,EAAE,SAAS;QAC3B,OAAO,SAAS,CAAC,IAAI,EAAE,SAAS,EAAE,SAAS,CAAC,CAAA;IAC9C,CAAC;CACF,CAAC,CAAA;AAEF,0EAA0E;AAC1E,2EAA2E;AAC3E,+BAA+B;AAC/B,SAAS,UAAU,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE;IAC5B,SAAS,UAAU,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,UAAU,CAAA,CAAC,CAAC;IAE1D,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACzB,IAAI,KAAK,GAAG,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAAC,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACnE,IAAI,KAAK,GAAG,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAAC,OAAO,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAA;QACrE,CAAC;QAAC,OAAO,EAAE,IAAI,KAAK,CAAC;IACvB,CAAC;IAAC,OAAO,EAAE,CAAA;AACb,CAAC"}

package/dist/cjs/classes/asyncIterable.d.ts

@@ -1,126 +0,0 @@
-/**
- * The AsyncIterable class extends the concept of Iterable to asynchronous
- * operations. It allows creating iterable objects where each element can be
- * an asynchronous entity, like a Promise. This class is particularly useful
- * when dealing with asynchronous data sources, such as API responses, file
- * reading in chunks, or any other data that is not immediately available but
- * arrives over time.
- */
-export class AsyncIterable {
-    /**
-     * Checks if a given value is an async iterable. This method determines if
-     * the provided value has a `Symbol.asyncIterator` property that is an async
-     * generator function. It's a precise way to identify if the value conforms
-     * to the async iterable protocol using an async generator function.
-     *
-     * Note: This method specifically checks for async generator functions. Some
-     * async iterables might use regular async functions that return an async
-     * iterator, which this method won't identify.
-     *
-     * @param {*} value - The value to be checked for async iterability.
-     * @returns {boolean} - Returns true if the value is an async iterable
-     * implemented using an async generator function, false otherwise.
-     */
-    static isAsyncIterable(value: any): boolean;
-    /**
-     * Constructs an instance of AsyncIterable. Similar to Iterable, it can be
-     * initialized with either an iterable object, an async generator function,
-     * or individual elements. The elements can be promises, direct values, or a
-     * mix of both. If the first argument is an iterable or an async generator
-     * function, the instance is initialized with the elements from the iterable
-     * or the generated elements from the async generator function, followed by
-     * any additional arguments. If the first argument is not an iterable or an
-     * async generator function, all arguments are treated as individual elements.
-     *
-     * @param {Iterable|AsyncGeneratorFunction|Promise|*} elementsOrFirstElement -
-     * An iterable object, an async generator function, a Promise, or the first
-     * element.
-     * @param {...Promise|*} moreElements - Additional elements if the first
-     * argument is not an iterable or an async generator function.
-     */
-    constructor(elementsOrFirstElement: Iterable<any> | AsyncGeneratorFunction | Promise<any> | any, ...moreElements: (Promise<any> | any)[]);
-    /**
-     * Implements the async iterable protocol. When an instance of AsyncIterable
-     * is used in a `for await...of` loop, this async generator function is
-     * invoked. It yields each element as a Promise, allowing asynchronous
-     * iteration. Elements that are not Promises are automatically wrapped in
-     * a resolved Promise to ensure consistency.
-     *
-     * @returns {AsyncGenerator} An async generator that yields each element as
-     * a Promise.
-     */
-    [Symbol.asyncIterator](): AsyncGenerator;
-    /**
-     * Ensures that the constructor of this object instance's name
-     * is returned if the string tag for this instance is queried
-     *
-     * @returns {string} the name of the class
-     */
-    get [Symbol.toStringTag](): string;
-    #private;
-}
-/**
- * Being able to create a compliant `AsyncIterator` around any type of
- * iterable object. This can be wrapped around any type of object that
- * has a `[Symbol.asyncIterator]` property assigned to a generator
- * function.
- */
-export class AsyncIterator {
-    /**
-     * Creates a new `AsyncIterator` object instance.
-     *
-     * @param {object|AsyncGeneratorFunction} asyncIterable any object that has a
-     * `[Symbol.asyncIterable]` property assigned to a generator function or an
-     * async generator function itself.
-     */
-    constructor(asyncIterable: object | AsyncGeneratorFunction);
-    /**
-     * Returns a new `Array` derived from the iterable this object
-     * wraps.
-     *
-     * @returns {array} a new `Array` generated from the wrapped
-     * iterable. The method is generated from using an async for of
-     * loop.
-     */
-    asArray(): any[];
-    /**
-     * Returns the actual iterable object passed to the constructor that
-     * created this instance.
-     *
-     * @returns {object} the object containing the `[Symbol.iterator]`
-     */
-    get asyncIterable(): object;
-    /**
-     * The function retrieves the next value in the iterator. If the
-     * the iterator has run its course, `reset()` can be invoked to
-     * reset the pointer to the beginning of the iteration.
-     *
-     * @returns {any} the next value
-     */
-    next(): any;
-    /**
-     * Resets the async iterator to the beginning allowing it to be
-     * iterated over again.
-     */
-    reset(): Promise<void>;
-    /**
-     * The existence of this symbol on the object instances, indicates that
-     * it can be used in `for(.. of ..)` loops and its values can be
-     * extracted from calls to `Array.from()`
-     *
-     * @returns {AsyncIterable} this is returned since this object is already
-     * conforming to the expected JavaScript AsyncIterator interface
-     */
-    [Symbol.asyncIterator](): AsyncIterable;
-    /**
-     * Ensures that the constructor of this object instance's name
-     * is returned if the string tag for this instance is queried
-     *
-     * @returns {string} the name of the class
-     */
-    get [Symbol.toStringTag](): string;
-    #private;
-}
-export const AsyncIterableExtensions: Extension;
-export const AsyncIteratorExtensions: Extension;
-import { Extension } from '@nejs/extension';

package/dist/cjs/classes/asyncIterable.js

@@ -1,209 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncIteratorExtensions = exports.AsyncIterableExtensions = exports.AsyncIterator = exports.AsyncIterable = void 0;
-const extension_1 = require("@nejs/extension");
-/**
- * The AsyncIterable class extends the concept of Iterable to asynchronous
- * operations. It allows creating iterable objects where each element can be
- * an asynchronous entity, like a Promise. This class is particularly useful
- * when dealing with asynchronous data sources, such as API responses, file
- * reading in chunks, or any other data that is not immediately available but
- * arrives over time.
- */
-class AsyncIterable {
-    /**
-     * Private field to store the elements of the async iterable.
-     * @private
-     */
-    #elements = [];
-    /**
-     * Constructs an instance of AsyncIterable. Similar to Iterable, it can be
-     * initialized with either an iterable object, an async generator function,
-     * or individual elements. The elements can be promises, direct values, or a
-     * mix of both. If the first argument is an iterable or an async generator
-     * function, the instance is initialized with the elements from the iterable
-     * or the generated elements from the async generator function, followed by
-     * any additional arguments. If the first argument is not an iterable or an
-     * async generator function, all arguments are treated as individual elements.
-     *
-     * @param {Iterable|AsyncGeneratorFunction|Promise|*} elementsOrFirstElement -
-     * An iterable object, an async generator function, a Promise, or the first
-     * element.
-     * @param {...Promise|*} moreElements - Additional elements if the first
-     * argument is not an iterable or an async generator function.
-     */
-    constructor(elementsOrFirstElement, ...moreElements) {
-        if (elementsOrFirstElement != null &&
-            (typeof elementsOrFirstElement[Symbol.iterator] === 'function' ||
-                typeof elementsOrFirstElement[Symbol.asyncIterator] === 'function')) {
-            this.#elements = [...elementsOrFirstElement, ...moreElements];
-        }
-        else if (typeof elementsOrFirstElement === 'function' &&
-            elementsOrFirstElement.constructor.name === 'AsyncGeneratorFunction') {
-            this.#elements = elementsOrFirstElement();
-        }
-        else {
-            this.#elements = [elementsOrFirstElement, ...moreElements];
-        }
-    }
-    /**
-     * Implements the async iterable protocol. When an instance of AsyncIterable
-     * is used in a `for await...of` loop, this async generator function is
-     * invoked. It yields each element as a Promise, allowing asynchronous
-     * iteration. Elements that are not Promises are automatically wrapped in
-     * a resolved Promise to ensure consistency.
-     *
-     * @returns {AsyncGenerator} An async generator that yields each element as
-     * a Promise.
-     */
-    async *[Symbol.asyncIterator]() {
-        for await (const element of this.#elements) {
-            // No need to wrap as a promise here since `for await...of` can handle
-            // both Promises and non-Promise values.
-            yield element;
-        }
-    }
-    /**
-     * Ensures that the constructor of this object instance's name
-     * is returned if the string tag for this instance is queried
-     *
-     * @returns {string} the name of the class
-     */
-    get [Symbol.toStringTag]() {
-        return this.constructor.name;
-    }
-    /**
-     * Checks if a given value is an async iterable. This method determines if
-     * the provided value has a `Symbol.asyncIterator` property that is an async
-     * generator function. It's a precise way to identify if the value conforms
-     * to the async iterable protocol using an async generator function.
-     *
-     * Note: This method specifically checks for async generator functions. Some
-     * async iterables might use regular async functions that return an async
-     * iterator, which this method won't identify.
-     *
-     * @param {*} value - The value to be checked for async iterability.
-     * @returns {boolean} - Returns true if the value is an async iterable
-     * implemented using an async generator function, false otherwise.
-     */
-    static isAsyncIterable(value) {
-        const type = Object.prototype.toString.call(value?.[Symbol.asyncIterator]);
-        return type === '[object AsyncGeneratorFunction]';
-    }
-}
-exports.AsyncIterable = AsyncIterable;
-/**
- * Being able to create a compliant `AsyncIterator` around any type of
- * iterable object. This can be wrapped around any type of object that
- * has a `[Symbol.asyncIterator]` property assigned to a generator
- * function.
- */
-class AsyncIterator {
-    /**
-     * Creates a new `AsyncIterator` object instance.
-     *
-     * @param {object|AsyncGeneratorFunction} asyncIterable any object that has a
-     * `[Symbol.asyncIterable]` property assigned to a generator function or an
-     * async generator function itself.
-     */
-    constructor(asyncIterable) {
-        if (typeof asyncIterable === 'function' &&
-            asyncIterable.constructor.name === 'AsyncGeneratorFunction') {
-            this.#asyncIterable = asyncIterable();
-        }
-        else if (!asyncIterable ||
-            !Reflect.has(asyncIterable, Symbol.asyncIterator)) {
-            throw new TypeError('Value used to instantiate AsyncIterator is not an async iterable');
-        }
-        else {
-            this.#asyncIterable = asyncIterable;
-        }
-        this.#asyncIterator = this.#asyncIterable[Symbol.asyncIterator]();
-    }
-    /**
-     * Returns a new `Array` derived from the iterable this object
-     * wraps.
-     *
-     * @returns {array} a new `Array` generated from the wrapped
-     * iterable. The method is generated from using an async for of
-     * loop.
-     */
-    async asArray() {
-        const array = [];
-        for await (const value of this) {
-            array.push(value);
-        }
-        return array;
-    }
-    /**
-     * Returns the actual iterable object passed to the constructor that
-     * created this instance.
-     *
-     * @returns {object} the object containing the `[Symbol.iterator]`
-     */
-    get asyncIterable() {
-        return this.#asyncIterable;
-    }
-    /**
-     * The function retrieves the next value in the iterator. If the
-     * the iterator has run its course, `reset()` can be invoked to
-     * reset the pointer to the beginning of the iteration.
-     *
-     * @returns {any} the next value
-     */
-    async next() {
-        const result = await this.#asyncIterator.next();
-        if (result.done) {
-            return { value: undefined, done: true };
-        }
-        else {
-            return { value: result.value, done: false };
-        }
-    }
-    /**
-     * Resets the async iterator to the beginning allowing it to be
-     * iterated over again.
-     */
-    async reset() {
-        this.#asyncIterator = this.#asyncIterable[Symbol.asyncIterator]();
-    }
-    /**
-     * The existence of this symbol on the object instances, indicates that
-     * it can be used in `for(.. of ..)` loops and its values can be
-     * extracted from calls to `Array.from()`
-     *
-     * @returns {AsyncIterable} this is returned since this object is already
-     * conforming to the expected JavaScript AsyncIterator interface
-     */
-    [Symbol.asyncIterator]() {
-        return this;
-    }
-    /**
-     * Ensures that the constructor of this object instance's name
-     * is returned if the string tag for this instance is queried
-     *
-     * @returns {string} the name of the class
-     */
-    get [Symbol.toStringTag]() {
-        return this.constructor.name;
-    }
-    /**
-     * The object from which its iterator functionality is derived.
-     *
-     * @type {object}
-     * @private
-     */
-    #asyncIterable = null;
-    /**
-     * The results of a call to the iterable's `[Symbol.asyncIterator]`
-     * generator function.
-     *
-     * @type {object}
-     * @private
-     */
-    #asyncIterator = null;
-}
-exports.AsyncIterator = AsyncIterator;
-exports.AsyncIterableExtensions = new extension_1.Extension(AsyncIterable);
-exports.AsyncIteratorExtensions = new extension_1.Extension(AsyncIterator);
-//# sourceMappingURL=asyncIterable.js.map

package/dist/cjs/classes/asyncIterable.js.map

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

package/dist/cjs/classes/deferred.d.ts

@@ -1,146 +0,0 @@
-/**
- * Deferreds, which were first introduced by jQuery for browsers in the early
- * 2000s, are a way to manage asynchronous operations. They have been widely
- * used and replicated by engineers since then. Although the Promise class in
- * modern JavaScript provides a static method called `withResolvers` that
- * returns an object with similar properties to a Deferred, it is not directly
- * supported by Node.js.
- *
- * ```
- * const withResolvers = Promise.withResolvers()
- * Reflect.has(withResolvers, 'promise') // true
- * Reflect.has(withResolvers, 'resolve') // true
- * Reflect.has(withResolvers, 'reject')  // true
- * ```
- *
- * This Deferred class extends the Promise class, allowing it to capture the
- * value or reason for easy access after resolution, akin to
- * {@link Promise.withResolvers}. As it extends {@link Promise}, it is
- * 'thenable' and works with `await` as if it were a native Promise. This
- * allows seamless integration with code expecting Promise-like objects.
- */
-export class Deferred extends Promise<any> {
-    /**
-     * A getter for the species symbol which returns a custom DeferredPromise
-     * class. This class extends from Deferred and is used to ensure that the
-     * constructor signature matches that of a Promise. The executor function
-     * passed to the constructor of this class is used to initialize the Deferred
-     * object with resolve and reject functions, similar to how a Promise would
-     * be initialized.
-     *
-     * @returns {DeferredPromise} A DeferredPromise class that extends Deferred.
-     */
-    static get [Symbol.species](): DeferredPromise;
-    /**
-     * The constructor for Deferred instances. By default, a new Deferred will
-     * have three important properties: `promise`, `resolve`, and `reject`.
-     *
-     * The constructor takes an object called `options`. It can have the
-     * following properties:
-     *
-     * ```
-     * interface BaseDeferredOptions {
-     *   // Deferreds store the value or reason. To turn this off, pass true
-     *   // to this option.
-     *   doNotTrackAnswers?: boolean;
-     * }
-     *
-     * interface ResolveDeferredOptions {
-     *   // Passing in an option object with a resolve value will auto resolve
-     *   // the Deferred with your value. An error will be raised if both
-     *   // resolve and reject are supplied at the same time.
-     *   resolve?: (value: any) => void;
-     * }
-     *
-     * interface RejectDeferredOptions {
-     *   // Passing in an option object with a reject reason will auto reject
-     *   // the Deferred with your reason. An error will be raised if both
-     *   // resolve and reject are supplied at the same time.
-     *   reject?: (reason: any) => void;
-     * }
-     *
-     * type DeferredOptions = BaseDeferredOptions &
-     *   (ResolveDeferredOptions | RejectDeferredOptions)
-     * ```
-     *
-     * @param {object} options see above for examples on supported options, but
-     * when supplied, the constructor can take instructions on how to auto
-     * resolve or reject the deferred created here.
-     */
-    constructor(options: object);
-    /**
-     * When the Deferred is settled with {@link Deferred.resolve}, the `value`
-     * passed to that function will be set here as well.
-     *
-     * @type {*}
-     */
-    value: any;
-    /**
-     * When the Deferred is settled with {@link Deferred.reject}, the `reason`
-     * passed to that rejection will also be stored here.
-     *
-     * @type {*}
-     */
-    reason: any;
-    /**
-     * Returns a boolean value that indicates whether or not this Deferred
-     * has been settled (either resolve or reject have been invoked).
-     *
-     * @returns {boolean} `true` if either {@link Deferred.resolve} or
-     * {@link Deferred.reject} have been invoked; `false` otherwise
-     */
-    get settled(): boolean;
-    /**
-     * A getter that returns a boolean indicating whether the Deferred instance
-     * was rejected. This property can be used to check if the Deferred has been
-     * settled with a rejection. It is particularly useful in scenarios where
-     * the resolution status of the Deferred needs to be checked without
-     * accessing the rejection reason or invoking any additional logic.
-     *
-     * @returns {boolean} `true` if the Deferred was rejected, otherwise `false`.
-     */
-    get wasRejected(): boolean;
-    /**
-     * A getter that returns a boolean indicating whether the Deferred instance
-     * was resolved. This property is useful for checking if the Deferred has been
-     * settled with a resolution, allowing for checks on the Deferred's status
-     * without needing to access the resolved value or trigger any additional
-     * logic.
-     *
-     * @returns {boolean} `true` if the Deferred was resolved, otherwise `false`.
-     */
-    get wasResolved(): boolean;
-    /**
-     * Accessor for the promise managed by this Deferred instance.
-     *
-     * This getter provides access to the internal promise which is controlled
-     * by the Deferred's resolve and reject methods. It allows external code to
-     * attach callbacks for the resolution or rejection of the Deferred without
-     * the ability to directly resolve or reject it.
-     *
-     * @returns {Promise} The promise controlled by this Deferred instance.
-     */
-    get promise(): Promise<any>;
-    /**
-     * Resolves the Deferred with the given value. If the value is a thenable
-     * (i.e., has a "then" method), the Deferred will "follow" that thenable,
-     * adopting its eventual state; otherwise, the Deferred will be fulfilled
-     * with the value. This function behaves the same as Promise.resolve.
-     *
-     * @param {*} value - The value to resolve the Deferred with.
-     * @returns {Promise} A Promise that is resolved with the given value.
-     */
-    resolve(value: any): Promise<any>;
-    /**
-     * Rejects the Deferred with the given reason. This function behaves the
-     * same as Promise.reject. The Deferred will be rejected with the provided
-     * reason.
-     *
-     * @param {*} reason - The reason to reject the Deferred with.
-     * @returns {Promise} A Promise that is rejected with the given reason.
-     */
-    reject(reason: any): Promise<any>;
-    #private;
-}
-export const DeferredExtension: Extension;
-import { Extension } from '@nejs/extension';