@alextheman/utility 2.21.0 → 3.0.0

package/dist/index.cjs

@@ -1,745 +1,586 @@
-"use strict";
+//#region rolldown:runtime
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  APIError: () => APIError_default,
-  DataError: () => DataError_default,
-  addDaysToDate: () => addDaysToDate_default,
-  appendSemicolon: () => appendSemicolon_default,
-  camelToKebab: () => camelToKebab_default,
-  convertFileToBase64: () => convertFileToBase64_default,
-  createFormData: () => createFormData_default,
-  createTemplateStringsArray: () => createTemplateStringsArray_default,
-  fillArray: () => fillArray_default,
-  formatDateAndTime: () => formatDateAndTime_default,
-  getRandomNumber: () => getRandomNumber_default,
-  getRecordKeys: () => getRecordKeys_default,
-  httpErrorCodeLookup: () => httpErrorCodeLookup,
-  interpolate: () => interpolate_default,
-  interpolateObjects: () => interpolateObjects_default,
-  isLeapYear: () => isLeapYear_default,
-  isMonthlyMultiple: () => isMonthlyMultiple_default,
-  isOrdered: () => isOrdered_default,
-  isSameDate: () => isSameDate_default,
-  kebabToCamel: () => kebabToCamel_default,
-  normaliseImportPath: () => normaliseImportPath,
-  normalizeImportPath: () => normalizeImportPath_default,
-  omitProperties: () => omitProperties_default,
-  paralleliseArrays: () => paralleliseArrays_default,
-  parseEmail: () => Email_default,
-  parseEnv: () => Env_default,
-  parseIntStrict: () => parseIntStrict_default,
-  parseUUID: () => UUID_default,
-  parseZodSchema: () => parseZodSchema_default,
-  randomiseArray: () => randomiseArray_default,
-  range: () => range_default,
-  removeDuplicates: () => removeDuplicates_default,
-  removeIndents: () => removeIndents_default,
-  stringListToArray: () => stringListToArray_default,
-  stringToBoolean: () => stringToBoolean_default,
-  stripIndents: () => stripIndents_default,
-  truncate: () => truncate_default,
-  wait: () => wait_default
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/functions/addDaysToDate.ts
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let path = require("path");
+path = __toESM(path);
+let zod = require("zod");
+zod = __toESM(zod);
+
+//#region src/functions/addDaysToDate.ts
 function addDaysToDate(currentDate = /* @__PURE__ */ new Date(), dayIncrement = 1) {
-  const newDate = currentDate;
-  newDate.setDate(newDate.getDate() + dayIncrement);
-  return newDate;
+	const newDate = currentDate;
+	newDate.setDate(newDate.getDate() + dayIncrement);
+	return newDate;
 }
 var addDaysToDate_default = addDaysToDate;
 
-// src/functions/appendSemicolon.ts
+//#endregion
+//#region src/functions/appendSemicolon.ts
 function appendSemicolon(stringToAppendTo) {
-  if (stringToAppendTo.includes("\n")) {
-    throw new Error("MULTIPLE_LINE_ERROR");
-  }
-  const stringWithNoTrailingWhitespace = stringToAppendTo.trimEnd();
-  if (stringWithNoTrailingWhitespace === "") {
-    return "";
-  }
-  return stringWithNoTrailingWhitespace[stringWithNoTrailingWhitespace.length - 1] === ";" ? stringWithNoTrailingWhitespace : `${stringWithNoTrailingWhitespace};`;
+	if (stringToAppendTo.includes("\n")) throw new Error("MULTIPLE_LINE_ERROR");
+	const stringWithNoTrailingWhitespace = stringToAppendTo.trimEnd();
+	if (stringWithNoTrailingWhitespace === "") return "";
+	return stringWithNoTrailingWhitespace[stringWithNoTrailingWhitespace.length - 1] === ";" ? stringWithNoTrailingWhitespace : `${stringWithNoTrailingWhitespace};`;
 }
 var appendSemicolon_default = appendSemicolon;
 
-// src/functions/camelToKebab.ts
+//#endregion
+//#region src/functions/camelToKebab.ts
 function camelToKebab(string) {
-  return string.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").toLowerCase();
+	return string.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").toLowerCase();
 }
 var camelToKebab_default = camelToKebab;
 
-// src/functions/convertFileToBase64.ts
+//#endregion
+//#region src/functions/convertFileToBase64.ts
 function convertFileToBase64(file) {
-  return new Promise((resolve, reject) => {
-    const reader = new FileReader();
-    reader.readAsDataURL(file);
-    reader.onload = () => {
-      if (reader.result === null) {
-        reject(new Error("FILE_CONVERSION_ERROR"));
-        return;
-      }
-      resolve(reader.result);
-    };
-    reader.onerror = () => {
-      reject(new Error("FILE_READER_ERROR"));
-    };
-  });
+	return new Promise((resolve, reject) => {
+		const reader = new FileReader();
+		reader.readAsDataURL(file);
+		reader.onload = () => {
+			if (reader.result === null) {
+				reject(/* @__PURE__ */ new Error("FILE_CONVERSION_ERROR"));
+				return;
+			}
+			resolve(reader.result);
+		};
+		reader.onerror = () => {
+			reject(/* @__PURE__ */ new Error("FILE_READER_ERROR"));
+		};
+	});
 }
 var convertFileToBase64_default = convertFileToBase64;
 
