@putkoff/abstract-utilities 0.1.220 → 0.1.223

package/dist/cjs/index.js

@@ -0,0 +1,1758 @@
+'use strict';
+
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+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;
+}
+
+/**
+ * Safely walk `globalThis` (or window/document) by a chain of property names.
+ * Returns `undefined` if any step is missing.
+ */
+function safeGlobalProp(...path) {
+    let obj = globalThis;
+    for (const key of path) {
+        if (obj == null || typeof obj !== "object" || !(key in obj)) {
+            return undefined;
+        }
+        obj = obj[key];
+    }
+    return obj;
+}
+
+/**
+ * Returns `window` if running in a browser, otherwise `undefined`.
+ */
+function getSafeLocalStorage() {
+    if (typeof window === 'undefined')
+        return undefined;
+    try {
+        return window.localStorage;
+    }
+    catch (_a) {
+        return undefined; // e.g. Safari private-mode block
+    }
+}
+/**
+ * Call a Storage method by name, silencing any errors or missing storage.
+ *
+ * @param method  One of the keys of the Storage interface: "getItem", "setItem", etc.
+ * @param args    The arguments you’d normally pass to that method.
+ * @returns       The method’s return value, or undefined if storage/method isn’t available.
+ */
+function callStorage(method, ...args) {
+    const storage = getSafeLocalStorage();
+    if (!storage)
+        return undefined;
+    const fn = storage[method];
+    if (typeof fn !== 'function')
+        return undefined;
+    try {
+        // @ts-ignore – TS can’t infer that this is callable
+        return fn.apply(storage, args);
+    }
+    catch (_a) {
+        return undefined;
+    }
+}
+/**
+ * Safely call storage methods (`localStorage` or `sessionStorage`) without blowing up.
+ * Returns `undefined` on any error.
+ */
+function safeStorage(storageName, method, ...args) {
+    try {
+        const store = safeGlobalProp(storageName);
+        if (!store || typeof store[method] !== "function")
+            return undefined;
+        // @ts-ignore
+        return store[method](...args);
+    }
+    catch (_a) {
+        return undefined;
+    }
+}
+
+/**
+ * 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 (_a) {
+        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');
+}
+
+/**
+***Changes**:
+*- Updated import path for `InputProps` to `../../types/interfaces`.
+*
+*3. **Token Utilities** (`src/functions/auth/token_utils.ts`):
+*   Copy from `/var/www/abstractendeavors/my-login-app/src/functions/auth_utils/token_utils.ts`.
+*
+*/
+/** Read raw JWT from LocalStorage (or null if absent) */
+function getToken() {
+    return callStorage('getItem', 'token');
+}
+function isLoggedIn() {
+    const tok = getToken();
+    return !!tok && !isTokenExpired(tok !== null && tok !== void 0 ? tok : "");
+}
+function removeToken() {
+    let is_logged = isLoggedIn();
+    if (is_logged) {
+        callStorage('removeItem', "token");
+    }
+    is_logged = isLoggedIn();
+    if (is_logged) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Add a Bearer Authorization header.
+ * A shallow copy of headers is returned so callers can keep chaining.
+ */
+function getAuthorizationHeader(headers = {}, token = null) {
+    token = token !== null && token !== void 0 ? token : getToken();
+    headers = headers || {};
+    if (token)
+        headers["Authorization"] = `Bearer ${token}`;
+    return Object.assign({}, headers);
+}
+/** Throw + redirect if there’s no valid token; otherwise return it. */
+function requireToken() {
+    const tok = getToken();
+    if (!tok || isTokenExpired(tok)) {
+        console.warn("→ No token or expired token, redirecting to login…");
+        removeToken();
+        window.location.href = '/';
+        throw new Error("Redirecting to login…");
+    }
+    return tok;
+}
+/** True if token is structurally bad or its exp ≤ now. */
+function isTokenExpired(token) {
+    try {
+        const payload = decodeJwt(token);
+        return Date.now() / 1000 >= payload.exp;
+    }
+    catch (_a) {
+        return true; // treat malformed token as expired
+    }
+}
+/** Convenience wrapper: return username from the JWT (or null). */
+function currentUsername() {
+    const token = getToken();
+    let uName = null;
+    if (token) {
+        const decodedJwt = decodeJwt(token) || {};
+        uName = (decodedJwt === null || decodedJwt === void 0 ? void 0 : decodedJwt.username) || null;
+    }
+    return uName;
+}
+function currentUsernames() {
+    var _a;
+    const tok = getToken();
+    if (!tok)
+        return null;
+    try {
+        const parts = tok.split(".");
+        if (parts.length !== 3)
+            return null;
+        let b64 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+        b64 = b64.padEnd(Math.ceil(b64.length / 4) * 4, "=");
+        const jsonText = atob(b64);
+        const payload = JSON.parse(jsonText);
+        return (_a = payload.username) !== null && _a !== void 0 ? _a : null;
+    }
+    catch (_b) {
+        return null;
+    }
+}
+/* ------------------------------------------------------------------ */
+/*  internals                                                         */
+/* ------------------------------------------------------------------ */
+function decodeJwt(token) {
+    const [header, payload, signature] = token.split(".");
+    if (!header || !payload || !signature) {
+        throw new Error("Malformed JWT");
+    }
+    // Handle URL-safe Base64
+    let b64 = payload.replace(/-/g, "+").replace(/_/g, "/");
+    // Add padding if necessary
+    b64 = b64.padEnd(Math.ceil(b64.length / 4) * 4, "=");
+    const jsonText = atob(b64);
+    return JSON.parse(jsonText);
+}
+
+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;
+}
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+// src/functions/read_utils/src/read_utils.ts
+/**
+ * Reads a JSON file, either via Node’s fs (if available)
+ * or via window.fetch in the browser. Never throws — returns
+ * the parsed object or null on any error.
+ */
+function readJsonFile(relativeOrAbsolutePath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (typeof window === 'undefined') {
+            try {
+                const { readFile } = yield import('fs/promises');
+                const { isAbsolute, resolve } = yield import('path');
+                const filePath = isAbsolute(relativeOrAbsolutePath)
+                    ? relativeOrAbsolutePath
+                    : resolve((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)) ? new URL('.', (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href))).pathname : '', relativeOrAbsolutePath);
+                const text = yield readFile(filePath, 'utf8');
+                return JSON.parse(text);
+            }
+            catch (_a) {
+                return null;
+            }
+        }
+        // Browser fallback
+        const fetchFn = safeGlobalProp('fetch');
+        if (typeof fetchFn !== 'function')
+            return null;
+        let url = relativeOrAbsolutePath;
+        const baseURI = safeGlobalProp('document', 'baseURI');
+        if (baseURI) {
+            try {
+                url = new URL(relativeOrAbsolutePath, baseURI).href;
+            }
+            catch (_b) { }
+        }
+        try {
+            const res = yield fetchFn(url);
+            if (!res.ok)
+                return null;
+            return yield res.json();
+        }
+        catch (_c) {
+            return null;
+        }
+    });
+}
+function getConfigContent() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            // `readJsonFile` should throw if the file isn’t there or isn’t valid JSON
+            const cfg = yield readJsonFile('./config.json');
+            return cfg;
+        }
+        catch (_a) {
+            // swallow errors & return null so callers can detect “no config”
+            return null;
+        }
+    });
+}
+// 2) Pull a single key out of that object
+function getConfigVar() {
+    return __awaiter(this, arguments, void 0, function* (key = null) {
+        const cfg = yield getConfigContent();
+        if (cfg && typeof cfg === 'object' && key in cfg) {
+            return cfg[key];
+        }
+        return undefined;
+    });
+}
+
+/**
+ * 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 = Object.assign({}, headers);
+    // inject auth if missing
+    if (!result.Authorization) {
+        const token = getToken();
+        Object.assign(result, getAuthorizationHeader(result, token));
+    }
+    method = getMethod(method, body);
+    // if it’s a multipart FormData, let the browser set the boundary header
+    if (body instanceof FormData) {
+        return result;
+    }
+    // otherwise for POST/PUT/PATCH default to JSON
+    if (['POST', 'PUT', 'PATCH'].includes(method) && !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.
+ */
+function parseResult(res) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // 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 = yield 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;
+}
+
+function fetchIt(endpoint_1) {
+    return __awaiter(this, arguments, void 0, function* (endpoint, body = null, method = null, headers = null, blob = false, configUrl = false, withCredentials = true, returnJson = true, returnResult = true) {
+        method = (method || "GET").toUpperCase();
+        // 2) choose the URL
+        let url = endpoint;
+        // 3) prepare headers & body
+        headers = Object.assign(Object.assign(Object.assign({}, (body instanceof FormData ? {} : { "Content-Type": "application/json" })), getAuthorizationHeader()), 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);
+        let res = yield fetch(url, opts);
+        if (!res.ok) {
+            const err = yield res.text();
+            throw new Error(`HTTP ${res.status}: ${err}`);
+        }
+        if (blob)
+            return res.blob();
+        if (returnResult || returnJson) {
+            let JsonRes = parseResult(res);
+            if (returnResult) {
+                JsonRes = getResult(JsonRes);
+            }
+            return JsonRes;
+        }
+        return res;
+    });
+}
+// Constructs HTML directory path
+function getHtmlDirectory(directory, filename) {
+    return `${directory}/${filename}.html`;
+}
+// Fetches HTML content
+function fetchIndexHtml(filename_1) {
+    return __awaiter(this, arguments, void 0, function* (filename, directory = 'sf_index', base = 'html') {
+        const url = `/${base}/${directory}/${filename}.html`;
+        const response = yield fetch(url);
+        return yield response.text();
+    });
+}
+// Fetches and injects HTML content into container
+function fetchIndexHtmlContainer(filename_1) {
+    return __awaiter(this, arguments, void 0, function* (filename, doc = document, directory = 'html') {
+        const container = `${filename}-container`;
+        const html = yield fetchIndexHtml(filename, directory);
+        const el = doc.getElementById(container);
+        if (el) {
+            el.innerHTML = html;
+        }
+        else {
+            console.warn(`⚠️ No container found for: #${container}`);
+        }
+    });
+}
+
+function assertPath(path) {
+  if (typeof path !== 'string') {
+    throw new TypeError('Path must be a string. Received ' + JSON.stringify(path));
+  }
+}
+
+// Resolves . and .. elements in a path with directory names
+function normalizeStringPosix(path, allowAboveRoot) {
+  var res = '';
+  var lastSegmentLength = 0;
+  var lastSlash = -1;
+  var dots = 0;
+  var code;
+  for (var i = 0; i <= path.length; ++i) {
+    if (i < path.length)
+      code = path.charCodeAt(i);
+    else if (code === 47 /*/*/)
+      break;
+    else
+      code = 47 /*/*/;
+    if (code === 47 /*/*/) {
+      if (lastSlash === i - 1 || dots === 1) ; else if (lastSlash !== i - 1 && dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 /*.*/ || res.charCodeAt(res.length - 2) !== 46 /*.*/) {
+          if (res.length > 2) {
+            var lastSlashIndex = res.lastIndexOf('/');
+            if (lastSlashIndex !== res.length - 1) {
+              if (lastSlashIndex === -1) {
+                res = '';
+                lastSegmentLength = 0;
+              } else {
+                res = res.slice(0, lastSlashIndex);
+                lastSegmentLength = res.length - 1 - res.lastIndexOf('/');
+              }
+              lastSlash = i;
+              dots = 0;
+              continue;
+            }
+          } else if (res.length === 2 || res.length === 1) {
+            res = '';
+            lastSegmentLength = 0;
+            lastSlash = i;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          if (res.length > 0)
+            res += '/..';
+          else
+            res = '..';
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0)
+          res += '/' + path.slice(lastSlash + 1, i);
+        else
+          res = path.slice(lastSlash + 1, i);
+        lastSegmentLength = i - lastSlash - 1;
+      }
+      lastSlash = i;
+      dots = 0;
+    } else if (code === 46 /*.*/ && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+
+function _format(sep, pathObject) {
+  var dir = pathObject.dir || pathObject.root;
+  var base = pathObject.base || (pathObject.name || '') + (pathObject.ext || '');
+  if (!dir) {
+    return base;
+  }
+  if (dir === pathObject.root) {
+    return dir + base;
+  }
+  return dir + sep + base;
+}
+
+var posix = {
+  // path.resolve([from ...], to)
+  resolve: function resolve() {
+    var resolvedPath = '';
+    var resolvedAbsolute = false;
+    var cwd;
+
+    for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+      var path;
+      if (i >= 0)
+        path = arguments[i];
+      else {
+        if (cwd === undefined)
+          cwd = process.cwd();
+        path = cwd;
+      }
+
+      assertPath(path);
+
+      // Skip empty entries
+      if (path.length === 0) {
+        continue;
+      }
+
+      resolvedPath = path + '/' + resolvedPath;
+      resolvedAbsolute = path.charCodeAt(0) === 47 /*/*/;
+    }
+
+    // At this point the path should be resolved to a full absolute path, but
+    // handle relative paths to be safe (might happen when process.cwd() fails)
+
+    // Normalize the path
+    resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
+
+    if (resolvedAbsolute) {
+      if (resolvedPath.length > 0)
+        return '/' + resolvedPath;
+      else
+        return '/';
+    } else if (resolvedPath.length > 0) {
+      return resolvedPath;
+    } else {
+      return '.';
+    }
+  },
+
+  normalize: function normalize(path) {
+    assertPath(path);
+
+    if (path.length === 0) return '.';
+
+    var isAbsolute = path.charCodeAt(0) === 47 /*/*/;
+    var trailingSeparator = path.charCodeAt(path.length - 1) === 47 /*/*/;
+
+    // Normalize the path
+    path = normalizeStringPosix(path, !isAbsolute);
+
+    if (path.length === 0 && !isAbsolute) path = '.';
+    if (path.length > 0 && trailingSeparator) path += '/';
+
+    if (isAbsolute) return '/' + path;
+    return path;
+  },
+
+  isAbsolute: function isAbsolute(path) {
+    assertPath(path);
+    return path.length > 0 && path.charCodeAt(0) === 47 /*/*/;
+  },
+
+  join: function join() {
+    if (arguments.length === 0)
+      return '.';
+    var joined;
+    for (var i = 0; i < arguments.length; ++i) {
+      var arg = arguments[i];
+      assertPath(arg);
+      if (arg.length > 0) {
+        if (joined === undefined)
+          joined = arg;
+        else
+          joined += '/' + arg;
+      }
+    }
+    if (joined === undefined)
+      return '.';
+    return posix.normalize(joined);
+  },
+
+  relative: function relative(from, to) {
+    assertPath(from);
+    assertPath(to);
+
+    if (from === to) return '';
+
+    from = posix.resolve(from);
+    to = posix.resolve(to);
+
+    if (from === to) return '';
+
+    // Trim any leading backslashes
+    var fromStart = 1;
+    for (; fromStart < from.length; ++fromStart) {
+      if (from.charCodeAt(fromStart) !== 47 /*/*/)
+        break;
+    }
+    var fromEnd = from.length;
+    var fromLen = fromEnd - fromStart;
+
+    // Trim any leading backslashes
+    var toStart = 1;
+    for (; toStart < to.length; ++toStart) {
+      if (to.charCodeAt(toStart) !== 47 /*/*/)
+        break;
+    }
+    var toEnd = to.length;
+    var toLen = toEnd - toStart;
+
+    // Compare paths to find the longest common path from root
+    var length = fromLen < toLen ? fromLen : toLen;
+    var lastCommonSep = -1;
+    var i = 0;
+    for (; i <= length; ++i) {
+      if (i === length) {
+        if (toLen > length) {
+          if (to.charCodeAt(toStart + i) === 47 /*/*/) {
+            // We get here if `from` is the exact base path for `to`.
+            // For example: from='/foo/bar'; to='/foo/bar/baz'
+            return to.slice(toStart + i + 1);
+          } else if (i === 0) {
+            // We get here if `from` is the root
+            // For example: from='/'; to='/foo'
+            return to.slice(toStart + i);
+          }
+        } else if (fromLen > length) {
+          if (from.charCodeAt(fromStart + i) === 47 /*/*/) {
+            // We get here if `to` is the exact base path for `from`.
+            // For example: from='/foo/bar/baz'; to='/foo/bar'
+            lastCommonSep = i;
+          } else if (i === 0) {
+            // We get here if `to` is the root.
+            // For example: from='/foo'; to='/'
+            lastCommonSep = 0;
+          }
+        }
+        break;
+      }
+      var fromCode = from.charCodeAt(fromStart + i);
+      var toCode = to.charCodeAt(toStart + i);
+      if (fromCode !== toCode)
+        break;
+      else if (fromCode === 47 /*/*/)
+        lastCommonSep = i;
+    }
+
+    var out = '';
+    // Generate the relative path based on the path difference between `to`
+    // and `from`
+    for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
+      if (i === fromEnd || from.charCodeAt(i) === 47 /*/*/) {
+        if (out.length === 0)
+          out += '..';
+        else
+          out += '/..';
+      }
+    }
+
+    // Lastly, append the rest of the destination (`to`) path that comes after
+    // the common path parts
+    if (out.length > 0)
+      return out + to.slice(toStart + lastCommonSep);
+    else {
+      toStart += lastCommonSep;
+      if (to.charCodeAt(toStart) === 47 /*/*/)
+        ++toStart;
+      return to.slice(toStart);
+    }
+  },
+
+  _makeLong: function _makeLong(path) {
+    return path;
+  },
+
+  dirname: function dirname(path) {
+    assertPath(path);
+    if (path.length === 0) return '.';
+    var code = path.charCodeAt(0);
+    var hasRoot = code === 47 /*/*/;
+    var end = -1;
+    var matchedSlash = true;
+    for (var i = path.length - 1; i >= 1; --i) {
+      code = path.charCodeAt(i);
+      if (code === 47 /*/*/) {
+          if (!matchedSlash) {
+            end = i;
+            break;
+          }
+        } else {
+        // We saw the first non-path separator
+        matchedSlash = false;
+      }
+    }
+
+    if (end === -1) return hasRoot ? '/' : '.';
+    if (hasRoot && end === 1) return '//';
+    return path.slice(0, end);
+  },
+
+  basename: function basename(path, ext) {
+    if (ext !== undefined && typeof ext !== 'string') throw new TypeError('"ext" argument must be a string');
+    assertPath(path);
+
+    var start = 0;
+    var end = -1;
+    var matchedSlash = true;
+    var i;
+
+    if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
+      if (ext.length === path.length && ext === path) return '';
+      var extIdx = ext.length - 1;
+      var firstNonSlashEnd = -1;
+      for (i = path.length - 1; i >= 0; --i) {
+        var code = path.charCodeAt(i);
+        if (code === 47 /*/*/) {
+            // If we reached a path separator that was not part of a set of path
+            // separators at the end of the string, stop now
+            if (!matchedSlash) {
+              start = i + 1;
+              break;
+            }
+          } else {
+          if (firstNonSlashEnd === -1) {
+            // We saw the first non-path separator, remember this index in case
+            // we need it if the extension ends up not matching
+            matchedSlash = false;
+            firstNonSlashEnd = i + 1;
+          }
+          if (extIdx >= 0) {
+            // Try to match the explicit extension
+            if (code === ext.charCodeAt(extIdx)) {
+              if (--extIdx === -1) {
+                // We matched the extension, so mark this as the end of our path
+                // component
+                end = i;
+              }
+            } else {
+              // Extension does not match, so our result is the entire path
+              // component
+              extIdx = -1;
+              end = firstNonSlashEnd;
+            }
+          }
+        }
+      }
+
+      if (start === end) end = firstNonSlashEnd;else if (end === -1) end = path.length;
+      return path.slice(start, end);
+    } else {
+      for (i = path.length - 1; i >= 0; --i) {
+        if (path.charCodeAt(i) === 47 /*/*/) {
+            // If we reached a path separator that was not part of a set of path
+            // separators at the end of the string, stop now
+            if (!matchedSlash) {
+              start = i + 1;
+              break;
+            }
+          } else if (end === -1) {
+          // We saw the first non-path separator, mark this as the end of our
+          // path component
+          matchedSlash = false;
+          end = i + 1;
+        }
+      }
+
+      if (end === -1) return '';
+      return path.slice(start, end);
+    }
+  },
+
+  extname: function extname(path) {
+    assertPath(path);
+    var startDot = -1;
+    var startPart = 0;
+    var end = -1;
+    var matchedSlash = true;
+    // Track the state of characters (if any) we see before our first dot and
+    // after any path separator we find
+    var preDotState = 0;
+    for (var i = path.length - 1; i >= 0; --i) {
+      var code = path.charCodeAt(i);
+      if (code === 47 /*/*/) {
+          // If we reached a path separator that was not part of a set of path
+          // separators at the end of the string, stop now
+          if (!matchedSlash) {
+            startPart = i + 1;
+            break;
+          }
+          continue;
+        }
+      if (end === -1) {
+        // We saw the first non-path separator, mark this as the end of our
+        // extension
+        matchedSlash = false;
+        end = i + 1;
+      }
+      if (code === 46 /*.*/) {
+          // If this is our first dot, mark it as the start of our extension
+          if (startDot === -1)
+            startDot = i;
+          else if (preDotState !== 1)
+            preDotState = 1;
+      } else if (startDot !== -1) {
+        // We saw a non-dot and non-path separator before our dot, so we should
+        // have a good chance at having a non-empty extension
+        preDotState = -1;
+      }
+    }
+
+    if (startDot === -1 || end === -1 ||
+        // We saw a non-dot character immediately before the dot
+        preDotState === 0 ||
+        // The (right-most) trimmed path component is exactly '..'
+        preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+      return '';
+    }
+    return path.slice(startDot, end);
+  },
+
+  format: function format(pathObject) {
+    if (pathObject === null || typeof pathObject !== 'object') {
+      throw new TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
+    }
+    return _format('/', pathObject);
+  },
+
+  parse: function parse(path) {
+    assertPath(path);
+
+    var ret = { root: '', dir: '', base: '', ext: '', name: '' };
+    if (path.length === 0) return ret;
+    var code = path.charCodeAt(0);
+    var isAbsolute = code === 47 /*/*/;
+    var start;
+    if (isAbsolute) {
+      ret.root = '/';
+      start = 1;
+    } else {
+      start = 0;
+    }
+    var startDot = -1;
+    var startPart = 0;
+    var end = -1;
+    var matchedSlash = true;
+    var i = path.length - 1;
+
+    // Track the state of characters (if any) we see before our first dot and
+    // after any path separator we find
+    var preDotState = 0;
+
+    // Get non-dir info
+    for (; i >= start; --i) {
+      code = path.charCodeAt(i);
+      if (code === 47 /*/*/) {
+          // If we reached a path separator that was not part of a set of path
+          // separators at the end of the string, stop now
+          if (!matchedSlash) {
+            startPart = i + 1;
+            break;
+          }
+          continue;
+        }
+      if (end === -1) {
+        // We saw the first non-path separator, mark this as the end of our
+        // extension
+        matchedSlash = false;
+        end = i + 1;
+      }
+      if (code === 46 /*.*/) {
+          // If this is our first dot, mark it as the start of our extension
+          if (startDot === -1) startDot = i;else if (preDotState !== 1) preDotState = 1;
+        } else if (startDot !== -1) {
+        // We saw a non-dot and non-path separator before our dot, so we should
+        // have a good chance at having a non-empty extension
+        preDotState = -1;
+      }
+    }
+
+    if (startDot === -1 || end === -1 ||
+    // We saw a non-dot character immediately before the dot
+    preDotState === 0 ||
+    // The (right-most) trimmed path component is exactly '..'
+    preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+      if (end !== -1) {
+        if (startPart === 0 && isAbsolute) ret.base = ret.name = path.slice(1, end);else ret.base = ret.name = path.slice(startPart, end);
+      }
+    } else {
+      if (startPart === 0 && isAbsolute) {
+        ret.name = path.slice(1, startDot);
+        ret.base = path.slice(1, end);
+      } else {
+        ret.name = path.slice(startPart, startDot);
+        ret.base = path.slice(startPart, end);
+      }
+      ret.ext = path.slice(startDot, end);
+    }
+
+    if (startPart > 0) ret.dir = path.slice(0, startPart - 1);else if (isAbsolute) ret.dir = '/';
+
+    return ret;
+  },
+
+  sep: '/',
+  delimiter: ':',
+  win32: null,
+  posix: null
+};
+
+posix.posix = posix;
+
+var pathBrowserify = posix;
+
+function ensure_list(obj) {
+    const objArray = Array.isArray(obj) ? obj : [obj];
+    return objArray;
+}
+function assureString(obj) {
+    return String(obj);
+}
+function cleanArray(obj) {
+    obj = assureArray(obj);
+    return Array.from(new Set(obj));
+}
+function assureArray(input) {
+    if (typeof input === 'string') {
+        return [input];
+    }
+    if (Array.isArray(input)) {
+        return input.map(item => assureString(item));
+    }
+    return [];
+}
+// 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 = assureArray(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;
+}
+function cleanText(input) {
+    // Replace delimiters with spaces and split
+    const str = assureString(input);
+    const words = str.replace(/[_.-]/g, ' '); // Replace _, -, . with space
+    return words;
+}
+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;
+}
+function isStrInString(obj, string) {
+    const obj_str = assureString(obj).toLowerCase;
+    string = assureString(string).toLowerCase;
+    if (string.includes(obj_str)) {
+        return true;
+    }
+    return false;
+}
+function getChar(i, string) {
+    if (string.length >= i) {
+        return assureString(string)[i];
+    }
+}
+function isType(obj, type) {
+    if (typeof obj === type) {
+        return true;
+    }
+    return false;
+}
+function getNums() {
+    return '0123456789';
+}
+function isNum(obj) {
+    const is_num = isType(obj, 'number');
+    if (is_num) {
+        return is_num;
+    }
+    return isStrInString(obj, getNums());
+}
+function ensure_number(object) {
+    if (isNum(object)) {
+        return Number(object);
+    }
+    let nuString = '';
+    const object_str = assureString(object);
+    const str_spl = object_str.split('');
+    for (const obj in str_spl) {
+        if (isNum(obj)) {
+            nuString += obj;
+        }
+    }
+    if (nuString != '') {
+        return Number(nuString);
+    }
+    return null;
+}
+function getAlphas() {
+    return 'abcdefghijklmnopqrstuvwxyz';
+}
+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 getSubstring(obj, maxLength = null, minLength = null) {
+    const objLength = obj.length;
+    const effectiveMaxLength = maxLength !== null && maxLength !== void 0 ? maxLength : objLength; // Use nullish coalescing for clarity
+    const effectiveMinLength = minLength !== null && minLength !== void 0 ? 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);
+}
+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);
+    let objs = string.replace('-', '_').split('_');
+    for (const obj of objs) {
+        let 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;
+}
+/**
+ * Removes characters from the beginning of the string
+ * if they are found in the list of characters.
+ *
+ * @param str - The input string.
+ * @param listObjects - A string or an array of characters to remove.
+ * @returns The modified string.
+ */
+function eatInner(str, listObjects) {
+    if (!Array.isArray(listObjects)) {
+        listObjects = [listObjects];
+    }
+    // Ensure str is a string
+    str = String(str);
+    // Remove characters from the beginning while they are in listObjects
+    while (str.length > 0 && listObjects.includes(str[0])) {
+        str = str.slice(1);
+    }
+    return str;
+}
+/**
+ * Removes characters from the end of the string
+ * if they are found in the list of characters.
+ *
+ * @param str - The input string.
+ * @param listObjects - A string or an array of characters to remove.
+ * @returns The modified string.
+ */
+function eatOuter(str, listObjects) {
+    if (!Array.isArray(listObjects)) {
+        listObjects = [listObjects];
+    }
+    // Ensure str is a string
+    str = String(str);
+    // Remove characters from the end while they are in listObjects
+    while (str.length > 0 && listObjects.includes(str[str.length - 1])) {
+        str = str.slice(0, -1);
+    }
+    return str;
+}
+/**
+ * Removes characters from both the beginning and the end of the string
+ * if they are found in the list of characters.
+ *
+ * @param str - The input string.
+ * @param listObjects - A string or an array of characters to remove.
+ * @returns The modified string.
+ */
+function eatAll(str, listObjects) {
+    return eatOuter(eatInner(str, listObjects), listObjects);
+}
+function eatEnd(obj, endings = ['/']) {
+    let result = obj;
+    let modified = true;
+    while (modified) {
+        modified = false;
+        for (const ending of endings) {
+            if (result.endsWith(ending)) {
+                result = result.slice(0, -ending.length);
+                modified = true;
+                break;
+            }
+        }
+    }
+    return result;
+}
+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;
+}
+
+/**
+ * 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 (_a) {
+        // fallback: just strip file://
+        return fileUrl.replace(/^file:\/\//, '');
+    }
+}
+function getAbsolutePath() {
+    if (typeof window !== 'undefined')
+        return '';
+    return fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)));
+}
+
+// path_utils.browser.ts
+function get_dirname(filePath) {
+    if (!filePath)
+        return '';
+    return pathBrowserify.dirname(filePath);
+}
+function get_basename(filePath) {
+    if (!filePath)
+        return '';
+    return pathBrowserify.basename(filePath);
+}
+function get_filename(file_path) {
+    const ext = pathBrowserify.extname(file_path);
+    return pathBrowserify.basename(file_path, ext);
+}
+function get_extname(filePath) {
+    if (!filePath)
+        return '';
+    return pathBrowserify.extname(filePath);
+}
+function get_splitext(filePath) {
+    if (!filePath)
+        return { filename: '', extname: '' };
+    const ext = pathBrowserify.extname(filePath);
+    // Get the basename without the extension
+    const filename = pathBrowserify.basename(filePath, ext);
+    return { filename, ext };
+}
+/**
+ * Join multiple path segments, normalizing leading/trailing slashes.
+ *
+ * Usage:
+ *   make_path('/foo','bar','baz')
+ *   make_path(['/foo','bar','baz'])
+ */
+function make_path(...paths) {
+    // If someone passed a single array, unwrap it:
+    const pathArray = (paths.length === 1 && Array.isArray(paths[0])
+        ? paths[0]
+        : paths);
+    let real_path = '';
+    for (let i = 0; i < pathArray.length; i++) {
+        let segment = pathArray[i];
+        if (i === 0) {
+            real_path = segment;
+        }
+        else {
+            // remove any leading slash on this segment
+            segment = segment.replace(/^\/+/, '');
+            // remove any trailing slash on the accumulator
+            real_path = real_path.replace(/\/+$/, '');
+            real_path = `${real_path}/${segment}`;
+        }
+    }
+    return real_path;
+}
+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(eatInner(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/');
+}
+
+/**
+ * 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 (_a) {
+        // If JSON.stringify fails (circular refs, etc.), fall back to a simple string
+        msg = String(obj);
+    }
+    alert(msg);
+}
+
+function Button(_a) {
+    var { children, color = 'gray', variant = 'default', className = '' } = _a, rest = __rest(_a, ["children", "color", "variant", "className"]);
+    const base = 'rounded px-3 py-1 text-sm font-medium focus:outline-none focus:ring-2 focus:ring-offset-2 transition-colors duration-150';
+    const variantStyles = {
+        default: '',
+        icon: 'p-1 bg-transparent hover:bg-gray-100',
+        primary: 'text-white',
+        secondary: '',
+    };
+    const palette = {
+        gray: variant === 'primary'
+            ? 'bg-gray-600 hover:bg-gray-700 focus:ring-gray-500'
+            : 'bg-gray-200 hover:bg-gray-300 focus:ring-gray-400',
+        green: 'bg-green-600 text-white hover:bg-green-700 focus:ring-green-500',
+        blue: variant === 'primary'
+            ? 'bg-blue-600 hover:bg-blue-700 focus:ring-blue-500'
+            : 'bg-blue-200 hover:bg-blue-300 focus:ring-blue-400',
+    };
+    return (jsxRuntime.jsx("button", Object.assign({ className: `${base} ${variantStyles[variant]} ${palette[color]} ${className}` }, rest, { children: children })));
+}
+
+function Checkbox(_a) {
+    var { label } = _a, rest = __rest(_a, ["label"]);
+    return (jsxRuntime.jsxs("label", { className: 'flex items-center gap-2 mb-4', children: [jsxRuntime.jsx("input", Object.assign({ type: 'checkbox' }, rest)), jsxRuntime.jsx("span", { children: label })] }));
+}
+
+function Input(_a) {
+    var { label, trailing } = _a, rest = __rest(_a, ["label", "trailing"]);
+    return (jsxRuntime.jsxs("label", { className: 'mb-4 block', children: [jsxRuntime.jsx("span", { className: 'block text-sm font-medium mb-1', children: label }), jsxRuntime.jsxs("div", { className: 'flex gap-2', children: [jsxRuntime.jsx("input", Object.assign({ className: 'flex-1 rounded border px-2 py-1 disabled:bg-gray-100' }, rest)), trailing] })] }));
+}
+
+function Spinner() {
+    return (jsxRuntime.jsx("p", { className: 'animate-pulse', children: "Loading\u2026" }));
+}
+
+// src/functions/config_utils/src/config_utils.ts
+/**
+ * Attempt to load config.json if present, otherwise return empty object.
+ */
+function getConfigJson() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            return (yield readJsonFile('config.json')) || {};
+        }
+        catch (_a) {
+            return {};
+        }
+    });
+}
+
+/**
+ * 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;
+}
+
+Object.defineProperty(exports, "useCallback", {
+    enumerable: true,
+    get: function () { return react.useCallback; }
+});
+Object.defineProperty(exports, "useEffect", {
+    enumerable: true,
+    get: function () { return react.useEffect; }
+});
+Object.defineProperty(exports, "useRef", {
+    enumerable: true,
+    get: function () { return react.useRef; }
+});
+Object.defineProperty(exports, "useState", {
+    enumerable: true,
+    get: function () { return react.useState; }
+});
+exports.API_PREFIX = API_PREFIX;
+exports.BASE_URL = BASE_URL;
+exports.Button = Button;
+exports.Checkbox = Checkbox;
+exports.DEV_PREFIX = DEV_PREFIX;
+exports.DOMAIN_NAME = DOMAIN_NAME;
+exports.Input = Input;
+exports.PROD_PREFIX = PROD_PREFIX;
+exports.PROTOCOL = PROTOCOL;
+exports.SUB_DIR = SUB_DIR;
+exports.Spinner = Spinner;
+exports.alertit = alertit;
+exports.assureArray = assureArray;
+exports.assureString = assureString;
+exports.callStorage = callStorage;
+exports.callWindowMethod = callWindowMethod;
+exports.capitalize = capitalize;
+exports.capitalize_str = capitalize_str;
+exports.checkResponse = checkResponse;
+exports.cleanArray = cleanArray;
+exports.cleanText = cleanText;
+exports.create_list_string = create_list_string;
+exports.currentUsername = currentUsername;
+exports.currentUsernames = currentUsernames;
+exports.decodeJwt = decodeJwt;
+exports.eatAll = eatAll;
+exports.eatEnd = eatEnd;
+exports.eatInner = eatInner;
+exports.eatOuter = eatOuter;
+exports.ensure_list = ensure_list;
+exports.ensure_number = ensure_number;
+exports.fetchIndexHtml = fetchIndexHtml;
+exports.fetchIndexHtmlContainer = fetchIndexHtmlContainer;
+exports.fetchIt = fetchIt;
+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.getAuthorizationHeader = getAuthorizationHeader;
+exports.getBaseDir = getBaseDir;
+exports.getBody = getBody;
+exports.getChar = getChar;
+exports.getCleanArray = getCleanArray;
+exports.getComponentsUtilsDirectory = getComponentsUtilsDirectory;
+exports.getConfigContent = getConfigContent;
+exports.getConfigJson = getConfigJson;
+exports.getConfigVar = getConfigVar;
+exports.getDbConfigsPath = getDbConfigsPath;
+exports.getDistDir = getDistDir;
+exports.getDocumentProp = getDocumentProp;
+exports.getEnvDir = getEnvDir;
+exports.getEnvPath = getEnvPath;
+exports.getFetchVars = getFetchVars;
+exports.getFunctionsDir = getFunctionsDir;
+exports.getFunctionsUtilsDirectory = getFunctionsUtilsDirectory;
+exports.getHeaders = getHeaders;
+exports.getHooksUtilsDirectory = getHooksUtilsDirectory;
+exports.getHtmlDirectory = getHtmlDirectory;
+exports.getLibUtilsDirectory = getLibUtilsDirectory;
+exports.getMethod = getMethod;
+exports.getNums = getNums;
+exports.getPublicDir = getPublicDir;
+exports.getResult = getResult;
+exports.getSafeDocument = getSafeDocument;
+exports.getSafeLocalStorage = getSafeLocalStorage;
+exports.getSafeWindow = getSafeWindow;
+exports.getSchemasDirPath = getSchemasDirPath;
+exports.getSchemasPath = getSchemasPath;
+exports.getSrcDir = getSrcDir;
+exports.getSubstring = getSubstring;
+exports.getToken = getToken;
+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_key_value = get_key_value;
+exports.get_keyword_string = get_keyword_string;
+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.isLoggedIn = isLoggedIn;
+exports.isNum = isNum;
+exports.isStrInString = isStrInString;
+exports.isTokenExpired = isTokenExpired;
+exports.isType = isType;
+exports.make_path = make_path;
+exports.make_sanitized_path = make_sanitized_path;
+exports.normalizeUrl = normalizeUrl;
+exports.parseResult = parseResult;
+exports.processKeywords = processKeywords;
+exports.readJsonFile = readJsonFile;
+exports.removeToken = removeToken;
+exports.requireToken = requireToken;
+exports.safeGlobalProp = safeGlobalProp;
+exports.safeStorage = safeStorage;
+exports.sanitizeFilename = sanitizeFilename;
+exports.stripPrefixes = stripPrefixes;
+exports.truncateString = truncateString;
+exports.tryParse = tryParse;
+//# sourceMappingURL=index.js.map