@oscarpalmer/atoms 0.162.0 → 0.164.0

package/{types/array/difference.d.ts → dist/array/difference.d.mts}

@@ -1,4 +1,6 @@
-import type { PlainObject } from '../models';
+import { PlainObject } from "../models.mjs";
+
+//#region src/array/difference.d.ts
 /**
  * Get the items from the first array that are not in the second array
  * @param first First array
@@ -6,7 +8,7 @@ import type { PlainObject } from '../models';
  * @param callback Callback to get an item's value for comparison
  * @returns Unique values from the first array
  */
-export declare function difference<First, Second>(first: First[], second: Second[], callback: (item: First | Second) => unknown): First[];
+declare 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
@@ -14,11 +16,13 @@ export declare function difference<First, Second>(first: First[], second: Second
  * @param key Key to get an item's value for comparison
  * @returns Unique values from the first array
  */
-export declare function difference<First extends PlainObject, Second extends PlainObject, Key extends keyof First & keyof Second>(first: First[], second: Second[], key: Key): First[];
+declare function difference<First extends PlainObject, Second extends PlainObject, Key extends keyof First & keyof Second>(first: First[], second: Second[], key: Key): 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
  */
-export declare function difference<First, Second>(first: First[], second: Second[]): First[];
+declare function difference<First, Second>(first: First[], second: Second[]): First[];
+//#endregion
+export { difference };

package/dist/array/{difference.js → difference.mjs}

@@ -1,4 +1,4 @@
-import { COMPARE_SETS_DIFFERENCE, compareSets } from "../internal/array/sets.js";
+import { COMPARE_SETS_DIFFERENCE, compareSets } from "../internal/array/sets.mjs";
 //#region src/array/difference.ts
 function difference(first, second, key) {
 	return compareSets(COMPARE_SETS_DIFFERENCE, first, second, key);

package/{types/array/exists.d.ts → dist/array/exists.d.mts}

@@ -1,4 +1,6 @@
-import type { PlainObject } from '../models';
+import { PlainObject } from "../models.mjs";
+
+//#region src/array/exists.d.ts
 /**
  * Does an item with a specific value exist in the array?
  * @param array Array to search in
@@ -6,7 +8,7 @@ import type { PlainObject } from '../models';
  * @param value Value to match against
  * @returns `true` if the item exists in the array, otherwise `false`
  */
-export declare function exists<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): boolean;
+declare 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
@@ -14,18 +16,20 @@ export declare function exists<Item, Callback extends (item: Item, index: number
  * @param value Value to match against
  * @returns `true` if the item exists in the array, otherwise `false`
  */
-export declare function exists<Item extends PlainObject, Key extends keyof Item>(array: Item[], key: Key, value: Item[Key]): boolean;
+declare function exists<Item extends PlainObject, Key extends keyof Item>(array: Item[], key: Key, value: Item[Key]): 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`
  */
-export declare function exists<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): boolean;
+declare 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`
  */
-export declare function exists<Item>(array: Item[], item: Item): boolean;
+declare function exists<Item>(array: Item[], item: Item): boolean;
+//#endregion
+export { exists };

package/dist/array/{exists.js → exists.mjs}

@@ -1,4 +1,4 @@
-import { FIND_VALUE_INDEX, findValue } from "../internal/array/find.js";
+import { FIND_VALUE_INDEX, findValue } from "../internal/array/find.mjs";
 //#region src/array/exists.ts
 function exists(array, ...parameters) {
 	if (parameters.length === 1 && typeof parameters[0] !== "function") return Array.isArray(array) ? array.includes(parameters[0]) : false;

package/{types/array/filter.d.ts → dist/array/filter.d.mts}

@@ -1,4 +1,6 @@
-import type { PlainObject } from '../models';
+import { PlainObject } from "../models.mjs";
+
+//#region src/array/filter.d.ts
 /**
  * Get a filtered array of items
  * @param array Array to search in
@@ -6,7 +8,7 @@ import type { PlainObject } from '../models';
  * @param value Value to match against
  * @returns Filtered array of items
  */
-export declare function filter<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): Item[];
+declare 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
@@ -14,26 +16,27 @@ export declare function filter<Item, Callback extends (item: Item, index: number
  * @param value Value to match against
  * @returns Filtered array of items
  */
-export declare function filter<Item extends PlainObject, Key extends keyof Item>(array: Item[], key: Key, value: Item[Key]): Item[];
+declare function filter<Item extends PlainObject, Key extends keyof Item>(array: Item[], key: Key, value: Item[Key]): 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
  */
-export declare function filter<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): Item[];
+declare 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
  */
-export declare function filter<Item>(array: Item[], item: Item): Item[];
-export declare namespace filter {
-    var remove: typeof removeFiltered;
+declare function filter<Item>(array: Item[], item: Item): Item[];
+declare namespace filter {
+  var remove: typeof removeFiltered;
 }
 declare function removeFiltered<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): unknown[];
 declare function removeFiltered<Item extends PlainObject, Key extends keyof Item>(array: Item[], key: Key, value: Item[Key]): unknown[];
 declare function removeFiltered<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): unknown[];
 declare function removeFiltered<Item>(array: Item[], item: Item): unknown[];
-export {};
+//#endregion
+export { filter };

package/dist/array/{filter.js → filter.mjs}

@@ -1,4 +1,4 @@
-import { findValues } from "../internal/array/find.js";
+import { findValues } from "../internal/array/find.mjs";
 //#region src/array/filter.ts
 function filter(array, ...parameters) {
 	return findValues("all", array, parameters).matched;

package/{types/array/find.d.ts → dist/array/find.d.mts}

@@ -1,4 +1,6 @@
-import type { PlainObject } from '../models';
+import { PlainObject } from "../models.mjs";
+
+//#region src/array/find.d.ts
 /**
  * Get the first items matching the given value
  * @param array Array to search in
@@ -6,7 +8,7 @@ import type { PlainObject } from '../models';
  * @param value Value to match against
  * @returns First item that matches the value, or `undefined` if no match is found
  */
-export declare function find<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): Item | undefined;
+declare function find<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): Item | undefined;
 /**
  * Get the first item matching the given value by key
  * @param array Array to search in
@@ -14,18 +16,20 @@ export declare function find<Item, Callback extends (item: Item, index: number,
  * @param value Value to match against
  * @returns First item that matches the value, or `undefined` if no match is found
  */
