@oscarpalmer/atoms 0.156.0 → 0.157.0

package/dist/array/index.js

@@ -14,10 +14,11 @@ import { intersection } from "./intersection.js";
 import { partition } from "./partition.js";
 import { push } from "./push.js";
 import { select } from "./select.js";
+import { drop, slice, take } from "./slice.js";
 import { sort } from "./sort.js";
 import { splice } from "./splice.js";
 import { toSet } from "./to-set.js";
 import { toggle } from "./toggle.js";
 import { union } from "./union.js";
 import { update } from "./update.js";
-export { chunk, compact, difference, exists, filter, find, flatten, getArray, indexOf, insert, intersection, partition, push, range, select, shuffle, sort, splice, times, toSet, toggle, union, update };
+export { chunk, compact, difference, drop, exists, filter, find, flatten, getArray, indexOf, insert, intersection, partition, push, range, select, shuffle, slice, sort, splice, take, times, toSet, toggle, union, update };

package/dist/array/slice.js

@@ -0,0 +1,51 @@
+import { getArrayCallbacks } from "../internal/array/callbacks.js";
+function drop(array, first, second) {
+	return extract(EXTRACT_DROP, array, first, second);
+}
+function extract(type, array, first, second) {
+	if (!Array.isArray(array)) return [];
+	const { length } = array;
+	if (length === 0) return [];
+	const isTake = type === EXTRACT_TAKE;
+	if (typeof first === "number") {
+		if (Math.abs(first) >= length) return isTake ? array.slice() : [];
+		if (first === 0) return isTake ? [] : array.slice();
+		if (isTake) return first >= 0 ? array.slice(0, first) : array.slice(array.length + first);
+		return first >= 0 ? array.slice(first) : array.slice(0, array.length + first);
+	}
+	const callbacks = second == null ? getArrayCallbacks(first) : getArrayCallbacks(void 0, void 0, first);
+	const isBoolean = callbacks?.bool != null;
+	if (callbacks?.bool == null && callbacks?.value == null) return isTake ? array.slice() : [];
+	const extracted = [];
+	let push = false;
+	for (let index = 0; index < length; index += 1) {
+		const item = array[index];
+		const matches = isBoolean ? callbacks.bool(item, index, array) : Object.is(callbacks.value(item, index, array), second);
+		if (isTake) {
+			if (isBoolean ? !matches : matches) break;
+			extracted.push(item);
+			continue;
+		}
+		if (push) extracted.push(item);
+		else if (isBoolean ? !matches : matches) {
+			push = true;
+			if (isBoolean) extracted.push(item);
+		}
+	}
+	return extracted;
+}
+function slice(array, first, second) {
+	if (!Array.isArray(array) || array.length === 0) return [];
+	const firstIsNumber = typeof first === "number";
+	const secondIsNumber = typeof second === "number";
+	if (!firstIsNumber && !secondIsNumber) return array.slice();
+	if (!secondIsNumber) return first >= 0 ? array.slice(0, first) : array.slice(array.length + first);
+	if (!firstIsNumber) return array.slice();
+	return first >= 0 ? array.slice(first, second) : array.slice(array.length + first, array.length + second);
+}
+function take(array, first, second) {
+	return extract(EXTRACT_TAKE, array, first, second);
+}
+var EXTRACT_DROP = "drop";
+var EXTRACT_TAKE = "take";
+export { drop, slice, take };

package/dist/atoms.full.js

