@stacksjs/storage 0.70.87 → 0.70.90

package/dist/mime-verify.js

@@ -0,0 +1,47 @@
+export function detectMimeFromMagicBytes(bytes) {
+  const view = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+  if (view.length < 4)
+    return null;
+  if (view[0] === 137 && view[1] === 80 && view[2] === 78 && view[3] === 71 && view[4] === 13 && view[5] === 10 && view[6] === 26 && view[7] === 10)
+    return "image/png";
+  if (view[0] === 255 && view[1] === 216 && view[2] === 255)
+    return "image/jpeg";
+  if (view[0] === 71 && view[1] === 73 && view[2] === 70 && view[3] === 56)
+    return "image/gif";
+  if (view[0] === 82 && view[1] === 73 && view[2] === 70 && view[3] === 70 && view.length >= 12) {
+    if (view[8] === 87 && view[9] === 69 && view[10] === 66 && view[11] === 80)
+      return "image/webp";
+    if (view[8] === 87 && view[9] === 65 && view[10] === 86 && view[11] === 69)
+      return "audio/wav";
+  }
+  if (view[0] === 37 && view[1] === 80 && view[2] === 68 && view[3] === 70)
+    return "application/pdf";
+  if (view[0] === 80 && view[1] === 75 && (view[2] === 3 || view[2] === 5) && (view[3] === 4 || view[3] === 6))
+    return "application/zip";
+  if (view.length >= 12 && view[4] === 102 && view[5] === 116 && view[6] === 121 && view[7] === 112) {
+    const brand = String.fromCharCode(view[8] ?? 0, view[9] ?? 0, view[10] ?? 0, view[11] ?? 0);
+    if (brand === "avif" || brand === "avis")
+      return "image/avif";
+    if (brand === "heic" || brand === "heix" || brand === "mif1")
+      return "image/heic";
+    return "video/mp4";
+  }
+  if (view[0] === 26 && view[1] === 69 && view[2] === 223 && view[3] === 163)
+    return "video/webm";
+  if (view[0] === 73 && view[1] === 68 && view[2] === 51)
+    return "audio/mpeg";
+  if (view[0] === 255 && (view[1] ?? 0) >= 224)
+    return "audio/mpeg";
+  return null;
+}
+function normalizeContentType(contentType) {
+  return contentType.split(";")[0]?.trim().toLowerCase() ?? "";
+}
+export async function verifyUploadedMime(path, expectedContentType, options = {}) {
+  const { Storage } = await import("./facade"), bytes = await Storage.disk(options.disk).readToUint8Array(path), expected = normalizeContentType(expectedContentType), detected = detectMimeFromMagicBytes(bytes.slice(0, 32));
+  return {
+    ok: detected === expected || detected === "image/jpeg" && (expected === "image/jpg" || expected === "image/pjpeg"),
+    expected,
+    detected
+  };
+}

package/dist/move.js

@@ -0,0 +1,55 @@
+import { err, handleError, ok } from "@stacksjs/error-handling";
+import { log } from "@stacksjs/logging";
+import { path } from "@stacksjs/path";
+import { fs } from "./fs";
+export async function move(src, dest, options) {
+  try {
+    if (Array.isArray(src)) {
+      const errors = [], operations = src.map(async (file) => {
+        const from = file, to = path.resolve(dest, path.basename(file)), result = await rename(from, to, options);
+        if (result.isErr) {
+          log.error(result.error);
+          errors.push(result.error);
+        }
+      });
+      await Promise.all(operations);
+      if (errors.length > 0)
+        return err(handleError(errors[0]));
+      return ok({ message: "Files moved successfully" });
+    }
+    const result = await rename(src, dest, options);
+    if (result.isErr) {
+      log.error(result.error);
+      return err(handleError(result.error));
+    }
+    return ok({ message: "File moved successfully" });
+  } catch (error) {
+    return err(handleError(error));
+  }
+}
+export async function rename(from, to, options) {
+  return new Promise((resolve, reject) => {
+    try {
+      const dir = path.dirname(to);
+      if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: !0 });
+      if (!fs.existsSync(from))
+        return reject(err(Error(`File or directory does not exist: ${from}`)));
+      if (fs.existsSync(to)) {
+        if (!options?.overwrite)
+          return reject(err(Error(`File or directory already exists: ${to}`)));
+        fs.rmSync(to, { recursive: !0, force: !0 });
+      }
+      fs.renameSync(from, to);
+      return resolve(ok({ message: "File moved successfully" }));
+    } catch (error) {
+      if (error.code === "ENOENT")
+        log.error(`File or directory does not exist
+
+`, error);
+      else
+        log.error(error);
+      return reject(err(Error(error)));
+    }
+  });
+}

