@putkoff/abstract-utilities 1.0.131 → 1.0.134

package/dist/cjs/print_utils-Dsre-F_V.js

@@ -0,0 +1,1863 @@
+'use strict';
+
+var path = require('path');
+var safe_storage = require('./safe_storage-BSCV5flZ.js');
+var fs = require('node:fs');
+var path$1 = require('node:path');
+var util = require('util');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+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((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('print_utils-Dsre-F_V.js', document.baseURI).href)));
+}
+
+function get_dirname(filePath) {
+    if (!filePath)
+        return '';
+    return safe_storage.path.dirname(filePath);
+}
+function get_basename(filePath) {
+    if (!filePath)
+        return '';
+    return safe_storage.path.basename(filePath);
+}
+function get_filename(filePath) {
+    if (!filePath)
+        return '';
+    const ext = safe_storage.path.extname(filePath);
+    return safe_storage.path.basename(filePath, ext);
+}
+function get_extname(filePath) {
+    if (!filePath)
+        return '';
+    return safe_storage.path.extname(filePath);
+}
+function get_splitext(filePath) {
+    if (!filePath)
+        return { filename: '', extname: '' };
+    const ext = safe_storage.path.extname(filePath);
+    // Get the basename without the extension
+    const filename = safe_storage.path.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 = safe_storage.path.relative(basePath, targetPath);
+        // Normalize to POSIX-style slashes for consistency (especially on Windows)
+        rel = rel.split(safe_storage.path.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
+    if (head === 0 || rest.some((d) => d === 0))
+        return 0;
+    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
+    if (head === 0 || rest.some((d) => d === 0))
+        return 0;
+    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 = safe_storage.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 = path$1.isAbsolute(relativeOrAbsolutePath)
+            ? relativeOrAbsolutePath
+            : path$1.resolve(process.cwd(), relativeOrAbsolutePath);
+        return JSON.parse(fs.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 ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('print_utils-Dsre-F_V.js', document.baseURI).href)) }) !== 'undefined' && typeof (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('print_utils-Dsre-F_V.js', document.baseURI).href)) === '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 = safe_storage.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 = safe_storage.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(util.inspect(value, {
+        depth: null,
+        colors: true,
+        compact: false,
+        maxArrayLength: null,
+    }));
+}
+
+exports.API_PREFIX = API_PREFIX;
+exports.ATTOSECOND = ATTOSECOND;
+exports.BASE_URL = BASE_URL;
+exports.CENTISECOND = CENTISECOND;
+exports.DAY = DAY;
+exports.DAY_IN_S = DAY_IN_S;
+exports.DECISECOND = DECISECOND;
+exports.DEV_PREFIX = DEV_PREFIX;
+exports.DIST_ALIASES = DIST_ALIASES;
+exports.DIST_FACTORS = DIST_FACTORS;
+exports.DOMAIN_NAME = DOMAIN_NAME;
+exports.DistanceConverter = DistanceConverter;
+exports.FEET_PER_METER = FEET_PER_METER;
+exports.FEMTOSECOND = FEMTOSECOND;
+exports.HOUR = HOUR;
+exports.HOUR_IN_S = HOUR_IN_S;
+exports.KMS_PER_METER = KMS_PER_METER;
+exports.METERS_PER_FOOT = METERS_PER_FOOT;
+exports.METERS_PER_KM = METERS_PER_KM;
+exports.METERS_PER_MILE = METERS_PER_MILE;
+exports.MICROSECOND = MICROSECOND;
+exports.MILES_PER_METER = MILES_PER_METER;
+exports.MILISECOND = MILISECOND;
+exports.MINUTE = MINUTE;
+exports.MIN_IN_S = MIN_IN_S;
+exports.MONTH = MONTH;
+exports.MONTH_IN_S = MONTH_IN_S;
+exports.MPerS_TO_MiPerH = MPerS_TO_MiPerH;
+exports.MiPerH_TO_MPerS = MiPerH_TO_MPerS;
+exports.NANOSECOND = NANOSECOND;
+exports.PI = PI;
+exports.PI2 = PI2;
+exports.PICOSECOND = PICOSECOND;
+exports.PROD_PREFIX = PROD_PREFIX;
+exports.PROTOCOL = PROTOCOL;
+exports.SECOND = SECOND;
+exports.SECONDS_PER_DAY = SECONDS_PER_DAY;
+exports.SECONDS_PER_HOUR = SECONDS_PER_HOUR;
+exports.SECONDS_PER_MINUTE = SECONDS_PER_MINUTE;
+exports.SUB_DIR = SUB_DIR;
+exports.SpeedConverter = SpeedConverter;
+exports.TIME_ALIASES = TIME_ALIASES;
+exports.TIME_FACTORS = TIME_FACTORS;
+exports.TimeConverter = TimeConverter;
+exports.YEAR = YEAR;
+exports.YEAR_IN_S = YEAR_IN_S;
+exports.ZEPTOSECOND = ZEPTOSECOND;
+exports.alertit = alertit;
+exports.assureArray = assureArray;
+exports.assureList = assureList;
+exports.assureNumber = assureNumber;
+exports.assureString = assureString;
+exports.assure_array = assure_array;
+exports.assure_list = assure_list;
+exports.assure_number = assure_number;
+exports.assure_string = assure_string;
+exports.assurearray = assurearray;
+exports.assurelist = assurelist;
+exports.assurenumber = assurenumber;
+exports.assurestring = assurestring;
+exports.callWindowMethod = callWindowMethod;
+exports.canonDist = canonDist;
+exports.canonTime = canonTime;
+exports.capitalize = capitalize;
+exports.capitalize_str = capitalize_str;
+exports.checkResponse = checkResponse;
+exports.cleanArray = cleanArray;
+exports.cleanText = cleanText;
+exports.convertBigInts = convertBigInts;
+exports.convertDistance = convertDistance;
+exports.convertSpeed = convertSpeed;
+exports.convertTime = convertTime;
+exports.create_list_string = create_list_string;
+exports.dataSize = dataSize;
+exports.dataSizeInMb = dataSizeInMb;
+exports.debugPrint = debugPrint;
+exports.distanceToMeters = distanceToMeters;
+exports.eatAll = eatAll;
+exports.eatElse = eatElse;
+exports.eatInner = eatInner;
+exports.eatOuter = eatOuter;
+exports.eatall = eatall;
+exports.eatinner = eatinner;
+exports.eatouter = eatouter;
+exports.emptyObjectToNull = emptyObjectToNull;
+exports.ends_in_quotes = ends_in_quotes;
+exports.ensureArray = ensureArray;
+exports.ensureList = ensureList;
+exports.ensureNumber = ensureNumber;
+exports.ensureString = ensureString;
+exports.ensure_array = ensure_array;
+exports.ensure_list = ensure_list;
+exports.ensure_number = ensure_number;
+exports.ensure_string = ensure_string;
+exports.ensurearray = ensurearray;
+exports.ensurelist = ensurelist;
+exports.ensurenumber = ensurenumber;
+exports.ensurestring = ensurestring;
+exports.exceedsMbLimit = exceedsMbLimit;
+exports.exponential = exponential;
+exports.extractInsertData = extractInsertData;
+exports.fetchIndexHtml = fetchIndexHtml;
+exports.fetchIndexHtmlContainer = fetchIndexHtmlContainer;
+exports.fetchIt = fetchIt;
+exports.findKeyValue = findKeyValue;
+exports.fmt = fmt;
+exports.formatNumber = formatNumber;
+exports.fromMeters = fromMeters;
+exports.fromMps = fromMps;
+exports.fromSeconds = fromSeconds;
+exports.geAuthsUtilsDirectory = geAuthsUtilsDirectory;
+exports.geBackupsUtilsDirectory = geBackupsUtilsDirectory;
+exports.geConstantsUtilsDirectory = geConstantsUtilsDirectory;
+exports.geEnvUtilsDirectory = geEnvUtilsDirectory;
+exports.geFetchUtilsDirectory = geFetchUtilsDirectory;
+exports.geFileUtilsDirectory = geFileUtilsDirectory;
+exports.gePathUtilsDirectory = gePathUtilsDirectory;
+exports.geStaticDirectory = geStaticDirectory;
+exports.geStringUtilsDirectory = geStringUtilsDirectory;
+exports.geTypeUtilsDirectory = geTypeUtilsDirectory;
+exports.get = get;
+exports.getAbsDir = getAbsDir;
+exports.getAbsPath = getAbsPath;
+exports.getAlphaNum = getAlphaNum;
+exports.getAlphas = getAlphas;
+exports.getBaseDir = getBaseDir;
+exports.getBasename = getBasename;
+exports.getBody = getBody;
+exports.getChar = getChar;
+exports.getCleanArray = getCleanArray;
+exports.getComponentsUtilsDirectory = getComponentsUtilsDirectory;
+exports.getConfig = getConfig;
+exports.getConfigContent = getConfigContent;
+exports.getDbConfigsPath = getDbConfigsPath;
+exports.getDirname = getDirname;
+exports.getDistDir = getDistDir;
+exports.getDocumentProp = getDocumentProp;
+exports.getEnvDir = getEnvDir;
+exports.getEnvPath = getEnvPath;
+exports.getExtname = getExtname;
+exports.getFetchVars = getFetchVars;
+exports.getFilename = getFilename;
+exports.getFunctionsDir = getFunctionsDir;
+exports.getFunctionsUtilsDirectory = getFunctionsUtilsDirectory;
+exports.getHeaders = getHeaders;
+exports.getHooksUtilsDirectory = getHooksUtilsDirectory;
+exports.getHtmlDirectory = getHtmlDirectory;
+exports.getIfNone = getIfNone;
+exports.getJsonSizeInMb = getJsonSizeInMb;
+exports.getLastCaller = getLastCaller;
+exports.getLibUtilsDirectory = getLibUtilsDirectory;
+exports.getMethod = getMethod;
+exports.getNums = getNums;
+exports.getPublicDir = getPublicDir;
+exports.getResult = getResult;
+exports.getSafeDocument = getSafeDocument;
+exports.getSafeWindow = getSafeWindow;
+exports.getSchemasDirPath = getSchemasDirPath;
+exports.getSchemasPath = getSchemasPath;
+exports.getSplitext = getSplitext;
+exports.getSrcDir = getSrcDir;
+exports.getSubstring = getSubstring;
+exports.getWindowHost = getWindowHost;
+exports.getWindowProp = getWindowProp;
+exports.get_basename = get_basename;
+exports.get_dirname = get_dirname;
+exports.get_extname = get_extname;
+exports.get_filename = get_filename;
+exports.get_full_path = get_full_path;
+exports.get_full_url = get_full_url;
+exports.get_key_value = get_key_value;
+exports.get_keyword_string = get_keyword_string;
+exports.get_relative_path = get_relative_path;
+exports.get_splitext = get_splitext;
+exports.get_window = get_window;
+exports.get_window_location = get_window_location;
+exports.get_window_parts = get_window_parts;
+exports.get_window_pathname = get_window_pathname;
+exports.getbasename = getbasename;
+exports.getdirname = getdirname;
+exports.getextname = getextname;
+exports.getfilename = getfilename;
+exports.getsplitext = getsplitext;
+exports.isFiniteNum = isFiniteNum;
+exports.isNum = isNum;
+exports.isStrInString = isStrInString;
+exports.isTimeInterval = isTimeInterval;
+exports.isType = isType;
+exports.isZero = isZero;
+exports.loadConfig = loadConfig;
+exports.loadInnerJson = loadInnerJson;
+exports.makePath = makePath;
+exports.make_path = make_path;
+exports.make_sanitized_path = make_sanitized_path;
+exports.makepath = makepath;
+exports.mergeNotNullValues = mergeNotNullValues;
+exports.metersToDistance = metersToDistance;
+exports.mpsToSpeed = mpsToSpeed;
+exports.normalizeUrl = normalizeUrl;
+exports.omitKeys = omitKeys;
+exports.parseResult = parseResult;
+exports.pathJoin = pathJoin;
+exports.path_join = path_join;
+exports.path_to_url = path_to_url;
+exports.pathjoin = pathjoin;
+exports.processKeywords = processKeywords;
+exports.readJsonFile = readJsonFile;
+exports.readJsonFileBrowser = readJsonFileBrowser;
+exports.readJsonFileNode = readJsonFileNode;
+exports.roundPercentage = roundPercentage;
+exports.safeAdd = safeAdd;
+exports.safeDivide = safeDivide;
+exports.safeJsonSizeInMb = safeJsonSizeInMb;
+exports.safeMultiply = safeMultiply;
+exports.safeNums = safeNums;
+exports.safeSubtract = safeSubtract;
+exports.sanitizeFilename = sanitizeFilename;
+exports.sanitizeString = sanitizeString;
+exports.secondsToTime = secondsToTime;
+exports.speedToMps = speedToMps;
+exports.stripPrefixes = stripPrefixes;
+exports.stripQuotes = stripQuotes;
+exports.timeToSeconds = timeToSeconds;
+exports.toMeters = toMeters;
+exports.toSeconds = toSeconds;
+exports.truncateString = truncateString;
+exports.tryEatPrefix = tryEatPrefix;
+exports.tryParse = tryParse;
+exports.urlJoin = urlJoin;
+exports.url_to_path = url_to_path;
+exports.urljoin = urljoin;
+exports.velocityFromMs = velocityFromMs;
+exports.velocityToMs = velocityToMs;
+//# sourceMappingURL=print_utils-Dsre-F_V.js.map