atomic-fns 1.1.7 → 2.0.0

package/dist/collections/frozenset.js

@@ -1,30 +0,0 @@
-/**
- * Returns a new immutable Set object with elements from `iterable`. Its contents cannot be altered after it's created.
- *
- *
- * @class FrozenSet
- * @extends {Set<T>}
- * @template T
- */
-export class FrozenSet extends Set {
-    constructor(iterable) {
-        super(iterable);
-        return this.freeze();
-    }
-    /** @private */
-    add() {
-        return this;
-    }
-    /** @private */
-    delete() {
-        return false;
-    }
-    /** @private */
-    clear() {
-        return this;
-    }
-    /** @private */
-    freeze() {
-        return Object.freeze(this);
-    }
-}

package/dist/functools/index.d.ts

@@ -1,130 +0,0 @@
-/**
- * This module includes functions that promote a more functional programming style.
- *
- * @module functools
- */
-import { Function } from '../globals/index.js';
-/**
- * Creates a function that invokes `fn` with the this binding of `thisArg` and `partials` as partially applied arguments.
- * @param {Function} fn The function to bind.
- * @param {*} thisArg The `this` value of `fn`.
- * @param {...*} [partials] The arguments to prepend to `fn`.
- * @returns {Function} Returns the new bound function.
- * @see {@link partial}
- */
-export declare function bind(fn: Function, thisArg: any, ...partials: any[]): Function;
-/**
- * Creates a function that accepts arguments of `func` and either invokes `func` returning its result, if at least arity number of arguments have been provided, or returns a function that accepts the remaining `func` arguments, and so on. The arity of `func` may be specified if `func.length` is not sufficient.
- * @param {Function} func The function to curry.
- * @returns Returns the new curried function.
- */
-export declare function curry(func: Function): Function<ReturnType<typeof func>>;
-/**
- * Creates a function that invokes `fn` with partials prepended to the arguments it receives.
- * **Note:** The given function will have `this` bound to `undefined`. If using `this` inside `fn`, consider {@link bind} instead.
- * @param {Function} fn The function to bind.
- * @param {...*} [args] The arguments to apply to `fn`.
- * @returns {Function} Returns the new partially applied function
- */
-export declare function partial(fn: Function, ...args: any[]): Function<ReturnType<typeof fn>>;
-/**
- * Creates a function composition from a given set of functions that will be each applied on the result of the previous one from left to right.
- * @param {...*} [args] The set of functions to apply.
- * @returns {Function} A new function that applies each given function on the result of the previous one.
- */
-export declare function flow(...args: Function[]): Function;
-/**
- * This is just an alias for the {@link flow} function.
- * @see {@link flow}
- */
-export declare const pipe: typeof flow;
-/**
- * Creates a function composition from a given set of functions that will be each applied on the result of the previous one from right to left.
- * @param {...*} [args] The set of functions to apply.
- * @returns {Function} A new function that applies each given function on the result of the previous step.
- */
-export declare function compose(...args: Function[]): Function;
-/**
- * Creates a function that memoizes the result of `func`. If `resolver` is provided, it determines the cache key for storing the result based on the arguments provided to the memoized function. By default, the first argument provided to the memoized function is used as the map cache key.
- *
- * @param {Function} func The function to have its output memoized.
- * @param {Function} [resolver] The function to resolve the cache key.
- * @return {Function} Returns the new memoized function.
- */
-export declare function memoize<T>(func: Function<T>, resolver?: Function): Function<T>;
-/**
- * Can be used as a decorator on any function or method to memoize its results.
- * **NOTE:** By default the given function is memoized using it's first argument, regardless of others.
- * @param target
- * @param name
- * @param descriptor
- * @returns A memoized version of the given function
- */
-export declare function cache(target: any, name: any, descriptor: any): any;
-/**
- * Creates a debounced function that delays invoking `func` until after `wait` milliseconds have elapsed since the last time the debounced function was invoked. Subsequent calls to the debounced function return the result of the last successful invocation. Provide options to set the `maxWait` milliseconds, regardless of when the function was last invoked.
- *
- * @param {Function} func The function to debounce.
- * @param {number} wait The number of milliseconds to delay.
- * @param {{ maxWait: number }} [opts] The maximum time `func` is allowed to be delayed before it's invoked.
- * @returns Returns the new debounced function.
- */
-export declare function debounce(func: Function, wait: number, { maxWait }?: {
-    maxWait?: number;
-}): Function;
-/**
- * Creates a throttled function that only invokes `func` at most once per every `wait` milliseconds. Subsequent calls to the throttled function return the result of the last successful invocation.
- *
- * @param {Function} func The function to throttle.
- * @param {number} wait The number of milliseconds to throttle invocations to.
- * @return {Function} Returns the new throttled function.
- */
-export declare function throttle(func: Function, wait: number): Function;
-/**
- * Creates a function that is restricted to invoking `func` once. Repeat calls to the function return the value of the first invocation. The `func` is invoked with the arguments of the created function.
- *
- * @param {Function} func The function to restrict
- * @returns {Function} Returns the new restricted function.
- * @example
-```js
-let func = x => x
-let single = once(func)
-single(1) // 1
-single(2) // 1
-single(3) // 1
-// ...
-// `func` is invoked only once.
-```
- */
-export declare function once<T>(func: Function<T>): Function<T>;
-export declare type Maybe<T> = T | undefined;
-export declare type Result<T, E = any> = [Maybe<T>, Maybe<E>];
-export declare type Optional<T> = Maybe<T>;
-/**
- * Wraps a function to catch any exceptions inside and return a {@link Result} tuple with the value and error, if any.
- * @template T,E
- * @param {Function<T>} fn The function to wrap.
- * @returns {Function} A new function that wraps `fn` and returns the result tuple.
- */
-export declare function result<T = any, E = unknown>(fn: Function<T>): Function<Result<T, E>>;
-/**
- * Wraps an async function to catch any exceptions inside and return a {@link Result} tuple with the value and error, if any.
- * @template T,E
- * @param {Function<Promise<T>>} fn The async function to await.
- * @returns {Function<Promise<Result<T, E>>>} A new function that awaits the given function and returns the result tuple.
- */
-export declare function resultAsync<T = any, E = unknown>(fn: Function<Promise<T>>): Function<Promise<Result<T, E>>>;
-/**
- * Converts a function that expects a node-style callback argument like `(err, result)` to return a `Promise` instead.
- * @template T
- * @param {Function<T>} fun The given function to convert from callback style to `Promise`.
- * @param {*} thisArg
- * @returns {Function<Promise<T>>} A function that wraps `fun` and returns a `Promise`.
- */
-export declare function promisify<T>(fun: Function, thisArg?: any): Function<Promise<T>>;
-/**
- * Invokes a given function that accepts callback arguments for success, error and returns a `Promise` of the results.
- * @param {Function} fn A function that accepts callback arguments for success, error.
- * @returns {Promise<T>} A `Promise` that will be resolved when `successCallback` is called or rejected when `errorCallback` is called.
- */
-export declare function callAsync<T = any>(fn: (successCallback: (data: T) => any, errorCallback: Function) => any): Promise<T>;

