@oscarpalmer/atoms 0.180.0 → 0.181.0

package/dist/internal/array/find.d.mts

@@ -10,12 +10,13 @@ type Parameters = {
   key?: unknown;
   value?: unknown;
 };
-declare function findValue(type: FindValueType, array: unknown[], parameters: unknown[], reversed: boolean): unknown;
+declare function findValue(type: Exclude<FindValueType, 'item'>, array: unknown[], parameters: unknown[], reversed: boolean): number;
+declare function findValue(type: Exclude<FindValueType, 'index'>, array: unknown[], parameters: unknown[], reversed: boolean): unknown;
 declare function findAbsoluteValueOrDefault(array: unknown[], parameters: unknown[], defaultValue: unknown, useDefaultValue: boolean, reversed: boolean): unknown;
 declare function findValues(type: FindValuesType, array: unknown[], parameters: unknown[], mapper?: unknown): FindValuesResult;
 declare function getFindParameters(original: unknown[]): Parameters;
-declare const FIND_VALUE_INDEX: FindValueType;
-declare const FIND_VALUE_ITEM: FindValueType;
+declare const FIND_VALUE_INDEX = "index";
+declare const FIND_VALUE_ITEM = "item";
 declare const FIND_VALUES_ALL: FindValuesType;
 declare const FIND_VALUES_UNIQUE: FindValuesType;
 //#endregion

package/dist/internal/array/find.mjs

@@ -5,9 +5,12 @@ function findValue(type, array, parameters, reversed) {
 	if (!Array.isArray(array) || array.length === 0) return findIndex ? -1 : void 0;
 	const { bool, key, value } = getFindParameters(parameters);
 	const callbacks = getArrayCallbacks(bool, key);
-	if (callbacks?.bool == null && callbacks?.keyed == null) return findIndex ? array.indexOf(value) : array.find((item) => Object.is(item, value));
+	if (callbacks?.bool == null && callbacks?.keyed == null) {
+		if (findIndex) return reversed ? array.lastIndexOf(value) : array.indexOf(value);
+		return reversed ? array.findLast((item) => Object.is(item, value)) : array.find((item) => Object.is(item, value));
+	}
 	if (callbacks.bool != null) {
-		const index = array.findIndex(callbacks.bool);
+		const index = reversed ? array.findLastIndex(callbacks.bool) : array.findIndex(callbacks.bool);
 		return findIndex ? index : array[index];
 	}
 	return findValueInArray(array, callbacks.keyed, value, findIndex, reversed);

package/dist/internal/array/index-of.d.mts

@@ -31,5 +31,46 @@ declare function indexOf<Item>(array: Item[], filter: (item: Item, index: number
  * @returns Index of the first matching item, or `-1` if no match is found
  */
 declare function indexOf<Item>(array: Item[], item: Item): number;
+declare namespace indexOf {
+  var last: typeof lastIndexOf;
+}
+/**
+ * Get the index of the last matching item by callback
+ *
+ * Available as `lastIndexOf` and `indexOf.last`
+ * @param array Array to search in
+ * @param callback Callback to get an item's value
+ * @param value Value to match against
+ * @returns Index of the last matching item, or `-1` if no match is found
+ */
+declare function lastIndexOf<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): number;
+/**
+ * Get the index of the last matching item by key
+ *
+ * Available as `lastIndexOf` and `indexOf.last`
+ * @param array Array to search in
+ * @param key Key to match items by
+ * @param value Value to match against
+ * @returns Index of the last matching item, or `-1` if no match is found
+ */
+declare function lastIndexOf<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): number;
+/**
+ * Get the index of the last item matching the filter
+ *
+ * Available as `lastIndexOf` and `indexOf.last`
+ * @param array Array to search in
+ * @param filter Filter callback to match items
+ * @returns Index of the last matching item, or `-1` if no match is found
+ */
+declare function lastIndexOf<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): number;
+/**
+ * Get the index of the last item matching the given item
+ *
+ * Available as `lastIndexOf` and `indexOf.last`
+ * @param array Array to search in
+ * @param item Item to match against
+ * @returns Index of the last matching item, or `-1` if no match is found
+ */
+declare function lastIndexOf<Item>(array: Item[], item: Item): number;
 //#endregion
-export { indexOf };
+export { indexOf, lastIndexOf };

package/dist/internal/array/index-of.mjs

