initial commit

node_modules/unstorage/dist/drivers/cloudflare-kv-binding.cjs

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = void 0;
+
+var _utils = require("./utils/index.cjs");
+
+var _default = (0, _utils.defineDriver)((opts = {}) => {
+  const binding = getBinding(opts.binding);
+
+  async function getKeys(base) {
+    const kvList = await binding.list(base ? {
+      prefix: base
+    } : void 0);
+    return kvList.keys.map(key => key.name);
+  }
+
+  return {
+    async hasItem(key) {
+      return (await binding.get(key)) !== null;
+    },
+
+    getItem(key) {
+      return binding.get(key);
+    },
+
+    setItem(key, value) {
+      return binding.put(key, value);
+    },
+
+    removeItem(key) {
+      return binding.delete(key);
+    },
+
+    getKeys,
+
+    async clear() {
+      const keys = await getKeys();
+      await Promise.all(keys.map(key => binding.delete(key)));
+    }
+
+  };
+});
+
+module.exports = _default;
+
+function getBinding(binding = "STORAGE") {
+  let bindingName = "[binding]";
+
+  if (typeof binding === "string") {
+    bindingName = binding;
+    binding = globalThis[bindingName];
+  }
+
+  if (!binding) {
+    throw new Error(`Invalid Cloudflare KV binding '${bindingName}': ${binding}`);
+  }
+
+  for (const key of ["get", "put", "delete"]) {
+    if (!(key in binding)) {
+      throw new Error(`Invalid Cloudflare KV binding '${bindingName}': '${key}' key is missing`);
+    }
+  }
+
+  return binding;
+}

node_modules/unstorage/dist/drivers/cloudflare-kv-binding.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="@cloudflare/workers-types" />
+export interface KVOptions {
+    binding?: string | KVNamespace;
+}
+declare const _default: (opts?: KVOptions) => import("../types").Driver;
+export default _default;

node_modules/unstorage/dist/drivers/cloudflare-kv-binding.mjs

@@ -0,0 +1,43 @@
+import { defineDriver } from "./utils/index.mjs";
+export default defineDriver((opts = {}) => {
+  const binding = getBinding(opts.binding);
+  async function getKeys(base) {
+    const kvList = await binding.list(base ? { prefix: base } : void 0);
+    return kvList.keys.map((key) => key.name);
+  }
+  return {
+    async hasItem(key) {
+      return await binding.get(key) !== null;
+    },
+    getItem(key) {
+      return binding.get(key);
+    },
+    setItem(key, value) {
+      return binding.put(key, value);
+    },
+    removeItem(key) {
+      return binding.delete(key);
+    },
+    getKeys,
+    async clear() {
+      const keys = await getKeys();
+      await Promise.all(keys.map((key) => binding.delete(key)));
+    }
+  };
+});
+function getBinding(binding = "STORAGE") {
+  let bindingName = "[binding]";
+  if (typeof binding === "string") {
+    bindingName = binding;
+    binding = globalThis[bindingName];
+  }
+  if (!binding) {
+    throw new Error(`Invalid Cloudflare KV binding '${bindingName}': ${binding}`);
+  }
+  for (const key of ["get", "put", "delete"]) {
+    if (!(key in binding)) {
+      throw new Error(`Invalid Cloudflare KV binding '${bindingName}': '${key}' key is missing`);
+    }
+  }
+  return binding;
+}

node_modules/unstorage/dist/drivers/cloudflare-kv-http.cjs

@@ -0,0 +1,165 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = void 0;
+
+var _ofetch = require("ofetch");
+
+var _utils = require("./utils/index.cjs");
+
+const LOG_TAG = "[unstorage] [cloudflare-http] ";
+
+var _default = (0, _utils.defineDriver)(opts => {
+  if (!opts.accountId) {
+    throw new Error(LOG_TAG + "`accountId` is required.");
+  }
+
+  if (!opts.namespaceId) {
+    throw new Error(LOG_TAG + "`namespaceId` is required.");
+  }
+
+  let headers;
+
+  if ("apiToken" in opts) {
+    headers = {
+      Authorization: `Bearer ${opts.apiToken}`
+    };
+  } else if ("userServiceKey" in opts) {
+    headers = {
+      "X-Auth-User-Service-Key": opts.userServiceKey
+    };
+  } else if (opts.email && opts.apiKey) {
+    headers = {
+      "X-Auth-Email": opts.email,
+      "X-Auth-Key": opts.apiKey
+    };
+  } else {
+    throw new Error(LOG_TAG + "One of the `apiToken`, `userServiceKey`, or a combination of `email` and `apiKey` is required.");
+  }
+
+  const apiURL = opts.apiURL || "https://api.cloudflare.com";
+  const baseURL = `${apiURL}/client/v4/accounts/${opts.accountId}/storage/kv/namespaces/${opts.namespaceId}`;
+
+  const kvFetch = _ofetch.$fetch.create({
+    baseURL,
+    headers
+  });
+
+  const hasItem = async key => {
+    try {
+      const res = await kvFetch(`/metadata/${key}`);
+      return res?.success === true;
+    } catch (err) {
+      if (!err.response) {
+        throw err;
+      }
+
+      if (err.response.status === 404) {
+        return false;
+      }
+
+      throw err;
+    }
+  };
+
+  const getItem = async key => {
+    try {
+      return await kvFetch(`/values/${key}`).then(r => r.text());
+    } catch (err) {
+      if (!err.response) {
+        throw err;
+      }
+
+      if (err.response.status === 404) {
+        return null;
+      }
+
+      throw err;
+    }
+  };
+
+  const setItem = async (key, value) => {
+    return await kvFetch(`/values/${key}`, {
+      method: "PUT",
+      body: value
+    });
+  };
+
+  const removeItem = async key => {
+    return await kvFetch(`/values/${key}`, {
+      method: "DELETE"
+    });
+  };
+
+  const getKeys = async base => {
+    const keys = [];
+    const params = new URLSearchParams();
+
+    if (base) {
+      params.set("prefix", base);
+    }
+
+    const firstPage = await kvFetch("/keys", {
+      params
+    });
+    firstPage.result.forEach(({
+      name
+    }) => keys.push(name));
+    const cursor = firstPage.result_info.cursor;
+
+    if (cursor) {
+      params.set("cursor", cursor);
+    }
+
+    while (params.has("cursor")) {
+      const pageResult = await kvFetch("/keys", {
+        params
+      });
+      pageResult.result.forEach(({
+        name
+      }) => keys.push(name));
+      const pageCursor = pageResult.result_info.cursor;
+
+      if (pageCursor) {
+        params.set("cursor", pageCursor);
+      } else {
+        params.delete("cursor");
+      }
+    }
+
+    return keys;
+  };
+
+  const clear = async () => {
+    const keys = await getKeys();
+    const chunks = keys.reduce((acc, key, i) => {
+      if (i % 1e4 === 0) {
+        acc.push([]);
+      }
+
+      acc[acc.length - 1].push(key);
+      return acc;
+    }, [[]]);
+    await Promise.all(chunks.map(chunk => {
+      return kvFetch("/bulk", {
+        method: "DELETE",
+        body: {
+          keys: chunk
+        }
+      });
+    }));
+  };
+
+  return {
+    hasItem,
+    getItem,
+    setItem,
+    removeItem,
+    getKeys,
+    clear
+  };
+});
+
+module.exports = _default;

node_modules/unstorage/dist/drivers/cloudflare-kv-http.d.ts

@@ -0,0 +1,47 @@
+interface KVAuthAPIToken {
+    /**
+     * API Token generated from the [User Profile 'API Tokens' page](https://dash.cloudflare.com/profile/api-tokens)
+     * of the Cloudflare console.
+     * @see https://api.cloudflare.com/#getting-started-requests
+     */
+    apiToken: string;
+}
+interface KVAuthServiceKey {
+    /**
+     * A special Cloudflare API key good for a restricted set of endpoints.
+     * Always begins with "v1.0-", may vary in length.
+     * May be used to authenticate in place of `apiToken` or `apiKey` and `email`.
+     * @see https://api.cloudflare.com/#getting-started-requests
+     */
+    userServiceKey: string;
+}
+interface KVAuthEmailKey {
+    /**
+     * Email address associated with your account.
+     * Should be used along with `apiKey` to authenticate in place of `apiToken`.
+     */
+    email: string;
+    /**
+     * API key generated on the "My Account" page of the Cloudflare console.
+     * Should be used along with `email` to authenticate in place of `apiToken`.
+     * @see https://api.cloudflare.com/#getting-started-requests
+     */
+    apiKey: string;
+}
+export declare type KVHTTPOptions = {
+    /**
+     * Cloudflare account ID (required)
+     */
+    accountId: string;
+    /**
+     * The ID of the KV namespace to target (required)
+     */
+    namespaceId: string;
+    /**
+     * The URL of the Cloudflare API.
+     * @default https://api.cloudflare.com
+     */
+    apiURL?: string;
+} & (KVAuthServiceKey | KVAuthAPIToken | KVAuthEmailKey);
+declare const _default: (opts?: KVHTTPOptions) => import("../types").Driver;
+export default _default;

node_modules/unstorage/dist/drivers/cloudflare-kv-http.mjs

