moderndash 0.0.11 → 0.0.13

package/dist/index.d.ts

@@ -1,668 +0,0 @@
-/**
- * Creates an array of elements split into groups the length of size. If array can't be split evenly, the final chunk will be the remaining elements.
- *
- * @category Array
- * @returns Returns the new array of chunks.
- * @param chunkSize - The array to process.
- * @param array - The length of each chunk
- * @example
- * chunk(2, ['a', 'b', 'c', 'd'])
- * // => [['a', 'b'], ['c', 'd']]
- *
- * chunk(3, ['a', 'b', 'c', 'd'])
- * // => [['a', 'b', 'c'], ['d']]
- */
-declare function chunk<TInput>(chunkSize: number, array: TInput[]): TInput[][];
-
-type MinimumTwoArrays<TInput> = [TInput[], TInput[], ...TInput[][]];
-type IterateeFunction<T> = (value: T) => unknown;
-type PropertyShorthand<T> = keyof T;
-type RecordKey = string | number | symbol;
-type ArrayOrRecord<TInput> = TInput[] | Record<RecordKey, TInput>;
-type NoUnion<T, U = T> = T extends U ? [U] extends [T] ? T : never : never;
-/**
- * @description Generic function type, should fit any function
- * @typeParam TFunc - The input function type
- */
-type GenericFunction<TFunc extends (...args: Parameters<TFunc>) => ReturnType<TFunc>> = (...args: Parameters<TFunc>) => ReturnType<TFunc>;
-
-/**
- * Creates an array of `array` values not included in the other given arrays. The order and references of result values are determined by the first array.
- *
- * **Note:** Unlike `pullAll`, this method returns a new array.
- *
- * @category Array
- * @param arrays - First array is inspected, others are excluded.
- * @returns Returns the new array of filtered values.
- * @example
- * difference([2, 1], [2, 3])
- * // => [1]
- */
-declare function difference<TInput>(...arrays: MinimumTwoArrays<TInput>): TInput[];
-
-/**
- * This method is like `difference` except that it accepts `iteratee` which
- * is invoked for each element of `array` and `values` to generate the criterion
- * by which they're compared. The order and references of result values are
- * determined by the first array.
- *
- * **Note:** Unlike `pullAllBy`, this method returns a new array.
- *
- * @category Array
- * @param iteratee - The iteratee invoked per element. Or property shorthand.
- * @param arrays - First array to inspect. Others are excluded.
-
- * @returns Returns the new array of filtered values.
- * @example
- * differenceBy(Math.floor, [2.1, 1.2], [2.3, 3.4])
- * // => [1.2]
- * differenceBy('x', [{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }])
- * // => [{ 'x': 2 }]
- */
-declare function differenceBy<T>(iteratee: IterateeFunction<T> | PropertyShorthand<T>, ...arrays: MinimumTwoArrays<T>): T[];
-
-/**
- * This method is like `difference` except that it accepts `comparator`
- * which is invoked to compare elements of `array` to `values`. The order and
- * references of result values are determined by the first array. The comparator
- * is invoked with two arguments: (arrVal, othVal).
- *
- * **Note:** Unlike `pullAllWith`, this method returns a new array.
- *
- * @category Array
- * @param comparator - The comparator invoked per element.
- * @param arrays - First array to inspect. Others are excluded.
- * @returns Returns the new array of filtered values.
- * @example
- * differenceWith(isEqual, [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }], [{ 'x': 1, 'y': 2 }])
- * // => [{ 'x': 2, 'y': 1 }]
- */
-declare function differenceWith<T>(comparator: (a: T, b: T) => boolean, ...arrays: MinimumTwoArrays<T>): T[];
-
-/**
- * Creates a slice of `array` excluding elements dropped from the end.
- * Elements are dropped until `predicate` returns falsey. The predicate is
- * invoked with three arguments: (value, index, array).
- *
- * @category Array
- * @param predicate - The function invoked per iteration.
- * @param array - The array to query.
- * @returns Returns the slice of `array`.
- * @example
- * const users = [
- *   { 'user': 'barney',  'active': false },
- *   { 'user': 'fred',    'active': true },
- *   { 'user': 'pebbles', 'active': true }
- * ]
- *
- * dropRightWhile(({ active }) => active, users)
- * // => objects for ['barney']
- */
-declare function dropRightWhile<T>(predicate: (value: T) => boolean, array: T[]): T[];
-
-/**
- * Creates a slice of `array` excluding elements dropped from the beginning.
- * Elements are dropped until `predicate` returns falsey. The predicate is
- * invoked with three arguments: (value, index, array).
- *
- * @category Array
- * @param predicate - The function invoked per iteration.
- * @param array - The array to query.
- * @returns Returns the slice of `array`.
- * @example
- * const users = [
- *   { 'user': 'barney',  'active': true },
- *   { 'user': 'fred',    'active': true },
- *   { 'user': 'pebbles', 'active': false }
- * ]
- *
- * dropWhile(({ active }) => active, users)
- * // => objects for ['pebbles']
- */
-declare function dropWhile<T>(predicate: (value: T) => boolean, array: T[]): T[];
-
-/**
- * Creates an array of unique values that are included in all given arrays.
- * The order and references of result values are determined by the first array.
- *
- * @category Array
- * @param arrays - The arrays to inspect.
- * @returns Returns the new array of intersecting values.
- * @example
- * intersection([2, 1], [2, 3])
- * // => [2]
- */
-declare function intersection<TInput>(...arrays: MinimumTwoArrays<TInput>): TInput[];
-
-/**
- * This method is like `intersection` except that it accepts `iteratee`
- * which is invoked for each element of each `arrays` to generate the criterion
- * by which they're compared. The order and references of result values are
- * determined by the first array. The iteratee is invoked with one argument:
- * (value).
- *
- * @category Array
- * @param iteratee - The iteratee invoked per element. Or property shorthand.
- * @param arrays - The arrays to inspect.
- * @returns Returns the new array of intersecting values.
- * @example
- * intersectionBy(Math.floor, [2.1, 1.2], [2.3, 3.4])
- * // => [2.1]
- */
-declare function intersectionBy<TInput>(iteratee: IterateeFunction<TInput> | PropertyShorthand<TInput>, ...arrays: MinimumTwoArrays<TInput>): TInput[];
-
-/**
- * This method is like `intersection` except that it accepts `comparator`
- * which is invoked to compare elements of `arrays`. The order and references
- * of result values are determined by the first array. The comparator is
- * invoked with two arguments: (arrVal, othVal).
- *
- * @category Array
- * @param comparator - The comparator invoked per element.
- * @param arrays - The arrays to inspect.
- * @returns Returns the new array of intersecting values.
- * @example
- * const objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]
- * const others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]
- *
- * intersectionWith(isEqual, objects, others)
- * // => [{ 'x': 1, 'y': 2 }]
- */
-declare function intersectionWith<T>(comparator: (a: T, b: T) => boolean, ...arrays: MinimumTwoArrays<T>): T[];
-
-/**
- * Gets a random element from `array`.
- *
- * @category Array
- * @param array - The array to sample.
- * @returns Returns the random element.
- * @example
- * sample([1, 2, 3, 4])
- * // => 2
- */
-declare function sample<T>(array: T[]): T | undefined;
-
-/**
- * Gets `n` random elements at unique keys from `array` up to the
- * size of `array`.
- *
- * @category Array
- * @param size The number of elements to sample.
- * @param array The array to sample.
- * @returns Returns the random elements.
- * @example
- * sampleSize([1, 2, 3], 2)
- * // => [3, 1]
- *
- * sampleSize([1, 2, 3], 4)
- * // => [2, 3, 1]
- */
-declare function sampleSize<TInput>(size: number, array: TInput[]): TInput[];
-
-/**
- * Creates an array of shuffled values, using a version of the
- * [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle).
- *
- * @since 0.1.0
- * @category Array
- * @param array - The array or object to shuffle.
- * @returns {Array} Returns the new shuffled array.
- * @example
- * shuffle([1, 2, 3, 4])
- * // => [4, 1, 3, 2]
- */
-declare function shuffle<TInput>(array: TInput[]): TInput[];
-
-/**
- * Creates a slice of `array` with elements taken from the end. Elements are
- * taken until `predicate` returns falsey. The predicate is invoked with
- * three arguments: (value, index, array).
- *
- * @category Array
- * @param predicate - The function invoked per iteration.
- * @param array - The array to query.
- * @returns Returns the slice of `array`.
- * @example
- * const users = [
- *   { 'user': 'barney',  'active': false },
- *   { 'user': 'fred',    'active': true },
- *   { 'user': 'pebbles', 'active': true }
- * ]
- *
- * takeRightWhile(({ active }) => active, users)
- * // => objects for ['fred', 'pebbles']
- */
-declare function takeRightWhile<T>(predicate: (elem: T) => boolean, array: T[]): T[];
-
-/**
- * Creates a slice of `array` with elements taken from the beginning. Elements
- * are taken until `predicate` returns falsey. The predicate is invoked with
- * three arguments: (value, index, array).
- *
- * @category Array
- * @param predicate The function invoked per iteration.
- * @param array The array to query.
- * @returns Returns the slice of `array`.
- * @example
- * const users = [
- *   { 'user': 'barney',  'active': true },
- *   { 'user': 'fred',    'active': true },
- *   { 'user': 'pebbles', 'active': false }
- * ]
- *
- * takeWhile(({ active }) => active, users)
- * // => objects for ['barney', 'fred']
- */
-declare function takeWhile<T>(predicate: (elem: T) => boolean, array: T[]): T[];
-
-/**
- * Creates a duplicate-free version of an array, in which only the first occurrence of each element is kept.
- * The order of result values is determined by the order they occur in the array.
- *
- * @category Array
- * @param array - The array to inspect.
- * @returns Returns the new duplicate free array.
- * @example
- * uniq([2, 1, 2])
- * // => [2, 1]
- */
-declare function uniq<TInput>(array: TInput[]): TInput[];
-
-/**
- * This method is like `uniq` except that it accepts `iteratee` which is
- * invoked for each element in `array` to generate the criterion by which
- * uniqueness is computed. The order of result values is determined by the
- * order they occur in the array.
- *
- * @category Array
- * @param array - The array to inspect.
- * @param iteratee - The iteratee invoked per element. Or property shorthand.
- * @returns Returns the new duplicate free array.
- * @example
- * uniqBy(Math.floor, [2.1, 1.2, 2.3])
- * // => [2.1, 1.2]
- */
-declare function uniqBy<T>(iteratee: IterateeFunction<T> | PropertyShorthand<T>, array: T[]): T[];
-
-/**
- * This method is like `uniq` except that it accepts `comparator` which is invoked to compare elements of `array`.
- * The order of result values is determined by the order they occur in the array.
- *
- * @category Array
- * @param array - The array to inspect.
- * @param comparator - The comparator invoked per element.
- * @returns {Array} Returns the new duplicate free array.
- * @example
- * const objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }]
- *
- * uniqWith(isEqual, objects)
- * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]
- */
-declare function uniqWith<TInput>(comparator: (a: TInput, b: TInput) => boolean, array: TInput[]): TInput[];
-
-/**
- * This method is like `zip` except that it accepts an array of grouped
- * elements and creates an array regrouping the elements to their pre-zip configuration.
- *
- * @category Array
- * @param array - The array of grouped elements to process.
- * @returns Returns the new array of regrouped elements.
- * @example
- * const zipped = zip(['a', 'b'], [1, 2], [true, false])
- * // => [['a', 1, true], ['b', 2, false]]
- *
- * unzip(zipped)
- * // => [['a', 'b'], [1, 2], [true, false]]
- */
-declare function unzip<TInput extends unknown[]>(array: TInput[]): TInput[];
-
-/**
- * This method is like `unzip` except that it accepts `iteratee` to specify
- * how regrouped values should be combined. The iteratee is invoked with the
- * elements of each group: (...group).
- *
- * @category Array
- * @param iteratee - The function to combine regrouped values.
- * @param array - The array of grouped elements to process.
- * @returns Returns the new array of regrouped elements.
- * @example
- * const zipped = zip([1, 2], [10, 20], [100, 200])
- * // => [[1, 10, 100], [2, 20, 200]]
- *
- * unzipWith(add, zipped)
- * // => [3, 30, 300]
- */
-declare function unzipWith<TInput extends unknown[], TOutput>(iteratee: (...t: TInput) => TOutput, array: TInput[]): TOutput[];
-
-/**
- * Creates an array of grouped elements, the first of which contains the first elements of the given arrays,
- * the second of which contains the second elements of the given arrays, and so on.
- *
- * @category Array
- * @param arrays - The arrays to process.
- * @returns Returns the new array of grouped elements.
- * @example
- * zip(['a', 'b'], [1, 2], [true, false])
- * // => [['a', 1, true], ['b', 2, false]]
- */
-declare function zip<TInput>(...arrays: TInput[][]): TInput[][];
-
-type UnZip<A extends readonly unknown[]> = {
-    [K in keyof A]: readonly A[K][];
-};
-/**
- * This method is like `zip` except that it accepts `iteratee` to specify
- * how grouped values should be combined. The iteratee is invoked with the
- * elements of each group: (...group).
- *
- * @category Array
- * @param combineFunc - The function to combine grouped values.
- * @param arrays - The arrays to process.
- * @returns Returns the new array of grouped elements.
- * @example
- * zipWith([1, 2], [10, 20], [100, 200], (a, b, c) => a + b + c)
- * // => [111, 222]
- */
-declare function zipWith<Args extends unknown[], TOutput>(combineFunc: (...args: Args) => TOutput, ...arrays: UnZip<Args>): TOutput[];
-
-/**
- * Creates an object composed of keys generated from the results of running
- * each element of `collection` thru `iteratee`. The corresponding value of
- * each key is the number of times the key was returned by `iteratee`.
- *
- * @category Collection
- * @param iteratee - The iteratee to transform keys.
- * @param collection - The array or record to iterate over.
- * @returns Returns the composed aggregate object.
- * @example
- * const users = [
- *   { 'user': 'barney', 'active': true },
- *   { 'user': 'betty', 'active': true },
- *   { 'user': 'fred', 'active': false }
- * ]
- *
- * countBy(users, value => value.active);
- * // => { 'true': 2, 'false': 1 }
- */
-declare function countBy<TInput, TKey extends RecordKey>(collection: ArrayOrRecord<TInput>, iteratee: (value: TInput) => TKey): Record<TKey, number>;
-
-/**
- * Creates an object composed of keys generated from the results of running
- * each element of `collection` thru `iteratee`. The order of grouped values
- * is determined by the order they occur in `collection`. The corresponding
- * value of each key is an array of elements responsible for generating the
- * key.
- *
- * @category Collection
- * @param collection - The array or object to iterate over.
- * @param iteratee - The iteratee to transform keys.
- * @returns Returns the composed aggregate object.
- * @example
- * groupBy([6.1, 4.2, 6.3], Math.floor)
- * // => { '4': [4.2], '6': [6.1, 6.3] }
- */
-declare function groupBy<T, U extends RecordKey>(collection: ArrayOrRecord<T>, iteratee: (value: T) => U): Record<U, T[]>;
-
-declare function sortBy<T, U>(iteratee: (item: T) => NoUnion<number | bigint | Date | string, U>, array: T[]): T[];
-
-/**
- * The opposite of `before`. This method creates a function that invokes `func` once it's called `n` or more times.
- *
- * @category Function
- * @param n The number of calls before `func` is invoked.
- * @param func The function to restrict.
- * @returns Returns the new restricted function.
- * @example
- * const caution = () => console.log("Caution!");
- *
- * const afterFN = after(2, caution);
- *
- * afterFN()
- * afterFN()
- * afterFN()
- * // => `caution` is invoked after called twice
- */
-declare function after<TFunc extends GenericFunction<TFunc>>(n: number, func: TFunc): (...args: Parameters<TFunc>) => ReturnType<TFunc> | undefined;
-
-/**
- * Creates a function that invokes `func`, while it's called less than `n` times. Subsequent
- * calls to the created function return the result of the last `func` invocation.
- *
- * @category Function
- * @param n - The number of calls at which `func` is no longer invoked.
- * @param func - The function to restrict.
- * @returns Returns the new restricted function.
- * @example
- * const caution = () => console.log("Caution!");
- *
- * // Only call caution two times
- * const reducedCaution = before(2, caution)
- *
- * reducedCaution()
- * reducedCaution()
- * reducedCaution()
- * // => `caution` is invoked twice
- */
-declare function before<TFunc extends (...args: Parameters<TFunc>) => ReturnType<TFunc>>(n: number, func: TFunc): TFunc;
-
-declare function debounce<TFunc extends GenericFunction<TFunc>>(fn: TFunc, wait?: number, options?: {
-    leading?: boolean;
-    maxWait?: number;
-    trailing?: boolean;
-}): (this: ThisParameterType<TFunc>, ...args: Parameters<TFunc>) => ReturnType<TFunc>;
-
-/**
- * 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, all arguments
- * provided to the memoized function are used as the map cache key.
- *
- * **Note:** The cache is exposed as the `cache` property on the memoized
- * function. Its creation may be customized by replacing the `memoize.Cache`
- * constructor with one whose instances implement the
- * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
- * method interface of `clear`, `delete`, `get`, `has`, and `set`.
- *
- * @category Function
- * @param func - The function to have its output memoized.
- * @param resolver - The function to resolve the cache key.
- * @typeParam TFunc - The input function type
- * @typeParam Cache - The cache map type
- * @returns  Returns the new memoized function.
- * @example
- * const object = \{ 'a': 1, 'b': 2 \}
- *
- * const values = memoize(values)
- * values(object)
- * // => [1, 2]
- *
- * values(object)
- * // => [1, 2]
- *
- * object.a = 2
- * values(object)
- * // => [2, 2]
- *
- * // Modify the result cache.
- * values.cache.set(object, ['a', 'b'])
- * values(object)
- * // => ['a', 'b']
- *
- * // Replace `memoize.Cache`.
- * memoize.Cache = WeakMap
- */
-declare function memoize<TFunc extends GenericFunction<TFunc>, Cache extends Map<string | symbol, ReturnType<TFunc>>>(func: TFunc, resolver?: ((...args: Parameters<TFunc>) => string | symbol)): TFunc & {
-    cache: Cache;
-};
-
-/**
- * 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 `this` binding and arguments of the created function.
- *
- * @category Function
- * @param func - The function to restrict.
- * @returns Returns the new restricted function.
- * @example
- * const initialize = once(() => console.log('initialize'))
- * initialize()
- * initialize()
- * // => `createApplication` is invoked once
- */
-declare function once<TFunc extends GenericFunction<TFunc>>(func: TFunc): TFunc;
-
-declare function throttle<TFunc extends GenericFunction<TFunc>>(func: TFunc, wait?: number, options?: {
-    leading?: boolean;
-    trailing?: boolean;
-}): (this: ThisParameterType<TFunc>, ...args: Parameters<TFunc>) => ReturnType<TFunc>;
-
-/**
- * Invokes the iteratee `n` times, returning an array of the results of
- * each invocation. The function is invoked with one argument: (index).
- *
- * @category Function
- * @param n - The number of times to invoke `func`.
- * @param iteratee - The function invoked per iteration.
- * @returns Returns the array of results.
- * @example
- * times(3, index => console.log("Run", index)))
- * // => "Run 0" | "Run 1" | "Run 2"
- *
- * times(3, Math.random)
- * // => [0.123, 0.456, 0.789]
- *
- * times(4, () => 0)
- * // => [0, 0, 0, 0]
- */
-declare function times<T>(n: number, func: (index: number) => T): T[];
-
-/**
- * Checks if `value` is an empty object, collection, map, or set.
- *
- * Objects are considered empty if they have no own enumerable string keyed
- * properties.
- *
- * Array-like values such as `arguments` objects, arrays, buffers, strings, or
- * Similarly, maps and sets are considered empty if they have a `size` of `0`.
- *
- * @category Lang
- * @param value - The value to check.
- * @returns Returns `true` if `value` is empty, else `false`.
- * @example
- * isEmpty(null)
- * // => true
- *
- * isEmpty({})
- * // => true
- *
- * isEmpty("")
- * // => true
- *
- * isEmpty([1, 2, 3])
- * // => false
- *
- * isEmpty('abc')
- * // => false
- *
- * isEmpty({ 'a': 1 })
- * // => false
- */
-declare function isEmpty(value: string | object | null | undefined): boolean;
-
-/**
- * Performs a deep comparison between two values to determine if they are
- * equivalent.
- *
- * **Note:** This method supports comparing arrays, array buffers, booleans,
- * date objects, error objects, maps, numbers, `Object` objects, regexes,
- * sets, strings, symbols, and typed arrays. `Object` objects are compared
- * by their own, not inherited, enumerable properties. Functions and DOM
- * nodes are compared by strict equality, i.e. `===`.
- *
- * @category Lang
- * @param value1 - The value to compare.
- * @param value2 - The other value to compare.
- * @returns Returns `true` if the values are equivalent, else `false`.
- * @example
- * var object = { 'a': 1 };
- * var other = { 'a': 1 };
- *
- * _.isEqual(object, other);
- * // => true
- *
- * object === other;
- * // => false
- */
-declare function isEqual(value1: unknown, value2: unknown): boolean;
-
-/**
- * This method is like `_.isEqual` except that it accepts `customizer` which
- * is invoked to compare values. If `customizer` returns `undefined`, comparisons
- * are handled by the method instead. The `customizer` is invoked with up to
- * six arguments: (objValue, othValue [, index|key, object, other, stack]).
- *
- * @category Lang
- * @param value1 - The value to compare.
- * @param value2 - The other value to compare.
- * @param customizer - The function to customize comparisons.
- * @returns Returns `true` if the values are equivalent, else `false`.
- * @example
- * function isGreeting(value) {
- *   return /^h(?:i|ello)$/.test(value);
- * }
- *
- * function customizer(objValue, othValue) {
- *   if (isGreeting(objValue) && isGreeting(othValue)) {
- *     return true;
- *   }
- * }
- *
- * var array = ['hello', 'goodbye'];
- * var other = ['hi', 'goodbye'];
- *
- * isEqualWith(array, other, customizer);
- * // => true
-*/
-declare function isEqualWith<T>(a: T, b: T, customizer: (value: T) => unknown): boolean;
-
-declare function isPlainObject(value: unknown): value is object;
-
-/**
- * Creates an object composed of the picked `object` properties.
- *
- * @category Object
- * @param object The source object.
- * @param keys The property paths to pick.
- * @returns {Object} Returns the new object.
- * @example
- *
- * const object = { 'a': 1, 'b': '2', 'c': 3 }
- *
- * pick(object, ['a', 'c'])
- * // => { 'a': 1, 'c': 3 }
- */
-declare function pick<T, K extends keyof T>(object: T, keys: K[]): Pick<T, K>;
-
-declare function camelCase(str: string): string;
-
-declare function capitalize(str: string): string;
-
-declare function deburr(str: string): string;
-
-declare function escape(str: string): string;
-
-declare function escapeRegExp(str: string): string;
-
-declare function kebabCase(str: string): string;
-
-declare function pascalCase(str: string): string;
-
-declare function snakeCase(str: string): string;
-
-declare function startCase(str: string): string;
-
-declare function stripSpecialChars(str: string): string;
-
-declare function unescapeHTML(html: string): string;
-
-export { ArrayOrRecord, GenericFunction, IterateeFunction, MinimumTwoArrays, NoUnion, PropertyShorthand, RecordKey, after, before, camelCase, capitalize, chunk, countBy, debounce, deburr, difference, differenceBy, differenceWith, dropRightWhile, dropWhile, escape, escapeRegExp, groupBy, intersection, intersectionBy, intersectionWith, isEmpty, isEqual, isEqualWith, isPlainObject, kebabCase, memoize, once, pascalCase, pick, sample, sampleSize, shuffle, snakeCase, sortBy, startCase, stripSpecialChars, takeRightWhile, takeWhile, throttle, times, unescapeHTML, uniq, uniqBy, uniqWith, unzip, unzipWith, zip, zipWith };