package/dist/path-sanitize.js

@@ -0,0 +1,84 @@
+export class PathSanitizeError extends Error {
+  reason;
+  constructor(message, reason) {
+    super(message);
+    this.name = "PathSanitizeError";
+    this.reason = reason;
+  }
+}
+const MAX_COMPONENT_LENGTH = 255, ALLOWED_DIR_CHAR = /^[A-Za-z0-9._-]+$/, ALLOWED_FILENAME_CHAR = /^[A-Za-z0-9._-]+$/, ALLOWED_EXTENSION = /^[a-z0-9]+$/;
+export function sanitizePresignedDir(dir) {
+  if (dir === void 0 || dir === "")
+    return "";
+  if (typeof dir !== "string")
+    throw new PathSanitizeError(`dir must be a string, got ${typeof dir}`, "not-string");
+  const trimmed = dir.replace(/^\/+/, "").replace(/\/+$/, "");
+  if (dir.startsWith("/"))
+    throw new PathSanitizeError(`dir must not be absolute: '${dir}'`, "absolute-path");
+  if (trimmed === "")
+    return "";
+  if (trimmed.includes("\x00"))
+    throw new PathSanitizeError("dir contains null byte", "null-byte");
+  if (/[\x00-\x1F\x7F]/.test(trimmed))
+    throw new PathSanitizeError("dir contains control character", "control-char");
+  const segments = trimmed.split("/");
+  for (const segment of segments) {
+    if (segment === "" || segment === "." || segment === "..")
+      throw new PathSanitizeError(`dir contains traversal or empty segment: '${dir}'`, "traversal");
+    if (segment.length > MAX_COMPONENT_LENGTH)
+      throw new PathSanitizeError(`dir segment exceeds ${MAX_COMPONENT_LENGTH} chars`, "too-long");
+    if (!ALLOWED_DIR_CHAR.test(segment))
+      throw new PathSanitizeError(`dir segment contains disallowed character: '${segment}'`, "invalid-char");
+  }
+  return segments.join("/");
+}
+export function sanitizePresignedFilename(filename) {
+  if (typeof filename !== "string")
+    throw new PathSanitizeError(`filename must be a string, got ${typeof filename}`, "not-string");
+  if (filename === "")
+    throw new PathSanitizeError("filename must not be empty", "empty");
+  if (filename.length > MAX_COMPONENT_LENGTH)
+    throw new PathSanitizeError(`filename exceeds ${MAX_COMPONENT_LENGTH} chars`, "too-long");
+  if (filename.includes("\x00"))
+    throw new PathSanitizeError("filename contains null byte", "null-byte");
+  if (/[\x00-\x1F\x7F]/.test(filename))
+    throw new PathSanitizeError("filename contains control character", "control-char");
+  if (filename.includes("/") || filename.includes("\\"))
+    throw new PathSanitizeError(`filename must not contain path separators: '${filename}'`, "traversal");
+  if (filename === "." || filename === ".." || filename.startsWith("../") || filename.includes("/.."))
+    throw new PathSanitizeError(`filename contains traversal token: '${filename}'`, "traversal");
+  if (!ALLOWED_FILENAME_CHAR.test(filename))
+    throw new PathSanitizeError(`filename contains disallowed character: '${filename}'`, "invalid-char");
+  const dotIdx = filename.lastIndexOf(".");
+  if (dotIdx > 0 && dotIdx < filename.length - 1) {
+    const ext = filename.slice(dotIdx + 1).toLowerCase();
+    if (!ALLOWED_EXTENSION.test(ext))
+      throw new PathSanitizeError(`filename has invalid extension: '.${ext}'`, "invalid-extension");
+  }
+  return filename;
+}
+const DISK_NAME_RE = /^[a-z0-9_-]+$/i;
+export function parseDiskPath(input) {
+  if (typeof input !== "string" || input.length === 0)
+    throw new PathSanitizeError("disk-path reference is empty", "empty");
+  if (input.includes("\x00"))
+    throw new PathSanitizeError("disk-path reference contains a null byte", "null-byte");
+  const colonIdx = input.indexOf(":");
+  if (colonIdx <= 0 || colonIdx === input.length - 1)
+    throw new PathSanitizeError(`disk-path reference must use '<disk>:<path>' format, got '${input}'`, "invalid-char");
+  const disk = input.slice(0, colonIdx), path = input.slice(colonIdx + 1);
+  if (!DISK_NAME_RE.test(disk))
+    throw new PathSanitizeError(`disk name '${disk}' is invalid (alphanumeric + '-' / '_' only)`, "invalid-char");
+  if (path.startsWith("/") || /^[A-Za-z]:[\\/]/.test(path))
+    throw new PathSanitizeError(`disk-path '${path}' is absolute`, "absolute-path");
+  if (path.includes("\x00"))
+    throw new PathSanitizeError("disk-path contains a null byte", "null-byte");
+  for (let i = 0;i < path.length; i++) {
+    const code = path.charCodeAt(i);
+    if (code < 32 || code === 127)
+      throw new PathSanitizeError(`disk-path contains a control character at index ${i}`, "control-char");
+  }
+  if (path.split(/[/\\]/).some((seg) => seg === ".."))
+    throw new PathSanitizeError(`disk-path '${path}' contains a '..' segment`, "traversal");
+  return { disk, path };
+}