@@ -3,5 +3,9 @@ import { FIND_VALUE_INDEX, findValue } from "./find.mjs";
 function indexOf(array, ...parameters) {
 	return findValue(FIND_VALUE_INDEX, array, parameters, false);
 }
+indexOf.last = lastIndexOf;
+function lastIndexOf(array, ...parameters) {
+	return findValue(FIND_VALUE_INDEX, array, parameters, true);
+}
 //#endregion
-export { indexOf };
+export { indexOf, lastIndexOf };

package/dist/internal/math/aggregate.mjs

@@ -1,4 +1,4 @@
-import { isNumber } from "../is.mjs";
+import { isNonNumber } from "../is.mjs";
 //#region src/internal/math/aggregate.ts
 function aggregate(type, array, key) {
 	const length = Array.isArray(array) ? array.length : 0;
@@ -14,7 +14,7 @@ function aggregate(type, array, key) {
 	for (let index = 0; index < length; index += 1) {
 		const item = array[index];
 		const value = callback == null ? item : callback(item, index, array);
-		if (!isNumber(value)) continue;
+		if (isNonNumber(value)) continue;
 		aggregated = aggregator(aggregated, value, notNumber);
 		counted += 1;
 		notNumber = false;

package/dist/internal/result.mjs

@@ -1,7 +1,7 @@
-import { isPlainObject } from "./is.mjs";
+import { isNonPlainObject } from "./is.mjs";
 //#region src/internal/result.ts
 function _isResult(value, okValue) {
-	if (!isPlainObject(value)) return false;
+	if (isNonPlainObject(value)) return false;
 	return value.ok === okValue && (okValue ? PROPERTY_VALUE : PROPERTY_ERROR) in value;
 }
 function isError(value, extended) {

package/dist/internal/string.d.mts

@@ -7,12 +7,14 @@
 declare function getString(value: unknown): string;
 declare function ignoreKey(key: string): boolean;
 /**
- * Join an array of values into a string
- * @param value Array of values
+ * Join an array of values into a string _(while ignoring empty values)_
+ *
+ * _(`null`, `undefined`, and any values that become whitespace-only strings are considered empty)_
+ * @param array Array of values
  * @param delimiter Delimiter to use between values
  * @returns Joined string
  */
-declare function join(value: unknown[], delimiter?: string): string;
+declare function join(array: unknown[], delimiter?: string): string;
 declare function tryDecode(value: string): string;
 declare function tryEncode(value: boolean | number | string): unknown;
 /**

package/dist/internal/string.mjs

@@ -1,4 +1,3 @@
-import { compact } from "./array/compact.mjs";
 //#region src/internal/string.ts
 /**
 * Get the string value from any value
@@ -17,13 +16,23 @@ function ignoreKey(key) {
 	return EXPRESSION_IGNORED.test(key);
 }
 /**
-* Join an array of values into a string
-* @param value Array of values
+* Join an array of values into a string _(while ignoring empty values)_
+*
+* _(`null`, `undefined`, and any values that become whitespace-only strings are considered empty)_
+* @param array Array of values
 * @param delimiter Delimiter to use between values
 * @returns Joined string
 */
-function join(value, delimiter) {
-	return compact(value).map(getString).join(typeof delimiter === "string" ? delimiter : "");
+function join(array, delimiter) {
+	if (!Array.isArray(array)) return "";
+	const { length } = array;
+	if (length === 0) return "";
+	const values = [];
+	for (let index = 0; index < length; index += 1) {
+		const item = getString(array[index]);
+		if (item.trim().length > 0) values.push(item);
+	}
+	return values.join(typeof delimiter === "string" ? delimiter : "");
 }
 function tryCallback(value, callback) {
 	try {

package/dist/internal/value/equal.mjs

@@ -1,4 +1,4 @@
-import { isPlainObject, isPrimitive, isTypedArray } from "../is.mjs";
+import { isNonPlainObject, isPlainObject, isPrimitive, isTypedArray } from "../is.mjs";
 import { getCompareHandlers } from "./handlers.mjs";
 //#region src/internal/value/equal.ts
 /**
@@ -131,7 +131,7 @@ function getEqualOptions(input) {
 		options.ignoreCase = input;
 		return options;
 	}
-	if (!isPlainObject(input)) return options;
+	if (isNonPlainObject(input)) return options;
 	options.ignoreCase = typeof input.ignoreCase === "boolean" ? input.ignoreCase : false;
 	options.ignoreExpressions.values = (Array.isArray(input.ignoreKeys) ? input.ignoreKeys : [input.ignoreKeys]).filter((key) => key instanceof RegExp);
 	options.ignoreKeys.values = new Set((Array.isArray(input.ignoreKeys) ? input.ignoreKeys : [input.ignoreKeys]).filter((key) => typeof key === "string"));

package/dist/internal/value/handlers.mjs

@@ -1,4 +1,4 @@
-import { isConstructor } from "../is.mjs";
+import { isNonConstructor } from "../is.mjs";
 //#region src/internal/value/handlers.ts
 function getCompareHandlers(owner, options) {
 	const handlers = getHandlers(owner, options);
@@ -26,7 +26,7 @@ function getHandlers(owner, options) {
 			if (isConstructable(first) && isConstructable(second) && first.constructor === second.constructor) return handlers.get(first.constructor);
 		},
 		register(constructor, handler) {
-			if (!isConstructor(constructor) || handler === owner) return;
+			if (isNonConstructor(constructor) || handler === owner) return;
 			let actual = handler ?? options.method;
 			if (typeof actual !== "function" && typeof actual !== "string") return;
 			if (typeof actual === "string") actual = typeof constructor.prototype[actual] === "function" ? actual : void 0;

package/dist/value/index.d.mts

@@ -1,5 +1,6 @@
 import { omit } from "./omit.mjs";
 import { pick } from "./pick.mjs";
+import { Shaken, shake } from "./shake.mjs";
 import { Smushed, smush } from "./smush.mjs";
 import { Unsmushed, unsmush } from "./unsmush.mjs";
-export { type Smushed, type Unsmushed, omit, pick, smush, unsmush };
+export { type Shaken, type Smushed, type Unsmushed, omit, pick, shake, smush, unsmush };

package/dist/value/index.mjs

@@ -1,5 +1,6 @@
 import { omit } from "./omit.mjs";
 import { pick } from "./pick.mjs";
+import { shake } from "./shake.mjs";
 import { smush } from "./smush.mjs";
 import { unsmush } from "./unsmush.mjs";
-export { omit, pick, smush, unsmush };
+export { omit, pick, shake, smush, unsmush };

package/dist/value/merge.d.mts

@@ -5,16 +5,29 @@ import { ArrayOrPlainObject, NestedPartial } from "../models.mjs";
  * Options for merging values
  */
 type MergeOptions = {
+  /**
+   * Assign values to the first array or object instead of creating a new one?
+   */
+  assignValues?: boolean;
   /**
    * Key _(or key epxressions)_ for values that should be replaced
+   *
    * ```ts
    * merge([{items: [1, 2, 3]}, {items: [99]}]); // {items: [99]}
    * ```
    */
   replaceableObjects?: string | RegExp | Array<string | RegExp>;
+  /**
+   * Skip nullable values when merging objects?
+   *
+   * ```ts
+   * merge({a: 1, b: 2}, {b: null, c: 3}, {d: null}); // {a: 1, b: 2, c: 3}
+   * ```
+   */
   skipNullableAny?: boolean;
   /**
    * Skip nullable values when merging arrays?
+   *
    * ```ts
    * merge([1, 2, 3], [null, null, 99]); // [1, 2, 99]
    * ```

package/dist/value/merge.mjs

@@ -3,12 +3,14 @@ import { join } from "../internal/string.mjs";
 //#region src/value/merge.ts
 function getMergeOptions(options) {
 	const actual = {
+		assignValues: false,
 		replaceableObjects: void 0,
 		skipNullableAny: false,
 		skipNullableInArrays: false
 	};
 	if (typeof options !== "object" || options == null) return actual;
 	actual.replaceableObjects = getReplaceableObjects(options.replaceableObjects);
+	actual.assignValues = options.assignValues === true;
 	actual.skipNullableAny = options.skipNullableAny === true;
 	actual.skipNullableInArrays = options.skipNullableInArrays === true;
 	return actual;
@@ -38,7 +40,7 @@ merge.initialize = initializeMerger;
 function mergeObjects(values, options, prefix) {
 	const { length } = values;
 	const isArray = values.every(Array.isArray);
-	const merged = isArray ? [] : {};
+	const merged = options.assignValues ? values[0] : isArray ? [] : {};
 	for (let outerIndex = 0; outerIndex < length; outerIndex += 1) {
 		const item = values[outerIndex];
 		const keys = Object.keys(item);

package/dist/value/shake.d.mts

@@ -0,0 +1,7 @@
+import { PlainObject } from "../models.mjs";
+
+//#region src/value/shake.d.ts
+type Shaken<Value extends PlainObject> = { [Key in keyof Value]: Value[Key] extends undefined ? never : Value[Key] };
+declare function shake<Value extends PlainObject>(value: Value): Shaken<Value>;
+//#endregion
+export { Shaken, shake };

package/dist/value/shake.mjs

@@ -0,0 +1,16 @@
+import { isNonPlainObject } from "../internal/is.mjs";
+//#region src/value/shake.ts
+function shake(value) {
+	const shaken = {};
+	if (isNonPlainObject(value)) return shaken;
+	const keys = Object.keys(value);
+	const { length } = keys;
+	for (let index = 0; index < length; index += 1) {
+		const key = keys[index];
+		const val = value[key];
+		if (val !== void 0) shaken[key] = val;
+	}
+	return shaken;
+}
+//#endregion
+export { shake };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/atoms",
-	"version": "0.180.0",
+	"version": "0.181.0",
 	"description": "Atomic utilities for making your JavaScript better.",
 	"keywords": [
 		"helper",

package/src/array/exists.ts

@@ -52,7 +52,7 @@ export function exists(array: unknown[], ...parameters: unknown[]): boolean {
 		return Array.isArray(array) ? array.includes(parameters[0]) : false;
 	}
 
-	return (findValue(FIND_VALUE_INDEX, array, parameters, false) as number) > -1;
+	return findValue(FIND_VALUE_INDEX, array, parameters, false) > -1;
 }
 
 // #endregion

package/src/array/find.ts

@@ -52,4 +52,62 @@ export function find(array: unknown[], ...parameters: unknown[]): unknown {
 	return findValue(FIND_VALUE_ITEM, array, parameters, false);
 }
 
+find.last = findLast;
+
+/**
+ * Get the last item matching the given value
+ *
+ * Available as `findLast` and `find.last`
+ * @param array Array to search in
+ * @param callback Callback to get an item's value for matching
+ * @param value Value to match against
+ * @returns Last item that matches the value, or `undefined` if no match is found
+ */
+export function findLast<
+	Item,
+	Callback extends (item: Item, index: number, array: Item[]) => unknown,
+>(array: Item[], callback: Callback, value: ReturnType<Callback>): Item | undefined;
+
+/**
+ * Get the last item matching the given value by key
+ *
+ * Available as `findLast` and `find.last`
+ * @param array Array to search in
+ * @param key Key to get an item's value for matching
+ * @param value Value to match against
+ * @returns Last item that matches the value, or `undefined` if no match is found
+ */
+export function findLast<Item extends PlainObject, ItemKey extends keyof Item>(
+	array: Item[],
+	key: ItemKey,
+	value: Item[ItemKey],
+): Item | undefined;
+
+/**
+ * Get the last item matching the filter
+ *
+ * Available as `findLast` and `find.last`
+ * @param array Array to search in
+ * @param filter Filter callback to match items
+ * @returns Last item that matches the filter, or `undefined` if no match is found
+ */
+export function findLast<Item>(
+	array: Item[],
+	filter: (item: Item, index: number, array: Item[]) => boolean,
+): Item | undefined;
+
+/**
+ * Get the last item matching the given value
+ *
+ * Available as `findLast` and `find.last`
+ * @param array Array to search in
+ * @param value Value to match against
+ * @returns Last item that matches the value, or `undefined` if no match is found
+ */
+export function findLast<Item>(array: Item[], value: Item): Item | undefined;
+
+export function findLast(array: unknown[], ...parameters: unknown[]): unknown {
+	return findValue(FIND_VALUE_ITEM, array, parameters, true);
+}
+
 // #endregion

package/src/array/get.ts

@@ -1,4 +1,4 @@
-import {isPlainObject} from '../internal/is';
+import {isNonPlainObject} from '../internal/is';
 import type {NumericalKeys, PlainObject} from '../models';
 
 // #region Functions
@@ -50,7 +50,7 @@ export function getArray(value: unknown, indiced?: unknown): unknown[] {
 		return [...value.values()];
 	}
 
-	if (!isPlainObject(value)) {
+	if (isNonPlainObject(value)) {
 		return [value];
 	}
 

package/src/internal/array/find.ts

@@ -21,6 +21,20 @@ type Parameters = {
 
 // #region Functions
 
+export function findValue(
+	type: Exclude<FindValueType, 'item'>,
+	array: unknown[],
+	parameters: unknown[],
+	reversed: boolean,
+): number;
+
+export function findValue(
+	type: Exclude<FindValueType, 'index'>,
+	array: unknown[],
+	parameters: unknown[],
+	reversed: boolean,
+): unknown;
+
 export function findValue(
 	type: FindValueType,
 	array: unknown[],
@@ -38,11 +52,17 @@ export function findValue(
 	const callbacks = getArrayCallbacks(bool, key);
 
 	if (callbacks?.bool == null && callbacks?.keyed == null) {
-		return findIndex ? array.indexOf(value) : array.find(item => Object.is(item, value));
+		if (findIndex) {
+			return reversed ? array.lastIndexOf(value) : array.indexOf(value);
+		}
+
+		return reversed
+			? array.findLast(item => Object.is(item, value))
+			: array.find(item => Object.is(item, value));
 	}
 
 	if (callbacks.bool != null) {
-		const index = array.findIndex(callbacks.bool);
+		const index = reversed ? array.findLastIndex(callbacks.bool) : array.findIndex(callbacks.bool);
 
 		return findIndex ? index : array[index];
 	}
@@ -167,9 +187,9 @@ export function getFindParameters(original: unknown[]): Parameters {
 
 // #region Variables
 
-export const FIND_VALUE_INDEX: FindValueType = 'index';
+export const FIND_VALUE_INDEX = 'index';
 
-export const FIND_VALUE_ITEM: FindValueType = 'item';
+export const FIND_VALUE_ITEM = 'item';
 
 export const FIND_VALUES_ALL: FindValuesType = 'all';
 

package/src/internal/array/index-of.ts

@@ -48,7 +48,65 @@ export function indexOf<Item>(
 export function indexOf<Item>(array: Item[], item: Item): number;
 
 export function indexOf(array: unknown[], ...parameters: unknown[]): number {
-	return findValue(FIND_VALUE_INDEX, array, parameters, false) as number;
+	return findValue(FIND_VALUE_INDEX, array, parameters, false);
+}
+
+indexOf.last = lastIndexOf;
+
+/**
+ * Get the index of the last matching item by callback
+ *
+ * Available as `lastIndexOf` and `indexOf.last`
+ * @param array Array to search in
+ * @param callback Callback to get an item's value
+ * @param value Value to match against
+ * @returns Index of the last matching item, or `-1` if no match is found
+ */
+export function lastIndexOf<
+	Item,
+	Callback extends (item: Item, index: number, array: Item[]) => unknown,
+>(array: Item[], callback: Callback, value: ReturnType<Callback>): number;
+
+/**
+ * Get the index of the last matching item by key
+ *
+ * Available as `lastIndexOf` and `indexOf.last`
+ * @param array Array to search in
+ * @param key Key to match items by
+ * @param value Value to match against
+ * @returns Index of the last matching item, or `-1` if no match is found
+ */
+export function lastIndexOf<Item extends PlainObject, ItemKey extends keyof Item>(
+	array: Item[],
+	key: ItemKey,
+	value: Item[ItemKey],
+): number;
+
+/**
+ * Get the index of the last item matching the filter
+ *
+ * Available as `lastIndexOf` and `indexOf.last`
+ * @param array Array to search in
+ * @param filter Filter callback to match items
+ * @returns Index of the last matching item, or `-1` if no match is found
+ */
+export function lastIndexOf<Item>(
+	array: Item[],
+	filter: (item: Item, index: number, array: Item[]) => boolean,
+): number;
+
+/**
+ * Get the index of the last item matching the given item
+ *
+ * Available as `lastIndexOf` and `indexOf.last`
+ * @param array Array to search in
+ * @param item Item to match against
+ * @returns Index of the last matching item, or `-1` if no match is found
+ */
+export function lastIndexOf<Item>(array: Item[], item: Item): number;
+
+export function lastIndexOf(array: unknown[], ...parameters: unknown[]): number {
+	return findValue(FIND_VALUE_INDEX, array, parameters, true);
 }
 
 // #endregion

package/src/internal/math/aggregate.ts

@@ -1,5 +1,5 @@
 import type {NumericalValues, PlainObject} from '../../models';
-import {isNumber} from '../is';
+import {isNonNumber} from '../is';
 
 // #region Types
 
@@ -40,7 +40,7 @@ export function aggregate(type: AggregationType, array: unknown[], key: unknown)
 
 		const value = callback == null ? item : callback(item as never, index, array);
 
-		if (!isNumber(value)) {
+		if (isNonNumber(value)) {
 			continue;
 		}
 

package/src/internal/result.ts

@@ -1,14 +1,17 @@
+import type {PlainObject} from '../models';
 import type {Err, ExtendedErr, Ok, Result} from '../result/models';
-import {isPlainObject} from './is';
+import {isNonPlainObject} from './is';
 
 // #region Functions
 
 function _isResult(value: unknown, okValue: boolean): value is Result<unknown, unknown> {
-	if (!isPlainObject(value)) {
+	if (isNonPlainObject(value)) {
 		return false;
 	}
 
-	return value.ok === okValue && (okValue ? PROPERTY_VALUE : PROPERTY_ERROR) in value;
+	return (
+		(value as PlainObject).ok === okValue && (okValue ? PROPERTY_VALUE : PROPERTY_ERROR) in value
+	);
 }
 
 /**

package/src/internal/string.ts

@@ -1,5 +1,3 @@
-import {compact} from './array/compact';
-
 // #region Functions
 
 /**
@@ -36,15 +34,35 @@ export function ignoreKey(key: string): boolean {
 }
 
 /**
- * Join an array of values into a string
- * @param value Array of values
+ * Join an array of values into a string _(while ignoring empty values)_
+ *
+ * _(`null`, `undefined`, and any values that become whitespace-only strings are considered empty)_
+ * @param array Array of values
  * @param delimiter Delimiter to use between values
  * @returns Joined string
  */
-export function join(value: unknown[], delimiter?: string): string {
-	return compact(value)
-		.map(getString)
-		.join(typeof delimiter === 'string' ? delimiter : '');
+export function join(array: unknown[], delimiter?: string): string {
+	if (!Array.isArray(array)) {
+		return '';
+	}
+
+	const {length} = array;
+
+	if (length === 0) {
+		return '';
+	}
+
+	const values: string[] = [];
+
+	for (let index = 0; index < length; index += 1) {
+		const item = getString(array[index]);
+
+		if (item.trim().length > 0) {
+			values.push(item);
+		}
+	}
+
+	return values.join(typeof delimiter === 'string' ? delimiter : '');
 }
 
 function tryCallback<T, U>(value: T, callback: (value: T) => U): U {

package/src/internal/value/equal.ts

@@ -1,5 +1,5 @@
 import type {ArrayOrPlainObject, Constructor, PlainObject, TypedArray} from '../../models';
-import {isPlainObject, isPrimitive, isTypedArray} from '../is';
+import {isNonPlainObject, isPlainObject, isPrimitive, isTypedArray} from '../is';
 import {getCompareHandlers} from './handlers';
 
 // #region Types
@@ -377,7 +377,7 @@ function getEqualOptions(input?: boolean | EqualOptions): Options {
 		return options;
 	}
 
-	if (!isPlainObject(input)) {
+	if (isNonPlainObject(input)) {
 		return options;
 	}
 

package/src/internal/value/handlers.ts

@@ -1,5 +1,5 @@
 import type {Constructor, GenericCallback} from '../../models';
-import {isConstructor} from '../is';
+import {isNonConstructor} from '../is';
 
 type Options = {
 	callback: GenericCallback;
@@ -47,7 +47,7 @@ function getHandlers(owner: GenericCallback, options: Options) {
 			}
 		},
 		register(constructor: Constructor, handler?: string | GenericCallback) {
-			if (!isConstructor(constructor) || handler === owner) {
+			if (isNonConstructor(constructor) || handler === owner) {
 				return;
 			}
 

package/src/value/index.ts

@@ -1,4 +1,5 @@
 export {omit} from './omit';
 export {pick} from './pick';
+export {shake, type Shaken} from './shake';
 export {smush, type Smushed} from './smush';
 export {unsmush, type Unsmushed} from './unsmush';