-// src/functions/createFormData.ts
+//#endregion
+//#region src/functions/createFormData.ts
 function getNullableResolutionStrategy(key, strategy) {
-  var _a;
-  return (_a = typeof strategy === "object" ? strategy[key] : strategy) != null ? _a : "empty";
+	return (typeof strategy === "object" ? strategy[key] : strategy) ?? "empty";
 }
 function createFormData(data, options = {
-  arrayResolution: "stringify",
-  nullableResolution: "empty"
+	arrayResolution: "stringify",
+	nullableResolution: "empty"
 }) {
-  const formData = new FormData();
-  function resolveNullablesByStrategy(key, value, resolutionStrategy) {
-    switch (resolutionStrategy) {
-      case "empty":
-        formData.append(String(key), "");
-        break;
-      case "stringify":
-        formData.append(String(key), JSON.stringify(value));
-        break;
-      case "omit":
-        break;
-      default:
-        throw new TypeError("SLOPPY_PURE_JAVASCRIPT_USER_ERROR");
-    }
-  }
-  function resolveNullables(key, value, options2) {
-    if (options2.nullableResolution) {
-      resolveNullablesByStrategy(
-        key,
-        value,
-        getNullableResolutionStrategy(key, options2.nullableResolution)
-      );
-      return;
-    }
-    if (options2.undefinedResolution || options2.nullResolution) {
-      if (data[key] === void 0 && options2.undefinedResolution) {
-        resolveNullablesByStrategy(
-          key,
-          value,
-          getNullableResolutionStrategy(key, options2.undefinedResolution)
-        );
-        return;
-      }
-      if (data[key] === null && options2.nullResolution) {
-        resolveNullablesByStrategy(
-          key,
-          value,
-          getNullableResolutionStrategy(key, options2.nullResolution)
-        );
-      }
-    }
-  }
-  const entries = Object.entries(data);
-  for (const [key, value] of entries) {
-    if (value instanceof Blob) {
-      formData.append(String(key), value);
-    } else if (value === void 0 || value === null) {
-      resolveNullables(key, value, options);
-    } else if (typeof value === "object") {
-      if (Array.isArray(value)) {
-        if (value.some((item) => {
-          return item instanceof Blob;
-        }) && (options.arrayResolution === "stringify" || typeof options.arrayResolution === "object" && options.arrayResolution[key] === "stringify")) {
-          throw new TypeError("CANNOT_STRINGIFY_BLOB");
-        }
-        if (options.arrayResolution === "multiple" || typeof options.arrayResolution === "object" && options.arrayResolution[key] === "multiple") {
-          for (const item of value) {
-            if ((typeof item === "object" || !item) && !(item instanceof Blob)) {
-              throw new TypeError("NON_PRIMITIVE_ARRAY_ITEMS_FOUND");
-            }
-            if (item instanceof Blob) {
-              formData.append(String(key), item);
-            } else {
-              formData.append(String(key), String(item));
-            }
-          }
-          continue;
-        }
-      }
-      formData.append(String(key), JSON.stringify(value));
-    } else {
-      formData.append(String(key), String(value));
-    }
-  }
-  return formData;
+	const formData = new FormData();
+	function resolveNullablesByStrategy(key, value, resolutionStrategy) {
+		switch (resolutionStrategy) {
+			case "empty":
+				formData.append(String(key), "");
+				break;
+			case "stringify":
+				formData.append(String(key), JSON.stringify(value));
+				break;
+			case "omit": break;
+			default: throw new TypeError("SLOPPY_PURE_JAVASCRIPT_USER_ERROR");
+		}
+	}
+	function resolveNullables(key, value, options$1) {
+		if (options$1.nullableResolution) {
+			resolveNullablesByStrategy(key, value, getNullableResolutionStrategy(key, options$1.nullableResolution));
+			return;
+		}
+		if (options$1.undefinedResolution || options$1.nullResolution) {
+			if (data[key] === void 0 && options$1.undefinedResolution) {
+				resolveNullablesByStrategy(key, value, getNullableResolutionStrategy(key, options$1.undefinedResolution));
+				return;
+			}
+			if (data[key] === null && options$1.nullResolution) resolveNullablesByStrategy(key, value, getNullableResolutionStrategy(key, options$1.nullResolution));
+		}
+	}
+	const entries = Object.entries(data);
+	for (const [key, value] of entries) if (value instanceof Blob) formData.append(String(key), value);
+	else if (value === void 0 || value === null) resolveNullables(key, value, options);
+	else if (typeof value === "object") {
+		if (Array.isArray(value)) {
+			if (value.some((item) => {
+				return item instanceof Blob;
+			}) && (options.arrayResolution === "stringify" || typeof options.arrayResolution === "object" && options.arrayResolution[key] === "stringify")) throw new TypeError("CANNOT_STRINGIFY_BLOB");
+			if (options.arrayResolution === "multiple" || typeof options.arrayResolution === "object" && options.arrayResolution[key] === "multiple") {
+				for (const item of value) {
+					if ((typeof item === "object" || !item) && !(item instanceof Blob)) throw new TypeError("NON_PRIMITIVE_ARRAY_ITEMS_FOUND");
+					if (item instanceof Blob) formData.append(String(key), item);
+					else formData.append(String(key), String(item));
+				}
+				continue;
+			}
+		}
+		formData.append(String(key), JSON.stringify(value));
+	} else formData.append(String(key), String(value));
+	return formData;
 }
 var createFormData_default = createFormData;
 
-// src/functions/createTemplateStringsArray.ts
+//#endregion
+//#region src/functions/createTemplateStringsArray.ts
 function createTemplateStringsArray(strings) {
-  return Object.assign([...strings], { raw: [...strings] });
+	return Object.assign([...strings], { raw: [...strings] });
 }
 var createTemplateStringsArray_default = createTemplateStringsArray;
 