package/dist/put-file.js

@@ -0,0 +1,85 @@
+const MIME_TO_EXT = {
+  "image/jpeg": "jpg",
+  "image/jpg": "jpg",
+  "image/png": "png",
+  "image/webp": "webp",
+  "image/gif": "gif",
+  "image/svg+xml": "svg",
+  "image/avif": "avif",
+  "application/pdf": "pdf",
+  "application/json": "json",
+  "application/zip": "zip",
+  "application/octet-stream": "bin",
+  "text/plain": "txt",
+  "text/csv": "csv",
+  "text/html": "html",
+  "video/mp4": "mp4",
+  "video/webm": "webm",
+  "audio/mpeg": "mp3",
+  "audio/wav": "wav"
+};
+function extFromOriginalName(name) {
+  if (!name)
+    return null;
+  const idx = name.lastIndexOf(".");
+  if (idx <= 0 || idx === name.length - 1)
+    return null;
+  const ext = name.slice(idx + 1).toLowerCase();
+  if (!/^[a-z0-9]+$/.test(ext))
+    return null;
+  return ext;
+}
+function originalNameOf(file) {
+  return file.originalName ?? file.name;
+}
+function mimetypeOf(file) {
+  return file.mimetype ?? file.mimeType;
+}
+function deriveExtension(file) {
+  const mime = mimetypeOf(file);
+  return extFromOriginalName(originalNameOf(file)) ?? (mime && MIME_TO_EXT[mime.toLowerCase()]) ?? null;
+}
+async function readBytes(file) {
+  if (file.buffer !== void 0)
+    return file.buffer;
+  if (typeof file.bytes === "function")
+    return await file.bytes();
+  if (typeof file.arrayBuffer === "function")
+    return await file.arrayBuffer();
+  throw Error("UploadedFile is missing both `buffer` and `bytes()`/`arrayBuffer()` accessors \u2014 cannot read file contents.");
+}
+function bufferLikeToHash(buffer) {
+  const view = buffer instanceof ArrayBuffer ? new Uint8Array(buffer) : buffer, hasher = new Bun.CryptoHasher("sha256");
+  hasher.update(view);
+  return hasher.digest("hex").slice(0, 32);
+}
+function sanitizeOriginalName(name) {
+  return name.replace(/[/\\]/g, "_").replace(/\.{2,}/g, "_").replace(/[^A-Za-z0-9._-]/g, "_").replace(/_+/g, "_");
+}
+async function resolveFilename(file, strategy) {
+  if (typeof strategy === "function")
+    return strategy(file);
+  switch (strategy) {
+    case "uuid":
+      return crypto.randomUUID().replace(/-/g, "");
+    case "hash": {
+      const bytes = await readBytes(file);
+      return bufferLikeToHash(bytes);
+    }
+    case "original": {
+      const name = originalNameOf(file);
+      return name ? sanitizeOriginalName(name) : crypto.randomUUID().replace(/-/g, "");
+    }
+  }
+}
+function joinPath(...parts) {
+  return parts.filter(Boolean).map((p, i) => i === 0 ? p.replace(/\/+$/, "") : p.replace(/^\/+/, "").replace(/\/+$/, "")).filter(Boolean).join("/");
+}
+export async function putUploadedFile(manager, file, opts) {
+  const disk = manager.disk(opts.disk), baseName = await resolveFilename(file, opts.filename ?? "uuid"), wantExt = opts.preserveExtension !== !1, baseHasExt = /\.[A-Za-z0-9]+$/.test(baseName), ext = wantExt && !baseHasExt ? deriveExtension(file) : null, finalName = ext ? `${baseName}.${ext}` : baseName, fullPath = joinPath(opts.dir ?? "", finalName), raw = await readBytes(file);
+  let contents = raw instanceof ArrayBuffer ? new Uint8Array(raw) : raw;
+  if (opts.transform)
+    contents = await opts.transform(contents);
+  const written = await disk.write(fullPath, contents), url = await disk.publicUrl(fullPath);
+  return { ...written, path: fullPath, url };
+}

