@oscarpalmer/atoms 0.218.0 → 0.220.0

package/dist/promise/misc.d.mts

@@ -11,7 +11,13 @@ import { isFulfilled, isRejected } from "./helpers.mjs";
  * @returns Cancelable _Promise_
  */
 export declare function cancelable<Value>(executor: (resolve: (value: Value) => void, reject: (reason: unknown) => void) => void): CancelablePromise<Value>;
+/**
+ * @internal
+ */
 export declare function handleResult(status: string, parameters: PromiseParameters): void;
+/**
+ * @internal
+ */
 export declare function settlePromise(settler: (value: any) => void, value: unknown, aborter?: Aborter): void;
 /**
  * Converts a _Promise_ to a promised result

package/dist/promise/misc.mjs

@@ -12,6 +12,9 @@ import { isFulfilled, isRejected } from "./helpers.mjs";
 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;
@@ -35,6 +38,9 @@ function handleResult(status, parameters) {
 		handlers.resolve(data.result);
 	}
 }
+/**
+* @internal
+*/
 function settlePromise(settler, value, aborter) {
 	aborter?.cancel();
 	settler(value);

package/dist/promise/timed.d.mts

@@ -1,6 +1,9 @@
 import { RequiredKeys } from "../models/index.mjs";
 import { PromiseOptions } from "../models/promise.model.mjs";
 //#region src/promise/timed.d.ts
+/**
+ * @internal
+ */
 export declare function getTimedPromise<Value>(promise: Promise<Value>, time: number, signal?: AbortSignal): Promise<Value>;
 /**
  * Create a _Promise_ that should be settled within a certain amount of time

package/dist/promise/timed.mjs

@@ -5,6 +5,9 @@ import { PROMISE_MESSAGE_EXPECTATION_TIMED, PromiseTimeoutError } from "../model
 import { createPromiseOptions } from "./helpers.mjs";
 import { settlePromise } from "./misc.mjs";
 //#region src/promise/timed.ts
+/**
+* @internal
+*/
 async function getTimedPromise(promise, time, signal) {
 	const aborter = createAborter(signal, () => {
 		limiter.cancel();

package/dist/queue.d.mts

@@ -17,7 +17,6 @@ export declare function isKeyedQueue(value: unknown): value is KeyedQueue<Generi
  * @returns `true` if the value is a queue, otherwise `false`
  */
 export declare function isQueue(value: unknown): value is Queue<GenericCallback | GenericAsyncCallback>;
-export declare function isQueueInstance<Instance>(name: string, value: unknown): value is Instance;
 /**
  * Create a keyed queue for an asynchronous callback function, where each key has its own queue
  *

package/dist/queue.mjs

@@ -360,4 +360,4 @@ async function run(state) {
 }
 queue.keyed = keyedQueue;
 //#endregion
-export { isKeyedQueue, isQueue, isQueueInstance, keyedQueue, queue };
+export { isKeyedQueue, isQueue, keyedQueue, queue };

package/dist/string/fuzzy.d.mts

@@ -1,7 +1,7 @@
 import { PlainObject } from "../models/index.mjs";
-import { Fuzzy, FuzzyConfiguration, FuzzyItem, FuzzyOptions, FuzzyResult, FuzzyState } from "../models/string/string.fuzzy.model.mjs";
+import { Fuzzy, FuzzyConfiguration, FuzzyOptions, FuzzyResult, FuzzyState, InternalFuzzy } from "../models/string/string.fuzzy.model.mjs";
 //#region src/string/fuzzy.d.ts
-declare function Fuzzy(this: any, state: FuzzyState<unknown>): void;
+declare function Fuzzy(this: InternalFuzzy, state: FuzzyState<unknown>): void;
 /**
  * Create a fuzzy searcher for an array of items
  *
@@ -50,4 +50,4 @@ export declare namespace fuzzy {
   export var match: typeof fuzzyMatch;
 }
 //#endregion
-export type { Fuzzy, FuzzyItem, FuzzyOptions, FuzzyResult };
+export type { Fuzzy, FuzzyOptions, FuzzyResult };

package/dist/string/fuzzy.mjs

@@ -3,8 +3,7 @@ import { floor } from "../internal/math/misc.mjs";
 import { max } from "../internal/math/aggregate.mjs";
 import { getString } from "../internal/string/misc.mjs";
 import { lowerCase } from "../internal/string/case.mjs";
-import { FUZZY_MESSAGE_ARRAY, FUZZY_MESSAGE_HANDLER, FUZZY_PROPERTY, FUZZY_SYMBOL } from "../models/string/string.fuzzy.model.mjs";
-import { includes } from "./match.mjs";
+import { FUZZY_BOUNDARY_SEPARATOR, FUZZY_MESSAGE_ARRAY, FUZZY_MESSAGE_HANDLER, FUZZY_PROPERTY, FUZZY_SYMBOL } from "../models/string/string.fuzzy.model.mjs";
 //#region src/string/fuzzy.ts
 function Fuzzy(state) {
 	this[FUZZY_SYMBOL] = state;
@@ -14,39 +13,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?
@@ -60,53 +96,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?
 *
@@ -118,74 +218,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

package/dist/string/index.d.mts

@@ -31,7 +31,7 @@ export declare function getUuid(): string;
  *
  * @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
  */
 export declare function parse(value: string, reviver?: (this: unknown, key: string, value: unknown) => unknown): unknown;
 /**
@@ -39,6 +39,13 @@ export declare function parse(value: string, reviver?: (this: unknown, key: stri
  *
  * @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('');                   // => ''
+ * ```
  */
 export declare function trim(value: string): string;
 /**
@@ -48,6 +55,13 @@ export declare function trim(value: string): string;
  * @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);          // => ''
+ * ```
  */
 export declare function truncate(value: string, length: number, suffix?: string): string;
 //#endregion

package/dist/string/index.mjs

@@ -57,7 +57,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 {
@@ -71,6 +71,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() : "";
@@ -82,6 +89,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 "";

package/dist/string/match.d.mts

@@ -6,6 +6,14 @@
  * @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
+ * ```
  */
 export declare function endsWith(haystack: string, needle: string, ignoreCase?: boolean): boolean;
 /**
@@ -15,6 +23,14 @@ export declare function endsWith(haystack: string, needle: string, ignoreCase?:
  * @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
+ * ```
  */
 export declare function includes(haystack: string, needle: string, ignoreCase?: boolean): boolean;
 /**
@@ -24,6 +40,14 @@ export declare function includes(haystack: string, needle: string, ignoreCase?:
  * @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
+ * ```
  */
 export declare function startsWith(haystack: string, needle: string, ignoreCase?: boolean): boolean;
 //#endregion

package/dist/string/match.mjs

@@ -8,6 +8,14 @@ import { memoize } from "../internal/function/memoize.mjs";
 * @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);
@@ -19,6 +27,14 @@ function endsWith(haystack, needle, ignoreCase) {
 * @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);
@@ -38,6 +54,14 @@ function matchCallback(haystack, needle, ignoreCase) {
 * @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);

package/dist/string/template.d.mts

@@ -24,6 +24,10 @@ export declare function template(strings: TemplateStringsArray, ...values: unkno
  * @param variables Variables to use
  * @param options Templating options
  * @returns Templated string
+ * @example
+ * ```typescript
+ * template('Hello, {{name}}!', {name: 'World'}); // => 'Hello, World!'
+ * ```
  */
 export declare function template(value: string, variables?: PlainObject, options?: Partial<TemplateOptions>): string;
 export declare namespace template {

package/package.json

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