@sohanemon/utils 6.2.8 → 6.2.10

package/dist/index.mjs

@@ -0,0 +1,664 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+//#region src/functions/cookie.ts
+const setClientSideCookie = (name, value, days, path = "/") => {
+	let expires = "";
+	if (days) {
+		const date = /* @__PURE__ */ new Date();
+		date.setTime(date.getTime() + days * 24 * 60 * 60 * 1e3);
+		expires = `; expires=${date.toUTCString()}`;
+	}
+	document.cookie = `${name}=${value || ""}${expires}; path=${path}`;
+};
+const deleteClientSideCookie = (name, path = "/") => {
+	document.cookie = `${name}=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=${path}`;
+};
+const hasClientSideCookie = (name) => {
+	return document.cookie.split("; ").some((row) => row.startsWith(`${name}=`));
+};
+const getClientSideCookie = (name) => {
+	return { value: document.cookie.split("; ").find((row) => row.startsWith(`${name}=`))?.split("=")[1] };
+};
+
+//#endregion
+//#region src/types/guards.ts
+const isFalsy = (val) => !val;
+const isNullish = (val) => val == null;
+const isPrimitive = (val) => {
+	if (val === null || val === void 0) return true;
+	switch (typeof val) {
+		case "string":
+		case "number":
+		case "bigint":
+		case "boolean":
+		case "symbol": return true;
+		default: return false;
+	}
+};
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	if (Object.prototype.toString.call(value) !== "[object Object]") return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === null || proto === Object.prototype;
+}
+
+//#endregion
+//#region src/functions/deepmerge.ts
+function deepmerge(target, ...args) {
+	let sources;
+	let options = {};
+	const lastArg = args[args.length - 1];
+	if (lastArg && typeof lastArg === "object" && !Array.isArray(lastArg) && (lastArg.arrayMerge !== void 0 || lastArg.clone !== void 0 || lastArg.customMerge !== void 0 || lastArg.maxDepth !== void 0)) {
+		options = {
+			...options,
+			...lastArg
+		};
+		sources = args.slice(0, -1);
+	} else sources = args;
+	const { arrayMerge = "replace", clone = true, customMerge, maxDepth = 100 } = options;
+	const visited = /* @__PURE__ */ new WeakMap();
+	return mergeObjects(target, sources, 0);
+	function mergeObjects(target$1, sources$1, depth) {
+		if (depth >= maxDepth) {
+			console.warn(`[deepmerge] Maximum depth ${maxDepth} exceeded. Returning target as-is.`);
+			return target$1;
+		}
+		if (!isPlainObject(target$1) && !Array.isArray(target$1)) {
+			for (const source of sources$1) if (source !== void 0) return source;
+			return target$1;
+		}
+		let result = clone ? Array.isArray(target$1) ? [...target$1] : { ...target$1 } : target$1;
+		for (const source of sources$1) {
+			if (source == null) continue;
+			if (visited.has(source)) continue;
+			visited.set(source, result);
+			if (Array.isArray(result) && Array.isArray(source)) result = mergeArrays(result, source, arrayMerge);
+			else if (isPlainObject(result) && isPlainObject(source)) {
+				const keys = new Set([
+					...Object.keys(result),
+					...Object.keys(source),
+					...Object.getOwnPropertySymbols(result),
+					...Object.getOwnPropertySymbols(source)
+				]);
+				for (const key of keys) {
+					const targetValue = result[key];
+					const sourceValue = source[key];
+					if (customMerge && customMerge(key, targetValue, sourceValue) !== void 0) result[key] = customMerge(key, targetValue, sourceValue);
+					else if (isPlainObject(targetValue) && isPlainObject(sourceValue)) result[key] = mergeObjects(targetValue, [sourceValue], depth + 1);
+					else if (Array.isArray(targetValue) && Array.isArray(sourceValue)) result[key] = mergeArrays(targetValue, sourceValue, arrayMerge);
+					else if (sourceValue !== void 0) result[key] = sourceValue;
+				}
+			} else result = source;
+		}
+		return result;
+	}
+	function mergeArrays(target$1, source, strategy) {
+		if (typeof strategy === "function") return strategy(target$1, source);
+		switch (strategy) {
+			case "concat": return [...target$1, ...source];
+			case "merge":
+				const maxLength = Math.max(target$1.length, source.length);
+				const merged = [];
+				for (let i = 0; i < maxLength; i++) if (i < target$1.length && i < source.length) if (isPlainObject(target$1[i]) && isPlainObject(source[i])) merged[i] = mergeObjects(target$1[i], [source[i]], 0);
+				else merged[i] = source[i];
+				else if (i < target$1.length) merged[i] = target$1[i];
+				else merged[i] = source[i];
+				return merged;
+			case "replace":
+			default: return [...source];
+		}
+	}
+}
+
+//#endregion
+//#region src/functions/hydrate.ts
+/**
+* Converts all `null` values to `undefined` in the data structure recursively.
+*
+* @param data - Any input data (object, array, primitive)
+* @returns Same type as input, but with all nulls replaced by undefined
+*
+* @example
+* hydrate({ a: null, b: 'test' }) // { a: undefined, b: 'test' }
+* hydrate([null, 1, { c: null }]) // [undefined, 1, { c: undefined }]
+*/
+function hydrate(data) {
+	return convertNulls(data);
+}
+function convertNulls(value) {
+	if (value === null) return void 0;
+	if (typeof value !== "object" || value === null) return value;
+	if (Array.isArray(value)) return value.map(convertNulls);
+	if (isPlainObject(value)) {
+		const result = {};
+		for (const key in value) result[key] = convertNulls(value[key]);
+		return result;
+	}
+	return value;
+}
+
+//#endregion
+//#region src/functions/object.ts
+/**
+* Implementation of deep object value retrieval with type safety
+* @param obj - Source object
+* @param path - Path specification (string or array)
+* @param defaultValue - Optional fallback value
+* @returns Value at path or default/undefined
+*/
+function getObjectValue(obj, path, defaultValue) {
+	if (typeof path !== "string" && !Array.isArray(path)) return defaultValue;
+	const pathArray = (() => {
+		if (Array.isArray(path)) return path;
+		if (path === "") return [];
+		return String(path).split(".").filter((segment) => segment !== "");
+	})();
+	if (!Array.isArray(pathArray)) return defaultValue;
+	let current = obj;
+	for (const key of pathArray) {
+		if (current === null || current === void 0) return defaultValue;
+		const actualKey = typeof key === "string" && Array.isArray(current) && /^\d+$/.test(key) ? Number.parseInt(key, 10) : key;
+		current = current[actualKey];
+	}
+	return current !== void 0 ? current : defaultValue;
+}
+/**
+* Extend an object or function with additional properties while
+* preserving the original type information.
+*
+* Works with both plain objects and callable functions since
+* functions in JavaScript are objects too.
+*
+* @template T The base object or function type
+* @template P The additional properties type
+*
+* @param base - The object or function to extend
+* @param props - An object containing properties to attach
+*
+* @returns The same object/function, augmented with the given properties
+*
+* @example
+* // Extend an object
+* const obj = extendProps({ a: 1 }, { b: "hello" });
+* // obj has { a: number; b: string }
+*
+* // Extend a function
+* const fn = (x: number) => x * 2;
+* const enhanced = extendProps(fn, { name: "doubler" });
+* // enhanced is callable and also has { name: string }
+*/
+function extendProps(base, props) {
+	return Object.assign(base, props);
+}
+
+//#endregion
+//#region src/functions/utils.ts
+/**
+* Utility to merge class names with Tailwind CSS and additional custom merging logic.
+*
+* @param {...ClassValue[]} inputs - Class names to merge.
+* @returns {string} - A string of merged class names.
+*/
+function cn(...inputs) {
+	return twMerge(clsx(inputs));
+}
+/**
+* @deprecated Use isLinkActive instead.
+*
+* Determines if a navigation link is active based on the current path.
+*
+* @param  href - The target URL.
+* @param  path - The current browser path.
+* @returns - True if the navigation is active, false otherwise.
+*/
+function isNavActive(href, path) {
+	console.warn("isNavActive is deprecated. Use isLinkActive instead.");
+	return (/* @__PURE__ */ new RegExp(`^/?${href}(/|$)`)).test(path);
+}
+/**
+* Checks if a link is active, considering optional localization prefixes.
+*
+* @param {Object} params - Parameters object.
+* @param {string} params.path - The target path of the link.
+* @param {string} params.currentPath - The current browser path.
+* @param {string[]} [params.locales=['en', 'es', 'de', 'zh', 'bn', 'fr', 'it', 'nl']] - Supported locale prefixes.
+* @returns {boolean} - True if the link is active, false otherwise.
+*/
+function isLinkActive({ path, currentPath, locales = [
+	"en",
+	"es",
+	"de",
+	"zh",
+	"bn",
+	"fr",
+	"it",
+	"nl"
+], exact = true }) {
+	const localeRegex = /* @__PURE__ */ new RegExp(`^/?(${locales.join("|")})/`);
+	const normalizePath = (p) => {
+		return p.replace(localeRegex, "").replace(/^\/+|\/+$/g, "");
+	};
+	const normalizedPath = normalizePath(path);
+	const normalizedCurrentPath = normalizePath(currentPath);
+	return exact ? normalizedPath === normalizedCurrentPath : normalizedCurrentPath.startsWith(normalizedPath);
+}
+/**
+* Cleans a file path by removing the `/public/` prefix if present.
+*
+* @param  src - The source path to clean.
+* @returns - The cleaned path.
+*/
+function cleanSrc(src) {
+	let cleanedSrc = src;
+	if (src.includes("/public/")) cleanedSrc = src.replace("/public/", "/");
+	return cleanedSrc.trim();
+}
+/**
+* Smoothly scrolls to the top or bottom of a specified container.
+*
+* @param  containerSelector - The CSS selector or React ref for the container.
+* @param  to - Specifies whether to scroll to the top or bottom.
+*/
+const scrollTo = (containerSelector, to$1) => {
+	let container;
+	if (typeof containerSelector === "string") container = document.querySelector(containerSelector);
+	else if (containerSelector.current) container = containerSelector.current;
+	else return;
+	if (container) container.scrollTo({
+		top: to$1 === "top" ? 0 : container.scrollHeight - container.clientHeight,
+		behavior: "smooth"
+	});
+};
+/**
+* Copies a given string to the clipboard.
+*
+* @param  value - The value to copy to the clipboard.
+* @param  [onSuccess=() => {}] - Optional callback executed after successful copy.
+*/
+const copyToClipboard = (value, onSuccess = () => {}) => {
+	if (typeof window === "undefined" || !navigator.clipboard?.writeText) return;
+	if (!value) return;
+	navigator.clipboard.writeText(value).then(onSuccess);
+};
+/**
+* Converts camelCase, PascalCase, kebab-case, snake_case into normal case.
+*
+* @param  inputString - The string need to be converted into normal case
+* @returns - Normal Case
+*/
+function convertToNormalCase(inputString) {
+	return (inputString.split(".").pop() || inputString).replace(/([a-z])([A-Z])/g, "$1 $2").split(/[-_|�\s]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+const from = "àáãäâèéëêìíïîòóöôùúüûñç·/_,:;";
+const to = "aaaaaeeeeiiiioooouuuunc------";
+/**
+* Converts a string to a URL-friendly slug by trimming, converting to lowercase,
+* replacing diacritics, removing invalid characters, and replacing spaces with hyphens.
+* @param {string} [str] - The input string to convert.
+* @returns {string} The generated slug.
+* @example
+* convertToSlug("Hello World!"); // "hello-world"
+* convertToSlug("Déjà Vu"); // "deja-vu"
+*/
+const convertToSlug = (str) => {
+	if (typeof str !== "string") throw new TypeError("Input must be a string");
+	let slug = str.trim().toLowerCase();
+	const charMap = {};
+	for (let i = 0; i < 29; i++) charMap[from.charAt(i)] = to.charAt(i);
+	slug = slug.replace(new RegExp(`[${from}]`, "g"), (match) => charMap[match] || match);
+	return slug.replace(/[^a-z0-9 -]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-+/, "").replace(/-+$/, "") || "";
+};
+/**
+* Checks if the code is running in a server-side environment.
+*
+* @returns - True if the code is executed in SSR (Server-Side Rendering) context, false otherwise
+*/
+const isSSR = typeof window === "undefined";
+/**
+* Converts an SVG string to a Base64-encoded string.
+*
+* @param str - The SVG string to encode
+* @returns - Base64-encoded string representation of the SVG
+*/
+const svgToBase64 = (str) => isSSR ? Buffer.from(str).toString("base64") : window.btoa(str);
+/**
+* Pauses execution for the specified time.
+*
+* `signal` allows cancelling the sleep via AbortSignal.
+*
+* @param time - Time in milliseconds to sleep (default is 1000ms)
+* @param signal - Optional AbortSignal to cancel the sleep early
+* @returns - A Promise that resolves after the specified time or when aborted
+*/
+const sleep = (time = 1e3, signal) => new Promise((resolve) => {
+	if (signal?.aborted) return resolve();
+	const id = setTimeout(() => {
+		cleanup();
+		resolve();
+	}, time);
+	function onAbort() {
+		clearTimeout(id);
+		cleanup();
+		resolve();
+	}
+	function cleanup() {
+		signal?.removeEventListener("abort", onAbort);
+	}
+	if (signal) signal.addEventListener("abort", onAbort, { once: true });
+});
+/**
+* Creates a debounced function that delays invoking the provided function until
+* after the specified `wait` time has elapsed since the last invocation.
+*
+* If the `immediate` option is set to `true`, the function will be invoked immediately
+* on the leading edge of the wait interval. Subsequent calls during the wait interval
+* will reset the timer but not invoke the function until the interval elapses again.
+*
+* The returned function includes the `isPending` property to check if the debounce
+* timer is currently active.
+*
+* @typeParam F - The type of the function to debounce.
+*
+* @param function_ - The function to debounce.
+* @param wait - The number of milliseconds to delay (default is 100ms).
+* @param options - An optional object with the following properties:
+*   - `immediate` (boolean): If `true`, invokes the function on the leading edge
+*     of the wait interval instead of the trailing edge.
+*
+* @returns A debounced version of the provided function, enhanced with the `isPending` property.
+*
+* @throws {TypeError} If the first parameter is not a function.
+* @throws {RangeError} If the `wait` parameter is negative.
+*
+* @example
+* const log = debounce((message: string) => console.log(message), 200);
+* log('Hello'); // Logs "Hello" after 200ms if no other call is made.
+* console.log(log.isPending); // true if the timer is active.
+*/
+function debounce(function_, wait = 100, options) {
+	if (typeof function_ !== "function") throw new TypeError(`Expected the first parameter to be a function, got \`${typeof function_}\`.`);
+	if (wait < 0) throw new RangeError("`wait` must not be negative.");
+	const immediate = options?.immediate ?? false;
+	let timeoutId;
+	let lastArgs;
+	let lastContext;
+	let result;
+	function run() {
+		result = function_.apply(lastContext, lastArgs);
+		lastArgs = void 0;
+		lastContext = void 0;
+		return result;
+	}
+	const debounced = function(...args) {
+		lastArgs = args;
+		lastContext = this;
+		if (timeoutId === void 0 && immediate) result = run.call(this);
+		if (timeoutId !== void 0) clearTimeout(timeoutId);
+		timeoutId = setTimeout(run.bind(this), wait);
+		return result;
+	};
+	Object.defineProperty(debounced, "isPending", { get() {
+		return timeoutId !== void 0;
+	} });
+	return debounced;
+}
+/**
+* Creates a throttled function that invokes the provided function at most once
+* every `wait` milliseconds.
+*
+* If the `leading` option is set to `true`, the function will be invoked immediately
+* on the leading edge of the throttle interval. If the `trailing` option is set to `true`,
+* the function will also be invoked at the end of the throttle interval if additional
+* calls were made during the interval.
+*
+* The returned function includes the `isPending` property to check if the throttle
+* timer is currently active.
+*
+* @typeParam F - The type of the function to throttle.
+*
+* @param function_ - The function to throttle.
+* @param wait - The number of milliseconds to wait between invocations (default is 100ms).
+* @param options - An optional object with the following properties:
+*   - `leading` (boolean): If `true`, invokes the function on the leading edge of the interval.
+*   - `trailing` (boolean): If `true`, invokes the function on the trailing edge of the interval.
+*
+* @returns A throttled version of the provided function, enhanced with the `isPending` property.
+*
+* @throws {TypeError} If the first parameter is not a function.
+* @throws {RangeError} If the `wait` parameter is negative.
+*
+* @example
+* const log = throttle((message: string) => console.log(message), 200);
+* log('Hello'); // Logs "Hello" immediately if leading is true.
+* console.log(log.isPending); // true if the timer is active.
+*/
+function throttle(function_, wait = 100, options) {
+	if (typeof function_ !== "function") throw new TypeError(`Expected the first parameter to be a function, got \`${typeof function_}\`.`);
+	if (wait < 0) throw new RangeError("`wait` must not be negative.");
+	const leading = options?.leading ?? true;
+	const trailing = options?.trailing ?? true;
+	let timeoutId;
+	let lastArgs;
+	let lastContext;
+	let lastCallTime;
+	let result;
+	function invoke() {
+		lastCallTime = Date.now();
+		result = function_.apply(lastContext, lastArgs);
+		lastArgs = void 0;
+		lastContext = void 0;
+	}
+	function later() {
+		timeoutId = void 0;
+		if (trailing && lastArgs) invoke();
+	}
+	const throttled = function(...args) {
+		const timeSinceLastCall = lastCallTime ? Date.now() - lastCallTime : Number.POSITIVE_INFINITY;
+		lastArgs = args;
+		lastContext = this;
+		if (timeSinceLastCall >= wait) if (leading) invoke();
+		else timeoutId = setTimeout(later, wait);
+		else if (!timeoutId && trailing) timeoutId = setTimeout(later, wait - timeSinceLastCall);
+		return result;
+	};
+	Object.defineProperty(throttled, "isPending", { get() {
+		return timeoutId !== void 0;
+	} });
+	return throttled;
+}
+/**
+* Formats a string by replacing each '%s' placeholder with the corresponding argument.
+* This function mimics the basic behavior of C's printf for %s substitution.
+*
+* It supports both calls like `printf(format, ...args)` and `printf(format, argsArray)`.
+*
+* @param format - The format string containing '%s' placeholders.
+* @param args - The values to substitute into the placeholders, either as separate arguments or as a single array.
+* @returns The formatted string with all '%s' replaced by the provided arguments.
+*
+* @example
+* ```ts
+* const message = printf("%s love %s", "I", "Bangladesh");
+* // message === "I love Bangladesh"
+*
+* const arr = ["I", "Bangladesh"];
+* const message2 = printf("%s love %s", arr);
+* // message2 === "I love Bangladesh"
+*
+* // If there are too few arguments:
+* const incomplete = printf("Bangladesh is %s %s", "beautiful");
+* // incomplete === "Bangladesh is beautiful"
+* ```
+*/
+function printf(format, ...args) {
+	const replacements = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
+	let idx = 0;
+	return format.replace(/%s/g, () => {
+		const arg = replacements[idx++];
+		return arg === void 0 ? "" : String(arg);
+	});
+}
+const mergeRefs = (...refs) => {
+	return (value) => {
+		for (const ref of refs) {
+			if (!ref) continue;
+			if (typeof ref === "function") ref(value);
+			else ref.current = value;
+		}
+	};
+};
+/**
+* Navigates to the specified client-side hash without ssr.
+* use `scroll-margin-top` with css to add margins
+*
+* @param id - The ID of the element without # to navigate to.
+*
+* @example goToClientSideHash('my-element');
+*/
+function goToClientSideHash(id, opts) {
+	const el = document.getElementById(id);
+	if (!el) return;
+	el.scrollIntoView({
+		behavior: "smooth",
+		block: "start",
+		...opts
+	});
+	window.history.pushState(null, "", `#${id}`);
+}
+/**
+* Escapes a string for use in a regular expression.
+*
+* @param str - The string to escape
+* @returns - The escaped string
+*
+* @example
+* const escapedString = escapeRegExp('Hello, world!');
+* // escapedString === 'Hello\\, world!'
+*/
+function escapeRegExp(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+* Normalizes a string by:
+* - Applying Unicode normalization (NFC)
+* - Optionally removing diacritic marks (accents)
+* - Optionally trimming leading/trailing non-alphanumeric characters
+* - Optionally converting to lowercase
+*
+* @param str - The string to normalize
+* @param options - Normalization options
+* @param options.lowercase - Whether to convert the result to lowercase (default: true)
+* @param options.removeAccents - Whether to remove diacritic marks like accents (default: true)
+* @param options.removeNonAlphanumeric - Whether to trim non-alphanumeric characters from the edges (default: true)
+* @returns The normalized string
+*/
+function normalizeText(str, options = {}) {
+	if (!str) return "";
+	const { lowercase = true, removeAccents = true, removeNonAlphanumeric = true } = options;
+	let result = str.normalize("NFC");
+	if (removeAccents) result = result.normalize("NFD").replace(/\p{M}/gu, "");
+	if (removeNonAlphanumeric) result = result.replace(/^[^\p{L}\p{N}]*|[^\p{L}\p{N}]*$/gu, "");
+	if (lowercase) result = result.toLocaleLowerCase();
+	return result;
+}
+
+//#endregion
+//#region src/functions/poll.ts
+/**
+* Repeatedly polls an async `cond` function UNTIL it returns a TRUTHY value,
+* or until the operation times out or is aborted.
+*
+* Designed for waiting on async jobs, external state, or delayed availability.
+*
+* @template T The type of the successful result.
+*
+* @param cond
+* A function returning a Promise that resolves to:
+*   - a truthy value `T` → stop polling and return it
+*   - falsy/null/undefined → continue polling
+*
+* @param options
+* Configuration options:
+* - `interval` (number) — Time between polls in ms (default: 5000 ms)
+* - `timeout` (number) — Max total duration before failing (default: 5 min)
+* - `jitter` (boolean) — Add small random offset (±10%) to intervals to avoid sync bursts (default: true)
+* - `signal` (AbortSignal) — Optional abort signal to cancel polling
+*
+* @returns
+* Resolves with the truthy value `T` when successful.
+* Throws `AbortError` if aborted
+*
+* @example
+* ```ts
+* const job = await poll(async () => {
+*   const status = await getJobStatus();
+*   return status === 'done' ? status : null;
+* }, { interval: 3000, timeout: 60000 });
+* ```
+*/
+async function poll(cond, { interval = 5e3, timeout = 300 * 1e3, jitter = true, signal } = {}) {
+	const start = Date.now();
+	let aborted = signal?.aborted ?? false;
+	const abortListener = () => {
+		aborted = true;
+	};
+	signal?.addEventListener("abort", abortListener, { once: true });
+	try {
+		for (let attempt = 0;; attempt++) {
+			if (aborted) throw new Error("Polling aborted");
+			const result = await cond();
+			if (result) return result;
+			if (Date.now() - start >= timeout) throw new Error("Polling timed out", { cause: `Polling timed out after ${timeout}ms` });
+			await sleep(jitter ? interval + (Math.random() - .5) * interval * .2 : interval, signal);
+		}
+	} catch (err) {
+		throw err;
+	} finally {
+		signal?.removeEventListener("abort", abortListener);
+	}
+}
+
+//#endregion
+//#region src/functions/schedule.ts
+/**
+* Runs a function asynchronously in the background.
+* Returns immediately, retries on failure if configured.
+* Logs total time taken.
+*/
+function schedule(task, options = {}) {
+	const { retry = 0, delay = 0 } = options;
+	const start = Date.now();
+	const attempt = async (triesLeft) => {
+		try {
+			await task();
+			const total = Date.now() - start;
+			console.log(`⚡[schedule.ts] Completed in ${total}ms`);
+		} catch (err) {
+			console.log("⚡[schedule.ts] err:", err);
+			if (triesLeft > 0) {
+				console.log(`⚡[schedule.ts] Retrying in ${delay}ms...`);
+				setTimeout(() => attempt(triesLeft - 1), delay);
+			} else {
+				const total = Date.now() - start;
+				console.log(`⚡[schedule.ts] Failed after ${total}ms`);
+			}
+		}
+	};
+	setTimeout(() => attempt(retry), 0);
+}
+
+//#endregion
+//#region src/functions/shield.ts
+function shield(operation) {
+	if (operation instanceof Promise) return operation.then((value) => [null, value]).catch((error) => [error, null]);
+	try {
+		return [null, operation()];
+	} catch (error) {
+		console.log(`\x1b[31m🛡 [shield]\x1b[0m ${operation.name} failed →`, error);
+		return [error, null];
+	}
+}
+
+//#endregion
+export { cleanSrc, cn, convertToNormalCase, convertToSlug, copyToClipboard, debounce, deepmerge, deleteClientSideCookie, escapeRegExp, extendProps, getClientSideCookie, getObjectValue, goToClientSideHash, hasClientSideCookie, hydrate, isFalsy, isLinkActive, isNavActive, isNullish, isPlainObject, isPrimitive, isSSR, mergeRefs, normalizeText, poll, printf, schedule, scrollTo, setClientSideCookie, shield, sleep, svgToBase64, throttle };