@oscarpalmer/atoms 0.193.0 → 0.194.0

package/dist/string/fuzzy.mjs

@@ -10,10 +10,10 @@ function getHandler(input) {
 		case "string": return (item) => item[input];
 		default:
 			if (isPlainObject(input)) return getHandler(input.key ?? input.handler);
-			throw new TypeError(MESSAGE_HANDLER);
+			throw new TypeError(FUZZY_MESSAGE_HANDLER);
 	}
 }
-function getItems(items) {
+function getFuzzyItems(items) {
 	return items.sort((first, second) => first.haystack.localeCompare(second.haystack)).map(({ item }) => item);
 }
 function getFuzzyOptions(input, state) {
@@ -37,22 +37,22 @@ function getFuzzyState(items, input) {
 }
 function getTolerance(input, state) {
 	if (typeof input === "number" && !Number.isNaN(input)) return input < 0 ? 0 : Math.floor(input);
-	return state?.tolerance ?? PROXIMITY_THRESHOLD;
+	return state?.tolerance ?? FUZZY_PROXIMITY_THRESHOLD;
 }
 function fuzzy(items, configuration) {
-	if (!Array.isArray(items)) throw new TypeError(MESSAGE_ARRAY);
+	if (!Array.isArray(items)) throw new TypeError(FUZZY_MESSAGE_ARRAY);
 	const state = getFuzzyState(items, configuration);
 	const instance = { search: (value, options) => search(state.items, state.strings, value, options == null ? state : getFuzzyOptions(options, state)) };
 	Object.defineProperties(instance, {
 		items: {
+			enumerable: true,
 			get: () => state.items.slice(),
-			set: (items) => {
-				if (!Array.isArray(items)) throw new TypeError(MESSAGE_ARRAY);
-				state.items = items.slice();
-				state.strings = items.map(state.handler);
-			}
+			set: (value) => setItems(state, value)
 		},
-		strings: { get: () => state.strings.slice() }
+		strings: {
+			enumerable: true,
+			get: () => state.strings.slice()
+		}
 	});
 	return Object.freeze(instance);
 }
@@ -96,14 +96,14 @@ function getScore(haystack, needle) {
 			if (haystackIndex === 0) score += 1;
 			if (previousMatchIndex !== -1) {
 				const gap = haystackIndex - previousMatchIndex - 1;
-				score += Math.max(0, PROXIMITY_THRESHOLD - gap);
+				score += Math.max(0, FUZZY_PROXIMITY_THRESHOLD - gap);
 			}
 			previousMatchIndex = haystackIndex;
 			needleIndex += 1;
 		}
 		if (needleIndex === needleLength) break;
 	}
-	score -= Math.floor(lowerCaseHaystack.length / LENGTH_DIVISOR);
+	score -= Math.floor(lowerCaseHaystack.length / FUZZY_LENGTH_DIVISOR);
 	return Math.max(0, score);
 }
 function search(items, strings, input, options) {
@@ -146,17 +146,22 @@ function search(items, strings, input, options) {
 		for (let index = 0; index < length; index += 1) {
 			const key = keys[index];
 			if (maxScore - key > options.tolerance) break;
-			similar.push(...getItems(scored[key]));
+			similar.push(...getFuzzyItems(scored[key]));
 		}
 	}
-	result.exact = getItems(options.limit == null ? exact : exact.slice(0, options.limit));
+	result.exact = getFuzzyItems(options.limit == null ? exact : exact.slice(0, options.limit));
 	if (options.limit == null) result.similar = similar;
 	else result.similar = similar.slice(0, options.limit - result.exact.length);
 	return result;
 }
