atomic-fns 0.3.4 → 0.4.2

package/{core → dist}/collections/deque.js

@@ -4,36 +4,39 @@ import { eq } from '../operators/index.js';
 import { Sequence } from './abc.js';
 /**
  * Fixed capacity double-ended queue implemented as ring deque.
- *
- * @constructor
+ * @template T
  */
 export class Deque extends Sequence {
     items;
     start = 0;
     count = 0;
     capacity;
-    ArrayClass;
-    constructor(ArrayClass = [], capacity = 1024) {
+    ArrayConstructor;
+    /**
+     * Creates a new `Deque` instance of a fixed size.
+     * @param {Array} [arrType = []] The initial elements or array type to use (accepts any kind of typed array).
+     * @param {number} [capacity=1024] The fixed size of the deque. Defaults to `1024`.
+     */
+    constructor(arrType = [], capacity = 1024) {
         super();
         if (typeof capacity !== 'number' || capacity <= 0)
             throw new ValueError(`Deque capacity should be a positive integer.`);
-        this.ArrayClass = ArrayClass.constructor;
+        this.ArrayConstructor = arrType.constructor;
         this.capacity = capacity;
-        this.items = new this.ArrayClass(ArrayClass.length || this.capacity);
+        this.items = new this.ArrayConstructor(arrType.length || this.capacity);
         this.clear();
-        if (ArrayClass.length) {
-            for (const item of ArrayClass) {
+        if (arrType.length) {
+            for (const item of arrType) {
                 this.append(item);
             }
         }
     }
+    /** Returns the total number of elements in the deque. */
     get size() {
         return this.count;
     }
     /**
      * Method used to clear the structure.
-     *
-     * @return {undefined}
      */
     clear() {
         // Properties
@@ -42,18 +45,16 @@ export class Deque extends Sequence {
     }
     /**
      * Alias of {@link Deque.append}
-     *
-     * @param  {any}    item - Item to append.
-     * @return {number}      - Returns the new size of the deque.
+     * @param {T} item Item to append.
+     * @returns {number} Returns the new size of the deque.
      */
     add(item) {
         return this.append(item);
     }
     /**
-     * Method used to append a value to the deque.
-     *
-     * @param  {any}    item - Item to append.
-     * @return {number}      - Returns the new size of the deque.
+     * Appends a new element to the end of the deque.
+     * @param {T} item Item to append.
+     * @returns {number} Returns the new size of the deque.
      */
     append(item) {
         if (this.count === this.capacity)
@@ -63,10 +64,9 @@ export class Deque extends Sequence {
         return ++this.count;
     }
     /**
-     * Method used to prepend a value to the deque.
-     *
-     * @param  {any}    item - Item to prepend.
-     * @return {number}      - Returns the new size of the deque.
+     * Appends a new element to the beginning of the deque.
+     * @param {T} item Item to prepend.
+     * @returns {number} Returns the new size of the deque.
      */
     appendleft(item) {
         if (this.count === this.capacity)
@@ -79,9 +79,8 @@ export class Deque extends Sequence {
         return ++this.count;
     }
     /**
-     * Method used to pop the deque.
-     *
-     * @return {any} - Returns the popped item.
+     * Removes and returns the element at the end of the deque.
+     * @returns {?T} Returns the popped item.
      */
     pop() {
         if (this.count === 0)
@@ -92,14 +91,14 @@ export class Deque extends Sequence {
     }
     /**
      * Alias of {@link Deque.pop}
+     * @returns {?T} Returns the popped item.
      */
     remove() {
         return this.pop();
     }
     /**
-     * Method used to shift the deque.
-     *
-     * @return {any} - Returns the shifted item.
+     * Removes and returns the element at the beginning of the deque.
+     * @returns {?T} Returns the removed deque element.
      */
     popleft() {
         if (this.count === 0)
@@ -112,9 +111,8 @@ export class Deque extends Sequence {
         return this.items[index];
     }
     /**
-     * Method used to peek the first value of the deque.
-     *
-     * @return {any}
+     * Returns the element at the beginning of the deque.
+     * @returns {?T} The element if exists
      */
     first() {
         if (this.count === 0)
@@ -122,10 +120,9 @@ export class Deque extends Sequence {
         return this.items[this.start];
     }
     /**
-     * Method used to get the desired value of the deque.
-     *
-     * @param  {number} index
-     * @return {any}
+     * Returns the element at a specified index position in the deque.
+     * @param {number} index The given index
+     * @returns {?T} The element if exists
      */
     get(index) {
         if (this.count === 0)
@@ -138,9 +135,8 @@ export class Deque extends Sequence {
         return this.items[index];
     }
     /**
-     * Update the value at a given `index`.
-     * @param index The given index
-     * @param value The new value to set at `index`.
+     * Update the element at a given `index`.
+     * @param {number} index The given index
      */
     set(index, value) {
         if (index < 0)
@@ -149,6 +145,11 @@ export class Deque extends Sequence {
             throw new KeyError(`Invalid index: ${index} not in Deque.`);
         this.items[index] = value;
     }
+    /**
+     * Check if a given element is in the deque.
+     * @param {T} x The value to find
+     * @returns {boolean} `true` if the value is found
+     */
     contains(x) {
         for (const value of this.values()) {
             if (eq(x, value))
@@ -156,6 +157,11 @@ export class Deque extends Sequence {
         }
         return false;
     }
+    /**
+     * Returns the first element that matches the `iteratee` function.
+     * @param {Iteratee<T>} iteratee A function that will be invoked per element
+     * @returns {?T} The element if exists
+     */
     find(iteratee) {
         for (const [key, value] of this.entries()) {
             if (iteratee(value, key, this))
@@ -163,11 +169,8 @@ export class Deque extends Sequence {
         }
     }
     /**
-     * Method used to iterate over the deque.
-     *
-     * @param  {function}  iteratee - Function to call for each item.
-     * @param  {object}    scope    - Optional scope.
-     * @return {undefined}
+     * Calls `iteratee` function for every element in the deque.
+     * @param {Iteratee<T>} iteratee A function that will be invoked per element
      */
     forEach(iteratee) {
         const c = this.capacity;
@@ -182,20 +185,23 @@ export class Deque extends Sequence {
                 i = 0;
         }
     }
+    /**
+     * Returns a new array with all the elements in reverse order.
+     * @returns {Array<T>} The elements reversed
+     */
     reversed() {
         return this.toArray().reverse();
     }
     /**
-     * Method used to convert the deque to a JavaScript array.
-     *
-     * @return {array}
+     * Returns a new array with all the elements in the order they were added to the deque.
+     * @returns {Array<T>} The elements array
      */
     toArray() {
         // Optimization
         const offset = this.start + this.count;
         if (offset < this.capacity)
             return this.items.slice(this.start, offset);
-        const array = new this.ArrayClass(this.count);
+        const array = new this.ArrayConstructor(this.count);
         const c = this.capacity;
         const l = this.count;
         let i = this.start;
@@ -210,9 +216,8 @@ export class Deque extends Sequence {
         return array;
     }
     /**
-     * Method used to create an iterator over the deque's values.
-     *
-     * @return {Iterator}
+     * Returns an iterator over the deque's values.
+     * @returns {Iterator}
      */
     values() {
         const items = this.items;
@@ -236,13 +241,15 @@ export class Deque extends Sequence {
             };
         });
     }
+    /**
+     * Alias of {@link Deque.values}. Returns iterator of values.
+     */
     keys() {
         return this.values();
     }
     /**
-     * Method used to create an iterator over the deque's entries.
-     *
-     * @return {Iterator}
+     * Creates an iterator of `[index, value]` pairs for all elements in the deque.
+     * @returns {Iterator}
      */
     entries() {
         const items = this.items;
@@ -271,9 +278,10 @@ export class Deque extends Sequence {
     [Symbol.for('nodejs.util.inspect.custom')]() {
         return this.inspect();
     }
+    // This is just for debugging in nodejs
     inspect() {
         const array = this.toArray();
-        array.type = this.ArrayClass.name;
+        array.type = this.ArrayConstructor.name;
         array.capacity = this.capacity;
         // Trick so that node displays the name of the constructor
         Object.defineProperty(array, 'constructor', {

package/{core → dist}/collections/frozenset.js

@@ -13,18 +13,15 @@ export class FrozenSet extends Set {
     }
     /** @private */
     add() {
-        throw TypeError('FrozenSet cannot be modified.');
-        return this; // eslint-disable-line
+        return this;
     }
     /** @private */
     delete() {
-        throw TypeError('FrozenSet cannot be modified.');
-        return false; // eslint-disable-line
+        return false;
     }
     /** @private */
     clear() {
-        throw TypeError('FrozenSet cannot be modified.');
-        return this; // eslint-disable-line
+        return this;
     }
     /** @private */
     freeze() {

package/{core → dist}/collections/index.d.ts

@@ -38,7 +38,7 @@ export declare function count<T>(iterable: Iterable<T> | Object, func: Iteratee<
  * @param fields - A list of field names
  * @returns A function that can be called with the field values
  */
-export declare function namedtuple(...fields: string[]): (...args: any[]) => {};
+export declare function namedtuple(...fields: string[]): (...args: any[]) => any;
 /**
  * Iterates over elements of collection, returning an array of all elements where predicate returns truthy value.
  *
@@ -66,7 +66,7 @@ filter(users, 'active')
  * @param {Function} fn The predicate function invoked for each item
  * @returns {Array} The new filtered array
  */
-export declare function filter(arr: any, fn?: Iteratee | PropertyKey | Object): any[] | undefined;
+export declare function filter(arr: any, fn?: Iteratee | PropertyKey | Object): any[];
 /**
  * Iterates over elements of collection, returning the first element where predicate returns truthy value. The predicate is invoked with three arguments: `(value, index|key, collection)`.
  * @example
@@ -242,7 +242,7 @@ map(users, 'user')
  * @returns Returns the new mapped array.
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map Array.map()}
  */
-export declare function map(arr: any, fn: Iteratee | PropertyKey): any[] | undefined;
+export declare function map(arr: any, fn: Iteratee | PropertyKey): any[];
 /**
  * Creates an object composed of the picked object properties.
  * @param {Object} obj The source object.
@@ -309,7 +309,7 @@ index(users, 'active')
  * @see {@link lastIndex}
  *
  */
-export declare function index(obj: any, fn: Iteratee | string | Object, start?: number): number | undefined;
+export declare function index(obj: any, fn: Iteratee | string | Object, start?: number): number;
 /**
  * This method is like {@link index} except that it searches for a given value directly, instead of using a predicate function.
  * @param {Array} obj The array to inspect.

package/{core → dist}/functools/index.d.ts

@@ -12,7 +12,7 @@ import { Function } from '../globals/index.js';
  * @returns {Function} Returns the new bound function.
  * @see {@link partial}
  */
-export declare const bind: (fn: Function, thisArg: any, ...partials: any[]) => (...args: any[]) => any;
+export declare const bind: (fn: Function, thisArg: any, ...partials: any[]) => any;
 /**
  * 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.
@@ -27,7 +27,7 @@ export declare const curry: (func: Function, arity?: number) => Function<any>;
  * @param {...*} [args] The arguments to apply to `fn`.
  * @returns {Function} Returns the new partially applied function
  */
-export declare const partial: (fn: any, ...args: any[]) => (...args: any[]) => any;
+export declare const partial: (fn: any, ...args: any[]) => any;
 /**
  * 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.
@@ -48,6 +48,14 @@ export declare const compose: (...args: any[]) => (x: any) => any;
  * @return {Function} Returns the new memoized function.
  */
 export declare function memoize<T>(func: Function<T>, resolver?: Function): Function<ReturnType<typeof func>>;
+/**
+ * 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.
@@ -77,31 +85,38 @@ export declare function throttle(func: Function, wait: number): Function;
 ```js
 let func = x => x
 let single = once(func)
-single(1) // => 1
-single(2) // => 1
-single(3) // => 1
+single(1) // 1
+single(2) // 1
+single(3) // 1
 // ...
-// => `func` is invoked only once.
+// `func` is invoked only once.
 ```
  */
 export declare function once<T>(func: Function<T>): (...args: any[]) => 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 `go` style error-return type {@link Result}.
- *
+ * @template T,E
  * @param {Function} fun The function to wrap and catch if it throws.
- * @param {?function(err: E, res: T): *} [onFinally] Optional callback that will be called on the `finally` clause if given.
+ * @param {Function} [onFinally] Optional callback that will be invoked with `(err?, value)` on the `finally` clause.
  * @returns {Function} A new function that wraps `fun`.
- * @template T,E
  */
 export declare function result<T = any, E = unknown>(fun: Function<T>, onFinally?: (err: E, res: T) => any): (...args: any[]) => Result<T, E>;
 /**
  * Wraps a function or promise to catch any exceptions inside and return a `go` style error-return type. This is like {@link result} but it deals with async functions or promises.
- *
- * @param {Function|Promise} awaitable The function or promise to await.
- * @param {?function(err: E, res: T): *} [onFinally] Optional callback that will be called on the `finally` clause if given.
- * @returns {Function} A new function that awaits the `awaitable` param and returns a {@link Result} type.
  * @template T,E
+ * @param {Function<T>|Promise<T>} awaitable The function or promise to await.
+ * @param {Function} [onFinally] Optional callback that will be invoked with `(err?, value)` on the `finally` clause.
+ * @returns {Function<Promise<Result<T, E>>>} A new function that awaits the `awaitable` param and returns a {@link Result} type.
  */
 export declare function resultAsync<T = any, E = unknown>(awaitable: Promise<T> | Function<Promise<T>>, onFinally?: (err: E, res: T) => any): (...args: any[]) => 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 = any>(fun: Function<T>, thisArg: any): (...args: any[]) => Promise<T>;

package/{core → dist}/functools/index.js

@@ -89,7 +89,14 @@ export function memoize(func, resolver) {
         return value;
     };
 }
-// TODO: also sized lru_cache
+/**
+ * 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') {
@@ -153,11 +160,11 @@ export function throttle(func, wait) {
 ```js
 let func = x => x
 let single = once(func)
-single(1) // => 1
-single(2) // => 1
-single(3) // => 1
+single(1) // 1
+single(2) // 1
+single(3) // 1
 // ...
-// => `func` is invoked only once.
+// `func` is invoked only once.
 ```
  */
 export function once(func) {
@@ -172,11 +179,10 @@ export function once(func) {
 }
 /**
  * Wraps a function to catch any exceptions inside and return a `go` style error-return type {@link Result}.
- *
+ * @template T,E
  * @param {Function} fun The function to wrap and catch if it throws.
- * @param {?function(err: E, res: T): *} [onFinally] Optional callback that will be called on the `finally` clause if given.
+ * @param {Function} [onFinally] Optional callback that will be invoked with `(err?, value)` on the `finally` clause.
  * @returns {Function} A new function that wraps `fun`.
- * @template T,E
  */
 export function result(fun, onFinally) {
     return (...args) => {
@@ -195,11 +201,10 @@ export function result(fun, onFinally) {
 }
 /**
  * Wraps a function or promise to catch any exceptions inside and return a `go` style error-return type. This is like {@link result} but it deals with async functions or promises.
- *
- * @param {Function|Promise} awaitable The function or promise to await.
- * @param {?function(err: E, res: T): *} [onFinally] Optional callback that will be called on the `finally` clause if given.
- * @returns {Function} A new function that awaits the `awaitable` param and returns a {@link Result} type.
  * @template T,E
+ * @param {Function<T>|Promise<T>} awaitable The function or promise to await.
+ * @param {Function} [onFinally] Optional callback that will be invoked with `(err?, value)` on the `finally` clause.
+ * @returns {Function<Promise<Result<T, E>>>} A new function that awaits the `awaitable` param and returns a {@link Result} type.
  */
 export function resultAsync(awaitable, onFinally) {
     return async (...args) => {
@@ -217,3 +222,20 @@ export function resultAsync(awaitable, onFinally) {
         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 = fun.bind(thisArg);
+    return async (...args) => {
+        return await new Promise((resolve, reject) => original(...args, (err, result) => {
+            if (err)
+                return reject(err);
+            resolve(result);
+        }));
+    };
+}

package/{core → dist}/globals/index.d.ts

@@ -4,7 +4,7 @@
  * @module Globals
  */
 /** This is just a noop function. */
-export declare const _: () => void;
+export declare const noop: () => void;
 /**
  * A generic function type with arbitrary arguments and return.
  */
@@ -92,7 +92,6 @@ export declare function type(value: any): any;
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/toString | Object.toString }
  */
 export declare const str: (obj: any) => any;
-export declare function hasOwnProperty(obj: any, prop: any): boolean;
 /** Check if value is a boolean type. */
 export declare const isBool: (x: any) => x is boolean;
 /** Check if value is an `Error` type. */
@@ -118,8 +117,6 @@ export declare const isNumber: (x: any) => x is number;
 export declare const isInteger: (x: any) => x is number;
 /** Check if value is a bigint type. */
 export declare const isBigint: (x: any) => x is BigInt;
-/** Check if value is NaN based on `Number.isNaN`. */
-export declare const isNaN: (x: any) => x is number;
 /** Check if value is a Promise type. */
 export declare const isPromise: (x: any) => x is Promise<any>;
 /** Check if value is a function type. */
@@ -129,9 +126,9 @@ export declare const isAsyncFunction: (x: any) => boolean;
 /** Check if value is a generator function type. */
 export declare const isGenerator: (x: any) => x is Generator<unknown, any, unknown>;
 /** Check if value is `null` or `undefined`. */
-export declare const isNull: (x: any) => x is null | undefined;
+export declare const isNull: (x: any) => x is null;
 /** Check if value === `undefined`. */
-export declare function isUndefined(o: any): boolean;
+export declare const isUndefined: (x: any) => x is undefined;
 /** Check if value is not `null` or `undefined`. */
 export declare const notNull: (x: any) => boolean;
 /** Returns `true` for objects without length or falsy values. */
@@ -164,10 +161,10 @@ export declare function len(value: any): any;
  * @example
 ```js
 uniqueId()
-// => 3445556877
+// 3445556877
 
 uniqueId('user_')
-// => 'user_1033763188'
+// 'user_1033763188'
 ```
  */
 export declare const uniqueId: (pre?: string) => any;
@@ -177,7 +174,7 @@ export declare const uniqueId: (pre?: string) => any;
  * @example
 ```js
 uuid()
-// => '183f8ef3-b8f0-4000-81f5-89234c836d00'
+// '183f8ef3-b8f0-4000-81f5-89234c836d00'
 ```
  */
 export declare const uuid: () => string;
@@ -213,7 +210,7 @@ export declare const values: (object: any) => unknown[];
  * @param attr A property key name.
  * @returns `true` if the object has the property name.
  */
-export declare const has: (obj: any, attr: PropertyKey) => any;
+export declare const has: (obj: any, attr: PropertyKey) => boolean;
 /**
  * Check if the attribute is present in the object or return a default value instead.
  * @param {PropertyKey} key
@@ -293,7 +290,7 @@ export declare const int: (x: any, base?: number) => number;
  */
 export declare const list: (value?: any) => unknown[];
 /**
- * Retrieve the next item from the iterator by calling it's `next()` method.
+ * Retrieve the next item from the iterator by calling its `next()` method.
  * @param iter The iterator.
  * @returns The next value from the iterator.
  */

package/{core → dist}/globals/index.js

@@ -4,7 +4,7 @@
  * @module Globals
  */
 /** This is just a noop function. */
-export const _ = () => { };
+export const noop = () => { };
 /** A function that always returns `true`. */
 export const True = () => true;
 /** A function that always returns `false`. */
@@ -122,9 +122,6 @@ export function type(value) {
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/toString | Object.toString }
  */
 export const str = (obj) => (obj != null ? obj.toString() : '');
-export function hasOwnProperty(obj, prop) {
-    return Object.prototype.hasOwnProperty.call(obj, prop);
-}
 /** Check if value is a boolean type. */
 export const isBool = (x) => type(x) === 'boolean';
 /** Check if value is an `Error` type. */
@@ -138,7 +135,7 @@ export const isIterable = (x) => {
 /** Check if value is a native `Date` type. */
 export const isDate = (x) => x instanceof Date;
 /** Check if value is an object type. */
-export const isObject = (x) => typeof x === 'object' && type(x) === 'object';
+export const isObject = (x) => type(x) === 'object';
 /** Check if value is a string type. */
 export const isString = (x) => type(x) === 'string';
 /** Check if value is an Array type. */
@@ -154,11 +151,9 @@ export const isArrayLike = (x) => {
 /** Check if value is a number type. */
 export const isNumber = (x) => type(x) === 'number';
 /** Check if value is an integer number type. */
-export const isInteger = (x) => type(x) === 'number' && Math.floor(x) === x;
+export const isInteger = (x) => type(x) === 'number' && Math.trunc(x) === x;
 /** Check if value is a bigint type. */
 export const isBigint = (x) => type(x) === 'bigint';
-/** Check if value is NaN based on `Number.isNaN`. */
-export const isNaN = (x) => Number.isNaN(x);
 /** Check if value is a Promise type. */
 export const isPromise = (x) => type(x) === 'Promise';
 /** Check if value is a function type. */
@@ -172,9 +167,7 @@ export const isGenerator = (x) => {
 /** Check if value is `null` or `undefined`. */
 export const isNull = (x) => x == null;
 /** Check if value === `undefined`. */
-export function isUndefined(o) {
-    return typeof o === 'undefined';
-}
+export const isUndefined = (x) => x === undefined;
 /** Check if value is not `null` or `undefined`. */
 export const notNull = (x) => x != null;
 /** Returns `true` for objects without length or falsy values. */
@@ -222,10 +215,10 @@ export function len(value) {
  * @example
 ```js
 uniqueId()
-// => 3445556877
+// 3445556877
 
 uniqueId('user_')
-// => 'user_1033763188'
+// 'user_1033763188'
 ```
  */
 export const uniqueId = (pre = '') => 
@@ -237,7 +230,7 @@ export const uniqueId = (pre = '') =>
  * @example
 ```js
 uuid()
-// => '183f8ef3-b8f0-4000-81f5-89234c836d00'
+// '183f8ef3-b8f0-4000-81f5-89234c836d00'
 ```
  */
 export const uuid = () => {
@@ -407,7 +400,7 @@ export const int = (x, base = 10) => parseInt(x, base);
  */
 export const list = (value) => (value ? Array.from(value) : []);
 /**
- * Retrieve the next item from the iterator by calling it's `next()` method.
+ * Retrieve the next item from the iterator by calling its `next()` method.
  * @param iter The iterator.
  * @returns The next value from the iterator.
  */