@putkoff/abstract-utilities 1.0.103 → 1.0.124

package/dist/esm/safe_storage-D4QfcTw0.js

@@ -0,0 +1,897 @@
+import * as fs from 'node:fs';
+import * as fsp from 'node:fs/promises';
+import * as path from 'node:path';
+
+/** 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 {
+        return true; // treat malformed token as expired
+    }
+}
+/* ------------------------------------------------------------------ */
+/*  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);
+}
+
+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;
+
+// mediaTypes.ts
+/** ---- Data: large but explicit, mirrors your Python mapping ---- */
+const MIME_TYPES = {
+    image: {
+        ".jpg": "image/jpeg",
+        ".jpeg": "image/jpeg",
+        ".png": "image/png",
+        ".gif": "image/gif",
+        ".bmp": "image/bmp",
+        ".tiff": "image/tiff",
+        ".webp": "image/webp",
+        ".svg": "image/svg+xml",
+        ".ico": "image/vnd.microsoft.icon",
+        ".heic": "image/heic",
+        ".psd": "image/vnd.adobe.photoshop",
+        ".raw": "image/x-raw",
+    },
+    video: {
+        ".mp4": "video/mp4",
+        ".webm": "video/webm",
+        ".ogg": "video/ogg",
+        ".mov": "video/quicktime",
+        ".avi": "video/x-msvideo",
+        ".mkv": "video/x-matroska",
+        ".flv": "video/x-flv",
+        ".wmv": "video/x-ms-wmv",
+        ".3gp": "video/3gpp",
+        ".ts": "video/mp2t",
+        ".mpeg": "video/mpeg",
+        ".mpg": "video/mpg",
+    },
+    audio: {
+        ".mp3": "audio/mpeg",
+        ".wav": "audio/wav",
+        ".flac": "audio/flac",
+        ".aac": "audio/aac",
+        ".ogg": "audio/ogg",
+        ".m4a": "audio/mp4",
+        ".opus": "audio/opus",
+    },
+    document: {
+        ".pdf": "application/pdf",
+        ".doc": "application/msword",
+        ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        ".odt": "application/vnd.oasis.opendocument.text",
+        ".txt": "text/plain",
+        ".rtf": "application/rtf",
+        ".md": "text/markdown",
+        ".markdown": "text/markdown",
+        ".tex": "application/x-tex",
+        ".log": "text/plain",
+        ".json": "application/json",
+        ".xml": "application/xml",
+        ".yaml": "application/x-yaml",
+        ".yml": "application/x-yaml",
+        ".ini": "text/plain",
+        ".cfg": "text/plain",
+        ".toml": "application/toml",
+        ".csv": "text/csv",
+        ".tsv": "text/tab-separated-values",
+    },
+    presentation: {
+        ".ppt": "application/vnd.ms-powerpoint",
+        ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+        ".odp": "application/vnd.oasis.opendocument.presentation",
+    },
+    spreadsheet: {
+        ".xls": "application/vnd.ms-excel",
+        ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        ".ods": "application/vnd.oasis.opendocument.spreadsheet",
+        ".csv": "text/csv",
+        ".tsv": "text/tab-separated-values",
+    },
+    code: {
+        ".py": "text/x-python",
+        ".java": "text/x-java-source",
+        ".c": "text/x-c",
+        ".cpp": "text/x-c++",
+        ".h": "text/x-c",
+        ".hpp": "text/x-c++",
+        ".js": "application/javascript",
+        ".cjs": "application/javascript",
+        ".mjs": "application/javascript",
+        ".jsx": "application/javascript",
+        ".ts": "application/typescript",
+        ".tsx": "application/typescript",
+        ".rb": "text/x-ruby",
+        ".php": "application/x-php",
+        ".go": "text/x-go",
+        ".rs": "text/rust",
+        ".swift": "text/x-swift",
+        ".kt": "text/x-kotlin",
+        ".sh": "application/x-shellscript",
+        ".bash": "application/x-shellscript",
+        ".ps1": "application/x-powershell",
+        ".sql": "application/sql",
+        ".yml": "application/x-yaml",
+        ".coffee": "text/coffeescript",
+        ".lua": "text/x-lua",
+    },
+    archive: {
+        ".zip": "application/zip",
+        ".tar": "application/x-tar",
+        ".gz": "application/gzip",
+        ".tgz": "application/gzip",
+        ".bz2": "application/x-bzip2",
+        ".xz": "application/x-xz",
+        ".rar": "application/vnd.rar",
+        ".7z": "application/x-7z-compressed",
+        ".iso": "application/x-iso9660-image",
+        ".dmg": "application/x-apple-diskimage",
+        ".jar": "application/java-archive",
+        ".war": "application/java-archive",
+        ".whl": "application/python-wheel",
+        ".egg": "application/python-egg",
+    },
+    font: {
+        ".ttf": "font/ttf",
+        ".otf": "font/otf",
+        ".woff": "font/woff",
+        ".woff2": "font/woff2",
+        ".eot": "application/vnd.ms-fontobject",
+    },
+    executable: {
+        ".exe": "application/vnd.microsoft.portable-executable",
+        ".dll": "application/vnd.microsoft.portable-executable",
+        ".bin": "application/octet-stream",
+        ".deb": "application/vnd.debian.binary-package",
+        ".rpm": "application/x-rpm",
+    },
+};
+/** Mirror of MEDIA_TYPES in Python: category -> Set of extensions */
+const MEDIA_TYPES = Object.fromEntries(Object.entries(MIME_TYPES).map(([cat, mapping]) => [
+    cat,
+    new Set(Object.keys(mapping)),
+]));
+/** ---- Helpers ---- */
+function toCategorySet(categories) {
+    const allCats = new Set(Object.keys(MIME_TYPES));
+    if (!categories) {
+        // all categories
+        return new Set(allCats);
+    }
+    const out = new Set();
+    for (const c of categories) {
+        const key = String(c);
+        if (allCats.has(key))
+            out.add(key);
+    }
+    return out.size ? out : new Set(allCats);
+}
+function normalizeCategories(categories, opts) {
+    const selected = categories ?? opts?.media_types ?? null;
+    return toCategorySet(selected);
+}
+function extOf(input) {
+    // Behaves like pathlib.Path(...).suffix.lower(): last extension only; lowercased.
+    let ext = path.extname(input || "");
+    if (!ext && input && input.startsWith(".")) {
+        // user passed ".jpg" directly
+        ext = input;
+    }
+    return (ext || "").toLowerCase();
+}
+function unionExts(categories) {
+    const out = new Set();
+    for (const c of categories) {
+        const set = MEDIA_TYPES[c];
+        for (const e of set)
+            out.add(e);
+    }
+    return out;
+}
+/** ---- API (Python parity) ---- */
+/**
+ * Return a sub-map of MEDIA_TYPES for the given categories.
+ * If categories is falsy, returns all categories.
+ */
+function getMediaMap(categories, opts) {
+    const cats = normalizeCategories(categories, opts);
+    const result = {};
+    for (const c of cats)
+        result[c] = new Set(MEDIA_TYPES[c]);
+    return result;
+}
+/**
+ * Return a flat, sorted list of all extensions for the given categories.
+ */
+function getMediaExts(categories, opts) {
+    const cats = normalizeCategories(categories, opts);
+    return Array.from(unionExts(cats)).sort();
+}
+/**
+ * Given a file path or extension, return its media category (e.g. "image") or null.
+ * Mirrors Python's confirm_type.
+ */
+function confirmType(pathOrExt, categories, opts) {
+    const cats = normalizeCategories(categories, opts);
+    const ext = extOf(pathOrExt);
+    // Preserve object insertion order like Python dict iteration
+    for (const [category, exts] of Object.entries(MEDIA_TYPES)) {
+        if (!cats.has(category))
+            continue;
+        if (ext && exts.has(ext))
+            return category;
+    }
+    return null;
+}
+/**
+ * True if the given file path or extension belongs to one of the categories.
+ */
+function isMediaType(pathOrExt, categories, opts) {
+    return confirmType(pathOrExt, categories, opts) !== null;
+}
+/**
+ * Look up the MIME type by extension; fall back to 'application/octet-stream'.
+ */
+function getMimeType(pathOrExt) {
+    const ext = extOf(pathOrExt);
+    for (const mapping of Object.values(MIME_TYPES)) {
+        if (ext && mapping[ext]) {
+            return mapping[ext];
+        }
+    }
+    return "application/octet-stream";
+}
+function getAllFileTypesSync(directory, categories, opts) {
+    // 🧩 Skip entirely if fs isn't available
+    if (!fs || !path)
+        return [];
+    try {
+        const stat = fs.statSync(directory);
+        if (!stat.isDirectory())
+            return [];
+        const cats = normalizeCategories(categories, opts);
+        const wanted = unionExts(cats);
+        const results = [];
+        function walkSync(dir) {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const ent of entries) {
+                const full = path.join(dir, ent.name);
+                if (ent.isDirectory()) {
+                    walkSync(full);
+                }
+                else if (ent.isFile()) {
+                    const ext = path.extname(ent.name).toLowerCase();
+                    if (wanted.has(ext))
+                        results.push(full);
+                }
+            }
+        }
+        walkSync(directory);
+        return results;
+    }
+    catch {
+        return [];
+    }
+}
+async function getAllFileTypes(directory, categories, opts) {
+    // 🧩 Skip entirely if fsp isn't available
+    if (!fsp || !path)
+        return [];
+    try {
+        const stat = await fsp.stat(directory);
+        if (!stat.isDirectory())
+            return [];
+        const cats = normalizeCategories(categories, opts);
+        const wanted = unionExts(cats);
+        const results = [];
+        async function walkAsync(dir) {
+            const entries = await fsp.readdir(dir, { withFileTypes: true });
+            for (const ent of entries) {
+                const full = path.join(dir, ent.name);
+                if (ent.isDirectory()) {
+                    await walkAsync(full);
+                }
+                else if (ent.isFile()) {
+                    const ext = path.extname(ent.name).toLowerCase();
+                    if (wanted.has(ext))
+                        results.push(full);
+                }
+            }
+        }
+        await walkAsync(directory);
+        return results;
+    }
+    catch {
+        return [];
+    }
+}
+/** Optional convenience re-exports that mirror your Python names */
+const get_all_file_types = getAllFileTypes;
+const get_media_map = getMediaMap;
+const get_media_exts = getMediaExts;
+const confirm_type = confirmType;
+const is_media_type = isMediaType;
+const get_mime_type = getMimeType;
+
+/**
+ * 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 {
+        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 {
+        return fn.apply(storage, args);
+    }
+    catch {
+        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;
+        return store[method](...args);
+    }
+    catch {
+        return undefined;
+    }
+}
+
+export { MIME_TYPES as M, MEDIA_TYPES as a, getMediaExts as b, confirmType as c, decodeJwt as d, isMediaType as e, getMimeType as f, getMediaMap as g, getAllFileTypesSync as h, isTokenExpired as i, getAllFileTypes as j, get_all_file_types as k, get_media_map as l, get_media_exts as m, confirm_type as n, is_media_type as o, get_mime_type as p, getSafeLocalStorage as q, callStorage as r, safeStorage as s, safeGlobalProp as t, pathBrowserify as u };
+//# sourceMappingURL=safe_storage-D4QfcTw0.js.map