@postxl/utils 1.0.1 → 1.1.0

package/dist/zod-excel.decoders-BJliEI1Y.js

@@ -0,0 +1,1426 @@
+import z$1, { z } from "zod";
+
+//#region src/DefaultMap.ts
+/**
+* A map extension that returns a default value if the key is not found.
+*/
+var DefaultMap = class extends Map {
+	/**
+	* A function that returns the default value for the map.
+	*/
+	constructor(_default) {
+		super();
+		this._default = _default;
+	}
+	get(key) {
+		const value = super.get(key);
+		if (value) return value;
+		const defaultValue = this._default();
+		this.set(key, defaultValue);
+		return defaultValue;
+	}
+};
+
+//#endregion
+//#region src/NestedMap.ts
+var NestedMap = class {
+	_map = new Map();
+	constructor(getKey1, getKey2, items = []) {
+		this.getKey1 = getKey1;
+		this.getKey2 = getKey2;
+		for (const item of items) this.set(item);
+	}
+	get(key1, key2) {
+		const map = this._map.get(key1);
+		if (!map) return void 0;
+		return map.get(key2);
+	}
+	getKeys(item) {
+		return [this.getKey1(item), this.getKey2(item)];
+	}
+	set(item) {
+		const [key1, key2] = this.getKeys(item);
+		let map = this._map.get(key1);
+		if (!map) {
+			map = new Map();
+			this._map.set(key1, map);
+		}
+		map.set(key2, item);
+	}
+	delete(item) {
+		const [key1, key2] = this.getKeys(item);
+		const map = this._map.get(key1);
+		if (!map) return;
+		map.delete(key2);
+	}
+	clear() {
+		this._map.clear();
+	}
+	get size() {
+		return Array.from(this._map.values()).reduce((sum, map) => sum + map.size, 0);
+	}
+	get keys() {
+		return this._map.keys();
+	}
+	get values() {
+		const values = [];
+		for (const map of this._map.values()) for (const value of map.values()) values.push(value);
+		return values;
+	}
+	get entries() {
+		const entries = [];
+		for (const [key1, map] of this._map.entries()) for (const [key2, value] of map.entries()) entries.push([
+			key1,
+			key2,
+			value
+		]);
+		return entries;
+	}
+	get [Symbol.iterator]() {
+		return this.entries;
+	}
+};
+
+//#endregion
+//#region src/TypedMapping.ts
+/**
+* A map of typed mappings.
+*/
+var TypedMapping = class {
+	constructor(mappings = {}) {
+		this.mappings = mappings;
+	}
+	/**
+	* Creates a new mapping from the original id to the new id.
+	*/
+	set({ model, id }, newId) {
+		if (!this.mappings[model]) this.mappings[model] = new Map();
+		this.mappings[model].set(id, newId);
+		return this;
+	}
+	/**
+	* Returns the id if there exists a mapping, otherwise returns the original id.
+	*/
+	get({ model, id }) {
+		const mapping = this.mappings[model]?.get(id);
+		if (!mapping) return id;
+		return mapping;
+	}
+};
+
+//#endregion
+//#region src/array.ts
+/**
+* Adds a value to a sorted array and keeps the array sorted.
+*
+* O(n)
+*/
+function addAndSort(arr, value, predicate) {
+	arr.push(value);
+	let i = arr.length - 1;
+	const item = arr[i];
+	const order = predicate(item);
+	while (i > 0 && order < predicate(arr[i - 1])) {
+		arr[i] = arr[i - 1];
+		i -= 1;
+	}
+	arr[i] = item;
+	return arr;
+}
+
+//#endregion
+//#region src/async.ts
+const defaultConcurrency = 5;
+async function mapLimit(arr, iterator, limit = defaultConcurrency) {
+	const result = [];
+	if (arr.length === 0) return result;
+	const generator = arrayGenerator(arr);
+	limit = Math.min(limit, arr.length);
+	const workers = new Array(limit);
+	for (let i = 0; i < limit; i++) workers.push(worker(i, generator, iterator, result));
+	await Promise.all(workers);
+	return result;
+}
+function* arrayGenerator(array) {
+	for (let index = 0; index < array.length; index++) {
+		const currentValue = array[index];
+		yield [currentValue, index];
+	}
+}
+async function worker(id, gen, mapFn, result) {
+	for (const [currentValue, index] of gen) {
+		result[index] = void 0;
+		if (currentValue === void 0) return;
+		try {
+			result[index] = await mapFn(currentValue, index);
+		} catch (e) {
+			console.error(`Worker ${id} --- index ${index} item ${JSON.stringify(currentValue)} failed`, e);
+		}
+	}
+}
+
+//#endregion
+//#region src/buffer.ts
+/**
+* Compares two string or buffer values for equality.
+*/
+function equals(a, b) {
+	if (typeof a === "string" && typeof b === "string") return a === b;
+	if (Buffer.isBuffer(a) && Buffer.isBuffer(b)) return a.equals(b);
+	return false;
+}
+
+//#endregion
+//#region src/datetime.ts
+/**
+* returns the default time stamp in format YYMMDD HHMM
+*/
+function timeStamp() {
+	const date = new Date();
+	const year = date.getFullYear().toString().slice(-2);
+	const month = (date.getMonth() + 1).toString().padStart(2, "0");
+	const day = date.getDate().toString().padStart(2, "0");
+	const hour = date.getHours().toString().padStart(2, "0");
+	const minute = date.getMinutes().toString().padStart(2, "0");
+	return `${year}${month}${day} ${hour}${minute}`;
+}
+/**
+* Checks if a value is a valid Date object.
+* Returns true only for Date instances that are not Invalid Date.
+* This function is isomorphic and works in both Node.js and browser environments.
+*
+* @param value - The value to check
+* @returns true if the value is a valid Date object, false otherwise
+*
+* @example
+* isDate(new Date()) // true
+* isDate(new Date('2023-01-01')) // true
+* isDate(new Date('invalid')) // false (Invalid Date)
+* isDate('2023-01-01') // false
+* isDate(1234567890) // false
+* isDate(null) // false
+* isDate(undefined) // false
+*/
+function isDate(value) {
+	return value instanceof Date && !Number.isNaN(value.getTime());
+}
+
+//#endregion
+//#region src/dictionary.ts
+function toDict(data, keyFn) {
+	const result = {};
+	for (const item of data) result[keyFn(item)] = item;
+	return result;
+}
+function idToDict(data) {
+	const result = {};
+	for (const item of data) result[item.id.toString()] = item;
+	return result;
+}
+function mapDict(dict, predicate) {
+	const result = {};
+	for (const [key, value] of Object.entries(dict)) result[key] = predicate(value);
+	return result;
+}
+function filterDict(dict, predicate) {
+	const result = {};
+	for (const [key, value] of Object.entries(dict)) if (predicate(value)) result[key] = value;
+	return result;
+}
+function dictGetAndAssert(dict, key) {
+	const value = dict[key];
+	if (value === null || value === void 0) throw new Error(`Key ${key} not found`);
+	return value;
+}
+
+//#endregion
+//#region src/format.ts
+function format(n, locale = "en-US") {
+	return new Intl.NumberFormat(locale).format(n);
+}
+
+//#endregion
+//#region src/group-by.ts
+const groupBy = (predicate, items) => {
+	const result = {};
+	for (const item of items) {
+		const key = predicate(item);
+		const group = result[key];
+		if (group === void 0) result[key] = [item];
+		else group.push(item);
+	}
+	return result;
+};
+const groupByCurried = (predicate) => {
+	const result = {};
+	return (items) => {
+		for (const item of items) {
+			const key = predicate(item);
+			const group = result[key];
+			if (group === void 0) result[key] = [item];
+			else group.push(item);
+		}
+		return result;
+	};
+};
+const groupByToDict = (predicate, items) => {
+	const result = {};
+	for (const item of items) {
+		const key = predicate(item);
+		const group = result[key];
+		if (group === void 0) result[key] = { [item.id]: item };
+		else group[item.id] = item;
+	}
+	return result;
+};
+const groupByToMap = (getGroupId, items) => {
+	const result = new Map();
+	for (const item of items) {
+		const groupId = getGroupId(item);
+		if (!result.has(groupId)) result.set(groupId, new Map());
+		const group = result.get(groupId);
+		if (group !== void 0) group.set(item.id, item);
+	}
+	return result;
+};
+
+//#endregion
+//#region src/map.ts
+function mapMap(map, predicate) {
+	const result = new Map();
+	for (const [key, value] of map.entries()) result.set(key, predicate(value, key));
+	return result;
+}
+function mapMapValues(map, predicate) {
+	const result = [];
+	for (const [key, value] of map.entries()) result.push(predicate(value, key));
+	return result;
+}
+/**
+*
+*/
+function mapMapKeyValues(map, keyPredicate, valuePredicate) {
+	const result = new Map();
+	for (const [key, value] of map.entries()) result.set(keyPredicate(key, value), valuePredicate(value, key));
+	return result;
+}
+/**
+* Maps keys of a map.
+*/
+function mapMapKeys(map, keyPredicate) {
+	const result = new Map();
+	for (const [key, value] of map.entries()) result.set(keyPredicate(key, value), value);
+	return result;
+}
+/**
+* Filters values from a map.
+*/
+function filterMap(map, predicate) {
+	const result = new Map();
+	for (const [key, value] of map.entries()) if (predicate(value, key)) result.set(key, value);
+	return result;
+}
+/**
+* Gets a value from a map and asserts that it exists.
+*/
+function mapGetAndAssert(map, key) {
+	const value = map.get(key);
+	if (!value) throw new Error(`Key ${JSON.stringify(key)} not found`);
+	return value;
+}
+/**
+* Converts a map to a dictionary.
+*/
+function mapToDict(map) {
+	const result = {};
+	for (const [key, value] of map.entries()) result[key] = value;
+	return result;
+}
+
+//#endregion
+//#region src/omit.ts
+/**
+* Omits a key from an object
+*/
+function omit(obj, key) {
+	const { [key]: _,...rest } = obj;
+	return rest;
+}
+
+//#endregion
+//#region src/pagination.ts
+const slice = (items, skip, take) => {
+	const start = skip ?? 0;
+	const end = take ? start + take : void 0;
+	return {
+		total: items.length,
+		offset: start,
+		items: items.slice(start, end)
+	};
+};
+
+//#endregion
+//#region src/random.ts
+/**
+* Returns a random integer between 0 (inclusive) and max (exclusive).
+*
+* Isomorphic implementation for Node.js, Deno, Bun, and browser environments.
+* Uses Web Crypto API which is available in all modern JavaScript runtimes.
+*/
+function randomInt(max) {
+	if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") return browserRandomInt(max);
+	throw new Error("No suitable random number generator available");
+}
+function browserRandomInt(max) {
+	const randomMax = 4294967296;
+	const range = randomMax - randomMax % max;
+	let value;
+	do {
+		const array = new Uint32Array(1);
+		crypto.getRandomValues(array);
+		value = array[0];
+	} while (value >= range);
+	return value % max;
+}
+const CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+/**
+* Returns a randomly generated alphanumeric string.
+*/
+function generateRandomAlphanumericString(length) {
+	let result = "";
+	for (let i = 0; i < length; i++) result += CHARS[randomInt(CHARS.length)];
+	return result;
+}
+
+//#endregion
+//#region src/is-object.ts
+/**
+* Only returns true for plain objects, not for classes or functions
+*/
+function isPlainObject(value) {
+	return value !== null && typeof value === "object" && value.constructor === Object;
+}
+
+//#endregion
+//#region src/remove-secrets.ts
+/**
+* Removes secrets from the given configuration object.
+*
+* Recursively checks all properties of the object for keys that end with
+* `key`, `secret`, `password`, `token` and replaces them with '***'.
+*
+* Also checks for keys the end with `connection` or `connectionString` and
+* replaces the connection string with the same string but with the password
+* replaced with '***'.
+*/
+function removeSecrets(config) {
+	const newConfig = {};
+	for (const [key, value] of Object.entries(config)) newConfig[key] = processValue(key, value);
+	return newConfig;
+}
+function processValue(key, value) {
+	if (typeof value === "string") return processString(key, value);
+	else if (Array.isArray(value)) return value.map((item) => removeSecrets(item));
+	else if (typeof value === "object" && isPlainObject(value)) return removeSecrets(value);
+	return value;
+}
+function processString(key, value) {
+	if (key.endsWith("key") || key.endsWith("secret") || key.endsWith("password") || key.endsWith("token")) return hidePassword(value);
+	else if (key.endsWith("connection") || key.endsWith("connectionString")) return hidePasswordInConnectionString(value);
+	else return value;
+}
+function hidePasswordInConnectionString(connection) {
+	return connection.replace(/^(.*):\/\/(.*):(.*)@(.*)$/, "$1://$2:***@$4").replace(/^(.*):(.*)@(.*)$/, "$1:***@$3");
+}
+function hidePassword(password) {
+	if (password === "") return "nothing provided!";
+	if (password === "secret") return "default provided!";
+	return "***";
+}
+
+//#endregion
+//#region src/remove-undefined.ts
+/**
+* Removes all undefined properties from an object.
+*
+* NOTE: This is useful when using the `Partial<T>` type modifier in combination with the spread operator to prevent
+*       overriding with undefined values.
+*/
+function removeUndefinedProperties(obj) {
+	const newObj = {};
+	for (const key in obj) {
+		const value = obj[key];
+		if (value !== void 0) newObj[key] = value;
+	}
+	return newObj;
+}
+
+//#endregion
+//#region src/result.ts
+var Result = class Result {
+	static ok(value) {
+		return new Result("ok", value);
+	}
+	static err(value) {
+		return new Result("err", value);
+	}
+	static fromThrowable(f, handleError) {
+		try {
+			return Result.ok(f());
+		} catch (error) {
+			return Result.err(handleError(error));
+		}
+	}
+	static fromObject(result) {
+		if (result.tag === "ok") return Result.ok(result.value);
+		else return Result.err(result.err);
+	}
+	static async fromPromise(promise, handleError) {
+		try {
+			return Result.ok(await promise());
+		} catch (error) {
+			return Result.err(handleError(error));
+		}
+	}
+	#tag;
+	#value;
+	#error;
+	constructor(tag, value) {
+		this.#tag = tag;
+		this.#value = tag === "ok" ? value : null;
+		this.#error = tag === "err" ? value : null;
+	}
+	isOk() {
+		return this.#tag === "ok";
+	}
+	isErr() {
+		return this.#tag === "err";
+	}
+	map(f) {
+		if (this.#tag === "ok") return Result.ok(f(this.#value));
+		else return this;
+	}
+	mapErr(f) {
+		if (this.#tag === "err") return Result.err(f(this.#error));
+		else return this;
+	}
+	andThen(f) {
+		if (this.#tag === "ok") return f(this.#value);
+		else return this;
+	}
+	withDefault(fallback) {
+		return this.#tag === "ok" ? this.#value : fallback;
+	}
+	unwrap() {
+		if (this.#tag === "ok") return this.#value;
+		else throw new Error(typeof this.#error === "string" ? this.#error : JSON.stringify(this.#error));
+	}
+	unwrapErr() {
+		if (this.#tag === "err") return this.#error;
+		else throw new Error("tried to unwrap an ok result");
+	}
+	toJSON() {
+		if (this.#tag === "ok") return {
+			tag: "ok",
+			value: this.#value
+		};
+		else return {
+			tag: "err",
+			err: this.#error
+		};
+	}
+};
+const ok = Result.ok;
+const err = Result.err;
+
+//#endregion
+//#region src/sort.ts
+const sort = (items, dir = "asc", compareFn = compareValues) => setDirection(items.toSorted(compareFn), dir);
+/**
+* Compare fields of an object.
+*/
+const compareFields = (key) => {
+	return (a, b) => compareValues(a[key], b[key]);
+};
+const compare = (getter) => {
+	return (a, b) => compareValues(getter(a), getter(b));
+};
+const keyGetter = (key) => {
+	return (data) => data[key];
+};
+const compareValues = (a, b) => {
+	switch (true) {
+		case (a === void 0 || a === null) && b !== void 0 && b !== null: return 1;
+		case (b === void 0 || b === null) && a !== void 0 && a !== null: return -1;
+		case (a === void 0 || a === null) && (b === void 0 || b === null): return 0;
+		case a instanceof Date && b instanceof Date: return compareDates(a, b);
+		case typeof a === "string" && typeof b === "string": return compareStrings(a, b);
+		case typeof a === "number" && typeof b === "number": return compareNumbers(a, b);
+		case typeof a === "boolean" && typeof b === "boolean": return compareBooleans(a, b);
+		default: return 0;
+	}
+};
+const compareDates = (a, b) => compareStrings(a.toISOString(), b.toISOString());
+const compareStrings = (a, b) => {
+	const aLower = a.trim().toLowerCase();
+	const bLower = b.trim().toLowerCase();
+	if (aLower === bLower) return 0;
+	return aLower > bLower ? 1 : -1;
+};
+const compareNumbers = (a, b) => a - b;
+const compareBooleans = (a, b) => booleanCode(a) - booleanCode(b);
+const booleanCode = (bool) => bool ? 1 : 0;
+const setDirection = (items, dir) => {
+	return dir === "desc" ? items.toReversed() : items;
+};
+
+//#endregion
+//#region src/string-colors.ts
+/**
+* Colors a string in red color (using ANSI escape codes).
+*/
+function red(input) {
+	return `\u001b[31m${input}\u001b[39m`;
+}
+/**
+* Colors a string in green color (using ANSI escape codes).
+*/
+function green(input) {
+	return `\u001b[32m${input}\u001b[39m`;
+}
+/**
+* Colors a string in yellow color (using ANSI escape codes).
+*/
+function yellow(input) {
+	return `\u001b[33m${input}\u001b[39m`;
+}
+/**
+* Colors a string in blue color (using ANSI escape codes).
+*/
+function blue(input) {
+	return `\u001b[34m${input}\u001b[39m`;
+}
+/**
+* Colors a string in cyan color (using ANSI escape codes).
+*/
+function cyan(input) {
+	return `\u001b[36m${input}\u001b[39m`;
+}
+/**
+* Colors a string in gray color (using ANSI escape codes).
+*/
+function gray(input) {
+	return `\u001b[90m${input}\u001b[39m`;
+}
+/**
+* Colors a string in bold color (using ANSI escape codes).
+*/
+function bold(input) {
+	return `\u001b[1m${input}\u001b[22m`;
+}
+/**
+* Colors a string in underline color (using ANSI escape codes).
+*/
+function underline(input) {
+	return `\u001b[4m${input}\u001b[24m`;
+}
+/**
+* Colors a string in italic color (using ANSI escape codes).
+*/
+function italic(input) {
+	return `\u001b[3m${input}\u001b[23m`;
+}
+/**
+* Inverts the color of a string (using ANSI escape codes).
+*/
+function inverse(input) {
+	return `\u001b[7m${input}\u001b[27m`;
+}
+
+//#endregion
+//#region src/string.ts
+function upperFirst(s) {
+	return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function lowerFirst(s) {
+	return s.charAt(0).toLowerCase() + s.slice(1);
+}
+const IRREGULAR_PLURALS = Object.entries({
+	abyss: "abysses",
+	aegis: "aegises",
+	alias: "aliases",
+	alumnus: "alumni",
+	amends: "amends",
+	analysis: "analyses",
+	apparatus: "apparatuses",
+	appendix: "appendices",
+	asbestos: "asbestoses",
+	atlas: "atlases",
+	axis: "axes",
+	basis: "bases",
+	biceps: "bicepses",
+	bus: "buses",
+	caress: "caresses",
+	child: "children",
+	children: "children",
+	circus: "circuses",
+	citrus: "citruses",
+	compass: "compasses",
+	crisis: "crises",
+	criterion: "criteria",
+	crocus: "crocuses",
+	data: "data",
+	datum: "data",
+	diabetes: "diabetes",
+	diagnosis: "diagnoses",
+	dross: "drosses",
+	egress: "egresses",
+	elvis: "elvises",
+	emboss: "embosses",
+	fiss: "fisses",
+	focus: "foci",
+	glass: "glasses",
+	hippocampus: "hippocampi",
+	history: "history",
+	hypothesis: "hypotheses",
+	ignis: "ignises",
+	index: "indices",
+	iris: "irises",
+	jesus: "jesuses",
+	kudos: "kudos",
+	lens: "lenses",
+	man: "men",
+	matrix: "matrices",
+	medium: "media",
+	news: "news",
+	oasis: "oases",
+	parenthesis: "parentheses",
+	pass: "passes",
+	phenomenon: "phenomena",
+	prognosis: "prognoses",
+	radius: "radii",
+	ras: "rasses",
+	sepsis: "sepses",
+	species: "species",
+	status: "statuses",
+	suffix: "suffixes",
+	syllabus: "syllabi",
+	synopsis: "synopses",
+	thesis: "theses",
+	tress: "tresses",
+	virus: "viruses",
+	vortex: "vortices",
+	woman: "women"
+});
+/**
+* Returns a pluralized version of the given string based on the count.
+*/
+function pluralize(s, count = 2) {
+	if (count === 1) return s;
+	const lower = s.toLowerCase();
+	for (const [singular, plural] of IRREGULAR_PLURALS) if (lower.endsWith(singular)) return s.slice(0, -singular.length + 1) + plural.slice(1);
+	if (lower.endsWith("ss")) return s.slice(0, -2) + "sses";
+	if (lower.endsWith("x") || lower.endsWith("z") || lower.endsWith("sh") || lower.endsWith("ch")) return s + "es";
+	if (s.endsWith("y") && !s.endsWith("ay") && !s.endsWith("ey") && !s.endsWith("iy") && !s.endsWith("oy") && !s.endsWith("uy")) return s.slice(0, -1) + "ies";
+	if (s.endsWith("s")) return s;
+	return s + "s";
+}
+/**
+* Returns true if the given string is already pluralized.
+*/
+function isPlural(s) {
+	const plural = pluralize(s);
+	return plural === s;
+}
+/**
+* Converts all keys of an object to capitalized versions in a type-safe way.
+*/
+function capitalizeKeys(obj) {
+	const result = {};
+	for (const key in obj) {
+		const cKey = `${key.charAt(0).toUpperCase()}${key.slice(1)}`;
+		const cVal = obj[key];
+		result[cKey] = cVal;
+	}
+	return result;
+}
+/**
+* Converts all keys of an object to uncapitalized versions in a type-safe way.
+*/
+function uncapitalizeKeys(obj) {
+	const result = {};
+	for (const key in obj) {
+		const unKey = `${key.charAt(0).toLowerCase()}${key.slice(1)}`;
+		const unVal = obj[key];
+		result[unKey] = unVal;
+	}
+	return result;
+}
+/**
+* Returns the same string with a lowercase first letter.
+*/
+function uncapitalize(str) {
+	return str.charAt(0).toLowerCase() + str.slice(1);
+}
+/**
+* Returns the same string with an uppercase first letter.
+*/
+function capitalize(str) {
+	return str.charAt(0).toUpperCase() + str.slice(1);
+}
+/**
+* Returns the camelCase version of the given string.
+*
+* Camel case examples:
+*  `toCamelCase('hello world')` -> 'helloWorld',
+*  `toCamelCase('hello_world')` -> 'helloWorld',
+*  `toCamelCase('helloWorld')` -> 'helloWorld'
+*  `toCamelCase('HelloWorld')` -> 'helloWorld'
+*  `toCamelCase('hello_world')` -> 'helloWorld'
+*/
+function toCamelCase(str) {
+	if (/^[a-z]+(?:[A-Z][a-z]*)*$/.test(str)) return str;
+	const words = str.split(/(?<![A-Z])(?=[A-Z])|[\s_-]+/);
+	const camelCasedWords = words.map((word) => word.toUpperCase() === word ? word.toLowerCase() : word).map((word, index) => index === 0 ? lowerFirst(word) : upperFirst(word));
+	const camelCasedStr = camelCasedWords.join("");
+	return camelCasedStr;
+}
+/**
+* Validates if a string is in camelCase format
+*/
+function isCamelCase(str) {
+	return str === toCamelCase(str);
+}
+/**
+* Returns the PascalCase version of the given string.
+*
+* Examples:
+*   `toPascalCase('hello world')` -> 'HelloWorld'
+*   `toPascalCase('hello_world')` -> 'HelloWorld'
+*   `toPascalCase('helloWorld')` -> 'HelloWorld'
+*   `toPascalCase('Hello-World')` -> 'HelloWorld'
+*   `toPascalCase('HELLO_WORLD')` -> 'HelloWorld'
+*/
+function toPascalCase(str) {
+	const s = toCamelCase(str);
+	return s.charAt(0).toUpperCase() + s.slice(1);
+}
+/**
+* Validates if a string is in PascalCase format
+*/
+function isPascalCase(str) {
+	return str === toPascalCase(str);
+}
+/**
+* Returns the snake_case version of the given string.
+*
+* Examples:
+*   `toSnakeCase('hello world')` -> 'hello_world'
+*   `toSnakeCase('helloWorld')` -> 'hello_world'
+*   `toSnakeCase('HelloWorld')` -> 'hello_world'
+*   `toSnakeCase('HELLO_WORLD')` -> 'hello_world'
+*/
+function toSnakeCase(str) {
+	const camelCase = toCamelCase(str);
+	return camelCase.replace(/([A-Z])/g, "_$1").toLowerCase();
+}
+/**
+* Validates if a string is in snake_case format
+*/
+function isSnakeCase(str) {
+	return str === toSnakeCase(str);
+}
+/**
+* Returns the kebab-case version of the given string.
+*
+* Examples:
+*   `toKebabCase('hello world')` -> 'hello-world'
+*   `toKebabCase('helloWorld')` -> 'hello-world'
+*   `toKebabCase('HelloWorld')` -> 'hello-world'
+*   `toKebabCase('HELLO_WORLD')` -> 'hello-world'
+*/
+function toKebabCase(str) {
+	const camelCase = toCamelCase(str);
+	return camelCase.replaceAll(/([A-Z])/g, "-$1").toLowerCase();
+}
+/**
+* Validates if a string is in kebab-case format
+*/
+function isKebabCase(str) {
+	return str === toKebabCase(str);
+}
+/**
+* Converts each line of a string to a commented line
+*/
+function commentLines(lines) {
+	return lines.split("\n").map((l) => `// ${l}`).join("\n");
+}
+function toHumanReadable(input) {
+	let result = input.replace(/[_-]/g, " ");
+	result = result.replace(/([a-z])([A-Z])/g, "$1 $2");
+	if (result === input) return input;
+	result = result.split(" ").map((s) => s.toLowerCase()).join(" ");
+	result = upperFirst(result);
+	return result;
+}
+/**
+* Sanitizes a string to be a valid Excel ListObject (table) column name.
+* - Removes illegal characters: [ ] : ? * / \
+* - Trims leading/trailing spaces
+* - Replaces multiple spaces with a single space
+* - If the result is empty, returns a default name
+*/
+function toExcelColumnName(input, defaultName = "Column1") {
+	let result = input.replace(/[[\]:?*/\\]/g, "");
+	result = result.replace(/\s+/g, " ");
+	result = result.trim();
+	if (!result) return toExcelColumnName(defaultName, "Column1");
+	return result;
+}
+/**
+* Sanitizes a string to be a valid Excel ListObject (table) name.
+* - Must start with a letter, underscore, or backslash
+* - Only letters, numbers, and underscores allowed (no spaces or punctuation)
+* - Cannot be a cell reference (e.g., "A1")
+* - Max 255 characters
+* - If invalid or empty, returns a default name
+*/
+function toExcelTableName(input, defaultName = "Table1") {
+	let result = input.replace(/[^A-Za-z0-9_\\]/g, "");
+	if (!/^[A-Za-z_\\]/.test(result)) result = "_" + result;
+	result = result.slice(0, 255);
+	if (/^[A-Za-z]{1,3}[1-9][0-9]{0,6}$/.test(result)) result = "_" + result;
+	if (!result || result === "_") return toExcelTableName(defaultName, "Table1");
+	return result;
+}
+/**
+* Provide all relevant conjugation of a name
+*/
+function conjugateNames(name) {
+	const plural = pluralize(name);
+	return {
+		camelCase: toCamelCase(name),
+		camelCasePlural: toCamelCase(plural),
+		capitalized: capitalize(name),
+		capitalizedPlural: capitalize(plural),
+		kebabCase: toKebabCase(name),
+		kebabCasePlural: toKebabCase(plural),
+		PascalCase: toPascalCase(name),
+		PascalCasePlural: toPascalCase(plural),
+		pluralized: capitalize(plural),
+		snake_case_plural: toSnakeCase(plural),
+		snake_case: toSnakeCase(name),
+		uncapitalized: uncapitalize(name),
+		uncapitalizedPlural: uncapitalize(plural)
+	};
+}
+function slugify(str) {
+	return str.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/([a-z])(\d)/g, "$1-$2").replace(/[^a-z0-9]+/g, "-").replace(/^-/g, "").replace(/-$/g, "").replace(/-+/g, "-");
+}
+function isSlug(str) {
+	return /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(str);
+}
+/**
+* Ensures that a string is unique within a list of existing values by appending a sequential number if necessary.
+*
+* If the base string is not in the list, it is returned as is.
+* If it is, the function looks for existing strings in the format "base (n)" where n is a number,
+* and returns the next available sequential string.
+*
+* @param value - The base string to ensure uniqueness for.
+* @param existingValues - An array of existing strings to check against.
+* @param maxChecks - Maximum number of checks to be performed. An error is thrown if this limit is exceeded. Default is 100
+* @returns A unique string based on the base string.
+*/
+const ensureUnique = (value, existingValues, maxChecks = 100) => {
+	const values = new Set(existingValues);
+	if (!values.has(value)) return value;
+	let base = value.trim();
+	let num = 0;
+	const m = /\((\d{1,5})\)$/.exec(value);
+	if (m && /\s$/.test(value.slice(0, m.index))) base = value.slice(0, m.index).trimEnd();
+	while (num < maxChecks) {
+		const newValue = num === 0 ? base : `${base} (${num})`;
+		if (!values.has(newValue)) return newValue;
+		num++;
+	}
+	throw new Error(`Could not find a unique name for "${value}" after ${maxChecks} checks`);
+};
+
+//#endregion
+//#region src/types.ts
+/**
+* Makes a type check that is only valid when all cases of a switch
+* statement have been covered.
+*/
+var ExhaustiveSwitchCheck = class extends Error {
+	constructor(val) {
+		super(`Unreachable case: ${JSON.stringify(val)}`);
+	}
+};
+/**
+* Allows inline type assertions.
+*
+* Example:
+* ```
+* type Original = { a: number }
+* type WithExtra = Original & { b: string }
+*
+* function addExtra(obj: Original): asserts obj is WithExtra {
+*   assertType(obj)
+*   obj.b = 'new value' // ✅ No TypeScript error!
+* }
+* ```
+*/
+function assertType(value) {
+	return value;
+}
+/**
+* Applies a type assertion to an entire array and hence asserts the array.
+*
+* Type assertions are especially useful when you want to modify and object in place - a function
+* with a type assertion lets TypeScript know that the object was modified.
+*
+* Example:
+* ```
+* type Original = { a: number }
+* type WithExtra = Original & { b: string }
+*
+* function addExtra(obj: Original): asserts obj is WithExtra {
+*   obj.b = 'new value'
+* }
+*
+* const myObj: Original[] = [{ a: 1 }]
+* console.log(myObj[0].b) // ❌ TypeScript error!
+* assertArray(myObj, addExtra)
+* console.log(myObj[0].b) // ✅ No TypeScript error!
+* ```
+*/
+function assertArray(obj, fn) {
+	obj.forEach(fn);
+}
+
+//#endregion
+//#region src/uniq.ts
+function uniq(items, predicate) {
+	const result = [];
+	const seen = {};
+	for (const item of items) {
+		const key = predicate(item);
+		if (!seen[key]) {
+			seen[key] = true;
+			result.push(item);
+		}
+	}
+	return result;
+}
+
+//#endregion
+//#region src/zod.ts
+/**
+* Pipes a list of Zod transformers together in a type-safe way. Returns early if any of the transformers returns `z.NEVER`.
+*/
+function pipeZodTransformers(initialValue, ctx, fns) {
+	let result = initialValue;
+	for (const fn of fns) {
+		result = fn(result, ctx);
+		if (result === z.NEVER) return z.NEVER;
+	}
+	return result;
+}
+/**
+* Returns a Zod error map that returns the given message for union errors.
+*
+* This is useful for generating meaningful error messages for unions, e.g.
+* ```
+* z.union(
+*   [z.constant('foo'), z.constant('bar')],
+*   unionErrorMessage('Value must be either "foo" or "bar"!')
+* )
+* ```
+*
+* In addition to a static message, you can also pass a function that takes the
+* invalid data as input and returns a string. Example:
+* ```
+* z.union(
+*   [z.constant('foo'), z.constant('bar')],
+*   unionErrorMessage((data) => `Value must be either "foo" or "bar" - received ${JSON.stringify(data)} instead!`)
+* )
+* ```
+*/
+function unionErrorMessage(param) {
+	return { errorMap: (issue, ctx) => {
+		let message;
+		if (typeof param === "string") message = param;
+		else message = param(ctx.data);
+		if (issue.code === z.ZodIssueCode.invalid_union) return { message };
+		return { message: ctx.defaultError };
+	} };
+}
+
+//#endregion
+//#region src/zod-excel.decoders.ts
+/**
+* Transformer that verifies that the number is an integer
+*/
+const intValidator = (x, ctx) => {
+	if (x % 1 !== 0) {
+		ctx.addIssue({
+			code: z$1.ZodIssueCode.custom,
+			message: `Not an integer: ${x}`
+		});
+		return z$1.NEVER;
+	}
+	return x;
+};
+/**
+* Converts any transformer to a nullable transformer, i.e. if the input is
+* null or undefined, the output will be nullable. Else the original transformer
+* is applied
+*/
+const nullableTransformer = (transformer) => (x, ctx) => {
+	if (x === null || x === void 0 || typeof x === "string" && x === "") return null;
+	return transformer(x, ctx);
+};
+/**
+* A decoder that transforms Excel strings to JS strings, also handling numbers and boolean. Will not parse any other type!
+*
+* Background: In Excel, entering a number in a cell will automatically convert it to a number -
+* and xlPort will return it as a number. However, often we want to treat it as a string - this decoder
+* hence accepts both strings and numbers, and converts numbers to strings.
+*
+* It'll perform casting based on the following rules:
+* - If the value is a number, it'll be converted to a string
+* - If the value is a string, it'll be returned as-is
+* - If the value is boolean, it'll return 'true' or 'false'
+*
+* Any other type will throw an error!
+*/
+const excelStringStrictDecoder = z$1.union([
+	z$1.string(),
+	z$1.number(),
+	z$1.boolean()
+]).transform((x) => {
+	if (typeof x === "number") return x.toString();
+	if (typeof x === "boolean") return x ? "true" : "false";
+	return x;
+});
+/**
+* A decoder that transforms Excel strings to JS strings, also handling numbers and any other potential type
+*
+* Background: In Excel, entering a number in a cell will automatically convert it to a number -
+* and xlPort will return it as a number. However, often we want to treat it as a string - this decoder
+* hence accepts both strings and numbers, and converts numbers to strings.
+*
+* It'll perform casting based on the following rules:
+* - If the value is a number, it'll be converted to a string
+* - If the value is a string, it'll be returned as-is
+* - If the value is boolean, it'll return 'true' or 'false'
+* - If the value is null or undefined, it'll return an empty string
+* - If the value is any other type, it'll return an empty string
+*
+* Null handling: Null values/blank cells will be converted to a blank string.
+*/
+const excelStringDecoder = z$1.union([
+	z$1.string(),
+	z$1.number(),
+	z$1.boolean(),
+	z$1.null(),
+	z$1.undefined(),
+	z$1.any()
+]).transform((x) => {
+	if (x === null || x === void 0) return "";
+	if (typeof x === "number") return x.toString();
+	if (typeof x === "boolean") return x ? "true" : "false";
+	if (typeof x === "string") return x;
+	return "";
+});
+/**
+* A decoder that transforms Excel strings to JS strings, also handling numbers and null
+*
+* Background: In Excel, entering a number in a cell will automatically convert it to a number -
+* and xlPort will return it as a number. However, often we want to treat it as a string - this decoder
+* hence accepts both strings and numbers, and converts numbers to strings.
+*
+* It'll perform casting based on the following rules:
+* - If the value is a number, it'll be converted to a string
+* - If the value is a string, it'll be returned as-is - except blank strings, which will be converted to null
+* - If the value is boolean, it'll return 'true' or 'false'
+* - If the value is null or undefined, it'll return null
+* - If the value is any other type, it'll return null
+*
+* Null handling: Blank strings will be converted to null. This is to reflect that in Excel a formula
+*   cannot return null. As a workaround, one often returns a blank string to represent null.
+*/
+const excelStringNullableDecoder = z$1.union([
+	z$1.string(),
+	z$1.number(),
+	z$1.boolean(),
+	z$1.null(),
+	z$1.undefined(),
+	z$1.any()
+]).transform((x) => {
+	if (x === null || x === void 0) return null;
+	if (typeof x === "number") return x.toString();
+	if (typeof x === "boolean") return x ? "true" : "false";
+	if (typeof x === "string") {
+		if (x === "") return null;
+		return x;
+	}
+	return null;
+});
+const excelNumberTransformer = (x) => {
+	if (typeof x === "string") {
+		if (x.trim() === "") return null;
+		const parsed = parseFloat(x);
+		if (Number.isNaN(parsed)) return null;
+		return parsed;
+	}
+	if (typeof x === "boolean") return x ? 1 : 0;
+	if (typeof x === "number") return x;
+	return null;
+};
+/**
+* A decoder that transforms Excel numbers to JS numbers, also handling strings and boolean. Will not parse any other type!
+*
+* It'll perform casting based on the following rules:
+* - If the value is a number, it'll be returned as-is
+* - If the value is a string, it'll try to parse it to a number. Blank strings will be converted to 0. Non-numeric strings will throw an error.
+* - If the value is boolean, it'll return 1 or 0
+* - If the value is any other type, it'll throw an error
+*
+*/
+const excelNumberStrictDecoder = z$1.union([
+	z$1.string(),
+	z$1.number(),
+	z$1.boolean()
+]).transform((x, ctx) => {
+	const result = excelNumberTransformer(x);
+	if (result === null) {
+		ctx.addIssue({
+			code: z$1.ZodIssueCode.custom,
+			message: `Not a number: ${x}`
+		});
+		return z$1.NEVER;
+	}
+	return result;
+});
+/**
+* A decoder that transforms Excel numbers to JS numbers, also handling strings, boolean and other types.
+*
+* It'll perform casting based on the following rules:
+* - If the value is a number, it'll be returned as-is
+* - If the value is a string, it'll try to parse it to a number. Blank strings and non-numerical strings will be converted to 0.
+* - If the value is boolean, it'll return 1 or 0
+* - If the value is any other type, it'll return 0
+*
+* Null handling: Null values/blank cells will be converted to blank strings.
+*/
+const excelNumberDecoder = z$1.union([
+	z$1.string(),
+	z$1.number(),
+	z$1.boolean(),
+	z$1.null(),
+	z$1.undefined(),
+	z$1.any()
+]).transform((x) => {
+	const result = excelNumberTransformer(x);
+	if (result === null) return 0;
+	return result;
+});
+/**
+* A decoder that transforms Excel numbers to JS numbers, also handling strings, boolean and other types.
+
+* It'll perform casting based on the following rules:
+* - If the value is a number, it'll be returned as-is
+* - If the value is a string, it'll try to parse it to a number. Non-numerical and blank strings will be converted to null
+* - If the value is boolean, it'll return 1 or 0
+* - If the value is any other type, it'll return null
+* 
+* Null handling: Blank strings will be converted to null. This is to reflect that in Excel a formula
+*   cannot return null. As a workaround, one often returns a blank string to represent null.
+*/
+const excelNumberNullableDecoder = z$1.union([
+	z$1.string(),
+	z$1.null(),
+	z$1.number(),
+	z$1.undefined(),
+	z$1.any()
+]).transform(excelNumberTransformer);
+/**
+* A decoder that transforms Excel numbers to JS integers, also handling strings and boolean. Other types will throw an error.
+*
+* If the number is not an integer, an error will be thrown.
+*/
+const excelIntStrictDecoder = excelNumberStrictDecoder.transform(intValidator);
+/**
+* A decoder that transforms Excel numbers to JS integers, also handling strings and boolean. Other types will be converted to 0.
+*
+* If the number is not an integer, an error will be thrown.
+*/
+const excelIntDecoder = excelNumberDecoder.transform(intValidator);
+/**
+* A decoder that transforms Excel numbers to JS integers, also handling strings and boolean. Other types will be converted to null.
+*
+* If the number is not an integer, an error will be thrown.
+*/
+const excelIntNullableDecoder = excelNumberNullableDecoder.transform(nullableTransformer(intValidator));
+const bigIntTransformer = (x, ctx) => {
+	if (x % 1 !== 0) {
+		ctx.addIssue({
+			code: z$1.ZodIssueCode.custom,
+			message: `Not an integer: ${x}`
+		});
+		return z$1.NEVER;
+	}
+	return BigInt(x);
+};
+/**
+* A decoder that transforms Excel numbers to JS BigInts, also handling strings and boolean. Other types will throw an error.
+*
+* If the number is not a (big) integer, an error will be thrown.
+*/
+const excelBigIntStrictDecoder = excelNumberStrictDecoder.transform(bigIntTransformer);
+/**
+* A decoder that transforms Excel numbers to JS BigInts, also handling strings and boolean. Other types will be converted to 0.
+*
+* If the number is not a (big) integer, an error will be thrown.
+*/
+const excelBigIntDecoder = excelNumberDecoder.transform(bigIntTransformer);
+/**
+* A decoder that transforms Excel numbers to JS BigInts, also handling strings and boolean. Other types will be converted to null.
+*
+* If the number is not a (big) integer, an error will be thrown.
+*/
+const excelBigIntNullableDecoder = excelNumberNullableDecoder.transform(nullableTransformer(bigIntTransformer));
+const excelBooleanNullableTransformer = (x) => {
+	if (typeof x === "number") return x !== 0;
+	if (typeof x === "string") switch (x.toLowerCase()) {
+		case "true":
+		case "1": return true;
+		case "false":
+		case "0": return false;
+		default: return null;
+	}
+	if (typeof x === "boolean") return x;
+	return null;
+};
+/**
+* A decoder that transforms Excel booleans to JS booleans, also handling numbers and strings.
+*
+* It'll perform casting based on the following rules:
+* - If the value is a number, it'll return true if it's not 0
+* - If the value is a string, it'll return true if it's 'true' or '1', false if it's 'false' or '0', and throw an error otherwise
+* - If the value is boolean, it'll return it as-is
+* - If the value is any other type, it'll throw an error
+*/
+const excelBooleanStrictDecoder = z$1.union([
+	z$1.boolean(),
+	z$1.number(),
+	z$1.string()
+]).transform((x, ctx) => {
+	const result = excelBooleanNullableTransformer(x);
+	if (result === null) {
+		ctx.addIssue({
+			code: z$1.ZodIssueCode.custom,
+			message: `Not a boolean: ${x}`
+		});
+		return z$1.NEVER;
+	}
+	return result;
+});
+/**
+* A decoder that transforms Excel booleans to JS booleans, also handling numbers and strings.
+*
+* It'll perform casting based on the following rules:
+* - If the value is a number, it'll return true if it's not 0
+* - If the value is a string, it'll return true if it's 'true' or '1', false otherwise
+* - If the value is boolean, it'll return it as-is
+* - If the value is any other type, it'll return false
+*/
+const excelBooleanDecoder = z$1.union([
+	z$1.boolean(),
+	z$1.number(),
+	z$1.null(),
+	z$1.string(),
+	z$1.undefined(),
+	z$1.any()
+]).transform((x) => {
+	const result = excelBooleanNullableTransformer(x);
+	if (result === null) return false;
+	return result;
+});
+/**
+* A decoder that transforms Excel booleans to JS booleans, also handling numbers and strings.
+*
+* It'll perform casting based on the following rules:
+* - If the value is a number, it'll return true if it's not 0
+* - If the value is a string, it'll return true if it's 'true' or '1', false if it's 'false' or '0', and null otherwise
+* - If the value is boolean, it'll return it as-is
+* - If the value is any other type, it'll return null
+*/
+const excelBooleanNullableDecoder = z$1.union([
+	z$1.boolean(),
+	z$1.number(),
+	z$1.null(),
+	z$1.string(),
+	z$1.undefined(),
+	z$1.any()
+]).transform(excelBooleanNullableTransformer);
+const excelDateNullableTransformer = (x, ctx) => {
+	if (x === null || x === void 0) return null;
+	if (isDate(x)) return x;
+	if (typeof x === "number") {
+		const date = new Date(Date.UTC(1900, 0, 1));
+		date.setUTCDate(date.getDate() + x - 2);
+		const fractionalDay = x - Math.floor(x);
+		date.setMilliseconds(date.getMilliseconds() + fractionalDay * 24 * 60 * 60 * 1e3);
+		return date;
+	}
+	if (typeof x === "string") {
+		if (typeof x === "string" && x.trim() === "") return null;
+		const result = new Date(x);
+		if (Number.isNaN(result.getTime())) {
+			ctx.addIssue({
+				code: z$1.ZodIssueCode.custom,
+				message: `Not a date: ${x}`
+			});
+			return z$1.NEVER;
+		}
+		return result;
+	}
+	return null;
+};
+/**
+* A decoder that transforms Excel dates to JS Dates
+*/
+const excelDateDecoder = z$1.union([
+	z$1.date(),
+	z$1.number(),
+	z$1.string()
+]).transform((x, ctx) => {
+	const result = excelDateNullableTransformer(x, ctx);
+	if (result === null) {
+		ctx.addIssue({
+			code: z$1.ZodIssueCode.custom,
+			message: `Not a date: ${x.toString()}`
+		});
+		return z$1.NEVER;
+	}
+	return result;
+});
+/**
+* A decoder that transforms nullable Excel dates to JS Dates
+*/
+const excelDateNullableDecoder = z$1.union([
+	z$1.date(),
+	z$1.string(),
+	z$1.number(),
+	z$1.null(),
+	z$1.undefined(),
+	z$1.any()
+]).transform(excelDateNullableTransformer);
+
+//#endregion
+export { DefaultMap, ExhaustiveSwitchCheck, NestedMap, Result, TypedMapping, addAndSort, assertArray, assertType, blue, bold, booleanCode, capitalize, capitalizeKeys, commentLines, compare, compareBooleans, compareDates, compareFields, compareNumbers, compareStrings, compareValues, conjugateNames, cyan, dictGetAndAssert, ensureUnique, equals, err, excelBigIntDecoder, excelBigIntNullableDecoder, excelBigIntStrictDecoder, excelBooleanDecoder, excelBooleanNullableDecoder, excelBooleanStrictDecoder, excelDateDecoder, excelDateNullableDecoder, excelIntDecoder, excelIntNullableDecoder, excelIntStrictDecoder, excelNumberDecoder, excelNumberNullableDecoder, excelNumberStrictDecoder, excelStringDecoder, excelStringNullableDecoder, excelStringStrictDecoder, filterDict, filterMap, format, generateRandomAlphanumericString, gray, green, groupBy, groupByCurried, groupByToDict, groupByToMap, idToDict, inverse, isCamelCase, isDate, isKebabCase, isPascalCase, isPlural, isSlug, isSnakeCase, italic, keyGetter, lowerFirst, mapDict, mapGetAndAssert, mapLimit, mapMap, mapMapKeyValues, mapMapKeys, mapMapValues, mapToDict, ok, omit, pipeZodTransformers, pluralize, randomInt, red, removeSecrets, removeUndefinedProperties, setDirection, slice, slugify, sort, timeStamp, toCamelCase, toDict, toExcelColumnName, toExcelTableName, toHumanReadable, toKebabCase, toPascalCase, toSnakeCase, uncapitalize, uncapitalizeKeys, underline, unionErrorMessage, uniq, upperFirst, yellow };
+//# sourceMappingURL=zod-excel.decoders-BJliEI1Y.js.map