-// src/functions/fillArray.ts
+//#endregion
+//#region src/functions/fillArray.ts
 function fillArray(callback, length = 1) {
-  const outputArray = new Array(length).fill(null).map((_, index) => {
-    return callback(index);
-  });
-  const isAsync = outputArray.some((item) => {
-    return item instanceof Promise;
-  });
-  if (isAsync) {
-    return Promise.all(outputArray);
-  }
-  return outputArray;
+	const outputArray = new Array(length).fill(null).map((_, index) => {
+		return callback(index);
+	});
+	if (outputArray.some((item) => {
+		return item instanceof Promise;
+	})) return Promise.all(outputArray);
+	return outputArray;
 }
 var fillArray_default = fillArray;
 
-// src/functions/isSameDate.ts
+//#endregion
+//#region src/functions/isSameDate.ts
 function isSameDate(firstDate, secondDate) {
-  return firstDate.getDate() === secondDate.getDate() && firstDate.getMonth() === secondDate.getMonth() && firstDate.getFullYear() === secondDate.getFullYear();
+	return firstDate.getDate() === secondDate.getDate() && firstDate.getMonth() === secondDate.getMonth() && firstDate.getFullYear() === secondDate.getFullYear();
 }
 var isSameDate_default = isSameDate;
 
-// src/functions/formatDateAndTime.ts
+//#endregion
+//#region src/functions/formatDateAndTime.ts
 function formatDateAndTime(inputDate) {
-  const yesterday = addDaysToDate_default(/* @__PURE__ */ new Date(), -1);
-  const today = /* @__PURE__ */ new Date();
-  const inputTime = `${inputDate.getHours().toString().padStart(2, "0")}:${inputDate.getMinutes().toString().padStart(2, "0")}`;
-  if (isSameDate_default(inputDate, yesterday)) {
-    return `Yesterday at ${inputTime}`;
-  }
-  if (isSameDate_default(inputDate, today)) {
-    return `Today at ${inputTime}`;
-  }
-  const formattedInputDay = inputDate.getDate().toString().padStart(2, "0");
-  const formattedInputMonth = (inputDate.getMonth() + 1).toString().padStart(2, "0");
-  const formattedInputYear = inputDate.getFullYear().toString();
-  return `${formattedInputDay}/${formattedInputMonth}/${formattedInputYear}, ${inputTime}`;
+	const yesterday = addDaysToDate_default(/* @__PURE__ */ new Date(), -1);
+	const today = /* @__PURE__ */ new Date();
+	const inputTime = `${inputDate.getHours().toString().padStart(2, "0")}:${inputDate.getMinutes().toString().padStart(2, "0")}`;
+	if (isSameDate_default(inputDate, yesterday)) return `Yesterday at ${inputTime}`;
+	if (isSameDate_default(inputDate, today)) return `Today at ${inputTime}`;
+	return `${inputDate.getDate().toString().padStart(2, "0")}/${(inputDate.getMonth() + 1).toString().padStart(2, "0")}/${inputDate.getFullYear().toString()}, ${inputTime}`;
 }
 var formatDateAndTime_default = formatDateAndTime;
 
-// src/functions/parseIntStrict.ts
-var IntegerParsingError = new TypeError("INTEGER_PARSING_ERROR");
+//#endregion
+//#region src/functions/parseIntStrict.ts
+const IntegerParsingError = /* @__PURE__ */ new TypeError("INTEGER_PARSING_ERROR");
 function parseIntStrict(...[string, radix]) {
-  const trimmedString = string.trim();
-  const pattern = radix && radix > 10 && radix <= 36 ? (
-    // String.fromCharCode() gets the maximum possible alphabetical character for a base above 10
-    new RegExp(`^[+-]?[0-9a-${String.fromCharCode(87 + radix - 1)}]+$`, "i")
-  ) : /^[+-]?\d+$/;
-  if (!pattern.test(trimmedString)) {
-    throw IntegerParsingError;
-  }
-  if (radix && radix < 10 && [...trimmedString].some((character) => {
-    return parseInt(character) >= radix;
-  })) {
-    throw IntegerParsingError;
-  }
-  const parseIntResult = parseInt(trimmedString, radix);
-  if (isNaN(parseIntResult)) {
-    throw IntegerParsingError;
-  }
-  return parseIntResult;
+	const trimmedString = string.trim();
+	if (!(radix && radix > 10 && radix <= 36 ? new RegExp(`^[+-]?[0-9a-${String.fromCharCode(87 + radix - 1)}]+$`, "i") : /^[+-]?\d+$/).test(trimmedString)) throw IntegerParsingError;
+	if (radix && radix < 10 && [...trimmedString].some((character) => {
+		return parseInt(character) >= radix;
+	})) throw IntegerParsingError;
+	const parseIntResult = parseInt(trimmedString, radix);
+	if (isNaN(parseIntResult)) throw IntegerParsingError;
+	return parseIntResult;
 }
 var parseIntStrict_default = parseIntStrict;
 
-// src/functions/getRandomNumber.ts
+//#endregion
+//#region src/functions/getRandomNumber.ts
 function getRandomNumber(lowerBound, upperBound) {
-  const parsedLowerBound = parseIntStrict_default(`${lowerBound}`);
-  const parsedUpperBound = parseIntStrict_default(`${upperBound}`);
-  return Math.floor(Math.random() * (parsedUpperBound - parsedLowerBound + 1) + parsedLowerBound);
+	const parsedLowerBound = parseIntStrict_default(`${lowerBound}`);
+	const parsedUpperBound = parseIntStrict_default(`${upperBound}`);
+	return Math.floor(Math.random() * (parsedUpperBound - parsedLowerBound + 1) + parsedLowerBound);
 }
 var getRandomNumber_default = getRandomNumber;
 
