@seedcord/utils 0.3.8 → 0.4.0-next.0

package/dist/index.cjs

@@ -1,336 +1,553 @@
-'use strict';
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	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(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
 
-var promises = require('fs/promises');
-var path = require('path');
-var services = require('@seedcord/services');
+//#endregion
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
 
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
+//#region src/misc/assertNever.ts
+/**
+* Exhaustiveness guard for discriminated unions. Place in the `default` branch of a `switch` over a
+* union's discriminant: if a new variant is added without a matching case, the call fails to compile.
+* Throws at runtime if reached with a value the types said was impossible.
+*/
+function assertNever(value) {
+	throw new Error(`Unhandled discriminated union member: ${JSON.stringify(value)}`);
 }
 
-var path__namespace = /*#__PURE__*/_interopNamespace(path);
-
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+//#endregion
+//#region src/misc/directory.ts
+/**
+* Determines if a directory entry is a TypeScript or JavaScript file.
+*
+* @param entry - The directory entry to check.
+* @returns True if the entry is a file ending with .ts or .js.
+*/
 function isTsOrJsFile(entry) {
-  return entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".js")) && !entry.name.endsWith(".d.ts") && !entry.name.endsWith(".map");
+	return entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".js")) && !entry.name.endsWith(".d.ts") && !entry.name.endsWith(".map");
 }
-__name(isTsOrJsFile, "isTsOrJsFile");
+/**
+* Recursively traverses through a directory, importing all .ts and .js files and applying a callback to each import.
+*
+* @param dir - The directory path to traverse.
+* @param callback - A function that will be called for each imported module. It receives the full file path, the file's relative path, and the imported module as arguments.
+* @returns A Promise that resolves when the traversal is complete.
+*/
 async function traverseDirectory(dir, callback, logger) {
-  let entries;
-  try {
-    entries = await promises.readdir(dir, {
-      withFileTypes: true
-    });
-  } catch {
-    logger.error("Failed to read this directory");
-    entries = [];
-  }
-  for (const entry of entries) {
-    const fullPath = path__namespace.join(dir, entry.name);
-    const relativePath = path__namespace.relative(process.cwd(), fullPath);
-    if (entry.isDirectory()) {
-      await traverseDirectory(fullPath, callback, logger);
-    } else if (isTsOrJsFile(entry)) {
-      const imported = await import(fullPath);
-      await callback(fullPath, relativePath, imported);
-    }
-  }
+	let entries;
+	try {
+		entries = await (0, node_fs_promises.readdir)(dir, { withFileTypes: true });
+	} catch (err) {
+		logger.error(`Failed to read directory ${dir}`, err);
+		entries = [];
+	}
+	for (const entry of entries) {
+		const fullPath = node_path.join(dir, entry.name);
+		const relativePath = node_path.relative(process.cwd(), fullPath);
+		if (entry.isDirectory()) await traverseDirectory(fullPath, callback, logger);
+		else if (isTsOrJsFile(entry)) await callback(fullPath, relativePath, await import(fullPath));
+	}
+}
+/**
+* Formats a file path relative to the current working directory.
+* @param filePath - The file path to format.
+* @param options - Formatting options.
+* @returns The formatted file path.
+*/
+function formatFilePath(filePath, options = {}) {
+	const { onlyDir = false, prefix = "./" } = options;
+	return `${prefix}${onlyDir ? node_path.relative(process.cwd(), filePath.replace(/\/[^/]*$/, "")) : node_path.relative(process.cwd(), filePath)}`;
 }
-__name(traverseDirectory, "traverseDirectory");
 