package/dist/functools/index.js

@@ -1,235 +0,0 @@
-/**
- * This module includes functions that promote a more functional programming style.
- *
- * @module functools
- */
-/**
- * Creates a function that invokes `fn` with the this binding of `thisArg` and `partials` as partially applied arguments.
- * @param {Function} fn The function to bind.
- * @param {*} thisArg The `this` value of `fn`.
- * @param {...*} [partials] The arguments to prepend to `fn`.
- * @returns {Function} Returns the new bound function.
- * @see {@link partial}
- */
-export function bind(fn, thisArg, ...partials) {
-    return fn.bind(thisArg, ...partials);
-}
-/**
- * Creates a function that accepts arguments of `func` and either invokes `func` returning its result, if at least arity number of arguments have been provided, or returns a function that accepts the remaining `func` arguments, and so on. The arity of `func` may be specified if `func.length` is not sufficient.
- * @param {Function} func The function to curry.
- * @returns Returns the new curried function.
- */
-export function curry(func) {
-    return function curried(...args) {
-        if (args.length >= func.length) {
-            return func.apply(this, args);
-        }
-        return (...args2) => {
-            return curried.apply(this, args.concat(args2));
-        };
-    };
-}
-/**
- * Creates a function that invokes `fn` with partials prepended to the arguments it receives.
- * **Note:** The given function will have `this` bound to `undefined`. If using `this` inside `fn`, consider {@link bind} instead.
- * @param {Function} fn The function to bind.
- * @param {...*} [args] The arguments to apply to `fn`.
- * @returns {Function} Returns the new partially applied function
- */
-export function partial(fn, ...args) {
-    return bind(fn, undefined, ...args);
-}
-/**
- * Creates a function composition from a given set of functions that will be each applied on the result of the previous one from left to right.
- * @param {...*} [args] The set of functions to apply.
- * @returns {Function} A new function that applies each given function on the result of the previous one.
- */
-export function flow(...args) {
-    return (x) => {
-        for (const fn of args) {
-            x = fn(x);
-        }
-        return x;
-    };
-}
-/**
- * This is just an alias for the {@link flow} function.
- * @see {@link flow}
- */
-export const pipe = flow;
-/**
- * Creates a function composition from a given set of functions that will be each applied on the result of the previous one from right to left.
- * @param {...*} [args] The set of functions to apply.
- * @returns {Function} A new function that applies each given function on the result of the previous step.
- */
-export function compose(...args) {
-    return flow(...args.reverse());
-}
-/**
- * Creates a function that memoizes the result of `func`. If `resolver` is provided, it determines the cache key for storing the result based on the arguments provided to the memoized function. By default, the first argument provided to the memoized function is used as the map cache key.
- *
- * @param {Function} func The function to have its output memoized.
- * @param {Function} [resolver] The function to resolve the cache key.
- * @return {Function} Returns the new memoized function.
- */
-export function memoize(func, resolver) {
-    const cache = new Map();
-    return (...args) => {
-        const key = resolver ? resolver(...args) : args[0];
-        const prev = cache.get(key);
-        if (prev !== undefined)
-            return prev;
-        const value = func(...args);
-        cache.set(key, value);
-        return value;
-    };
-}
-/**
- * Can be used as a decorator on any function or method to memoize its results.
- * **NOTE:** By default the given function is memoized using it's first argument, regardless of others.
- * @param target
- * @param name
- * @param descriptor
- * @returns A memoized version of the given function
- */
-export function cache(target, name, descriptor) {
-    const original = descriptor.value;
-    if (typeof original === 'function') {
-        descriptor.value = memoize(original);
-    }
-    return descriptor;
-}
-/**
- * Creates a debounced function that delays invoking `func` until after `wait` milliseconds have elapsed since the last time the debounced function was invoked. Subsequent calls to the debounced function return the result of the last successful invocation. Provide options to set the `maxWait` milliseconds, regardless of when the function was last invoked.
- *
- * @param {Function} func The function to debounce.
- * @param {number} wait The number of milliseconds to delay.
- * @param {{ maxWait: number }} [opts] The maximum time `func` is allowed to be delayed before it's invoked.
- * @returns Returns the new debounced function.
- */
-export function debounce(func, wait, { maxWait } = {}) {
-    let timer, maxTimer, lastResult;
-    return (...args) => {
-        if (timer)
-            clearTimeout(timer);
-        timer = setTimeout(() => {
-            clearTimeout(maxTimer);
-            maxTimer = null;
-            lastResult = func(...args);
-        }, wait);
-        if (maxWait && !maxTimer) {
-            maxTimer = setTimeout(() => {
-                clearTimeout(timer);
-                maxTimer = null;
-                lastResult = func(...args);
-            }, maxWait);
-        }
-        return lastResult;
-    };
-}
-/**
- * Creates a throttled function that only invokes `func` at most once per every `wait` milliseconds. Subsequent calls to the throttled function return the result of the last successful invocation.
- *
- * @param {Function} func The function to throttle.
- * @param {number} wait The number of milliseconds to throttle invocations to.
- * @return {Function} Returns the new throttled function.
- */
-export function throttle(func, wait) {
-    let pending = false;
-    return (...args) => {
-        if (pending)
-            return;
-        func(...args);
-        pending = true;
-        setTimeout(() => {
-            pending = false;
-        }, wait);
-    };
-}
-/**
- * Creates a function that is restricted to invoking `func` once. Repeat calls to the function return the value of the first invocation. The `func` is invoked with the arguments of the created function.
- *
- * @param {Function} func The function to restrict
- * @returns {Function} Returns the new restricted function.
- * @example
-```js
-let func = x => x
-let single = once(func)
-single(1) // 1
-single(2) // 1
-single(3) // 1
-// ...
-// `func` is invoked only once.
-```
- */
-export function once(func) {
-    let result, isCalled;
-    return (...args) => {
-        if (!isCalled) {
-            result = func(...args);
-            isCalled = true;
-        }
-        return result;
-    };
-}
-/**
- * Wraps a function to catch any exceptions inside and return a {@link Result} tuple with the value and error, if any.
- * @template T,E
- * @param {Function<T>} fn The function to wrap.
- * @returns {Function} A new function that wraps `fn` and returns the result tuple.
- */
-export function result(fn) {
-    return (...args) => {
-        let value, err;
-        try {
-            value = fn(...args);
-        }
-        catch (error) {
-            err = error;
-        }
-        return [value, err];
-    };
-}
-/**
- * Wraps an async function to catch any exceptions inside and return a {@link Result} tuple with the value and error, if any.
- * @template T,E
- * @param {Function<Promise<T>>} fn The async function to await.
- * @returns {Function<Promise<Result<T, E>>>} A new function that awaits the given function and returns the result tuple.
- */
-export function resultAsync(fn) {
-    return async (...args) => {
-        let value, err;
-        try {
-            value = await fn(...args);
-        }
-        catch (error) {
-            err = error;
-        }
-        return [value, err];
-    };
-}
-/**
- * Converts a function that expects a node-style callback argument like `(err, result)` to return a `Promise` instead.
- * @template T
- * @param {Function<T>} fun The given function to convert from callback style to `Promise`.
- * @param {*} thisArg
- * @returns {Function<Promise<T>>} A function that wraps `fun` and returns a `Promise`.
- */
-export function promisify(fun, thisArg) {
-    const original = thisArg ? fun.bind(thisArg) : fun;
-    return async (...args) => {
-        return await new Promise((resolve, reject) => original(...args, (err, result) => {
-            if (err)
-                return reject(err);
-            resolve(result);
-        }));
-    };
-}
-/**
- * Invokes a given function that accepts callback arguments for success, error and returns a `Promise` of the results.
- * @param {Function} fn A function that accepts callback arguments for success, error.
- * @returns {Promise<T>} A `Promise` that will be resolved when `successCallback` is called or rejected when `errorCallback` is called.
- */
-export async function callAsync(fn) {
-    return await new Promise(fn);
-}