-// src/functions/getRecordKeys.ts
+//#endregion
+//#region src/functions/getRecordKeys.ts
 function getRecordKeys(record) {
-  return Object.keys(record);
+	return Object.keys(record);
 }
 var getRecordKeys_default = getRecordKeys;
 
-// src/functions/isLeapYear.ts
+//#endregion
+//#region src/functions/isLeapYear.ts
 function isLeapYear(year) {
-  const parsedYear = parseIntStrict_default(`${year}`);
-  return parsedYear % 4 === 0 && parsedYear % 100 !== 0 || parsedYear % 400 === 0;
+	const parsedYear = parseIntStrict_default(`${year}`);
+	return parsedYear % 4 === 0 && parsedYear % 100 !== 0 || parsedYear % 400 === 0;
 }
 var isLeapYear_default = isLeapYear;
 
-// src/functions/isMonthlyMultiple.ts
+//#endregion
+//#region src/functions/isMonthlyMultiple.ts
 function endOfMonthChecksButNotFebruary(firstDate, secondDate) {
-  if ([3, 5, 8, 10].includes(firstDate.getMonth())) {
-    return firstDate.getDate() === 30 && secondDate.getDate() === 31;
-  }
-  return false;
+	if ([
+		3,
+		5,
+		8,
+		10
+	].includes(firstDate.getMonth())) return firstDate.getDate() === 30 && secondDate.getDate() === 31;
+	return false;
 }
 function nonLeapYearFebruaryChecks(firstDate, secondDate) {
-  if (firstDate.getMonth() === 1) {
-    if (!isLeapYear_default(firstDate.getFullYear()) && firstDate.getDate() === 28) {
-      return [28, 29, 30, 31].includes(secondDate.getDate());
-    }
-  }
-  return false;
+	if (firstDate.getMonth() === 1) {
+		if (!isLeapYear_default(firstDate.getFullYear()) && firstDate.getDate() === 28) return [
+			28,
+			29,
+			30,
+			31
+		].includes(secondDate.getDate());
+	}
+	return false;
 }
 function leapYearFebruaryChecks(firstDate, secondDate) {
-  if (firstDate.getMonth() === 1) {
-    if (isLeapYear_default(firstDate.getFullYear()) && firstDate.getDate() === 29) {
-      return [29, 30, 31].includes(secondDate.getDate());
-    }
-  }
-  return false;
+	if (firstDate.getMonth() === 1) {
+		if (isLeapYear_default(firstDate.getFullYear()) && firstDate.getDate() === 29) return [
+			29,
+			30,
+			31
+		].includes(secondDate.getDate());
+	}
+	return false;
 }
 function isMonthlyMultiple(firstDate, secondDate) {
-  if (endOfMonthChecksButNotFebruary(firstDate, secondDate) || endOfMonthChecksButNotFebruary(secondDate, firstDate)) {
-    return true;
-  }
-  if (nonLeapYearFebruaryChecks(firstDate, secondDate) || nonLeapYearFebruaryChecks(secondDate, firstDate)) {
-    return true;
-  }
-  if (leapYearFebruaryChecks(firstDate, secondDate) || leapYearFebruaryChecks(secondDate, firstDate)) {
-    return true;
-  }
-  return firstDate.getDate() === secondDate.getDate();
+	if (endOfMonthChecksButNotFebruary(firstDate, secondDate) || endOfMonthChecksButNotFebruary(secondDate, firstDate)) return true;
+	if (nonLeapYearFebruaryChecks(firstDate, secondDate) || nonLeapYearFebruaryChecks(secondDate, firstDate)) return true;
+	if (leapYearFebruaryChecks(firstDate, secondDate) || leapYearFebruaryChecks(secondDate, firstDate)) return true;
+	return firstDate.getDate() === secondDate.getDate();
 }
 var isMonthlyMultiple_default = isMonthlyMultiple;
 
-// src/functions/isOrdered.ts
+//#endregion
+//#region src/functions/isOrdered.ts
 function isOrdered(array) {
-  const newArray = [...array];
-  newArray.sort();
-  for (const index in newArray) {
-    if (newArray[index] !== array[index]) {
-      return false;
-    }
-  }
-  return true;
+	const newArray = [...array];
+	newArray.sort();
+	for (const index in newArray) if (newArray[index] !== array[index]) return false;
+	return true;
 }
 var isOrdered_default = isOrdered;
 
-// src/functions/kebabToCamel.ts
+//#endregion
+//#region src/functions/kebabToCamel.ts
 function kebabToCamel(string, options) {
-  if (string !== string.toLowerCase()) {
-    throw new Error("INVALID_KEBAB_CASE_INPUT");
-  }
-  if (string.startsWith("-") || string.endsWith("-") || string.includes("--")) {
-    throw new Error("INVALID_KEBAB_CASE_INPUT");
-  }
-  let outputString = "";
-  let skip = false;
-  for (const stringIndex in [...string]) {
-    if (skip) {
-      skip = false;
-      continue;
-    }
-    const index = parseIntStrict_default(stringIndex);
-    if (index === 0 && (options == null ? void 0 : options.startWithUpper)) {
-      outputString += string[index].toUpperCase();
-      continue;
-    }
-    if (index === string.length - 1) {
-      outputString += string[index];
-      break;
-    }
-    if (string[index] === "-" && /^[a-zA-Z]+$/.test(string[index + 1])) {
-      outputString += string[index + 1].toUpperCase();
-      skip = true;
-    } else {
-      outputString += string[index];
-    }
-  }
-  return outputString;
+	if (string !== string.toLowerCase()) throw new Error("INVALID_KEBAB_CASE_INPUT");
+	if (string.startsWith("-") || string.endsWith("-") || string.includes("--")) throw new Error("INVALID_KEBAB_CASE_INPUT");
+	let outputString = "";
+	let skip = false;
+	for (const stringIndex in [...string]) {
+		if (skip) {
+			skip = false;
+			continue;
+		}
+		const index = parseIntStrict_default(stringIndex);
+		if (index === 0 && options?.startWithUpper) {
+			outputString += string[index].toUpperCase();
+			continue;
+		}
+		if (index === string.length - 1) {
+			outputString += string[index];
+			break;
+		}
+		if (string[index] === "-" && /^[a-zA-Z]+$/.test(string[index + 1])) {
+			outputString += string[index + 1].toUpperCase();
+			skip = true;
+		} else outputString += string[index];
+	}
+	return outputString;
 }
 var kebabToCamel_default = kebabToCamel;
 