package/dist/s3-presigned-post.js

@@ -0,0 +1,68 @@
+import { createHmac } from "node:crypto";
+import { Buffer } from "node:buffer";
+const ALGORITHM = "AWS4-HMAC-SHA256", MIN_EXPIRY = 60, MAX_EXPIRY = 604800;
+function hmac(key, data) {
+  return createHmac("sha256", key).update(data, "utf8").digest();
+}
+function deriveSigningKey(secretAccessKey, dateStamp, region) {
+  const kDate = hmac(`AWS4${secretAccessKey}`, dateStamp), kRegion = hmac(kDate, region), kService = hmac(kRegion, "s3");
+  return hmac(kService, "aws4_request");
+}
+function isoDate(now) {
+  const amzDate = now.toISOString().replace(/[:-]|\.\d{3}/g, ""), dateStamp = amzDate.slice(0, 8);
+  return { amzDate, dateStamp };
+}
+export function signS3PresignedPost(input) {
+  const expiresIn = Math.floor(input.expiresIn);
+  if (!Number.isFinite(expiresIn) || expiresIn < MIN_EXPIRY || expiresIn > MAX_EXPIRY)
+    throw RangeError(`[storage/s3-post] expiresIn must be between ${MIN_EXPIRY}s and ${MAX_EXPIRY}s (got ${expiresIn}s)`);
+  if (!input.bucket)
+    throw Error("[storage/s3-post] bucket is required");
+  if (!input.credentials?.accessKeyId || !input.credentials?.secretAccessKey)
+    throw Error("[storage/s3-post] credentials.accessKeyId and credentials.secretAccessKey are required");
+  const now = new Date, { amzDate, dateStamp } = isoDate(now), credentialScope = `${dateStamp}/${input.region}/s3/aws4_request`, credentialField = `${input.credentials.accessKeyId}/${credentialScope}`, expirationDate = new Date(now.getTime() + expiresIn * 1000).toISOString().replace(/\.\d{3}Z$/, "Z"), conditions = [];
+  conditions.push({ bucket: input.bucket });
+  if (typeof input.key === "string")
+    conditions.push({ key: input.key });
+  else
+    conditions.push(["starts-with", "$key", input.key.startsWith]);
+  const acl = input.acl ?? "private";
+  conditions.push({ acl });
+  if (typeof input.contentType === "string")
+    conditions.push({ "Content-Type": input.contentType });
+  else
+    conditions.push(["starts-with", "$Content-Type", input.contentType.startsWith]);
+  if (input.contentLengthRange) {
+    if (!Number.isFinite(input.contentLengthRange.min) || input.contentLengthRange.min < 0 || !Number.isFinite(input.contentLengthRange.max) || input.contentLengthRange.max < input.contentLengthRange.min)
+      throw RangeError("[storage/s3-post] contentLengthRange must satisfy 0 <= min <= max");
+    conditions.push(["content-length-range", input.contentLengthRange.min, input.contentLengthRange.max]);
+  }
+  if (input.fields)
+    for (const [k, v] of Object.entries(input.fields))
+      conditions.push({ [k]: v });
+  conditions.push({ "x-amz-credential": credentialField });
+  conditions.push({ "x-amz-algorithm": ALGORITHM });
+  conditions.push({ "x-amz-date": amzDate });
+  if (input.credentials.sessionToken)
+    conditions.push({ "x-amz-security-token": input.credentials.sessionToken });
+  const policy = {
+    expiration: expirationDate,
+    conditions
+  }, policyBase64 = Buffer.from(JSON.stringify(policy), "utf8").toString("base64"), signingKey = deriveSigningKey(input.credentials.secretAccessKey, dateStamp, input.region), signature = createHmac("sha256", signingKey).update(policyBase64, "utf8").digest("hex"), fields = {
+    key: typeof input.key === "string" ? input.key : `${input.key.startsWith}\${filename}`,
+    acl,
+    "Content-Type": typeof input.contentType === "string" ? input.contentType : input.contentType.startsWith,
+    "x-amz-credential": credentialField,
+    "x-amz-algorithm": ALGORITHM,
+    "x-amz-date": amzDate,
+    policy: policyBase64,
+    "x-amz-signature": signature,
+    ...input.credentials.sessionToken ? { "x-amz-security-token": input.credentials.sessionToken } : {},
+    ...input.fields ?? {}
+  };
+  return {
+    url: `https://${input.bucket}.s3.${input.region}.amazonaws.com/`,
+    fields,
+    key: typeof input.key === "string" ? input.key : input.key.startsWith
+  };
+}

