@putkoff/abstract-utilities 0.1.243 → 1.0.0

package/dist/cjs/index.js

@@ -2,7 +2,6 @@
 
 var react = require('react');
 var path = require('path');
-var path$2 = require('path-browserify');
 var fs = require('node:fs');
 var fsp = require('node:fs/promises');
 var path$1 = require('node:path');
@@ -26,7 +25,6 @@ function _interopNamespaceDefault(e) {
     return Object.freeze(n);
 }
 
-var path__namespace$1 = /*#__PURE__*/_interopNamespaceDefault(path$2);
 var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
 var fsp__namespace = /*#__PURE__*/_interopNamespaceDefault(fsp);
 var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path$1);
@@ -170,17 +168,6 @@ 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.
@@ -197,7 +184,7 @@ function requireToken() {
     const tok = getToken();
     if (!tok || isTokenExpired(tok)) {
         console.warn("→ No token or expired token, redirecting to login…");
-        removeToken();
+        localStorage.removeItem("token");
         window.location.href = '/';
         throw new Error("Redirecting to login…");
     }
@@ -215,13 +202,16 @@ function isTokenExpired(token) {
 }
 /** 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;
+    const tok = getToken();
+    if (!tok)
+        return null;
+    try {
+        const { username } = decodeJwt(tok);
+        return username !== null && username !== void 0 ? username : null;
+    }
+    catch (_a) {
+        return null;
     }
-    return uName;
 }
 function currentUsernames() {
     var _a;
@@ -365,37 +355,44 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
  */
 function readJsonFile(relativeOrAbsolutePath) {
     return __awaiter(this, void 0, void 0, function* () {
-        if (typeof window === 'undefined') {
+        // 1) Try Node.js fs
+        if (typeof process !== 'undefined' &&
+            process.versions != null &&
+            process.versions.node) {
             try {
-                const { readFile } = yield import('fs/promises');
-                const { isAbsolute, resolve } = yield import('path');
-                const filePath = isAbsolute(relativeOrAbsolutePath)
+                const fs = yield import('fs');
+                const path = yield import('path');
+                const filePath = path.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');
+                    : path.resolve(process.cwd(), relativeOrAbsolutePath);
+                const text = yield fs.promises.readFile(filePath, 'utf8');
                 return JSON.parse(text);
             }
             catch (_a) {
-                return null;
+                // swallow and fall back to browser
             }
         }
-        // Browser fallback
+        // 2) Try browser fetch
         const fetchFn = safeGlobalProp('fetch');
-        if (typeof fetchFn !== 'function')
+        if (typeof fetchFn !== 'function') {
             return null;
+        }
+        // Resolve URL against document.baseURI if possible
         let url = relativeOrAbsolutePath;
         const baseURI = safeGlobalProp('document', 'baseURI');
         if (baseURI) {
             try {
                 url = new URL(relativeOrAbsolutePath, baseURI).href;
             }
-            catch (_b) { }
+            catch (_b) {
+                // keep url as-is
+            }
         }
         try {
             const res = yield fetchFn(url);
             if (!res.ok)
                 return null;
-            return yield res.json();
+            return (yield res.json());
         }
         catch (_c) {
             return null;
@@ -438,7 +435,6 @@ function getResult(obj) {
     }
     return current;
 }
-const get_result = getResult;
 // Determines HTTP method, defaults to GET or POST based on body
 function getMethod(method = null, body = null) {
     const validMethods = ['GET', 'POST', 'PUT', 'PATCH', 'PULL'];
@@ -527,7 +523,7 @@ function checkResponse(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) {
+    return __awaiter(this, arguments, void 0, function* (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
         let url = endpoint;
@@ -543,20 +539,18 @@ function fetchIt(endpoint_1) {
                     ? JSON.stringify(body)
                     : undefined,
         };
-        let res = yield fetch(url, opts);
+        console.debug("➡️ secureFetchIt →", url, opts);
+        const 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;
-        }
+        if (returnReult)
+            return getResult(res.json());
+        if (returnJson)
+            return res.json();
         return res;
     });
 }
@@ -670,6 +664,637 @@ function url_to_path(urlStr, all_paths) {
     return null;
 }
 
+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 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;
+}
+// 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;
+}
+
 function ensure_list(obj) {
     const objArray = Array.isArray(obj) ? obj : [obj];
     return objArray;
@@ -1110,159 +1735,6 @@ const confirm_type = confirmType;
 const is_media_type = isMediaType;
 const get_mime_type = getMimeType;
 
-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.
@@ -1283,37 +1755,34 @@ function fileURLToPath(fileUrl) {
     }
 }
 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 path__namespace$1.dirname(filePath);
+    return pathBrowserify.dirname(filePath);
 }
 function get_basename(filePath) {
     if (!filePath)
         return '';
-    return path__namespace$1.basename(filePath);
+    return pathBrowserify.basename(filePath);
 }
 function get_filename(file_path) {
-    const ext = path__namespace$1.extname(file_path);
-    return path__namespace$1.basename(file_path, ext);
+    const ext = pathBrowserify.extname(file_path);
+    return pathBrowserify.basename(file_path, ext);
 }
 function get_extname(filePath) {
     if (!filePath)
         return '';
-    return path__namespace$1.extname(filePath);
+    return pathBrowserify.extname(filePath);
 }
 function get_splitext(filePath) {
     if (!filePath)
         return { filename: '', extname: '' };
-    const ext = path__namespace$1.extname(filePath);
+    const ext = pathBrowserify.extname(filePath);
     // Get the basename without the extension
-    const filename = path__namespace$1.basename(filePath, ext);
+    const filename = pathBrowserify.basename(filePath, ext);
     return { filename, ext };
 }
 /**
@@ -1344,23 +1813,6 @@ function make_path(...paths) {
     }
     return real_path;
 }
-function makePath(...paths) {
-    var _a;
-    const pathArray = ensure_list(paths);
-    let real_path = '';
-    for (let i = 0; i < pathArray.length; i++) {
-        let seg = String((_a = pathArray[i]) !== null && _a !== void 0 ? _a : '');
-        if (i === 0) {
-            real_path = seg;
-        }
-        else {
-            seg = eatInner(seg, ['/']);
-            real_path = eatOuter(real_path, ['/']);
-            real_path = `${real_path}/${seg}`;
-        }
-    }
-    return real_path || '';
-}
 function sanitizeFilename(filename) {
     return filename
         .toLowerCase()
@@ -1370,13 +1822,6 @@ function sanitizeFilename(filename) {
         .replace(/-+/g, '-') // Collapse multiple hyphens into one
         .replace(/^-|-$/, ''); // Remove leading/trailing hyphens
 }
-function get_relative_path(directory, fullPath) {
-    return path__namespace$1.relative(directory, fullPath);
-}
-// Safer resolver that strips .. at the front only, but prefer server-side checks.
-function get_safe_path(p) {
-    return path__namespace$1.normalize(p).replace(/^(\.\.[/\\])+/, '');
-}
 function make_sanitized_path(...paths) {
     let real_path = '';
     for (let i = 0; i < paths.length; i++) {
@@ -1390,13 +1835,13 @@ function make_sanitized_path(...paths) {
     }
     return real_path || '';
 }
-/** FIXED: your regexes were strings. This correctly joins without duplicate slashes. */
 function normalizeUrl(base, p) {
     if (!p)
-        return base.replace(/\/+$/g, '');
-    const cleanBase = base.replace(/\/+$/g, '');
-    const cleanPath = p.replace(/^\/+/g, '');
-    return `${cleanBase}/${cleanPath}`.replace(/([^:])\/{2,}/g, '$1/'); // keep protocol //
+        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/');
 }
 
 /**
@@ -1497,7 +1942,32 @@ function alertit(obj = null) {
     }
     alert(msg);
 }
-const alertIt = alertit;
+
+// 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 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 Button(_a) {
     var { children, color = 'gray', variant = 'default', className = '' } = _a, rest = __rest(_a, ["children", "color", "variant", "className"]);
@@ -1535,17 +2005,74 @@ function Spinner() {
 }
 
 // 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* () {
+let _cachedConfig = null;
+function loadConfig() {
+    return __awaiter(this, arguments, void 0, function* (filePath = null) {
+        var _a;
+        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('index.js', document.baseURI).href)) }) !== 'undefined' && typeof (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)) === 'string') {
+            // ES module: resolve relative to this file
+            try {
+                configUrl = new URL('./config.json', (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href))).href;
+            }
+            catch (_b) {
+                configUrl = 'config.json';
+            }
+        }
+        else {
+            // browser fallback
+            const baseURI = safeGlobalProp('document', 'baseURI');
+            try {
+                configUrl =
+                    typeof baseURI === 'string'
+                        ? new URL('config.json', baseURI).href
+                        : 'config.json';
+            }
+            catch (_c) {
+                configUrl = 'config.json';
+            }
+        }
+        // 2) if we have a fetch, try HTTP(S)
+        const fetchFn = safeGlobalProp('fetch');
+        if (typeof fetchFn === 'function') {
+            try {
+                const res = yield fetchFn(configUrl);
+                if (res.ok) {
+                    const json = yield res.json();
+                    // cache & return
+                    _cachedConfig = (_a = json) !== null && _a !== void 0 ? _a : {};
+                    return _cachedConfig;
+                }
+            }
+            catch (_d) {
+                /* swallow */
+            }
+        }
+        // 3) Node fallback: try reading from disk (requires your readJsonFile util)
         try {
-            return (yield readJsonFile('config.json')) || {};
+            const disk = yield readJsonFile(configUrl);
+            _cachedConfig = disk !== null && disk !== void 0 ? disk : {};
+            return _cachedConfig;
         }