-// src/misc/fyShuffle.ts
+//#endregion
+//#region src/misc/fyShuffle.ts
+/**
+* Shuffles an array using the Fisher-Yates algorithm.
+* This function creates a new array with the same elements in a random order,
+* without modifying the original array.
+*
+* @typeParam TArray - The type of elements in the array
+* @param items - The array to shuffle
+* @returns A new array with the same elements in a random order
+*
+* @example
+* ```typescript
+* const numbers = [1, 2, 3, 4, 5];
+* const shuffled = fyShuffle(numbers);
+* // shuffled might be [3, 1, 5, 2, 4]
+* // numbers is still [1, 2, 3, 4, 5]
+* ```
+*/
 function fyShuffle(items) {
-  const array = items.slice();
-  for (let i = array.length - 1; i > 0; i--) {
-    const j = Math.floor(Math.random() * (i + 1));
-    [array[i], array[j]] = [
-      array[j],
-      array[i]
-    ];
-  }
-  return array;
+	const array = items.slice();
+	for (let i = array.length - 1; i > 0; i--) {
+		const j = Math.floor(Math.random() * (i + 1));
+		[array[i], array[j]] = [array[j], array[i]];
+	}
+	return array;
 }
-__name(fyShuffle, "fyShuffle");
 
-// src/numbers/currentTime.ts
+//#endregion
+//#region src/numbers/currentTime.ts
+/**
+* Return current time in seconds
+*/
 function currentTime() {
-  return Math.floor(Date.now() / 1e3);
+	return Math.floor(Date.now() / 1e3);
 }
-__name(currentTime, "currentTime");
 
-// src/numbers/generateCode.ts
+//#endregion
+//#region src/numbers/generateCode.ts
+/**
+* Generates a random numeric code with the specified number of digits.
+*
+* @param digits - The number of digits for the generated code.
+* @returns A random numeric code with the specified number of digits.
+*/
 function generateCode(digits) {
-  const min = Math.pow(10, digits - 1);
-  const max = Math.pow(10, digits) - 1;
-  return Math.floor(Math.random() * (max - min + 1) + min);
+	const min = Math.pow(10, digits - 1);
+	const max = Math.pow(10, digits) - 1;
+	return Math.floor(Math.random() * (max - min + 1) + min);
 }