package/dist/signed-url.js

@@ -0,0 +1,86 @@
+import { Buffer } from "node:buffer";
+import { createHmac, timingSafeEqual } from "node:crypto";
+import process from "node:process";
+const ALG = "HS256";
+function getAppKey() {
+  const k = process.env.APP_KEY;
+  if (!k || k.length < 16) {
+    if (process.env.APP_ENV === "production" || process.env.NODE_ENV === "production")
+      throw Error("[storage/signed-url] APP_KEY is missing or too short (need \u226516 chars). Cannot sign URL.");
+  }
+  return k || "stacks-default-key-dev-only-do-not-use-prod";
+}
+function base64UrlEncode(buf) {
+  return buf.toString("base64url");
+}
+function base64UrlDecode(str) {
+  return Buffer.from(str, "base64url");
+}
+function normalizeExpiry(expiresIn) {
+  if (expiresIn instanceof Date)
+    return Math.floor(expiresIn.getTime() / 1000);
+  return Math.floor(Date.now() / 1000) + Math.floor(expiresIn);
+}
+export function createSignedStorageToken(path, options) {
+  const exp = normalizeExpiry(options.expiresIn), iat = Math.floor(Date.now() / 1000), header = { alg: ALG, typ: "JWT" }, payload = {
+    iss: options.issuer || "stacks",
+    iat,
+    exp,
+    path
+  }, headerPart = base64UrlEncode(Buffer.from(JSON.stringify(header))), payloadPart = base64UrlEncode(Buffer.from(JSON.stringify(payload))), signingInput = `${headerPart}.${payloadPart}`, sig = base64UrlEncode(createHmac("sha256", getAppKey()).update(signingInput).digest());
+  return `${signingInput}.${sig}`;
+}
+const REVOCATION_LIMIT = 1e5, revokedSignatures = new Set;
+function rememberRevoked(sigPart) {
+  if (revokedSignatures.has(sigPart))
+    return;
+  if (revokedSignatures.size >= REVOCATION_LIMIT) {
+    const oldest = revokedSignatures.values().next().value;
+    if (oldest !== void 0)
+      revokedSignatures.delete(oldest);
+  }
+  revokedSignatures.add(sigPart);
+}
+export function revokeSignedStorageToken(token) {
+  if (typeof token !== "string" || token.length === 0)
+    return;
+  const parts = token.split("."), sig = parts.length === 3 ? parts[2] : token;
+  if (sig)
+    rememberRevoked(sig);
+}
+export function isSignedStorageTokenRevoked(sigPart) {
+  return revokedSignatures.has(sigPart);
+}
+export function clearRevokedSignedStorageTokens() {
+  revokedSignatures.clear();
+}
+export function verifySignedStorageToken(token, requestedPath) {
+  if (typeof token !== "string")
+    return { valid: !1, reason: "malformed" };
+  const parts = token.split(".");
+  if (parts.length !== 3)
+    return { valid: !1, reason: "malformed" };
+  const headerPart = parts[0], payloadPart = parts[1], sigPart = parts[2], signingInput = `${headerPart}.${payloadPart}`, expectedSig = createHmac("sha256", getAppKey()).update(signingInput).digest();
+  let providedSig;
+  try {
+    providedSig = base64UrlDecode(sigPart);
+  } catch {
+    return { valid: !1, reason: "malformed" };
+  }
+  if (providedSig.length !== expectedSig.length || !timingSafeEqual(providedSig, expectedSig))
+    return { valid: !1, reason: "bad_signature" };
+  if (revokedSignatures.has(sigPart))
+    return { valid: !1, reason: "revoked" };
+  let claims;
+  try {
+    claims = JSON.parse(base64UrlDecode(payloadPart).toString("utf8"));
+  } catch {
+    return { valid: !1, reason: "malformed" };
+  }
+  const now = Math.floor(Date.now() / 1000);
+  if (typeof claims.exp !== "number" || now >= claims.exp)
+    return { valid: !1, reason: "expired" };
+  if (claims.path !== requestedPath)
+    return { valid: !1, reason: "path_mismatch" };
+  return { valid: !0, claims };
+}