-export declare function find<Item extends PlainObject, Key extends keyof Item>(array: Item[], key: Key, value: Item[Key]): Item | undefined;
+declare function find<Item extends PlainObject, Key extends keyof Item>(array: Item[], key: Key, value: Item[Key]): Item | undefined;
 /**
  * Get the first item matching the filter
  * @param array Array to search in
  * @param filter Filter callback to match items
  * @returns First item that matches the filter, or `undefined` if no match is found
  */
-export declare function find<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): Item | undefined;
+declare function find<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): Item | undefined;
 /**
  * Get the first item matching the given value
  * @param array Array to search in
  * @param value Value to match against
  * @returns First item that matches the value, or `undefined` if no match is found
  */
-export declare function find<Item>(array: Item[], value: Item): Item | undefined;
+declare function find<Item>(array: Item[], value: Item): Item | undefined;
+//#endregion
+export { find };

package/dist/array/{find.js → find.mjs}

@@ -1,4 +1,4 @@
-import { FIND_VALUE_VALUE, findValue } from "../internal/array/find.js";
+import { FIND_VALUE_VALUE, findValue } from "../internal/array/find.mjs";
 //#region src/array/find.ts
 function find(array, ...parameters) {
 	return findValue(FIND_VALUE_VALUE, array, parameters);

package/dist/array/flatten.d.mts

@@ -0,0 +1,11 @@
+import { NestedArray } from "../models.mjs";
+
+//#region src/array/flatten.d.ts
+/**
+ * Flatten an array _(using native `flat` and maximum depth)_
+ * @param array Array to flatten
+ * @returns Flattened array
+ */
+declare function flatten<Item>(array: Item[]): NestedArray<Item>[];
+//#endregion
+export { flatten };

package/{types/array/from.d.ts → dist/array/from.d.mts}

@@ -1,16 +1,17 @@
+//#region src/array/from.d.ts
 /**
  * Get an array with a specified length, filled with indices
  * @param length Length of the array
  * @returns Array of indices
  */
-export declare function range(length: number): number[];
+declare function range(length: number): number[];
 /**
  * Get an array of numbers in a specified range
  * @param start Starting number _(inclusive)_
  * @param end Ending number _(exclusive)_
  * @returns Array of numbers in range
  */
-export declare function range(start: number, end: number): number[];
+declare function range(start: number, end: number): number[];
 /**
  * Get an array of numbers in a specified range with a specified step
  * @param start Starting number _(inclusive)_
@@ -18,24 +19,26 @@ export declare function range(start: number, end: number): number[];
  * @param step Step between numbers
  * @returns Array of numbers in range
  */
-export declare function range(start: number, end: number, step: number): number[];
+declare function range(start: number, end: number, step: number): number[];
 /**
  * Get an array with a specified length, filled with indices
  * @param length Length of the array
  * @returns Array of indices
  */
-export declare function times(length: number): number[];
+declare function times(length: number): number[];
 /**
  * Get an array with a specified length, filled by values from a callback
  * @param length Length of the array
  * @param callback Callback function to generate values
  * @returns Array of values generated by the callback
  */
-export declare function times<Callback extends (index: number) => unknown>(length: number, callback: Callback): ReturnType<Callback>[];
+declare function times<Callback extends (index: number) => unknown>(length: number, callback: Callback): ReturnType<Callback>[];
 /**
  * Get an array with a specified length, filled with a specified value
  * @param length Length of the array
  * @param value Value to fill the array with
  * @returns Array filled with the specified value
  */
-export declare function times<Value>(length: number, value: Value): Value[];
+declare function times<Value>(length: number, value: Value): Value[];
+//#endregion
+export { range, times };

package/{types/array/get.d.ts → dist/array/get.d.mts}

@@ -1,31 +1,35 @@
-import type { NumericalKeys, PlainObject } from '../models';
+import { NumericalKeys, PlainObject } from "../models.mjs";
+
+//#region src/array/get.d.ts
 /**
  * Get an array from an object, where only values with numerical keys will be included
  * @param value Object to convert to an array
  * @returns Array holding the values of the object's numerical keys
  */
-export declare function getArray<Value extends PlainObject>(value: Value, indiced: true): Value[NumericalKeys<Value>][];
+declare function getArray<Value extends PlainObject>(value: Value, indiced: true): Value[NumericalKeys<Value>][];
 /**
  * Get an array from an object
  * @param value Object to convert to an array
  * @returns Array holding the values of the object
  */
-export declare function getArray<Value extends PlainObject>(value: Value): Value[keyof Value][];
+declare function getArray<Value extends PlainObject>(value: Value): Value[keyof Value][];
 /**
  * Get an array
  * @param value Original array
  * @returns Original array
  */
-export declare function getArray<Item>(value: Item[]): Item[];
+declare function getArray<Item>(value: Item[]): Item[];
 /**
  * Get an array from a value
  * @param value Value to convert to an array
  * @returns Array holding the value
  */
-export declare function getArray<Item>(value: Item): Item[];
+declare function getArray<Item>(value: Item): Item[];
 /**
  * Get an array from an unknown value
  * @param value Value to convert to an array
  * @returns Array of value
  */
-export declare function getArray(value: unknown): unknown[];
+declare function getArray(value: unknown): unknown[];
+//#endregion
+export { getArray };

package/dist/array/{get.js → get.mjs}

@@ -1,4 +1,4 @@
-import { isPlainObject } from "../internal/is.js";
+import { isPlainObject } from "../internal/is.mjs";
 //#region src/array/get.ts
 function getArray(value, indiced) {
 	if (Array.isArray(value)) return value;

package/{types/array/group-by.d.ts → dist/array/group-by.d.mts}

@@ -1,4 +1,6 @@
-import type { Key, KeyedValue, PlainObject, Simplify } from '../models';
+import { Key, KeyedValue, PlainObject, Simplify } from "../models.mjs";
+
+//#region src/array/group-by.d.ts
 /**
  * Create a record from an array of items using a specific key and value
  *
@@ -8,7 +10,7 @@ import type { Key, KeyedValue, PlainObject, Simplify } from '../models';
  * @param value Callback to get an item's value
  * @returns Record of keyed values
  */
-export declare function groupBy<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Simplify<Record<ReturnType<KeyCallback>, ReturnType<ValueCallback>>>;
+declare function groupBy<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Simplify<Record<ReturnType<KeyCallback>, ReturnType<ValueCallback>>>;
 /**
  * Create a record from an array of items using a specific key and value
  *
@@ -18,7 +20,7 @@ export declare function groupBy<Item, KeyCallback extends (item: Item, index: nu
  * @param value Key to use for value
  * @returns Record of keyed values
  */
-export declare function groupBy<Item extends PlainObject, KeyCallback extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: KeyCallback, value: ItemValue): Record<ReturnType<KeyCallback>, Item[ItemValue]>;
+declare function groupBy<Item extends PlainObject, KeyCallback extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: KeyCallback, value: ItemValue): Record<ReturnType<KeyCallback>, Item[ItemValue]>;
 /**
  * Create a record from an array of items using a specific key and value
  *
@@ -28,7 +30,7 @@ export declare function groupBy<Item extends PlainObject, KeyCallback extends (i
  * @param value Callback to get an item's value
  * @returns Record of keyed values
  */