-__name(generateCode, "generateCode");
-function hexToNumber(hex) {
-  if (typeof hex !== "string") {
-    throw new services.SeedcordTypeError(services.SeedcordErrorCode.UtilHexInputType);
-  }
-  const normalized = hex.replace(/^#/, "");
-  if (!/^[0-9a-fA-F]+$/.test(normalized)) {
-    throw new services.SeedcordError(services.SeedcordErrorCode.UtilHexInvalid);
-  }
-  const converted = parseInt(normalized, 16);
-  if (Number.isNaN(converted)) {
-    throw new services.SeedcordError(services.SeedcordErrorCode.UtilHexInvalid);
-  }
-  return converted;
-}
-__name(hexToNumber, "hexToNumber");
 
-// src/numbers/ordinal.ts
+//#endregion
+//#region src/numbers/ordinal.ts
+/**
+* Returns the ordinal suffix for a given number.
+*
+* @param n - The number to get the ordinal for
+* @returns The number with its ordinal suffix
+*
+* @example
+* ordinal(1); // "1st"
+* ordinal(22); // "22nd"
+* ordinal(13); // "13th"
+*/
 function ordinal(n) {
-  const s = [
-    "th",
-    "st",
-    "nd",
-    "rd"
-  ];
-  const v = n % 100;
-  const index = (v - 20) % 10;
-  const suffix = s[index] ?? s[v] ?? s[0];
-  if (!suffix) return `${n}th`;
-  return `${n}${suffix}`;
+	const s = [
+		"th",
+		"st",
+		"nd",
+		"rd"
+	];
+	const v = n % 100;
+	const suffix = s[(v - 20) % 10] ?? s[v] ?? s[0];
+	if (!suffix) return `${n}th`;
+	return `${n}${suffix}`;
 }
-__name(ordinal, "ordinal");
 
-// src/numbers/percentage.ts
+//#endregion
+//#region src/numbers/percentage.ts
+/**
+* Takes two numbers and returns the percentage of the first number in the second number with two decimal places.
+*
+* @param num1 - The first number.
+* @param num2 - The second number.
+*
+* @returns The percentage of the first number in the second number with two decimal places.
+*/
 function percentage(num1, num2) {
-  return Number((num1 / num2 * 100).toFixed(2));
+	return Number((num1 / num2 * 100).toFixed(2));
 }
-__name(percentage, "percentage");
 
-// src/numbers/round.ts
+//#endregion
+//#region src/numbers/round.ts
+/**
+* Rounds a number to a specified number of decimal places.
+*
+* @param num - The number to be rounded.
+* @param precision - The number of decimal places to round to.
+* @returns The rounded number.
+*/
 function round(num, precision) {
-  const factor = Math.pow(10, precision);
-  return Math.round((num + Number.EPSILON) * factor) / factor;
+	const factor = Math.pow(10, precision);
+	return Math.round((num + Number.EPSILON) * factor) / factor;
 }
-__name(round, "round");
 
-// src/numbers/roundToDenomination.ts
+//#endregion
+//#region src/numbers/roundToDenomination.ts
+/**
+* Rounds a number to a string representation with a denomination suffix.
+* @param num - The number to round.
+* @example
+* ```ts
+* roundToDenomination(1234); // "1.2K"
+* roundToDenomination(10000, ['k', 'm', 'b', 't', 'q']); // "10k"
+* roundToDenomination(12345678); // "12.3M"
+* ```
+* @returns The rounded number as a string with a denomination suffix.
+*/
 function roundToDenomination(num, opts) {
-  const { suffixes = [
-    "K",
-    "M",
-    "B",
-    "T",
-    "Q"
-  ], precision = 1 } = opts ?? {};
-  if (num < 1e4) {
-    return num.toString();
-  }
-  let index = -1;
-  let temp = num;
-  while (temp >= 1e3 && index < suffixes.length - 1) {
-    temp /= 1e3;
-    index++;
-  }
-  let result;
-  if (temp % 1 === 0) {
-    result = temp.toString();
-  } else {
-    const adjustedTemp = Math.round(temp * Math.pow(10, precision + 1)) / Math.pow(10, precision + 1);
-    result = adjustedTemp.toFixed(precision);
-  }
-  if (result.endsWith(".9")) {
-    result = Math.ceil(Number(result)).toString();
-  }
-  if (result.endsWith(".0")) {
-    result = result.substring(0, result.length - 2);
-  }
-  if (result === "1000") {
-    index += 1;
-    result = "1";
-  }
-  return result + (index >= 0 ? suffixes[index] : "");
+	const { suffixes = [
+		"K",
+		"M",
+		"B",
+		"T",
+		"Q"
+	], precision = 1 } = opts ?? {};
+	if (num < 1e4) return num.toString();
+	let index = -1;
+	let temp = num;
+	while (temp >= 1e3 && index < suffixes.length - 1) {
+		temp /= 1e3;
+		index++;
+	}
+	let result;
+	if (temp % 1 === 0) result = temp.toString();
+	else result = (Math.round(temp * Math.pow(10, precision + 1)) / Math.pow(10, precision + 1)).toFixed(precision);
+	if (result.endsWith(".9")) result = Math.ceil(Number(result)).toString();
+	if (result.endsWith(".0")) result = result.substring(0, result.length - 2);
+	if (result === "1000") {
+		index += 1;
+		result = "1";
+	}
+	return result + (index >= 0 ? suffixes[index] : "");
 }
-__name(roundToDenomination, "roundToDenomination");
 
-// src/objects/filterCirculars.ts
+//#endregion
+//#region src/objects/filterCirculars.ts
+/**
+* Creates a clean, JSON safe copy of a value and replaces circular references with a marker.
+*
+* In `json` mode it behaves like stringify then parse with a replacer that handles cycles and BigInt.
+* In `decycle` mode it first clones without using toJSON, then you can stringify the result later.
+*
+* @typeParam ObjType - Type of the input value.
+* @typeParam Marker - Marker string used for circular references.
+*
+* @param value - The value to clone safely.
+* @param options - Optional configuration.
+*
+* @returns A JSON safe structure with circular references replaced by the marker.
+*
+* @example
+* ```ts
+* interface Test {
+*   name: string;
+*   self?: Test;
+* }
+*
+* const obj: Test = { name: 'seedcord' };
+* obj.self = obj;
+*
+* const clean = filterCirculars(obj);
+* //     ^? { name: string; self?: "[Circular]" | { ... } }
+* console.log(clean.self); // "[Circular]"
+* ```
+*/
 function filterCirculars(value, options) {
-  const logger = options?.logger;
-  const marker = options?.marker ?? "[Circular]";
-  const mode = options?.mode ?? "decycle";
-  if (mode === "json") return json(value, marker, logger);
-  try {
-    return decycle(value, marker);
-  } catch (error) {
-    logger?.error("filterCirculars decycle error", error);
-    return value;
-  }
+	const logger = options?.logger;
+	const marker = options?.marker ?? "[Circular]";
+	if ((options?.mode ?? "decycle") === "json") return json(value, marker, logger);
+	try {
+		return decycle(value, marker);
+	} catch (error) {
+		logger?.error("filterCirculars decycle error", error);
+		return { "[unserializable]": "decycle failed" };
+	}
 }
-__name(filterCirculars, "filterCirculars");
+/**
+* Attempts to build a JSONified object using JSON.stringify and JSON.parse.
+*
+* @internal
+*/
 function json(value, marker, logger) {
-  const seen = /* @__PURE__ */ new WeakSet();
-  let json2;
-  try {
-    json2 = JSON.stringify(value, (_k, v) => {
-      if (typeof v === "bigint") return v.toString();
-      if (typeof v === "object" && v !== null) {
-        const obj = v;
-        if (seen.has(obj)) return marker;
-        seen.add(obj);
-      }
-      return v;
-    });
-  } catch (error) {
-    logger?.error("filterCirculars stringify error", error);
-    if (typeof value === "object" && value !== null) {
-      logger?.error("top level keys", Object.keys(value));
-    }
-    return value;
-  }
-  if (typeof json2 !== "string") {
-    return value;
-  }
-  try {
-    return JSON.parse(json2);
-  } catch (error) {
-    logger?.error("filterCirculars parse error", error);
-    logger?.error("bad JSON", json2);
-    return value;
-  }
+	const seen = /* @__PURE__ */ new WeakSet();
+	let json;
+	try {
+		json = JSON.stringify(value, (_k, v) => {
+			if (typeof v === "bigint") return v.toString();
+			if (typeof v === "object" && v !== null) {
+				const obj = v;
+				if (seen.has(obj)) return marker;
+				seen.add(obj);
+			}
+			return v;
+		});
+	} catch (error) {
+		logger?.error("filterCirculars stringify error", error);
+		if (typeof value === "object" && value !== null) logger?.error("top level keys", Object.keys(value));
+		return { "[unserializable]": "stringify failed" };
+	}
+	if (typeof json !== "string") return { "[unserializable]": "stringify returned undefined" };
+	try {
+		return JSON.parse(json);
+	} catch (error) {
+		logger?.error("filterCirculars parse error", error);
+		logger?.error("bad JSON", json);
+		return { "[unserializable]": "parse failed" };
+	}
 }
-__name(json, "json");
+/**
+* Builds a JSON safe clone without calling toJSON on class instances.
+*
+* @internal
+*/
 function decycle(input, marker, seen = /* @__PURE__ */ new WeakSet()) {
-  const recur = /* @__PURE__ */ __name((val) => {
-    if (val === null) return null;
-    const t = typeof val;
-    if (t === "bigint") return val.toString();
-    if (t !== "object") return val;
-    const obj = val;
-    if (seen.has(obj)) return marker;
-    seen.add(obj);
-    if (obj instanceof Date) return obj.toISOString();
-    if (obj instanceof RegExp) return obj.toString();
-    if (Array.isArray(obj)) {
-      return obj.map((item) => recur(item));
-    }
-    if (obj instanceof Map) {
-      return Array.from(obj, ([k, v]) => [
-        recur(k),
-        recur(v)
-      ]);
-    }
-    if (obj instanceof Set) {
-      return Array.from(obj, (v) => recur(v));
-    }
-    const out = {};
-    for (const [k, v] of Object.entries(obj)) {
-      if (typeof v === "function") continue;
-      out[k] = recur(v);
-    }
-    return out;
-  }, "recur");
-  return recur(input);
+	const recur = (val) => {
+		if (val === null) return null;
+		const t = typeof val;
+		if (t === "bigint") return val.toString();
+		if (t !== "object") return val;
+		const obj = val;
+		if (seen.has(obj)) return marker;
+		seen.add(obj);
+		if (obj instanceof Date) return obj.toISOString();
+		if (obj instanceof RegExp) return obj.toString();
+		if (Array.isArray(obj)) return obj.map((item) => recur(item));
+		if (obj instanceof Map) return Array.from(obj, ([k, v]) => [recur(k), recur(v)]);
+		if (obj instanceof Set) return Array.from(obj, (v) => recur(v));
+		const out = {};
+		for (const [k, v] of Object.entries(obj)) {
+			if (typeof v === "function") continue;
+			out[k] = recur(v);
+		}
+		return out;
+	};
+	return recur(input);
+}
+
+//#endregion
+//#region src/objects/hasKeys.ts
+/**
+* Checks for the presence of nested keys in an object that's possibly a distributed union, narrowing the object type accordingly.
+*
+* Checks if an object has the specified nested keys and that their values are not null or undefined. If they are not, the object type is narrowed to reflect the presence of these keys with their respective types from the original distributed union object.
+*
+* @param obj - The object to check.
+* @param keys - An array of dot-notation paths to check.
+* @returns True if all keys exist and are non-null/defined, narrowing the object type.
+*
+* @example
+* ```ts
+* interface Test {
+*   a?: {
+*     b?: {
+*       c?: string;
+*     };
+*   } | null;
+*   x?: number | null;
+* }
+*
+* const obj: Test = { a: { b: { c: 'hello' } }, x: 42 };
+*
+* if (hasKeys(obj, ['a.b.c', 'x'])) {
+*   // Here, obj is narrowed to:
+*   // {
+*   //   a: { b: { c: string } };
+*   //   x: number;
+*   // }
+*   console.log(obj.a.b.c.toUpperCase()); // Safe to access and use
+*   console.log(obj.x.toFixed(2)); // Safe to access and use
+* }
+* ```
+*/
+function hasKeys(obj, keys) {
+	return keys.every((key) => {
+		const parts = key.split(".");
+		let current = obj;
+		for (const part of parts) {
+			if (current === null || current === void 0 || typeof current !== "object" && typeof current !== "function") return false;
+			if (!(part in current)) return false;
+			current = current[part];
+		}
+		return current !== null && current !== void 0;
+	});
 }
-__name(decycle, "decycle");
 
-// src/objects/keepDefined.ts
+//#endregion
+//#region src/objects/keepDefined.ts
+/**
+* Copies only the keys whose values are defined.
+*
+* @typeParam TObject - the original object type you're pulling from
+* @typeParam TKey - the keys to copy when defined
+* @param source - the object to read values from
+* @param keys - optional list of keys to include when present. If omitted, all keys are considered
+*
+* @example
+* ```ts
+* interface Config {
+*   host?: string;
+*   port?: number;
+*   user?: string;
+*   password?: string;
+* }
+*
+* const config: Config = {
+*   host: 'localhost',
+*   port: undefined,
+*   user: 'admin',
+*   password: undefined
+* };
+*
+* const definedConfig = keepDefined(config, 'host', 'port', 'user', 'password');
+* // Result: { host: 'localhost', user: 'admin' }
+* ```
+*/
 function keepDefined(source, ...keys) {
-  const selectedKeys = keys.length > 0 ? keys : Object.keys(source);
-  const result = {};
-  for (const key of selectedKeys) {
-    const value = source[key];
-    if (value !== void 0 && value !== null) {
-      result[key] = value;
-    }
-  }
-  return result;
+	const selectedKeys = keys.length > 0 ? keys : Object.keys(source);
+	const result = {};
+	for (const key of selectedKeys) {
+		const value = source[key];
+		if (value !== void 0 && value !== null) result[key] = value;
+	}
+	return result;
 }
-__name(keepDefined, "keepDefined");
 
-// src/strings/capitalize.ts
+//#endregion
+//#region src/strings/capitalize.ts
+/**
+* Returns the word with its first letter capitalized and the rest in lowercase.
+* @param word - The word to be formatted.
+* @returns The formatted word.
+*/
 function capitalize(word) {
-  return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+	return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
 }
-__name(capitalize, "capitalize");
 
-// src/strings/longestStringLength.ts
+//#endregion
+//#region src/strings/longestStringLength.ts
+/**
+* Function takes an array of strings or numbers and returns the number of characters in the longest string/number
+*
+* @param arr - The array of strings or numbers
+* @returns The length of the longest element when converted to string
+*/
 function longestStringLength(arr) {
-  return Math.max(...arr.map((el) => el.toString().length));
+	return Math.max(...arr.map((el) => el.toString().length));
 }
-__name(longestStringLength, "longestStringLength");
 
-// src/strings/generateAsciiTable.ts
+//#endregion
+//#region src/strings/generateAsciiTable.ts
+/**
+* Generates an ASCII table from the provided data.
+*
+* @param data - The data to be displayed in the table.
+* @returns The generated ASCII table as a string.
+*/
 function generateAsciiTable(data) {
-  if (data.length === 0) return "";
-  const firstRow = data[0];
-  if (!firstRow || firstRow.length === 0) return "";
-  let table = "";
-  const columnWidths = [];
-  for (let i = 0; i < firstRow.length; i++) {
-    let maxWidth = 0;
-    for (const row of data) {
-      const cell = row[i];
-      if (cell !== void 0) maxWidth = Math.max(maxWidth, cell.length);
-    }
-    columnWidths.push(maxWidth);
-  }
-  const createLine = /* @__PURE__ */ __name((char, left, intersect, right) => {
-    let line = left;
-    columnWidths.forEach((width, index) => {
-      line += char.repeat(width + 2);
-      if (index < columnWidths.length - 1) line += intersect;
-      else line += right;
-    });
-    line += "\n";
-    return line;
-  }, "createLine");
-  table += createLine("\u2550", "\u2554", "\u2566", "\u2557");
-  data.forEach((row, rowIndex) => {
-    table += "\u2551";
-    row.forEach((cell, columnIndex) => {
-      const columnWidth = columnWidths[columnIndex];
-      if (columnWidth !== void 0) table += ` ${cell.padEnd(columnWidth)} \u2551`;
-    });
-    table += "\n";
-    if (rowIndex < data.length - 1) table += createLine("\u2500", "\u2560", "\u256C", "\u2563");
-    else table += createLine("\u2550", "\u255A", "\u2569", "\u255D");
-  });
-  return table;
+	if (data.length === 0) return "";
+	const firstRow = data[0];
+	if (!firstRow || firstRow.length === 0) return "";
+	let table = "";
+	const columnWidths = [];
+	for (let i = 0; i < firstRow.length; i++) {
+		let maxWidth = 0;
+		for (const row of data) {
+			const cell = row[i];
+			if (cell !== void 0) maxWidth = Math.max(maxWidth, cell.length);
+		}
+		columnWidths.push(maxWidth);
+	}
+	const createLine = (char, left, intersect, right) => {
+		let line = left;
+		columnWidths.forEach((width, index) => {
+			line += char.repeat(width + 2);
+			if (index < columnWidths.length - 1) line += intersect;
+			else line += right;
+		});
+		line += "\n";
+		return line;
+	};
+	table += createLine("═", "╔", "╦", "╗");
+	data.forEach((row, rowIndex) => {
+		table += "║";
+		row.forEach((cell, columnIndex) => {
+			const columnWidth = columnWidths[columnIndex];
+			if (columnWidth !== void 0) table += ` ${cell.padEnd(columnWidth)} ║`;
+		});
+		table += "\n";
+		if (rowIndex < data.length - 1) table += createLine("─", "╠", "╬", "╣");
+		else table += createLine("═", "╚", "╩", "╝");
+	});
+	return table;
 }
-__name(generateAsciiTable, "generateAsciiTable");
 
-// src/strings/prettify.ts
+//#endregion
+//#region src/strings/prettify.ts
+/**
+* Converts a string from any common naming convention to human-readable format.
+* Accepts camelCase, PascalCase, snake_case, and kebab-case input.
+*
+* @param key - The string to convert
+* @param opts - Optional configuration
+* @returns A space-separated, human-readable string
+*
+* @example
+* prettify("camelCaseString") // "camel Case String"
+* prettify("PascalCaseString") // "Pascal Case String"
+* prettify("snake_case_string") // "snake case string"
+* prettify("kebab-case-string") // "kebab case string"
+* prettify("mixedCase_string-name") // "mixed Case string name"
+*/
 function prettify(key, opts) {
-  const result = key.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[_-]/g, " ").trim();
-  if (opts?.capitalize) return capitalize(result);
-  return result;
+	const result = key.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[_-]/g, " ").trim();
+	if (opts?.capitalize) return capitalize(result);
+	return result;
 }