package/dist/static-serve.js

@@ -0,0 +1,110 @@
+import { createHash } from "node:crypto";
+import { extname } from "node:path";
+const etagCache = new Map, ETAG_CACHE_MAX = 5000, FINGERPRINTED = /\.[a-f0-9]{8,}\./;
+export async function serveFile(req, filePath, options = {}) {
+  const file = Bun.file(filePath);
+  if (!await file.exists())
+    return new Response("Not Found", { status: 404 });
+  const stat = await file.stat(), mtimeMs = Math.floor(typeof stat.mtimeMs === "number" ? stat.mtimeMs : stat.mtime?.getTime() ?? Date.now()), lastModified = new Date(mtimeMs).toUTCString(), contentType = options.contentType || file.type || guessMime(filePath);
+  let etag;
+  if (options.etag !== !1)
+    etag = await computeEtag(filePath, mtimeMs, file);
+  const ifNoneMatch = req.headers.get("if-none-match");
+  if (etag && ifNoneMatch && stripWeak(ifNoneMatch) === etag)
+    return new Response(null, {
+      status: 304,
+      headers: buildHeaders({ etag, lastModified, contentType, filePath, options, omitContentType: !0 })
+    });
+  const ifModifiedSince = req.headers.get("if-modified-since");
+  if (ifModifiedSince) {
+    const sinceMs = Date.parse(ifModifiedSince);
+    if (!Number.isNaN(sinceMs) && mtimeMs <= sinceMs)
+      return new Response(null, {
+        status: 304,
+        headers: buildHeaders({ etag, lastModified, contentType, filePath, options, omitContentType: !0 })
+      });
+  }
+  return new Response(file, {
+    status: 200,
+    headers: buildHeaders({ etag, lastModified, contentType, filePath, options })
+  });
+}
+function buildHeaders(input) {
+  const h = new Headers;
+  if (!input.omitContentType)
+    h.set("Content-Type", input.contentType);
+  h.set("Last-Modified", input.lastModified);
+  if (input.etag)
+    h.set("ETag", `"${input.etag}"`);
+  h.set("Cache-Control", input.options.cacheControl || pickCacheControl(input.filePath, input.options));
+  h.set("Vary", "Accept-Encoding");
+  return h;
+}
+function pickCacheControl(filePath, options) {
+  if (FINGERPRINTED.test(filePath))
+    return "public, max-age=31536000, immutable";
+  return `public, max-age=${options.defaultMaxAge ?? 300}, must-revalidate`;
+}
+async function computeEtag(filePath, mtimeMs, file) {
+  const cached = etagCache.get(filePath);
+  if (cached && cached.mtimeMs === mtimeMs)
+    return cached.etag;
+  const buf = await file.arrayBuffer(), etag = createHash("sha256").update(new Uint8Array(buf)).digest("hex").slice(0, 16);
+  if (etagCache.size >= ETAG_CACHE_MAX) {
+    const firstKey = etagCache.keys().next().value;
+    if (firstKey !== void 0)
+      etagCache.delete(firstKey);
+  }
+  etagCache.set(filePath, { mtimeMs, etag });
+  return etag;
+}
+function stripWeak(v) {
+  let s = v.trim();
+  if (s.startsWith("W/"))
+    s = s.slice(2);
+  if (s.startsWith('"') && s.endsWith('"'))
+    s = s.slice(1, -1);
+  return s;
+}
+function guessMime(filePath) {
+  switch (extname(filePath).toLowerCase()) {
+    case ".js":
+    case ".mjs":
+    case ".cjs":
+      return "application/javascript; charset=utf-8";
+    case ".css":
+      return "text/css; charset=utf-8";
+    case ".html":
+    case ".htm":
+      return "text/html; charset=utf-8";
+    case ".json":
+      return "application/json; charset=utf-8";
+    case ".svg":
+      return "image/svg+xml";
+    case ".webp":
+      return "image/webp";
+    case ".png":
+      return "image/png";
+    case ".jpg":
+    case ".jpeg":
+      return "image/jpeg";
+    case ".gif":
+      return "image/gif";
+    case ".ico":
+      return "image/x-icon";
+    case ".woff":
+      return "font/woff";
+    case ".woff2":
+      return "font/woff2";
+    case ".ttf":
+      return "font/ttf";
+    case ".txt":
+      return "text/plain; charset=utf-8";
+    case ".wasm":
+      return "application/wasm";
+    case ".map":
+      return "application/json; charset=utf-8";
+    default:
+      return "application/octet-stream";
+  }
+}