-export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ValueCallback): Simplify<Record<KeyedValue<Item, ItemKey>, ReturnType<ValueCallback>>>;
+declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ValueCallback): Simplify<Record<KeyedValue<Item, ItemKey>, ReturnType<ValueCallback>>>;
 /**
  * Create a record from an array of items using a specific key and value
  *
@@ -38,7 +40,7 @@ export declare function groupBy<Item extends PlainObject, ItemKey extends keyof
  * @param value Key to use for value
  * @returns Record of keyed values
  */
-export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Simplify<Record<KeyedValue<Item, ItemKey>, Item[ItemValue]>>;
+declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Simplify<Record<KeyedValue<Item, ItemKey>, Item[ItemValue]>>;
 /**
  * Create a record from an array of items using a specific key
  *
@@ -47,7 +49,7 @@ export declare function groupBy<Item extends PlainObject, ItemKey extends keyof
  * @param callback Callback to get an item's grouping key
  * @returns Record of keyed items
  */
-export declare function groupBy<Item, Callback extends (item: Item, index: number, array: Item[]) => Key>(array: Item[], callback: Callback): Record<ReturnType<Callback>, Item>;
+declare function groupBy<Item, Callback extends (item: Item, index: number, array: Item[]) => Key>(array: Item[], callback: Callback): Record<ReturnType<Callback>, Item>;
 /**
  * Create a record from an array of items using a specific key
  *
@@ -56,15 +58,15 @@ export declare function groupBy<Item, Callback extends (item: Item, index: numbe
  * @param key Key to use for grouping
  * @returns Record of keyed items
  */