@@ -0,0 +1,107 @@
+import { $fetch } from "ofetch";
+import { defineDriver } from "./utils/index.mjs";
+const LOG_TAG = "[unstorage] [cloudflare-http] ";
+export default defineDriver((opts) => {
+  if (!opts.accountId) {
+    throw new Error(LOG_TAG + "`accountId` is required.");
+  }
+  if (!opts.namespaceId) {
+    throw new Error(LOG_TAG + "`namespaceId` is required.");
+  }
+  let headers;
+  if ("apiToken" in opts) {
+    headers = { Authorization: `Bearer ${opts.apiToken}` };
+  } else if ("userServiceKey" in opts) {
+    headers = { "X-Auth-User-Service-Key": opts.userServiceKey };
+  } else if (opts.email && opts.apiKey) {
+    headers = { "X-Auth-Email": opts.email, "X-Auth-Key": opts.apiKey };
+  } else {
+    throw new Error(
+      LOG_TAG + "One of the `apiToken`, `userServiceKey`, or a combination of `email` and `apiKey` is required."
+    );
+  }
+  const apiURL = opts.apiURL || "https://api.cloudflare.com";
+  const baseURL = `${apiURL}/client/v4/accounts/${opts.accountId}/storage/kv/namespaces/${opts.namespaceId}`;
+  const kvFetch = $fetch.create({ baseURL, headers });
+  const hasItem = async (key) => {
+    try {
+      const res = await kvFetch(`/metadata/${key}`);
+      return res?.success === true;
+    } catch (err) {
+      if (!err.response) {
+        throw err;
+      }
+      if (err.response.status === 404) {
+        return false;
+      }
+      throw err;
+    }
+  };
+  const getItem = async (key) => {
+    try {
+      return await kvFetch(`/values/${key}`).then((r) => r.text());
+    } catch (err) {
+      if (!err.response) {
+        throw err;
+      }
+      if (err.response.status === 404) {
+        return null;
+      }
+      throw err;
+    }
+  };
+  const setItem = async (key, value) => {
+    return await kvFetch(`/values/${key}`, { method: "PUT", body: value });
+  };
+  const removeItem = async (key) => {
+    return await kvFetch(`/values/${key}`, { method: "DELETE" });
+  };
+  const getKeys = async (base) => {
+    const keys = [];
+    const params = new URLSearchParams();
+    if (base) {
+      params.set("prefix", base);
+    }
+    const firstPage = await kvFetch("/keys", { params });
+    firstPage.result.forEach(({ name }) => keys.push(name));
+    const cursor = firstPage.result_info.cursor;
+    if (cursor) {
+      params.set("cursor", cursor);
+    }
+    while (params.has("cursor")) {
+      const pageResult = await kvFetch("/keys", { params });
+      pageResult.result.forEach(({ name }) => keys.push(name));
+      const pageCursor = pageResult.result_info.cursor;
+      if (pageCursor) {
+        params.set("cursor", pageCursor);
+      } else {
+        params.delete("cursor");
+      }
+    }
+    return keys;
+  };
+  const clear = async () => {
+    const keys = await getKeys();
+    const chunks = keys.reduce((acc, key, i) => {
+      if (i % 1e4 === 0) {
+        acc.push([]);
+      }
+      acc[acc.length - 1].push(key);
+      return acc;
+    }, [[]]);
+    await Promise.all(chunks.map((chunk) => {
+      return kvFetch("/bulk", {
+        method: "DELETE",
+        body: { keys: chunk }
+      });
+    }));
+  };
+  return {
+    hasItem,
+    getItem,
+    setItem,
+    removeItem,
+    getKeys,
+    clear
+  };
+});

node_modules/unstorage/dist/drivers/fs.cjs