-// src/functions/normalizeImportPath.ts
-var import_path = __toESM(require("path"), 1);
+//#endregion
+//#region src/functions/normalizeImportPath.ts
 function normalizeImportPath(importPath) {
-  const normalizedPath = import_path.default.posix.normalize(importPath);
-  if (importPath.startsWith("./") && !normalizedPath.startsWith("./")) {
-    return `./${normalizedPath}`;
-  }
-  return normalizedPath;
+	const normalizedPath = path.default.posix.normalize(importPath);
+	if (importPath.startsWith("./") && !normalizedPath.startsWith("./")) return `./${normalizedPath}`;
+	return normalizedPath;
 }
-var normaliseImportPath = normalizeImportPath;
+const normaliseImportPath = normalizeImportPath;
 var normalizeImportPath_default = normalizeImportPath;
 
-// src/functions/omitProperties.ts
+//#endregion
+//#region src/functions/omitProperties.ts
 function omitProperties(object, keysToOmit) {
-  const outputObject = __spreadValues({}, object);
-  const keysArray = Array.isArray(keysToOmit) ? keysToOmit : [keysToOmit];
-  keysArray.forEach((key) => {
-    delete outputObject[key];
-  });
-  return outputObject;
+	const outputObject = { ...object };
+	(Array.isArray(keysToOmit) ? keysToOmit : [keysToOmit]).forEach((key) => {
+		delete outputObject[key];
+	});
+	return outputObject;
 }
 var omitProperties_default = omitProperties;
 
-// src/functions/paralleliseArrays.ts
+//#endregion
+//#region src/functions/paralleliseArrays.ts
 function paralleliseArrays(firstArray, secondArray) {
-  const outputArray = [];
-  for (let i = 0; i < firstArray.length; i++) {
-    outputArray.push([firstArray[i], secondArray[i]]);
-  }
-  return outputArray;
+	const outputArray = [];
+	for (let i = 0; i < firstArray.length; i++) outputArray.push([firstArray[i], secondArray[i]]);
+	return outputArray;
 }
 var paralleliseArrays_default = paralleliseArrays;
 