-const LENGTH_DIVISOR = 3;
-const MESSAGE_ARRAY = "Fuzzy requires an array of items";
-const MESSAGE_HANDLER = "Fuzzy requires a key or function to stringify items";
-const PROXIMITY_THRESHOLD = 5;
+function setItems(state, value) {
+	if (!Array.isArray(value)) throw new TypeError(FUZZY_MESSAGE_ARRAY);
+	state.items = value.slice();
+	state.strings = value.map(state.handler);
+}
+const FUZZY_LENGTH_DIVISOR = 3;
+const FUZZY_MESSAGE_ARRAY = "Fuzzy requires an array of items";
+const FUZZY_MESSAGE_HANDLER = "Fuzzy requires a key or function to stringify items";
+const FUZZY_PROXIMITY_THRESHOLD = 5;
 //#endregion
 export { fuzzy, fuzzyMatch };

package/dist/string/index.mjs

@@ -37,16 +37,16 @@ function getUuid(html) {
 		crypto.getRandomValues(bytes);
 		bytes[6] = bytes[6] & 15 | 64;
 		bytes[8] = bytes[8] & 63 | 128;
-		const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, ZERO)).join("");
+		const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, STRING_ZERO)).join("");
 		const first = hex.substring(0, 8);
-		if (forHTML && NUMERICAL_PREFIX_PATTERN.test(first)) continue;
+		if (forHTML && STRING_NUMERICAL_PREFIX_PATTERN.test(first)) continue;
 		return [
 			first,
 			hex.substring(8, 12),
 			hex.substring(12, 16),
 			hex.substring(16, 20),
 			hex.substring(20, 32)
-		].join(forHTML ? DELIMITER_UUID_HTML : DELIMITER_UUID_DEFAULT);
+		].join(forHTML ? STRING_DELIMITER_UUID_HTML : STRING_DELIMITER_UUID_DEFAULT);
 	}
 }
 /**
@@ -89,9 +89,9 @@ function truncate(value, length, suffix) {
 	const truncatedLength = length - actualSuffixLength;
 	return `${value.slice(0, truncatedLength)}${actualSuffix}`;
 }
-const DELIMITER_UUID_DEFAULT = "-";
-const DELIMITER_UUID_HTML = "_";
-const NUMERICAL_PREFIX_PATTERN = /^\d/;
-const ZERO = "0";
+const STRING_DELIMITER_UUID_DEFAULT = "-";
+const STRING_DELIMITER_UUID_HTML = "_";
+const STRING_NUMERICAL_PREFIX_PATTERN = /^\d/;
+const STRING_ZERO = "0";
 //#endregion
 export { dedent, getString, getUuid, join, parse, trim, truncate, words };

package/dist/string/normalize.mjs

@@ -11,8 +11,8 @@ import { lowerCase } from "./case.mjs";
 function deburr(value) {
 	if (typeof value !== "string") return "";
 	deburrMemoizer ??= memoize((value) => {
-		let deburred = value.normalize(DEBURR_NORMALIZATION).replace(DEBURR_PATTERN_SIMPLE, "");
-		deburred = deburred.replace(DEBURR_PATTERN_CHARACTERS, (_, character) => DEBURR_CHARACTERS[character]);
+		let deburred = value.normalize(NORMALIZE_DEBURR_NORMALIZATION).replace(NORMALIZE_DEBURR_PATTERN_SIMPLE, "");
+		deburred = deburred.replace(NORMALIZE_DEBURR_PATTERN_CHARACTERS, (_, character) => NORMALIZE_DEBURR_CHARACTERS[character]);
 		return deburred;
 	});
 	return deburrMemoizer.run(value);
@@ -56,13 +56,13 @@ function normalizeString(value, options) {
 	if (typeof value !== "string") return "";
 	let result = value;
 	if (options.trim) result = result.trim();
-	if (options.whitespace) result = result.replace(WHITESPACE_PATTERN, WHITESPACE_REPLACEMENT);
+	if (options.whitespace) result = result.replace(NORMALIZE_WHITESPACE_PATTERN, NORMALIZE_WHITESPACE_REPLACEMENT);
 	if (options.deburr) result = deburr(result);
 	if (options.lowerCase) result = lowerCase(result);
-	if (options.special) result = result.replace(SPECIAL_PATTERN, SPECIAL_REPLACEMENT);
-	return result.normalize(NORMALIZATION_NORMALIZATION);
+	if (options.special) result = result.replace(NORMALIZE_SPECIAL_PATTERN, NORMALIZE_SPECIAL_REPLACEMENT);
+	return result.normalize(NORMALIZE_NORMALIZATION_NORMALIZATION);
 }
-const DEBURR_CHARACTERS = {
+const NORMALIZE_DEBURR_CHARACTERS = {
 	Æ: "AE",
 	æ: "ae",
 	Ð: "D",
@@ -94,14 +94,14 @@ const DEBURR_CHARACTERS = {
 	Ŧ: "T",
 	ŧ: "t"
 };
-const DEBURR_NORMALIZATION = "NFD";
-const DEBURR_PATTERN_CHARACTERS = new RegExp(`(${Object.keys(DEBURR_CHARACTERS).join("|")})`, "g");
-const DEBURR_PATTERN_SIMPLE = /[\u0300-\u036f]/g;
-const NORMALIZATION_NORMALIZATION = "NFC";
-const SPECIAL_PATTERN = /[\p{P}\p{S}]/gu;
-const SPECIAL_REPLACEMENT = "";
-const WHITESPACE_PATTERN = /\s+/g;
-const WHITESPACE_REPLACEMENT = " ";
+const NORMALIZE_DEBURR_NORMALIZATION = "NFD";
+const NORMALIZE_DEBURR_PATTERN_CHARACTERS = new RegExp(`(${Object.keys(NORMALIZE_DEBURR_CHARACTERS).join("|")})`, "g");
+const NORMALIZE_DEBURR_PATTERN_SIMPLE = /[\u0300-\u036f]/g;
+const NORMALIZE_NORMALIZATION_NORMALIZATION = "NFC";
+const NORMALIZE_SPECIAL_PATTERN = /[\p{P}\p{S}]/gu;
+const NORMALIZE_SPECIAL_REPLACEMENT = "";
+const NORMALIZE_WHITESPACE_PATTERN = /\s+/g;
+const NORMALIZE_WHITESPACE_REPLACEMENT = " ";
 let deburrMemoizer;
 //#endregion
 export { deburr, initializeNormalizer, normalize };

package/dist/string/template.mjs

@@ -11,7 +11,7 @@ function getTemplateOptions(input) {
 	const options = isPlainObject(input) ? input : {};
 	return {
 		ignoreCase: options.ignoreCase === true,
-		pattern: options.pattern instanceof RegExp ? options.pattern : EXPRESSION_VARIABLE
+		pattern: options.pattern instanceof RegExp ? options.pattern : TEMPLATE_EXPRESSION_VARIABLE
 	};
 }
 function handleTemplate(value, pattern, ignoreCase, variables) {
@@ -46,6 +46,6 @@ function template(value, ...parameters) {
 	return handleTemplate(value, pattern, ignoreCase, parameters[0]);
 }
 template.initialize = initializeTemplater;
-const EXPRESSION_VARIABLE = /{{([\s\S]+?)}}/g;
+const TEMPLATE_EXPRESSION_VARIABLE = /{{([\s\S]+?)}}/g;
 //#endregion
 export { initializeTemplater, template };

package/dist/value/clone.mjs

@@ -12,21 +12,21 @@ clone.handlers = getSelfHandlers(clone, {
 clone.deregister = deregisterCloner;
 clone.register = registerCloner;
 function cloneArrayBuffer(value, depth, references) {
-	if (typeof depth === "number" && depth >= MAX_CLONE_DEPTH) return value;
+	if (typeof depth === "number" && depth >= CLONE_MAX_DEPTH) return value;
 	const cloned = new ArrayBuffer(value.byteLength);
 	new Uint8Array(cloned).set(new Uint8Array(value));
 	references?.set(value, cloned);
 	return cloned;
 }
 function cloneDataView(value, depth, references) {
-	if (depth >= MAX_CLONE_DEPTH) return value;
+	if (depth >= CLONE_MAX_DEPTH) return value;
 	const buffer = cloneArrayBuffer(value.buffer);
 	const cloned = new DataView(buffer, value.byteOffset, value.byteLength);
 	references.set(value, cloned);
 	return cloned;
 }
 function cloneMap(map, depth, references, flat) {
-	if (depth >= MAX_CLONE_DEPTH) return map;
+	if (depth >= CLONE_MAX_DEPTH) return map;
 	const cloned = /* @__PURE__ */ new Map();
 	const entries = map.entries();
 	for (const entry of entries) cloned.set(flat ? entry[0] : cloneValue(entry[0], depth + 1, references, false), flat ? entry[1] : cloneValue(entry[1], depth + 1, references, false));
