@oscarpalmer/atoms 0.193.1 → 0.194.0

package/dist/queue.mjs

@@ -1,3 +1,4 @@
+import { createAborter } from "./internal/abort.mjs";
 import { getNumberOrDefault } from "./internal/number.mjs";
 //#region src/queue.ts
 /**
@@ -6,11 +7,47 @@ import { getNumberOrDefault } from "./internal/number.mjs";
 var QueueError = class extends Error {
 	constructor(message) {
 		super(message);
-		this.name = ERROR_NAME;
+		this.name = QUEUE_ERROR_NAME;
 	}
 };
+function addToQueue(instance, state, parameters, signal) {
+	if (instance.full) throw new QueueError(QUEUE_MESSAGE_MAXIMUM);
+	const abortSignal = signal instanceof AbortSignal ? signal : void 0;
+	if (abortSignal?.aborted ?? false) throw new Error(abortSignal?.reason);
+	const id = identify(state);
+	let rejector;
+	let resolver;
+	const promise = new Promise((resolve, reject) => {
+		rejector = reject;
+		resolver = resolve;
+	});
+	const aborter = createAborter(abortSignal, () => rejector(abortSignal?.reason));
+	state.items.push({
+		aborter,
+		id,
+		parameters,
+		promise,
+		key: state.key,
+		reject: rejector,
+		resolve: resolver
+	});
+	if (state.options.autostart) run(state);
+	return {
+		id,
+		promise
+	};
+}
+function clearQueue(state) {
+	const items = state.items.splice(0);
+	const { length } = items;
+	for (let index = 0; index < length; index += 1) {
+		const { aborter, reject } = items[index];
+		aborter?.cancel();
+		reject(new QueueError(QUEUE_MESSAGE_CLEAR));
+	}
+}
 function createQueue(callback, options, key) {
-	if (typeof callback !== "function") throw new TypeError(MESSAGE_CALLBACK);
+	if (typeof callback !== "function") throw new TypeError(QUEUE_MESSAGE_CALLBACK);
 	const state = {
 		callback,
 		key,
@@ -22,71 +59,16 @@ function createQueue(callback, options, key) {
 		runners: 0
 	};
 	const instance = {
-		add: (parameters, signal) => {
-			if (instance.full) throw new QueueError(MESSAGE_MAXIMUM);
-			const abortSignal = signal instanceof AbortSignal ? signal : void 0;
-			if (abortSignal?.aborted ?? false) throw new Error(abortSignal.reason);
-			const id = identify(state);
-			let rejector;
-			let resolver;
-			const promise = new Promise((resolve, reject) => {
-				rejector = reject;
-				resolver = resolve;
-			});
-			const aborter = abortSignal == null ? void 0 : () => rejector(abortSignal.reason);
-			signal?.addEventListener(EVENT_NAME, aborter, EVENT_OPTIONS);
-			state.items.push({
-				id,
-				parameters,
-				promise,
-				abort: aborter,
-				key: state.key,
-				reject: rejector,
-				resolve: resolver,
-				signal: abortSignal
-			});
-			if (state.options.autostart) run(state);
-			return {
-				id,
-				promise
-			};
-		},
-		clear: () => {
-			const items = state.items.splice(0);
-			const { length } = items;
-			for (let index = 0; index < length; index += 1) {
-				const { abort, reject, signal } = items[index];
-				reject(new QueueError(MESSAGE_CLEAR));
-				signal?.removeEventListener(EVENT_NAME, abort);
-			}
-		},
+		add: (parameters, signal) => addToQueue(instance, state, parameters, signal),
+		clear: () => clearQueue(state),
 		pause: () => {
 			state.paused = true;
 		},
-		remove: (id) => {
-			const index = state.items.findIndex((item) => item.id === id);
-			if (index > -1) {
-				const { abort, reject, signal } = state.items.splice(index, 1)[0];
-				reject(new QueueError(MESSAGE_REMOVE));
-				signal?.removeEventListener(EVENT_NAME, abort);
-			}
-		},
-		resume: () => {
-			if (state.paused) {
-				const handled = state.handled.splice(0);
-				const { length } = handled;
-				for (let index = 0; index < length; index += 1) handled[index]();
-			}
-			state.paused = false;
-			const length = Math.min(state.options.concurrency, state.items.length);
-			for (let index = 0; index < length; index += 1) run(state);
-		}
+		remove: (id) => removeQueued(state, id),
+		resume: () => resumeQueue(state)
 	};
 	Object.defineProperties(instance, {
-		[KEY_QUEUE]: {
-			enumerable: false,
-			value: NAME_QUEUE
-		},
+		[QUEUE_PROPERTY]: { value: QUEUE_NAME_QUEUE },
 		active: {
 			enumerable: true,
 			get: () => state.runners > 0
@@ -125,12 +107,6 @@ function createQueue(callback, options, key) {
 function getBooleanOrDefault(value, defaultValue) {
 	return typeof value === "boolean" ? value : defaultValue;
 }
-function getItems(state) {
-	const size = {};
-	const queues = state.queues.entries();
-	for (const [key, queue] of queues) size[key] = queue.size;
-	return size;
-}
 function getOptions(input) {
 	const options = typeof input === "object" && input != null ? input : {};
 	return {
@@ -140,7 +116,7 @@ function getOptions(input) {
 	};
 }
 function getQueue(state, key, add) {
-	if (typeof key !== "string" || key.trim().length === 0) throw new TypeError(MESSAGE_KEY);
+	if (typeof key !== "string" || key.trim().length === 0) throw new TypeError(QUEUE_MESSAGE_KEY);
 	let queue = state.queues.get(key);
 	if (queue == null && add === true) {
 		queue = createQueue(state.callback, state.options, key);
@@ -148,6 +124,12 @@ function getQueue(state, key, add) {
 	}
 	return queue;
 }
+function getQueueItems(state) {
+	const size = {};
+	const queues = state.queues.entries();
+	for (const [key, queue] of queues) size[key] = queue.size;
+	return size;
+}
 function getStatus(state, status) {
 	const queues = state.queues.entries();
 	const result = [];
@@ -155,8 +137,8 @@ function getStatus(state, status) {
 	return result;
 }
 function handleQueuedResult(item, error, result) {
-	item.signal?.removeEventListener(EVENT_NAME, item.abort);
-	if (item.signal?.aborted ?? false) {
+	item.aborter?.cancel();
+	if (item.aborter?.signal?.aborted ?? false) {
 		item.reject();
 		return;
 	}
@@ -185,7 +167,7 @@ function identify(state) {
 * @returns `true` if the value is a keyed queue, otherwise `false`
 */
 function isKeyedQueue(value) {
-	return isQueueInstance(NAME_KEYED, value);
+	return isQueueInstance(QUEUE_NAME_KEYED, value);
 }
 /**
 * Is the value a queue?
@@ -194,13 +176,13 @@ function isKeyedQueue(value) {
 * @returns `true` if the value is a queue, otherwise `false`
 */
 function isQueue(value) {
-	return isQueueInstance(NAME_QUEUE, value);
+	return isQueueInstance(QUEUE_NAME_QUEUE, value);
 }
 function isQueueInstance(name, value) {
-	return typeof value === "object" && value != null && value[KEY_QUEUE] === name;
+	return typeof value === "object" && value != null && value[QUEUE_PROPERTY] === name;
 }
 function keyedQueue(callback, options) {
-	if (typeof callback !== "function") throw new TypeError(MESSAGE_CALLBACK);
+	if (typeof callback !== "function") throw new TypeError(QUEUE_MESSAGE_CALLBACK);
 	const state = {
 		callback,
 		options: getOptions(options),
@@ -208,26 +190,17 @@ function keyedQueue(callback, options) {
 	};
 	const instance = {
 		add: (key, parameters, signal) => getQueue(state, key, true).add(parameters, signal),
-		clear: (key) => {
-			handleQueues(state, HANDLE_CLEAR, key);
-		},
+		clear: (key) => handleQueues(state, QUEUE_HANDLE_CLEAR, key),
 		get: (key) => getQueue(state, key),
-		pause: (key) => {
-			handleQueues(state, HANDLE_PAUSE, key);
-		},
+		pause: (key) => handleQueues(state, QUEUE_HANDLE_PAUSE, key),
 		remove: (key, id) => removeQueue(state, key, id),
-		resume: (key) => {
-			handleQueues(state, HANDLE_RESUME, key);
-		}
+		resume: (key) => handleQueues(state, QUEUE_HANDLE_RESUME, key)
 	};
 	Object.defineProperties(instance, {
-		[KEY_QUEUE]: {
-			enumerable: false,
-			value: NAME_KEYED
-		},
+		[QUEUE_PROPERTY]: { value: QUEUE_NAME_KEYED },
 		active: {
 			enumerable: true,
-			get: () => getStatus(state, STATUS_ACTIVE)
+			get: () => getStatus(state, QUEUE_STATUS_ACTIVE)
 		},
 		autostart: {
 			enumerable: true,
@@ -239,15 +212,15 @@ function keyedQueue(callback, options) {
 		},
 		empty: {
 			enumerable: true,
-			get: () => getStatus(state, STATUS_EMPTY)
+			get: () => getStatus(state, QUEUE_STATUS_EMPTY)
 		},
 		full: {
 			enumerable: true,
-			get: () => getStatus(state, STATUS_FULL)
+			get: () => getStatus(state, QUEUE_STATUS_FULL)
 		},
 		items: {
 			enumerable: true,
-			get: () => getItems(state)
+			get: () => getQueueItems(state)
 		},
 		keys: {
 			enumerable: true,
@@ -259,7 +232,7 @@ function keyedQueue(callback, options) {
 		},
 		paused: {
 			enumerable: true,
-			get: () => getStatus(state, STATUS_PAUSED)
+			get: () => getStatus(state, QUEUE_STATUS_PAUSED)
 		},
 		queues: {
 			enumerable: true,
@@ -274,7 +247,7 @@ function queue(callback, options) {
 queue.keyed = keyedQueue;
 function removeQueue(state, key, id) {
 	if (key == null) {
-		handleQueues(state, HANDLE_CLEAR);
+		handleQueues(state, QUEUE_HANDLE_CLEAR);
 		state.queues.clear();
 		return;
 	}
@@ -287,6 +260,24 @@ function removeQueue(state, key, id) {
 	queue.clear();
 	state.queues.delete(key);
 }
+function removeQueued(state, id) {
+	const index = state.items.findIndex((item) => item.id === id);
+	if (index > -1) {
+		const { aborter, reject } = state.items.splice(index, 1)[0];
+		aborter?.cancel();
+		reject(new QueueError(QUEUE_MESSAGE_REMOVE));
+	}
+}
+function resumeQueue(state) {
+	if (state.paused) {
+		const handled = state.handled.splice(0);
+		const { length } = handled;
+		for (let index = 0; index < length; index += 1) handled[index]();
+	}
+	state.paused = false;
+	const length = Math.min(state.options.concurrency, state.items.length);
+	for (let index = 0; index < length; index += 1) run(state);
+}
 async function run(state) {
 	if (state.paused || state.runners >= state.options.concurrency) return;
 	state.runners += 1;
@@ -295,7 +286,7 @@ async function run(state) {
 		let error = false;
 		let result;
 		try {
-			if (!(item.signal?.aborted ?? false)) {
+			if (!(item.aborter?.signal?.aborted ?? false)) {
 				const parameters = item.key == null ? item.parameters : [item.key, ...item.parameters];
 				result = await state.callback(...parameters);
 			}
@@ -305,9 +296,7 @@ async function run(state) {
 		}
 		if (state.paused) {
 			const paused = item;
-			state.handled.push(() => {
-				handleQueuedResult(paused, error, result);
-			});
+			state.handled.push(() => handleQueuedResult(paused, error, result));
 			break;
 		}
 		handleQueuedResult(item, error, result);
@@ -315,23 +304,21 @@ async function run(state) {
 	}
 	state.runners -= 1;
 }
-const ERROR_NAME = "QueueError";
-const EVENT_NAME = "abort";
-const EVENT_OPTIONS = { once: true };
-const KEY_QUEUE = "$queue";
-const HANDLE_CLEAR = "clear";
-const HANDLE_PAUSE = "pause";
-const HANDLE_RESUME = "resume";
-const MESSAGE_CALLBACK = "A Queue requires a callback function";
-const MESSAGE_CLEAR = "Queue was cleared";
-const MESSAGE_KEY = "Key must be a non-empty string";
-const MESSAGE_MAXIMUM = "Queue has reached its maximum size";
-const MESSAGE_REMOVE = "Item removed from queue";
-const NAME_KEYED = "keyedQueue";
-const NAME_QUEUE = "queue";
-const STATUS_ACTIVE = "active";
-const STATUS_EMPTY = "empty";
-const STATUS_FULL = "full";
-const STATUS_PAUSED = "paused";
+const QUEUE_ERROR_NAME = "QueueError";
+const QUEUE_PROPERTY = "$queue";
+const QUEUE_HANDLE_CLEAR = "clear";
+const QUEUE_HANDLE_PAUSE = "pause";
+const QUEUE_HANDLE_RESUME = "resume";
+const QUEUE_MESSAGE_CALLBACK = "A Queue requires a callback function";
+const QUEUE_MESSAGE_CLEAR = "Queue was cleared";
+const QUEUE_MESSAGE_KEY = "Key must be a non-empty string";
+const QUEUE_MESSAGE_MAXIMUM = "Queue has reached its maximum size";
+const QUEUE_MESSAGE_REMOVE = "Item removed from queue";
+const QUEUE_NAME_KEYED = "keyedQueue";
+const QUEUE_NAME_QUEUE = "queue";
+const QUEUE_STATUS_ACTIVE = "active";
+const QUEUE_STATUS_EMPTY = "empty";
+const QUEUE_STATUS_FULL = "full";
+const QUEUE_STATUS_PAUSED = "paused";
 //#endregion
 export { QueueError, isKeyedQueue, isQueue, isQueueInstance, keyedQueue, queue };

package/dist/random.mjs

@@ -8,7 +8,7 @@ import { join } from "./internal/string.mjs";
 * @returns Random boolean
 */
 function getRandomBoolean() {
-	return Math.random() > BOOLEAN_MODIFIER;
+	return Math.random() > RANDOM_BOOLEAN_MODIFIER;
 }
 /**
 * Get a random string of characters with a specified length
@@ -19,7 +19,7 @@ function getRandomBoolean() {
 */
 function getRandomCharacters(length, selection) {
 	if (typeof length !== "number" || length <= 0) return "";
-	const actual = typeof selection === "string" && selection.length > 0 ? selection : ALPHABET;
+	const actual = typeof selection === "string" && selection.length > 0 ? selection : RANDOM_ALPHABET;
 	let characters = "";
 	for (let index = 0; index < length; index += 1) characters += actual.charAt(getRandomInteger(0, actual.length - 1));
 	return characters;
@@ -39,7 +39,7 @@ function getRandomColor(prefix) {
 * @returns Random hexadecimal character from `0-9` and `A-F`
 */
 function getRandomHex() {
-	return HEX_CHARACTERS[getRandomInteger(0, HEX_MAXIMUM)];
+	return RANDOM_HEX_CHARACTERS[getRandomInteger(0, RANDOM_HEX_MAXIMUM)];
 }
 /**
 * Get a random item from an array
@@ -57,9 +57,9 @@ function getRandomItems(array, amount) {
 	if (amount === 1) return [array[getRandomInteger(0, array.length - 1)]];
 	return typeof amount !== "number" || amount <= 0 || amount >= array.length ? shuffle(array) : shuffle(array).slice(0, amount);
 }
-const ALPHABET = "abcdefghijklmnopqrstuvwxyz";
-const BOOLEAN_MODIFIER = .5;
-const HEX_CHARACTERS = "0123456789ABCDEF";
-const HEX_MAXIMUM = 15;
+const RANDOM_ALPHABET = "abcdefghijklmnopqrstuvwxyz";
+const RANDOM_BOOLEAN_MODIFIER = .5;
+const RANDOM_HEX_CHARACTERS = "0123456789ABCDEF";
+const RANDOM_HEX_MAXIMUM = 15;
 //#endregion
 export { getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloatingNumber as getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems };

package/dist/result/index.d.mts

@@ -53,8 +53,5 @@ declare function attempt<Value, E>(callback: () => Value, error: E): ExtendedRes
  * @returns Callback result
  */
 declare function attempt<Value>(callback: () => Value): Result<Value, Error>;
-declare namespace attempt {
-  var async: typeof asyncAttempt;
-}
 //#endregion
 export { asyncAttempt, attempt };

package/dist/result/index.mjs

@@ -17,6 +17,6 @@ function attempt(callback, err) {
 		return getError(err ?? thrown, err == null ? void 0 : thrown);
 	}
 }
-attempt.async = asyncAttempt;
+Object.defineProperty(attempt, "async", { value: asyncAttempt });
 //#endregion
 export { asyncAttempt, attempt };

package/dist/result/match.d.mts

@@ -38,8 +38,5 @@ declare function matchResult<Value, Returned, E = Error>(result: AnyResult<Value
  * @returns Matched value
  */
 declare function matchResult<Value, Returned, E = Error>(result: AnyResult<Value, E> | (() => AnyResult<Value, E>), ok: ResultMatch<Value, Returned, E>['ok'], error: ResultMatch<Value, Returned, E>['error']): Returned;
-declare namespace matchResult {
-  var async: typeof asyncMatchResult;
-}
 //#endregion
 export { asyncMatchResult, matchResult };

package/dist/result/match.mjs

@@ -5,7 +5,7 @@ async function asyncMatchResult(result, first, error) {
 	if (typeof result === "function") value = await result();
 	else if (result instanceof Promise) value = await result;
 	else value = result;
-	if (!isResult(value)) throw new Error(MESSAGE_RESULT);
+	if (!isResult(value)) throw new Error(MATCH_MESSAGE);
 	const hasObj = typeof first === "object" && first !== null;
 	const okHandler = hasObj ? first.ok : first;
 	const errorHandler = hasObj ? first.error : error;
@@ -14,14 +14,14 @@ async function asyncMatchResult(result, first, error) {
 }
 function matchResult(result, first, error) {
 	const value = typeof result === "function" ? result() : result;
-	if (!isResult(value)) throw new Error(MESSAGE_RESULT);
+	if (!isResult(value)) throw new Error(MATCH_MESSAGE);
 	const hasObj = typeof first === "object" && first !== null;
 	const okHandler = hasObj ? first.ok : first;
 	const errorHandler = hasObj ? first.error : error;
 	if (isOk(value)) return okHandler(value.value);
 	return errorHandler(value.error, value.original);
 }
-matchResult.async = asyncMatchResult;
-const MESSAGE_RESULT = "`result.match` expected a Result or a function that returns a Result";
+const MATCH_MESSAGE = "`result.match` expected a Result or a function that returns a Result";
+Object.defineProperty(matchResult, "async", { value: asyncMatchResult });
 //#endregion
 export { asyncMatchResult, matchResult };

package/dist/result/misc.mjs

@@ -33,12 +33,12 @@ function ok(value) {
 */
 async function toPromise(result) {
 	const actual = typeof result === "function" ? result() : result;
-	if (!isResult(actual)) return Promise.reject(new Error(MESSAGE_PROMISE_RESULT));
+	if (!isResult(actual)) return Promise.reject(new Error(RESULT_MESSAGE_PROMISE));
 	return isOk(actual) ? Promise.resolve(actual.value) : Promise.reject(actual.error);
 }
 function unwrap(value, defaultValue) {
 	return isOk(value) ? value.value : defaultValue;
 }
-const MESSAGE_PROMISE_RESULT = "toPromise expected to receive a Result";
+const RESULT_MESSAGE_PROMISE = "toPromise expected to receive a Result";
 //#endregion
 export { error, getError, isError, isOk, isResult, ok, toPromise, unwrap };

package/dist/result/work/flow.d.mts

@@ -177,8 +177,5 @@ declare function attemptFlow<First extends GenericCallback>(first: First, ...fns
  * @returns _Flow_ function
  */
 declare function attemptFlow(...fns: GenericCallback[]): (...args: unknown[]) => Result<unknown>;
-declare namespace attemptFlow {
-  var async: typeof attemptAsyncFlow;
-}
 //#endregion
 export { AttemptFlow, AttemptFlowPromise, attemptAsyncFlow, attemptFlow };

package/dist/result/work/flow.mjs

@@ -1,11 +1,11 @@
 import { isError, isOk } from "../../internal/result.mjs";
-import { flow } from "../../function/work.mjs";
-import { attempt } from "../index.mjs";
+import { asyncFlow, flow } from "../../function/work.mjs";
+import { asyncAttempt, attempt } from "../index.mjs";
 //#region src/result/work/flow.ts
 function attemptAsyncFlow(...fns) {
 	let Flow;
-	return (...args) => attempt.async(() => {
-		Flow ??= flow.async(...fns);
+	return (...args) => asyncAttempt(() => {
+		Flow ??= asyncFlow(...fns);
 		return Flow(...args.map((value) => {
 			if (isError(value)) throw value.error;
 			return isOk(value) ? value.value : value;
@@ -22,6 +22,6 @@ function attemptFlow(...fns) {
 		}));
 	});
 }
-attemptFlow.async = attemptAsyncFlow;
+Object.defineProperty(attemptFlow, "async", { value: attemptAsyncFlow });
 //#endregion
 export { attemptAsyncFlow, attemptFlow };

package/dist/result/work/pipe.d.mts

@@ -178,8 +178,5 @@ declare function attemptPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth
  * @returns _Piped_ result
  */
 declare function attemptPipe<Initial>(initial: GenericCallback | Initial | Result<Initial>, first?: (value: UnwrapValue<Initial>) => unknown, ...seconds: Array<(value: unknown) => unknown>): WrapValue<Initial>;
-declare namespace attemptPipe {
-  var async: typeof attemptAsyncPipe;
-}
 //#endregion
 export { attemptAsyncPipe, attemptPipe };

package/dist/result/work/pipe.mjs

@@ -1,9 +1,9 @@
 import { isError, isOk } from "../../internal/result.mjs";
 import { asyncPipe, pipe } from "../../function/work.mjs";
-import { attempt } from "../index.mjs";
+import { asyncAttempt, attempt } from "../index.mjs";
 //#region src/result/work/pipe.ts
 async function attemptAsyncPipe(initial, first, ...seconds) {
-	return attempt.async(() => {
+	return asyncAttempt(() => {
 		if (isError(initial)) throw initial.error;
 		const value = typeof initial === "function" ? initial() : isOk(initial) ? initial.value : initial;
 		if (first == null) return value;
@@ -18,6 +18,6 @@ function attemptPipe(initial, first, ...seconds) {
 		return pipe(value, ...[first, ...seconds]);
 	});
 }
-attemptPipe.async = attemptAsyncPipe;
+Object.defineProperty(attemptPipe, "async", { value: attemptAsyncPipe });
 //#endregion
 export { attemptAsyncPipe, attemptPipe };

package/dist/string/case.mjs

@@ -8,7 +8,7 @@ import { memoize } from "../function/memoize.mjs";
 * @returns Camel-cased string
 */
 function camelCase(value) {
-	return toCase(CASE_CAMEL, value, true, false);
+	return toCase(STRING_CASE_CAMEL, value, true, false);
 }
 /**
 * Capitalize the first letter of a string _(and lowercase the rest)_
@@ -28,7 +28,7 @@ function capitalize(value) {
 * @returns Kebab-cased string
 */
 function kebabCase(value) {
-	return toCase(CASE_KEBAB, value, false, false);
+	return toCase(STRING_CASE_KEBAB, value, false, false);
 }
 /**
 * Convert a string to lower case
@@ -48,7 +48,7 @@ function lowerCase(value) {
 * @returns Pascal-cased string
 */
 function pascalCase(value) {
-	return toCase(CASE_PASCAL, value, true, true);
+	return toCase(STRING_CASE_PASCAL, value, true, true);
 }
 /**
 * Convert a string to snake case _(this_is_snake_case)_
@@ -57,7 +57,7 @@ function pascalCase(value) {
 * @returns Snake-cased string
 */
 function snakeCase(value) {
-	return toCase(CASE_SNAKE, value, false, false);
+	return toCase(STRING_CASE_SNAKE, value, false, false);
 }
 /**
 * Convert a string to title case _(Capitalizing Every Word)_
@@ -86,7 +86,7 @@ function toCaseCallback(value) {
 	const partsLength = parts.length;
 	const cased = [];
 	for (let partIndex = 0; partIndex < partsLength; partIndex += 1) {
-		const items = parts[partIndex].replace(EXPRESSION_ACRONYM, (full, one, two, three) => three === S ? full : `${one}-${two}${three}`).replace(EXPRESSION_CAMEL_CASE, REPLACEMENT_CAMEL_CASE).split("-");
+		const items = parts[partIndex].replace(STRING_EXPRESSION_ACRONYM, (full, one, two, three) => three === STRING_S ? full : `${one}-${two}${three}`).replace(STRING_EXPRESSION_CAMEL_CASE, STRING_REPLACEMENT_CAMEL_CASE).split("-");
 		const itemsLength = items.length;
 		const partResult = [];
 		let itemCount = 0;
@@ -112,23 +112,23 @@ function upperCase(value) {
 	memoizedUpperCase ??= memoize((v) => v.toLocaleUpperCase());
 	return memoizedUpperCase.run(value);
 }
-const CASE_CAMEL = "camel";
-const CASE_KEBAB = "kebab";
-const CASE_PASCAL = "pascal";
-const CASE_SNAKE = "snake";
-const DELIMTER_EMPTY = "";
-const DELIMITER_HYPHEN = "-";
-const DELIMITER_UNDERSCORE = "_";
-const EXPRESSION_CAMEL_CASE = /(\p{Ll})(\p{Lu})/gu;
-const EXPRESSION_ACRONYM = /(\p{Lu}*)(\p{Lu})(\p{Ll}+)/gu;
-const REPLACEMENT_CAMEL_CASE = "$1-$2";
-const S = "s";
+const STRING_CASE_CAMEL = "camel";
+const STRING_CASE_KEBAB = "kebab";
+const STRING_CASE_PASCAL = "pascal";
+const STRING_CASE_SNAKE = "snake";
+const STRING_DELIMTER_EMPTY = "";
+const STRING_DELIMITER_HYPHEN = "-";
+const STRING_DELIMITER_UNDERSCORE = "_";
+const STRING_EXPRESSION_CAMEL_CASE = /(\p{Ll})(\p{Lu})/gu;
+const STRING_EXPRESSION_ACRONYM = /(\p{Lu}*)(\p{Lu})(\p{Ll}+)/gu;
+const STRING_REPLACEMENT_CAMEL_CASE = "$1-$2";
+const STRING_S = "s";
 const caseMemoizers = {};
 const delimiters = {
-	[CASE_CAMEL]: DELIMTER_EMPTY,
-	[CASE_KEBAB]: DELIMITER_HYPHEN,
-	[CASE_PASCAL]: DELIMTER_EMPTY,
-	[CASE_SNAKE]: DELIMITER_UNDERSCORE
+	[STRING_CASE_CAMEL]: STRING_DELIMTER_EMPTY,
+	[STRING_CASE_KEBAB]: STRING_DELIMITER_HYPHEN,
+	[STRING_CASE_PASCAL]: STRING_DELIMTER_EMPTY,
+	[STRING_CASE_SNAKE]: STRING_DELIMITER_UNDERSCORE
 };
 let memoizedCapitalize;
 let memoizedLowerCase;