package/dist/storage.js

@@ -0,0 +1,9 @@
+export * from "./copy";
+export * from "./delete";
+export * from "./files";
+export * from "./folders";
+export * from "./fs";
+export * from "./helpers";
+export * from "./move";
+export * from "./visibility";
+export * from "./zip";

package/dist/types/filesystem.js

@@ -0,0 +1,40 @@
+export function localDisk(root, options) {
+  return {
+    driver: "local",
+    root,
+    visibility: "private",
+    ...options
+  };
+}
+export function s3Disk(bucket, options) {
+  return {
+    driver: "s3",
+    bucket,
+    region: process.env.AWS_DEFAULT_REGION || "us-east-1",
+    visibility: "private",
+    ...options
+  };
+}
+export function configFromEnv(base = {}) {
+  const env = process.env;
+  return {
+    default: env.FILESYSTEM_DISK || base.default || "local",
+    disks: {
+      ...base.disks,
+      ...env.AWS_ACCESS_KEY_ID && env.AWS_BUCKET ? {
+        s3: {
+          driver: "s3",
+          bucket: env.AWS_BUCKET,
+          region: env.AWS_DEFAULT_REGION || "us-east-1",
+          endpoint: env.AWS_ENDPOINT,
+          url: env.AWS_URL,
+          usePathStyleEndpoint: env.AWS_USE_PATH_STYLE_ENDPOINT === "true",
+          credentials: {
+            key: env.AWS_ACCESS_KEY_ID,
+            secret: env.AWS_SECRET_ACCESS_KEY || ""
+          }
+        }
+      } : {}
+    }
+  };
+}

package/dist/types.js

@@ -0,0 +1,25 @@
+export var Visibility;
+((Visibility) => {
+  Visibility.PUBLIC = "public";
+  Visibility.PRIVATE = "private";
+})(Visibility ||= {});
+export async function* createDirectoryListing(entries) {
+  for (const entry of entries)
+    yield entry;
+}
+export function normalizeExpiryToMilliseconds(expiry) {
+  if (expiry instanceof Date)
+    return expiry.getTime() - Date.now();
+  return expiry * 1000;
+}
+export function normalizeExpiryToDate(expiry) {
+  if (expiry instanceof Date)
+    return expiry;
+  return new Date(Date.now() + expiry * 1000);
+}
+export function isFile(entry) {
+  return entry.type === "file";
+}
+export function isDirectory(entry) {
+  return entry.type === "directory";
+}