-__name(prettify, "prettify");
 
-// src/strings/prettyDifference.ts
+//#endregion
+//#region src/strings/prettyDifference.ts
+/**
+* Calculates the difference between two numbers and formats it as a string with a '+' prefix for positive differences.
+*
+* @param numBefore - The initial number value
+* @param numAfter - The final number value
+* @returns A string representing the difference, with a '+' sign for positive differences
+*
+* @example
+* // Returns "+5"
+* prettyDifference(10, 15);
+*
+* @example
+* // Returns "-3"
+* prettyDifference(10, 7);
+*/
 function prettyDifference(numBefore, numAfter) {
-  return (numAfter - numBefore > 0 ? `+${numAfter - numBefore}` : numAfter - numBefore).toString();
+	return (numAfter - numBefore > 0 ? `+${numAfter - numBefore}` : numAfter - numBefore).toString();
 }
-__name(prettyDifference, "prettyDifference");
 
+//#endregion
+//#region src/index.ts
+/** Package version */
+const version = "0.4.0-next.0";
+
+//#endregion
+exports.assertNever = assertNever;
 exports.capitalize = capitalize;
 exports.currentTime = currentTime;
 exports.filterCirculars = filterCirculars;
+exports.formatFilePath = formatFilePath;
 exports.fyShuffle = fyShuffle;
 exports.generateAsciiTable = generateAsciiTable;
 exports.generateCode = generateCode;
-exports.hexToNumber = hexToNumber;
+exports.hasKeys = hasKeys;
 exports.isTsOrJsFile = isTsOrJsFile;
 exports.keepDefined = keepDefined;
 exports.longestStringLength = longestStringLength;
@@ -341,5 +558,5 @@ exports.prettyDifference = prettyDifference;
 exports.round = round;
 exports.roundToDenomination = roundToDenomination;
 exports.traverseDirectory = traverseDirectory;
-//# sourceMappingURL=index.cjs.map
+exports.version = version;
 //# sourceMappingURL=index.cjs.map