@oscarpalmer/atoms 0.181.0 → 0.182.0

package/dist/index.d.mts

@@ -2876,6 +2876,64 @@ declare function setValue<Data extends PlainObject, Path extends NestedKeys<Data
  */
 declare function setValue<Data extends PlainObject>(data: Data, path: string, value: unknown, ignoreCase?: boolean): Data;
 //#endregion
+//#region src/kalas.d.ts
+declare class Events<Map extends Record<string, GenericCallback>> {
+  #private;
+  constructor(kalas: Kalas<Map>);
+  /**
+   * Subscribe to an event with a callback
+   * @param event Event name
+   * @param callback Callback function
+   * @returns Unsubscriber function
+   */
+  subscribe<Event extends keyof Map>(event: Event, callback: Map[Event]): Unsubscriber;
+  /**
+   * Unsubscribe from an event with a callback _(or all callbacks, if no callback is provided)_
+   * @param event Event name
+   * @param callback Callback function
+   * @returns Unsubscriber function
+   */
+  unsubscribe<Event extends keyof Map>(event: Event, callback?: Map[Event]): void;
+}
+declare class Kalas<Map extends Record<string, GenericCallback>> {
+  #private;
+  /**
+   * Events interface for subscribing and unsubscribing to events
+   */
+  readonly events: Events<Map>;
+  constructor(names: (keyof Map)[]);
+  /**
+   * Remove all event subscribers
+   */
+  clear(): void;
+  /**
+   * Emit an event with parameters
+   * @param event Event name
+   * @param parameters Event parameters
+   */
+  emit<Event extends keyof Map>(event: Event, ...parameters: Parameters<Map[Event]>): void;
+  /**
+   * Subscribe to an event with a callback
+   * @param event Event name
+   * @param callback Callback function
+   * @returns Unsubscriber function
+   */
+  subscribe<Event extends keyof Map>(event: Event, callback: Map[Event]): Unsubscriber;
+  /**
+   * Unsubscribe from an event with a callback _(or all callbacks, if no callback is provided)_
+   * @param event Event name
+   * @param callback Callback function
+   */
+  unsubscribe<Event extends keyof Map>(event: Event, callback?: Map[Event]): void;
+}
+type Unsubscriber = () => void;
+/**
+ * Create a Kalas _(party)_ for named events
+ * @param names Event names
+ * @returns Kalas instance
+ */
+declare function kalas<Events extends Record<string, GenericCallback>>(names: (keyof Events)[]): Kalas<Events>;
+//#endregion
 //#region src/string/case.d.ts
 /**
  * Convert a string to camel case _(thisIsCamelCase)_
@@ -3099,6 +3157,60 @@ declare function includes(haystack: string, needle: string, ignoreCase?: boolean
  */
 declare function startsWith(haystack: string, needle: string, ignoreCase?: boolean): boolean;
 //#endregion