package/dist/globals/index.d.ts

@@ -1,285 +0,0 @@
-/**
- * This module includes global functions and constants.
- *
- * @module globals
- */
-/**
- * A generic function type with arbitrary arguments and return.
- */
-export declare type Function<TReturn = any> = (...args: any) => TReturn;
-/** This is just a noop function. */
-export declare function noop(): void;
-/** A function that always returns `true`. */
-export declare const True: () => boolean;
-/** A function that always returns `false`. */
-export declare const False: () => boolean;
-/**
- * A custom error class that inherits from the Error object.
- * @class CustomError
- * @extends {Error}
- */
-export declare class CustomError extends Error {
-    /**
-     * Returns a new CustomError with the specified message.
-     * @param {string} message
-     * @constructor
-     */
-    constructor(message?: string);
-}
-/**
- * Custom error to signal an invalid index access.
- * @extends {CustomError}
- */
-export declare class IndexError extends CustomError {
-}
-/**
- * Raised when a system function returns an I/O failure such as "file not found"
- * or "disk full".
- * @extends {CustomError}
- */
-export declare class IOError extends CustomError {
-}
-/**
- * Custom error to signal an invalid key access.
- * @extends {CustomError}
- */
-export declare class KeyError extends CustomError {
-}
-/**
- * Custom error to signal an invalid operation.
- * @extends {CustomError}
- */
-export declare class NotImplementedError extends CustomError {
-}
-/**
- * Custom error to signal an invalid value.
- * @extends {CustomError}
- */
-export declare class ValueError extends CustomError {
-}
-/**
- * Raised when the second argument of a division or modulo operation is zero.
- * @extends {CustomError}
- */
-export declare class ZeroDivisionError extends CustomError {
-}
-/**
- * Returns the true type of any value with correct detection for `null`, `Array`,
- * `Object`, `Promise`, `Symbol`, and `NaN`. The correct values are inferred from {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/toStringTag | Symbol.toStringTag} and the value's prototype.
- * @param value
- * @returns The value type.
- */
-export declare function type(value: any): string;
-/**
- * Returns a string representing the object.
- * @param obj
- * @returns `obj.toString()` or `''` if `obj` is `null` or `undefined`.
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/toString | Object.toString }
- */
-export declare function str(obj: any): string;
-/** Check if value is a boolean type. */
-export declare function isBool(x: any): x is boolean;
-/** Check if value is an `Error` type. */
-export declare function isError(x: any): x is Error;
-/** Check if value is an iterable type. */
-export declare function isIterable(x: any): x is IterableIterator<any>;
-/** Check if value is a native `Date` type. */
-export declare function isDate(x: any): x is Date;
-/** Check if value is an object type. */
-export declare function isObject(x: any): x is Object;
-/** Check if value is a string type. */
-export declare function isString(x: any): x is string;
-/** Check if value is an Array type. */
-export declare function isArray(x: any): x is any[];
-/**
- * Check if value is Array-like type.
- * A value is considered array-like if it's not a function and has a `.length` number property.
- */
-export declare function isArrayLike(x: any): boolean;
-/** Check if value is a number type. */
-export declare function isNumber(x: any): x is number;
-/** Check if value is an integer number type. */
-export declare function isInteger(x: any): x is number;
-/** Check if value is a bigint type. */
-export declare function isBigint(x: any): x is BigInt;
-/** Check if value is a Promise type. */
-export declare function isPromise(x: any): x is Promise<any>;
-/** Check if value is a function type. */
-export declare function isFunction(x: any): x is Function;
-/** Check if value is an async function type. */
-export declare function isAsyncFunction(x: any): boolean;
-/** Check if value is a generator function type. */
-export declare function isGenerator(x: any): x is Generator;
-/** Check if value is `null` or `undefined`. */
-export declare function isNull(x: any): x is null | undefined;
-/** Check if value === `undefined`. */
-export declare function isUndefined(x: any): x is undefined;
-/** Check if value is not `null` or `undefined`. */
-export declare function notNull(x: any): boolean;
-/** Returns `true` for objects without length or falsy values. */
-export declare function isEmpty(x: any): boolean;
-/** Check if value is a `RegExp` type */
-export declare function isRegExp(x: any): x is RegExp;
-/** Check if value is a `Symbol` type */
-export declare function isSymbol(x: any): x is symbol;
-/** Check if value is a `Set` type. */
-export declare function isSet<T>(x: any): x is Set<T>;
-/** Check if value is a `Map` type. */
-export declare function isMap<K, V>(x: any): x is Map<K, V>;
-/** Check if value is a `WeakSet` type. */
-export declare function isWeakSet<T extends object>(x: any): x is WeakSet<T>;
-/** Check if value is a `WeakMap` type. */
-export declare function isWeakMap<K extends object, V>(x: any): x is WeakMap<K, V>;
-/**
- * Returns the number of elements in a collection type.
- *
- * If `value.length` or `value.size()` is defined, this will be returned.
- * If `value` is an `Object`, it returns the number of keys.
- * @param value
- * @returns The number of elements in the collection or `undefined`.
- */
-export declare function len(value: any): number;
-/**
- * Generates a unique ID using random numbers. If a prefix is given, the ID is appended to it and returned as a string.
- * @param {string} [pre=''] The id prefix.
- * @returns {number|string} Returns the numeric or string ID.
- * @example
-```js
-uniqueId()
-// 3445556877
-
-uniqueId('user_')
-// 'user_1033763188'
-```
- */
-export declare function uniqueId(pre?: string): string;
-/**
- * Generates a monotonically increasing, pseudo-random based uuid-v4 string. These are sortable, url-friendly and are 100% unique if the IDs are generated more than 1 millisecond apart. If two IDs are generated at the same millisecond, the chance of collision is still pretty low (1 in 10^15).
- * @returns Returns a GUID formatted string.
- * @example
-```js
-uuid()
-// '183f8ef3-b8f0-4000-81f5-89234c836d00'
-```
- */
-export declare function uuid(): string;
-/**
- * Checks if `obj.key` is a function, and calls it with any given `args`.
- * @param {*} obj
- * @param {PropertyKey} key
- * @param {...any[]} args
- * @return `obj.key(...args)` or `undefined`.
- */
-export declare function call<T = any>(obj: any, key: PropertyKey, ...args: any[]): T;
-/** Convert number to unicode character */
-export declare function chr(x: number): string;
-/** Convert character to Unicode code point */
-export declare function ord(x: string): number;
-/**
- * Returns an array of the own enumerable property names of `object`.
- * @param object The given object.
- * @returns The array of object keys.
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys Object.keys()}
- */
-export declare function keys<T>(object: T): Array<keyof T>;
-/**
- * Returns an array of the own enumerable property values of `object`.
- * @param object The given object.
- * @returns The array of object keys.
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/values Object.values()}
- */
-export declare function values<T = any>(object: any): T[];
-/**
- * Check if a given property is present in a given object.
- * @param obj The object to check.
- * @param attr A property key name.
- * @returns `true` if the object has the property name.
- */
-export declare function has(obj: any, attr: PropertyKey): boolean;
-/**
- * Check if the attribute is present in the object or return a default value instead.
- * @param {PropertyKey} key
- * @param {*} obj
- * @param {*} [value=undefined]
- * @return The property value or default value.
- */
-export declare function get<T>(key: PropertyKey, obj: T, value?: any): any;
-export declare function get<T>(key: PropertyKey[], obj: T, value?: any): any;
-/**
- * Deletes a given property key from an object.
- * @param attr The property name.
- * @param x The given object.
- * @returns The modified object.
- */
-export declare function del<T>(attr: PropertyKey, x: T): T;
-/**
- * Adds a property to an object, or modifies the existing value.
- * @param attr The name or Symbol of the property to be defined or modified.
- * @param obj The container object.
- * @param value The value associated with the property
- * @param {boolean} [writable=false] If `true` the value may be changed later. Defaults to `false`.
- * @param {boolean} [enumerable=false] If `true` this property shows up during enumeration of the properties in the object. Defaults to `false`.
- * @returns
- */
-export declare function set(attr: PropertyKey, obj: any, value: any, writable?: boolean, enumerable?: boolean): any;
-export declare const HASH_KEY: unique symbol;
-/**
- * Return a hash value for a given object. The hash will be the same for subsequent invocations.
- * @param obj The given object.
- * @returns The hash value.
- */
-export declare function hash(obj: string): number;
-export declare function hash<T>(obj: T): T;
-/**
- * A hash value generator for strings.
- * @param {string} str The given string.
- * @returns {number} The hash value of the string.
- * @see {@link http://isthe.com/chongo/tech/comp/fnv/ FNV hash}
- */
-export declare function hashCode(str: string): number;
-/**
- * Converts a number to a binary string.
- * @param n The given number.
- * @returns The binary string representation of `n`.
- */
-export declare function bin(n: number): string;
-/**
- * Converts a number to a hexadecimal string.
- * @param n The given number.
- * @returns The hexadecimal string representation of `n`.
- */
-export declare function hex(n: number): string;
-/**
- * Converts a number to an octal string.
- * @param n The given number.
- * @returns The octal string representation of `n`.
- */
-export declare function oct(n: number): string;
-/**
- * Returns a floating point number constructed from a number or string `x`.
- * @param x The number or string.
- * @returns A floating point number parsed from the given value or `NaN`.
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/parseFloat parseFloat}
- */
-export declare function float(x: string): number;
-/**
- * Returns an integer number constructed from a number or string `x`.
- * @param x The number or string.
- * @returns An integer number parsed from the given value or `NaN`.
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/parseInt parseInt}
- */
-export declare function int(x: string, base?: number): number;
-/**
- * Converts the value to an array using `Array.from()`.
- * @param value
- * @returns A new array value.
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from Array.from()}
- */
-export declare function list<T>(value?: any): T[];
-/**
- * Retrieve the next item from the iterator by calling its `next()` method.
- * @param iter The iterator.
- * @returns The next value from the iterator.
- */
-export declare function next<T>(iter: Iterator<T>): T | undefined;
-export declare function next<T>(iter: Generator<any, T>): T | undefined;