@@ -381,6 +381,55 @@ function push(array, pushed) {
 function select(array, ...parameters) {
 	return findValues(FIND_VALUES_ALL, array, parameters, parameters.pop()).matched;
 }
+function drop(array, first, second) {
+	return extract(EXTRACT_DROP, array, first, second);
+}
+function extract(type, array, first, second) {
+	if (!Array.isArray(array)) return [];
+	const { length } = array;
+	if (length === 0) return [];
+	const isTake = type === EXTRACT_TAKE;
+	if (typeof first === "number") {
+		if (Math.abs(first) >= length) return isTake ? array.slice() : [];
+		if (first === 0) return isTake ? [] : array.slice();
+		if (isTake) return first >= 0 ? array.slice(0, first) : array.slice(array.length + first);
+		return first >= 0 ? array.slice(first) : array.slice(0, array.length + first);
+	}
+	const callbacks = second == null ? getArrayCallbacks(first) : getArrayCallbacks(void 0, void 0, first);
+	const isBoolean = callbacks?.bool != null;
+	if (callbacks?.bool == null && callbacks?.value == null) return isTake ? array.slice() : [];
+	const extracted = [];
+	let push = false;
+	for (let index = 0; index < length; index += 1) {
+		const item = array[index];
+		const matches = isBoolean ? callbacks.bool(item, index, array) : Object.is(callbacks.value(item, index, array), second);
+		if (isTake) {
+			if (isBoolean ? !matches : matches) break;
+			extracted.push(item);
+			continue;
+		}
+		if (push) extracted.push(item);
+		else if (isBoolean ? !matches : matches) {
+			push = true;
+			if (isBoolean) extracted.push(item);
+		}
+	}
+	return extracted;
+}
+function slice(array, first, second) {
+	if (!Array.isArray(array) || array.length === 0) return [];
+	const firstIsNumber = typeof first === "number";
+	const secondIsNumber = typeof second === "number";
+	if (!firstIsNumber && !secondIsNumber) return array.slice();
+	if (!secondIsNumber) return first >= 0 ? array.slice(0, first) : array.slice(array.length + first);
+	if (!firstIsNumber) return array.slice();
+	return first >= 0 ? array.slice(first, second) : array.slice(array.length + first, array.length + second);
+}
+function take(array, first, second) {
+	return extract(EXTRACT_TAKE, array, first, second);
+}
+const EXTRACT_DROP = "drop";
+const EXTRACT_TAKE = "take";
 function aggregate(type, array, key) {
 	const length = Array.isArray(array) ? array.length : 0;
 	if (length === 0) return {
@@ -3874,4 +3923,4 @@ var SizedSet = class extends Set {
 		}
 	}
 };
-export { CancelablePromise, PromiseTimeoutError, QueueError, RetryError, SizedMap, SizedSet, attempt, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, delay, diff, difference, endsWith, equal, error, exists, filter, find, flatten, floor, flow, toResult as fromPromise, toResult, fromQuery, toPromise as fromResult, toPromise, getArray, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getUuid, getValue, groupBy, hasValue, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, includes, indexOf, insert, intersection, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonNullable, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, max, median, memoize, merge, min, noop, ok, omit, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, retry, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, shuffle, smush, snakeCase, sort, splice, startsWith, sum, template, throttle, timed, times, titleCase, toMap, toQuery, toRecord, toSet, toggle, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };
+export { CancelablePromise, PromiseTimeoutError, QueueError, RetryError, SizedMap, SizedSet, attempt, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, delay, diff, difference, drop, endsWith, equal, error, exists, filter, find, flatten, floor, flow, toResult as fromPromise, toResult, fromQuery, toPromise as fromResult, toPromise, getArray, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getUuid, getValue, groupBy, hasValue, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, includes, indexOf, insert, intersection, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonNullable, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, max, median, memoize, merge, min, noop, ok, omit, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, retry, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, shuffle, slice, smush, snakeCase, sort, splice, startsWith, sum, take, template, throttle, timed, times, titleCase, toMap, toQuery, toRecord, toSet, toggle, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };

package/dist/index.js

@@ -17,6 +17,7 @@ import { intersection } from "./array/intersection.js";
 import { partition } from "./array/partition.js";
 import { push } from "./array/push.js";
 import { select } from "./array/select.js";
+import { drop, slice, take } from "./array/slice.js";
 import { max } from "./internal/math/aggregate.js";
 import { getString, ignoreKey, join, tryDecode, tryEncode, words } from "./internal/string.js";
 import { compare } from "./internal/value/compare.js";
@@ -75,4 +76,4 @@ import { QueueError, queue } from "./queue.js";
 import { getRandomBoolean, getRandomCharacters, getRandomColor, getRandomHex, getRandomItem, getRandomItems } from "./random.js";
 import { attempt } from "./result/index.js";
 import { SizedSet } from "./sized/set.js";
-export { CancelablePromise, PromiseTimeoutError, QueueError, RetryError, SizedMap, SizedSet, attempt, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, delay, diff, difference, endsWith, equal, error, exists, filter, find, flatten, floor, flow, toResult as fromPromise, fromQuery, toPromise as fromResult, getArray, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getUuid, getValue, groupBy, hasValue, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, includes, indexOf, insert, intersection, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonNullable, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, max, median, memoize, merge, min, noop, ok, omit, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, retry, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, shuffle, smush, snakeCase, sort, splice, startsWith, sum, template, throttle, timed, times, titleCase, toMap, toPromise, toQuery, toRecord, toResult, toSet, toggle, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };
+export { CancelablePromise, PromiseTimeoutError, QueueError, RetryError, SizedMap, SizedSet, attempt, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, delay, diff, difference, drop, endsWith, equal, error, exists, filter, find, flatten, floor, flow, toResult as fromPromise, fromQuery, toPromise as fromResult, getArray, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getUuid, getValue, groupBy, hasValue, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, includes, indexOf, insert, intersection, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonNullable, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, max, median, memoize, merge, min, noop, ok, omit, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, retry, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, shuffle, slice, smush, snakeCase, sort, splice, startsWith, sum, take, template, throttle, timed, times, titleCase, toMap, toPromise, toQuery, toRecord, toResult, toSet, toggle, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };

package/package.json

@@ -184,5 +184,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.156.0"
+	"version": "0.157.0"
 }