-// src/types/APIError.ts
-var httpErrorCodeLookup = {
-  400: "BAD_REQUEST",
-  401: "UNAUTHORISED",
-  403: "FORBIDDEN",
-  404: "NOT_FOUND",
-  /* Supporting this one too because it's funny. You'll never use it in practice because 
-                why would an error give a teapot, but it's funny. Do not question me. */
-  418: "I_AM_A_TEAPOT",
-  500: "INTERNAL_SERVER_ERROR"
+//#endregion
+//#region src/types/APIError.ts
+const httpErrorCodeLookup = {
+	400: "BAD_REQUEST",
+	401: "UNAUTHORISED",
+	403: "FORBIDDEN",
+	404: "NOT_FOUND",
+	418: "I_AM_A_TEAPOT",
+	500: "INTERNAL_SERVER_ERROR"
 };
 var APIError = class extends Error {
-  constructor(status = 500, message, options) {
-    var _a;
-    super(message, options);
-    __publicField(this, "status");
-    this.status = status;
-    if (message) {
-      this.message = message;
-    } else {
-      this.message = (_a = httpErrorCodeLookup[this.status]) != null ? _a : "API_ERROR";
-    }
-    Object.defineProperty(this, "message", { enumerable: true });
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-  static check(input) {
-    const data = input;
-    return typeof data === "object" && data !== null && typeof (data == null ? void 0 : data.status) === "number" && typeof (data == null ? void 0 : data.message) === "string";
-  }
+	status;
+	constructor(status = 500, message, options) {
+		super(message, options);
+		this.status = status;
+		if (message) this.message = message;
+		else this.message = httpErrorCodeLookup[this.status] ?? "API_ERROR";
+		Object.defineProperty(this, "message", { enumerable: true });
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+	static check(input) {
+		const data = input;
+		return typeof data === "object" && data !== null && typeof data?.status === "number" && typeof data?.message === "string";
+	}
 };
 var APIError_default = APIError;
 
-// src/types/DataError.ts
+//#endregion
+//#region src/types/DataError.ts
 var DataError = class extends Error {
-  /** @param data - The data that caused the error. */
-  /** @param message - A human-readable error message (e.g. The data provided is invalid). */
-  /** @param code - A standardised code (e.g. UNEXPECTED_DATA). */
-  /** @param options - Extra options to pass to super Error constructor. */
-  constructor(data, message = "The data provided is invalid", code = "INVALID_DATA", options) {
-    super(message, options);
-    __publicField(this, "data");
-    __publicField(this, "code");
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, new.target);
-    }
-    this.name = new.target.name;
-    this.code = code;
-    this.data = data;
-    Object.defineProperty(this, "message", { enumerable: true });
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-  static check(input) {
-    const data = input;
-    return typeof data === "object" && data !== null && typeof data.message === "string" && typeof data.code === "string" && "data" in data;
-  }
+	data;
+	code;
+	/** @param data - The data that caused the error. */
+	/** @param message - A human-readable error message (e.g. The data provided is invalid). */
+	/** @param code - A standardised code (e.g. UNEXPECTED_DATA). */
+	/** @param options - Extra options to pass to super Error constructor. */
+	constructor(data, message = "The data provided is invalid", code = "INVALID_DATA", options) {
+		super(message, options);
+		if (Error.captureStackTrace) Error.captureStackTrace(this, new.target);
+		this.name = new.target.name;
+		this.code = code;
+		this.data = data;
+		Object.defineProperty(this, "message", { enumerable: true });
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+	static check(input) {
+		const data = input;
+		return typeof data === "object" && data !== null && typeof data.message === "string" && typeof data.code === "string" && "data" in data;
+	}
 };
 var DataError_default = DataError;
 
-// src/types/Email.ts
-var import_zod = __toESM(require("zod"), 1);
-var emailSchema = import_zod.default.email().brand();
+//#endregion
+//#region src/types/Email.ts
+const emailSchema = zod.default.email().brand();
 function parseEmail(data) {
-  return emailSchema.parse(data);
+	return emailSchema.parse(data);
 }
 var Email_default = parseEmail;
 
-// src/types/Env.ts
-var import_zod2 = require("zod");
-var envSchema = import_zod2.z.enum(["test", "development", "production"]);
+//#endregion
+//#region src/types/Env.ts
+const envSchema = zod.z.enum([
+	"test",
+	"development",
+	"production"
+]);
 function parseEnv(data = "development") {
-  return envSchema.parse(data);
+	return envSchema.parse(data);
 }
 var Env_default = parseEnv;
 
-// src/types/UUID.ts
-var import_zod3 = __toESM(require("zod"), 1);
-var uuidSchema = import_zod3.default.uuid().brand();
+//#endregion
+//#region src/types/UUID.ts
+const uuidSchema = zod.default.uuid().brand();
 function parseUUID(UUID) {
-  return uuidSchema.parse(UUID);
+	return uuidSchema.parse(UUID);
 }
 var UUID_default = parseUUID;
 
-// src/functions/parseZodSchema.ts
+//#endregion
+//#region src/functions/parseZodSchema.ts
 function parseZodSchema(schema, data) {
-  const parsedResult = schema.safeParse(data);
-  if (!parsedResult.success) {
-    throw new DataError_default(data);
-  }
-  return parsedResult.data;
+	const parsedResult = schema.safeParse(data);
+	if (!parsedResult.success) throw new DataError_default(data);
+	return parsedResult.data;
 }
 var parseZodSchema_default = parseZodSchema;
 
-// src/functions/randomiseArray.ts
+//#endregion
+//#region src/functions/randomiseArray.ts
 function randomiseArray(array) {
-  const mutableArray = [...array];
-  const outputArray = [];
-  do {
-    const indexToRemove = getRandomNumber_default(0, mutableArray.length - 1);
-    outputArray.push(mutableArray.splice(indexToRemove, 1)[0]);
-  } while (mutableArray.length > 0);
-  return outputArray;
+	const mutableArray = [...array];
+	const outputArray = [];
+	do {
+		const indexToRemove = getRandomNumber_default(0, mutableArray.length - 1);
+		outputArray.push(mutableArray.splice(indexToRemove, 1)[0]);
+	} while (mutableArray.length > 0);
+	return outputArray;
 }
 var randomiseArray_default = randomiseArray;
 
-// src/functions/range.ts
+//#endregion
+//#region src/functions/range.ts
 function range(start, stop, step = 1) {
-  const numbers = [];
-  if (step === 0) {
-    throw new Error("ZERO_STEP_SIZE_NOT_ALLOWED");
-  } else if (step > 0) {
-    if (start > stop) {
-      throw new Error("INVALID_BOUNDARIES");
-    }
-    for (let i = start; i < stop; i += step) {
-      numbers.push(i);
-    }
-  } else if (step < 0) {
-    if (start < stop) {
-      throw new Error("INVALID_BOUNDARIES");
-    }
-    for (let i = start; i > stop; i += step) {
-      numbers.push(i);
-    }
-  }
-  return numbers;
+	const numbers = [];
+	if (step === 0) throw new Error("ZERO_STEP_SIZE_NOT_ALLOWED");
+	else if (step > 0) {
+		if (start > stop) throw new Error("INVALID_BOUNDARIES");
+		for (let i = start; i < stop; i += step) numbers.push(i);
+	} else if (step < 0) {
+		if (start < stop) throw new Error("INVALID_BOUNDARIES");
+		for (let i = start; i > stop; i += step) numbers.push(i);
+	}
+	return numbers;
 }
 var range_default = range;
 
-// src/functions/removeDuplicates.ts
+//#endregion
+//#region src/functions/removeDuplicates.ts
 function removeDuplicates(array) {
-  const outputArray = [];
-  for (const item of array) {
-    if (!outputArray.includes(item)) {
-      outputArray.push(item);
-    }
-  }
-  return outputArray;
+	const outputArray = [];
+	for (const item of array) if (!outputArray.includes(item)) outputArray.push(item);
+	return outputArray;
 }
 var removeDuplicates_default = removeDuplicates;
 
-// src/functions/stringListToArray.ts
+//#endregion
+//#region src/functions/stringListToArray.ts
 function stringListToArray(stringList, { separator = ",", trimWhitespace = true } = {}) {
-  if (trimWhitespace && stringList.trim() === "") {
-    return [];
-  }
-  const arrayList = stringList.split(separator != null ? separator : "");
-  return trimWhitespace ? arrayList.map((item) => {
-    return item.trim();
-  }) : arrayList;
+	if (trimWhitespace && stringList.trim() === "") return [];
+	const arrayList = stringList.split(separator ?? "");
+	return trimWhitespace ? arrayList.map((item) => {
+		return item.trim();
+	}) : arrayList;
 }
 var stringListToArray_default = stringListToArray;
 
-// src/functions/stringToBoolean.ts
+//#endregion
+//#region src/functions/stringToBoolean.ts
 function stringToBoolean(inputString) {
-  const normalisedString = inputString.toLowerCase();
-  if (normalisedString !== "true" && normalisedString !== "false") {
-    throw new TypeError("INVALID_BOOLEAN_STRING");
-  }
-  return normalisedString === "true";
+	const normalisedString = inputString.toLowerCase();
+	if (normalisedString !== "true" && normalisedString !== "false") throw new TypeError("INVALID_BOOLEAN_STRING");
+	return normalisedString === "true";
 }
 var stringToBoolean_default = stringToBoolean;
 
-// src/functions/truncate.ts
+//#endregion
+//#region src/functions/truncate.ts
 function truncate(stringToTruncate, maxLength = 5) {
-  return stringToTruncate.length > maxLength ? `${stringToTruncate.slice(0, maxLength)}...` : stringToTruncate;
+	return stringToTruncate.length > maxLength ? `${stringToTruncate.slice(0, maxLength)}...` : stringToTruncate;
 }
 var truncate_default = truncate;
 
-// src/functions/wait.ts
+//#endregion
+//#region src/functions/wait.ts
 function wait(seconds) {
-  return new Promise((resolve, _) => {
-    setTimeout(() => {
-      resolve();
-    }, seconds * 1e3);
-  });
+	return new Promise((resolve, _) => {
+		setTimeout(() => {
+			resolve();
+		}, seconds * 1e3);
+	});
 }
 var wait_default = wait;
 
-// src/functions/taggedTemplate/interpolate.ts
+//#endregion
+//#region src/functions/taggedTemplate/interpolate.ts
 function interpolate(strings, ...interpolations) {
-  let result = "";
-  for (const [string, interpolation = ""] of paralleliseArrays_default(strings, interpolations)) {
-    result += string + interpolation;
-  }
-  return result;
+	let result = "";
+	for (const [string, interpolation = ""] of paralleliseArrays_default(strings, interpolations)) result += string + interpolation;
+	return result;
 }
 var interpolate_default = interpolate;
 
-// src/functions/taggedTemplate/interpolateObjects.ts
+//#endregion
+//#region src/functions/taggedTemplate/interpolateObjects.ts
 function interpolateObjects(strings, ...values) {
-  let result = "";
-  for (let i = 0; i < strings.length; i++) {
-    result += strings[i];
-    if (i !== strings.length - 1) {
-      result += values[i] && typeof values[i] === "object" ? JSON.stringify(values[i]) : values[i];
-    }
-  }
-  return result;
+	let result = "";
+	for (let i = 0; i < strings.length; i++) {
+		result += strings[i];
+		if (i !== strings.length - 1) result += values[i] && typeof values[i] === "object" ? JSON.stringify(values[i]) : values[i];
+	}
+	return result;
 }
 var interpolateObjects_default = interpolateObjects;
 
-// src/functions/taggedTemplate/removeIndents.ts
+//#endregion
+//#region src/functions/taggedTemplate/removeIndents.ts
 function calculateTabSize(line, whitespaceLength) {
-  const potentialWhitespacePart = line.slice(0, whitespaceLength);
-  const trimmedString = line.trimStart();
-  if (potentialWhitespacePart.trim() !== "") {
-    return 0;
-  }
-  const tabSize = line.length - (trimmedString.length + whitespaceLength);
-  return tabSize < 0 ? 0 : tabSize;
+	const potentialWhitespacePart = line.slice(0, whitespaceLength);
+	const trimmedString = line.trimStart();
+	if (potentialWhitespacePart.trim() !== "") return 0;
+	const tabSize = line.length - (trimmedString.length + whitespaceLength);
+	return tabSize < 0 ? 0 : tabSize;
 }
 function getWhitespaceLength(lines) {
-  const [firstNonEmptyLine] = lines.filter((line) => {
-    return line.trim() !== "";
-  });
-  return firstNonEmptyLine.length - firstNonEmptyLine.trimStart().length;
+	const [firstNonEmptyLine] = lines.filter((line) => {
+		return line.trim() !== "";
+	});
+	return firstNonEmptyLine.length - firstNonEmptyLine.trimStart().length;
 }
 function reduceLines(lines, { preserveTabs = true }) {
-  const slicedLines = lines.slice(1);
-  const isFirstLineEmpty = lines[0].trim() === "";
-  const whitespaceLength = getWhitespaceLength(isFirstLineEmpty ? lines : slicedLines);
-  return (isFirstLineEmpty ? slicedLines : lines).map((line) => {
-    const tabSize = calculateTabSize(line, whitespaceLength);
-    return (preserveTabs ? fillArray_default(() => {
-      return " ";
-    }, tabSize).join("") : "") + line.trimStart();
-  }).join("\n");
+	const slicedLines = lines.slice(1);
+	const isFirstLineEmpty = lines[0].trim() === "";
+	const whitespaceLength = getWhitespaceLength(isFirstLineEmpty ? lines : slicedLines);
+	return (isFirstLineEmpty ? slicedLines : lines).map((line) => {
+		const tabSize = calculateTabSize(line, whitespaceLength);
+		return (preserveTabs ? fillArray_default(() => {
+			return " ";
+		}, tabSize).join("") : "") + line.trimStart();
+	}).join("\n");
 }
 function removeIndents(first, ...args) {
-  if (typeof first === "object" && first !== null && !Array.isArray(first)) {
-    const options2 = first;
-    return (strings2, ...interpolations2) => {
-      return removeIndents(strings2, ...interpolations2, options2);
-    };
-  }
-  const strings = first;
-  const options = typeof args[args.length - 1] === "object" && !Array.isArray(args[args.length - 1]) ? args.pop() : {};
-  const interpolations = [...args];
-  const fullString = interpolate_default(strings, ...interpolations);
-  return reduceLines(fullString.split("\n"), options);
+	if (typeof first === "object" && first !== null && !Array.isArray(first)) {
+		const options$1 = first;
+		return (strings$1, ...interpolations) => {
+			return removeIndents(strings$1, ...interpolations, options$1);
+		};
+	}
+	const strings = first;
+	const options = typeof args[args.length - 1] === "object" && !Array.isArray(args[args.length - 1]) ? args.pop() : {};
+	return reduceLines(interpolate_default(strings, ...[...args]).split("\n"), options);
 }
 var removeIndents_default = removeIndents;
 
-// src/functions/taggedTemplate/stripIndents.ts
-function calculateTabSize2(line, whitespaceLength = 12) {
-  const potentialWhitespacePart = line.slice(0, whitespaceLength);
-  const trimmedString = line.trimStart();
-  if (potentialWhitespacePart.trim() !== "") {
-    return 0;
-  }
-  const tabSize = line.length - (trimmedString.length + whitespaceLength);
-  return tabSize < 0 ? 0 : tabSize;
-}
-function reduceLines2(lines, { whitespaceLength = 12, preserveTabs = true }) {
-  return lines.map((line) => {
-    const tabSize = calculateTabSize2(line, whitespaceLength);
-    return (preserveTabs ? fillArray_default(() => {
-      return " ";
-    }, tabSize).join("") : "") + line.trimStart();
-  }).join("\n");
-}
-function stripIndents(first, ...args) {
-  if (typeof first === "object" && first !== null && !Array.isArray(first)) {
-    const options2 = first;
-    return (strings2, ...interpolations2) => {
-      return stripIndents(strings2, ...interpolations2, options2);
-    };
-  }
-  const strings = first;
-  const options = typeof args[args.length - 1] === "object" && !Array.isArray(args[args.length - 1]) ? args.pop() : {};
-  const interpolations = [...args];
-  const fullString = interpolate_default(strings, ...interpolations);
-  return reduceLines2(fullString.split("\n"), options);
-}
-var stripIndents_default = stripIndents;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  APIError,
-  DataError,
-  addDaysToDate,
-  appendSemicolon,
-  camelToKebab,
-  convertFileToBase64,
-  createFormData,
-  createTemplateStringsArray,
-  fillArray,
-  formatDateAndTime,
-  getRandomNumber,
-  getRecordKeys,
-  httpErrorCodeLookup,
-  interpolate,
-  interpolateObjects,
-  isLeapYear,
-  isMonthlyMultiple,
-  isOrdered,
-  isSameDate,
-  kebabToCamel,
-  normaliseImportPath,
-  normalizeImportPath,
-  omitProperties,
-  paralleliseArrays,
-  parseEmail,
-  parseEnv,
-  parseIntStrict,
-  parseUUID,
-  parseZodSchema,
-  randomiseArray,
-  range,
-  removeDuplicates,
-  removeIndents,
-  stringListToArray,
-  stringToBoolean,
-  stripIndents,
-  truncate,
-  wait
-});
+//#endregion
+exports.APIError = APIError_default;
+exports.DataError = DataError_default;
+exports.addDaysToDate = addDaysToDate_default;
+exports.appendSemicolon = appendSemicolon_default;
+exports.camelToKebab = camelToKebab_default;
+exports.convertFileToBase64 = convertFileToBase64_default;
+exports.createFormData = createFormData_default;
+exports.createTemplateStringsArray = createTemplateStringsArray_default;
+exports.fillArray = fillArray_default;
+exports.formatDateAndTime = formatDateAndTime_default;
+exports.getRandomNumber = getRandomNumber_default;
+exports.getRecordKeys = getRecordKeys_default;
+exports.httpErrorCodeLookup = httpErrorCodeLookup;
+exports.interpolate = interpolate_default;
+exports.interpolateObjects = interpolateObjects_default;
+exports.isLeapYear = isLeapYear_default;
+exports.isMonthlyMultiple = isMonthlyMultiple_default;
+exports.isOrdered = isOrdered_default;
+exports.isSameDate = isSameDate_default;
+exports.kebabToCamel = kebabToCamel_default;
+exports.normaliseImportPath = normaliseImportPath;
+exports.normalizeImportPath = normalizeImportPath_default;
+exports.omitProperties = omitProperties_default;
+exports.paralleliseArrays = paralleliseArrays_default;
+exports.parseEmail = Email_default;
+exports.parseEnv = Env_default;
+exports.parseIntStrict = parseIntStrict_default;
+exports.parseUUID = UUID_default;
+exports.parseZodSchema = parseZodSchema_default;
+exports.randomiseArray = randomiseArray_default;
+exports.range = range_default;
+exports.removeDuplicates = removeDuplicates_default;
+exports.removeIndents = removeIndents_default;
+exports.stringListToArray = stringListToArray_default;
+exports.stringToBoolean = stringToBoolean_default;
+exports.truncate = truncate_default;
+exports.wait = wait_default;