@putkoff/abstract-utilities 1.0.132 → 1.0.134

package/dist/esm/print_utils-p0I6-E-k.js

@@ -0,0 +1,1624 @@
+import path from 'path';
+import { u as path$1, t as safeGlobalProp } from './safe_storage-BmC80yrG.js';
+import { readFileSync } from 'node:fs';
+import { isAbsolute, resolve } from 'node:path';
+import { inspect } from 'util';
+
+const PROTOCOL = 'https://';
+const DOMAIN_NAME = 'abstractendeavors';
+const BASE_URL = `${PROTOCOL}${DOMAIN_NAME}.com`;
+const SUB_DIR = 'secure-files';
+const PROD_PREFIX = `/${SUB_DIR}/`;
+const API_PREFIX = `/${SUB_DIR}/api`;
+const DEV_PREFIX = `/${SUB_DIR}-dev/`;
+
+function get_window() {
+    try {
+        if (typeof window !== 'undefined') {
+            return window;
+        }
+    }
+    catch (err) {
+        alert(err);
+    }
+    return null;
+}
+function get_window_location() {
+    try {
+        const Window = get_window();
+        if (!Window) {
+            return BASE_URL;
+        }
+        return Window.location;
+    }
+    catch (err) {
+        alert(err);
+    }
+    return null;
+}
+function get_window_pathname() {
+    try {
+        const Window = get_window();
+        if (!Window) {
+            return DEV_PREFIX;
+        }
+        return Window.location.pathname;
+    }
+    catch (err) {
+        alert(err);
+    }
+    return null;
+}
+function get_window_parts() {
+    try {
+        return get_window_location();
+    }
+    catch (err) {
+        alert(err);
+    }
+    return null;
+}
+
+/**
+ * Unwraps nested { result } fields until you hit a non-object or no more "result" keys.
+ */
+function getResult(obj) {
+    let current = obj;
+    while (current &&
+        typeof current === "object" &&
+        Object.prototype.hasOwnProperty.call(current, "result")) {
+        current = current.result;
+    }
+    return current;
+}
+// Determines HTTP method, defaults to GET or POST based on body
+function getMethod(method = null, body = null) {
+    const validMethods = ['GET', 'POST', 'PUT', 'PATCH', 'PULL'];
+    method = (method || '').toUpperCase();
+    if (!validMethods.includes(method)) {
+        method = body ? 'POST' : 'GET';
+    }
+    return method;
+}
+// Gets headers, skips JSON headers when body is FormData
+function getHeaders(headers = {}, method = null, body = null) {
+    const result = { ...headers };
+    // let browser set boundary
+    if (body instanceof FormData) {
+        return result;
+    }
+    const upper = method?.toUpperCase();
+    if (['POST', 'PUT', 'PATCH'].includes(upper ?? '') &&
+        !result['Content-Type']) {
+        result['Content-Type'] = 'application/json';
+    }
+    return result;
+}
+// Prepares request body, serializes to JSON for non-GET requests
+function getBody(body = null, method = null) {
+    method = getMethod(method, body);
+    if (method === 'GET') {
+        return undefined;
+    }
+    if (body) {
+        try {
+            return JSON.stringify(body);
+        }
+        catch (err) {
+            return body;
+        }
+    }
+    return undefined;
+}
+// Prepares fetch variables, passes FormData intact
+function getFetchVars(headers = null, method = null, body = null) {
+    method = getMethod(method, body);
+    headers = getHeaders(headers || {}, method, body);
+    // only JSON-stringify non-FormData bodies
+    if (!(body instanceof FormData)) {
+        body = getBody(body, method);
+    }
+    return { method, headers, body };
+}
+/*
+ * parseResult no longer needs to worry about JSON vs HTML redirect errors;
+ * all 401/403 have already been handled above.
+ */
+async function parseResult(res) {
+    // runs checkResponse first, will throw if session is expired
+    res = checkResponse(res);
+    if (!res.ok) {
+        // for any other non-401 errors, you can still surface them
+        const errorText = await res.text();
+        throw new Error(errorText || res.statusText);
+    }
+    // now safely parse JSON
+    return res.json();
+}
+/**
+ * Intercept 401/403 and force a clean redirect to login
+ * without ever showing an alert.
+ */
+function checkResponse(res) {
+    if (res.status === 401 || res.status === 403) {
+        // 1) clear out the stale token
+        localStorage.removeItem("token");
+        // 2) replace history so "back" doesn’t re-trigger the protected route
+        window.history.replaceState({}, "", "/secure-files");
+        // 3) short-circuit all further fetch logic
+        throw new Error("SessionExpired");
+    }
+    return res;
+}
+
+async function fetchIt(endpoint, body = null, method = null, headers = null, blob = false, configUrl = false, withCredentials = true, returnJson = true, returnReult = true) {
+    method = (method || "GET").toUpperCase();
+    // 2) choose the URL
+    const url = endpoint;
+    // 3) prepare headers & body
+    headers = {
+        ...(body instanceof FormData ? {} : { "Content-Type": "application/json" }),
+        ...headers,
+    };
+    const opts = {
+        method,
+        credentials: withCredentials ? "include" : "same-origin",
+        headers,
+        body: body instanceof FormData
+            ? body
+            : body != null && method !== "GET"
+                ? JSON.stringify(body)
+                : undefined,
+    };
+    console.debug("➡️ secureFetchIt →", url, opts);
+    const res = await fetch(url, opts);
+    if (!res.ok) {
+        const err = await res.text();
+        throw new Error(`HTTP ${res.status}: ${err}`);
+    }
+    if (blob)
+        return res.blob();
+    if (returnReult)
+        return getResult(res.json());
+    if (returnJson)
+        return res.json();
+    return res;
+}
+// Constructs HTML directory path
+function getHtmlDirectory(directory, filename) {
+    return `${directory}/${filename}.html`;
+}
+// Fetches HTML content
+async function fetchIndexHtml(filename, directory = 'sf_index', base = 'html') {
+    const url = `/${base}/${directory}/${filename}.html`;
+    const response = await fetch(url);
+    return await response.text();
+}
+// Fetches and injects HTML content into container
+async function fetchIndexHtmlContainer(filename, doc = document, directory = 'html') {
+    const container = `${filename}-container`;
+    const html = await fetchIndexHtml(filename, directory);
+    const el = doc.getElementById(container);
+    if (el) {
+        el.innerHTML = html;
+    }
+    else {
+        console.warn(`⚠️ No container found for: #${container}`);
+    }
+}
+
+function urlJoin(...parts) {
+    const s = (parts.length === 1 && Array.isArray(parts[0]) ? parts[0] : parts);
+    let r = "";
+    for (let i = 0; i < s.length; i++) {
+        let d = (s[i] ?? "").toString();
+        if (!d)
+            continue;
+        if (i === 0)
+            r = d;
+        else {
+            d = d.replace(/^\/+/, "");
+            r = r.replace(/\/+$/, "");
+            r = `${r}/${d}`;
+        }
+    }
+    return r;
+}
+/**
+ * Returns a full URL.
+ * If partial_url is already absolute (starts with http), it is returned as is.
+ * Otherwise, it is combined with the base URL.
+ */
+function get_full_url(partial_url, domain = null) {
+    if (typeof partial_url !== 'string') {
+        throw new Error('partial_url must be a string');
+    }
+    // If it already starts with http, assume it is absolute.
+    if (partial_url.startsWith('http')) {
+        return partial_url;
+    }
+    return urlJoin(domain, partial_url);
+}
+/**
+ * Returns a full file system path.
+ * If partial_path is already absolute, it is returned as is.
+ * Otherwise, it is joined with the base directory.
+ */
+function get_full_path(partial_path, parent_dir = null) {
+    if (typeof partial_path !== 'string') {
+        throw new Error('partial_path must be a string');
+    }
+    if (path.isAbsolute(partial_path)) {
+        return partial_path;
+    }
+    return urlJoin(parent_dir, partial_path);
+}
+/**
+ * Converts a local file system path into its corresponding URL.
+ * It checks against the known directories in all_paths and replaces the matching base.
+ */
+function path_to_url(filePath, all_paths) {
+    if (typeof filePath !== 'string') {
+        throw new Error('filePath must be a string');
+    }
+    for (const key in all_paths) {
+        const mapping = all_paths[key];
+        const normalizedBase = path.normalize(mapping.path);
+        if (filePath.startsWith(normalizedBase)) {
+            const relativePath = filePath.substring(normalizedBase.length);
+            return urlJoin(mapping.url, relativePath.replace(/\\/g, '/'));
+        }
+    }
+    return null;
+}
+/**
+ * Converts a URL into its corresponding local file system path.
+ * It checks against the known URL prefixes in all_paths and replaces the matching base.
+ */
+function url_to_path(urlStr, all_paths) {
+    if (typeof urlStr !== 'string') {
+        throw new Error('urlStr must be a string');
+    }
+    for (const key in all_paths) {
+        const mapping = all_paths[key];
+        if (urlStr.startsWith(mapping.url)) {
+            const relativeUrl = urlStr.substring(mapping.url.length);
+            return urlJoin(mapping.path, relativeUrl);
+        }
+    }
+    return null;
+}
+function urljoin(...parts) {
+    return urlJoin(...parts);
+}
+
+function split_outside_brackets(s) {
+    let depth = 0;
+    let start = 0;
+    const out = [];
+    for (let i = 0; i < s.length; i++) {
+        const c = s[i];
+        if (c === "[")
+            depth++;
+        else if (c === "]")
+            depth--;
+        // split only when NOT inside brackets
+        if (c === "," && depth === 0) {
+            out.push(s.slice(start, i));
+            start = i + 1;
+        }
+    }
+    out.push(s.slice(start));
+    return out;
+}
+function parse_nested_list(s) {
+    // strip outer brackets
+    const inner = s.slice(1, -1).trim();
+    const parts = split_outside_brackets(inner);
+    const result = [];
+    for (let p of parts) {
+        p = p.trim();
+        if (p.startsWith("[") && p.endsWith("]")) {
+            // recursively parse nested list
+            result.push(parse_nested_list(p));
+        }
+        else {
+            result.push(p);
+        }
+    }
+    return result;
+}
+
+function ensure_list(obj) {
+    if (obj == null)
+        return [];
+    if (Array.isArray(obj)) {
+        return obj.flatMap(item => ensure_list(item));
+    }
+    const s = String(obj).trim();
+    if (s.startsWith("[") && s.endsWith("]")) {
+        return parse_nested_list(s);
+    }
+    return split_outside_brackets(s).map(x => x.trim());
+}
+// coerce any single value into a number (0 if it can't)
+function ensure_number(x) {
+    const n = Number(x);
+    return isNaN(n) ? 0 : n;
+}
+function ensure_string(obj) {
+    return String(obj);
+}
+function ensurelist(obj) {
+    return ensure_list(obj);
+}
+function assureList(obj) {
+    return ensure_list(obj);
+}
+function assure_list(obj) {
+    return ensure_list(obj);
+}
+function ensureList(obj) {
+    return ensure_list(obj);
+}
+function assurelist(obj) {
+    return ensure_list(obj);
+}
+function ensurenumber(x) {
+    return ensure_number(x);
+}
+function assureNumber(x) {
+    return ensure_number(x);
+}
+function ensureNumber(x) {
+    return ensure_number(x);
+}
+function assurenumber(x) {
+    return ensure_number(x);
+}
+function assure_number(x) {
+    return ensure_number(x);
+}
+function ensurestring(obj) {
+    return ensure_string(obj);
+}
+function ensureString(obj) {
+    return ensure_string(obj);
+}
+function assureString(obj) {
+    return ensure_string(obj);
+}
+function assurestring(obj) {
+    return ensure_string(obj);
+}
+function assure_string(obj) {
+    return ensure_string(obj);
+}
+function assurearray(obj) {
+    return ensure_list(obj);
+}
+function ensurearray(obj) {
+    return ensure_list(obj);
+}
+function ensure_array(obj) {
+    return ensure_list(obj);
+}
+function ensureArray(obj) {
+    return ensure_list(obj);
+}
+function assure_array(obj) {
+    return ensure_list(obj);
+}
+function assureArray(obj) {
+    return ensure_list(obj);
+}
+
+function cleanText(input) {
+    // Replace delimiters with spaces and split
+    const str = ensure_string(input);
+    const words = str.replace(/[_.-]/g, ' '); // Replace _, -, . with space
+    return words;
+}
+function cleanArray(obj) {
+    obj = ensure_array(obj);
+    return Array.from(new Set(obj));
+}
+function getCleanArray(obj) {
+    obj = obj.split(/\s+/) // Split on any whitespace
+        .filter((item) => typeof item === 'string' && item !== '');
+    // Get basename
+    // Remove duplicates using Set
+    const uniqueWords = cleanArray(obj);
+    return uniqueWords;
+}
+// Cache a formatter instance for slightly better performance
+const US_DECIMAL_FORMATTER = new Intl.NumberFormat('en-US', {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2,
+});
+function formatNumber(value) {
+    try {
+        // coerce to number
+        const num = Number(value);
+        // if it's NaN or infinite, bail out
+        if (!isFinite(num))
+            return value;
+        return US_DECIMAL_FORMATTER.format(num);
+    }
+    catch {
+        // if anything goes wrong, return the original
+        return value;
+    }
+}
+
+// Constrain T so 'in obj' is allowed
+function get_key_value(obj, key) {
+    // we cast to any for the indexing, since TS can’t infer arbitrary string keys
+    if (key in obj && obj[key] != null) {
+        return obj[key];
+    }
+    return null;
+}
+function get(obj, keys, defaultValue = null) {
+    const keyArray = ensure_array(keys);
+    if (!obj || keyArray.length === 0) {
+        return defaultValue;
+    }
+    for (const key of keyArray) {
+        const val = get_key_value(obj, key);
+        if (val != null) {
+            return val;
+        }
+    }
+    return defaultValue;
+}
+// Create the accountInfo table if it doesn't already exist
+function findKeyValue(obj, keyToFind) {
+    if (keyToFind in obj)
+        return obj[keyToFind];
+    for (const key in obj) {
+        if (typeof obj[key] === 'object' && obj[key] !== null) {
+            const result = findKeyValue(obj[key], keyToFind);
+            if (result !== undefined)
+                return result;
+        }
+    }
+    return undefined;
+}
+function omitKeys(obj, ...keys) {
+    const newObj = { ...obj };
+    keys.forEach(key => {
+        delete newObj[key];
+    });
+    return newObj;
+}
+/**
+* Extracts necessary properties from the insertValue to prevent circular references.
+*
+* @param insertValue - The original RPC result.
+* @returns A new object with only the required properties.
+*/
+function extractInsertData(insertValue) {
+    // Example: Suppose you only need certain fields from the transaction
+    // Modify this function based on your actual data structure
+    if (insertValue && typeof insertValue === 'object') {
+        const { transaction, ...rest } = insertValue; // Exclude 'transaction' property
+        return rest;
+    }
+    return insertValue;
+}
+// Recursive function to load nested JSON
+function loadInnerJson(data) {
+    if (typeof data === 'string') {
+        try {
+            const parsed = JSON.parse(data);
+            return loadInnerJson(parsed);
+        }
+        catch (e) {
+            return data;
+        }
+    }
+    else if (Array.isArray(data)) {
+        return data.map(item => loadInnerJson(item));
+    }
+    else if (typeof data === 'object' && data !== null) {
+        const result = {};
+        for (const key in data) {
+            if (data.hasOwnProperty(key)) {
+                result[key] = loadInnerJson(data[key]);
+            }
+        }
+        return result;
+    }
+    return data;
+}
+
+function isType(obj, type) {
+    if (typeof obj === type) {
+        return true;
+    }
+    return false;
+}
+function isStrInString(obj, string) {
+    const obj_str = ensure_string(obj).toLowerCase;
+    string = ensure_string(string).toLowerCase;
+    if (string.includes(obj_str)) {
+        return true;
+    }
+    return false;
+}
+function getChar(i, string) {
+    if (string.length >= i) {
+        return ensure_string(string)[i];
+    }
+}
+function getAlphaNum(obj) {
+    const is_num = isNum(obj);
+    const alphas = getAlphas();
+    if (is_num) {
+        return getChar(obj, alphas);
+    }
+    if (isStrInString(obj, alphas)) {
+        return getChar(obj, alphas);
+    }
+}
+function getNums() {
+    return '0123456789';
+}
+function isNum(obj) {
+    return !Number.isNaN(Number(obj));
+}
+function getAlphas() {
+    return 'abcdefghijklmnopqrstuvwxyz';
+}
+
+// Function to handle undefined or null values
+function getIfNone(obj, fallback) {
+    return obj !== undefined && obj !== null && obj !== '' ? obj : fallback;
+}
+/**
+ * Merges non-null values from multiple dictionaries.
+ */
+function mergeNotNullValues(dictA, dictB, dictC, dictD, dictE) {
+    const result = {};
+    for (const key of Object.keys(dictA)) {
+        result[key] = dictA[key] ?? dictB?.[key] ?? dictC?.[key] ?? dictD?.[key] ?? dictE?.[key];
+    }
+    return result;
+}
+/**
+ * Converts an empty object to null.
+ */
+function emptyObjectToNull(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length === 0 ? null : value;
+}
+
+function getSubstring(obj, maxLength = null, minLength = null) {
+    const objLength = obj.length;
+    const effectiveMaxLength = maxLength ?? objLength; // Use nullish coalescing for clarity
+    const effectiveMinLength = minLength ?? 0;
+    // Ensure bounds are valid
+    const clampedMaxLength = Math.min(Math.max(effectiveMaxLength, 0), objLength);
+    const clampedMinLength = Math.min(Math.max(effectiveMinLength, 0), objLength);
+    // If minLength exceeds maxLength, return empty string or adjust logic as needed
+    if (clampedMinLength >= clampedMaxLength) {
+        return '';
+    }
+    return obj.substring(clampedMinLength, clampedMaxLength);
+}
+/**
+ * Sanitize a string by removing null bytes and trimming whitespace.
+ */
+function sanitizeString(input) {
+    if (!input)
+        return input;
+    return input.replace(/\u0000/g, "").trim(); // Remove null bytes and whitespace
+}
+function truncateString(obj, maxLength = 20) {
+    const objLength = obj.length;
+    if (objLength > maxLength && maxLength) {
+        obj = getSubstring(obj, maxLength) + '...';
+    }
+    return obj;
+}
+function capitalize_str(string) {
+    string = assureString(string);
+    const string_len = string.length;
+    let init_char = string.toUpperCase();
+    if (string_len > 0) {
+        init_char = string[0].toUpperCase();
+    }
+    let rest_chars = '';
+    if (string_len > 1) {
+        rest_chars = string.slice(1).toLowerCase();
+    }
+    const fin_chars = `${init_char}${rest_chars}`;
+    return fin_chars;
+}
+function capitalize(string) {
+    let nu_string = '';
+    string = assureString(string);
+    const objs = string.replace('-', '_').split('_');
+    for (const obj of objs) {
+        const str_obj = capitalize_str(obj);
+        nu_string = `${nu_string} ${str_obj}`;
+    }
+    return eatAll(nu_string, [' ']);
+}
+// string_utils/src/string_utils.ts
+function stripPrefixes(str, bases = []) {
+    /* NEW: coerce whatever arrives into a string */
+    str = String(str);
+    const prefixes = (Array.isArray(bases) ? bases : [bases])
+        .filter(Boolean)
+        .sort((a, b) => b.length - a.length); // longest first
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const prefix of prefixes) {
+            if (str.startsWith(prefix)) {
+                str = str.slice(prefix.length);
+                changed = true;
+                break; // restart from longest prefix
+            }
+        }
+    }
+    return str;
+}
+function tryEatPrefix(str, length, ...objs) {
+    str = String(str);
+    objs = ensure_list(objs);
+    const prefix = str.slice(0, length);
+    if (length < 0) {
+        const start = str.length + length;
+        const actualPrefix = str.slice(start);
+        return objs.includes(actualPrefix) ? [str.slice(0, start), true] : [str, false];
+    }
+    if (objs.includes(prefix)) {
+        return [str.slice(length), true];
+    }
+    return [str, false];
+}
+/** Python-equivalent eatInner */
+function eatInner(str, listObjects) {
+    str = String(str);
+    const chars = Array.isArray(listObjects) ? listObjects : [listObjects];
+    // Keep removing from left while leftmost char is in the set
+    while (str.length > 0 && chars.includes(str[0])) {
+        str = str.slice(1);
+    }
+    return str;
+}
+/** Python-equivalent eatOuter */
+function eatOuter(str, listObjects) {
+    str = String(str);
+    const chars = Array.isArray(listObjects) ? listObjects : [listObjects];
+    if (!str || chars.length === 0)
+        return str;
+    for (let i = 0; i < str.length; i++) {
+        if (!str)
+            return str;
+        const last = str[str.length - 1];
+        if (!chars.includes(last)) {
+            return str;
+        }
+        str = str.slice(0, -1);
+    }
+    return str;
+}
+/** Python-equivalent eatAll */
+function eatAll(str, listObjects) {
+    str = String(str);
+    const chars = Array.isArray(listObjects) ? listObjects : [listObjects];
+    str = eatInner(str, chars);
+    str = eatOuter(str, chars);
+    return str;
+}
+// Plug in the actual version from your project
+function get_alpha_ints(opts) {
+    // REPLACE WITH YOUR REAL IMPLEMENTATION
+    return [];
+}
+/** Python-equivalent eatElse */
+function eatElse(stringObj, chars, ints = true, alpha = true, lower = true, capitalize = true, string = true, listObj = true) {
+    stringObj = String(stringObj);
+    const alphaInts = get_alpha_ints();
+    const ls = ensure_list(chars || []).concat(alphaInts);
+    while (true) {
+        if (!stringObj)
+            return stringObj;
+        const startOk = !ls.includes(stringObj[0]);
+        const endOk = !ls.includes(stringObj[stringObj.length - 1]);
+        const shouldEat = startOk || endOk;
+        if (!shouldEat)
+            return stringObj;
+        if (stringObj && startOk) {
+            stringObj = stringObj.length === 1 ? "" : stringObj.slice(1);
+        }
+        if (stringObj && endOk) {
+            stringObj = stringObj.length === 1 ? "" : stringObj.slice(0, -1);
+        }
+    }
+}
+function tryParse(obj) {
+    try {
+        obj = JSON.stringify(obj);
+    }
+    catch (err) {
+        try {
+            obj = JSON.parse(obj);
+        }
+        catch (err) {
+        }
+    }
+    return obj;
+}
+function create_list_string(array_obj) {
+    let string = '';
+    for (const obj in array_obj) {
+        const array_value = array_obj[obj];
+        const parsed_value = tryParse(array_value);
+        string += `${obj} == ${parsed_value}\n`;
+    }
+    return string;
+}
+function eatall(str, listObjects) {
+    return eatAll(str, listObjects);
+}
+function eatinner(str, listObjects) {
+    return eatInner(str, listObjects);
+}
+function eatouter(str, listObjects) {
+    return eatOuter(str, listObjects);
+}
+
+/**
+ * Checks if a value is enclosed in quotes.
+ */
+function ends_in_quotes(value) {
+    if (typeof value === 'string') {
+        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+            return true;
+        }
+    }
+    return false;
+}
+function stripQuotes(value) {
+    if (ends_in_quotes(value)) {
+        return value.slice(1, -1); // Remove the first and last characters
+    }
+    return value; // Return the input unchanged for all other cases
+}
+
+/**
+ * In the browser we already have a WHATWG URL constructor on window.
+ * Here we re-export it as “url” so other modules can import it.
+ */
+/**
+ * Minimal fileURLToPath implementation for browser-side code.
+ * If you only ever need to strip off “file://” in development, this is enough.
+ */
+function fileURLToPath(fileUrl) {
+    // e.g. fileUrl = "file:///Users/foo/bar.txt"
+    try {
+        const u = new URL(fileUrl);
+        return u.pathname;
+    }
+    catch {
+        // fallback: just strip file://
+        return fileUrl.replace(/^file:\/\//, '');
+    }
+}
+function getAbsolutePath() {
+    return fileURLToPath(import.meta.url);
+}
+
+function get_dirname(filePath) {
+    if (!filePath)
+        return '';
+    return path$1.dirname(filePath);
+}
+function get_basename(filePath) {
+    if (!filePath)
+        return '';
+    return path$1.basename(filePath);
+}
+function get_filename(filePath) {
+    if (!filePath)
+        return '';
+    const ext = path$1.extname(filePath);
+    return path$1.basename(filePath, ext);
+}
+function get_extname(filePath) {
+    if (!filePath)
+        return '';
+    return path$1.extname(filePath);
+}
+function get_splitext(filePath) {
+    if (!filePath)
+        return { filename: '', extname: '' };
+    const ext = path$1.extname(filePath);
+    // Get the basename without the extension
+    const filename = path$1.basename(filePath, ext);
+    return { filename, ext };
+}
+/**
+ * Returns the path of `targetPath` relative to `basePath`.
+ * Normalizes separators for consistent web and server environments.
+ *
+ * @param basePath - The base directory you want to compare from.
+ * @param targetPath - The full path of the file/directory.
+ * @returns A normalized relative path (e.g., "subdir/file.txt").
+ */
+function get_relative_path(basePath, targetPath) {
+    try {
+        // Compute the relative path using Node's native path.relative
+        let rel = path$1.relative(basePath, targetPath);
+        // Normalize to POSIX-style slashes for consistency (especially on Windows)
+        rel = rel.split(path$1.sep).join('/');
+        // Avoid empty string (happens if both paths are identical)
+        return rel || '.';
+    }
+    catch (err) {
+        console.error(`[get_relative_path] Error computing relative path`, err);
+        return targetPath;
+    }
+}
+/**
+ * Join multiple path segments — clean, predictable, bulletproof.
+ *
+ * Accepts ANYTHING that ensure_list can handle:
+ *   • 'a,b,c'
+ *   • ['a', 'b,c']
+ *   • 'a/b/c'
+ *   • '/a/', 'b//c'
+ *   • mixed arrays, comma strings, whatever
+ *
+ * Always returns a clean POSIX path string. Never a list.
+ */
+function make_path(...parts) {
+    // Normalize incoming segments into a flat list
+    const segments = ensure_list(parts).map(x => String(x));
+    let out = "";
+    for (let i = 0; i < segments.length; i++) {
+        const seg = segments[i];
+        // Normalize a segment:
+        let cleaned = eatOuter(seg, "/"); // trim trailing slashes
+        if (!cleaned)
+            continue;
+        if (out === "") {
+            out = cleaned;
+        }
+        else {
+            cleaned = eatInner(cleaned, "/"); // trim leading slashes
+            out = `${out}/${cleaned}`;
+        }
+    }
+    return out;
+}
+function sanitizeFilename(filename) {
+    return filename
+        .toLowerCase()
+        .replace(/\s+|-/g, '-') // Replace spaces and hyphens with single hyphen
+        .replace(/_/g, '-') // Replace underscores with hyphens
+        .replace(/[^a-z0-9-.]/g, '') // Remove all non-alphanumeric chars except hyphen and dot
+        .replace(/-+/g, '-') // Collapse multiple hyphens into one
+        .replace(/^-|-$/, ''); // Remove leading/trailing hyphens
+}
+function make_sanitized_path(...paths) {
+    let real_path = '';
+    for (let i = 0; i < paths.length; i++) {
+        const sanitized = sanitizeFilename(eatOuter(paths[i], '/'));
+        if (i === 0) {
+            real_path = sanitized;
+        }
+        else if (sanitized) { // Only append if there's a non-empty segment
+            real_path = `${real_path}/${sanitized}`;
+        }
+    }
+    return real_path || '';
+}
+function normalizeUrl(base, p) {
+    if (!p)
+        return base;
+    const cleanBase = base.replace(/\/+$/, ''); // regex literal
+    const cleanPath = p.replace(/^\/+/, '');
+    // collapse multiple “//” into one, but keep the “://” after protocol
+    return `${cleanBase}/${cleanPath}`.replace(/([^:])\/{2,}/g, '$1/');
+}
+function pathjoin(...parts) {
+    return make_path(...parts);
+}
+function pathJoin(...parts) {
+    return make_path(...parts);
+}
+function makepath(...parts) {
+    return make_path(...parts);
+}
+function makePath(...parts) {
+    return make_path(...parts);
+}
+function path_join(...parts) {
+    return make_path(...parts);
+}
+function getSplitext(filePath) {
+    return get_splitext(filePath);
+}
+function getsplitext(filePath) {
+    return get_splitext(filePath);
+}
+function getextname(filePath) {
+    return get_extname(filePath);
+}
+function getExtname(filePath) {
+    return get_extname(filePath);
+}
+function getfilename(filePath) {
+    return get_filename(filePath);
+}
+function getFilename(filePath) {
+    return get_filename(filePath);
+}
+function getbasename(filePath) {
+    return get_basename(filePath);
+}
+function getBasename(filePath) {
+    return get_basename(filePath);
+}
+function getdirname(filePath) {
+    return get_dirname(filePath);
+}
+function getDirname(filePath) {
+    return get_dirname(filePath);
+}
+
+/**
+ * Returns the absolute path of the current file.
+ */
+function getAbsDir() {
+    return get_dirname(getAbsolutePath());
+}
+function getAbsPath(subPath) {
+    return make_path(getAbsDir(), subPath);
+}
+
+function getFunctionsDir() {
+    return get_dirname(getAbsDir());
+}
+function geAuthsUtilsDirectory() {
+    return make_path(getFunctionsDir(), 'auths');
+}
+function geBackupsUtilsDirectory() {
+    return make_path(getFunctionsDir(), 'backups');
+}
+function geConstantsUtilsDirectory() {
+    return make_path(getFunctionsDir(), 'constants');
+}
+function geEnvUtilsDirectory() {
+    return make_path(getFunctionsDir(), 'env_utils');
+}
+function geFetchUtilsDirectory() {
+    return make_path(getFunctionsDir(), 'fetch_utils');
+}
+function geFileUtilsDirectory() {
+    return make_path(getFunctionsDir(), 'file_utils');
+}
+function gePathUtilsDirectory() {
+    return make_path(getFunctionsDir(), 'path_utils');
+}
+function geStringUtilsDirectory() {
+    return make_path(getFunctionsDir(), 'string_utils');
+}
+function geTypeUtilsDirectory() {
+    return make_path(getFunctionsDir(), 'type_utils');
+}
+
+function getSrcDir() {
+    return get_dirname(getFunctionsDir());
+}
+function geStaticDirectory() {
+    return make_path(getSrcDir(), 'static');
+}
+function getLibUtilsDirectory() {
+    return make_path(getSrcDir(), 'lib');
+}
+function getHooksUtilsDirectory() {
+    return make_path(getSrcDir(), 'hooks');
+}
+function getFunctionsUtilsDirectory() {
+    return make_path(getSrcDir(), 'functions');
+}
+function getComponentsUtilsDirectory() {
+    return make_path(getSrcDir(), 'components');
+}
+
+function getBaseDir() {
+    return get_dirname(getSrcDir());
+}
+function getPublicDir() {
+    return make_path(getBaseDir(), 'public');
+}
+function getDistDir() {
+    return make_path(getBaseDir(), 'dist');
+}
+function getEnvDir() {
+    return make_path(getBaseDir(), '.env');
+}
+
+function getEnvPath(string = '.env') {
+    return make_path(getEnvDir(), string);
+}
+function getDbConfigsPath() {
+    return make_path(getBaseDir(), 'dbConfigs');
+}
+function getSchemasPath() {
+    return make_path(getDbConfigsPath(), 'schemas');
+}
+function getSchemasDirPath(subPath) {
+    return make_path(getSchemasPath(), subPath);
+}
+
+// src/functions/rndm_utils/utils.ts
+function alertit(obj = null) {
+    let msg;
+    try {
+        msg = JSON.stringify(obj);
+    }
+    catch {
+        // If JSON.stringify fails (circular refs, etc.), fall back to a simple string
+        msg = String(obj);
+    }
+    alert(msg);
+}
+
+// take N args and coerce them all to numbers
+function safeNums(...args) {
+    return args.map(ensure_number);
+}
+// divide the first value by each of the following
+function safeAdd(...args) {
+    const [head, ...rest] = safeNums(...args);
+    // if we don’t have a head or any divisor is zero, bail
+    return rest.reduce((acc, d) => acc + d, head);
+}
+// divide the first value by each of the following
+function safeSubtract(...args) {
+    const [head, ...rest] = safeNums(...args);
+    // if we don’t have a head or any divisor is zero, bail
+    return rest.reduce((acc, d) => acc - d, head);
+}
+// divide the first value by each of the following
+function safeDivide(...args) {
+    const [head, ...rest] = safeNums(...args);
+    // if we don’t have a head or any divisor is zero, bail
+    if (head === 0 || rest.some((d) => d === 0))
+        return 0;
+    return rest.reduce((acc, d) => acc / d, head);
+}
+// multiply all the values together
+function safeMultiply(...args) {
+    const nums = safeNums(...args);
+    // if any number is zero, result is zero
+    if (nums.includes(0))
+        return 0;
+    return nums.reduce((acc, n) => acc * n, 1);
+}
+// round a value to two decimals by percent
+function roundPercentage(x) {
+    const pct = safeMultiply(ensure_number(x), 100);
+    return safeDivide(Math.round(pct), 100);
+}
+function exponential(i, k) {
+    return i * (10 ** (k));
+}
+function isZero(obj) {
+    if (obj == 0) {
+        return true;
+    }
+    return false;
+}
+
+const SECOND = 1;
+const ZEPTOSECOND = exponential(SECOND, -21);
+const ATTOSECOND = exponential(SECOND, -18);
+const FEMTOSECOND = exponential(SECOND, -15);
+const PICOSECOND = exponential(SECOND, -12);
+const NANOSECOND = exponential(SECOND, -9);
+const MICROSECOND = exponential(SECOND, -6);
+const MILISECOND = exponential(SECOND, -3);
+const CENTISECOND = exponential(SECOND, -2);
+const DECISECOND = exponential(SECOND, -1);
+const MINUTE = 60 * SECOND;
+const HOUR = 60 * MINUTE;
+const DAY = 24 * HOUR;
+const YEAR = 365 * DAY;
+const MONTH = YEAR / 12;
+// Derived: explicit names
+const SECONDS_PER_MINUTE = MINUTE;
+const SECONDS_PER_HOUR = HOUR;
+const SECONDS_PER_DAY = DAY;
+//math
+const PI = Math.PI;
+const PI2 = 2 * PI;
+// Distance
+const METERS_PER_KM = 1000;
+const METERS_PER_MILE = 1609.34;
+const METERS_PER_FOOT = 0.3048;
+const KMS_PER_METER = 1 / METERS_PER_KM;
+const MILES_PER_METER = 1 / METERS_PER_MILE;
+const FEET_PER_METER = 1 / METERS_PER_FOOT;
+const MIN_IN_S = 1 / MINUTE;
+const HOUR_IN_S = 1 / HOUR;
+const DAY_IN_S = 1 / DAY;
+const YEAR_IN_S = 1 / YEAR;
+const MONTH_IN_S = 1 / MONTH;
+const MiPerH_TO_MPerS = METERS_PER_MILE * HOUR_IN_S;
+const MPerS_TO_MiPerH = 1 / MiPerH_TO_MPerS;
+
+// conversions.ts
+/*───────────────────────────────────────────────────────────────
+  🧭 CANONICAL MAPPINGS
+───────────────────────────────────────────────────────────────*/
+const DIST_ALIASES = {
+    m: "m", meter: "m", meters: "m",
+    km: "km", kms: "km", kilometer: "km", kilometers: "km",
+    mi: "mi", mile: "mi", miles: "mi",
+    ft: "ft", f: "ft", foot: "ft", feet: "ft",
+};
+const TIME_ALIASES = {
+    s: "s", sec: "s", second: "s", seconds: "s",
+    min: "min", m: "min", minute: "min", minutes: "min",
+    h: "h", hr: "h", hour: "h", hours: "h",
+    day: "day", d: "day", days: "day",
+};
+const DIST_FACTORS = {
+    m: 1,
+    km: METERS_PER_KM,
+    mi: METERS_PER_MILE,
+    ft: METERS_PER_FOOT,
+};
+const TIME_FACTORS = {
+    s: 1,
+    min: MINUTE,
+    h: HOUR,
+    day: DAY,
+};
+/*───────────────────────────────────────────────────────────────
+  🔍 CANONICALIZATION HELPERS
+───────────────────────────────────────────────────────────────*/
+function canonDist(u) {
+    const key = (u ?? "m").toString().toLowerCase();
+    const canon = DIST_ALIASES[key];
+    if (!canon)
+        throw new Error(`Unknown distance unit: ${u}`);
+    return canon;
+}
+function canonTime(u) {
+    const key = (u ?? "s").toString().toLowerCase();
+    const canon = TIME_ALIASES[key];
+    if (!canon)
+        throw new Error(`Unknown time unit: ${u}`);
+    return canon;
+}
+/*───────────────────────────────────────────────────────────────
+  ⚖️ NORMALIZATION HELPERS
+───────────────────────────────────────────────────────────────*/
+function distanceToMeters(d, unit) {
+    const u = canonDist(unit);
+    return safeMultiply(d, DIST_FACTORS[u]);
+}
+function metersToDistance(v, unit) {
+    const u = canonDist(unit);
+    return safeDivide(v, DIST_FACTORS[u]);
+}
+function timeToSeconds(t, unit) {
+    const u = canonTime(unit);
+    return safeMultiply(t, TIME_FACTORS[u]);
+}
+function secondsToTime(v, unit) {
+    const u = canonTime(unit);
+    return safeDivide(v, TIME_FACTORS[u]);
+}
+/*───────────────────────────────────────────────────────────────
+  🚀 SPEED CONVERSIONS (normalize / unnormalize)
+───────────────────────────────────────────────────────────────*/
+function speedToMps(v, distUnit, timeUnit) {
+    const du = canonDist(distUnit);
+    const tu = canonTime(timeUnit);
+    return v * (DIST_FACTORS[du] / TIME_FACTORS[tu]);
+}
+function mpsToSpeed(vMps, distUnit, timeUnit) {
+    const du = canonDist(distUnit);
+    const tu = canonTime(timeUnit);
+    return vMps * (TIME_FACTORS[tu] / DIST_FACTORS[du]);
+}
+/*───────────────────────────────────────────────────────────────
+  🎯 UNIVERSAL CONVERTERS
+───────────────────────────────────────────────────────────────*/
+function convertDistance({ d, fromDist, toDist, vOnly = true, }) {
+    const m = distanceToMeters(d, fromDist);
+    const D = canonDist(toDist ?? "m");
+    const out = metersToDistance(m, D);
+    return vOnly ? out : { d: out, D };
+}
+function convertTime({ t, fromTime, toTime, vOnly = true, }) {
+    const sec = timeToSeconds(t, fromTime);
+    const T = canonTime(toTime ?? "s");
+    const out = secondsToTime(sec, T);
+    return vOnly ? out : { t: out, T };
+}
+function convertSpeed({ v, fromDist, fromTime, toDist, toTime, vOnly = true, }) {
+    const mps = speedToMps(v, fromDist, fromTime);
+    const d = canonDist(toDist ?? "m");
+    const t = canonTime(toTime ?? "s");
+    const out = mpsToSpeed(mps, d, t);
+    return vOnly ? out : { v: out, d, t };
+}
+const DistanceConverter = {
+    normalize: distanceToMeters,
+    unnormalize: metersToDistance,
+};
+const TimeConverter = {
+    normalize: timeToSeconds,
+    unnormalize: secondsToTime,
+};
+const SpeedConverter = {
+    normalize: (v, [du, tu]) => speedToMps(v, du, tu),
+    unnormalize: (v, [du, tu]) => mpsToSpeed(v, du, tu),
+};
+/*───────────────────────────────────────────────────────────────
+  🧩 COMPATIBILITY WRAPPERS (legacy aliases)
+───────────────────────────────────────────────────────────────*/
+const toMeters = distanceToMeters;
+const fromMeters = metersToDistance;
+const toSeconds = timeToSeconds;
+const fromSeconds = secondsToTime;
+const velocityToMs = (value, unit) => speedToMps(value, unit, "s");
+const velocityFromMs = (value, unit) => mpsToSpeed(value, unit, "s");
+/** Non-canonical helper for arbitrary rate conversion, e.g. ft/day → m/s */
+const fromMps = (v, dist_unit, time_unit) => mpsToSpeed(v, dist_unit, time_unit);
+/*───────────────────────────────────────────────────────────────
+  📊 UTILITIES
+───────────────────────────────────────────────────────────────*/
+const isFiniteNum = (x) => Number.isFinite(x);
+const fmt = (n, digits = 2) => isFiniteNum(n) ? n.toFixed(digits) : "N/A";
+
+// Function to check time interval
+function isTimeInterval(timeObj, interval) {
+    return (Date.now() / 1000 - timeObj) < (interval - 1);
+}
+
+/**
+ * Recursively traverse the object and convert BigInts to numbers or strings.
+ *
+ * @param {object|array} obj - The object to traverse
+ * @param {boolean} convertToNumber - Whether to convert BigInt to Number (default is true)
+ * @returns {object|array} - The transformed object
+ */
+function convertBigInts(obj, convertToNumber = true) {
+    if (obj === null || obj === undefined)
+        return obj;
+    try {
+        if (typeof obj === 'bigint') {
+            return convertToNumber ? Number(obj) : obj.toString();
+        }
+        if (typeof obj === 'object') {
+            if (Array.isArray(obj)) {
+                return obj.map((item) => convertBigInts(item, convertToNumber));
+            }
+            return Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, convertBigInts(value, convertToNumber)]));
+        }
+    }
+    catch (error) {
+    }
+    return obj;
+}
+
+function getSafeDocument() {
+    return typeof document !== 'undefined' ? document : undefined;
+}
+function getDocumentProp(...keys) {
+    let obj = getSafeDocument();
+    for (const k of keys) {
+        if (obj == null || typeof obj !== 'object')
+            return undefined;
+        obj = obj[k];
+    }
+    return obj;
+}
+
+/**
+ * Returns the global window object if it exists, otherwise undefined.
+ */
+function getSafeWindow() {
+    return typeof window !== 'undefined' ? window : undefined;
+}
+/**
+ * Safely call a method on window by name.
+ *
+ * @param method  The Window method to call (e.g. "alert", "open", etc.).
+ * @param args    Arguments to pass to that method.
+ * @returns       The method’s return value, or undefined if
+ *                 window/method isn’t available or throws.
+ */
+function callWindowMethod(method, ...args) {
+    const w = getSafeWindow();
+    if (!w)
+        return undefined;
+    const fn = w[method];
+    if (typeof fn !== 'function')
+        return undefined;
+    try {
+        // cast to any so TS doesn’t complain about apply/invoke
+        return fn(...args);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** implementation */
+function getWindowProp(...keys) {
+    let obj = getSafeWindow();
+    for (const k of keys) {
+        if (obj == null || typeof obj !== 'object')
+            return undefined;
+        obj = obj[k];
+    }
+    return obj;
+}
+function getWindowHost() {
+    return getWindowProp('location', 'host');
+}
+
+async function readJsonFileBrowser(url) {
+    const fetchFn = safeGlobalProp("fetch");
+    if (typeof fetchFn !== "function")
+        return null;
+    try {
+        const res = await fetchFn(url);
+        if (!res.ok)
+            return null;
+        return (await res.json());
+    }
+    catch {
+        return null;
+    }
+}
+
+var readJsonFile_browser = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    readJsonFileBrowser: readJsonFileBrowser
+});
+
+function readJsonFileNode(relativeOrAbsolutePath) {
+    try {
+        const filePath = isAbsolute(relativeOrAbsolutePath)
+            ? relativeOrAbsolutePath
+            : resolve(process.cwd(), relativeOrAbsolutePath);
+        return JSON.parse(readFileSync(filePath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+
+var readJsonFile_node = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    readJsonFileNode: readJsonFileNode
+});
+
+async function readJsonFile(relativeOrAbsolutePath) {
+    if (typeof process !== "undefined" && process.versions?.node) {
+        const mod = await Promise.resolve().then(function () { return readJsonFile_node; });
+        return mod.readJsonFileNode(relativeOrAbsolutePath);
+    }
+    else {
+        const mod = await Promise.resolve().then(function () { return readJsonFile_browser; });
+        return mod.readJsonFileBrowser(relativeOrAbsolutePath);
+    }
+}
+async function getConfigContent() {
+    try {
+        // `readJsonFile` should throw if the file isn’t there or isn’t valid JSON
+        const cfg = await readJsonFile('./config.json');
+        return cfg;
+    }
+    catch {
+        // swallow errors & return null so callers can detect “no config”
+        return null;
+    }
+}
+
+// src/functions/config_utils/src/config_utils.ts
+let _cachedConfig = null;
+async function loadConfig(filePath = null) {
+    if (_cachedConfig) {
+        return _cachedConfig;
+    }
+    // 1) figure out where config.json lives
+    let configUrl;
+    if (filePath) {
+        configUrl = filePath;
+    }
+    else if (typeof import.meta !== 'undefined' && typeof import.meta.url === 'string') {
+        // ES module: resolve relative to this file
+        try {
+            const mod = await (new Function("return import('./config.json').catch(() => ({}))"))();
+            _cachedConfig = mod.default ?? {};
+            return _cachedConfig;
+        }
+        catch {
+            configUrl = 'config.json';
+        }
+    }
+    else {
+        // browser fallback
+        const baseURI = safeGlobalProp('document', 'baseURI');
+        try {
+            configUrl =
+                typeof baseURI === 'string'
+                    ? new URL('config.json', baseURI).href
+                    : 'config.json';
+        }
+        catch {
+            configUrl = 'config.json';
+        }
+    }
+    // 2) if we have a fetch, try HTTP(S)
+    const fetchFn = safeGlobalProp('fetch');
+    if (typeof fetchFn === 'function') {
+        try {
+            const res = await fetchFn(configUrl);
+            if (res.ok) {
+                const json = await res.json();
+                // cache & return
+                _cachedConfig = json ?? {};
+                return _cachedConfig;
+            }
+        }
+        catch {
+            /* swallow */
+        }
+    }
+    // 3) Node fallback: try reading from disk (requires your readJsonFile util)
+    try {
+        const disk = await readJsonFile(configUrl);
+        _cachedConfig = disk ?? {};
+        return _cachedConfig;
+    }
+    catch {
+        /* swallow */
+    }
+    // 4) if all else fails, return an empty config
+    _cachedConfig = {};
+    return _cachedConfig;
+}
+async function getConfig(key) {
+    const cfg = await loadConfig();
+    return key != null ? cfg[key] : cfg;
+}
+
+/**
+ * Processes keywords by checking if keywords is a string and splitting it.
+ * Then cleans each keyword using `eatAll` with a set of characters to remove.
+ *
+ * @param keywords - The keywords as a comma-separated string or as an array.
+ * @returns An array of cleaned keywords.
+ */
+function processKeywords(keywords) {
+    let keywordArray;
+    // If keywords is a string, split it on commas
+    if (typeof keywords === "string") {
+        keywordArray = keywords.split(",");
+    }
+    else {
+        keywordArray = keywords;
+    }
+    // Clean each keyword by removing unwanted characters
+    return keywordArray.map(keyword => eatAll(keyword, [",", "\n", "\t", " ", "#"]));
+}
+/**
+ * Constructs a keyword string where each keyword is prefixed with a hash (#).
+ *
+ * @param keywords - An array of keywords.
+ * @returns A string with each keyword prefixed by '#'.
+ */
+function get_keyword_string(keywords) {
+    keywords = processKeywords(keywords);
+    let allString = "";
+    for (const keyword of keywords) {
+        allString += ` #${keyword}`;
+    }
+    return allString;
+}
+
+// Function to compare MB
+function exceedsMbLimit(limitMb, payloadMb) {
+    return payloadMb > limitMb;
+}
+function safeJsonSizeInMb(value) {
+    const seen = new WeakSet();
+    const json = JSON.stringify(value, (_, v) => {
+        if (typeof v === "bigint")
+            return v.toString();
+        if (typeof v === "object" && v !== null) {
+            if (seen.has(v))
+                return "[Circular]";
+            seen.add(v);
+        }
+        return v;
+    });
+    return Buffer.byteLength(json, "utf8") / (1024 * 1024);
+}
+function dataSizeInMb(data) {
+    const size = typeof data === "string"
+        ? Buffer.byteLength(data, "utf8")
+        : Buffer.byteLength(JSON.stringify(data), "utf8");
+    return size / (1024 * 1024);
+}
+function getJsonSizeInMb(json) {
+    return Buffer.byteLength(JSON.stringify(json), "utf8") / (1024 * 1024);
+}
+// Function to calculate data size in KB
+function dataSize(data) {
+    let size = 0;
+    if (typeof data === 'string') {
+        size = Buffer.byteLength(data, 'utf8');
+    }
+    else if (Buffer.isBuffer(data)) {
+        size = data.length;
+    }
+    else if (typeof data === 'object') {
+        size = Buffer.byteLength(JSON.stringify(data), 'utf8');
+    }
+    else {
+        size = Buffer.byteLength(String(data), 'utf8');
+    }
+    return size / 1000; // Convert to kilobytes
+}
+
+function getLastCaller(skip = ["debugPrint"]) {
+    const stack = new Error().stack;
+    if (!stack)
+        return null;
+    const lines = stack
+        .split("\n")
+        .map(l => l.trim())
+        .slice(1); // drop "Error"
+    for (const line of lines) {
+        // Example:
+        // at processSingleAddress (/path/file.ts:142:7)
+        const match = line.match(/at (.+?) \((.+?):(\d+):(\d+)\)/) ||
+            line.match(/at (.+?):(\d+):(\d+)/);
+        if (!match)
+            continue;
+        const functionName = match[1] ?? "anonymous";
+        if (skip.includes(functionName))
+            continue;
+        return {
+            functionName,
+            file: match[2],
+            line: Number(match[3]),
+            column: Number(match[4]),
+        };
+    }
+    return null;
+}
+
+function debugPrint(value, label = null) {
+    const caller = getLastCaller();
+    const header = label ??
+        (caller
+            ? `${caller.functionName} @ ${caller.file}:${caller.line}`
+            : "object");
+    console.log(`\n🔍 ${header}`);
+    console.log(inspect(value, {
+        depth: null,
+        colors: true,
+        compact: false,
+        maxArrayLength: null,
+    }));
+}
+
+export { getAbsDir as $, API_PREFIX as A, BASE_URL as B, get_extname as C, DOMAIN_NAME as D, get_splitext as E, get_relative_path as F, make_path as G, sanitizeFilename as H, make_sanitized_path as I, normalizeUrl as J, pathjoin as K, pathJoin as L, makepath as M, makePath as N, path_join as O, PROTOCOL as P, getSplitext as Q, getsplitext as R, SUB_DIR as S, getextname as T, getExtname as U, getfilename as V, getFilename as W, getbasename as X, getBasename as Y, getdirname as Z, getDirname as _, PROD_PREFIX as a, mpsToSpeed as a$, getAbsPath as a0, getFunctionsDir as a1, geAuthsUtilsDirectory as a2, geBackupsUtilsDirectory as a3, geConstantsUtilsDirectory as a4, geEnvUtilsDirectory as a5, geFetchUtilsDirectory as a6, geFileUtilsDirectory as a7, gePathUtilsDirectory as a8, geStringUtilsDirectory as a9, eatElse as aA, tryParse as aB, create_list_string as aC, eatall as aD, eatinner as aE, eatouter as aF, ends_in_quotes as aG, stripQuotes as aH, safeNums as aI, safeAdd as aJ, safeSubtract as aK, safeDivide as aL, safeMultiply as aM, roundPercentage as aN, exponential as aO, isZero as aP, DIST_ALIASES as aQ, TIME_ALIASES as aR, DIST_FACTORS as aS, TIME_FACTORS as aT, canonDist as aU, canonTime as aV, distanceToMeters as aW, metersToDistance as aX, timeToSeconds as aY, secondsToTime as aZ, speedToMps as a_, geTypeUtilsDirectory as aa, getSrcDir as ab, geStaticDirectory as ac, getLibUtilsDirectory as ad, getHooksUtilsDirectory as ae, getFunctionsUtilsDirectory as af, getComponentsUtilsDirectory as ag, getBaseDir as ah, getPublicDir as ai, getDistDir as aj, getEnvDir as ak, getEnvPath as al, getDbConfigsPath as am, getSchemasPath as an, getSchemasDirPath as ao, alertit as ap, getSubstring as aq, sanitizeString as ar, truncateString as as, capitalize_str as at, capitalize as au, stripPrefixes as av, tryEatPrefix as aw, eatInner as ax, eatOuter as ay, eatAll as az, DEV_PREFIX as b, assureNumber as b$, convertDistance as b0, convertTime as b1, convertSpeed as b2, DistanceConverter as b3, TimeConverter as b4, SpeedConverter as b5, toMeters as b6, fromMeters as b7, toSeconds as b8, fromSeconds as b9, METERS_PER_MILE as bA, METERS_PER_FOOT as bB, KMS_PER_METER as bC, MILES_PER_METER as bD, FEET_PER_METER as bE, MIN_IN_S as bF, HOUR_IN_S as bG, DAY_IN_S as bH, YEAR_IN_S as bI, MONTH_IN_S as bJ, MiPerH_TO_MPerS as bK, MPerS_TO_MiPerH as bL, isTimeInterval as bM, convertBigInts as bN, cleanText as bO, cleanArray as bP, getCleanArray as bQ, formatNumber as bR, ensure_list as bS, ensure_number as bT, ensure_string as bU, ensurelist as bV, assureList as bW, assure_list as bX, ensureList as bY, assurelist as bZ, ensurenumber as b_, velocityToMs as ba, velocityFromMs as bb, fromMps as bc, isFiniteNum as bd, fmt as be, SECOND as bf, ZEPTOSECOND as bg, ATTOSECOND as bh, FEMTOSECOND as bi, PICOSECOND as bj, NANOSECOND as bk, MICROSECOND as bl, MILISECOND as bm, CENTISECOND as bn, DECISECOND as bo, MINUTE as bp, HOUR as bq, DAY as br, YEAR as bs, MONTH as bt, SECONDS_PER_MINUTE as bu, SECONDS_PER_HOUR as bv, SECONDS_PER_DAY as bw, PI as bx, PI2 as by, METERS_PER_KM as bz, get_window_location as c, ensureNumber as c0, assurenumber as c1, assure_number as c2, ensurestring as c3, ensureString as c4, assureString as c5, assurestring as c6, assure_string as c7, assurearray as c8, ensurearray as c9, getSafeDocument as cA, getDocumentProp as cB, getSafeWindow as cC, callWindowMethod as cD, getWindowProp as cE, getWindowHost as cF, processKeywords as cG, get_keyword_string as cH, exceedsMbLimit as cI, safeJsonSizeInMb as cJ, dataSizeInMb as cK, getJsonSizeInMb as cL, dataSize as cM, debugPrint as cN, getLastCaller as cO, ensure_array as ca, ensureArray as cb, assure_array as cc, assureArray as cd, get_key_value as ce, get as cf, findKeyValue as cg, omitKeys as ch, extractInsertData as ci, loadInnerJson as cj, isType as ck, isStrInString as cl, getChar as cm, getAlphaNum as cn, getNums as co, isNum as cp, getAlphas as cq, getIfNone as cr, mergeNotNullValues as cs, emptyObjectToNull as ct, loadConfig as cu, getConfig as cv, readJsonFileBrowser as cw, readJsonFileNode as cx, readJsonFile as cy, getConfigContent as cz, get_window_pathname as d, get_window_parts as e, fetchIt as f, get_window as g, getHtmlDirectory as h, fetchIndexHtml as i, fetchIndexHtmlContainer as j, getResult as k, getMethod as l, getHeaders as m, getBody as n, getFetchVars as o, parseResult as p, checkResponse as q, get_full_url as r, get_full_path as s, path_to_url as t, urlJoin as u, url_to_path as v, urljoin as w, get_dirname as x, get_basename as y, get_filename as z };
+//# sourceMappingURL=print_utils-p0I6-E-k.js.map