@oscarpalmer/atoms 0.219.0 → 0.221.0

package/dist/index.mjs

@@ -1132,7 +1132,7 @@ const VALUE_MISC_NESTED_MESSAGE_UNSAFE = "Access to this property is not allowed
 //#endregion
 //#region src/models/string/string.misc.model.ts
 const STRING_EXPRESSION_IGNORED = /(^|\.)(__proto__|constructor|prototype)(\.|$)/i;
-const STRING_EXPRESSION_WORDS = /([^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+)/g;
+const STRING_EXPRESSION_WORDS = /[\dA-Za-z\P{ASCII}]+/gu;
 const STRING_EXPRESSION_WHITESPACE_PREFIX = /^(\s+)/;
 const STRING_MATCH_ENDS_WITH = "endsWith";
 const STRING_MATCH_INCLUDES = "includes";
@@ -1981,9 +1981,7 @@ function assertInstanceOf(constructor, message, error) {
 * @returns _Asserter_
 */
 function assertIs(condition, message, error) {
-	return (value) => {
-		assert(() => condition(value), message, error);
-	};
+	return assertCondition(condition, message, error);
 }
 /**
 * Creates an _Asserter_ that asserts a property of a value exists and satisfies a condition, throwing an error if it does not
@@ -2568,12 +2566,17 @@ pipe.async = asyncPipe;
 //#endregion
 //#region src/models/string/string.case.model.ts
 const STRING_CASE_CAMEL = "camel";
+const STRING_CASE_CAPITALIZE = "capitalize";
 const STRING_CASE_KEBAB = "kebab";
+const STRING_CASE_LOWER = "lower";
 const STRING_CASE_PASCAL = "pascal";
 const STRING_CASE_SNAKE = "snake";
+const STRING_CASE_TITLE = "title";
+const STRING_CASE_UPPER = "upper";
 const STRING_EXPRESSION_CAMEL_CASE = /(\p{Ll})(\p{Lu})/gu;
-const STRING_EXPRESSION_ACRONYM = /(\p{Lu}*)(\p{Lu})(\p{Ll}+)/gu;
+const STRING_EXPRESSION_ACRONYM = /(?<=\p{Lu})(?=\p{Lu}\p{Ll})(?!\p{Lu}s(?!\p{Ll}))/gu;
 const STRING_REPLACEMENT_CAMEL_CASE = "$1-$2";
+const ignoreCachingCases = /* @__PURE__ */ new Set(["lower", "upper"]);
 //#endregion
 //#region src/internal/string/case.ts
 /**
@@ -2608,9 +2611,11 @@ function camelCase(value) {
 * ```
 */
 function capitalize(value) {
-	if (typeof value !== "string" || value.length === 0) return "";
-	memoizedCapitalize ??= memoize((v) => v.length === 1 ? v.toLocaleUpperCase() : `${v.charAt(0).toLocaleUpperCase()}${v.slice(1).toLocaleLowerCase()}`);
-	return memoizedCapitalize.run(value);
+	return toCase(STRING_CASE_CAPITALIZE, value, true, true, capitalizeHandler);
+}
+function capitalizeHandler(value) {
+	if (value.length === 1) return value.toLocaleUpperCase();
+	return `${value.charAt(0).toLocaleUpperCase()}${value.slice(1).toLocaleLowerCase()}`;
 }
 /**
 * Convert a string to kebab case _(this-is-kebab-case)_
@@ -2643,9 +2648,10 @@ function kebabCase(value) {
 * ```
 */
 function lowerCase(value) {
-	if (typeof value !== "string") return "";
-	memoizedLowerCase ??= memoize((v) => v.toLocaleLowerCase());
-	return memoizedLowerCase.run(value);
+	return toCase(STRING_CASE_LOWER, value, false, false, lowerCaseHandler);
+}
+function lowerCaseHandler(value) {
+	return value.toLocaleLowerCase();
 }
 /**
 * Convert a string to pascal case _(ThisIsPascalCase)_
@@ -2696,33 +2702,39 @@ function snakeCase(value) {
 * ```
 */
 function titleCase(value) {
-	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);
+	return toCase(STRING_CASE_TITLE, value, true, true, titleCaseHandler);
 }
-function toCase(type, value, capitalizeAny, capitalizeFirst) {
-	caseMemoizers[type] ??= memoize(toCaseCallback.bind({
-		type,
-		capitalizeAny,
-		capitalizeFirst
-	}));
-	return caseMemoizers[type].run(value);
+function titleCaseHandler(value) {
+	if (value.length < 2) return capitalize(value);
+	return join(words(value).map(capitalize), " ");
 }
-function toCaseCallback(value) {
+function toCase(type, value, capitalizeAny, capitalizeFirst, handler) {
 	if (typeof value !== "string") return "";
-	if (value.length < 1) return value;
+	if (value.trim().length === 0) return value;
+	if (handler == null) {
+		caseMemoizers[type] ??= memoize(toCaseCallback.bind({
+			type,
+			capitalizeAny,
+			capitalizeFirst
+		}));
+		return caseMemoizers[type].run(value);
+	}
+	if (ignoreCachingCases.has(type)) return handler(value);
+	simpleMemoizers[type] ??= memoize(handler);
+	return simpleMemoizers[type].run(value);
+}
+function toCaseCallback(value) {
 	const { capitalizeAny, capitalizeFirst, type } = this;
 	const parts = words(value);
 	const partsLength = parts.length;
 	const cased = [];
 	for (let partIndex = 0; partIndex < partsLength; partIndex += 1) {
-		const items = parts[partIndex].replace(STRING_EXPRESSION_ACRONYM, (full, one, two, three) => three === "s" ? full : `${one}-${two}${three}`).replace(STRING_EXPRESSION_CAMEL_CASE, STRING_REPLACEMENT_CAMEL_CASE).split("-");
+		const items = parts[partIndex].replace(STRING_EXPRESSION_ACRONYM, "-").replace(STRING_EXPRESSION_CAMEL_CASE, STRING_REPLACEMENT_CAMEL_CASE).split("-");
 		const itemsLength = items.length;
 		const partResult = [];
 		let itemCount = 0;
 		for (let itemIndex = 0; itemIndex < itemsLength; itemIndex += 1) {
 			const item = items[itemIndex];
-			if (item.length === 0) continue;
 			if (!capitalizeAny || itemCount === 0 && partIndex === 0 && !capitalizeFirst) partResult.push(item.toLocaleLowerCase());
 			else partResult.push(capitalize(item));
 			itemCount += 1;
@@ -2746,9 +2758,10 @@ function toCaseCallback(value) {
 * ```
 */
 function upperCase(value) {
-	if (typeof value !== "string" || value.length === 0) return "";
-	memoizedUpperCase ??= memoize((v) => v.toLocaleUpperCase());
-	return memoizedUpperCase.run(value);
+	return toCase(STRING_CASE_UPPER, value, false, false, upperCaseHandler);
+}
+function upperCaseHandler(value) {
+	return value.toLocaleUpperCase();
 }
 const caseMemoizers = {};
 const delimiters = {
@@ -2757,10 +2770,7 @@ const delimiters = {
 	[STRING_CASE_PASCAL]: "",
 	[STRING_CASE_SNAKE]: "_"
 };
-let memoizedCapitalize;
-let memoizedLowerCase;
-let memoizedTitleCase;
-let memoizedUpperCase;
+const simpleMemoizers = {};
 //#endregion
 //#region src/models/value/value.equal.model.ts
 const EQUAL_ERROR_PROPERTIES = ["name", "message"];
@@ -3728,79 +3738,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`
-*
-* @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/string/fuzzy.ts
 function Fuzzy(state) {
 	this[FUZZY_SYMBOL] = state;
@@ -3810,39 +3753,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?
@@ -3856,53 +3836,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 getFuzzyStrings() {
-	return this[FUZZY_SYMBOL].strings.slice();
+function getItems() {
+	return this[FUZZY_SYMBOL].items.original.map((item) => item.data);
 }
-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?
 *
@@ -3914,74 +3958,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 score = getScore(haystack, value);
+		const position = string.lowercase.indexOf(lowercaseValue);
+		if (position > -1) {
+			included.push(createRanked(item, lowercaseValue, position));
+			continue;
+		}
+		const score = getScore(string, lowercaseValue);
 		if (score > -1) {
 			scored[score] ??= [];
-			scored[score].push({
-				item,
-				haystack
-			});
+			scored[score].push(item);
 		}
 	}
-	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]));
-		}
-	}
-	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
@@ -4089,6 +4107,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",
@@ -4195,7 +4281,7 @@ let deburrMemoizer;
 normalize.initialize = initializeNormalizer;
 //#endregion
 //#region src/models/string/string.template.model.ts
-const TEMPLATE_EXPRESSION_VARIABLE = /{{([\s\S]+?)}}/g;
+const TEMPLATE_EXPRESSION_VARIABLE = /{{([^{}]+)}}/g;
 const TEMPLATE_SYMBOL = Symbol("template");
 //#endregion
 //#region src/string/template.ts
@@ -5002,9 +5088,7 @@ function addSubscription(instance) {
 		return;
 	}
 	/* istanbul ignore if */
-	if (items.keyed == null || values.from.keyed == null || values.to.keyed == null)
- // istanbul ignore next
-	return;
+	if (items.keyed == null || values.from.keyed == null || values.to.keyed == null) return;
 	let keyedItems = items.keyed.get(key);
 	if (keyedItems == null) {
 		keyedItems = /* @__PURE__ */ new Set();
@@ -5154,9 +5238,7 @@ function removeSubscription() {
 	}
 	const keyed = items.keyed?.get(key);
 	/* istanbul ignore if */
-	if (items.keyed == null || keyed == null)
- // istanbul ignore next
-	return;
+	if (items.keyed == null || keyed == null) return;
 	removeFromStore(keyed, values, this, value, key);
 	if (keyed.size === 0) items.keyed.delete(key);
 }
@@ -7578,4 +7660,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, 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 };
+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, toCaseCallback, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, use, words };