@@ -34,13 +34,13 @@ function cloneMap(map, depth, references, flat) {
 	return cloned;
 }
 function cloneNode(node, depth, references) {
-	if (depth >= MAX_CLONE_DEPTH) return node;
+	if (depth >= CLONE_MAX_DEPTH) return node;
 	const cloned = node.cloneNode(true);
 	references.set(node, cloned);
 	return cloned;
 }
 function cloneObject(value, depth, references, flat) {
-	if (flat || depth >= MAX_CLONE_DEPTH) return Array.isArray(value) ? value.slice() : { ...value };
+	if (flat || depth >= CLONE_MAX_DEPTH) return Array.isArray(value) ? value.slice() : { ...value };
 	const cloned = Array.isArray(value) ? [] : {};
 	const keys = [...Object.keys(value), ...Object.getOwnPropertySymbols(value)];
 	const { length } = keys;
@@ -52,14 +52,14 @@ function cloneObject(value, depth, references, flat) {
 	return cloned;
 }
 function cloneRegularExpression(value, depth, references) {
-	if (depth >= MAX_CLONE_DEPTH) return value;
+	if (depth >= CLONE_MAX_DEPTH) return value;
 	const cloned = new RegExp(value.source, value.flags);
 	cloned.lastIndex = value.lastIndex;
 	references.set(value, cloned);
 	return cloned;
 }
 function cloneSet(set, depth, references, flat) {
-	if (depth >= MAX_CLONE_DEPTH) return set;
+	if (depth >= CLONE_MAX_DEPTH) return set;
 	const cloned = /* @__PURE__ */ new Set();
 	const values = [...set.values()];
 	const { length } = values;
@@ -68,7 +68,7 @@ function cloneSet(set, depth, references, flat) {
 	return cloned;
 }
 function cloneTypedArray(value, depth, references) {
-	if (depth >= MAX_CLONE_DEPTH) return value;
+	if (depth >= CLONE_MAX_DEPTH) return value;
 	const cloned = new value.constructor(value);
 	references.set(value, cloned);
 	return cloned;
@@ -129,7 +129,7 @@ function registerCloner(constructor, handler) {
 	clone.handlers.register(constructor, handler);
 }
 function tryStructuredClone(value, depth, references) {
-	if (depth >= MAX_CLONE_DEPTH) return value;
+	if (depth >= CLONE_MAX_DEPTH) return value;
 	try {
 		const cloned = structuredClone(value);
 		references.set(value, cloned);
@@ -139,6 +139,6 @@ function tryStructuredClone(value, depth, references) {
 		return value;
 	}
 }
-const MAX_CLONE_DEPTH = 100;
+const CLONE_MAX_DEPTH = 100;
 //#endregion
 export { clone, copy, deregisterCloner, registerCloner };

package/dist/value/smush.mjs

@@ -2,7 +2,7 @@ import { isArrayOrPlainObject } from "../internal/is.mjs";
 import { join } from "../internal/string.mjs";
 //#region src/value/smush.ts
 function flattenObject(value, depth, smushed, prefix) {
-	if (depth >= MAX_DEPTH) return {};
+	if (depth >= SMUSH_MAX_DEPTH) return {};
 	if (smushed.has(value)) return smushed.get(value);
 	const keys = Object.keys(value);
 	const { length } = keys;
@@ -34,6 +34,6 @@ function flattenObject(value, depth, smushed, prefix) {
 function smush(value) {
 	return typeof value === "object" && value !== null ? flattenObject(value, 0, /* @__PURE__ */ new WeakMap()) : {};
 }
-const MAX_DEPTH = 100;
+const SMUSH_MAX_DEPTH = 100;
 //#endregion
 export { smush };

package/package.json

@@ -1,9 +1,18 @@
 {
 	"name": "@oscarpalmer/atoms",
-	"version": "0.193.0",
+	"version": "0.194.0",
 	"description": "Atomic utilities for making your JavaScript better.",
 	"keywords": [
+		"array",
+		"color",
 		"helper",
+		"observable",
+		"promise",
+		"query",
+		"queue",
+		"random",
+		"result",
+		"subscription",
 		"utility"
 	],
 	"license": "MIT",
@@ -17,8 +26,7 @@
 	},
 	"files": [
 		"dist",
-		"plugin",
-		"src"
+		"plugin"
 	],
 	"type": "module",
 	"module": "./dist/index.mjs",
@@ -257,8 +265,8 @@
 		"watch": "npx vite build --watch"
 	},
 	"devDependencies": {
-		"@oxlint/plugins": "^1.79",
-		"@types/node": "^26.2",
+		"@oxlint/plugins": "^1.80",
+		"@types/node": "^26.4",
 		"@vitest/coverage-istanbul": "^4.1",
 		"eslint": "^10.9",
 		"jsdom": "^30",

package/src/array/difference.ts

@@ -1,73 +0,0 @@
-import {COMPARE_SETS_DIFFERENCE, compareSets} from '../internal/array/sets';
-import type {PlainObject} from '../models';
-
-// #region Functions
-
-/**
- * Get the items from the first array that are not in the second array
- *
- * @param first First array
- * @param second Second array
- * @param callback Callback to get an item's value for comparison
- * @returns Unique values from the first array
- *
- * @example
- * ```typescript
- * difference(
- *   [{id: 1}, {id: 2}, {id: 3}],
- *   [{id: 2}, {id: 4}],
- *   item => item.id,
- * ); // => [{id: 1}, {id: 3}]
- * ```
- */
-export function difference<First, Second>(
-	first: First[],
-	second: Second[],
-	callback: (item: First | Second) => unknown,
-): First[];
-
-/**
- * Get the items from the first array that are not in the second array
- *
- * @param first First array
- * @param second Second array
- * @param key Key to get an item's value for comparison
- * @returns Unique values from the first array
- *
- * @example
- * ```typescript
- * difference(
- *   [{id: 1}, {id: 2}, {id: 3}],
- *   [{id: 2}, {id: 4}],
- *   'id',
- * ); // => [{id: 1}, {id: 3}]
- * ```
- */
-export function difference<
-	First extends PlainObject,
-	Second extends PlainObject,
-	SharedKey extends keyof First & keyof Second,
->(first: First[], second: Second[], key: SharedKey): First[];
-
-/**
- * Get the items from the first array that are not in the second array
- *
- * @param first First array
- * @param second Second array
- * @returns Unique values from the first array
- *
- * @example
- * ```typescript
- * difference(
- *   [1, 2, 3],
- *   [2, 4],
- * ); // => [1, 3]
- * ```
- */
-export function difference<First, Second>(first: First[], second: Second[]): First[];
-
-export function difference(first: unknown[], second: unknown[], key?: unknown): unknown[] {
-	return compareSets(COMPARE_SETS_DIFFERENCE, first, second, key);
-}
-
-// #endregion

package/src/array/exists.ts

@@ -1,93 +0,0 @@
-import {FIND_VALUE_INDEX, findValue} from '../internal/array/find';
-import type {PlainObject} from '../models';
-
-// #region Functions
-
-/**
- * Does an item with a specific value exist in the array?
- *
- * @param array Array to search in
- * @param callback Callback to get an item's value for matching
- * @param value Value to match against
- * @returns `true` if the item exists in the array, otherwise `false`
- *
- * @example
- * ```typescript
- * exists(
- *   [{id: 1}, {id: 2}, {id: 3}],
- *   item => item.id,
- *   2,
- * ); // => true
- * ```
- */
-export function exists<
-	Item,
-	Callback extends (item: Item, index: number, array: Item[]) => unknown,
->(array: Item[], callback: Callback, value: ReturnType<Callback>): boolean;
-
-/**
- * Does an item with a specific value exist in the array?
- *
- * @param array Array to search in
- * @param key Key to get an item's value for matching
- * @param value Value to match against
- * @returns `true` if the item exists in the array, otherwise `false`
- *
- * @example
- * ```typescript
- * exists(
- *   [{id: 1}, {id: 2}, {id: 3}],
- *   'id',
- *   2,
- * ); // => true
- * ```
- */
-export function exists<Item extends PlainObject, ItemKey extends keyof Item>(
-	array: Item[],
-	key: ItemKey,
-	value: Item[ItemKey],
-): boolean;
-
-/**
- * Does an item in the array match the filter?
- *
- * @param array Array to search in
- * @param filter Filter callback to match items
- * @returns `true` if a matching item exists, otherwise `false`
- *
- * @example
- * ```typescript
- * exists(
- *   [{id: 1}, {id: 2}, {id: 3}],
- *   item => item.id === 2,
- * ); // => true
- * ```
- */
-export function exists<Item>(
-	array: Item[],
-	filter: (item: Item, index: number, array: Item[]) => boolean,
-): boolean;
-
-/**
- * Does the item exist in the array?
- *
- * @param array Array to search in
- * @param item Item to search for
- * @returns `true` if the item exists in the array, otherwise `false`
- *
- * @example
- * ```typescript
- * exists([1, 2, 3], 2); // => true
- * ```
- */
-export function exists<Item>(array: Item[], item: Item): boolean;
-
-export function exists(array: unknown[], ...parameters: unknown[]): boolean {
-	if (parameters.length === 1 && typeof parameters[0] !== 'function') {
-		return Array.isArray(array) ? array.includes(parameters[0]) : false;
-	}
-
-	return findValue(FIND_VALUE_INDEX, array, parameters, false) > -1;
-}
-
-// #endregion

package/src/array/filter.ts

@@ -1,182 +0,0 @@
-import {FIND_VALUES_ALL, findValues} from '../internal/array/find';
-import type {PlainObject} from '../models';
-
-// #region Functions
-
-/**
- * Get a filtered array of items that do not match the value
- *
- * _Available as `exclude` and `filter.remove`_
- *
- * @param array Array to search in
- * @param callback Callback to get an item's value for matching
- * @param value Value to match against
- * @returns Filtered array of items that do not match the filter
- *
- * @example
- * ```typescript
- * exclude(
- *   [{id: 1}, {id: 2}, {id: 3}],
- *   item => item.id,
- *   2,
- * ); // => [{id: 1}, {id: 3}]
- * ```
- */
-export function exclude<
-	Item,
-	Callback extends (item: Item, index: number, array: Item[]) => unknown,
->(array: Item[], callback: Callback, value: ReturnType<Callback>): unknown[];
-
-/**
- * Get a filtered array of items that do not match the value
- *
- * _Available as `exclude` and `filter.remove`_
- *
- * @param array Array to search in
- * @param key Key to get an item's value for matching
- * @param value Value to match against
- * @returns Filtered array of items that do not match the filter
- *
- * @example
- * ```typescript
- * exclude(
- *   [{id: 1}, {id: 2}, {id: 3}],
- *   'id',
- *   2,
- * ); // => [{id: 1}, {id: 3}]
- * ```
- */
-export function exclude<Item extends PlainObject, ItemKey extends keyof Item>(
-	array: Item[],
-	key: ItemKey,
-	value: Item[ItemKey],
-): unknown[];
-
-/**
- * Get a filtered array of items that do not match the filter
- *
- * _Available as `exclude` and `filter.remove`_
- *
- * @param array Array to search in
- * @param filter Filter callback to match items
- * @returns Filtered array of items that do not match the filter
- *
- * @example
- * ```typescript
- * exclude(
- *   [{id: 1}, {id: 2}, {id: 3}],
- *   item => item.id === 2,
- * ); // => [{id: 1}, {id: 3}]
- * ```
- */
-export function exclude<Item>(
-	array: Item[],
-	filter: (item: Item, index: number, array: Item[]) => boolean,
-): unknown[];
-
-/**
- * Get a filtered array of items that do not match the given item
- *
- * _Available as `exclude` and `filter.remove`_
- *
- * @param array Array to search in
- * @param item Item to match against
- * @returns Filtered array of items that do not match the given item
- *
- * @example
- * ```typescript
- * exclude([1, 2, 3], 2); // => [1, 3]
- * ```
- */
-export function exclude<Item>(array: Item[], item: Item): unknown[];
-
-export function exclude(array: unknown[], ...parameters: unknown[]): unknown[] {
-	return findValues(FIND_VALUES_ALL, array, parameters).notMatched;
-}
-
-/**
- * Get a filtered array of items
- *
- * @param array Array to search in
- * @param callback Callback to get an item's value for matching
- * @param value Value to match against
- * @returns Filtered array of items
- *
- * @example
- * ```typescript
- * filter(
- *   [{id: 1}, {id: 2}, {id: 3}],
- *   item => item.id,
- *   2,
- * ); // => [{id: 2}]
- * ```
- */
-export function filter<
-	Item,
-	Callback extends (item: Item, index: number, array: Item[]) => unknown,
->(array: Item[], callback: Callback, value: ReturnType<Callback>): Item[];
-
-/**
- * Get a filtered array of items
- *
- * @param array Array to search in
- * @param key Key to get an item's value for matching
- * @param value Value to match against
- * @returns Filtered array of items
- *
- * @example
- * ```typescript
- * filter(
- *   [{id: 1}, {id: 2}, {id: 3}],
- *   'id',
- *   2,
- * ); // => [{id: 2}]
- * ```
- */
-export function filter<Item extends PlainObject, ItemKey extends keyof Item>(
-	array: Item[],
-	key: ItemKey,
-	value: Item[ItemKey],
-): Item[];
-
-/**
- * Get a filtered array of items matching the filter
- *
- * @param array Array to search in
- * @param filter Filter callback to match items
- * @returns Filtered array of items
- *
- * @example
- * ```typescript
- * filter(
- *   [{id: 1}, {id: 2}, {id: 3}],
- *   item => item.id === 2,
- * ); // => [{id: 2}]
- * ```
- */
-export function filter<Item>(
-	array: Item[],
-	filter: (item: Item, index: number, array: Item[]) => boolean,
-): Item[];
-
-/**
- * Get a filtered array of items matching the given item
- *
- * @param array Array to search in
- * @param item Item to match against
- * @returns Filtered array of items
- *
- * @example
- * ```typescript
- * filter([1, 2, 3], 2); // => [2]
- * ```
- */
-export function filter<Item>(array: Item[], item: Item): Item[];
-
-export function filter(array: unknown[], ...parameters: unknown[]): unknown[] {
-	return findValues(FIND_VALUES_ALL, array, parameters).matched;
-}
-
-filter.remove = exclude;
-
-// #endregion