atomic-fns 1.2.0 → 2.0.0

package/dist/i18n/format.d.ts

@@ -1,34 +0,0 @@
-export declare function fromFields(utc: boolean, year: number, month: any, day: any, hour: any, minute: any, second: any, ms: any): Date;
-/**
- * Returns a new Date from the given arguments.
- * @param {string | number | Date} date The date value
- * @param {?boolean} [utc=false] Interprets the given value as a UTC date
- * @returns {Date} The new date object
- */
-export declare function asDate(date: string | number | Date, utc?: boolean): Date;
-/**
- * Returns a localized string representation of this date, according to the given format string. Format codes use the same specification as {@link https://momentjs.com/docs/#/displaying/format/ moment}.
- * @param {string} formatStr The format string to use
- * @param {Date} date The date value
- * @param {?string} locale The locale to use when formatting (default is system locale).
- * @see {@link https://momentjs.com/docs/#/displaying/format/ List of formats}
- * @example
-```js
-formatDate('MM/DD/YYYY', new Date()) // '10/31/2022'
-```
-  */
-export declare function formatDate(formatStr: string, date: Date, locale?: string): string;
-/**
- * Formats a date using a formatting string in the {@link https://strftime.org/ strftime} format, in any given locale.
- * @param {string} fmt The format string to apply
- * @param {Date} date The date value
- * @param {?string} locale The locale to use when formatting (default is system locale).
- * @returns {string} The string representation of date
- * @see {@link https://strftime.org/ strftime format}
- * @example
-```js
-strftime('%A, %d/%m/%y', new Date())
-// 'Saturday, 01/02/2020'
-```
- */
-export declare function strftime(fmt: string, date: Date, locale?: string): string;

package/dist/i18n/format.js

