@oscarpalmer/atoms 0.124.0 → 0.125.0

package/dist/array/group-by.js

@@ -2,7 +2,8 @@ import { groupValues } from "../internal/array/group.js";
 function groupBy(array, first, second) {
 	return groupValues(array, first, second, false);
 }
-function groupByArrays(array, first, second) {
+groupBy.arrays = groupArraysBy;
+function groupArraysBy(array, first, second) {
 	return groupValues(array, first, second, true);
 }
-export { groupBy, groupByArrays };
+export { groupBy };

package/dist/array/index.js

@@ -3,7 +3,7 @@ import { filter } from "./filter.js";
 import { find } from "./find.js";
 import { flatten } from "./flatten.js";
 import { getArray } from "./get.js";
-import { groupBy, groupByArrays } from "./group-by.js";
+import { groupBy } from "./group-by.js";
 import { indexOf } from "./index-of.js";
 import { chunk } from "../internal/array/chunk.js";
 import { compact } from "../internal/array/compact.js";
@@ -12,8 +12,8 @@ import { insert } from "./insert.js";
 import { push } from "./push.js";
 import { sort } from "./sort.js";
 import { splice } from "./splice.js";
-import { toMap, toMapArrays } from "./to-map.js";
-import { toRecord, toRecordArrays } from "./to-record.js";
+import { toMap } from "./to-map.js";
+import { toRecord } from "./to-record.js";
 import { toSet } from "./to-set.js";
 import { unique } from "./unique.js";
-export { chunk, compact, exists, filter, find, flatten, getArray, groupBy, groupByArrays, indexOf, insert, push, shuffle, sort, splice, toMap, toMapArrays, toRecord, toRecordArrays, toSet, unique };
+export { chunk, compact, exists, filter, find, flatten, getArray, groupBy, indexOf, insert, push, shuffle, sort, splice, toMap, toRecord, toSet, unique };

package/dist/array/to-map.js

@@ -19,7 +19,8 @@ function getMapValues(array, first, second, arrays) {
 function toMap(array, first, second) {
 	return getMapValues(array, first, second, false);
 }
+toMap.arrays = toMapArrays;
 function toMapArrays(array, first, second) {
 	return getMapValues(array, first, second, true);
 }
-export { toMap, toMapArrays };
+export { toMap };

package/dist/array/to-record.js

@@ -2,7 +2,8 @@ import { groupValues } from "../internal/array/group.js";
 function toRecord(array, first, second) {
 	return groupValues(array, first, second, false);
 }
+toRecord.arrays = toRecordArrays;
 function toRecordArrays(array, first, second) {
 	return groupValues(array, first, second, true);
 }
-export { toRecord, toRecordArrays };
+export { toRecord };

package/dist/atoms.full.js

@@ -210,7 +210,8 @@ function groupValues(array, key, value, arrays) {
 function groupBy(array, first, second) {
 	return groupValues(array, first, second, false);
 }
-function groupByArrays(array, first, second) {
+groupBy.arrays = groupArraysBy;
+function groupArraysBy(array, first, second) {
 	return groupValues(array, first, second, true);
 }
 function indexOf(array, ...parameters) {
@@ -443,12 +444,14 @@ function getMapValues(array, first, second, arrays) {
 function toMap(array, first, second) {
 	return getMapValues(array, first, second, false);
 }
+toMap.arrays = toMapArrays;
 function toMapArrays(array, first, second) {
 	return getMapValues(array, first, second, true);
 }
 function toRecord(array, first, second) {
 	return groupValues(array, first, second, false);
 }
+toRecord.arrays = toRecordArrays;
 function toRecordArrays(array, first, second) {
 	return groupValues(array, first, second, true);
 }
@@ -1673,12 +1676,12 @@ function template(value, variables, options) {
 	const { ignoreCase, pattern } = getTemplateOptions(options);
 	return handleTemplate(value, pattern, ignoreCase, variables);
 }
-function templater(options) {
+template.initialize = function(options) {
 	const { ignoreCase, pattern } = getTemplateOptions(options);
 	return (value, variables) => {
 		return handleTemplate(value, pattern, ignoreCase, variables);
 	};
-}
+};
 const EXPRESSION_VARIABLE = /{{([\s\S]+?)}}/g;
 function equal(first, second, options) {
 	return equalValue(first, second, getEqualOptions(options));
@@ -1778,10 +1781,10 @@ function equalValue(first, second, options) {
 		default: return Object.is(first, second);
 	}
 }
-function equalizer(options) {
+equal.initialize = function(options) {
 	const actual = getEqualOptions(options);
 	return (first, second) => equalValue(first, second, actual);
-}
+};
 function filterKey(key, options) {
 	if (typeof key !== "string") return true;
 	if (options.ignoreExpressions.enabled && options.ignoreExpressions.values.some((expression) => expression.test(key))) return false;
@@ -2020,10 +2023,10 @@ function handleMerge(values, options) {
 function merge(values, options) {
 	return handleMerge(values, getMergeOptions(options));
 }
-function merger(options) {
+merge.initialize = function(options) {
 	const actual = getMergeOptions(options);
 	return (values) => handleMerge(values, actual);
-}
+};
 function mergeObjects(values, options, prefix) {
 	const { length } = values;
 	const isArray = values.every(Array.isArray);
@@ -2113,4 +2116,4 @@ function unsmush(value) {
 	}
 	return unsmushed;
 }
-export { frame_rate_default as FRAME_RATE_MS, SizedMap, SizedSet, average, beacon, between, camelCase, capitalize, chunk, clamp, clone, compact, compare, count, createUuid, debounce, diff, equal, equalizer, exists, filter, find, flatten, fromQuery, getArray, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getUuid, getValue, groupBy, groupByArrays, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, indexOf, insert, isArrayOrPlainObject, isColor, isEmpty, isHexColor, isHslColor, isHslLike, isHslaColor, isKey, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isPlainObject, isPrimitive, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, max, memoize, merge, merger, min, noop, parse, partial, pascalCase, push, rgbToHex, rgbToHsl, rgbToHsla, round, setValue, shuffle, smush, snakeCase, sort, splice, sum, template, templater, throttle, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toSet, truncate, unique, unsmush, words };
+export { frame_rate_default as FRAME_RATE_MS, SizedMap, SizedSet, average, beacon, between, camelCase, capitalize, chunk, clamp, clone, compact, compare, count, createUuid, debounce, diff, equal, exists, filter, find, flatten, fromQuery, getArray, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getUuid, getValue, groupBy, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, indexOf, insert, isArrayOrPlainObject, isColor, isEmpty, isHexColor, isHslColor, isHslLike, isHslaColor, isKey, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isPlainObject, isPrimitive, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, max, memoize, merge, min, noop, parse, partial, pascalCase, push, rgbToHex, rgbToHsl, rgbToHsla, round, setValue, shuffle, smush, snakeCase, sort, splice, sum, template, throttle, titleCase, toMap, toQuery, toRecord, toSet, truncate, unique, unsmush, words };

package/dist/index.js

@@ -4,7 +4,7 @@ import { find } from "./array/find.js";
 import { flatten } from "./array/flatten.js";
 import { isArrayOrPlainObject, isKey, isNumber, isPlainObject, isTypedArray } from "./internal/is.js";
 import { getArray } from "./array/get.js";
-import { groupBy, groupByArrays } from "./array/group-by.js";
+import { groupBy } from "./array/group-by.js";
 import { indexOf } from "./array/index-of.js";
 import { chunk } from "./internal/array/chunk.js";
 import { compact } from "./internal/array/compact.js";
@@ -17,10 +17,11 @@ import { getString, join, words } from "./internal/string.js";
 import { compare } from "./internal/value/compare.js";
 import { sort } from "./array/sort.js";
 import { splice } from "./array/splice.js";
-import { toMap, toMapArrays } from "./array/to-map.js";
-import { toRecord, toRecordArrays } from "./array/to-record.js";
+import { toMap } from "./array/to-map.js";
+import { toRecord } from "./array/to-record.js";
 import { toSet } from "./array/to-set.js";
 import { unique } from "./array/unique.js";
+import "./array/index.js";
 import { noop } from "./internal/function.js";
 import { beacon } from "./beacon.js";
 import { between, clamp, getNumber } from "./internal/number.js";
@@ -42,13 +43,14 @@ import { getRandomBoolean, getRandomCharacters, getRandomColor, getRandomHex, ge
 import { camelCase, capitalize, kebabCase, pascalCase, snakeCase, titleCase } from "./string/case.js";
 import { createUuid, getUuid, parse, truncate } from "./string/misc.js";
 import { getValue } from "./internal/value/get.js";
-import { template, templater } from "./string/template.js";
+import { template } from "./string/template.js";
 import "./string/index.js";
-import { equal, equalizer } from "./internal/value/equal.js";
+import { equal } from "./internal/value/equal.js";
 import { diff } from "./value/diff.js";
 import { clone } from "./value/clone.js";
-import { merge, merger } from "./value/merge.js";
+import { merge } from "./value/merge.js";
 import { partial } from "./value/partial.js";
 import { smush } from "./value/smush.js";
 import { unsmush } from "./value/unsmush.js";
-export { frame_rate_default as FRAME_RATE_MS, SizedMap, SizedSet, average, beacon, between, camelCase, capitalize, chunk, clamp, clone, compact, compare, count, createUuid, debounce, diff, equal, equalizer, exists, filter, find, flatten, fromQuery, getArray, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getUuid, getValue, groupBy, groupByArrays, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, indexOf, insert, isArrayOrPlainObject, isColor, isEmpty, isHexColor, isHslColor, isHslLike, isHslaColor, isKey, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isPlainObject, isPrimitive, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, max, memoize, merge, merger, min, noop, parse, partial, pascalCase, push, rgbToHex, rgbToHsl, rgbToHsla, round, setValue, shuffle, smush, snakeCase, sort, splice, sum, template, templater, throttle, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toSet, truncate, unique, unsmush, words };
+import "./value/index.js";
+export { frame_rate_default as FRAME_RATE_MS, SizedMap, SizedSet, average, beacon, between, camelCase, capitalize, chunk, clamp, clone, compact, compare, count, createUuid, debounce, diff, equal, exists, filter, find, flatten, fromQuery, getArray, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getUuid, getValue, groupBy, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, indexOf, insert, isArrayOrPlainObject, isColor, isEmpty, isHexColor, isHslColor, isHslLike, isHslaColor, isKey, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isPlainObject, isPrimitive, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, max, memoize, merge, min, noop, parse, partial, pascalCase, push, rgbToHex, rgbToHsl, rgbToHsla, round, setValue, shuffle, smush, snakeCase, sort, splice, sum, template, throttle, titleCase, toMap, toQuery, toRecord, toSet, truncate, unique, unsmush, words };

package/dist/internal/value/equal.js

@@ -98,10 +98,10 @@ function equalValue(first, second, options) {
 		default: return Object.is(first, second);
 	}
 }
-function equalizer(options) {
+equal.initialize = function(options) {
 	const actual = getEqualOptions(options);
 	return (first, second) => equalValue(first, second, actual);
-}
+};
 function filterKey(key, options) {
 	if (typeof key !== "string") return true;
 	if (options.ignoreExpressions.enabled && options.ignoreExpressions.values.some((expression) => expression.test(key))) return false;
@@ -136,4 +136,4 @@ function getEqualOptions(input) {
 }
 var ARRAY_PEEK_PERCENTAGE = 10;
 var ARRAY_THRESHOLD = 100;
-export { equal, equalizer };
+export { equal };

package/dist/string/index.js

@@ -1,5 +1,5 @@
 import { getString, join, words } from "../internal/string.js";
 import { camelCase, capitalize, kebabCase, pascalCase, snakeCase, titleCase } from "./case.js";
 import { createUuid, getUuid, parse, truncate } from "./misc.js";
-import { template, templater } from "./template.js";
-export { camelCase, capitalize, createUuid, getString, getUuid, join, kebabCase, parse, pascalCase, snakeCase, template, templater, titleCase, truncate, words };
+import { template } from "./template.js";
+export { camelCase, capitalize, createUuid, getString, getUuid, join, kebabCase, parse, pascalCase, snakeCase, template, titleCase, truncate, words };

package/dist/string/template.js

@@ -24,11 +24,11 @@ function template(value, variables, options) {
 	const { ignoreCase, pattern } = getTemplateOptions(options);
 	return handleTemplate(value, pattern, ignoreCase, variables);
 }
-function templater(options) {
+template.initialize = function(options) {
 	const { ignoreCase, pattern } = getTemplateOptions(options);
 	return (value, variables) => {
 		return handleTemplate(value, pattern, ignoreCase, variables);
 	};
-}
+};
 var EXPRESSION_VARIABLE = /{{([\s\S]+?)}}/g;
-export { template, templater };
+export { template };

package/dist/value/index.js

@@ -1,11 +1,11 @@
 import { compare } from "../internal/value/compare.js";
 import { setValue } from "../internal/value/set.js";
 import { getValue } from "../internal/value/get.js";
-import { equal, equalizer } from "../internal/value/equal.js";
+import { equal } from "../internal/value/equal.js";
 import { diff } from "./diff.js";
 import { clone } from "./clone.js";
-import { merge, merger } from "./merge.js";
+import { merge } from "./merge.js";
 import { partial } from "./partial.js";
 import { smush } from "./smush.js";
 import { unsmush } from "./unsmush.js";
-export { clone, compare, diff, equal, equalizer, getValue, merge, merger, partial, setValue, smush, unsmush };
+export { clone, compare, diff, equal, getValue, merge, partial, setValue, smush, unsmush };

package/dist/value/merge.js

@@ -20,10 +20,10 @@ function handleMerge(values, options) {
 function merge(values, options) {
 	return handleMerge(values, getMergeOptions(options));
 }
-function merger(options) {
+merge.initialize = function(options) {
 	const actual = getMergeOptions(options);
 	return (values) => handleMerge(values, actual);
-}
+};
 function mergeObjects(values, options, prefix) {
 	const { length } = values;
 	const isArray = values.every(Array.isArray);
@@ -48,4 +48,4 @@ function mergeValues(values, options, validate, prefix) {
 	const actual = validate ? values.filter(isArrayOrPlainObject) : values;
 	return actual.length > 1 ? mergeObjects(actual, options, prefix) : actual[0] ?? {};
 }
-export { merge, merger };
+export { merge };

package/package.json

@@ -8,9 +8,9 @@
 		"@types/node": "^25",
 		"@vitest/coverage-istanbul": "^4",
 		"jsdom": "^27.4",
-		"oxfmt": "^0.21",
-		"oxlint": "^1.36",
-		"rolldown": "1.0.0-beta.57",
+		"oxfmt": "^0.23",
+		"oxlint": "^1.38",
+		"rolldown": "1.0.0-beta.58",
 		"tslib": "^2.8",
 		"typescript": "^5.9",
 		"vite": "8.0.0-beta.5",
@@ -101,5 +101,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.124.0"
+	"version": "0.125.0"
 }

package/src/array/group-by.ts

@@ -114,6 +114,8 @@ export function groupBy(array: unknown[], first?: unknown, second?: unknown): un
 	return groupValues(array, first, second, false);
 }
 
+groupBy.arrays = groupArraysBy;
+
 /**
  * Create a record from an array of items using a specific key and value, grouping values into arrays
  * @param array Array to group
@@ -121,7 +123,7 @@ export function groupBy(array: unknown[], first?: unknown, second?: unknown): un
  * @param value Callback to get an item's value
  * @returns Record of keyed values
  */
-export function groupByArrays<
+function groupArraysBy<
 	Item,
 	KeyCallback extends (item: Item, index: number, array: Item[]) => Key,
 	ValueCallback extends (item: Item, index: number, array: Item[]) => unknown,
@@ -138,7 +140,7 @@ export function groupByArrays<
  * @param value Key to use for value
  * @returns Record of keyed values
  */
-export function groupByArrays<
+function groupArraysBy<
 	Item extends PlainObject,
 	KeyCallback extends (item: Item, index: number, array: Item[]) => Key,
 	ItemValue extends keyof Item,
@@ -155,7 +157,7 @@ export function groupByArrays<
  * @param value Callback to get an item's value
  * @returns Record of keyed values
  */
-export function groupByArrays<
+function groupArraysBy<
 	Item extends PlainObject,
 	ItemKey extends keyof Item,
 	ValueCallback extends (item: Item, index: number, array: Item[]) => unknown,
@@ -172,7 +174,7 @@ export function groupByArrays<
  * @param value Key to use for value
  * @returns Record of keyed values
  */
-export function groupByArrays<
+function groupArraysBy<
 	Item extends PlainObject,
 	ItemKey extends keyof Item,
 	ItemValue extends keyof Item,
@@ -188,10 +190,10 @@ export function groupByArrays<
  * @param callback Callback to get an item's grouping key
  * @returns Record of keyed items
  */
-export function groupByArrays<
-	Item,
-	Callback extends (item: Item, index: number, array: Item[]) => Key,
->(array: Item[], callback: Callback): Record<ReturnType<Callback>, Item[]>;
+function groupArraysBy<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, grouping items into arrays
@@ -199,11 +201,11 @@ export function groupByArrays<
  * @param key Key to use for grouping
  * @returns Record of keyed items
  */
-export function groupByArrays<Item extends PlainObject, ItemKey extends keyof Item>(
+function groupArraysBy<Item extends PlainObject, ItemKey extends keyof Item>(
 	array: Item[],
 	key: ItemKey,
 ): Simplify<Record<KeyedValue<Item, ItemKey>, Item[]>>;
 
-export function groupByArrays(array: unknown[], first?: unknown, second?: unknown): unknown {
+function groupArraysBy(array: unknown[], first?: unknown, second?: unknown): unknown {
 	return groupValues(array, first, second, true);
 }

package/src/array/index.ts

@@ -6,7 +6,7 @@ export {filter} from './filter';
 export {find} from './find';
 export {flatten} from './flatten';
 export {getArray} from './get';
-export {groupBy, groupByArrays} from './group-by';
+export {groupBy} from './group-by';
 export {indexOf} from './index-of';
 export {insert} from './insert';
 export type {
@@ -21,7 +21,7 @@ export type {
 export {push} from './push';
 export {sort} from './sort';
 export {splice} from './splice';
-export {toMap, toMapArrays} from './to-map';
-export {toRecord, toRecordArrays} from './to-record';
+export {toMap} from './to-map';
+export {toRecord} from './to-record';
 export {toSet} from './to-set';
 export {unique} from './unique';

package/src/array/to-map.ts

@@ -138,6 +138,8 @@ export function toMap(array: unknown[], first?: unknown, second?: unknown): unkn
 	return getMapValues(array, first, second, false);
 }
 
+toMap.arrays = toMapArrays;
+
 /**
  * Create a Map from an array of items using callbacks, grouping values into arrays
  * @param array Array to convert
@@ -145,7 +147,7 @@ export function toMap(array: unknown[], first?: unknown, second?: unknown): unkn
  * @param value Callback to get an item's value
  * @returns Map of keyed arrays of values
  */
-export function toMapArrays<
+function toMapArrays<
 	Item,
 	KeyCallback extends (item: Item, index: number, array: Item[]) => Key,
 	ValueCallback extends (item: Item, index: number, array: Item[]) => unknown,
@@ -162,7 +164,7 @@ export function toMapArrays<
  * @param value Key to use for value
  * @returns Map of keyed arrays of values
  */
-export function toMapArrays<
+function toMapArrays<
 	Item extends PlainObject,
 	KeyCallback extends (item: Item, index: number, array: Item[]) => Key,
 	ItemValue extends keyof Item,
@@ -179,7 +181,7 @@ export function toMapArrays<
  * @param value Callback to get an item's value
  * @returns Map of keyed arrays of values
  */
-export function toMapArrays<
+function toMapArrays<
 	Item extends PlainObject,
 	ItemKey extends keyof Item,
 	ValueCallback extends (item: Item, index: number, array: Item[]) => unknown,
@@ -196,7 +198,7 @@ export function toMapArrays<
  * @param value Key to use for value
  * @returns Map of keyed arrays of values
  */
-export function toMapArrays<
+function toMapArrays<
 	Item extends PlainObject,
 	ItemKey extends keyof Item,
 	ItemValue extends keyof Item,
@@ -208,10 +210,10 @@ export function toMapArrays<
  * @param callback Callback to get an item's grouping key
  * @returns Map of keyed arrays of items
  */
-export function toMapArrays<
-	Item,
-	Callback extends (item: Item, index: number, array: Item[]) => Key,
->(array: Item[], callback: Callback): Map<ReturnType<Callback>, Item[]>;
+function toMapArrays<Item, Callback extends (item: Item, index: number, array: Item[]) => Key>(
+	array: Item[],
+	callback: Callback,
+): Map<ReturnType<Callback>, Item[]>;
 
 /**
  * Create a Map from an array of items using a key, grouping items into arrays
@@ -219,11 +221,11 @@ export function toMapArrays<
  * @param key Key to use for grouping
  * @returns Map of keyed arrays of items
  */
-export function toMapArrays<Item extends PlainObject, ItemKey extends keyof Item>(
+function toMapArrays<Item extends PlainObject, ItemKey extends keyof Item>(
 	array: Item[],
 	key: ItemKey,
 ): Map<Item[ItemKey], Item[]>;
 
-export function toMapArrays(array: unknown[], first?: unknown, second?: unknown): unknown {
+function toMapArrays(array: unknown[], first?: unknown, second?: unknown): unknown {
 	return getMapValues(array, first, second, true);
 }

package/src/array/to-record.ts

@@ -114,6 +114,8 @@ export function toRecord(array: unknown[], first?: unknown, second?: unknown): u
 	return groupValues(array, first, second, false);
 }
 
+toRecord.arrays = toRecordArrays;
+
 /**
  * Create a record from an array of items using callbacks, grouping values into arrays
  * @param array Array to convert
@@ -121,7 +123,7 @@ export function toRecord(array: unknown[], first?: unknown, second?: unknown): u
  * @param value Callback to get an item's value
  * @returns Record of keyed arrays of values
  */
-export function toRecordArrays<
+function toRecordArrays<
 	Item,
 	KeyCallback extends (item: Item, index: number, array: Item[]) => Key,
 	ValueCallback extends (item: Item, index: number, array: Item[]) => unknown,
@@ -138,7 +140,7 @@ export function toRecordArrays<
  * @param value Key to use for value
  * @returns Record of keyed arrays of values
  */
-export function toRecordArrays<
+function toRecordArrays<
 	Item extends PlainObject,
 	Callback extends (item: Item, index: number, array: Item[]) => Key,
 	ItemValue extends keyof Item,
@@ -155,7 +157,7 @@ export function toRecordArrays<
  * @param callback Callback to get an item's value
  * @returns Record of keyed arrays of values
  */
-export function toRecordArrays<
+function toRecordArrays<
 	Item extends PlainObject,
 	ItemKey extends keyof Item,
 	Callback extends (item: Item, index: number, array: Item[]) => unknown,
@@ -172,7 +174,7 @@ export function toRecordArrays<
  * @param value Key to use for value
  * @returns Record of keyed arrays of values
  */
-export function toRecordArrays<
+function toRecordArrays<
 	Item extends PlainObject,
 	ItemKey extends keyof Item,
 	ItemValue extends keyof Item,
@@ -188,10 +190,10 @@ export function toRecordArrays<
  * @param callback Callback to get an item's grouping key
  * @returns Record of keyed arrays of items
  */
-export function toRecordArrays<
-	Item,
-	Callback extends (item: Item, index: number, array: Item[]) => Key,
->(array: Item[], callback: Callback): Record<ReturnType<Callback>, Item[]>;
+function toRecordArrays<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 key, grouping items into arrays
@@ -199,11 +201,11 @@ export function toRecordArrays<
  * @param key Key to use for grouping
  * @returns Record of keyed arrays of items
  */
-export function toRecordArrays<Item extends PlainObject, ItemKey extends keyof Item>(
+function toRecordArrays<Item extends PlainObject, ItemKey extends keyof Item>(
 	array: Item[],
 	key: ItemKey,
 ): Simplify<Record<KeyedValue<Item, ItemKey>, Item[]>>;
 
-export function toRecordArrays(array: unknown[], first?: unknown, second?: unknown): unknown {
+function toRecordArrays(array: unknown[], first?: unknown, second?: unknown): unknown {
 	return groupValues(array, first, second, true);
 }

package/src/internal/value/equal.ts

@@ -296,11 +296,11 @@ function equalValue(first: unknown, second: unknown, options: Options): boolean
  * @param options Comparison options
  * @returns Equalizer function
  */
-export function equalizer(options?: EqualOptions): Equalizer {
+equal.initialize = function (options?: EqualOptions): Equalizer {
 	const actual = getEqualOptions(options);
 
 	return (first: unknown, second: unknown): boolean => equalValue(first, second, actual);
-}
+};
 
 function filterKey(key: string | symbol, options: Options): boolean {
 	if (typeof key !== 'string') {

package/src/string/index.ts

@@ -2,4 +2,4 @@ export {getString, join, words} from '../internal/string';
 export type {PlainObject} from '../models';
 export {camelCase, capitalize, kebabCase, pascalCase, snakeCase, titleCase} from './case';
 export {createUuid, getUuid, parse, truncate} from './misc';
-export {template, templater} from './template';
+export {template} from './template';

package/src/string/template.ts

@@ -82,13 +82,13 @@ export function template(
  * @param options Templating options
  * @returns Templater function
  */
-export function templater(options?: Partial<TemplateOptions>): Templater {
+template.initialize = function (options?: Partial<TemplateOptions>): Templater {
 	const {ignoreCase, pattern} = getTemplateOptions(options);
 
 	return (value: string, variables?: PlainObject): string => {
 		return handleTemplate(value, pattern, ignoreCase, variables);
 	};
-}
+};
 
 //
 

package/src/value/index.ts

@@ -1,11 +1,11 @@
 export {compare} from '../internal/value/compare';
 export {diff} from './diff';
-export {equal, equalizer} from '../internal/value/equal';
+export {equal} from '../internal/value/equal';
 export {getValue} from '../internal/value/get';
 export {setValue} from '../internal/value/set';
 export type {ArrayOrPlainObject, NestedPartial, PlainObject} from '../models';
 export {clone} from './clone';
-export {merge, merger} from './merge';
+export {merge} from './merge';
 export {partial} from './partial';
 export {smush} from './smush';
 export {unsmush} from './unsmush';

package/src/value/merge.ts

@@ -88,12 +88,12 @@ export function merge<Model extends ArrayOrPlainObject>(
  * @param options Merging options
  * @returns Merger function
  */
-export function merger(options?: Partial<MergeOptions>): Merger {
+merge.initialize = function (options?: Partial<MergeOptions>): Merger {
 	const actual = getMergeOptions(options);
 
 	return <Model extends ArrayOrPlainObject>(values: NestedPartial<Model>[]): Model =>
 		handleMerge(values, actual) as Model;
-}
+};
 
 function mergeObjects(
 	values: ArrayOrPlainObject[],

package/types/array/group-by.d.ts

@@ -63,6 +63,9 @@ export declare function groupBy<Item extends PlainObject, ItemKey extends keyof
  * @returns Record of indiced items
  */
 export declare function groupBy<Item>(array: Item[]): Record<number, Item>;
+export 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
  * @param array Array to group
@@ -70,7 +73,7 @@ export declare function groupBy<Item>(array: Item[]): Record<number, Item>;
  * @param value Callback to get an item's value
  * @returns Record of keyed values
  */
-export declare function groupByArrays<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): Record<ReturnType<KeyCallback>, ReturnType<ValueCallback>[]>;
+declare function groupArraysBy<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): Record<ReturnType<KeyCallback>, ReturnType<ValueCallback>[]>;
 /**
  * Create a record from an array of items using a specific key and value, grouping values into arrays
  * @param array Array to group
@@ -78,7 +81,7 @@ export declare function groupByArrays<Item, KeyCallback extends (item: Item, ind
  * @param value Key to use for value
  * @returns Record of keyed values
  */
-export declare function groupByArrays<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 groupArraysBy<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, grouping values into arrays
  * @param array Array to group
@@ -86,7 +89,7 @@ export declare function groupByArrays<Item extends PlainObject, KeyCallback exte
  * @param value Callback to get an item's value
  * @returns Record of keyed values
  */
-export declare function groupByArrays<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 groupArraysBy<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, grouping values into arrays
  * @param array Array to group
@@ -94,18 +97,19 @@ export declare function groupByArrays<Item extends PlainObject, ItemKey extends
  * @param value Key to use for value
  * @returns Record of keyed values
  */
-export declare function groupByArrays<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 groupArraysBy<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, grouping items into arrays
  * @param array Array to group
  * @param callback Callback to get an item's grouping key
  * @returns Record of keyed items
  */
-export declare function groupByArrays<Item, Callback extends (item: Item, index: number, array: Item[]) => Key>(array: Item[], callback: Callback): Record<ReturnType<Callback>, Item[]>;
+declare function groupArraysBy<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, grouping items into arrays
  * @param array Array to group
  * @param key Key to use for grouping
  * @returns Record of keyed items
  */
-export declare function groupByArrays<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Simplify<Record<KeyedValue<Item, ItemKey>, Item[]>>;
+declare function groupArraysBy<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Simplify<Record<KeyedValue<Item, ItemKey>, Item[]>>;
+export {};

package/types/array/index.d.ts

@@ -6,14 +6,14 @@ export { filter } from './filter';
 export { find } from './find';
 export { flatten } from './flatten';
 export { getArray } from './get';
-export { groupBy, groupByArrays } from './group-by';
+export { groupBy } from './group-by';
 export { indexOf } from './index-of';
 export { insert } from './insert';
 export type { CallbackSorter, Key, KeySorter, KeyedValue, NestedArray, NumericalKeys, PlainObject, } from './models';
 export { push } from './push';
 export { sort } from './sort';
 export { splice } from './splice';
-export { toMap, toMapArrays } from './to-map';
-export { toRecord, toRecordArrays } from './to-record';
+export { toMap } from './to-map';
+export { toRecord } from './to-record';
 export { toSet } from './to-set';
 export { unique } from './unique';

package/types/array/to-map.d.ts

@@ -63,6 +63,9 @@ export declare function toMap<Item extends PlainObject, ItemKey extends keyof It
  * @returns Map of indiced items
  */
 export declare function toMap<Item>(array: Item[]): Map<number, Item>;
+export declare namespace toMap {
+    var arrays: typeof toMapArrays;
+}
 /**
  * Create a Map from an array of items using callbacks, grouping values into arrays
  * @param array Array to convert
@@ -70,7 +73,7 @@ export declare function toMap<Item>(array: Item[]): Map<number, Item>;
  * @param value Callback to get an item's value
  * @returns Map of keyed arrays of values
  */
-export declare function toMapArrays<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): Map<ReturnType<KeyCallback>, ReturnType<ValueCallback>[]>;
+declare function toMapArrays<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): Map<ReturnType<KeyCallback>, ReturnType<ValueCallback>[]>;
 /**
  * Create a Map from an array of items using a callback and value, grouping values into arrays
  * @param array Array to convert
@@ -78,7 +81,7 @@ export declare function toMapArrays<Item, KeyCallback extends (item: Item, index
  * @param value Key to use for value
  * @returns Map of keyed arrays of values
  */
-export declare function toMapArrays<Item extends PlainObject, KeyCallback extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: KeyCallback, value: ItemValue): Map<ReturnType<KeyCallback>, Item[ItemValue][]>;
+declare function toMapArrays<Item extends PlainObject, KeyCallback extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: KeyCallback, value: ItemValue): Map<ReturnType<KeyCallback>, Item[ItemValue][]>;
 /**
  * Create a Map from an array of items using a key and callback, grouping values into arrays
  * @param array Array to convert
@@ -86,7 +89,7 @@ export declare function toMapArrays<Item extends PlainObject, KeyCallback extend
  * @param value Callback to get an item's value
  * @returns Map of keyed arrays of values
  */
-export declare function toMapArrays<Item extends PlainObject, ItemKey extends keyof Item, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ValueCallback): Map<Item[ItemKey], ReturnType<ValueCallback>[]>;
+declare function toMapArrays<Item extends PlainObject, ItemKey extends keyof Item, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ValueCallback): Map<Item[ItemKey], ReturnType<ValueCallback>[]>;
 /**
  * Create a Map from an array of items using a key and value, grouping values into arrays
  * @param array Array to convert
@@ -94,18 +97,19 @@ export declare function toMapArrays<Item extends PlainObject, ItemKey extends ke
  * @param value Key to use for value
  * @returns Map of keyed arrays of values
  */
-export declare function toMapArrays<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Map<Item[ItemKey], Item[ItemValue][]>;
+declare function toMapArrays<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Map<Item[ItemKey], Item[ItemValue][]>;
 /**
  * Create a Map from an array of items using a callback, grouping items into arrays
  * @param array Array to convert
  * @param callback Callback to get an item's grouping key
  * @returns Map of keyed arrays of items
  */
-export declare function toMapArrays<Item, Callback extends (item: Item, index: number, array: Item[]) => Key>(array: Item[], callback: Callback): Map<ReturnType<Callback>, Item[]>;
+declare function toMapArrays<Item, Callback extends (item: Item, index: number, array: Item[]) => Key>(array: Item[], callback: Callback): Map<ReturnType<Callback>, Item[]>;
 /**
  * Create a Map from an array of items using a key, grouping items into arrays
  * @param array Array to convert
  * @param key Key to use for grouping
  * @returns Map of keyed arrays of items
  */
-export declare function toMapArrays<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Map<Item[ItemKey], Item[]>;
+declare function toMapArrays<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Map<Item[ItemKey], Item[]>;
+export {};

package/types/array/to-record.d.ts

@@ -63,6 +63,9 @@ export declare function toRecord<Item extends PlainObject, ItemKey extends keyof
  * @returns Record of indiced values
  */
 export declare function toRecord<Item>(array: Item[]): Record<number, Item>;
+export declare namespace toRecord {
+    var arrays: typeof toRecordArrays;
+}
 /**
  * Create a record from an array of items using callbacks, grouping values into arrays
  * @param array Array to convert
@@ -70,7 +73,7 @@ export declare function toRecord<Item>(array: Item[]): Record<number, Item>;
  * @param value Callback to get an item's value
  * @returns Record of keyed arrays of values
  */
-export declare function toRecordArrays<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): Record<ReturnType<KeyCallback>, ReturnType<ValueCallback>[]>;
+declare function toRecordArrays<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): Record<ReturnType<KeyCallback>, ReturnType<ValueCallback>[]>;
 /**
  * Create a record from an array of items using a callback and value, grouping values into arrays
  * @param array Array to convert
@@ -78,7 +81,7 @@ export declare function toRecordArrays<Item, KeyCallback extends (item: Item, in
  * @param value Key to use for value
  * @returns Record of keyed arrays of values
  */
-export declare function toRecordArrays<Item extends PlainObject, Callback extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], callback: Callback, value: ItemValue): Record<ReturnType<Callback>, Item[ItemValue][]>;
+declare function toRecordArrays<Item extends PlainObject, Callback extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], callback: Callback, value: ItemValue): Record<ReturnType<Callback>, Item[ItemValue][]>;
 /**
  * Create a record from an array of items using a key and callback, grouping values into arrays
  * @param array Array to convert
@@ -86,7 +89,7 @@ export declare function toRecordArrays<Item extends PlainObject, Callback extend
  * @param callback Callback to get an item's value
  * @returns Record of keyed arrays of values
  */
-export declare function toRecordArrays<Item extends PlainObject, ItemKey extends keyof Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, callback: Callback): Simplify<Record<KeyedValue<Item, ItemKey>, ReturnType<Callback>[]>>;
+declare function toRecordArrays<Item extends PlainObject, ItemKey extends keyof Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, callback: Callback): Simplify<Record<KeyedValue<Item, ItemKey>, ReturnType<Callback>[]>>;
 /**
  * Create a record from an array of items using a key and value, grouping values into arrays
  * @param array Array to convert
@@ -94,18 +97,19 @@ export declare function toRecordArrays<Item extends PlainObject, ItemKey extends
  * @param value Key to use for value
  * @returns Record of keyed arrays of values
  */
-export declare function toRecordArrays<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 toRecordArrays<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 callback, grouping items into arrays
  * @param array Array to convert
  * @param callback Callback to get an item's grouping key
  * @returns Record of keyed arrays of items
  */
-export declare function toRecordArrays<Item, Callback extends (item: Item, index: number, array: Item[]) => Key>(array: Item[], callback: Callback): Record<ReturnType<Callback>, Item[]>;
+declare function toRecordArrays<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 key, grouping items into arrays
  * @param array Array to convert
  * @param key Key to use for grouping
  * @returns Record of keyed arrays of items
  */
-export declare function toRecordArrays<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Simplify<Record<KeyedValue<Item, ItemKey>, Item[]>>;
+declare function toRecordArrays<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Simplify<Record<KeyedValue<Item, ItemKey>, Item[]>>;
+export {};

package/types/internal/value/equal.d.ts

@@ -35,10 +35,7 @@ export declare function equal(first: string, second: string, ignoreCase?: boolea
  * @returns `true` if the values are equal, otherwise `false`
  */
 export declare function equal(first: unknown, second: unknown, options?: EqualOptions): boolean;
-/**
- * Create an equalizer with predefined options
- * @param options Comparison options
- * @returns Equalizer function
- */
-export declare function equalizer(options?: EqualOptions): Equalizer;
+export declare namespace equal {
+    var initialize: (options?: EqualOptions) => Equalizer;
+}
 export {};

package/types/string/index.d.ts

@@ -2,4 +2,4 @@ export { getString, join, words } from '../internal/string';
 export type { PlainObject } from '../models';
 export { camelCase, capitalize, kebabCase, pascalCase, snakeCase, titleCase } from './case';
 export { createUuid, getUuid, parse, truncate } from './misc';
-export { template, templater } from './template';
+export { template } from './template';

package/types/string/template.d.ts

@@ -24,10 +24,7 @@ type Templater = (value: string, variables?: PlainObject) => string;
  * @returns Templated string
  */
 export declare function template(value: string, variables: PlainObject, options?: Partial<TemplateOptions>): string;
-/**
- * Create a templater with predefined options
- * @param options Templating options
- * @returns Templater function
- */
-export declare function templater(options?: Partial<TemplateOptions>): Templater;
+export declare namespace template {
+    var initialize: (options?: Partial<TemplateOptions>) => Templater;
+}
 export {};

package/types/value/index.d.ts

@@ -1,11 +1,11 @@
 export { compare } from '../internal/value/compare';
 export { diff } from './diff';
-export { equal, equalizer } from '../internal/value/equal';
+export { equal } from '../internal/value/equal';
 export { getValue } from '../internal/value/get';
 export { setValue } from '../internal/value/set';
 export type { ArrayOrPlainObject, NestedPartial, PlainObject } from '../models';
 export { clone } from './clone';
-export { merge, merger } from './merge';
+export { merge } from './merge';
 export { partial } from './partial';
 export { smush } from './smush';
 export { unsmush } from './unsmush';

package/types/value/merge.d.ts

@@ -31,10 +31,7 @@ type Merger<Model extends ArrayOrPlainObject = ArrayOrPlainObject> = (values: Ne
  * @returns Merged value
  */
 export declare function merge<Model extends ArrayOrPlainObject>(values: NestedPartial<Model>[], options?: Partial<MergeOptions>): Model;
-/**
- * Create a merger with predefined options
- * @param options Merging options
- * @returns Merger function
- */
-export declare function merger(options?: Partial<MergeOptions>): Merger;
+export declare namespace merge {
+    var initialize: (options?: Partial<MergeOptions>) => Merger;
+}
 export {};