package/src/array/index.ts

@@ -15,6 +15,7 @@ export * from './intersection';
 export * from './partition';
 export * from './push';
 export * from './select';
+export * from './slice';
 export * from './sort';
 export * from './splice';
 export * from './to-set';

package/src/array/slice.ts

@@ -0,0 +1,245 @@
+import {getArrayCallbacks} from '../internal/array/callbacks';
+import type {PlainObject} from '../models';
+
+// #region Types
+
+type ExtractType = 'drop' | 'take';
+
+// #endregion
+
+// #region Functions
+
+/**
+ * Drop items from the start of an array until they match a value
+ * @param array Original array
+ * @param key Key to get an item's value for matching
+ * @param value Value to match against
+ * @returns New array with items dropped
+ */
+export function drop<Item extends PlainObject, Key extends keyof Item>(
+	array: Item[],
+	key: Key,
+	value: Item[Key],
+): Item[];
+
+/**
+ * Drop items from the start of an array until they match a value
+ * @param array Original array
+ * @param callback Callback to get an item's value for matching
+ * @param value Value to match against
+ * @return New array with items dropped
+ */
+export function drop<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(
+	array: Item[],
+	callback: Callback,
+	value: ReturnType<Callback>,
+): Item[];
+
+/**
+ * Drop items from the start of an array while they match a filter
+ * @param array Original array
+ * @param callback Filter callback to match items
+ * @return New array with items dropped
+ */
+export function drop<Item extends PlainObject>(
+	array: Item[],
+	callback: (item: Item, index: number, array: Item[]) => boolean,
+): Item[];
+
+/**
+ * Drop a specified number of items, from the start if `>= 0`, or from the end if `< 0`
+ * @param array Original array
+ * @param count Number of items to drop
+ * @returns New array with items dropped
+ */
+export function drop(array: unknown[], count: number): unknown[];
+
+export function drop(array: unknown[], first?: unknown, second?: unknown): unknown[] {
+	return extract(EXTRACT_DROP, array, first, second);
+}
+
+function extract(
+	type: ExtractType,
+	array: unknown[],
+	first?: unknown,
+	second?: unknown,
+): unknown[] {
+	if (!Array.isArray(array)) {
+		return [];
+	}
+
+	const {length} = array;
+
+	if (length === 0) {
+		return [];
+	}
+
+	const isTake = type === EXTRACT_TAKE;
+
+	if (typeof first === 'number') {
+		if (Math.abs(first) >= length) {
+			return isTake ? array.slice() : [];
+		}
+
+		if (first === 0) {
+			return isTake ? [] : array.slice();
+		}
+
+		if (isTake) {
+			return first >= 0 ? array.slice(0, first) : array.slice(array.length + first);
+		}
+
+		return first >= 0 ? array.slice(first) : array.slice(0, array.length + first);
+	}
+
+	const callbacks =
+		second == null ? getArrayCallbacks(first) : getArrayCallbacks(undefined, undefined, first);
+
+	const isBoolean = callbacks?.bool != null;
+
+	if (callbacks?.bool == null && callbacks?.value == null) {
+		return isTake ? array.slice() : [];
+	}
+
+	const extracted: unknown[] = [];
+
+	let push = false;
+
+	for (let index = 0; index < length; index += 1) {
+		const item = array[index];
+
+		const matches = isBoolean
+			? callbacks.bool!(item, index, array)
+			: Object.is(callbacks!.value!(item, index, array), second);
+
+		if (isTake) {
+			if (isBoolean ? !matches : matches) {
+				break;
+			}
+
+			extracted.push(item);
+
+			continue;
+		}
+
+		if (push) {
+			extracted.push(item);
+		} else if (isBoolean ? !matches : matches) {
+			push = true;
+
+			if (isBoolean) {
+				extracted.push(item);
+			}
+		}
+	}
+
+	return extracted;
+}
+
+/**
+ * Slice an array, returning a new array with a specified range of items
+ * @param array Original array
+ * @param start Start index _(inclusive)_
+ * @param end End index _(exclusive)_
+ * @return New array with sliced items
+ */
+export function slice<Item>(array: Item[], start: number, end: number): Item[];
+
+/**
+ * Slice an array, returning a new array with a specified number of items
+ * @param array Original array
+ * @param count Maximum sixe of the new array
+ * @return New array with sliced items
+ */
+export function slice<Item>(array: Item[], count: number): Item[];
+
+/**
+ * Slice an array
+ * @param array Array to slice
+ * @returns Sliced array
+ */
+export function slice<Item>(array: Item[]): Item[];
+
+export function slice(array: unknown[], first?: number, second?: number): unknown[] {
+	if (!Array.isArray(array) || array.length === 0) {
+		return [];
+	}
+
+	const firstIsNumber = typeof first === 'number';
+	const secondIsNumber = typeof second === 'number';
+
+	if (!firstIsNumber && !secondIsNumber) {
+		return array.slice();
+	}
+
+	if (!secondIsNumber) {
+		return first! >= 0 ? array.slice(0, first) : array.slice(array.length + first!);
+	}
+
+	if (!firstIsNumber) {
+		return array.slice();
+	}
+
+	return first! >= 0
+		? array.slice(first!, second!)
+		: array.slice(array.length + first!, array.length + second!);
+}
+
+/**
+ * Take items from the start of an array until they match a value
+ * @param array Original array
+ * @param key Key to get an item's value for matching
+ * @param value Value to match against
+ * @returns New array with taken items
+ */
+export function take<Item extends PlainObject, Key extends keyof Item>(
+	array: Item[],
+	key: Key,
+	value: Item[Key],
+): Item[];
+
+/**
+ * Take items from the start of an array until they match a value
+ * @param array Original array
+ * @param callback Callback to get an item's value for matching
+ * @param value Value to match against
+ * @return New array with taken items
+ */
+export function take<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(
+	array: Item[],
+	callback: Callback,
+	value: ReturnType<Callback>,
+): Item[];
+
+/**
+ * Take items from the start of an array while they match a filter
+ * @param array Original array
+ * @param callback Filter callback to match items
+ * @return New array with taken items
+ */
+export function take<Item extends PlainObject>(
+	array: Item[],
+	callback: (item: Item, index: number, array: Item[]) => boolean,
+): Item[];
+
+/**
+ * Take a specified number of items, from the start if `>= 0`, or from the end if `< 0`
+ * @param array Original array
+ * @param count Number of items to take
+ * @returns New array with taken items
+ */
+export function take(array: unknown[], count: number): unknown[];
+
+export function take(array: unknown[], first?: unknown, second?: unknown): unknown[] {
+	return extract(EXTRACT_TAKE, array, first, second);
+}
+
+// #endregion
+
+// #region Variables
+
+const EXTRACT_DROP: ExtractType = 'drop';
+
+const EXTRACT_TAKE: ExtractType = 'take';
+
+// #endregion