@@ -1,378 +0,0 @@
-const NATIVE_DATE = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/;
-const REGEX_FORMAT = /\[([^\]]+)]|Y{1,4}|M{1,4}|Q|Do|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|z{1,4}|N{1,4}|LTS?|L{1,4}|l{1,4}|x|X|SSS/g;
-const FORMAT_DEFAULT = 'YYYY-MM-DDTHH:mm:ssZ';
-const INVALID_DATE_STRING = 'Invalid Date';
-const ORDINAL_SUFFIXES = { one: 'st', two: 'nd', few: 'rd', other: 'th' };
-function padStart(string, length, pad) {
-    return String(string).padStart(length, pad);
-}
-function padYear(year) {
-    return `${year < 0 ? '-' : ''}${padStart(Math.abs(year), 4, '0')}`;
-}
-function padZoneStr(instance) {
-    const negMinutes = -instance.getTimezoneOffset();
-    const minutes = Math.abs(negMinutes);
-    const hourOffset = Math.floor(minutes / 60);
-    const minuteOffset = minutes % 60;
-    return `${negMinutes >= 0 ? '+' : '-'}${padStart(hourOffset, 2, '0')}:${padStart(minuteOffset, 2, '0')}`;
-}
-export function fromFields(utc, year, month, day, hour, minute, second, ms) {
-    // Date reads the years 0 to 99 as 1900 to 1999, 400 years later the leap years still match
-    const shift = year >= 0 && year < 100 ? 400 : 0;
-    if (utc) {
-        const date = new Date(Date.UTC(year + shift, month, day, hour, minute, second, ms));
-        date.setUTCFullYear(date.getUTCFullYear() - shift);
-        return date;
-    }
-    const date = new Date(year + shift, month, day, hour, minute, second, ms);
-    date.setFullYear(date.getFullYear() - shift);
-    return date;
-}
-/**
- * Returns a new Date from the given arguments.
- * @param {string | number | Date} date The date value
- * @param {?boolean} [utc=false] Interprets the given value as a UTC date
- * @returns {Date} The new date object
- */
-export function asDate(date, utc = false) {
-    if (date === null) {
-        return new Date(NaN);
-    }
-    if (date === undefined) {
-        date = Date.now();
-    }
-    if (typeof date === 'string' && !/Z$/i.test(date)) {
-        const d = date.match(NATIVE_DATE);
-        if (d) {
-            const m = d[2] - 1 || 0;
-            const ms = (d[7] || '').padEnd(3, '0').slice(0, 3);
-            return fromFields(utc, Number(d[1]), m, d[3] || 1, d[4] || 0, d[5] || 0, d[6] || 0, ms);
-        }
-    }
-    const fromDate = new Date(date);
-    if (utc) {
-        return fromFields(false, fromDate.getUTCFullYear(), fromDate.getUTCMonth(), fromDate.getUTCDate(), fromDate.getUTCHours(), fromDate.getUTCMinutes(), fromDate.getUTCSeconds(), fromDate.getUTCMilliseconds());
-    }
-    return fromDate;
-}
-const n = 'numeric';
-const s = 'short';
-const l = 'long';
-const dd = '2-digit';
-const STRFTIME = {
-    // weekday
-    '%A': { weekday: l },
-    '%a': { weekday: s },
-    // day
-    '%d': { day: dd },
-    '%-d': { day: n },
-    // month
-    '%m': { month: dd },
-    '%-m': { month: n },
-    '%B': { month: l },
-    '%b': { month: s },
-    '%bb': { month: n },
-    // year
-    '%y': { year: n },
-    '%Y': { year: dd },
-    // hour
-    '%K': { hourCycle: 'h11', hour: dd },
-    '%I': { hourCycle: 'h12', hour: dd },
-    '%-I': { hourCycle: 'h12', hour: n },
-    '%H': { hourCycle: 'h23', hour: dd },
-    '%-H': { hourCycle: 'h23', hour: n },
-    '%k': { hourCycle: 'h24', hour: n },
-    // minutes
-    '%M': { minute: dd },
-    '%-M': { minute: n },
-    // seconds
-    '%S': { second: dd },
-    '%-S': { second: n },
-    // day period
-    '%P': { dayPeriod: l },
-    '%p': { dayPeriod: s },
-    '%pp': { dayPeriod: 'narrow' },
-    // era
-    '%N': { era: l, year: dd },
-    '%n': { era: s, year: dd },
-    // timeZoneName
-    // '%Z': { timeZoneName: 'longGeneric', year: dd },
-    // '%-Z': { timeZoneName: 'shortGeneric', year: dd },
-    '%z': { timeZoneName: 'longOffset', year: dd },
-    '%-z': { timeZoneName: 'shortOffset', year: dd },
-    '%Z': { timeZoneName: l, year: dd },
-    '%-Z': { timeZoneName: s, year: dd }
-};
-const TOKENS = {
-    // weekday
-    dddd: { weekday: l },
-    ddd: { weekday: s },
-    E: { weekday: n },
-    // day
-    DD: { day: dd },
-    D: { day: n },
-    // month
-    MM: { month: dd },
-    M: { month: n },
-    MMMM: { month: l },
-    MMM: { month: s },
-    // year
-    YYYY: { year: n },
-    YY: { year: dd },
-    // hour
-    hh: { hourCycle: 'h12', hour: dd },
-    h: { hourCycle: 'h12', hour: n },
-    HH: { hourCycle: 'h23', hour: dd },
-    H: { hourCycle: 'h23', hour: n },
-    kk: { hourCycle: 'h11', hour: dd },
-    k: { hourCycle: 'h24', hour: n },
-    // minutes
-    mm: { minute: dd },
-    m: { minute: n },
-    // seconds
-    ss: { second: dd },
-    s: { second: n },
-    // day period
-    A: { dayPeriod: l },
-    a: { dayPeriod: s },
-    // era
-    N: { era: s, year: dd },
-    NN: { era: s, year: dd },
-    NNN: { era: s, year: dd },
-    NNNN: { era: l, year: dd },
-    // timeZoneName
-    zzz: { timeZoneName: l, year: dd },
-    z: { timeZoneName: s, year: dd }
-};
-const HOUR_PARTS = { '%I': 1, '%-I': 1, '%K': 1, '%k': 1 };
-const ERA_PARTS = { '%n': 1, '%N': 1 };
-const TZ_PARTS = { '%-z': 1, '%z': 1, '%-Z': 1, '%Z': 1 };
-function formatter(locale, opts) {
-    return new Intl.DateTimeFormat(locale, opts);
-}
-function formatHour(h, maxLength) {
-    return String(h % 12 || 12).padStart(maxLength, '0');
-}
-function formatMeridiem(hour, isLowercase) {
-    const m = hour < 12 ? 'AM' : 'PM';
-    return isLowercase ? m.toLowerCase() : m;
-}
-function formatOrdinal(day, locale) {
-    const rules = new Intl.PluralRules(locale, { type: 'ordinal' });
-    const isEnglish = rules.resolvedOptions().locale.split('-')[0] === 'en';
-    return isEnglish ? `${day}${ORDINAL_SUFFIXES[rules.select(day)]}` : String(day);
-}
-function formatPart(locale, opts, date, type) {
-    return (formatter(locale, opts)
-        .formatToParts(date)
-        .find((part) => part.type === type)?.value ?? '');
-}
-/**
- * Returns a localized string representation of this date, according to the given format string. Format codes use the same specification as {@link https://momentjs.com/docs/#/displaying/format/ moment}.
- * @param {string} formatStr The format string to use
- * @param {Date} date The date value
- * @param {?string} locale The locale to use when formatting (default is system locale).
- * @see {@link https://momentjs.com/docs/#/displaying/format/ List of formats}
- * @example
-```js
-formatDate('MM/DD/YYYY', new Date()) // '10/31/2022'
-```
-  */
-export function formatDate(formatStr, date, locale) {
-    if (Number.isNaN(date.getTime()))
-        return INVALID_DATE_STRING;
-    const str = formatStr || FORMAT_DEFAULT;
-    const zoneStr = padZoneStr(date);
-    const time = {
-        H: date.getHours(),
-        HH: padStart(date.getHours(), 2, '0'),
-        h: formatHour(date.getHours(), 1),
-        hh: formatHour(date.getHours(), 2),
-        a: formatMeridiem(date.getHours(), true),
-        A: formatMeridiem(date.getHours()),
-        m: date.getMinutes(),
-        mm: padStart(date.getMinutes(), 2, '0'),
-        s: date.getSeconds(),
-        ss: padStart(date.getSeconds(), 2, '0'),
-        SSS: padStart(date.getMilliseconds(), 3, '0'),
-        X: Math.floor(date.getTime() / 1000),
-        x: date.getTime()
-    };
-    const matches = {
-        ...time,
-        N: formatPart(locale, TOKENS.N, date, 'era'),
-        NN: formatPart(locale, TOKENS.NN, date, 'era'),
-        NNN: formatPart(locale, TOKENS.NNN, date, 'era'),
-        NNNN: formatPart(locale, TOKENS.NNNN, date, 'era'),
-        YY: padStart(Math.abs(date.getFullYear()) % 100, 2, '0'),
-        YYYY: padYear(date.getFullYear()),
-        M: date.getMonth() + 1,
-        MM: padStart(date.getMonth() + 1, 2, '0'),
-        MMM: formatter(locale, TOKENS.MMM).format(date),
-        MMMM: formatter(locale, TOKENS.MMMM).format(date),
-        Q: Math.ceil((date.getMonth() + 1) / 3),
-        D: date.getDate(),
-        DD: padStart(date.getDate(), 2, '0'),
-        Do: formatOrdinal(date.getDate(), locale),
-        d: date.getDay(),
-        ddd: formatter(locale, TOKENS.ddd).format(date),
-        dddd: formatter(locale, TOKENS.dddd).format(date),
-        Z: zoneStr,
-        ZZ: zoneStr.replace(':', ''),
-        z: formatPart(locale, TOKENS.z, date, 'timeZoneName'),
-        zzz: formatPart(locale, TOKENS.zzz, date, 'timeZoneName'),
-        LT: `${time.h}:${time.mm} ${time.A}`,
-        LTS: `${time.h}:${time.mm}:${time.ss} ${time.A}`,
-        L: formatter(locale, DATE_SHORT_DD).format(date),
-        LL: formatter(locale, DATE_FULL).format(date),
-        LLL: formatter(locale, DATE_LONG_TIME).format(date),
-        LLLL: formatter(locale, DATE_HUGE).format(date),
-        l: formatter(locale, DATE_SHORT).format(date),
-        ll: formatter(locale, DATE_MED).format(date),
-        lll: formatter(locale, DATE_MED_TIME).format(date),
-        llll: formatter(locale, DATE_MED_WITH_WEEKDAY).format(date)
-    };
-    return str.replace(REGEX_FORMAT, (match, $1) => $1 ?? matches[match] ?? match);
-}
-/**
- * Formats a date using a formatting string in the {@link https://strftime.org/ strftime} format, in any given locale.
- * @param {string} fmt The format string to apply
- * @param {Date} date The date value
- * @param {?string} locale The locale to use when formatting (default is system locale).
- * @returns {string} The string representation of date
- * @see {@link https://strftime.org/ strftime format}
- * @example
-```js
-strftime('%A, %d/%m/%y', new Date())
-// 'Saturday, 01/02/2020'
-```
- */
-export function strftime(fmt, date, locale) {
-    if (date != null && Number.isNaN(+date))
-        return INVALID_DATE_STRING;
-    const results = [];
-    let dayPeriod = '';
-    const dayPeriodIndexes = [];
-    for (let i = 0; i < fmt.length; i++) {
-        let part = fmt[i];
-        if (part === '%') {
-            // check for escaped '%'
-            if (fmt[++i] === '%') {
-                results.push('%');
-                continue;
-            }
-            if (fmt[i] === '-') {
-                part += fmt[i++];
-            }
-            part += fmt[i] ?? '';
-            // a doubled letter is a directive of its own only when the table lists it
-            if (fmt[i + 1] === fmt[i] && STRFTIME[part + fmt[i]])
-                part += fmt[++i];
-            if (!STRFTIME[part]) {
-                results.push(part);
-                continue;
-            }
-            if (HOUR_PARTS[part]) {
-                results.push(formatPart(locale, STRFTIME[part], date, 'hour'));
-                // save the AM/PM for the correct spot
-                dayPeriod = formatPart(locale, STRFTIME[part], date, 'dayPeriod');
-                continue;
-            }
-            if (part === '%P' || part === '%p') {
-                // leave this flag in place for later
-                dayPeriodIndexes.push(results.length);
-                results.push(part);
-                continue;
-            }
-            if (ERA_PARTS[part] || TZ_PARTS[part]) {
-                const type = ERA_PARTS[part] ? 'era' : 'timeZoneName';
-                results.push(formatPart(locale, STRFTIME[part], date, type));
-                continue;
-            }
-            // format any other parts, numbers without the unit text of the locale
-            const [type, style] = Object.entries(STRFTIME[part]).at(-1);
-            let res = style === n || style === dd
-                ? formatPart(locale, STRFTIME[part], date, type)
-                : formatter(locale, STRFTIME[part]).format(date);
-            // fix bugs in time formatter
-            if ((part === '%S' || part === '%M') && res.length === 1)
-                res = `0${res}`;
-            if (part === '%-H') {
-                const hours = (date === undefined ? new Date() : new Date(date)).getHours();
-                res = new Intl.NumberFormat(locale).format(hours);
-            }
-            results.push(res);
-        }
-        else {
-            // output as literal
-            results.push(part);
-        }
-    }
-    // insert the AM/PM at the correct spots
-    for (const index of dayPeriodIndexes) {
-        results[index] = results[index] === '%p' ? dayPeriod.toLowerCase() : dayPeriod;
-    }
-    return results.join('').trim();
-}
-/** L: 09/04/1983 */
-const DATE_SHORT_DD = {
-    year: n,
-    month: dd,
-    day: dd
-};
-/** l: 9/4/1983 */
-const DATE_SHORT = {
-    year: n,
-    month: n,
-    day: n
-};
-/** ll: Oct 14, 1983 */
-const DATE_MED = {
-    year: n,
-    month: s,
-    day: n
-};
-/** LL: October 14, 1983 */
-const DATE_FULL = {
-    year: n,
-    month: l,
-    day: n
-};
-/** lll: Oct 14, 1983 8:30 PM */
-const DATE_MED_TIME = {
-    year: n,
-    month: s,
-    day: n,
-    hour: n,
-    minute: n,
-    hourCycle: 'h12'
-};
-/** LLL: October 14, 1983 8:30 PM */
-const DATE_LONG_TIME = {
-    year: n,
-    month: l,
-    day: n,
-    hour: n,
-    minute: n,
-    hourCycle: 'h12'
-};
-/** llll: Fri, Oct 14, 1983, 8:30 PM */
-const DATE_MED_WITH_WEEKDAY = {
-    year: n,
-    month: s,
-    day: n,
-    weekday: s,
-    hour: n,
-    minute: n,
-    hourCycle: 'h12'
-};
-/** LLLL: Friday, October 14, 1983, 8:30 PM */
-const DATE_HUGE = {
-    year: n,
-    month: l,
-    day: n,
-    weekday: l,
-    hour: n,
-    minute: n,
-    hourCycle: 'h12'
-};