+//#region src/string/normalize.d.ts
+/**
+ * Options for normalizing a string
+ */
+type NormalizeOptions = {
+  /**
+   * Remove diacritical marks from the string? _(defaults to `true`)_
+   */
+  deburr?: boolean;
+  /**
+   * Convert the string to lower case? _(defaults to `true`)_
+   */
+  lowerCase?: boolean;
+  /**
+   * Trim the string? _(defaults to `true`)_
+   */
+  trim?: boolean;
+};
+/**
+ * String normalizer function
+ */
+type Normalizer = {
+  /**
+   * Normalize a string
+   * @param value String to normalize
+   * @returns Normalized string
+   */
+  (value: string): string;
+};
+/**
+ * Deburr a string, removing diacritical marks
+ * @param value String to deburr
+ * @returns Deburred string
+ */
+declare function deburr(value: string): string;
+/**
+ * Initialize a string normalizer
+ * @param options Normalization options
+ * @returns Normalizer function
+ */
+declare function initializeNormalizer(options?: NormalizeOptions): Normalizer;
+/**
+ * Normalize a string
+ *
+ * By default, the string will be trimmed, deburred, and then lowercased
+ * @param value String to normalize
+ * @param options Normalization options
+ * @returns Normalized string
+ */
+declare function normalize(value: string, options?: NormalizeOptions): string;
+declare namespace normalize {
+  var initialize: typeof initializeNormalizer;
+}
+//#endregion
 //#region src/string/template.d.ts
 /**
  * Options for templating strings
@@ -5207,4 +5319,4 @@ declare class SizedSet<Value = unknown> extends Set<Value> {
   get(value: Value, update?: boolean): Value | undefined;
 }
 //#endregion
-export { AnyResult, ArrayComparisonSorter, ArrayKeySorter, ArrayOrPlainObject, ArrayPosition, ArrayValueSorter, Asserter, AsyncCancelableCallback, AttemptFlow, AttemptFlowPromise, type Beacon, type BeaconOptions, BuiltIns, CancelableCallback, CancelablePromise, type Color, Constructor, DiffOptions, DiffResult, DiffValue, EqualOptions, Err, EventPosition, ExtendedErr, ExtendedResult, Flow, FlowPromise, FulfilledPromise, FuzzyConfiguration, FuzzyOptions, FuzzyResult, FuzzySearchOptions, GenericAsyncCallback, GenericCallback, type HSLAColor, type HSLColor, Key$1 as Key, KeyedValue, type Logger, type Memoized, type MemoizedOptions, MergeOptions, Merger, NestedArray, NestedKeys, NestedPartial, NestedValue, NestedValues, NumericalKeys, NumericalValues, type Observable, type Observer, Ok, OnceAsyncCallback, OnceCallback, PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED, PlainObject, Primitive, PromiseData, PromiseHandlers, PromiseOptions, PromiseParameters, PromiseStrategy, PromiseTimeoutError, PromisesItems, PromisesOptions, PromisesResult, PromisesUnwrapped, PromisesValue, PromisesValues, type Queue, QueueError, type QueueOptions, type Queued, type QueuedResult, type RGBAColor, type RGBColor, RejectedPromise, RequiredKeys, Result, ResultMatch, RetryError, RetryOptions, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, Shaken, Simplify, SizedMap, SizedSet, Smushed, SortDirection, Sorter, type Subscription, TemplateOptions, type Time, ToString, TypedArray, Unsmushed, UnwrapValue, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, asyncAttempt, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, filter, find, findLast, first, firstOrDefault, flatten, floor, flow, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayPosition, getColor, getError, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeEqualizer, initializeMerger, initializeSorter, initializeTemplater, insert, intersection, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isSorted, isTypedArray, join, kebabCase, last, lastIndexOf, lastOrDefault, logger, lowerCase, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };
+export { AnyResult, ArrayComparisonSorter, ArrayKeySorter, ArrayOrPlainObject, ArrayPosition, ArrayValueSorter, Asserter, AsyncCancelableCallback, AttemptFlow, AttemptFlowPromise, type Beacon, type BeaconOptions, BuiltIns, CancelableCallback, CancelablePromise, type Color, Constructor, DiffOptions, DiffResult, DiffValue, EqualOptions, Err, EventPosition, type Events, ExtendedErr, ExtendedResult, Flow, FlowPromise, FulfilledPromise, FuzzyConfiguration, FuzzyOptions, FuzzyResult, FuzzySearchOptions, GenericAsyncCallback, GenericCallback, type HSLAColor, type HSLColor, type Kalas, Key$1 as Key, KeyedValue, type Logger, type Memoized, type MemoizedOptions, MergeOptions, Merger, NestedArray, NestedKeys, NestedPartial, NestedValue, NestedValues, NormalizeOptions, Normalizer, NumericalKeys, NumericalValues, type Observable, type Observer, Ok, OnceAsyncCallback, OnceCallback, PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED, PlainObject, Primitive, PromiseData, PromiseHandlers, PromiseOptions, PromiseParameters, PromiseStrategy, PromiseTimeoutError, PromisesItems, PromisesOptions, PromisesResult, PromisesUnwrapped, PromisesValue, PromisesValues, type Queue, QueueError, type QueueOptions, type Queued, type QueuedResult, type RGBAColor, type RGBColor, RejectedPromise, RequiredKeys, Result, ResultMatch, RetryError, RetryOptions, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, Shaken, Simplify, SizedMap, SizedSet, Smushed, SortDirection, Sorter, type Subscription, TemplateOptions, type Time, ToString, TypedArray, Unsmushed, Unsubscriber, UnwrapValue, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, asyncAttempt, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, filter, find, findLast, first, firstOrDefault, flatten, floor, flow, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayPosition, getColor, getError, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, insert, intersection, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isSorted, isTypedArray, join, kalas, kebabCase, last, lastIndexOf, lastOrDefault, logger, lowerCase, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };

package/dist/index.mjs

@@ -620,10 +620,10 @@ function select(array, ...parameters) {
 //#region src/array/single.ts
 function single(array, ...parameters) {
 	const { matched } = findValues("all", array, parameters);
-	if (matched.length > 1) throw new Error(MESSAGE);
+	if (matched.length > 1) throw new Error(MESSAGE$1);
 	return matched[0];
 }
-const MESSAGE = "Multiple items were found";
+const MESSAGE$1 = "Multiple items were found";
 //#endregion
 //#region src/array/slice.ts
 function drop(array, first, second) {
@@ -2289,6 +2289,97 @@ function setValue(data, path, value, ignoreCase) {
 }
 const EXPRESSION_INDEX = /^\d+$/;
 //#endregion
+//#region src/kalas.ts
+var Events = class {
+	#kalas;
+	constructor(kalas) {
+		this.#kalas = kalas;
+	}
+	/**
+	* Subscribe to an event with a callback
+	* @param event Event name
+	* @param callback Callback function
+	* @returns Unsubscriber function
+	*/
+	subscribe(event, callback) {
+		return this.#kalas.subscribe(event, callback);
+	}
+	/**
+	* Unsubscribe from an event with a callback _(or all callbacks, if no callback is provided)_
+	* @param event Event name
+	* @param callback Callback function
+	* @returns Unsubscriber function
+	*/
+	unsubscribe(event, callback) {
+		return this.#kalas.unsubscribe(event, callback);
+	}
+};
+var Kalas = class {
+	#names;
+	#subscribers = /* @__PURE__ */ new Map();
+	constructor(names) {
+		this.#names = new Set(names);
+		Object.defineProperty(this, "events", { value: new Events(this) });
+	}
+	/**
+	* Remove all event subscribers
+	*/
+	clear() {
+		this.#subscribers.clear();
+	}
+	/**
+	* Emit an event with parameters
+	* @param event Event name
+	* @param parameters Event parameters
+	*/
+	emit(event, ...parameters) {
+		const subscribers = this.#subscribers.get(event);
+		if (subscribers == null) return;
+		for (const callback of subscribers) callback(...parameters);
+	}
+	/**
+	* Subscribe to an event with a callback
+	* @param event Event name
+	* @param callback Callback function
+	* @returns Unsubscriber function
+	*/
+	subscribe(event, callback) {
+		if (!this.#names.has(event) || typeof callback !== "function") return noop;
+		let subscribers = this.#subscribers.get(event);
+		if (subscribers == null) {
+			subscribers = /* @__PURE__ */ new Set();
+			this.#subscribers.set(event, subscribers);
+		}
+		subscribers.add(callback);
+		return () => {
+			subscribers?.delete(callback);
+		};
+	}
+	/**
+	* Unsubscribe from an event with a callback _(or all callbacks, if no callback is provided)_
+	* @param event Event name
+	* @param callback Callback function
+	*/
+	unsubscribe(event, callback) {
+		if (!this.#names.has(event) || (callback != null ? typeof callback !== "function" : false)) return;
+		const subscribers = this.#subscribers.get(event);
+		if (subscribers == null) return;
+		if (callback == null) subscribers.clear();
+		else subscribers.delete(callback);
+		if (callback == null || subscribers.size === 0) this.#subscribers.delete(event);
+	}
+};
+/**
+* Create a Kalas _(party)_ for named events
+* @param names Event names
+* @returns Kalas instance
+*/
+function kalas(names) {
+	if (!Array.isArray(names) || names.length === 0 || !names.every((name) => typeof name === "string")) throw new Error(MESSAGE);
+	return new Kalas(names);
+}
+const MESSAGE = "Kalas requires an array of event names.";
+//#endregion
 //#region src/string/case.ts
 /**
 * Convert a string to camel case _(thisIsCamelCase)_
@@ -2322,7 +2413,9 @@ function kebabCase(value) {
 * @returns Lower-cased string
 */
 function lowerCase(value) {
-	return typeof value === "string" ? value.toLocaleLowerCase() : "";
+	if (typeof value !== "string") return "";
+	memoizedLowerCase ??= memoize((v) => v.toLocaleLowerCase());
+	return memoizedLowerCase.run(value);
 }
 /**
 * Convert a string to pascal case _(ThisIsPascalCase)_
@@ -2346,8 +2439,8 @@ function snakeCase(value) {
 * @returns Title-cased string
 */
 function titleCase(value) {
-	if (typeof value !== "string") return "";
-	memoizedTitleCase ??= memoize((v) => v.length < 1 ? capitalize(v) : join(words(v).map(capitalize), " "));
+	if (typeof value !== "string" || value.length === 0) return "";
+	memoizedTitleCase ??= memoize((v) => v.length < 2 ? capitalize(v) : join(words(v).map(capitalize), " "));
 	return memoizedTitleCase.run(value);
 }
 function toCase(type, value, capitalizeAny, capitalizeFirst) {
@@ -2387,7 +2480,9 @@ function toCaseCallback(value) {
 * @returns Upper-cased string
 */
 function upperCase(value) {
-	return typeof value === "string" ? value.toLocaleUpperCase() : "";
+	if (typeof value !== "string" || value.length === 0) return "";
+	memoizedUpperCase ??= memoize((v) => v.toLocaleUpperCase());
+	return memoizedUpperCase.run(value);
 }
 const CASE_CAMEL = "camel";
 const CASE_KEBAB = "kebab";
@@ -2408,7 +2503,9 @@ const delimiters = {
 	[CASE_SNAKE]: DELIMITER_UNDERSCORE
 };
 let memoizedCapitalize;
+let memoizedLowerCase;
 let memoizedTitleCase;
+let memoizedUpperCase;
 //#endregion
 //#region src/is.ts
 /**
@@ -2822,6 +2919,95 @@ function truncate(value, length, suffix) {
 }
 const ZERO = "0";
 //#endregion
+//#region src/string/normalize.ts
+/**
+* Deburr a string, removing diacritical marks
+* @param value String to deburr
+* @returns Deburred string
+*/
+function deburr(value) {
+	if (typeof value !== "string") return "";
+	deburrMemoizer ??= memoize((value) => {
+		let deburred = value.normalize(DEBURR_NORMALIZATION).replace(DEBURR_PATTERN_SIMPLE, "");
+		deburred = deburred.replace(DEBURR_PATTERN_CHARACTERS, (_, character) => DEBURR_CHARACTERS[character]);
+		return deburred;
+	});
+	return deburrMemoizer.run(value);
+}
+function getNormalizeOptions(input) {
+	const options = isPlainObject(input) ? input : {};
+	return {
+		deburr: options.deburr !== false,
+		lowerCase: options.lowerCase !== false,
+		trim: options.trim !== false
+	};
+}
+/**
+* Initialize a string normalizer
+* @param options Normalization options
+* @returns Normalizer function
+*/
+function initializeNormalizer(options) {
+	const normalization = getNormalizeOptions(options);
+	return (value) => normalizeString(value, normalization);
+}
+/**
+* Normalize a string
+*
+* By default, the string will be trimmed, deburred, and then lowercased
+* @param value String to normalize
+* @param options Normalization options
+* @returns Normalized string
+*/
+function normalize(value, options) {
+	return normalizeString(value, getNormalizeOptions(options));
+}
+normalize.initialize = initializeNormalizer;
+function normalizeString(value, options) {
+	if (typeof value !== "string") return "";
+	let result = value;
+	if (options.trim) result = result.trim();
+	if (options.deburr) result = deburr(result);
+	if (options.lowerCase) result = lowerCase(result);
+	return result;
+}
+const DEBURR_CHARACTERS = {
+	Æ: "AE",
+	æ: "ae",
+	Ð: "D",
+	ð: "d",
+	Đ: "D",
+	đ: "d",
+	Ħ: "H",
+	ħ: "h",
+	IJ: "IJ",
+	ij: "ij",
+	İ: "I",
+	ı: "i",
+	ĸ: "k",
+	Ŀ: "L",
+	ŀ: "l",
+	Ł: "L",
+	ł: "l",
+	Ŋ: "N",
+	ŋ: "n",
+	ʼn: "'n",
+	Œ: "OE",
+	œ: "oe",
+	Ø: "O",
+	ø: "o",
+	ſ: "s",
+	ß: "ss",
+	Þ: "TH",
+	þ: "th",
+	Ŧ: "T",
+	ŧ: "t"
+};
+const DEBURR_NORMALIZATION = "NFD";
+const DEBURR_PATTERN_CHARACTERS = new RegExp(`(${Object.keys(DEBURR_CHARACTERS).join("|")})`, "g");
+const DEBURR_PATTERN_SIMPLE = /[\u0300-\u036f]/g;
+let deburrMemoizer;
+//#endregion
 //#region src/string/template.ts
 function getTemplateOptions(input) {
 	const options = isPlainObject(input) ? input : {};
@@ -5054,4 +5240,4 @@ var SizedSet = class extends Set {
 	}
 };
 //#endregion
-export { CancelablePromise, PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED, PromiseTimeoutError, QueueError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, asyncAttempt, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, filter, find, findLast, first, firstOrDefault, flatten, floor, flow, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayPosition, getColor, getError, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeEqualizer, initializeMerger, initializeSorter, initializeTemplater, insert, intersection, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isSorted, isTypedArray, join, kebabCase, last, lastIndexOf, lastOrDefault, logger, lowerCase, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };
+export { CancelablePromise, PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED, PromiseTimeoutError, QueueError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, asyncAttempt, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, filter, find, findLast, first, firstOrDefault, flatten, floor, flow, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayPosition, getColor, getError, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, insert, intersection, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isSorted, isTypedArray, join, kalas, kebabCase, last, lastIndexOf, lastOrDefault, logger, lowerCase, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };

package/dist/kalas.d.mts

@@ -0,0 +1,61 @@
+import { GenericCallback } from "./models.mjs";
+
+//#region src/kalas.d.ts
+declare class Events<Map extends Record<string, GenericCallback>> {
+  #private;
+  constructor(kalas: Kalas<Map>);
+  /**
+   * Subscribe to an event with a callback
+   * @param event Event name
+   * @param callback Callback function
+   * @returns Unsubscriber function
+   */
+  subscribe<Event extends keyof Map>(event: Event, callback: Map[Event]): Unsubscriber;
+  /**
+   * Unsubscribe from an event with a callback _(or all callbacks, if no callback is provided)_
+   * @param event Event name
+   * @param callback Callback function
+   * @returns Unsubscriber function
+   */
+  unsubscribe<Event extends keyof Map>(event: Event, callback?: Map[Event]): void;
+}
+declare class Kalas<Map extends Record<string, GenericCallback>> {
+  #private;
+  /**
+   * Events interface for subscribing and unsubscribing to events
+   */
+  readonly events: Events<Map>;
+  constructor(names: (keyof Map)[]);
+  /**
+   * Remove all event subscribers
+   */
+  clear(): void;
+  /**
+   * Emit an event with parameters
+   * @param event Event name
+   * @param parameters Event parameters
+   */
+  emit<Event extends keyof Map>(event: Event, ...parameters: Parameters<Map[Event]>): void;
+  /**
+   * Subscribe to an event with a callback
+   * @param event Event name
+   * @param callback Callback function
+   * @returns Unsubscriber function
+   */
+  subscribe<Event extends keyof Map>(event: Event, callback: Map[Event]): Unsubscriber;
+  /**
+   * Unsubscribe from an event with a callback _(or all callbacks, if no callback is provided)_
+   * @param event Event name
+   * @param callback Callback function
+   */
+  unsubscribe<Event extends keyof Map>(event: Event, callback?: Map[Event]): void;
+}
+type Unsubscriber = () => void;
+/**
+ * Create a Kalas _(party)_ for named events
+ * @param names Event names
+ * @returns Kalas instance
+ */
+declare function kalas<Events extends Record<string, GenericCallback>>(names: (keyof Events)[]): Kalas<Events>;
+//#endregion
+export { type Events, type Kalas, Unsubscriber, kalas };

package/dist/kalas.mjs

@@ -0,0 +1,93 @@
+import { noop } from "./internal/function/misc.mjs";
+//#region src/kalas.ts
+var Events = class {
+	#kalas;
+	constructor(kalas) {
+		this.#kalas = kalas;
+	}
+	/**
+	* Subscribe to an event with a callback
+	* @param event Event name
+	* @param callback Callback function
+	* @returns Unsubscriber function
+	*/
+	subscribe(event, callback) {
+		return this.#kalas.subscribe(event, callback);
+	}
+	/**
+	* Unsubscribe from an event with a callback _(or all callbacks, if no callback is provided)_
+	* @param event Event name
+	* @param callback Callback function
+	* @returns Unsubscriber function
+	*/
+	unsubscribe(event, callback) {
+		return this.#kalas.unsubscribe(event, callback);
+	}
+};
+var Kalas = class {
+	#names;
+	#subscribers = /* @__PURE__ */ new Map();
+	constructor(names) {
+		this.#names = new Set(names);
+		Object.defineProperty(this, "events", { value: new Events(this) });
+	}
+	/**
+	* Remove all event subscribers
+	*/
+	clear() {
+		this.#subscribers.clear();
+	}
+	/**
+	* Emit an event with parameters
+	* @param event Event name
+	* @param parameters Event parameters
+	*/
+	emit(event, ...parameters) {
+		const subscribers = this.#subscribers.get(event);
+		if (subscribers == null) return;
+		for (const callback of subscribers) callback(...parameters);
+	}
+	/**
+	* Subscribe to an event with a callback
+	* @param event Event name
+	* @param callback Callback function
+	* @returns Unsubscriber function
+	*/
+	subscribe(event, callback) {
+		if (!this.#names.has(event) || typeof callback !== "function") return noop;
+		let subscribers = this.#subscribers.get(event);
+		if (subscribers == null) {
+			subscribers = /* @__PURE__ */ new Set();
+			this.#subscribers.set(event, subscribers);
+		}
+		subscribers.add(callback);
+		return () => {
+			subscribers?.delete(callback);
+		};
+	}
+	/**
+	* Unsubscribe from an event with a callback _(or all callbacks, if no callback is provided)_
+	* @param event Event name
+	* @param callback Callback function
+	*/
+	unsubscribe(event, callback) {
+		if (!this.#names.has(event) || (callback != null ? typeof callback !== "function" : false)) return;
+		const subscribers = this.#subscribers.get(event);
+		if (subscribers == null) return;
+		if (callback == null) subscribers.clear();
+		else subscribers.delete(callback);
+		if (callback == null || subscribers.size === 0) this.#subscribers.delete(event);
+	}
+};
+/**
+* Create a Kalas _(party)_ for named events
+* @param names Event names
+* @returns Kalas instance
+*/
+function kalas(names) {
+	if (!Array.isArray(names) || names.length === 0 || !names.every((name) => typeof name === "string")) throw new Error(MESSAGE);
+	return new Kalas(names);
+}
+const MESSAGE = "Kalas requires an array of event names.";
+//#endregion
+export { kalas };

package/dist/string/case.mjs

@@ -33,7 +33,9 @@ function kebabCase(value) {
 * @returns Lower-cased string
 */
 function lowerCase(value) {
-	return typeof value === "string" ? value.toLocaleLowerCase() : "";
+	if (typeof value !== "string") return "";
+	memoizedLowerCase ??= memoize((v) => v.toLocaleLowerCase());
+	return memoizedLowerCase.run(value);
 }
 /**
 * Convert a string to pascal case _(ThisIsPascalCase)_
@@ -57,8 +59,8 @@ function snakeCase(value) {
 * @returns Title-cased string
 */
 function titleCase(value) {
-	if (typeof value !== "string") return "";
-	memoizedTitleCase ??= memoize((v) => v.length < 1 ? capitalize(v) : join(words(v).map(capitalize), " "));
+	if (typeof value !== "string" || value.length === 0) return "";
+	memoizedTitleCase ??= memoize((v) => v.length < 2 ? capitalize(v) : join(words(v).map(capitalize), " "));
 	return memoizedTitleCase.run(value);
 }
 function toCase(type, value, capitalizeAny, capitalizeFirst) {
@@ -98,7 +100,9 @@ function toCaseCallback(value) {
 * @returns Upper-cased string
 */
 function upperCase(value) {
-	return typeof value === "string" ? value.toLocaleUpperCase() : "";
+	if (typeof value !== "string" || value.length === 0) return "";
+	memoizedUpperCase ??= memoize((v) => v.toLocaleUpperCase());
+	return memoizedUpperCase.run(value);
 }
 const CASE_CAMEL = "camel";
 const CASE_KEBAB = "kebab";
@@ -119,6 +123,8 @@ const delimiters = {
 	[CASE_SNAKE]: DELIMITER_UNDERSCORE
 };
 let memoizedCapitalize;
+let memoizedLowerCase;
 let memoizedTitleCase;
+let memoizedUpperCase;
 //#endregion
 export { camelCase, capitalize, kebabCase, lowerCase, pascalCase, snakeCase, titleCase, upperCase };

package/dist/string/normalize.d.mts

@@ -0,0 +1,55 @@
+//#region src/string/normalize.d.ts
+/**
+ * Options for normalizing a string
+ */
+type NormalizeOptions = {
+  /**
+   * Remove diacritical marks from the string? _(defaults to `true`)_
+   */
+  deburr?: boolean;
+  /**
+   * Convert the string to lower case? _(defaults to `true`)_
+   */
+  lowerCase?: boolean;
+  /**
+   * Trim the string? _(defaults to `true`)_
+   */
+  trim?: boolean;
+};
+/**
+ * String normalizer function
+ */
+type Normalizer = {
+  /**
+   * Normalize a string
+   * @param value String to normalize
+   * @returns Normalized string
+   */
+  (value: string): string;
+};
+/**
+ * Deburr a string, removing diacritical marks
+ * @param value String to deburr
+ * @returns Deburred string
+ */
+declare function deburr(value: string): string;
+/**
+ * Initialize a string normalizer
+ * @param options Normalization options
+ * @returns Normalizer function
+ */
+declare function initializeNormalizer(options?: NormalizeOptions): Normalizer;
+/**
+ * Normalize a string
+ *
+ * By default, the string will be trimmed, deburred, and then lowercased
+ * @param value String to normalize
+ * @param options Normalization options
+ * @returns Normalized string
+ */
+declare function normalize(value: string, options?: NormalizeOptions): string;
+declare namespace normalize {
+  var initialize: typeof initializeNormalizer;
+}
+//#endregion
+export { NormalizeOptions, Normalizer, deburr, initializeNormalizer, normalize };

package/dist/string/normalize.mjs

@@ -0,0 +1,93 @@
+import { isPlainObject } from "../internal/is.mjs";
+import { memoize } from "../function/memoize.mjs";
+import { lowerCase } from "./case.mjs";
+//#region src/string/normalize.ts
+/**
+* Deburr a string, removing diacritical marks
+* @param value String to deburr
+* @returns Deburred string
+*/
+function deburr(value) {
+	if (typeof value !== "string") return "";
+	deburrMemoizer ??= memoize((value) => {
+		let deburred = value.normalize(DEBURR_NORMALIZATION).replace(DEBURR_PATTERN_SIMPLE, "");
+		deburred = deburred.replace(DEBURR_PATTERN_CHARACTERS, (_, character) => DEBURR_CHARACTERS[character]);
+		return deburred;
+	});
+	return deburrMemoizer.run(value);
+}
+function getNormalizeOptions(input) {
+	const options = isPlainObject(input) ? input : {};
+	return {
+		deburr: options.deburr !== false,
+		lowerCase: options.lowerCase !== false,
+		trim: options.trim !== false
+	};
+}
+/**
+* Initialize a string normalizer
+* @param options Normalization options
+* @returns Normalizer function
+*/
+function initializeNormalizer(options) {
+	const normalization = getNormalizeOptions(options);
+	return (value) => normalizeString(value, normalization);
+}
+/**
+* Normalize a string
+*
+* By default, the string will be trimmed, deburred, and then lowercased
+* @param value String to normalize
+* @param options Normalization options
+* @returns Normalized string
+*/
+function normalize(value, options) {
+	return normalizeString(value, getNormalizeOptions(options));
+}
+normalize.initialize = initializeNormalizer;
+function normalizeString(value, options) {
+	if (typeof value !== "string") return "";
+	let result = value;
+	if (options.trim) result = result.trim();
+	if (options.deburr) result = deburr(result);
+	if (options.lowerCase) result = lowerCase(result);
+	return result;
+}
+const DEBURR_CHARACTERS = {
+	Æ: "AE",
+	æ: "ae",
+	Ð: "D",
+	ð: "d",
+	Đ: "D",
+	đ: "d",
+	Ħ: "H",
+	ħ: "h",
+	IJ: "IJ",
+	ij: "ij",
+	İ: "I",
+	ı: "i",
+	ĸ: "k",
+	Ŀ: "L",
+	ŀ: "l",
+	Ł: "L",
+	ł: "l",
+	Ŋ: "N",
+	ŋ: "n",
+	ʼn: "'n",
+	Œ: "OE",
+	œ: "oe",
+	Ø: "O",
+	ø: "o",
+	ſ: "s",
+	ß: "ss",
+	Þ: "TH",
+	þ: "th",
+	Ŧ: "T",
+	ŧ: "t"
+};
+const DEBURR_NORMALIZATION = "NFD";
+const DEBURR_PATTERN_CHARACTERS = new RegExp(`(${Object.keys(DEBURR_CHARACTERS).join("|")})`, "g");
+const DEBURR_PATTERN_SIMPLE = /[\u0300-\u036f]/g;
+let deburrMemoizer;
+//#endregion
+export { deburr, initializeNormalizer, normalize };

package/package.json

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

package/src/index.ts

@@ -25,10 +25,13 @@ export * from './internal/value/get';
 export * from './internal/value/has';
 export * from './internal/value/set';
 
+export * from './kalas';
+
 export * from './string/case';
 export * from './string/fuzzy';
 export * from './string/index';
 export * from './string/match';
+export * from './string/normalize';
 export * from './string/template';
 
 export * from './value/clone';

package/src/kalas.ts

@@ -0,0 +1,167 @@
+import {noop} from './internal/function/misc';
+import type {GenericCallback} from './models';
+
+// #region Types
+
+class Events<Map extends Record<string, GenericCallback>> {
+	readonly #kalas: Kalas<Map>;
+
+	constructor(kalas: Kalas<Map>) {
+		this.#kalas = kalas;
+	}
+
+	/**
+	 * Subscribe to an event with a callback
+	 * @param event Event name
+	 * @param callback Callback function
+	 * @returns Unsubscriber function
+	 */
+	subscribe<Event extends keyof Map>(event: Event, callback: Map[Event]): Unsubscriber {
+		return this.#kalas.subscribe(event, callback);
+	}
+
+	/**
+	 * Unsubscribe from an event with a callback _(or all callbacks, if no callback is provided)_
+	 * @param event Event name
+	 * @param callback Callback function
+	 * @returns Unsubscriber function
+	 */
+	unsubscribe<Event extends keyof Map>(event: Event, callback?: Map[Event]): void {
+		return this.#kalas.unsubscribe(event, callback);
+	}
+}
+
+class Kalas<Map extends Record<string, GenericCallback>> {
+	readonly #names: Set<keyof Map>;
+
+	readonly #subscribers = new Map<keyof Map, Set<Map[keyof Map]>>();
+
+	/**
+	 * Events interface for subscribing and unsubscribing to events
+	 */
+	declare readonly events: Events<Map>;
+
+	constructor(names: (keyof Map)[]) {
+		this.#names = new Set(names);
+
+		Object.defineProperty(this, 'events', {
+			value: new Events(this),
+		});
+	}
+
+	/**
+	 * Remove all event subscribers
+	 */
+	clear(): void {
+		this.#subscribers.clear();
+	}
+
+	/**
+	 * Emit an event with parameters
+	 * @param event Event name
+	 * @param parameters Event parameters
+	 */
+	emit<Event extends keyof Map>(event: Event, ...parameters: Parameters<Map[Event]>) {
+		const subscribers = this.#subscribers.get(event);
+
+		if (subscribers == null) {
+			return;
+		}
+
+		for (const callback of subscribers) {
+			callback(...parameters);
+		}
+	}
+
+	/**
+	 * Subscribe to an event with a callback
+	 * @param event Event name
+	 * @param callback Callback function
+	 * @returns Unsubscriber function
+	 */
+	subscribe<Event extends keyof Map>(event: Event, callback: Map[Event]): Unsubscriber {
+		if (!this.#names.has(event) || typeof callback !== 'function') {
+			return noop;
+		}
+
+		let subscribers = this.#subscribers.get(event);
+
+		if (subscribers == null) {
+			subscribers = new Set();
+
+			this.#subscribers.set(event, subscribers);
+		}
+
+		subscribers.add(callback);
+
+		return () => {
+			subscribers?.delete(callback);
+		};
+	}
+
+	/**
+	 * Unsubscribe from an event with a callback _(or all callbacks, if no callback is provided)_
+	 * @param event Event name
+	 * @param callback Callback function
+	 */
+	unsubscribe<Event extends keyof Map>(event: Event, callback?: Map[Event]): void {
+		if (!this.#names.has(event) || (callback != null ? typeof callback !== 'function' : false)) {
+			return;
+		}
+
+		const subscribers = this.#subscribers.get(event);
+
+		if (subscribers == null) {
+			return;
+		}
+
+		if (callback == null) {
+			subscribers.clear();
+		} else {
+			subscribers.delete(callback);
+		}
+
+		if (callback == null || subscribers.size === 0) {
+			this.#subscribers.delete(event);
+		}
+	}
+}
+
+export type Unsubscriber = () => void;
+
+// #endregion
+
+// #region Functions
+
+/**
+ * Create a Kalas _(party)_ for named events
+ * @param names Event names
+ * @returns Kalas instance
+ */
+export function kalas<Events extends Record<string, GenericCallback>>(
+	names: (keyof Events)[],
+): Kalas<Events> {
+	if (
+		!Array.isArray(names) ||
+		names.length === 0 ||
+		!names.every(name => typeof name === 'string')
+	) {
+		throw new Error(MESSAGE);
+	}
+
+	return new Kalas<Events>(names);
+}
+
+// #endregion
+
+// #region Variables
+
+const MESSAGE = 'Kalas requires an array of event names.';
+
+// #endregion
+
+// #region Exports
+
+export {type Events, type Kalas};
+
+// #endregion

package/src/string/case.ts

@@ -58,7 +58,13 @@ export function kebabCase(value: string): string {
  * @returns Lower-cased string
  */
 export function lowerCase(value: string): string {
-	return typeof value === 'string' ? value.toLocaleLowerCase() : '';
+	if (typeof value !== 'string') {
+		return '';
+	}
+
+	memoizedLowerCase ??= memoize(v => v.toLocaleLowerCase());
+
+	return memoizedLowerCase.run(value);
 }
 
 /**
@@ -85,12 +91,12 @@ export function snakeCase(value: string): string {
  * @returns Title-cased string
  */
 export function titleCase(value: string): string {
-	if (typeof value !== 'string') {
+	if (typeof value !== 'string' || value.length === 0) {
 		return '';
 	}
 
 	memoizedTitleCase ??= memoize(v =>
-		v.length < 1 ? capitalize(v) : join(words(v).map(capitalize), ' '),
+		v.length < 2 ? capitalize(v) : join(words(v).map(capitalize), ' '),
 	);
 
 	return memoizedTitleCase.run(value);
@@ -167,7 +173,13 @@ function toCaseCallback(this: Options, value: string): string {
  * @returns Upper-cased string
  */
 export function upperCase(value: string): string {
-	return typeof value === 'string' ? value.toLocaleUpperCase() : '';
+	if (typeof value !== 'string' || value.length === 0) {
+		return '';
+	}
+
+	memoizedUpperCase ??= memoize(v => v.toLocaleUpperCase());
+
+	return memoizedUpperCase.run(value);
 }
 
 // #endregion
@@ -207,6 +219,10 @@ const delimiters: Record<Case, string> = {
 
 let memoizedCapitalize: Memoized<(value: string) => string>;
 
+let memoizedLowerCase: Memoized<(value: string) => string>;
+
 let memoizedTitleCase: Memoized<(value: string) => string>;
 
+let memoizedUpperCase: Memoized<(value: string) => string>;
+
 // #endregion

package/src/string/normalize.ts

@@ -0,0 +1,169 @@
+import {memoize, type Memoized} from '../function/memoize';
+import {isPlainObject} from '../internal/is';
+import {lowerCase} from './case';
+
+// #region Types
+
+/**
+ * Options for normalizing a string
+ */
+export type NormalizeOptions = {
+	/**
+	 * Remove diacritical marks from the string? _(defaults to `true`)_
+	 */
+	deburr?: boolean;
+	/**
+	 * Convert the string to lower case? _(defaults to `true`)_
+	 */
+	lowerCase?: boolean;
+	/**
+	 * Trim the string? _(defaults to `true`)_
+	 */
+	trim?: boolean;
+};
+
+/**
+ * String normalizer function
+ */
+export type Normalizer = {
+	/**
+	 * Normalize a string
+	 * @param value String to normalize
+	 * @returns Normalized string
+	 */
+	(value: string): string;
+};
+
+type Options = Required<NormalizeOptions>;
+
+// #endregion
+
+// #region Functions
+
+/**
+ * Deburr a string, removing diacritical marks
+ * @param value String to deburr
+ * @returns Deburred string
+ */
+export function deburr(value: string): string {
+	if (typeof value !== 'string') {
+		return '';
+	}
+
+	deburrMemoizer ??= memoize(value => {
+		let deburred = value.normalize(DEBURR_NORMALIZATION).replace(DEBURR_PATTERN_SIMPLE, '');
+
+		deburred = deburred.replace(
+			DEBURR_PATTERN_CHARACTERS,
+			(_, character) => DEBURR_CHARACTERS[character as keyof typeof DEBURR_CHARACTERS],
+		);
+
+		return deburred;
+	});
+
+	return deburrMemoizer.run(value);
+}
+
+function getNormalizeOptions(input?: NormalizeOptions): Options {
+	const options = isPlainObject(input) ? input : {};
+
+	return {
+		deburr: options.deburr !== false,
+		lowerCase: options.lowerCase !== false,
+		trim: options.trim !== false,
+	};
+}
+
+/**
+ * Initialize a string normalizer
+ * @param options Normalization options
+ * @returns Normalizer function
+ */
+export function initializeNormalizer(options?: NormalizeOptions): Normalizer {
+	const normalization = getNormalizeOptions(options);
+
+	return (value: string) => normalizeString(value, normalization);
+}
+
+/**
+ * Normalize a string
+ *
+ * By default, the string will be trimmed, deburred, and then lowercased
+ * @param value String to normalize
+ * @param options Normalization options
+ * @returns Normalized string
+ */
+export function normalize(value: string, options?: NormalizeOptions): string {
+	return normalizeString(value, getNormalizeOptions(options));
+}
+
+normalize.initialize = initializeNormalizer;
+
+function normalizeString(value: string, options: Options): string {
+	if (typeof value !== 'string') {
+		return '';
+	}
+
+	let result = value;
+
+	if (options.trim) {
+		result = result.trim();
+	}
+
+	if (options.deburr) {
+		result = deburr(result);
+	}
+
+	if (options.lowerCase) {
+		result = lowerCase(result);
+	}
+
+	return result;
+}
+
+// #endregion
+
+// #region Variables
+
+const DEBURR_CHARACTERS = {
+	Æ: 'AE',
+	æ: 'ae',
+	Ð: 'D',
+	ð: 'd',
+	Đ: 'D',
+	đ: 'd',
+	Ħ: 'H',
+	ħ: 'h',
+	IJ: 'IJ',
+	ij: 'ij',
+	İ: 'I',
+	ı: 'i',
+	ĸ: 'k',
+	Ŀ: 'L',
+	ŀ: 'l',
+	Ł: 'L',
+	ł: 'l',
+	Ŋ: 'N',
+	ŋ: 'n',
+	ʼn: "'n",
+	Œ: 'OE',
+	œ: 'oe',
+	Ø: 'O',
+	ø: 'o',
+	ſ: 's',
+	ß: 'ss',
+	Þ: 'TH',
+	þ: 'th',
+	Ŧ: 'T',
+	ŧ: 't',
+};
+
+const DEBURR_NORMALIZATION = 'NFD';
+
+const DEBURR_PATTERN_CHARACTERS = new RegExp(`(${Object.keys(DEBURR_CHARACTERS).join('|')})`, 'g');
+
+const DEBURR_PATTERN_SIMPLE = /[\u0300-\u036f]/g;
+
+let deburrMemoizer: Memoized<typeof deburr>;
+
+// #endregion