package/types/array/index.d.ts

@@ -14,6 +14,7 @@ export * from './intersection';
 export * from './partition';
 export * from './push';
 export * from './select';
+export * from './slice';
 export * from './sort';
 export * from './splice';
 export * from './to-set';

package/types/array/slice.d.ts

@@ -0,0 +1,82 @@
+import type { PlainObject } from '../models';
+/**
+ * Drop items from the start of an array until they match a value
+ * @param array Original array
+ * @param key Key to get an item's value for matching
+ * @param value Value to match against
+ * @returns New array with items dropped
+ */
+export declare function drop<Item extends PlainObject, Key extends keyof Item>(array: Item[], key: Key, value: Item[Key]): Item[];
+/**
+ * Drop items from the start of an array until they match a value
+ * @param array Original array
+ * @param callback Callback to get an item's value for matching
+ * @param value Value to match against
+ * @return New array with items dropped
+ */
+export declare function drop<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): Item[];
+/**
+ * Drop items from the start of an array while they match a filter
+ * @param array Original array
+ * @param callback Filter callback to match items
+ * @return New array with items dropped
+ */
+export declare function drop<Item extends PlainObject>(array: Item[], callback: (item: Item, index: number, array: Item[]) => boolean): Item[];
+/**
+ * Drop a specified number of items, from the start if `>= 0`, or from the end if `< 0`
+ * @param array Original array
+ * @param count Number of items to drop
+ * @returns New array with items dropped
+ */
+export declare function drop(array: unknown[], count: number): unknown[];
+/**
+ * Slice an array, returning a new array with a specified range of items
+ * @param array Original array
+ * @param start Start index _(inclusive)_
+ * @param end End index _(exclusive)_
+ * @return New array with sliced items
+ */
+export declare function slice<Item>(array: Item[], start: number, end: number): Item[];
+/**
+ * Slice an array, returning a new array with a specified number of items
+ * @param array Original array
+ * @param count Maximum sixe of the new array
+ * @return New array with sliced items
+ */
+export declare function slice<Item>(array: Item[], count: number): Item[];
+/**
+ * Slice an array
+ * @param array Array to slice
+ * @returns Sliced array
+ */
+export declare function slice<Item>(array: Item[]): Item[];
+/**
+ * Take items from the start of an array until they match a value
+ * @param array Original array
+ * @param key Key to get an item's value for matching
+ * @param value Value to match against
+ * @returns New array with taken items
+ */
+export declare function take<Item extends PlainObject, Key extends keyof Item>(array: Item[], key: Key, value: Item[Key]): Item[];
+/**
+ * Take items from the start of an array until they match a value
+ * @param array Original array
+ * @param callback Callback to get an item's value for matching
+ * @param value Value to match against
+ * @return New array with taken items
+ */
+export declare function take<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): Item[];
+/**
+ * Take items from the start of an array while they match a filter
+ * @param array Original array
+ * @param callback Filter callback to match items
+ * @return New array with taken items
+ */
+export declare function take<Item extends PlainObject>(array: Item[], callback: (item: Item, index: number, array: Item[]) => boolean): Item[];
+/**
+ * Take a specified number of items, from the start if `>= 0`, or from the end if `< 0`
+ * @param array Original array
+ * @param count Number of items to take
+ * @returns New array with taken items
+ */
+export declare function take(array: unknown[], count: number): unknown[];