package/dist/i18n/index.d.ts

@@ -1,9 +0,0 @@
-/**
- * This module includes functions and classes to handle internationalization of dates and currencies.
- *
- * @module i18n
- */
-export * from './currency.js';
-export * from './date/index.js';
-export { Duration } from './duration.js';
-export type { DurationUnit, TDuration } from './duration.js';

package/dist/i18n/index.js

@@ -1,8 +0,0 @@
-/**
- * This module includes functions and classes to handle internationalization of dates and currencies.
- *
- * @module i18n
- */
-export * from './currency.js';
-export * from './date/index.js';
-export { Duration } from './duration.js';

package/dist/itertools/index.d.ts

@@ -1,251 +0,0 @@
-/**
- * This module includes functions that deal with or produce iterators.
- *
- * @module itertools
- */
-import { add, type Comparer } from '../operators/index.js';
-import type { Function, Iteratee, Predicate } from '../types.js';
-/**
- * Make an iterator that returns accumulated sums, or accumulated results of other binary functions (specified via the optional `func` argument).
- * @param iterable The iterable to accumulate
- * @param func The accumulator function (default `add`).
- * @param initial Optional initial value (defaults to the first element in iterable)
- * @returns A sequence of accumulated values
- */
-export declare function accumulate<T>(iterable: Iterable<T>, func?: typeof add, initial?: any): Generator<T>;
-/**
- * Returns `true` when all of the items in iterable are truthy. An optional predicate function can be used to define what truthiness means for this specific collection.
- * @param iterable
- * @param fn
- * @returns `True` if all elements pass the test or are truthy else `false`.
- * @example
-```js
-all([0])
-// false
-
-all([1, 2, 3])
-// true
-
-all([2, 4, 6], n => n > 1)
-// true
-```
-@see {@link any}
- */
-export declare function all<T>(iterable: Iterable<T>, fn?: Predicate<T>): boolean;
-/**
- * Returns true when any of the items in iterable are truthy. An optional predicate function can be used to define what truthiness means for this specific collection.
- * @param iterable
- * @param fn
- * @returns `True` if any element passes the test or is truthy else `false`.
- * @example
-```js
-any([0])
-// false
-
-any([0, 1, null, undefined])
-// true
-
-any([1, 4, 5], n => n % 2 === 0)
-// true
-```
-@see {@link all}
- */
-export declare function any<T>(iterable: Iterable<T>, fn?: Predicate<T>): boolean;
-export declare function chain<T>(...iterables: Array<Iterable<T>>): Generator<T, void, unknown>;
-/**
- * Checks if the `value` is in `collection`.
- * @param collection The collection to inspect.
- * @param value The value to search for.
- * @returns Returns `true` if value is found, else `false`.
- * @example
-```js
-contains([1, 2, 3], 1)
-// true
-
-contains({ 'a': 1, 'b': 2 }, 1)
-// true
-
-contains('abcd', 'bc')
-// true
-```
- *
- * @see {@link collections.find}
- */
-export declare function contains(collection: Iterable<any>, value: any): boolean;
-/**
- * Returns a generator that drops elements from the iterable as long as the predicate is `true`; afterwards, returns every remaining element. Note, the generator does not produce any output until the predicate first becomes `false`.
- * @param iterable The iterable to inspect.
- * @param predicate A function invoked per element to check if it should be dropped.
- * @returns Elements
- */
-export declare function dropWhile<T>(iterable: Iterable<T>, predicate: Predicate<T>): Generator<T, T, unknown>;
-export declare function iforEach<T>(iterable: Iterable<T>, fun: Iteratee<T>): void;
-/**
- * Yields elements like `[index, item]` from an iterable. Index starts at zero by default.
- * @template T
- * @param iterable The iterable to inspect.
- * @param start The starting index.
- * @returns A generator with tuples like `[index, item]`.
- * @example
-```js
-console.log([...enumerate(['hello', 'world'])])
-// [[0, 'hello'], [1, 'world']]
-
-// Start with index `1`
-console.log([...enumerate(['hello', 'world'], 1)])
-// [[1, 'hello'], [2, 'world']]
-```
- */
-export declare function enumerate<T>(iterable: Iterable<T>, start?: number): Generator<[number, T], void, unknown>;
-/**
- * Returns the first element in an iterable.
- * @param iterable The iterable to inspect.
- * @returns The first element found or undefined if iterable is empty.
- */
-export declare function first<T>(iterable: Iterable<T>): T;
-/**
- * Creates a new generator that filters all falsy and empty values from iterable.
- * @param iterable The iterable to compact
- * @returns A generator with the filtered values.
- * @example
-```js
-[...icompact([0, 1, false, 2, '', 3])]
-// [1, 2, 3]
-```
- */
-export declare function icompact<T>(iterable: Iterable<T>): Generator<T, void, unknown>;
-/**
- * Iterates over elements of collection, producing only those elements where predicate returns a `truthy` value.
- */
-export declare function ifilter<T>(iterable: Iterable<T>, predicate: Predicate<T, boolean>): Generator<T, void, unknown>;
-export declare function imap<T, TReturn = any>(iterable: Iterable<T>, mapFn: Predicate<T, TReturn>): Generator<TReturn, void, unknown>;
-/**
- * Returns a generator flattening one level of nesting in a list of lists.
- * @param iterables The iterable to flatten
- * @example
-```js
-[...iflatten([[0, 1], [2, 3]])]
-// [0, 1, 2, 3]
-```
- */
-export declare function iflatten<T = any>(iterables: Iterable<Iterable<T>>): Generator<T, void, unknown>;
-export declare function flatMap<T>(iterable: Iterable<T>, mapFn?: (x: T) => any): Generator<T, void, unknown>;
-export declare function islice<T>(iterable: Iterable<T>, start: number, stop?: number, step?: number): Generator<T, void, unknown>;
-export declare function itake<T>(n: number, iterable: Iterable<T>): Generator<T, void, unknown>;
-/**
- * Returns an Iterator from the elements of a collection or the object keys.
- * @param obj The given collection to iterate over.
- * @returns An Iterator type.
- */
-export declare function iter<T>(obj: any): Iterator<T, T>;
-export declare function partition<T>(iterable: Iterable<T>, predicate: Predicate<T, boolean>): [T[], T[]];
-/**
- * Returns a generator for a sequence of numbers in the given range, starting from `start` (default 0) to `stop` (not-inclusive) in increments of `step` (default 1).
- *
- * `range(x)` is a shorthand for `range(0, x, 1)`, or `range(0, x, -1)` when `x` is negative.
- * @param args When called with a single argument, it is assigned to `stop` param. If two arguments are given, it will assign them to `(start, stop)`. When three arguments, it means `(start, stop, step)`.
- * @example
-```js
-range(5)
-// [0, 1, 2, 3, 4]
-
-range(2, 5)
-// [2, 3, 4]
-
-range(0, 5, 2)
-// [0, 2, 4]
-
-range(5, 0, -1)
-// [5, 4, 3, 2, 1]
-
-range(-3)
-// [0, -1, -2]
-```
- */
-export declare function range(...args: number[]): Generator<number, void, unknown>;
-/**
- * Applies a `reducer` function on each element of the iterable, in order, passing the return value from the operation on the previous element. The final result of running the reducer across all elements of the iterable is a single value.
- * @param iterable The collection to reduce.
- * @param reducer A reducer function that will be called per item.
- * @param initial Optional initial value (defaults to the first element in the iterable).
- * @returns The result of calling reducer on each item.
- * @example
-```js
-reduce([1, 2, 3, 4, 5], (x, y) => x + y, 0)
-// 15
-```
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce Array.reduce()}
- */
-export declare function reduce<T>(iterable: Iterable<T>, reducer: (prev: T, value: T, index: any) => T, initial?: any): any;
-/**
- * Creates a new array with the elements from the iterable in reverse order.
- * @param iterable The iterable to inspect.
- * @returns A new array with the elements reversed.
- */
-export declare function reversed<T>(iterable: Iterable<T>): T[];
-/**
- * Creates a new sorted list from the elements in the array. This can be called many ways:
- *   - sorted([...], true) - reverse order
- *   - sorted([...], fn = x => any) - using a key fn
- *   - sorted([...], fn = x => any, true) - reverse order using key
- *   - sorted([...], false, (x, y) => number) - using custom compare
- *   - sorted([...], fn = x => any, true, (x, y) => number) - custom key, reverse and compare
- *
- * If `args` is an Object, returns the sorted keys.
- *
- *
- * @param {(Array | Object)} args
- * @param {(boolean | Function)} [key]
- * @param {(boolean | Comparer)} [reverse]
- * @param {Comparer} [compareFn]
- * @return
- */
-export declare function sorted<T>(args: T[]): T[];
-export declare function sorted<T>(args: T[], reverse: boolean): T[];
-export declare function sorted<T>(args: T[], reverse: boolean, comp: Comparer): T[];
-export declare function sorted<T>(args: T[], key: Function): T[];
-export declare function sorted<T>(args: T[], key: Function, reverse: boolean): T[];
-/**
- * Sort `args` in place. Can be called like this:
- *   - sort([...], true) - reverse order
- *   - sort([...], (x, y) => number) - using custom compare
- *   - sort([...], true, (x, y) => number) - reverse and using custom compare
- *
- * @param {any[]} args
- * @param {(boolean | Comparer)} [reverse]
- * @param {Comparer} [compareFn]
- * @return
- */
-export declare function sort<T>(args: T[]): T[];
-export declare function sort<T>(args: T[], reverse: boolean): T[];
-export declare function sort<T>(args: T[], compareFn: Comparer): T[];
-export declare function sort<T>(args: T[], reverse: boolean, compareFn: Comparer): T[];
-export declare function take<T>(n: number, iterable: Iterable<T>): T[];
-/**
- * Returns a generator that takes elements from the iterable as long as the predicate is `true`.
- * @param iterable The iterable to inspect.
- * @param predicate A function invoked per element to check if it should be taken.
- * @returns Elements
- */
-export declare function takeWhile<T>(iterable: Iterable<T>, predicate: Predicate<T>): Generator<T, void, unknown>;
-/** Returns a generator that calls `fn(index)` for each index < n */
-/**
- * Returns a generator that produces `fn(index)` for each `index < n`.
- * @param n The number of times to invoke `fn`.
- * @param fn A function used to produce the results.
- */
-export declare function times(n: number, fn: (index: number) => any): Generator<any, void, unknown>;
-/**
- * Returns a generator that aggregates elements from the iterables producing tuples with the next element from each one.
- * @param args The iterables to zip
- * @returns Tuples with elements from each iterator
- * @example
-```js
-for item of zip([1, 2, 3], ['sugar', 'spice', 'nice'])
-  console.log(item)
-// [1, 'sugar']
-// [2, 'spice']
-// [3, 'nice']
-```
- */
-export declare function zip(...args: Array<Iterable<any>>): Generator<any[], void, unknown>;