@@ -0,0 +1,121 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = void 0;
+
+var _fs = require("fs");
+
+var _path = require("path");
+
+var _chokidar = require("chokidar");
+
+var _utils = require("./utils/index.cjs");
+
+var _nodeFs = require("./utils/node-fs.cjs");
+
+var _anymatch = _interopRequireDefault(require("anymatch"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const PATH_TRAVERSE_RE = /\.\.\:|\.\.$/;
+
+var _default = (0, _utils.defineDriver)((opts = {}) => {
+  if (!opts.base) {
+    throw new Error("base is required");
+  }
+
+  if (!opts.ignore) {
+    opts.ignore = ["**/node_modules/**", "**/.git/**"];
+  }
+
+  opts.base = (0, _path.resolve)(opts.base);
+
+  const r = key => {
+    if (PATH_TRAVERSE_RE.test(key)) {
+      throw new Error("[unstorage] [fs] Invalid key. It should not contain `..` segments: " + key);
+    }
+
+    const resolved = (0, _path.join)(opts.base, key.replace(/:/g, "/"));
+    return resolved;
+  };
+
+  let _watcher;
+
+  return {
+    hasItem(key) {
+      return (0, _fs.existsSync)(r(key));
+    },
+
+    getItem(key) {
+      return (0, _nodeFs.readFile)(r(key));
+    },
+
+    async getMeta(key) {
+      const {
+        atime,
+        mtime,
+        size
+      } = await _fs.promises.stat(r(key)).catch(() => ({
+        atime: void 0,
+        mtime: void 0,
+        size: void 0
+      }));
+      return {
+        atime,
+        mtime,
+        size
+      };
+    },
+
+    setItem(key, value) {
+      return (0, _nodeFs.writeFile)(r(key), value);
+    },
+
+    removeItem(key) {
+      return (0, _nodeFs.unlink)(r(key));
+    },
+
+    getKeys() {
+      return (0, _nodeFs.readdirRecursive)(r("."), (0, _anymatch.default)(opts.ignore || []));
+    },
+
+    async clear() {
+      await (0, _nodeFs.rmRecursive)(r("."));
+    },
+
+    async dispose() {
+      if (_watcher) {
+        await _watcher.close();
+      }
+    },
+
+    watch(callback) {
+      if (_watcher) {
+        return;
+      }
+
+      return new Promise((resolve2, reject) => {
+        _watcher = (0, _chokidar.watch)(opts.base, {
+          ignoreInitial: true,
+          ignored: opts.ignore,
+          ...opts.watchOptions
+        }).on("ready", () => {
+          resolve2(() => _watcher.close().then(() => _watcher = void 0));
+        }).on("error", reject).on("all", (eventName, path) => {
+          path = (0, _path.relative)(opts.base, path);
+
+          if (eventName === "change" || eventName === "add") {
+            callback("update", path);
+          } else if (eventName === "unlink") {
+            callback("remove", path);
+          }
+        });
+      });
+    }
+
+  };
+});
+
+module.exports = _default;

node_modules/unstorage/dist/drivers/fs.d.ts

@@ -0,0 +1,8 @@
+import { WatchOptions } from 'chokidar';
+export interface FSStorageOptions {
+    base?: string;
+    ignore?: string[];
+    watchOptions?: WatchOptions;
+}
+declare const _default: (opts?: FSStorageOptions) => import("../types").Driver;
+export default _default;

node_modules/unstorage/dist/drivers/fs.mjs

@@ -0,0 +1,77 @@
+import { existsSync, promises as fsp } from "fs";
+import { resolve, relative, join } from "path";
+import { watch } from "chokidar";
+import { defineDriver } from "./utils/index.mjs";
+import { readFile, writeFile, readdirRecursive, rmRecursive, unlink } from "./utils/node-fs.mjs";
+import anymatch from "anymatch";
+const PATH_TRAVERSE_RE = /\.\.\:|\.\.$/;
+export default defineDriver((opts = {}) => {
+  if (!opts.base) {
+    throw new Error("base is required");
+  }
+  if (!opts.ignore) {
+    opts.ignore = [
+      "**/node_modules/**",
+      "**/.git/**"
+    ];
+  }
+  opts.base = resolve(opts.base);
+  const r = (key) => {
+    if (PATH_TRAVERSE_RE.test(key)) {
+      throw new Error("[unstorage] [fs] Invalid key. It should not contain `..` segments: " + key);
+    }
+    const resolved = join(opts.base, key.replace(/:/g, "/"));
+    return resolved;
+  };
+  let _watcher;
+  return {
+    hasItem(key) {
+      return existsSync(r(key));
+    },
+    getItem(key) {
+      return readFile(r(key));
+    },
+    async getMeta(key) {
+      const { atime, mtime, size } = await fsp.stat(r(key)).catch(() => ({ atime: void 0, mtime: void 0, size: void 0 }));
+      return { atime, mtime, size };
+    },
+    setItem(key, value) {
+      return writeFile(r(key), value);
+    },
+    removeItem(key) {
+      return unlink(r(key));
+    },
+    getKeys() {
+      return readdirRecursive(r("."), anymatch(opts.ignore || []));
+    },
+    async clear() {
+      await rmRecursive(r("."));
+    },
+    async dispose() {
+      if (_watcher) {
+        await _watcher.close();
+      }
+    },
+    watch(callback) {
+      if (_watcher) {
+        return;
+      }
+      return new Promise((resolve2, reject) => {
+        _watcher = watch(opts.base, {
+          ignoreInitial: true,
+          ignored: opts.ignore,
+          ...opts.watchOptions
+        }).on("ready", () => {
+          resolve2(() => _watcher.close().then(() => _watcher = void 0));
+        }).on("error", reject).on("all", (eventName, path) => {
+          path = relative(opts.base, path);
+          if (eventName === "change" || eventName === "add") {
+            callback("update", path);
+          } else if (eventName === "unlink") {
+            callback("remove", path);
+          }
+        });
+      });
+    }
+  };
+});

node_modules/unstorage/dist/drivers/github.cjs

@@ -0,0 +1,131 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = void 0;
+
+var _utils = require("./utils/index.cjs");
+
+var _ofetch = require("ofetch");
+
+var _ufo = require("ufo");
+
+const defaultOptions = {
+  repo: null,
+  branch: "main",
+  ttl: 600,
+  dir: "",
+  apiURL: "https://api.github.com",
+  cdnURL: "https://raw.githubusercontent.com"
+};
+
+var _default = (0, _utils.defineDriver)(_opts => {
+  const opts = { ...defaultOptions,
+    ..._opts
+  };
+  const rawUrl = (0, _ufo.joinURL)(opts.cdnURL, opts.repo, opts.branch, opts.dir);
+  let files = {};
+  let lastCheck = 0;
+  let syncPromise;
+
+  if (!opts.repo) {
+    throw new Error('[unstorage] [github] Missing required option "repo"');
+  }
+
+  const syncFiles = async () => {
+    if (lastCheck + opts.ttl * 1e3 > Date.now()) {
+      return;
+    }
+
+    if (!syncPromise) {
+      syncPromise = fetchFiles(opts);
+    }
+
+    files = await syncPromise;
+    lastCheck = Date.now();
+    syncPromise = void 0;
+  };
+
+  return {
+    async getKeys() {
+      await syncFiles();
+      return Object.keys(files);
+    },
+
+    async hasItem(key) {
+      await syncFiles();
+      return key in files;
+    },
+
+    async getItem(key) {
+      await syncFiles();
+      const item = files[key];
+
+      if (!item) {
+        return null;
+      }
+
+      if (!item.body) {
+        try {
+          item.body = await (0, _ofetch.$fetch)(key.replace(/:/g, "/"), {
+            baseURL: rawUrl,
+            headers: {
+              Authorization: opts.token ? `token ${opts.token}` : void 0
+            }
+          });
+        } catch (err) {
+          throw new Error(`[unstorage] [github] Failed to fetch "${key}"`, {
+            cause: err
+          });
+        }
+      }
+
+      return item.body;
+    },
+
+    async getMeta(key) {
+      await syncFiles();
+      const item = files[key];
+      return item ? item.meta : null;
+    }
+
+  };
+});
+
+module.exports = _default;
+
+async function fetchFiles(opts) {
+  const prefix = (0, _ufo.withTrailingSlash)(opts.dir).replace(/^\//, "");
+  const files = {};
+
+  try {
+    const trees = await (0, _ofetch.$fetch)(`/repos/${opts.repo}/git/trees/${opts.branch}?recursive=1`, {
+      baseURL: opts.apiURL,
+      headers: {
+        Authorization: opts.token ? `token ${opts.token}` : void 0
+      }
+    });
+
+    for (const node of trees.tree) {
+      if (node.type !== "blob" || !node.path.startsWith(prefix)) {
+        continue;
+      }
+
+      const key = node.path.substring(prefix.length).replace(/\//g, ":");
+      files[key] = {
+        meta: {
+          sha: node.sha,
+          mode: node.mode,
+          size: node.size
+        }
+      };
+    }
+  } catch (err) {
+    throw new Error(`[unstorage] [github] Failed to fetch git tree`, {
+      cause: err
+    });
+  }
+
+  return files;
+}

node_modules/unstorage/dist/drivers/github.d.ts

@@ -0,0 +1,34 @@
+export interface GithubOptions {
+    /**
+     * The name of the repository. (e.g. `username/my-repo`)
+     * Required
+     */
+    repo: string;
+    /**
+     * The branch to fetch. (e.g. `dev`)
+     * @default "main"
+     */
+    branch: string;
+    /**
+     * @default ""
+     */
+    dir: string;
+    /**
+     * @default 600
+     */
+    ttl: number;
+    /**
+     * Github API token (recommended)
+     */
+    token?: string;
+    /**
+     * @default "https://api.github.com"
+     */
+    apiURL?: string;
+    /**
+     * @default "https://raw.githubusercontent.com"
+     */
+    cdnURL?: string;
+}
+declare const _default: (opts?: GithubOptions) => import("../types").Driver;
+export default _default;

node_modules/unstorage/dist/drivers/github.mjs

@@ -0,0 +1,95 @@
+import { defineDriver } from "./utils/index.mjs";
+import { $fetch } from "ofetch";
+import { withTrailingSlash, joinURL } from "ufo";
+const defaultOptions = {
+  repo: null,
+  branch: "main",
+  ttl: 600,
+  dir: "",
+  apiURL: "https://api.github.com",
+  cdnURL: "https://raw.githubusercontent.com"
+};
+export default defineDriver((_opts) => {
+  const opts = { ...defaultOptions, ..._opts };
+  const rawUrl = joinURL(opts.cdnURL, opts.repo, opts.branch, opts.dir);
+  let files = {};
+  let lastCheck = 0;
+  let syncPromise;
+  if (!opts.repo) {
+    throw new Error('[unstorage] [github] Missing required option "repo"');
+  }
+  const syncFiles = async () => {
+    if (lastCheck + opts.ttl * 1e3 > Date.now()) {
+      return;
+    }
+    if (!syncPromise) {
+      syncPromise = fetchFiles(opts);
+    }
+    files = await syncPromise;
+    lastCheck = Date.now();
+    syncPromise = void 0;
+  };
+  return {
+    async getKeys() {
+      await syncFiles();
+      return Object.keys(files);
+    },
+    async hasItem(key) {
+      await syncFiles();
+      return key in files;
+    },
+    async getItem(key) {
+      await syncFiles();
+      const item = files[key];
+      if (!item) {
+        return null;
+      }
+      if (!item.body) {
+        try {
+          item.body = await $fetch(key.replace(/:/g, "/"), {
+            baseURL: rawUrl,
+            headers: {
+              Authorization: opts.token ? `token ${opts.token}` : void 0
+            }
+          });
+        } catch (err) {
+          throw new Error(`[unstorage] [github] Failed to fetch "${key}"`, { cause: err });
+        }
+      }
+      return item.body;
+    },
+    async getMeta(key) {
+      await syncFiles();
+      const item = files[key];
+      return item ? item.meta : null;
+    }
+  };
+});
+async function fetchFiles(opts) {
+  const prefix = withTrailingSlash(opts.dir).replace(/^\//, "");
+  const files = {};
+  try {
+    const trees = await $fetch(`/repos/${opts.repo}/git/trees/${opts.branch}?recursive=1`, {
+      baseURL: opts.apiURL,
+      headers: {
+        Authorization: opts.token ? `token ${opts.token}` : void 0
+      }
+    });
+    for (const node of trees.tree) {
+      if (node.type !== "blob" || !node.path.startsWith(prefix)) {
+        continue;
+      }
+      const key = node.path.substring(prefix.length).replace(/\//g, ":");
+      files[key] = {
+        meta: {
+          sha: node.sha,
+          mode: node.mode,
+          size: node.size
+        }
+      };
+    }
+  } catch (err) {
+    throw new Error(`[unstorage] [github] Failed to fetch git tree`, { cause: err });
+  }
+  return files;
+}

node_modules/unstorage/dist/drivers/http.cjs

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = void 0;
+
+var _utils = require("./utils/index.cjs");
+
+var _ofetch = require("ofetch");
+
+var _ufo = require("ufo");
+
+var _default = (0, _utils.defineDriver)((opts = {}) => {
+  const r = key => (0, _ufo.joinURL)(opts.base, key.replace(/:/g, "/"));
+
+  return {
+    hasItem(key) {
+      return (0, _ofetch.$fetch)(r(key), {
+        method: "HEAD"
+      }).then(() => true).catch(() => false);
+    },
+
+    async getItem(key) {
+      const value = await (0, _ofetch.$fetch)(r(key));
+      return value;
+    },
+
+    async getMeta(key) {
+      const res = await _ofetch.$fetch.raw(r(key), {
+        method: "HEAD"
+      });
+      let mtime = void 0;
+
+      const _lastModified = res.headers.get("last-modified");
+
+      if (_lastModified) {
+        mtime = new Date(_lastModified);
+      }
+
+      return {
+        status: res.status,
+        mtime
+      };
+    },
+
+    async setItem(key, value) {
+      await (0, _ofetch.$fetch)(r(key), {
+        method: "PUT",
+        body: (0, _utils.stringify)(value)
+      });
+    },
+
+    async removeItem(key) {
+      await (0, _ofetch.$fetch)(r(key), {
+        method: "DELETE"
+      });
+    },
+
+    async getKeys() {
+      const value = await (0, _ofetch.$fetch)(r(""));
+      return Array.isArray(value) ? value : [];
+    },
+
+    clear() {}
+
+  };
+});
+
+module.exports = _default;

node_modules/unstorage/dist/drivers/http.d.ts

@@ -0,0 +1,5 @@
+export interface HTTPOptions {
+    base?: string;
+}
+declare const _default: (opts?: HTTPOptions) => import("../types").Driver;
+export default _default;

node_modules/unstorage/dist/drivers/http.mjs

@@ -0,0 +1,40 @@
+import { defineDriver } from "./utils/index.mjs";
+import { stringify } from "./utils/index.mjs";
+import { $fetch } from "ofetch";
+import { joinURL } from "ufo";
+export default defineDriver((opts = {}) => {
+  const r = (key) => joinURL(opts.base, key.replace(/:/g, "/"));
+  return {
+    hasItem(key) {
+      return $fetch(r(key), { method: "HEAD" }).then(() => true).catch(() => false);
+    },
+    async getItem(key) {
+      const value = await $fetch(r(key));
+      return value;
+    },
+    async getMeta(key) {
+      const res = await $fetch.raw(r(key), { method: "HEAD" });
+      let mtime = void 0;
+      const _lastModified = res.headers.get("last-modified");
+      if (_lastModified) {
+        mtime = new Date(_lastModified);
+      }
+      return {
+        status: res.status,
+        mtime
+      };
+    },
+    async setItem(key, value) {
+      await $fetch(r(key), { method: "PUT", body: stringify(value) });
+    },
+    async removeItem(key) {
+      await $fetch(r(key), { method: "DELETE" });
+    },
+    async getKeys() {
+      const value = await $fetch(r(""));
+      return Array.isArray(value) ? value : [];
+    },
+    clear() {
+    }
+  };
+});

node_modules/unstorage/dist/drivers/localstorage.cjs

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = void 0;
+
+var _utils = require("./utils/index.cjs");
+
+var _default = (0, _utils.defineDriver)((opts = {}) => {
+  if (!opts.window) {
+    opts.window = typeof window !== "undefined" ? window : void 0;
+  }
+
+  if (!opts.localStorage) {
+    opts.localStorage = opts.window?.localStorage;
+  }
+
+  if (!opts.localStorage) {
+    throw new Error("localStorage not available");
+  }
+
+  const r = key => (opts.base ? opts.base + ":" : "") + key;
+
+  let _storageListener;
+
+  return {
+    hasItem(key) {
+      return Object.prototype.hasOwnProperty.call(opts.localStorage, r(key));
+    },
+
+    getItem(key) {
+      return opts.localStorage.getItem(r(key));
+    },
+
+    setItem(key, value) {
+      return opts.localStorage.setItem(r(key), value);
+    },
+
+    removeItem(key) {
+      return opts.localStorage.removeItem(r(key));
+    },
+
+    getKeys() {
+      return Object.keys(opts.localStorage);
+    },
+
+    clear() {
+      if (!opts.base) {
+        opts.localStorage.clear();
+      } else {
+        for (const key of Object.keys(opts.localStorage)) {
+          opts.localStorage?.removeItem(key);
+        }
+      }
+
+      if (opts.window && _storageListener) {
+        opts.window.removeEventListener("storage", _storageListener);
+      }
+    },
+
+    watch(callback) {
+      if (!opts.window) {
+        return;
+      }
+
+      _storageListener = ev => {
+        if (ev.key) {
+          callback(ev.newValue ? "update" : "remove", ev.key);
+        }
+      };
+
+      opts.window.addEventListener("storage", _storageListener);
+      return () => {
+        opts.window.removeEventListener("storage", _storageListener);
+        _storageListener = void 0;
+      };
+    }
+
+  };
+});
+
+module.exports = _default;

node_modules/unstorage/dist/drivers/localstorage.d.ts

@@ -0,0 +1,7 @@
+export interface LocalStorageOptions {
+    base?: string;
+    window?: typeof window;
+    localStorage?: typeof window.localStorage;
+}
+declare const _default: (opts?: LocalStorageOptions) => import("../types").Driver;
+export default _default;

node_modules/unstorage/dist/drivers/localstorage.mjs

@@ -0,0 +1,58 @@
+import { defineDriver } from "./utils/index.mjs";
+export default defineDriver((opts = {}) => {
+  if (!opts.window) {
+    opts.window = typeof window !== "undefined" ? window : void 0;
+  }
+  if (!opts.localStorage) {
+    opts.localStorage = opts.window?.localStorage;
+  }
+  if (!opts.localStorage) {
+    throw new Error("localStorage not available");
+  }
+  const r = (key) => (opts.base ? opts.base + ":" : "") + key;
+  let _storageListener;
+  return {
+    hasItem(key) {
+      return Object.prototype.hasOwnProperty.call(opts.localStorage, r(key));
+    },
+    getItem(key) {
+      return opts.localStorage.getItem(r(key));
+    },
+    setItem(key, value) {
+      return opts.localStorage.setItem(r(key), value);
+    },
+    removeItem(key) {
+      return opts.localStorage.removeItem(r(key));
+    },
+    getKeys() {
+      return Object.keys(opts.localStorage);
+    },
+    clear() {
+      if (!opts.base) {
+        opts.localStorage.clear();
+      } else {
+        for (const key of Object.keys(opts.localStorage)) {
+          opts.localStorage?.removeItem(key);
+        }
+      }
+      if (opts.window && _storageListener) {
+        opts.window.removeEventListener("storage", _storageListener);
+      }
+    },
+    watch(callback) {
+      if (!opts.window) {
+        return;
+      }
+      _storageListener = (ev) => {
+        if (ev.key) {
+          callback(ev.newValue ? "update" : "remove", ev.key);
+        }
+      };
+      opts.window.addEventListener("storage", _storageListener);
+      return () => {
+        opts.window.removeEventListener("storage", _storageListener);
+        _storageListener = void 0;
+      };
+    }
+  };
+});

node_modules/unstorage/dist/drivers/memory.cjs

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = void 0;
+
+var _utils = require("./utils/index.cjs");
+
+var _default = (0, _utils.defineDriver)(() => {
+  const data = /* @__PURE__ */new Map();
+  return {
+    hasItem(key) {
+      return data.has(key);
+    },
+
+    getItem(key) {
+      return data.get(key) || null;
+    },
+
+    setItem(key, value) {
+      data.set(key, value);
+    },
+
+    removeItem(key) {
+      data.delete(key);
+    },
+
+    getKeys() {
+      return Array.from(data.keys());
+    },
+
+    clear() {
+      data.clear();
+    },
+
+    dispose() {
+      data.clear();
+    }
+
+  };
+});
+
+module.exports = _default;

node_modules/unstorage/dist/drivers/memory.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (opts?: any) => import("../types").Driver;
+export default _default;

node_modules/unstorage/dist/drivers/memory.mjs

@@ -0,0 +1,27 @@
+import { defineDriver } from "./utils/index.mjs";
+export default defineDriver(() => {
+  const data = /* @__PURE__ */ new Map();
+  return {
+    hasItem(key) {
+      return data.has(key);
+    },
+    getItem(key) {
+      return data.get(key) || null;
+    },
+    setItem(key, value) {
+      data.set(key, value);
+    },
+    removeItem(key) {
+      data.delete(key);
+    },
+    getKeys() {
+      return Array.from(data.keys());
+    },
+    clear() {
+      data.clear();
+    },
+    dispose() {
+      data.clear();
+    }
+  };
+});

node_modules/unstorage/dist/drivers/overlay.cjs

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = void 0;
+
+var _utils = require("./utils/index.cjs");
+
+const OVERLAY_REMOVED = "__OVERLAY_REMOVED__";
+
+var _default = (0, _utils.defineDriver)(options => {
+  return {
+    async hasItem(key) {
+      for (const layer of options.layers) {
+        if (await layer.hasItem(key)) {
+          if (layer === options.layers[0]) {
+            if ((await options.layers[0]?.getItem(key)) === OVERLAY_REMOVED) {
+              return false;
+            }
+          }
+
+          return true;
+        }
+      }
+
+      return false;
+    },
+
+    async getItem(key) {
+      for (const layer of options.layers) {
+        const value = await layer.getItem(key);
+
+        if (value === OVERLAY_REMOVED) {
+          return null;
+        }
+
+        if (value !== null) {
+          return value;
+        }
+      }
+
+      return null;
+    },
+
+    async setItem(key, value) {
+      await options.layers[0]?.setItem(key, value);
+    },
+
+    async removeItem(key) {
+      await options.layers[0]?.setItem(key, OVERLAY_REMOVED);
+    },
+
+    async getKeys(base) {
+      const allKeys = await Promise.all(options.layers.map(async layer => {
+        const keys = await layer.getKeys(base);
+        return keys.map(key => (0, _utils.normalizeKey)(key));
+      }));
+      const uniqueKeys = Array.from(new Set(allKeys.flat()));
+      const existingKeys = await Promise.all(uniqueKeys.map(async key => {
+        if ((await options.layers[0]?.getItem(key)) === OVERLAY_REMOVED) {
+          return false;
+        }
+
+        return key;
+      }));
+      return existingKeys.filter(Boolean);
+    },
+
+    async dispose() {
+      await Promise.all(options.layers.map(async layer => {
+        if (layer.dispose) {
+          await layer.dispose();
+        }
+      }));
+    }
+
+  };
+});
+
+module.exports = _default;

node_modules/unstorage/dist/drivers/overlay.d.ts

@@ -0,0 +1,6 @@
+import type { Driver } from '../types';
+export interface OverlayStorageOptions {
+    layers: Driver[];
+}
+declare const _default: (opts?: OverlayStorageOptions) => Driver;
+export default _default;

node_modules/unstorage/dist/drivers/overlay.mjs

@@ -0,0 +1,59 @@
+import { defineDriver } from "./utils/index.mjs";
+import { normalizeKey } from "./utils/index.mjs";
+const OVERLAY_REMOVED = "__OVERLAY_REMOVED__";
+export default defineDriver((options) => {
+  return {
+    async hasItem(key) {
+      for (const layer of options.layers) {
+        if (await layer.hasItem(key)) {
+          if (layer === options.layers[0]) {
+            if (await options.layers[0]?.getItem(key) === OVERLAY_REMOVED) {
+              return false;
+            }
+          }
+          return true;
+        }
+      }
+      return false;
+    },
+    async getItem(key) {
+      for (const layer of options.layers) {
+        const value = await layer.getItem(key);
+        if (value === OVERLAY_REMOVED) {
+          return null;
+        }
+        if (value !== null) {
+          return value;
+        }
+      }
+      return null;
+    },
+    async setItem(key, value) {
+      await options.layers[0]?.setItem(key, value);
+    },
+    async removeItem(key) {
+      await options.layers[0]?.setItem(key, OVERLAY_REMOVED);
+    },
+    async getKeys(base) {
+      const allKeys = await Promise.all(options.layers.map(async (layer) => {
+        const keys = await layer.getKeys(base);
+        return keys.map((key) => normalizeKey(key));
+      }));
+      const uniqueKeys = Array.from(new Set(allKeys.flat()));
+      const existingKeys = await Promise.all(uniqueKeys.map(async (key) => {
+        if (await options.layers[0]?.getItem(key) === OVERLAY_REMOVED) {
+          return false;
+        }
+        return key;
+      }));
+      return existingKeys.filter(Boolean);
+    },
+    async dispose() {
+      await Promise.all(options.layers.map(async (layer) => {
+        if (layer.dispose) {
+          await layer.dispose();
+        }
+      }));
+    }
+  };
+});

node_modules/unstorage/dist/drivers/redis.cjs

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = void 0;
+
+var _utils = require("./utils/index.cjs");
+
+var _ioredis = _interopRequireDefault(require("ioredis"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = (0, _utils.defineDriver)(_opts => {
+  const opts = {
+    lazyConnect: true,
+    ..._opts
+  };
+  const redis = opts.url ? new _ioredis.default(opts?.url, opts) : new _ioredis.default(opts);
+  let base = opts?.base || "";
+
+  if (base && !base.endsWith(":")) {
+    base += ":";
+  }
+
+  const r = key => base + key;
+
+  return {
+    hasItem(key) {
+      return redis.exists(r(key)).then(Boolean);
+    },
+
+    getItem(key) {
+      return redis.get(r(key));
+    },
+
+    setItem(key, value) {
+      return redis.set(r(key), value).then(() => {});
+    },
+
+    removeItem(key) {
+      return redis.del(r(key)).then(() => {});
+    },
+
+    getKeys() {
+      return redis.keys(r("*"));
+    },
+
+    async clear() {
+      const keys = await redis.keys(r("*"));
+      return redis.del(keys.map(key => r(key))).then(() => {});
+    },
+
+    dispose() {
+      return redis.disconnect();
+    }
+
+  };
+});
+
+module.exports = _default;

node_modules/unstorage/dist/drivers/redis.d.ts

@@ -0,0 +1,7 @@
+import { RedisOptions as _RedisOptions } from 'ioredis';
+export interface RedisOptions extends _RedisOptions {
+    base: string;
+    url: string;
+}
+declare const _default: (opts?: RedisOptions) => import("../types").Driver;
+export default _default;

node_modules/unstorage/dist/drivers/redis.mjs

@@ -0,0 +1,38 @@
+import { defineDriver } from "./utils/index.mjs";
+import Redis from "ioredis";
+export default defineDriver((_opts) => {
+  const opts = { lazyConnect: true, ..._opts };
+  const redis = opts.url ? new Redis(opts?.url, opts) : new Redis(opts);
+  let base = opts?.base || "";
+  if (base && !base.endsWith(":")) {
+    base += ":";
+  }
+  const r = (key) => base + key;
+  return {
+    hasItem(key) {
+      return redis.exists(r(key)).then(Boolean);
+    },
+    getItem(key) {
+      return redis.get(r(key));
+    },
+    setItem(key, value) {
+      return redis.set(r(key), value).then(() => {
+      });
+    },
+    removeItem(key) {
+      return redis.del(r(key)).then(() => {
+      });
+    },
+    getKeys() {
+      return redis.keys(r("*"));
+    },
+    async clear() {
+      const keys = await redis.keys(r("*"));
+      return redis.del(keys.map((key) => r(key))).then(() => {
+      });
+    },
+    dispose() {
+      return redis.disconnect();
+    }
+  };
+});

node_modules/unstorage/dist/drivers/utils/index.cjs

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defineDriver = defineDriver;
+exports.isPrimitive = isPrimitive;
+exports.normalizeKey = normalizeKey;
+exports.stringify = stringify;
+
+function defineDriver(factory) {
+  return factory;
+}
+
+function isPrimitive(arg) {
+  const type = typeof arg;
+  return arg === null || type !== "object" && type !== "function";
+}
+
+function stringify(arg) {
+  return isPrimitive(arg) ? arg + "" : JSON.stringify(arg);
+}
+
+function normalizeKey(key) {
+  if (!key) {
+    return "";
+  }
+
+  return key.replace(/[/\\]/g, ":").replace(/^:|:$/g, "");
+}

node_modules/unstorage/dist/drivers/utils/index.d.ts

@@ -0,0 +1,7 @@
+import type { Driver } from '../../types';
+declare type DriverFactory<T> = (opts?: T) => Driver;
+export declare function defineDriver<T = any>(factory: DriverFactory<T>): DriverFactory<T>;
+export declare function isPrimitive(arg: any): boolean;
+export declare function stringify(arg: any): string;
+export declare function normalizeKey(key: string | undefined): string;
+export {};

node_modules/unstorage/dist/drivers/utils/index.mjs

@@ -0,0 +1,16 @@
+export function defineDriver(factory) {
+  return factory;
+}
+export function isPrimitive(arg) {
+  const type = typeof arg;
+  return arg === null || type !== "object" && type !== "function";
+}
+export function stringify(arg) {
+  return isPrimitive(arg) ? arg + "" : JSON.stringify(arg);
+}
+export function normalizeKey(key) {
+  if (!key) {
+    return "";
+  }
+  return key.replace(/[/\\]/g, ":").replace(/^:|:$/g, "");
+}

node_modules/unstorage/dist/drivers/utils/node-fs.cjs

@@ -0,0 +1,92 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ensuredir = ensuredir;
+exports.readFile = readFile;
+exports.readdir = readdir;
+exports.readdirRecursive = readdirRecursive;
+exports.rmRecursive = rmRecursive;
+exports.stat = stat;
+exports.unlink = unlink;
+exports.writeFile = writeFile;
+
+var _fs = require("fs");
+
+var _path = require("path");
+
+function ignoreNotfound(err) {
+  return err.code === "ENOENT" || err.code === "EISDIR" ? null : err;
+}
+
+function ignoreExists(err) {
+  return err.code === "EEXIST" ? null : err;
+}
+
+async function writeFile(path, data) {
+  await ensuredir((0, _path.dirname)(path));
+  return _fs.promises.writeFile(path, data, "utf8");
+}
+
+function readFile(path) {
+  return _fs.promises.readFile(path, "utf8").catch(ignoreNotfound);
+}
+
+function stat(path) {
+  return _fs.promises.stat(path).catch(ignoreNotfound);
+}
+
+function unlink(path) {
+  return _fs.promises.unlink(path).catch(ignoreNotfound);
+}
+
+function readdir(dir) {
+  return _fs.promises.readdir(dir, {
+    withFileTypes: true
+  }).catch(ignoreNotfound).then(r => r || []);
+}
+
+async function ensuredir(dir) {
+  if ((0, _fs.existsSync)(dir)) {
+    return;
+  }
+
+  await ensuredir((0, _path.dirname)(dir)).catch(ignoreExists);
+  await _fs.promises.mkdir(dir).catch(ignoreExists);
+}
+
+async function readdirRecursive(dir, ignore) {
+  if (ignore && ignore(dir)) {
+    return [];
+  }
+
+  const entries = await readdir(dir);
+  const files = [];
+  await Promise.all(entries.map(async entry => {
+    const entryPath = (0, _path.resolve)(dir, entry.name);
+
+    if (entry.isDirectory()) {
+      const dirFiles = await readdirRecursive(entryPath, ignore);
+      files.push(...dirFiles.map(f => entry.name + "/" + f));
+    } else {
+      if (ignore && !ignore(entry.name)) {
+        files.push(entry.name);
+      }
+    }
+  }));
+  return files;
+}
+
+async function rmRecursive(dir) {
+  const entries = await readdir(dir);
+  await Promise.all(entries.map(entry => {
+    const entryPath = (0, _path.resolve)(dir, entry.name);
+
+    if (entry.isDirectory()) {
+      return rmRecursive(entryPath).then(() => _fs.promises.rmdir(entryPath));
+    } else {
+      return _fs.promises.unlink(entryPath);
+    }
+  }));
+}

node_modules/unstorage/dist/drivers/utils/node-fs.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { Dirent } from 'fs';
+export declare function writeFile(path: string, data: string): Promise<void>;
+export declare function readFile(path: string): Promise<any>;
+export declare function stat(path: string): Promise<any>;
+export declare function unlink(path: string): Promise<any>;
+export declare function readdir(dir: string): Promise<Dirent[]>;
+export declare function ensuredir(dir: string): Promise<void>;
+export declare function readdirRecursive(dir: string, ignore?: (p: string) => boolean): Promise<string[]>;
+export declare function rmRecursive(dir: string): Promise<void>;

node_modules/unstorage/dist/drivers/utils/node-fs.mjs

@@ -0,0 +1,61 @@
+import { existsSync, promises as fsPromises } from "fs";
+import { resolve, dirname } from "path";
+function ignoreNotfound(err) {
+  return err.code === "ENOENT" || err.code === "EISDIR" ? null : err;
+}
+function ignoreExists(err) {
+  return err.code === "EEXIST" ? null : err;
+}
+export async function writeFile(path, data) {
+  await ensuredir(dirname(path));
+  return fsPromises.writeFile(path, data, "utf8");
+}
+export function readFile(path) {
+  return fsPromises.readFile(path, "utf8").catch(ignoreNotfound);
+}
+export function stat(path) {
+  return fsPromises.stat(path).catch(ignoreNotfound);
+}
+export function unlink(path) {
+  return fsPromises.unlink(path).catch(ignoreNotfound);
+}
+export function readdir(dir) {
+  return fsPromises.readdir(dir, { withFileTypes: true }).catch(ignoreNotfound).then((r) => r || []);
+}
+export async function ensuredir(dir) {
+  if (existsSync(dir)) {
+    return;
+  }
+  await ensuredir(dirname(dir)).catch(ignoreExists);
+  await fsPromises.mkdir(dir).catch(ignoreExists);
+}
+export async function readdirRecursive(dir, ignore) {
+  if (ignore && ignore(dir)) {
+    return [];
+  }
+  const entries = await readdir(dir);
+  const files = [];
+  await Promise.all(entries.map(async (entry) => {
+    const entryPath = resolve(dir, entry.name);
+    if (entry.isDirectory()) {
+      const dirFiles = await readdirRecursive(entryPath, ignore);
+      files.push(...dirFiles.map((f) => entry.name + "/" + f));
+    } else {
+      if (ignore && !ignore(entry.name)) {
+        files.push(entry.name);
+      }
+    }
+  }));
+  return files;
+}
+export async function rmRecursive(dir) {
+  const entries = await readdir(dir);
+  await Promise.all(entries.map((entry) => {
+    const entryPath = resolve(dir, entry.name);
+    if (entry.isDirectory()) {
+      return rmRecursive(entryPath).then(() => fsPromises.rmdir(entryPath));
+    } else {
+      return fsPromises.unlink(entryPath);
+    }
+  }));
+}

node_modules/unstorage/dist/index.cjs

@@ -0,0 +1,325 @@
+'use strict';
+
+const destr = require('destr');
+const _utils = require('./shared/unstorage.e5f2cd8b.cjs');
+
+function defineDriver(factory) {
+  return factory;
+}
+
+const memory = defineDriver(() => {
+  const data = /* @__PURE__ */ new Map();
+  return {
+    hasItem(key) {
+      return data.has(key);
+    },
+    getItem(key) {
+      return data.get(key) || null;
+    },
+    setItem(key, value) {
+      data.set(key, value);
+    },
+    removeItem(key) {
+      data.delete(key);
+    },
+    getKeys() {
+      return Array.from(data.keys());
+    },
+    clear() {
+      data.clear();
+    },
+    dispose() {
+      data.clear();
+    }
+  };
+});
+
+const storageKeyProperties = [
+  "hasItem",
+  "getItem",
+  "setItem",
+  "removeItem",
+  "getMeta",
+  "setMeta",
+  "removeMeta",
+  "getKeys",
+  "clear",
+  "mount",
+  "unmount"
+];
+function prefixStorage(storage, base) {
+  base = normalizeBaseKey(base);
+  if (!base) {
+    return storage;
+  }
+  const nsStorage = { ...storage };
+  for (const property of storageKeyProperties) {
+    nsStorage[property] = (key = "", ...arguments_) => storage[property](base + key, ...arguments_);
+  }
+  nsStorage.getKeys = (key = "", ...arguments_) => storage.getKeys(base + key, ...arguments_).then((keys) => keys.map((key2) => key2.slice(base.length)));
+  return nsStorage;
+}
+function normalizeKey(key) {
+  if (!key) {
+    return "";
+  }
+  return key.replace(/[/\\]/g, ":").replace(/:+/g, ":").replace(/^:|:$/g, "");
+}
+function joinKeys(...keys) {
+  return normalizeKey(keys.join(":"));
+}
+function normalizeBaseKey(base) {
+  base = normalizeKey(base);
+  return base ? base + ":" : "";
+}
+
+function createStorage(options = {}) {
+  const context = {
+    mounts: { "": options.driver || memory() },
+    mountpoints: [""],
+    watching: false,
+    watchListeners: [],
+    unwatch: {}
+  };
+  const getMount = (key) => {
+    for (const base of context.mountpoints) {
+      if (key.startsWith(base)) {
+        return {
+          relativeKey: key.slice(base.length),
+          driver: context.mounts[base]
+        };
+      }
+    }
+    return {
+      relativeKey: key,
+      driver: context.mounts[""]
+    };
+  };
+  const getMounts = (base, includeParent) => {
+    return context.mountpoints.filter((mountpoint) => mountpoint.startsWith(base) || includeParent && base.startsWith(mountpoint)).map((mountpoint) => ({
+      relativeBase: base.length > mountpoint.length ? base.slice(mountpoint.length) : void 0,
+      mountpoint,
+      driver: context.mounts[mountpoint]
+    }));
+  };
+  const onChange = (event, key) => {
+    if (!context.watching) {
+      return;
+    }
+    key = normalizeKey(key);
+    for (const listener of context.watchListeners) {
+      listener(event, key);
+    }
+  };
+  const startWatch = async () => {
+    if (context.watching) {
+      return;
+    }
+    context.watching = true;
+    for (const mountpoint in context.mounts) {
+      context.unwatch[mountpoint] = await watch(context.mounts[mountpoint], onChange, mountpoint);
+    }
+  };
+  const stopWatch = async () => {
+    if (!context.watching) {
+      return;
+    }
+    for (const mountpoint in context.unwatch) {
+      await context.unwatch[mountpoint]();
+    }
+    context.unwatch = {};
+    context.watching = false;
+  };
+  const storage = {
+    hasItem(key) {
+      key = normalizeKey(key);
+      const { relativeKey, driver } = getMount(key);
+      return _utils.asyncCall(driver.hasItem, relativeKey);
+    },
+    getItem(key) {
+      key = normalizeKey(key);
+      const { relativeKey, driver } = getMount(key);
+      return _utils.asyncCall(driver.getItem, relativeKey).then((value) => destr(value));
+    },
+    async setItem(key, value) {
+      if (value === void 0) {
+        return storage.removeItem(key);
+      }
+      key = normalizeKey(key);
+      const { relativeKey, driver } = getMount(key);
+      if (!driver.setItem) {
+        return;
+      }
+      await _utils.asyncCall(driver.setItem, relativeKey, _utils.stringify(value));
+      if (!driver.watch) {
+        onChange("update", key);
+      }
+    },
+    async removeItem(key, removeMeta = true) {
+      key = normalizeKey(key);
+      const { relativeKey, driver } = getMount(key);
+      if (!driver.removeItem) {
+        return;
+      }
+      await _utils.asyncCall(driver.removeItem, relativeKey);
+      if (removeMeta) {
+        await _utils.asyncCall(driver.removeItem, relativeKey + "$");
+      }
+      if (!driver.watch) {
+        onChange("remove", key);
+      }
+    },
+    async getMeta(key, nativeMetaOnly) {
+      key = normalizeKey(key);
+      const { relativeKey, driver } = getMount(key);
+      const meta = /* @__PURE__ */ Object.create(null);
+      if (driver.getMeta) {
+        Object.assign(meta, await _utils.asyncCall(driver.getMeta, relativeKey));
+      }
+      if (!nativeMetaOnly) {
+        const value = await _utils.asyncCall(driver.getItem, relativeKey + "$").then((value_) => destr(value_));
+        if (value && typeof value === "object") {
+          if (typeof value.atime === "string") {
+            value.atime = new Date(value.atime);
+          }
+          if (typeof value.mtime === "string") {
+            value.mtime = new Date(value.mtime);
+          }
+          Object.assign(meta, value);
+        }
+      }
+      return meta;
+    },
+    setMeta(key, value) {
+      return this.setItem(key + "$", value);
+    },
+    removeMeta(key) {
+      return this.removeItem(key + "$");
+    },
+    async getKeys(base) {
+      base = normalizeBaseKey(base);
+      const mounts = getMounts(base, true);
+      let maskedMounts = [];
+      const allKeys = [];
+      for (const mount of mounts) {
+        const rawKeys = await _utils.asyncCall(mount.driver.getKeys, mount.relativeBase);
+        const keys = rawKeys.map((key) => mount.mountpoint + normalizeKey(key)).filter((key) => !maskedMounts.some((p) => key.startsWith(p)));
+        allKeys.push(...keys);
+        maskedMounts = [
+          mount.mountpoint,
+          ...maskedMounts.filter((p) => !p.startsWith(mount.mountpoint))
+        ];
+      }
+      return base ? allKeys.filter((key) => key.startsWith(base) && !key.endsWith("$")) : allKeys.filter((key) => !key.endsWith("$"));
+    },
+    async clear(base) {
+      base = normalizeBaseKey(base);
+      await Promise.all(getMounts(base, false).map(async (m) => {
+        if (m.driver.clear) {
+          return _utils.asyncCall(m.driver.clear);
+        }
+        if (m.driver.removeItem) {
+          const keys = await m.driver.getKeys();
+          return Promise.all(keys.map((key) => m.driver.removeItem(key)));
+        }
+      }));
+    },
+    async dispose() {
+      await Promise.all(Object.values(context.mounts).map((driver) => dispose(driver)));
+    },
+    async watch(callback) {
+      await startWatch();
+      context.watchListeners.push(callback);
+      return async () => {
+        context.watchListeners = context.watchListeners.filter((listener) => listener !== callback);
+        if (context.watchListeners.length === 0) {
+          await stopWatch();
+        }
+      };
+    },
+    async unwatch() {
+      context.watchListeners = [];
+      await stopWatch();
+    },
+    mount(base, driver) {
+      base = normalizeBaseKey(base);
+      if (base && context.mounts[base]) {
+        throw new Error(`already mounted at ${base}`);
+      }
+      if (base) {
+        context.mountpoints.push(base);
+        context.mountpoints.sort((a, b) => b.length - a.length);
+      }
+      context.mounts[base] = driver;
+      if (context.watching) {
+        Promise.resolve(watch(driver, onChange, base)).then((unwatcher) => {
+          context.unwatch[base] = unwatcher;
+        }).catch(console.error);
+      }
+      return storage;
+    },
+    async unmount(base, _dispose = true) {
+      base = normalizeBaseKey(base);
+      if (!base || !context.mounts[base]) {
+        return;
+      }
+      if (context.watching && base in context.unwatch) {
+        context.unwatch[base]();
+        delete context.unwatch[base];
+      }
+      if (_dispose) {
+        await dispose(context.mounts[base]);
+      }
+      context.mountpoints = context.mountpoints.filter((key) => key !== base);
+      delete context.mounts[base];
+    }
+  };
+  return storage;
+}
+async function snapshot(storage, base) {
+  base = normalizeBaseKey(base);
+  const keys = await storage.getKeys(base);
+  const snapshot2 = {};
+  await Promise.all(keys.map(async (key) => {
+    snapshot2[key.slice(base.length)] = await storage.getItem(key);
+  }));
+  return snapshot2;
+}
+async function restoreSnapshot(driver, snapshot2, base = "") {
+  base = normalizeBaseKey(base);
+  await Promise.all(Object.entries(snapshot2).map((e) => driver.setItem(base + e[0], e[1])));
+}
+function watch(driver, onChange, base) {
+  return driver.watch ? driver.watch((event, key) => onChange(event, base + key)) : () => {
+  };
+}
+async function dispose(driver) {
+  if (typeof driver.dispose === "function") {
+    await _utils.asyncCall(driver.dispose);
+  }
+}
+
+const builtinDrivers = {
+  cloudflareKVHTTP: "unstorage/drivers/cloudflare-kv-http",
+  cloudflareKVBinding: "unstorage/drivers/cloudflare-kv-binding",
+  "cloudflare-kv-http": "unstorage/drivers/cloudflare-kv-http",
+  "cloudflare-kv-binding": "unstorage/drivers/cloudflare-kv-binding",
+  fs: "unstorage/drivers/fs",
+  github: "unstorage/drivers/github",
+  http: "unstorage/drivers/http",
+  localStorage: "unstorage/drivers/localstorage",
+  localstorage: "unstorage/drivers/localstorage",
+  memory: "unstorage/drivers/memory",
+  overlay: "unstorage/drivers/overlay",
+  redis: "unstorage/drivers/redis"
+};
+
+exports.builtinDrivers = builtinDrivers;
+exports.createStorage = createStorage;
+exports.defineDriver = defineDriver;
+exports.joinKeys = joinKeys;
+exports.normalizeBaseKey = normalizeBaseKey;
+exports.normalizeKey = normalizeKey;
+exports.prefixStorage = prefixStorage;
+exports.restoreSnapshot = restoreSnapshot;
+exports.snapshot = snapshot;

node_modules/unstorage/dist/index.d.ts

@@ -0,0 +1,36 @@
+import { D as Driver, S as Storage, a as StorageValue } from './types-227df1cc.js';
+export { D as Driver, S as Storage, c as StorageMeta, a as StorageValue, U as Unwatch, b as WatchCallback, W as WatchEvent } from './types-227df1cc.js';
+
+interface CreateStorageOptions {
+    driver?: Driver;
+}
+declare function createStorage(options?: CreateStorageOptions): Storage;
+declare type Snapshot<T = string> = Record<string, T>;
+declare function snapshot(storage: Storage, base: string): Promise<Snapshot<string>>;
+declare function restoreSnapshot(driver: Storage, snapshot: Snapshot<StorageValue>, base?: string): Promise<void>;
+
+declare function prefixStorage(storage: Storage, base: string): Storage;
+declare function normalizeKey(key?: string): string;
+declare function joinKeys(...keys: string[]): string;
+declare function normalizeBaseKey(base?: string): string;
+
+declare type DriverFactory<T> = (opts?: T) => Driver;
+declare function defineDriver<T = any>(factory: DriverFactory<T>): DriverFactory<T>;
+
+declare const builtinDrivers: {
+    cloudflareKVHTTP: string;
+    cloudflareKVBinding: string;
+    "cloudflare-kv-http": string;
+    "cloudflare-kv-binding": string;
+    fs: string;
+    github: string;
+    http: string;
+    localStorage: string;
+    localstorage: string;
+    memory: string;
+    overlay: string;
+    redis: string;
+};
+declare type BuiltinDriverName = keyof typeof builtinDrivers;
+
+export { BuiltinDriverName, CreateStorageOptions, Snapshot, builtinDrivers, createStorage, defineDriver, joinKeys, normalizeBaseKey, normalizeKey, prefixStorage, restoreSnapshot, snapshot };

node_modules/unstorage/dist/index.mjs

@@ -0,0 +1,315 @@
+import destr from 'destr';
+import { a as asyncCall, s as stringify } from './shared/unstorage.10149939.mjs';
+
+function defineDriver(factory) {
+  return factory;
+}
+
+const memory = defineDriver(() => {
+  const data = /* @__PURE__ */ new Map();
+  return {
+    hasItem(key) {
+      return data.has(key);
+    },
+    getItem(key) {
+      return data.get(key) || null;
+    },
+    setItem(key, value) {
+      data.set(key, value);
+    },
+    removeItem(key) {
+      data.delete(key);
+    },
+    getKeys() {
+      return Array.from(data.keys());
+    },
+    clear() {
+      data.clear();
+    },
+    dispose() {
+      data.clear();
+    }
+  };
+});
+
+const storageKeyProperties = [
+  "hasItem",
+  "getItem",
+  "setItem",
+  "removeItem",
+  "getMeta",
+  "setMeta",
+  "removeMeta",
+  "getKeys",
+  "clear",
+  "mount",
+  "unmount"
+];
+function prefixStorage(storage, base) {
+  base = normalizeBaseKey(base);
+  if (!base) {
+    return storage;
+  }
+  const nsStorage = { ...storage };
+  for (const property of storageKeyProperties) {
+    nsStorage[property] = (key = "", ...arguments_) => storage[property](base + key, ...arguments_);
+  }
+  nsStorage.getKeys = (key = "", ...arguments_) => storage.getKeys(base + key, ...arguments_).then((keys) => keys.map((key2) => key2.slice(base.length)));
+  return nsStorage;
+}
+function normalizeKey(key) {
+  if (!key) {
+    return "";
+  }
+  return key.replace(/[/\\]/g, ":").replace(/:+/g, ":").replace(/^:|:$/g, "");
+}
+function joinKeys(...keys) {
+  return normalizeKey(keys.join(":"));
+}
+function normalizeBaseKey(base) {
+  base = normalizeKey(base);
+  return base ? base + ":" : "";
+}
+
+function createStorage(options = {}) {
+  const context = {
+    mounts: { "": options.driver || memory() },
+    mountpoints: [""],
+    watching: false,
+    watchListeners: [],
+    unwatch: {}
+  };
+  const getMount = (key) => {
+    for (const base of context.mountpoints) {
+      if (key.startsWith(base)) {
+        return {
+          relativeKey: key.slice(base.length),
+          driver: context.mounts[base]
+        };
+      }
+    }
+    return {
+      relativeKey: key,
+      driver: context.mounts[""]
+    };
+  };
+  const getMounts = (base, includeParent) => {
+    return context.mountpoints.filter((mountpoint) => mountpoint.startsWith(base) || includeParent && base.startsWith(mountpoint)).map((mountpoint) => ({
+      relativeBase: base.length > mountpoint.length ? base.slice(mountpoint.length) : void 0,
+      mountpoint,
+      driver: context.mounts[mountpoint]
+    }));
+  };
+  const onChange = (event, key) => {
+    if (!context.watching) {
+      return;
+    }
+    key = normalizeKey(key);
+    for (const listener of context.watchListeners) {
+      listener(event, key);
+    }
+  };
+  const startWatch = async () => {
+    if (context.watching) {
+      return;
+    }
+    context.watching = true;
+    for (const mountpoint in context.mounts) {
+      context.unwatch[mountpoint] = await watch(context.mounts[mountpoint], onChange, mountpoint);
+    }
+  };
+  const stopWatch = async () => {
+    if (!context.watching) {
+      return;
+    }
+    for (const mountpoint in context.unwatch) {
+      await context.unwatch[mountpoint]();
+    }
+    context.unwatch = {};
+    context.watching = false;
+  };
+  const storage = {
+    hasItem(key) {
+      key = normalizeKey(key);
+      const { relativeKey, driver } = getMount(key);
+      return asyncCall(driver.hasItem, relativeKey);
+    },
+    getItem(key) {
+      key = normalizeKey(key);
+      const { relativeKey, driver } = getMount(key);
+      return asyncCall(driver.getItem, relativeKey).then((value) => destr(value));
+    },
+    async setItem(key, value) {
+      if (value === void 0) {
+        return storage.removeItem(key);
+      }
+      key = normalizeKey(key);
+      const { relativeKey, driver } = getMount(key);
+      if (!driver.setItem) {
+        return;
+      }
+      await asyncCall(driver.setItem, relativeKey, stringify(value));
+      if (!driver.watch) {
+        onChange("update", key);
+      }
+    },
+    async removeItem(key, removeMeta = true) {
+      key = normalizeKey(key);
+      const { relativeKey, driver } = getMount(key);
+      if (!driver.removeItem) {
+        return;
+      }
+      await asyncCall(driver.removeItem, relativeKey);
+      if (removeMeta) {
+        await asyncCall(driver.removeItem, relativeKey + "$");
+      }
+      if (!driver.watch) {
+        onChange("remove", key);
+      }
+    },
+    async getMeta(key, nativeMetaOnly) {
+      key = normalizeKey(key);
+      const { relativeKey, driver } = getMount(key);
+      const meta = /* @__PURE__ */ Object.create(null);
+      if (driver.getMeta) {
+        Object.assign(meta, await asyncCall(driver.getMeta, relativeKey));
+      }
+      if (!nativeMetaOnly) {
+        const value = await asyncCall(driver.getItem, relativeKey + "$").then((value_) => destr(value_));
+        if (value && typeof value === "object") {
+          if (typeof value.atime === "string") {
+            value.atime = new Date(value.atime);
+          }
+          if (typeof value.mtime === "string") {
+            value.mtime = new Date(value.mtime);
+          }
+          Object.assign(meta, value);
+        }
+      }
+      return meta;
+    },
+    setMeta(key, value) {
+      return this.setItem(key + "$", value);
+    },
+    removeMeta(key) {
+      return this.removeItem(key + "$");
+    },
+    async getKeys(base) {
+      base = normalizeBaseKey(base);
+      const mounts = getMounts(base, true);
+      let maskedMounts = [];
+      const allKeys = [];
+      for (const mount of mounts) {
+        const rawKeys = await asyncCall(mount.driver.getKeys, mount.relativeBase);
+        const keys = rawKeys.map((key) => mount.mountpoint + normalizeKey(key)).filter((key) => !maskedMounts.some((p) => key.startsWith(p)));
+        allKeys.push(...keys);
+        maskedMounts = [
+          mount.mountpoint,
+          ...maskedMounts.filter((p) => !p.startsWith(mount.mountpoint))
+        ];
+      }
+      return base ? allKeys.filter((key) => key.startsWith(base) && !key.endsWith("$")) : allKeys.filter((key) => !key.endsWith("$"));
+    },
+    async clear(base) {
+      base = normalizeBaseKey(base);
+      await Promise.all(getMounts(base, false).map(async (m) => {
+        if (m.driver.clear) {
+          return asyncCall(m.driver.clear);
+        }
+        if (m.driver.removeItem) {
+          const keys = await m.driver.getKeys();
+          return Promise.all(keys.map((key) => m.driver.removeItem(key)));
+        }
+      }));
+    },
+    async dispose() {
+      await Promise.all(Object.values(context.mounts).map((driver) => dispose(driver)));
+    },
+    async watch(callback) {
+      await startWatch();
+      context.watchListeners.push(callback);
+      return async () => {
+        context.watchListeners = context.watchListeners.filter((listener) => listener !== callback);
+        if (context.watchListeners.length === 0) {
+          await stopWatch();
+        }
+      };
+    },
+    async unwatch() {
+      context.watchListeners = [];
+      await stopWatch();
+    },
+    mount(base, driver) {
+      base = normalizeBaseKey(base);
+      if (base && context.mounts[base]) {
+        throw new Error(`already mounted at ${base}`);
+      }
+      if (base) {
+        context.mountpoints.push(base);
+        context.mountpoints.sort((a, b) => b.length - a.length);
+      }
+      context.mounts[base] = driver;
+      if (context.watching) {
+        Promise.resolve(watch(driver, onChange, base)).then((unwatcher) => {
+          context.unwatch[base] = unwatcher;
+        }).catch(console.error);
+      }
+      return storage;
+    },
+    async unmount(base, _dispose = true) {
+      base = normalizeBaseKey(base);
+      if (!base || !context.mounts[base]) {
+        return;
+      }
+      if (context.watching && base in context.unwatch) {
+        context.unwatch[base]();
+        delete context.unwatch[base];
+      }
+      if (_dispose) {
+        await dispose(context.mounts[base]);
+      }
+      context.mountpoints = context.mountpoints.filter((key) => key !== base);
+      delete context.mounts[base];
+    }
+  };
+  return storage;
+}
+async function snapshot(storage, base) {
+  base = normalizeBaseKey(base);
+  const keys = await storage.getKeys(base);
+  const snapshot2 = {};
+  await Promise.all(keys.map(async (key) => {
+    snapshot2[key.slice(base.length)] = await storage.getItem(key);
+  }));
+  return snapshot2;
+}
+async function restoreSnapshot(driver, snapshot2, base = "") {
+  base = normalizeBaseKey(base);
+  await Promise.all(Object.entries(snapshot2).map((e) => driver.setItem(base + e[0], e[1])));
+}
+function watch(driver, onChange, base) {
+  return driver.watch ? driver.watch((event, key) => onChange(event, base + key)) : () => {
+  };
+}
+async function dispose(driver) {
+  if (typeof driver.dispose === "function") {
+    await asyncCall(driver.dispose);
+  }
+}
+
+const builtinDrivers = {
+  cloudflareKVHTTP: "unstorage/drivers/cloudflare-kv-http",
+  cloudflareKVBinding: "unstorage/drivers/cloudflare-kv-binding",
+  "cloudflare-kv-http": "unstorage/drivers/cloudflare-kv-http",
+  "cloudflare-kv-binding": "unstorage/drivers/cloudflare-kv-binding",
+  fs: "unstorage/drivers/fs",
+  github: "unstorage/drivers/github",
+  http: "unstorage/drivers/http",
+  localStorage: "unstorage/drivers/localstorage",
+  localstorage: "unstorage/drivers/localstorage",
+  memory: "unstorage/drivers/memory",
+  overlay: "unstorage/drivers/overlay",
+  redis: "unstorage/drivers/redis"
+};
+
+export { builtinDrivers, createStorage, defineDriver, joinKeys, normalizeBaseKey, normalizeKey, prefixStorage, restoreSnapshot, snapshot };

node_modules/unstorage/dist/server.cjs

@@ -0,0 +1,47 @@
+'use strict';
+
+const h3 = require('h3');
+const _utils = require('./shared/unstorage.e5f2cd8b.cjs');
+
+function createStorageServer(storage, _options = {}) {
+  const app = h3.createApp();
+  app.use(h3.eventHandler(async (event) => {
+    if (event.req.method === "GET") {
+      const value = await storage.getItem(event.req.url);
+      if (!value) {
+        const keys = await storage.getKeys(event.req.url);
+        return keys.map((key) => key.replace(/:/g, "/"));
+      }
+      return _utils.stringify(value);
+    }
+    if (event.req.method === "HEAD") {
+      const _hasItem = await storage.hasItem(event.req.url);
+      event.res.statusCode = _hasItem ? 200 : 404;
+      if (_hasItem) {
+        const meta = await storage.getMeta(event.req.url);
+        if (meta.mtime) {
+          event.res.setHeader("Last-Modified", new Date(meta.mtime).toUTCString());
+        }
+      }
+      return "";
+    }
+    if (event.req.method === "PUT") {
+      const value = await h3.readBody(event);
+      await storage.setItem(event.req.url, value);
+      return "OK";
+    }
+    if (event.req.method === "DELETE") {
+      await storage.removeItem(event.req.url);
+      return "OK";
+    }
+    throw h3.createError({
+      statusCode: 405,
+      statusMessage: "Method Not Allowed"
+    });
+  }));
+  return {
+    handle: h3.toNodeListener(app)
+  };
+}
+
+exports.createStorageServer = createStorageServer;

node_modules/unstorage/dist/server.d.ts

@@ -0,0 +1,11 @@
+import { RequestListener } from 'node:http';
+import { S as Storage } from './types-227df1cc.js';
+
+interface StorageServerOptions {
+}
+interface StorageServer {
+    handle: RequestListener;
+}
+declare function createStorageServer(storage: Storage, _options?: StorageServerOptions): StorageServer;
+
+export { StorageServer, StorageServerOptions, createStorageServer };

node_modules/unstorage/dist/server.mjs

@@ -0,0 +1,45 @@
+import { createApp, eventHandler, readBody, createError, toNodeListener } from 'h3';
+import { s as stringify } from './shared/unstorage.10149939.mjs';
+
+function createStorageServer(storage, _options = {}) {
+  const app = createApp();
+  app.use(eventHandler(async (event) => {
+    if (event.req.method === "GET") {
+      const value = await storage.getItem(event.req.url);
+      if (!value) {
+        const keys = await storage.getKeys(event.req.url);
+        return keys.map((key) => key.replace(/:/g, "/"));
+      }
+      return stringify(value);
+    }
+    if (event.req.method === "HEAD") {
+      const _hasItem = await storage.hasItem(event.req.url);
+      event.res.statusCode = _hasItem ? 200 : 404;
+      if (_hasItem) {
+        const meta = await storage.getMeta(event.req.url);
+        if (meta.mtime) {
+          event.res.setHeader("Last-Modified", new Date(meta.mtime).toUTCString());
+        }
+      }
+      return "";
+    }
+    if (event.req.method === "PUT") {
+      const value = await readBody(event);
+      await storage.setItem(event.req.url, value);
+      return "OK";
+    }
+    if (event.req.method === "DELETE") {
+      await storage.removeItem(event.req.url);
+      return "OK";
+    }
+    throw createError({
+      statusCode: 405,
+      statusMessage: "Method Not Allowed"
+    });
+  }));
+  return {
+    handle: toNodeListener(app)
+  };
+}
+
+export { createStorageServer };

node_modules/unstorage/dist/shared/unstorage.10149939.mjs

@@ -0,0 +1,22 @@
+function wrapToPromise(value) {
+  if (!value || typeof value.then !== "function") {
+    return Promise.resolve(value);
+  }
+  return value;
+}
+function asyncCall(function_, ...arguments_) {
+  try {
+    return wrapToPromise(function_(...arguments_));
+  } catch (error) {
+    return Promise.reject(error);
+  }
+}
+function isPrimitive(argument) {
+  const type = typeof argument;
+  return argument === null || type !== "object" && type !== "function";
+}
+function stringify(argument) {
+  return isPrimitive(argument) ? argument + "" : JSON.stringify(argument);
+}
+
+export { asyncCall as a, stringify as s };

node_modules/unstorage/dist/shared/unstorage.e5f2cd8b.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+function wrapToPromise(value) {
+  if (!value || typeof value.then !== "function") {
+    return Promise.resolve(value);
+  }
+  return value;
+}
+function asyncCall(function_, ...arguments_) {
+  try {
+    return wrapToPromise(function_(...arguments_));
+  } catch (error) {
+    return Promise.reject(error);
+  }
+}
+function isPrimitive(argument) {
+  const type = typeof argument;
+  return argument === null || type !== "object" && type !== "function";
+}
+function stringify(argument) {
+  return isPrimitive(argument) ? argument + "" : JSON.stringify(argument);
+}
+
+exports.asyncCall = asyncCall;
+exports.stringify = stringify;

node_modules/unstorage/dist/types-227df1cc.d.ts

@@ -0,0 +1,39 @@
+declare type StorageValue = null | string | String | number | Number | boolean | Boolean | object;
+declare type WatchEvent = "update" | "remove";
+declare type WatchCallback = (event: WatchEvent, key: string) => any;
+declare type MaybePromise<T> = T | Promise<T>;
+declare type Unwatch = () => MaybePromise<void>;
+interface StorageMeta {
+    atime?: Date;
+    mtime?: Date;
+    [key: string]: StorageValue | Date | undefined;
+}
+interface Driver {
+    hasItem: (key: string) => MaybePromise<boolean>;
+    getItem: (key: string) => StorageValue;
+    setItem?: (key: string, value: string) => MaybePromise<void>;
+    removeItem?: (key: string) => MaybePromise<void>;
+    getMeta?: (key: string) => MaybePromise<StorageMeta>;
+    getKeys: (base?: string) => MaybePromise<string[]>;
+    clear?: () => MaybePromise<void>;
+    dispose?: () => MaybePromise<void>;
+    watch?: (callback: WatchCallback) => MaybePromise<Unwatch>;
+}
+interface Storage {
+    hasItem: (key: string) => Promise<boolean>;
+    getItem: (key: string) => Promise<StorageValue>;
+    setItem: (key: string, value: StorageValue) => Promise<void>;
+    removeItem: (key: string, removeMeta?: boolean) => Promise<void>;
+    getMeta: (key: string, nativeMetaOnly?: true) => MaybePromise<StorageMeta>;
+    setMeta: (key: string, value: StorageMeta) => Promise<void>;
+    removeMeta: (key: string) => Promise<void>;
+    getKeys: (base?: string) => Promise<string[]>;
+    clear: (base?: string) => Promise<void>;
+    dispose: () => Promise<void>;
+    watch: (callback: WatchCallback) => Promise<Unwatch>;
+    unwatch: () => Promise<void>;
+    mount: (base: string, driver: Driver) => Storage;
+    unmount: (base: string, dispose?: boolean) => Promise<void>;
+}
+
+export { Driver as D, Storage as S, Unwatch as U, WatchEvent as W, StorageValue as a, WatchCallback as b, StorageMeta as c };