-export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Simplify<Record<KeyedValue<Item, ItemKey>, Item>>;
+declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Simplify<Record<KeyedValue<Item, ItemKey>, Item>>;
 /**
  * Create a record from an array of items _(using indices as keys)_
  * @param array Array to group
  * @returns Record of indiced items
  */
-export declare function groupBy<Item>(array: Item[]): Record<number, Item>;
-export declare namespace groupBy {
-    var arrays: typeof groupArraysBy;
+declare function groupBy<Item>(array: Item[]): Record<number, Item>;
+declare namespace groupBy {
+  var arrays: typeof groupArraysBy;
 }
 /**
  * Create a record from an array of items using a specific key and value, grouping values into arrays
@@ -112,4 +114,5 @@ declare function groupArraysBy<Item, Callback extends (item: Item, index: number
  * @returns Record of keyed items
  */
 declare function groupArraysBy<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Simplify<Record<KeyedValue<Item, ItemKey>, Item[]>>;
-export {};
+//#endregion
+export { groupBy };

package/dist/array/{group-by.js → group-by.mjs}

@@ -1,4 +1,4 @@
-import { groupValues } from "../internal/array/group.js";
+import { groupValues } from "../internal/array/group.mjs";
 //#region src/array/group-by.ts
 function groupBy(array, first, second) {
 	return groupValues(array, first, second, false);

package/dist/array/index.d.mts

@@ -0,0 +1,27 @@
+import { difference } from "./difference.mjs";
+import { exists } from "./exists.mjs";
+import { filter } from "./filter.mjs";
+import { find } from "./find.mjs";
+import { flatten } from "./flatten.mjs";
+import { range, times } from "./from.mjs";
+import { getArray } from "./get.mjs";
+import { chunk } from "../internal/array/chunk.mjs";
+import { compact } from "../internal/array/compact.mjs";
+import { indexOf } from "../internal/array/index-of.mjs";
+import { shuffle } from "../internal/array/shuffle.mjs";
+import { insert } from "./insert.mjs";
+import { intersection } from "./intersection.mjs";
+import { move } from "./move.mjs";
+import { partition } from "./partition.mjs";
+import { ArrayPosition, endsWithArray, getArrayPosition, includesArray, indexOfArray, startsWithArray } from "./position.mjs";
+import { push } from "./push.mjs";
+import { select } from "./select.mjs";
+import { drop, slice, take } from "./slice.mjs";
+import { sort } from "./sort.mjs";
+import { splice } from "./splice.mjs";
+import { swap } from "./swap.mjs";
+import { toSet } from "./to-set.mjs";
+import { toggle } from "./toggle.mjs";
+import { union } from "./union.mjs";
+import { update } from "./update.mjs";
+export { ArrayPosition, chunk, compact, difference, drop, endsWithArray, exists, filter, find, flatten, getArray, getArrayPosition, includesArray, indexOf, indexOfArray, insert, intersection, move, partition, push, range, select, shuffle, slice, sort, splice, startsWithArray, swap, take, times, toSet, toggle, union, update };

package/dist/array/index.mjs

@@ -0,0 +1,27 @@
+import { chunk } from "../internal/array/chunk.mjs";
+import { compact } from "../internal/array/compact.mjs";
+import { indexOf } from "../internal/array/index-of.mjs";
+import { shuffle } from "../internal/array/shuffle.mjs";
+import { difference } from "./difference.mjs";
+import { exists } from "./exists.mjs";
+import { filter } from "./filter.mjs";
+import { find } from "./find.mjs";
+import { flatten } from "./flatten.mjs";
+import { range, times } from "./from.mjs";
+import { getArray } from "./get.mjs";
+import { insert } from "./insert.mjs";
+import { intersection } from "./intersection.mjs";
+import { endsWithArray, getArrayPosition, includesArray, indexOfArray, startsWithArray } from "./position.mjs";
+import { move } from "./move.mjs";
+import { partition } from "./partition.mjs";
+import { push } from "./push.mjs";
+import { select } from "./select.mjs";
+import { drop, slice, take } from "./slice.mjs";
+import { sort } from "./sort.mjs";
+import { splice } from "./splice.mjs";
+import { swap } from "./swap.mjs";
+import { toSet } from "./to-set.mjs";
+import { toggle } from "./toggle.mjs";
+import { union } from "./union.mjs";
+import { update } from "./update.mjs";
+export { chunk, compact, difference, drop, endsWithArray, exists, filter, find, flatten, getArray, getArrayPosition, includesArray, indexOf, indexOfArray, insert, intersection, move, partition, push, range, select, shuffle, slice, sort, splice, startsWithArray, swap, take, times, toSet, toggle, union, update };

package/{types/array/insert.d.ts → dist/array/insert.d.mts}

@@ -1,3 +1,4 @@
+//#region src/array/insert.d.ts
 /**
  * Insert items into an array at a specified index
  * @param array Original array
@@ -5,11 +6,13 @@
  * @param items Inserted items
  * @returns Updated array
  */
-export declare function insert<Item>(array: Item[], index: number, items: Item[]): Item[];
+declare function insert<Item>(array: Item[], index: number, items: Item[]): Item[];
 /**
  * Insert items into an array _(at the end)_
  * @param array Original array
  * @param items Inserted items
  * @returns Updated array
  */
-export declare function insert<Item>(array: Item[], items: Item[]): Item[];
+declare function insert<Item>(array: Item[], items: Item[]): Item[];
+//#endregion
+export { insert };

package/dist/array/{insert.js → insert.mjs}

@@ -1,4 +1,4 @@
-import { INSERT_TYPE_INSERT, insertValues } from "../internal/array/insert.js";
+import { INSERT_TYPE_INSERT, insertValues } from "../internal/array/insert.mjs";
 //#region src/array/insert.ts
 function insert(array, indexOrItems, items) {
 	return insertValues(INSERT_TYPE_INSERT, array, items == null ? indexOrItems : items, typeof indexOrItems === "number" ? indexOrItems : array?.length, 0);

package/{types/array/intersection.d.ts → dist/array/intersection.d.mts}

@@ -1,3 +1,4 @@
+//#region src/array/intersection.d.ts
 /**
  * Get the common values between two arrays
  * @param first First array
@@ -5,7 +6,7 @@
  * @param callback Callback to get an item's value for comparison
  * @returns Common values from both arrays
  */
-export declare function intersection<First, Second>(first: First[], second: Second[], callback: (item: First | Second) => unknown): First[];
+declare function intersection<First, Second>(first: First[], second: Second[], callback: (item: First | Second) => unknown): First[];
 /**
  * Get the common values between two arrays
  * @param first First array
@@ -13,11 +14,13 @@ export declare function intersection<First, Second>(first: First[], second: Seco
  * @param key Key to get an item's value for comparison
  * @returns Common values from both arrays
  */
-export declare function intersection<First extends Record<string, unknown>, Second extends Record<string, unknown>, Key extends keyof First & keyof Second>(first: First[], second: Second[], key: Key): First[];
+declare function intersection<First extends Record<string, unknown>, Second extends Record<string, unknown>, Key extends keyof First & keyof Second>(first: First[], second: Second[], key: Key): First[];
 /**
  * Get the common values between two arrays
  * @param first First array
  * @param second Second array
  * @returns Common values from both arrays
  */
-export declare function intersection<First, Second>(first: First[], second: Second[]): First[];
+declare function intersection<First, Second>(first: First[], second: Second[]): First[];
+//#endregion
+export { intersection };

package/dist/array/{intersection.js → intersection.mjs}

@@ -1,4 +1,4 @@
-import { COMPARE_SETS_INTERSECTION, compareSets } from "../internal/array/sets.js";
+import { COMPARE_SETS_INTERSECTION, compareSets } from "../internal/array/sets.mjs";
 //#region src/array/intersection.ts
 function intersection(first, second, key) {
 	return compareSets(COMPARE_SETS_INTERSECTION, first, second, key);

package/{types/array/move.d.ts → dist/array/move.d.mts}

@@ -1,4 +1,6 @@
-import type { PlainObject } from '../models';
+import { PlainObject } from "../models.mjs";
+
+//#region src/array/move.d.ts
 /**
  * Move an item _(or array of items)_ to the position of another item _(or array of items)_ within an array
  *
@@ -11,7 +13,7 @@ import type { PlainObject } from '../models';
  * @param key Key to get an item's value for matching
  * @returns Original array with items moved _(or unchanged if unable to move)_
  */
-export declare function move<Item extends PlainObject, Key extends keyof Item>(array: Item[], from: Item | Item[], to: Item | Item[], key: Key): Item[];
+declare function move<Item extends PlainObject, Key extends keyof Item>(array: Item[], from: Item | Item[], to: Item | Item[], key: Key): Item[];
 /**
  * Move an item _(or array of items)_ to the position of another item _(or array of items)_ within an array
  *
@@ -24,7 +26,7 @@ export declare function move<Item extends PlainObject, Key extends keyof Item>(a
  * @param callback Callback to get an item's value for matching
  * @returns Original array with items moved _(or unchanged if unable to move)_
  */
-export declare function move<Item>(array: Item[], from: Item | Item[], to: Item | Item[], callback: (item: Item, index: number, array: Item[]) => unknown): Item[];
+declare function move<Item>(array: Item[], from: Item | Item[], to: Item | Item[], callback: (item: Item, index: number, array: Item[]) => unknown): Item[];
 /**
  * Move an item _(or array of items)_ to the position of another item _(or array of items)_ within an array
  *
@@ -36,10 +38,10 @@ export declare function move<Item>(array: Item[], from: Item | Item[], to: Item
  * @param to Item or items to move to
  * @returns Original array with items moved _(or unchanged if unable to move)_
  */
-export declare function move<Item>(array: Item[], from: Item | Item[], to: Item | Item[]): Item[];
-export declare namespace move {
-    var indices: typeof moveIndices;
-    var toIndex: typeof moveToIndex;
+declare function move<Item>(array: Item[], from: Item | Item[], to: Item | Item[]): Item[];
+declare namespace move {
+  var indices: typeof moveIndices;
+  var toIndex: typeof moveToIndex;
 }
 /**
  * Move an item from one index to another within an array
@@ -83,4 +85,5 @@ declare function moveToIndex<Item>(array: Item[], value: Item | Item[], index: n
  * @returns Original array with items moved _(or unchanged if unable to move)_
  */
 declare function moveToIndex<Item>(array: Item[], value: Item | Item[], index: number): Item[];
-export {};
+//#endregion
+export { move };

package/dist/array/{move.js → move.mjs}

@@ -1,5 +1,5 @@
-import { arraysOverlap } from "../internal/array/overlap.js";
-import { indexOfArray } from "./position.js";
+import { arraysOverlap } from "../internal/array/overlap.mjs";
+import { indexOfArray } from "./position.mjs";
 //#region src/array/move.ts
 function move(array, from, to, key) {
 	if (!Array.isArray(array)) return [];

package/{types/array/partition.d.ts → dist/array/partition.d.mts}

@@ -1,4 +1,6 @@
-import type { PlainObject } from '../models';
+import { PlainObject } from "../models.mjs";
+
+//#region src/array/partition.d.ts
 /**
  * Get a partitioned array of items
  * @param array Array to search in
@@ -6,7 +8,7 @@ import type { PlainObject } from '../models';
  * @param value Value to match against
  * @returns Partitioned array of items
  */
-export declare function partition<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): Item[][];
+declare function partition<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): Item[][];
 /**
  * Get a partitioned array of items
  * @param array Array to search in
@@ -14,18 +16,20 @@ export declare function partition<Item, Callback extends (item: Item, index: num
  * @param value Value to match against
  * @returns Partitioned array of items
  */
-export declare function partition<Item extends PlainObject, Key extends keyof Item>(array: Item[], key: Key, value: Item[Key]): Item[][];
+declare function partition<Item extends PlainObject, Key extends keyof Item>(array: Item[], key: Key, value: Item[Key]): Item[][];
 /**
  * Get a partitioned array of items
  * @param array Array to search in
  * @param filter Filter callback to match items
  * @returns Partitioned array of items
  */
-export declare function partition<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): Item[][];
+declare function partition<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): Item[][];
 /**
  * Get a partitioned array of items matching the given item
  * @param array Array to search in
  * @param item Item to match against
  * @returns Partitioned array of items
  */
-export declare function partition<Item>(array: Item[], item: Item): Item[][];
+declare function partition<Item>(array: Item[], item: Item): Item[][];
+//#endregion
+export { partition };

package/dist/array/{partition.js → partition.mjs}

@@ -1,4 +1,4 @@
-import { findValues } from "../internal/array/find.js";
+import { findValues } from "../internal/array/find.mjs";
 //#region src/array/partition.ts
 function partition(array, ...parameters) {
 	const { matched, notMatched } = findValues("all", array, parameters);