@oscarpalmer/atoms 0.218.0 → 0.220.0

package/dist/index.mjs

@@ -8,7 +8,7 @@ function getArrayCallback(value) {
 	switch (typeof value) {
 		case "function": return value;
 		case "number":
-		case "string": return typeof value === "string" && value.includes(".") ? void 0 : (obj) => obj[value];
+		case "string": return (obj) => obj?.[value];
 		default: return;
 	}
 }
@@ -21,6 +21,15 @@ function getArrayCallbacks(bool, key, value) {
 }
 //#endregion
 //#region src/internal/array/find.ts
+function addResult(result, mapped, flat) {
+	if (!flat) {
+		result.matched.push(mapped);
+		return;
+	}
+	const array = Array.isArray(mapped) ? mapped : [mapped];
+	const { length } = array;
+	for (let index = 0; index < length; index += 1) result.matched.push(array[index]);
+}
 function createFindParameters(original) {
 	const { length } = original;
 	return {
@@ -29,24 +38,27 @@ function createFindParameters(original) {
 		value: length === 1 && typeof original[0] !== "function" ? original[0] : original[1]
 	};
 }
+function findAbsoluteValueOrDefault(array, parameters, defaultValue, useDefaultValue, reversed) {
+	if (parameters.length === 0) {
+		if (Array.isArray(array) && array.length > 0) return reversed ? array.at(-1) : array[0];
+		return useDefaultValue ? defaultValue : void 0;
+	}
+	const index = findValue(ARRAY_FIND_VALUE_INDEX, array, parameters, reversed);
+	if (index === -1) return useDefaultValue ? defaultValue : void 0;
+	return array[index];
+}
 function findComplexValues(parameters) {
-	const { array, keyCallback, length, mapAfter, mapBefore, result, type, value } = parameters;
+	const { array, arrayLength, callback, limit, result, type, value } = parameters;
 	const keys = /* @__PURE__ */ new Set();
-	for (let index = 0; index < length; index += 1) {
-		const item = array[index];
-		let keyed;
-		let transformed;
-		if (mapBefore == null) {
-			keyed = keyCallback?.(item, index, array) ?? item;
-			transformed = item;
-		} else {
-			transformed = mapBefore(item, index, array);
-			keyed = keyCallback?.(transformed, index, array) ?? transformed;
-		}
+	for (let arrayIndex = 0; arrayIndex < arrayLength; arrayIndex += 1) {
+		const arrayItem = array[arrayIndex];
+		const keyed = callback == null ? arrayItem : callback(arrayItem, arrayIndex, array);
+		const mapped = arrayItem;
 		if (type === "all" && Object.is(keyed, value) || type === "unique" && !keys.has(keyed)) {
 			keys.add(keyed);
-			result.matched.push(mapAfter?.(item, index, array) ?? transformed);
-		} else result.notMatched.push(item);
+			result.matched.push(mapped);
+			if (result.matched.length >= limit) return result;
+		} else result.notMatched.push(arrayItem);
 	}
 	return result;
 }
@@ -54,13 +66,28 @@ function findSimpleValue(array, value, findIndex, reversed) {
 	if (findIndex) return reversed ? array.lastIndexOf(value) : array.indexOf(value);
 	return reversed ? array.findLast((item) => Object.is(item, value)) : array.find((item) => Object.is(item, value));
 }
-function findSimpleValues(array, length, value, boolCallback, mapBefore, mapAfter, result) {
-	const callback = boolCallback ?? ((item) => Object.is(item, value));
-	for (let index = 0; index < length; index += 1) {
-		const item = array[index];
-		const transformed = mapBefore?.(item, index, array) ?? item;
-		if (callback(transformed, index, array)) result.matched.push(mapAfter?.(item, index, array) ?? transformed);
-		else result.notMatched.push(item);
+function findSimpleValues(parameters) {
+	const { array, arrayLength, callback, flat, limit, map, result, value } = parameters;
+	const { after, before } = map ?? {};
+	const handler = callback ?? ((item) => Object.is(item, value));
+	for (let arrayIndex = 0; arrayIndex < arrayLength; arrayIndex += 1) {
+		const arrayItem = array[arrayIndex];
+		let mapped = before == null ? arrayItem : before(arrayItem, arrayIndex, array);
+		if (!flat || after != null) {
+			if (handler(mapped, arrayIndex, array)) {
+				mapped = after == null ? mapped : after(arrayItem, arrayIndex, array);
+				addResult(result, mapped, flat);
+				if (result.matched.length >= limit) return result;
+			} else result.notMatched.push(arrayItem);
+			continue;
+		}
+		const flatItems = Array.isArray(mapped) ? mapped : [mapped];
+		const flatLength = flatItems.length;
+		for (let flatIndex = 0; flatIndex < flatLength; flatIndex += 1) {
+			const flatItem = flatItems[flatIndex];
+			if (handler(flatItem, arrayIndex, array)) result.matched.push(flatItem);
+			else result.notMatched.push(flatItem);
+		}
 	}
 	return result;
 }
@@ -84,50 +111,42 @@ function findValueInArray(array, callback, value, findIndex, reversed) {
 	}
 	return findIndex ? -1 : void 0;
 }
-function findAbsoluteValueOrDefault(array, parameters, defaultValue, useDefaultValue, reversed) {
-	if (parameters.length === 0) {
-		if (Array.isArray(array) && array.length > 0) return reversed ? array.at(-1) : array[0];
-		return useDefaultValue ? defaultValue : void 0;
-	}
-	const index = findValue(ARRAY_FIND_VALUE_INDEX, array, parameters, reversed);
-	if (index === -1) return useDefaultValue ? defaultValue : void 0;
-	return array[index];
-}
-function findValues(type, array, parameters, mapper) {
+function findValues(type, array, parameters, options) {
 	const result = {
 		matched: [],
 		notMatched: []
 	};
-	if (!Array.isArray(array) || array.length === 0) return result;
-	const { length } = array;
+	if (!Array.isArray(array)) return result;
+	const arrayLength = array.length;
+	if (arrayLength === 0) return result;
 	const { bool, key, value } = createFindParameters(parameters);
 	const callbacks = getArrayCallbacks(bool, key);
-	if (type === "unique" && callbacks?.keyed == null && length >= 100) {
+	if (type === "unique" && callbacks?.keyed == null && arrayLength >= 100) {
 		result.matched = [...new Set(array)];
 		return result;
 	}
-	const mapCallback = getArrayCallback(mapper?.callback);
-	const mapReverse = mapper?.reverse ?? false;
-	let mapAfter;
-	let mapBefore;
-	if (mapCallback == null) {
-		mapAfter = void 0;
-		mapBefore = void 0;
-	} else {
-		mapAfter = mapReverse ? void 0 : mapCallback;
-		mapBefore = mapReverse ? mapCallback : void 0;
-	}
-	if (callbacks?.bool != null || type === "all" && key == null) return findSimpleValues(array, length, value, callbacks?.bool, mapBefore, mapAfter, result);
-	return findComplexValues({
+	const limit = options?.limit ?? Number.POSITIVE_INFINITY;
+	const flat = options?.map?.flat ?? false;
+	const mapCallback = getArrayCallback(options?.map?.callback);
+	const mapReverse = options?.map?.reverse ?? false;
+	let map;
+	if (mapCallback != null) map = {
+		before: mapReverse ? mapCallback : void 0,
+		after: mapReverse ? void 0 : mapCallback
+	};
+	const simple = callbacks?.bool != null || type === "all" && key == null;
+	const findParameters = {
 		array,
-		length,
-		mapAfter,
-		mapBefore,
+		arrayLength,
+		flat,
+		limit,
+		map,
 		result,
 		type,
 		value,
-		keyCallback: callbacks?.keyed
-	});
+		callback: simple ? callbacks?.bool : callbacks?.keyed
+	};
+	return simple ? findSimpleValues(findParameters) : findComplexValues(findParameters);
 }
 //#endregion
 //#region src/array/filter.ts
@@ -506,6 +525,13 @@ function startsWithArray(haystack, needle, key) {
 * @param value Number to round down
 * @param decimals Number of decimal places to round to _(defaults to `0`)_
 * @returns Rounded number, or `Number.NaN` if the value if unable to be rounded
+*
+* @example
+* ```typescript
+* floor(10.567, 2); // => 10.56
+* floor(10.567);    // => 10
+* floor('abc');       // => Number.NaN
+* ```
 */
 function floor(value, decimals) {
 	return roundNumber(Math.floor, value, decimals);
@@ -516,6 +542,13 @@ function floor(value, decimals) {
 * @param value Number to round
 * @param decimals Number of decimal places to round to _(defaults to `0`)_
 * @returns Rounded number, or `Number.NaN` if the value if unable to be rounded
+*
+* @example
+* ```typescript
+* round(10.567, 2); // => 10.57
+* round(10.567);    // => 11
+* round('abc');       // => Number.NaN
+* ```
 */
 function round(value, decimals) {
 	return roundNumber(Math.round, value, decimals);
@@ -573,6 +606,11 @@ const RANDOM_DIVISOR = 2 ** 32;
 *
 * @param array Original array
 * @returns Shuffled array
+*
+* @example
+* ```typescript
+* shuffle([1, 2, 3]); // => [3, 1, 2] (maybe? it's random, you know)
+* ```
 */
 function shuffle(array) {
 	if (!Array.isArray(array)) return [];
@@ -805,6 +843,12 @@ function push(array, pushed) {
 *
 * @param array Array to reverse
 * @returns Reversed array
+*
+* @example
+* ```typescript
+* reverse([1, 2, 3]);       // => [3, 2, 1]
+* reverse(['a', 'b', 'c']); // => ['c', 'b', 'a']
+* ```
 */
 function reverse(array) {
 	if (!Array.isArray(array)) return [];
@@ -822,7 +866,7 @@ function reverse(array) {
 //#endregion
 //#region src/array/single.ts
 function single(array, ...parameters) {
-	const { matched } = findValues("all", array, parameters);
+	const { matched } = findValues("all", array, parameters, { limit: 2 });
 	if (matched.length > 1) throw new Error(SINGLE_MESSAGE);
 	return matched[0];
 }
@@ -1053,22 +1097,28 @@ move.indices = moveIndices;
 move.toIndex = moveToIndex;
 //#endregion
 //#region src/array/select.ts
-function filterAndMap(array, ...parameters) {
-	return selectValues(array, parameters);
+function filterAndFlatMap(array, filter, mapper) {
+	return selectValues(array, filter, mapper, true, false);
+}
+function filterAndMap(array, filter, mapper) {
+	return selectValues(array, filter, mapper, false, false);
 }
-function mapAndFilter(array, ...parameters) {
-	return findValues("all", array, parameters, {
-		callback: parameters.shift(),
-		reverse: true
-	}).matched;
+function flatMapAndFilter(array, mapper, filter) {
+	return selectValues(array, filter, mapper, true, true);
 }
-function selectValues(array, parameters) {
-	return findValues("all", array, parameters, {
-		callback: parameters.pop(),
-		reverse: false
-	}).matched;
+function mapAndFilter(array, mapper, filter) {
+	return selectValues(array, filter, mapper, false, true);
 }
+function selectValues(array, filter, mapper, flat, reverse) {
+	return findValues("all", array, [filter], { map: {
+		flat,
+		reverse,
+		callback: mapper
+	} }).matched;
+}
+filterAndMap.flat = filterAndFlatMap;
 filterAndMap.reverse = mapAndFilter;
+mapAndFilter.flat = flatMapAndFilter;
 //#endregion
 //#region src/models/value/value.misc.model.ts
 const COMPARE_NAME = "compare";
@@ -1194,9 +1244,15 @@ function getString(value) {
 	const asString = String(value.valueOf?.() ?? value);
 	return asString.startsWith("[object ") ? JSON.stringify(value) : asString;
 }
+/**
+* @internal
+*/
 function ignoreKey(key) {
 	return STRING_EXPRESSION_IGNORED.test(key);
 }
+/**
+* @internal
+*/
 function interpolate(strings, values) {
 	const { length } = strings;
 	let interpolated = "";
@@ -1214,6 +1270,14 @@ function interpolate(strings, values) {
 * @param array Array of values
 * @param delimiter Delimiter to use between values
 * @returns Joined string
+* @example
+* ```typescript
+* join(['a', 'b', 'c']);          // => 'abc'
+* join(['a', 'b', 'c'], ', ');   // => 'a, b, c'
+* join(['a', '', 'c']);           // => 'ac'
+* join([null, 'b', undefined]);   // => 'b'
+* join([]);                       // => ''
+* ```
 */
 function join(array, delimiter) {
 	if (!Array.isArray(array)) return "";
@@ -1229,9 +1293,15 @@ function join(array, delimiter) {
 function tryCallback(value, callback) {
 	return unwrap(attempt(() => callback(value)), value);
 }
+/**
+* @internal
+*/
 function tryDecode(value) {
 	return tryCallback(value, decodeURIComponent);
 }
+/**
+* @internal
+*/
 function tryEncode(value) {
 	return tryCallback(value, encodeURIComponent);
 }
@@ -2219,6 +2289,13 @@ const EXPRESSION_WHITESPACE_ONLY = /^\s*$/;
 * @param minimum Minimum value
 * @param maximum Maximum value _(inclusive)_
 * @returns `true` if the value is between the minimum and maximum, otherwise `false`
+*
+* @example
+* ```typescript
+* between(5, 1, 10); // => true
+* between(0, 1, 10); // => false
+* between(10, 10, 10); // => true
+* ```
 */
 function between(value, minimum, maximum) {
 	if (![
@@ -2261,6 +2338,17 @@ function clamp(value, minimum, maximum, loop) {
 *
 * @param value Original value
 * @returns Original value as a number, or `Number.NaN` if the value is unable to be parsed
+*
+* @example
+* ```typescript
+* getNumber(null)       // => Number.NaN
+* getNumber('foo')      // => Number.NaN
+* getNumber('123')        // => 123
+* getNumber(true)       // => 1
+* getNumber([1, 2, 3])  // => Number.NaN
+* getNumber({a: 1})     // => Number.NaN
+* getNumber(() => 123)  // => 123
+* ```
 */
 function getNumber(value) {
 	if (typeof value === "number") return value;
@@ -2493,6 +2581,14 @@ const STRING_REPLACEMENT_CAMEL_CASE = "$1-$2";
 *
 * @param value String to convert
 * @returns Camel-cased string
+*
+* @example
+* ```typescript
+* camelCase('this is camel case'); // => 'thisIsCamelCase'
+* camelCase('ThisIsCamelCase');    // => 'thisIsCamelCase'
+* camelCase('this-is-camel-case'); // => 'thisIsCamelCase'
+* camelCase('this_is_camel_case'); // => 'thisIsCamelCase'
+* ```
 */
 function camelCase(value) {
 	return toCase(STRING_CASE_CAMEL, value, true, false);
@@ -2502,6 +2598,14 @@ function camelCase(value) {
 *
 * @param value String to capitalize
 * @returns Capitalized string
+*
+* @example
+* ```typescript
+* capitalize('this is a test'); // => 'This is a test'
+* capitalize('This Is A Test'); // => 'This is a test'
+* capitalize('t');              // => 'T'
+* capitalize('');               // => ''
+* ```
 */
 function capitalize(value) {
 	if (typeof value !== "string" || value.length === 0) return "";
@@ -2513,6 +2617,14 @@ function capitalize(value) {
 *
 * @param value String to convert
 * @returns Kebab-cased string
+*
+* @example
+* ```typescript
+* kebabCase('this is kebab case'); // => 'this-is-kebab-case'
+* kebabCase('ThisIsKebabCase');    // => 'this-is-kebab-case'
+* kebabCase('this-is-kebab-case'); // => 'this-is-kebab-case'
+* kebabCase('this_is_kebab_case'); // => 'this-is-kebab-case'
+* ```
 */
 function kebabCase(value) {
 	return toCase(STRING_CASE_KEBAB, value, false, false);
@@ -2522,6 +2634,13 @@ function kebabCase(value) {
 *
 * @param value String to convert
 * @returns Lower-cased string
+*
+* @example
+* ```typescript
+* lowerCase('THIS IS A TEST'); // => 'this is a test'
+* lowerCase('this is a test'); // => 'this is a test'
+* lowerCase('t');              // => 't'
+* ```
 */
 function lowerCase(value) {
 	if (typeof value !== "string") return "";
@@ -2533,6 +2652,14 @@ function lowerCase(value) {
 *
 * @param value String to convert
 * @returns Pascal-cased string
+*
+* @example
+* ```typescript
+* pascalCase('this is pascal case'); // => 'ThisIsPascalCase'
+* pascalCase('ThisIsPascalCase');    // => 'ThisIsPascalCase'
+* pascalCase('this-is-pascal-case'); // => 'ThisIsPascalCase'
+* pascalCase('this_is_pascal_case'); // => 'ThisIsPascalCase'
+* ```
 */
 function pascalCase(value) {
 	return toCase(STRING_CASE_PASCAL, value, true, true);
@@ -2542,6 +2669,14 @@ function pascalCase(value) {
 *
 * @param value String to convert
 * @returns Snake-cased string
+*
+* @example
+* ```typescript
+* snakeCase('this is snake case'); // => 'this_is_snake_case'
+* snakeCase('ThisIsSnakeCase');    // => 'this_is_snake_case'
+* snakeCase('this-is-snake-case'); // => 'this_is_snake_case'
+* snakeCase('this_is_snake_case'); // => 'this_is_snake_case'
+* ```
 */
 function snakeCase(value) {
 	return toCase(STRING_CASE_SNAKE, value, false, false);
@@ -2551,6 +2686,14 @@ function snakeCase(value) {
 *
 * @param value String to convert
 * @returns Title-cased string
+*
+* @example
+* ```typescript
+* titleCase('this is a test'); // => 'This Is A Test'
+* titleCase('This Is A Test'); // => 'This Is A Test'
+* titleCase('t');              // => 'T'
+* titleCase('');               // => ''
+* ```
 */
 function titleCase(value) {
 	if (typeof value !== "string" || value.length === 0) return "";
@@ -2593,6 +2736,14 @@ function toCaseCallback(value) {
 *
 * @param value String to convert
 * @returns Upper-cased string
+*
+* @example
+* ```typescript
+* upperCase('this is a test'); // => 'THIS IS A TEST'
+* upperCase('This Is A Test'); // => 'THIS IS A TEST'
+* upperCase('t');              // => 'T'
+* upperCase('');               // => ''
+* ```
 */
 function upperCase(value) {
 	if (typeof value !== "string" || value.length === 0) return "";
@@ -3337,6 +3488,9 @@ function isRejected(value) {
 function cancelable(executor) {
 	return new CancelablePromise(executor);
 }
+/**
+* @internal
+*/
 function handleResult(status, parameters) {
 	const { aborter, complete, data, handlers, index, key, value } = parameters;
 	if (aborter?.signal.aborted ?? false) return;
@@ -3360,6 +3514,9 @@ function handleResult(status, parameters) {
 		handlers.resolve(data.result);
 	}
 }
+/**
+* @internal
+*/
 function settlePromise(settler, value, aborter) {
 	aborter?.cancel();
 	settler(value);
@@ -3390,6 +3547,9 @@ function delay(options) {
 }
 //#endregion
 //#region src/promise/timed.ts
+/**
+* @internal
+*/
 async function getTimedPromise(promise, time, signal) {
 	const aborter = createAborter(signal, () => {
 		limiter.cancel();
@@ -3568,55 +3728,12 @@ function attemptPipe(initial, first, ...seconds) {
 attemptPipe.async = attemptAsyncPipe;
 //#endregion
 //#region src/models/string/string.fuzzy.model.ts
+const FUZZY_BOUNDARY_SEPARATOR = /[\s./:\\_-]/;
 const FUZZY_MESSAGE_ARRAY = "Fuzzy requires an array of items";
 const FUZZY_MESSAGE_HANDLER = "Fuzzy requires a key or function to stringify items";
 const FUZZY_PROPERTY = "$fuzzy";
 const FUZZY_SYMBOL = Symbol(FUZZY_PROPERTY);
 //#endregion
-//#region src/string/match.ts
-/**
-* Check if a string ends with a specified substring
-*
-* @param haystack String to look in
-* @param needle String to look for
-* @param ignoreCase Ignore case when matching? _(defaults to `false`)_
-* @returns `true` if the string ends with the given substring, otherwise `false`
-*/
-function endsWith(haystack, needle, ignoreCase) {
-	return match(STRING_MATCH_ENDS_WITH, haystack, needle, ignoreCase === true);
-}
-/**
-* Check if a string includes a specified substring
-*
-* @param haystack String to look in
-* @param needle String to look for
-* @param ignoreCase Ignore case when matching? _(defaults to `false`)_
-* @returns `true` if the string includes the given substring, otherwise `false`
-*/
-function includes(haystack, needle, ignoreCase) {
-	return match(STRING_MATCH_INCLUDES, haystack, needle, ignoreCase === true);
-}
-function match(type, haystack, needle, ignoreCase) {
-	if (typeof haystack !== "string" || typeof needle !== "string") return false;
-	matchMemoizers[type] ??= memoize(matchCallback.bind(type));
-	return matchMemoizers[type].run(haystack, needle, ignoreCase);
-}
-function matchCallback(haystack, needle, ignoreCase) {
-	return (ignoreCase ? haystack.toLocaleLowerCase() : haystack)[this](ignoreCase ? needle.toLocaleLowerCase() : needle);
-}
-/**
-* Check if a string starts with a specified substring
-*
-* @param haystack String to look in
-* @param needle String to look for
-* @param ignoreCase Ignore case when matching? _(defaults to `false`)_
-* @returns `true` if the string starts with the given substring, otherwise `false`
-*/
-function startsWith(haystack, needle, ignoreCase) {
-	return match(STRING_MATCH_STARTS_WITH, haystack, needle, ignoreCase === true);
-}
-const matchMemoizers = {};
-//#endregion
 //#region src/string/fuzzy.ts
 function Fuzzy(state) {
 	this[FUZZY_SYMBOL] = state;
@@ -3626,39 +3743,76 @@ Fuzzy.prototype.search = search;
 Object.defineProperties(Fuzzy.prototype, {
 	items: {
 		enumerable: true,
-		get: getFuzzyItems,
-		set: setFuzzyItems
+		get: getItems,
+		set: setItems
 	},
 	strings: {
 		enumerable: true,
-		get: getFuzzyStrings
+		get: getStrings
 	}
 });
-function createFuzzyItems(items) {
-	return items.toSorted((first, second) => first.haystack.localeCompare(second.haystack)).map(({ item }) => item);
+function compareItem(sorter) {
+	return (first, second) => sorter(first.string.original, second.string.original);
 }
-function createFuzzyOptions(input, state) {
-	const options = isPlainObject(input) ? input : {};
-	const limit = typeof input === "number" ? input : options.limit;
+function compareRanked(sorter) {
+	return (first, second) => first.rank - second.rank || first.position - second.position || sorter(first.string.original, second.string.original);
+}
+function createItems(state, items) {
+	state.items.original = items.map((item) => ({
+		data: item,
+		string: createString(state.handler(item))
+	}));
+	state.items.sorted = void 0;
+}
+function createOptions(input, state) {
+	const options = {};
+	const original = isPlainObject(input) ? input : {};
+	const limit = typeof input === "number" ? input : original.limit;
 	if (typeof limit === "number" && !Number.isNaN(limit) && limit >= 1) options.limit = floor(limit);
-	else options.limit = state?.limit;
-	options.tolerance = getTolerance(options.tolerance, state);
+	else options.limit = state?.limit ?? Number.POSITIVE_INFINITY;
+	options.tolerance = getTolerance(original.tolerance, state);
 	return options;
 }
-function createFuzzyState(items, input) {
-	const handler = getHandler(input);
-	const options = createFuzzyOptions(input);
+function createRanked(item, needle, position) {
+	let boundary = position;
+	while (boundary > -1 && !isBoundary(item.string, boundary)) boundary = item.string.lowercase.indexOf(needle, boundary + 1);
+	if (boundary === -1) return {
+		...item,
+		position,
+		rank: 2
+	};
 	return {
+		...item,
+		position: boundary,
+		rank: boundary === 0 ? 0 : 1
+	};
+}
+function createState(items, input) {
+	const handler = getHandler(input);
+	const options = createOptions(input);
+	const sorter = getComparator(input);
+	const state = {
+		compare: {
+			item: compareItem(sorter),
+			ranked: compareRanked(sorter)
+		},
 		handler,
-		items: items.slice(),
+		items: { original: [] },
 		limit: options.limit,
-		strings: items.map(handler),
 		tolerance: options.tolerance
 	};
+	createItems(state, items);
+	return state;
+}
+function createString(original) {
+	return {
+		original,
+		lowercase: lowerCase(original)
+	};
 }
 function fuzzy(items, configuration) {
 	if (!Array.isArray(items)) throw new TypeError(FUZZY_MESSAGE_ARRAY);
-	return new Fuzzy(createFuzzyState(items, configuration));
+	return new Fuzzy(createState(items, configuration));
 }
 /**
 * Does the needle match the haystack in a fuzzy way?
@@ -3672,53 +3826,117 @@ function fuzzy(items, configuration) {
 function fuzzyMatch(haystack, needle) {
 	if (typeof haystack !== "string" || typeof needle !== "string") return false;
 	const trimmed = needle.trim();
-	if (includes(haystack, trimmed, true)) return true;
-	return getScore(haystack, trimmed) > -1;
+	const lowercaseHaystack = lowerCase(haystack);
+	const lowercaseNeedle = lowerCase(trimmed);
+	if (lowercaseHaystack.includes(lowercaseNeedle)) return true;
+	return getScore({
+		lowercase: lowercaseHaystack,
+		original: haystack
+	}, lowercaseNeedle) > -1;
+}
+function getComparator(input) {
+	if (isPlainObject(input) && typeof input.compare === "function") return input.compare;
+	defaultSorter ??= Intl.Collator().compare;
+	return defaultSorter;
 }
 function getHandler(input) {
 	if (input == null || input === getString) return getString;
 	switch (typeof input) {
-		case "function": return input;
-		case "string": return (item) => item[input];
+		case "function": return (item) => getString(input(item));
+		case "number":
+		case "string":
+		case "symbol": return (item) => getString(item?.[input]);
 		default:
 			if (isPlainObject(input)) return getHandler(input.key ?? input.handler);
 			throw new TypeError(FUZZY_MESSAGE_HANDLER);
 	}
 }
-function getFuzzyItems() {
-	return this[FUZZY_SYMBOL].items.slice();
+function getItems() {
+	return this[FUZZY_SYMBOL].items.original.map((item) => item.data);
 }
-function getFuzzyStrings() {
-	return this[FUZZY_SYMBOL].strings.slice();
-}
-function getScore(haystack, needle) {
-	if (!isSubsequence(haystack, needle)) return -1;
-	const lowerCaseHaystack = lowerCase(haystack);
-	const lowerCaseNeedle = lowerCase(needle);
-	const needleLength = lowerCaseNeedle.length;
+function getMatchEnd(haystack, needle, cursor) {
+	const haystackLength = haystack.length;
+	const needleLength = needle.length;
 	let needleIndex = 0;
-	let previousMatchIndex = -1;
-	let score = 0;
-	for (let haystackIndex = 0; haystackIndex < lowerCaseHaystack.length; haystackIndex += 1) {
-		if (lowerCaseHaystack[haystackIndex] === lowerCaseNeedle[needleIndex]) {
-			score += 1;
-			if (haystackIndex === 0) score += 1;
-			if (previousMatchIndex !== -1) {
-				const gap = haystackIndex - previousMatchIndex - 1;
-				score += max([0, 5 - gap]);
+	for (let index = cursor; index < haystackLength; index += 1) if (haystack[index] === needle[needleIndex]) {
+		needleIndex += 1;
+		if (needleIndex === needleLength) return index;
+	}
+	return -1;
+}
+function getResult(state, exact, included, scored, options) {
+	const result = {
+		exact: [],
+		included: [],
+		similar: []
+	};
+	exact.sort(state.compare.item);
+	result.exact = exact.slice(0, options.limit).map((item) => item.data);
+	included.sort(state.compare.ranked);
+	result.included = included.slice(0, options.limit - result.exact.length).map((item) => item.data);
+	const remaining = options.limit - result.exact.length - result.included.length;
+	if (remaining === 0) return result;
+	const keys = Object.keys(scored).map(Number).sort((first, second) => second - first);
+	const keysLength = keys.length;
+	if (keysLength === 0) return result;
+	const maxScore = keys[0];
+	outer: for (let index = 0; index < keysLength; index += 1) {
+		const key = keys[index];
+		if (maxScore - key > options.tolerance) break;
+		const keyed = scored[key];
+		const keyedLength = keyed.length;
+		keyed.sort(state.compare.item);
+		for (let keyedIndex = 0; keyedIndex < keyedLength; keyedIndex += 1) {
+			result.similar.push(keyed[keyedIndex].data);
+			if (result.similar.length >= remaining) break outer;
+		}
+	}
+	return result;
+}
+function getScore(item, needle) {
+	const haystackLength = item.lowercase.length;
+	const needleLength = needle.length;
+	if (needleLength > haystackLength) return -1;
+	let best = -1;
+	let cursor = 0;
+	while (cursor < haystackLength) {
+		const end = getMatchEnd(item.lowercase, needle, cursor);
+		if (end === -1) break;
+		let index = end;
+		let needleIndex = needleLength - 1;
+		let next = -1;
+		let score = 0;
+		let start = end;
+		while (needleIndex >= 0) {
+			if (item.lowercase[index] === needle[needleIndex]) {
+				score += 1;
+				if (next !== -1) score += max([0, 5 - (next - index - 1)]);
+				if (isBoundary(item, index)) score += 2;
+				next = index;
+				start = index;
+				needleIndex -= 1;
 			}
-			previousMatchIndex = haystackIndex;
-			needleIndex += 1;
+			index -= 1;
 		}
-		if (needleIndex === needleLength) break;
+		if (start === 0) score += 1;
+		if (score > best) best = score;
+		cursor = start + 1;
 	}
-	score -= floor(lowerCaseHaystack.length / 3);
-	return max([0, score]);
+	if (best === -1) return -1;
+	return max([0, best - floor(haystackLength / 3)]);
+}
+function getStrings() {
+	return this[FUZZY_SYMBOL].items.original.map((item) => item.string.original);
 }
 function getTolerance(input, state) {
 	if (typeof input === "number" && !Number.isNaN(input)) return input < 0 ? 0 : floor(input);
 	return state?.tolerance ?? 5;
 }
+function isBoundary(string, index) {
+	if (index === 0 || FUZZY_BOUNDARY_SEPARATOR.test(string.lowercase[index - 1])) return true;
+	if (string.original.length !== string.lowercase.length) return false;
+	return string.original[index] !== string.lowercase[index] && string.original[index - 1] === string.lowercase[index - 1];
+}
 /**
 * Is the value a fuzzy searcher?
 *
@@ -3730,74 +3948,48 @@ function getTolerance(input, state) {
 function isFuzzy(value) {
 	return typeof value === "object" && value !== null && "$fuzzy" in value && value["$fuzzy"] === true;
 }
-function isSubsequence(haystack, needle) {
-	const lowerCaseHaystack = lowerCase(haystack);
-	const lowerCaseNeedle = lowerCase(needle);
-	const haystackLength = lowerCaseHaystack.length;
-	const needleLength = lowerCaseNeedle.length;
-	let needleIndex = 0;
-	for (let haystackIndex = 0; haystackIndex < haystackLength; haystackIndex += 1) {
-		if (lowerCaseHaystack[haystackIndex] === lowerCaseNeedle[needleIndex]) needleIndex += 1;
-		if (needleIndex === needleLength) return true;
-	}
-	return false;
-}
 function search(input, option) {
 	const state = this[FUZZY_SYMBOL];
-	const options = option == null ? state : createFuzzyOptions(option, state);
-	const result = {
-		exact: [],
-		similar: []
-	};
+	const options = option == null ? state : createOptions(option, state);
 	const value = typeof input === "string" ? input.trim() : "";
+	const lowercaseValue = lowerCase(value);
 	if (value.length === 0) {
-		result.exact = state.items.slice(0, options.limit);
-		return result;
+		state.items.sorted ??= state.items.original.toSorted(state.compare.item);
+		return {
+			exact: state.items.sorted.slice(0, options.limit).map((item) => item.data),
+			included: [],
+			similar: []
+		};
 	}
-	let { length } = state.items;
 	const exact = [];
-	const similar = [];
+	const included = [];
 	const scored = {};
+	const { length } = state.items.original;
 	for (let index = 0; index < length; index += 1) {
-		const item = state.items[index];
-		const haystack = state.strings[index];
-		if (includes(haystack, value, true)) {
-			exact.push({
-				item,
-				haystack
-			});
+		const item = state.items.original[index];
+		const { string } = item;
+		if (string.lowercase === lowercaseValue) {
+			exact.push(item);
+			continue;
+		}
+		const position = string.lowercase.indexOf(lowercaseValue);
+		if (position > -1) {
+			included.push(createRanked(item, lowercaseValue, position));
 			continue;
 		}
-		const score = getScore(haystack, value);
+		const score = getScore(string, lowercaseValue);
 		if (score > -1) {
 			scored[score] ??= [];
-			scored[score].push({
-				item,
-				haystack
-			});
-		}
-	}
-	const keys = Object.keys(scored).map(Number).sort((first, second) => second - first);
-	length = keys.length;
-	if (length > 0 && options.tolerance > 0) {
-		const maxScore = keys[0];
-		for (let index = 0; index < length; index += 1) {
-			const key = keys[index];
-			if (maxScore - key > options.tolerance) break;
-			similar.push(...createFuzzyItems(scored[key]));
+			scored[score].push(item);
 		}
 	}
-	result.exact = createFuzzyItems(options.limit == null ? exact : exact.slice(0, options.limit));
-	if (options.limit == null) result.similar = similar;
-	else result.similar = similar.slice(0, options.limit - result.exact.length);
-	return result;
+	return getResult(state, exact, included, scored, options);
 }
-function setFuzzyItems(value) {
+function setItems(value) {
 	if (!Array.isArray(value)) throw new TypeError(FUZZY_MESSAGE_ARRAY);
-	const state = this[FUZZY_SYMBOL];
-	state.items = value.slice();
-	state.strings = value.map((item) => state.handler(item));
+	createItems(this[FUZZY_SYMBOL], value);
 }
+let defaultSorter;
 fuzzy.is = isFuzzy;
 fuzzy.match = fuzzyMatch;
 //#endregion
@@ -3855,7 +4047,7 @@ function getUuid(html) {
 *
 * @param value JSON string to parse
 * @param reviver Reviver function to transform the parsed values
-* @returns Parsed value or `undefined` if parsing fails
+* @returns Parsed value, or `undefined` if parsing fails
 */
 function parse(value, reviver) {
 	try {
@@ -3869,6 +4061,13 @@ function parse(value, reviver) {
 *
 * @param value String to trim
 * @returns Trimmed string
+* @example
+* ```typescript
+* trim('  this is a test  '); // => 'this is a test'
+* trim('this is a test');     // => 'this is a test'
+* trim('   ');                // => ''
+* trim('');                   // => ''
+* ```
 */
 function trim(value) {
 	return typeof value === "string" ? value.trim() : "";
@@ -3880,6 +4079,13 @@ function trim(value) {
 * @param length Maximum length of the string after truncation
 * @param suffix Suffix to append to the truncated string
 * @returns Truncated string
+* @example
+* ```typescript
+* truncate('this is a test', 7);          // => 'this is'
+* truncate('this is a test', 7, '...');   // => 'this ...'
+* truncate('this is a test', 20);         // => 'this is a test'
+* truncate('this is a test', 0);          // => ''
+* ```
 */
 function truncate(value, length, suffix) {
 	if (typeof value !== "string" || typeof length !== "number" || length === 0) return "";
@@ -3891,6 +4097,74 @@ function truncate(value, length, suffix) {
 	return `${value.slice(0, truncatedLength)}${actualSuffix}`;
 }
 //#endregion
+//#region src/string/match.ts
+/**
+* Check if a string ends with a specified substring
+*
+* @param haystack String to look in
+* @param needle String to look for
+* @param ignoreCase Ignore case when matching? _(defaults to `false`)_
+* @returns `true` if the string ends with the given substring, otherwise `false`
+*
+* @example
+* ```typescript
+* endsWith('this is a test', 'test');          // => true
+* endsWith('this is a test', 'Test');          // => false
+* endsWith('this is a test', 'Test', true);    // => true
+* endsWith('this is a test', 'not');           // => false
+* ```
+*/
+function endsWith(haystack, needle, ignoreCase) {
+	return match(STRING_MATCH_ENDS_WITH, haystack, needle, ignoreCase === true);
+}
+/**
+* Check if a string includes a specified substring
+*
+* @param haystack String to look in
+* @param needle String to look for
+* @param ignoreCase Ignore case when matching? _(defaults to `false`)_
+* @returns `true` if the string includes the given substring, otherwise `false`
+*
+* @example
+* ```typescript
+* includes('this is a test', 'is');          // => true
+* includes('this is a test', 'Is');          // => false
+* includes('this is a test', 'Is', true);    // => true
+* includes('this is a test', 'not');         // => false
+* ```
+*/
+function includes(haystack, needle, ignoreCase) {
+	return match(STRING_MATCH_INCLUDES, haystack, needle, ignoreCase === true);
+}
+function match(type, haystack, needle, ignoreCase) {
+	if (typeof haystack !== "string" || typeof needle !== "string") return false;
+	matchMemoizers[type] ??= memoize(matchCallback.bind(type));
+	return matchMemoizers[type].run(haystack, needle, ignoreCase);
+}
+function matchCallback(haystack, needle, ignoreCase) {
+	return (ignoreCase ? haystack.toLocaleLowerCase() : haystack)[this](ignoreCase ? needle.toLocaleLowerCase() : needle);
+}
+/**
+* Check if a string starts with a specified substring
+*
+* @param haystack String to look in
+* @param needle String to look for
+* @param ignoreCase Ignore case when matching? _(defaults to `false`)_
+* @returns `true` if the string starts with the given substring, otherwise `false`
+*
+* @example
+* ```typescript
+* startsWith('this is a test', 'this');          // => true
+* startsWith('this is a test', 'This');          // => false
+* startsWith('this is a test', 'This', true);    // => true
+* startsWith('this is a test', 'not');           // => false
+* ```
+*/
+function startsWith(haystack, needle, ignoreCase) {
+	return match(STRING_MATCH_STARTS_WITH, haystack, needle, ignoreCase === true);
+}
+const matchMemoizers = {};
+//#endregion
 //#region src/models/string/string.normalize.model.ts
 const NORMALIZE_DEBURR_CHARACTERS = {
 	Æ: "AE",
@@ -5929,6 +6203,14 @@ function getHexaColor$1() {
 * @param value Value to normalize
 * @param alpha Include alpha channel _(opacity)_? _(defaults to `false`)_
 * @returns Normalized hex color
+*
+* @example
+* ```typescript
+* getNormalizedHex('#abc'); // => '#aabbcc'
+* getNormalizedHex('#abc', true); // => '#aabbccff'
+* getNormalizedHex(123); // => '#000000'
+* getNormalizedHex(123, true); // => '#000000ff'
+* ```
 */
 function getNormalizedHex(value, alpha) {
 	const includeAlpha = alpha === true;
@@ -6703,12 +6985,24 @@ function getTimeLoggerStop() {
 	}
 	return noop;
 }
+/**
+* Is the value a _Logger_?
+*
+* @param value Value to check
+* @returns `true` if the value is a _Logger_, otherwise `false`
+*/
 function isLogger(value) {
 	return isLoggerInstance(LOGGER_NAME, value);
 }
 function isLoggerInstance(name, value) {
 	return typeof value === "object" && value !== null && "$logger" in value && value["$logger"] === name;
 }
+/**
+* Is the value a _TimeLogger_?
+*
+* @param value Value to check
+* @returns `true` if the value is a _TimeLogger_, otherwise `false`
+*/
 function isTimeLogger(value) {
 	return isLoggerInstance(LOGGER_NAME_TIMED, value);
 }
@@ -6734,6 +7028,13 @@ function average(array, key) {
 * @param value Number to round up
 * @param decimals Number of decimal places to round to _(defaults to `0`)_
 * @returns Rounded number, or `Number.NaN` if the value if unable to be rounded
+*
+* @example
+* ```typescript
+* ceil(1.234, 2); // => 1.24
+* ceil(1.234);    // => 2
+* ceil('abc');    // => Number.NaN
+* ```
 */
 function ceil(value, decimals) {
 	return roundNumber(Math.ceil, value, decimals);
@@ -7353,4 +7654,4 @@ var SizedSet = class extends Set {
 	}
 };
 //#endregion
-export { CancelablePromise, Logger, PromiseTimeoutError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, push as append, push, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncAttemptRun, asyncDebounce, asyncFail, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncRun, asyncSucceed, asyncThrottle, asyncUse, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, attemptRun, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, copy, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, fail, filter, filterAndMap, filterAndMap as select, find, findLast, first, firstOrDefault, flatFreeze, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayComparison, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getHwbColor, getHwbaColor, getNormalizedHex, getNumber, getRandom, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloatingNumber as getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hasValueResult, herald, hexToHsl, hexToHsla, hexToHwb, hexToHwba, hexToRgb, hexToRgba, hslToHex, hslToHwb, hslToHwba, hslToRgb, hslToRgba, hwbToHex, hwbToHsl, hwbToHsla, hwbToRgb, hwbToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeAssigner, initializeCloner, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, initializeTransformer, insert, interpolate, intersection, isArrayOrPlainObject, isAsyncFailure, isAsyncGenerator, isAsyncGeneratorFunction, isAsyncOnce, isAsyncPlan, isAsyncStep, isAsyncSuccess, isBeacon, isBeaconSubscription, isColor, isConstructor, isEmpty, isError, isFailure, isFrozen, isFulfilled, isFuzzy, isGenerator, isGeneratorFunction, isHerald, isHeraldEvents, isHeraldSubscription, isHexColor, isHslColor, isHslaColor, isHwbColor, isHwbaColor, isInstanceOf, isKey, isKeyedQueue, isLogger, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTemplateStringsArray, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isObservable, isOk, isOnce, isPlainObject, isPlan, isPrimitive, isQueue, isQueueInstance, isRejected, isResult, isRgbColor, isRgbaColor, isSorted, isStep, isSubscription, isSubscriptions, isSuccess, isTemplateStringsArray, isTimeLogger, isTypedArray, join, kebabCase, keyedQueue, last, lastIndexOf, lastOrDefault, lowerCase, mapAndFilter, mapAndFilter as reverseSelect, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, plan, promises, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, round, run, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, subscriptions, succeed, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, use, words };
+export { CancelablePromise, Logger, PromiseTimeoutError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, push as append, push, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncAttemptRun, asyncDebounce, asyncFail, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncRun, asyncSucceed, asyncThrottle, asyncUse, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, attemptRun, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, copy, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, fail, filter, filterAndFlatMap, filterAndMap, filterAndMap as select, find, findLast, first, firstOrDefault, flatFreeze, flatMapAndFilter, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayComparison, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getHwbColor, getHwbaColor, getNormalizedHex, getNumber, getRandom, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloatingNumber as getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hasValueResult, herald, hexToHsl, hexToHsla, hexToHwb, hexToHwba, hexToRgb, hexToRgba, hslToHex, hslToHwb, hslToHwba, hslToRgb, hslToRgba, hwbToHex, hwbToHsl, hwbToHsla, hwbToRgb, hwbToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeAssigner, initializeCloner, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, initializeTransformer, insert, interpolate, intersection, isArrayOrPlainObject, isAsyncFailure, isAsyncGenerator, isAsyncGeneratorFunction, isAsyncOnce, isAsyncPlan, isAsyncStep, isAsyncSuccess, isBeacon, isBeaconSubscription, isColor, isConstructor, isEmpty, isError, isFailure, isFrozen, isFulfilled, isFuzzy, isGenerator, isGeneratorFunction, isHerald, isHeraldEvents, isHeraldSubscription, isHexColor, isHslColor, isHslaColor, isHwbColor, isHwbaColor, isInstanceOf, isKey, isKeyedQueue, isLogger, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTemplateStringsArray, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isObservable, isOk, isOnce, isPlainObject, isPlan, isPrimitive, isQueue, isRejected, isResult, isRgbColor, isRgbaColor, isSorted, isStep, isSubscription, isSubscriptions, isSuccess, isTemplateStringsArray, isTimeLogger, isTypedArray, join, kebabCase, keyedQueue, last, lastIndexOf, lastOrDefault, lowerCase, mapAndFilter, mapAndFilter as reverseSelect, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, plan, promises, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, round, run, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, subscriptions, succeed, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, use, words };