-        catch (_a) {
-            return {};
+        catch (_e) {
+            /* swallow */
         }
+        // 4) if all else fails, return an empty config
+        _cachedConfig = {};
+        return _cachedConfig;
+    });
+}
+function getConfig(key) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const cfg = yield loadConfig();
+        return key != null ? cfg[key] : cfg;
     });
 }
 
@@ -1583,102 +2110,6 @@ function get_keyword_string(keywords) {
     return allString;
 }
 
-// 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 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);
-}
-
-// urlTools.ts
-// Minimal, safe encoders/decoders + helpers to build/parse URLs
-/** Encode a single query value/key safely */
-const encode = (v) => encodeURIComponent(String(v !== null && v !== void 0 ? v : ""));
-/** Decode a single query value/key safely (never throws) */
-const decodeSafe = (v) => {
-    if (v == null)
-        return "";
-    try {
-        return decodeURIComponent(v);
-    }
-    catch (_a) {
-        // handles bad % sequences or already-decoded strings
-        return v;
-    }
-};
-/** Decode strings that might be double-encoded (up to 2 passes) */
-const decodeMaybeDouble = (v) => {
-    const once = decodeSafe(v);
-    const twice = decodeSafe(once);
-    return twice.length < once.length ? twice : once;
-};
-/** Convert + to spaces (legacy www-form behavior) then decode */
-const decodeFormComponent = (v) => decodeSafe(v.replace(/\+/g, " "));
-/** Build a URL with query params (skips null/undefined) */
-const buildUrl = (base, params) => {
-    const u = new URL(base, typeof window !== "undefined" ? window.location.origin : "http://localhost");
-    if (params) {
-        for (const [k, val] of Object.entries(params)) {
-            if (val === null || val === undefined)
-                continue;
-            // arrays -> multiple entries
-            if (Array.isArray(val)) {
-                val.forEach(v => u.searchParams.append(k, String(v)));
-            }
-            else {
-                u.searchParams.set(k, String(val));
-            }
-        }
-    }
-    return u.toString();
-};
-/** Parse a query string into an object (first value wins; arrays if repeat=true) */
-const parseQuery = (qs, opts) => {
-    var _a;
-    const { repeat = false, form = false } = opts || {};
-    const out = {};
-    const s = qs.startsWith("?") ? qs.slice(1) : qs;
-    if (!s)
-        return out;
-    for (const part of s.split("&")) {
-        if (!part)
-            continue;
-        const [kRaw, vRaw = ""] = part.split("=");
-        const K = form ? decodeFormComponent(kRaw) : decodeSafe(kRaw);
-        const V = form ? decodeFormComponent(vRaw) : decodeSafe(vRaw);
-        if (repeat) {
-            ((_a = out[K]) !== null && _a !== void 0 ? _a : (out[K] = [])).push(V);
-        }
-        else {
-            out[K] = V;
-        }
-    }
-    return out;
-};
-/** Quick helper: percent-encode whole strings for placement in URLs */
-const encodeTextForUrl = (text) => encode(text);
-/** Quick helper: decode long blobs coming from share-intents/UTMs */
-const decodeShareBlob = (blob) => decodeMaybeDouble(blob).replace(/\r\n/g, "\n");
-
 Object.defineProperty(exports, "useCallback", {
     enumerable: true,
     get: function () { return react.useCallback; }
@@ -1708,7 +2139,6 @@ exports.PROD_PREFIX = PROD_PREFIX;
 exports.PROTOCOL = PROTOCOL;
 exports.SUB_DIR = SUB_DIR;
 exports.Spinner = Spinner;
-exports.alertIt = alertIt;
 exports.alertit = alertit;
 exports.assureArray = assureArray;
 exports.assureList = assureList;
@@ -1718,11 +2148,8 @@ exports.assure_array = assure_array;
 exports.assure_list = assure_list;
 exports.assure_number = assure_number;
 exports.assure_string = assure_string;
-exports.buildUrl = buildUrl;
 exports.callStorage = callStorage;
 exports.callWindowMethod = callWindowMethod;
-exports.capitalize = capitalize;
-exports.capitalize_str = capitalize_str;
 exports.checkResponse = checkResponse;
 exports.cleanArray = cleanArray;
 exports.cleanText = cleanText;
@@ -1731,17 +2158,11 @@ exports.confirm_type = confirm_type;
 exports.create_list_string = create_list_string;
 exports.currentUsername = currentUsername;
 exports.currentUsernames = currentUsernames;
-exports.decodeFormComponent = decodeFormComponent;
 exports.decodeJwt = decodeJwt;
-exports.decodeMaybeDouble = decodeMaybeDouble;
-exports.decodeSafe = decodeSafe;
-exports.decodeShareBlob = decodeShareBlob;
 exports.eatAll = eatAll;
 exports.eatEnd = eatEnd;
 exports.eatInner = eatInner;
 exports.eatOuter = eatOuter;
-exports.encode = encode;
-exports.encodeTextForUrl = encodeTextForUrl;
 exports.ensureArray = ensureArray;
 exports.ensureList = ensureList;
 exports.ensureNumber = ensureNumber;
@@ -1777,8 +2198,8 @@ exports.getBody = getBody;
 exports.getChar = getChar;
 exports.getCleanArray = getCleanArray;
 exports.getComponentsUtilsDirectory = getComponentsUtilsDirectory;
+exports.getConfig = getConfig;
 exports.getConfigContent = getConfigContent;
-exports.getConfigJson = getConfigJson;
 exports.getConfigVar = getConfigVar;
 exports.getDbConfigsPath = getDbConfigsPath;
 exports.getDistDir = getDistDir;
@@ -1821,9 +2242,6 @@ exports.get_keyword_string = get_keyword_string;
 exports.get_media_exts = get_media_exts;
 exports.get_media_map = get_media_map;
 exports.get_mime_type = get_mime_type;
-exports.get_relative_path = get_relative_path;
-exports.get_result = get_result;
-exports.get_safe_path = get_safe_path;
 exports.get_splitext = get_splitext;
 exports.get_window = get_window;
 exports.get_window_location = get_window_location;
@@ -1836,16 +2254,14 @@ exports.isStrInString = isStrInString;
 exports.isTokenExpired = isTokenExpired;
 exports.isType = isType;
 exports.is_media_type = is_media_type;
-exports.makePath = makePath;
+exports.loadConfig = loadConfig;
 exports.make_path = make_path;
 exports.make_sanitized_path = make_sanitized_path;
 exports.normalizeUrl = normalizeUrl;
-exports.parseQuery = parseQuery;
 exports.parseResult = parseResult;
 exports.path_to_url = path_to_url;
 exports.processKeywords = processKeywords;
 exports.readJsonFile = readJsonFile;
-exports.removeToken = removeToken;
 exports.requireToken = requireToken;
 exports.roundPercentage = roundPercentage;
 exports.safeDivide = safeDivide;