@filebox/webdav-server 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 FileBox
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,31 @@
+# @filebox/webdav-server
+
+FileBox 的 WebDAV 服务适配包，用来把 FileBox 驱动暴露为 WebDAV 请求处理器。
+
+## 安装
+
+```bash
+pnpm add @filebox/webdav-server
+```
+
+## 使用
+
+```js
+const { WebDAVServer } = require("@filebox/webdav-server");
+
+const server = new WebDAVServer({
+  auth: (user, password) => user === "admin" && password === "password",
+});
+
+const response = await server.request(request, {
+  driver,
+  base: "/webdav",
+  temp: "/tmp/filebox",
+});
+```
+
+驱动需要提供 WebDAV 操作中用到的文件能力，例如 `stat`、`list`、`download`、`upload`、`mkdir`、`remove`、`rename`、`copy` 和 `move`。
+
+## License
+
+MIT

package/context.js

@@ -0,0 +1,37 @@
+const createContext = (req, base, allows, temp) => {
+  const authorization = req.headers?.authorization?.split(" ")[1];
+
+  const path = new URL(req.url, `http://${req.headers.host}`).pathname;
+  const ctx = {
+    req: req,
+    depth: req.headers?.depth || 0,
+    method: (req.method || "").toLowerCase(),
+    path: path.replace(base, "").replace("/k", ""), // 临时这么做
+    base,
+    config: {
+      temp,
+    },
+    auth: { user: undefined, pass: undefined },
+    allows,
+    get(field) {
+      const req = this.req;
+      switch ((field = field.toLowerCase())) {
+        case "referer":
+        case "referrer":
+          return req.headers.referrer || req.headers.referer || "";
+        default:
+          return req.headers[field] || "";
+      }
+    },
+  };
+
+  if (authorization) {
+    const pairs = Buffer.from(authorization, "base64")
+      .toString("utf8")
+      .split(":");
+    ctx.auth = { user: pairs[0], pass: pairs[1] };
+  }
+  return ctx;
+};
+
+module.exports = createContext;

package/index.js

@@ -0,0 +1,88 @@
+const Commands = require("./operations/commands");
+const createContext = require("./context");
+
+const StatusCodes = {
+  200: "OK",
+  201: "Created",
+  204: "No Content",
+  207: "Multi Status",
+  302: "Moved Temporarily",
+  401: "Unauthorized",
+  403: "Forbidden",
+  404: "Not Found",
+  409: "Conflict",
+  423: "Locked",
+  500: "Internal Server Error",
+};
+
+const VirtualDriver = {
+  async get() {
+    return {
+      status: "200",
+      body: "Hello World!",
+      headers: {
+        "Content-Type": "application/json",
+      },
+    };
+  },
+  // 其他方法...
+};
+
+class WebDAVServer {
+  constructor(
+    { driver, base, redirect, auth } = { redirect: false, auth: () => true },
+  ) {
+    this.methods = {};
+    this.driver = driver || VirtualDriver;
+    this.base = base || "";
+    this.auth = auth;
+    this.config = { redirect };
+    const commands = Commands;
+    for (const k in commands) {
+      if (k === "NotImplemented") {
+        this.unknownMethod = commands[k];
+      } else {
+        this.methods[k.toLowerCase()] = commands[k];
+      }
+    }
+    this.allows = Object.keys(this.methods).map((i) => i.toUpperCase());
+  }
+
+  async request(req, options) {
+    const ctx = createContext(
+      req,
+      options?.base || this.base,
+      this.allows,
+      options.temp,
+    );
+
+    if (
+      !(ctx.method == "options" && !ctx.path) &&
+      !this?.auth(ctx.auth.user, ctx.auth.pass)
+    ) {
+      return {
+        headers: {
+          "X-WebDAV-Status": `401 ${StatusCodes[401]}`,
+          "www-Authenticate": 'Basic realm="Restricted"',
+        },
+        status: "401",
+      };
+    }
+
+    // ctx.driver = this.driver;
+    ctx.driver = options.driver;
+    ctx.config = { ...this.config, temp: options.temp };
+    const method = this.methods[ctx.method] || this.unknownMethod;
+    const res = await method(ctx);
+    res.headers = res.headers ?? {};
+    if (res.status) {
+      // res.headers["X-WebDAV-Status"] =
+      //   res.status + " " + StatusCodes[res.status];
+    }
+    return res;
+  }
+}
+
+module.exports = {
+  WebDAVServer,
+};

package/operations/commands.js

@@ -0,0 +1,31 @@
+const Get = require("./get");
+const Put = require("./put");
+const Post = require("./post");
+const Head = require("./head");
+const Move = require("./move");
+const Lock = require("./lock");
+const Copy = require("./copy");
+const Mkcol = require("./mkcol");
+const Unlock = require("./unlock");
+const Delete = require("./delete");
+const Options = require("./options");
+const Propfind = require("./propfind");
+const Proppatch = require("./proppatch");
+const NotImplemented = require("./not-implemented");
+
+module.exports = {
+  NotImplemented,
+  Proppatch,
+  Propfind,
+  Options,
+  Delete,
+  // Unlock,
+  Mkcol,
+  Copy,
+  // Lock,
+  Move,
+  Head,
+  // Post,
+  Put,
+  Get,
+};

package/operations/copy.js

@@ -0,0 +1,37 @@
+module.exports = async (ctx) => {
+  try {
+    const dst = new URL(ctx.req.headers?.destination).pathname.replace(
+      ctx.base,
+      "",
+    );
+    const src = ctx.path;
+    if (src === dst) {
+      return { status: "403" };
+    }
+
+    const stat = await ctx.driver.stat(src);
+    if (!stat || !stat.file) {
+      return { status: "404" };
+    }
+
+    const data = await ctx.driver.download(src);
+    if (!data || !data.length) {
+      return { status: "404" };
+    }
+
+    const { basename, dirname } = require("pathe");
+    const upath = dirname(dst);
+    const name = basename(dst);
+    const resp = await fetch(data[0].url);
+    await ctx.driver.upload(upath, {
+      name,
+      size: parseInt(resp.headers.get("content-length") || "0"),
+      data: resp.body,
+      mimeType: stat.mime || "application/octet-stream",
+    });
+
+    return { status: "201" };
+  } catch (_) {
+    return { status: "502" };
+  }
+};

package/operations/delete.js

@@ -0,0 +1,12 @@
+module.exports = async (ctx) => {
+  try {
+    await ctx.driver.remove(ctx.path);
+    return {
+      status: "204",
+    };
+  } catch (_) {
+    return {
+      status: "502",
+    };
+  }
+};

package/operations/get.js

@@ -0,0 +1,34 @@
+async function loadProxy() {
+  const proxy = await import("@filebox/proxy");
+  return proxy.default || proxy;
+}
+
+module.exports = async (ctx) => {
+  try {
+    const decodedPath = decodeURIComponent(ctx.path);
+    const stat = await ctx.driver.stat(decodedPath);
+    if (!stat || !stat.file) {
+      return {
+        status: "405",
+        body: "405 Method not allowed",
+      };
+    }
+    const data = await ctx.driver.download(decodedPath);
+    if (!data || !data.length || !data[0].url) {
+      return {
+        status: "404",
+        body: "file not found",
+      };
+    }
+    const proxy = await loadProxy();
+    return proxy(ctx.req, {
+      ...data[0],
+      fileName: decodedPath,
+    });
+  } catch (_) {
+    return {
+      status: "500",
+      body: "Internal Server Error",
+    };
+  }
+};

package/operations/head.js

@@ -0,0 +1,23 @@
+module.exports = async (ctx) => {
+  try {
+    console.log(ctx.path, "head", 22222);
+    const stat = ctx.driver.stat(ctx.path);
+    const headers = {
+      "Content-Type": "application/octet-stream",
+      "Content-Length": stat.size,
+      "Last-Modified": stat.mtime,
+      "Accept-Ranges": "bytes",
+    };
+
+    return {
+      status: "200",
+      headers: headers,
+      body: null,
+    };
+  } catch (error) {
+    console.log(error);
+    return {
+      status: "404",
+    };
+  }
+};

package/operations/lock.js

@@ -0,0 +1 @@
+module.exports = {};

package/operations/mkcol.js

@@ -0,0 +1,14 @@
+module.exports = async (ctx) => {
+  try {
+    await ctx.driver.mkdir(ctx.path);
+    return {
+      status: "201",
+      body: null,
+    };
+  } catch (_) {
+    return {
+      status: "500",
+      body: null,
+    };
+  }
+};

package/operations/move.js

@@ -0,0 +1,46 @@
+const { basename, dirname } = require("pathe");
+
+module.exports = async (ctx) => {
+  try {
+    const dst = new URL(ctx.req.headers?.destination).pathname.replace(
+      ctx.base,
+      "",
+    );
+    const src = ctx.path;
+
+    if (!dst) {
+      return {
+        status: "400",
+        body: "Missing source or destination URI",
+      };
+    }
+
+    const normalizedSrc = src.endsWith("/") ? src.slice(0, -1) : src;
+    const normalizedDst = dst.endsWith("/") ? dst.slice(0, -1) : dst;
+
+    if (normalizedSrc === normalizedDst) {
+      return { status: "403" };
+    }
+
+    const isRename =
+      normalizedSrc.substring(0, normalizedSrc.lastIndexOf("/")) ===
+      normalizedDst.substring(0, normalizedDst.lastIndexOf("/"));
+
+    if (isRename) {
+      // 处理重命名
+      await ctx.driver?.rename(normalizedSrc, basename(normalizedDst));
+    } else {
+      // 处理移动
+      await ctx.driver?.move(normalizedSrc, dirname(normalizedDst));
+    }
+
+    return {
+      status: "201",
+    };
+  } catch (_) {
+    return {
+      status: "502",
+      body: null,
+    };
+  }
+};

package/operations/not-implemented.js

@@ -0,0 +1,10 @@
+const commands = require("./commands");
+
+module.exports = async (ctx) => {
+  return {
+    status: "405 Method not allowed",
+    headers: {
+      Allow: Object.keys(commands).join(", "),
+    },
+  };
+};

package/operations/options.js

@@ -0,0 +1,17 @@
+module.exports = async (ctx) => {
+  const dav = [1];
+
+  if (ctx.allows?.includes("LOCK")) {
+    dav.push(2);
+  }
+
+  return {
+    headers: {
+      // For Microsoft clients
+      "MS-Author-Via": "DAV",
+      DAV: dav.join(", "),
+      Allow: ctx.allows?.join(", ") || "",
+    },
+    status: "200",
+  };
+};

package/operations/post.js

@@ -0,0 +1,10 @@
+const commands = require("./commands");
+
+module.exports = async (ctx) => {
+  return {
+    status: "405 Method not allowed",
+    headers: {
+      Allow: Object.keys(commands).join(", "),
+    },
+  };
+};

package/operations/propfind.js

@@ -0,0 +1,323 @@
+const parseXML = require("./shared");
+const xml2js = require("xml2js");
+
+const DEFAULT_PROPS = [
+  "displayname",
+  "getcontentlength",
+  "resourcetype",
+  "getcontenttype",
+  "creationdate",
+  "getlastmodified",
+];
+
+/**
+ * Parse props from webdav request
+ *
+ * @param {object} [data]
+ * @return {object|boolean}
+ */
+// const propParse = (data) => {
+//     if (!data) return {
+//         ns: { prefix: 'D', uri: 'DAV:' },
+//         prop: [...DEFAULT_PROPS]
+//     }
+//     let prop = [...DEFAULT_PROPS]
+//     const prefix = Object.keys(data.propfind.$).find(i => i.startsWith('xmlns:'))?.split(':')[1] || ''
+//     const uri = data.propfind.$?.[`xmlns${prefix ? `:${prefix}` : ''}`] || ''
+//     if (data.propfind.hasOwnProperty('prop')) {
+//         prop = Object.keys(data.propfind.prop)
+//     }
+//     return { ns: { prefix, uri }, prop }
+// }
+
+const propParse = (data) => {
+  if (!data) {
+    return {
+      ns: { prefix: "D", uri: "DAV:" },
+      prop: [...DEFAULT_PROPS],
+    };
+  }
+
+  let prop = [...DEFAULT_PROPS];
+  const ns = { prefix: "D", uri: "DAV:" };
+
+  if (data.propfind.hasOwnProperty("prop")) {
+    if (data.propfind.prop.hasOwnProperty("allprop")) {
+      return {
+        ns,
+        prop: [...DEFAULT_PROPS],
+      };
+    }
+
+    prop = Object.keys(data.propfind.prop);
+  }
+
+  return { ns, prop };
+};
+
+/**
+ * Create webdav responese xml by data and props options
+ *
+ * @param {object} [data] file data
+ * @param {object} [options]
+ * @param {object} [options.props] Available props
+ * @param {object} [options.path]  Current folder path
+ * @param {object} [options.ns]
+ * @return {string} XML string
+ */
+
+// const convData = (files, options) => {
+//   const {
+//     path,
+//     base = "",
+//     depth,
+//     prop,
+//     ns: { prefix, uri },
+//   } = options;
+//   console.log(options, 2222);
+//   console.log(files, 222);
+//   return files.map((file) => {
+//     const item = {};
+//     for (const key of prop) {
+//       item[key] = file.name
+//         .replace(/&/g, "&")
+//         .replace(/</g, "&lt;")
+//         .replace(/>/g, "&gt;")
+//         .replace(/"/g, "&quot;")
+//         .replace(/'/g, "&apos;");
+
+//       if (key == "getcontentlength") {
+//         item[key] = parseInt(file.size || 0);
+//       } else if (key == "resourcetype") {
+//         item[key] = file.type == "folder" ? { collection: "" } : "";
+//         // } else if (key == 'getcontenttype') {
+//         //   item[key] = file.mime
+//       } else if (key == "creationdate" && file.ctime) {
+//         item[key] = new Date(file.ctime).toUTCString();
+//       } else if (key == "getlastmodified" && file.lastModifiedDateTime) {
+//         item[key] = new Date(file.lastModifiedDateTime).toUTCString();
+//       }
+//     }
+
+//     const href = (
+//       base +
+//       path +
+//       (depth == "0" ? "" : "/" + encodeURIComponent(file.name))
+//     ).replace(/\/{2,}/g, "/");
+//     //if (file.type == 'file' && file.download_url) href = file.download_url
+//     return {
+//       href,
+//       propstat: {
+//         status: "HTTP/1.1 200 OK",
+//         prop: item,
+//       },
+//     };
+//   });
+// };
+
+const convData = (files, options) => {
+  const {
+    path,
+    base = "",
+    depth,
+    prop,
+    ns: { prefix, uri },
+  } = options;
+  // console.log(prop, 1111)
+  files = files.data || files.list || files;
+  return files.map((file) => {
+    const item = {};
+    for (const key of prop) {
+      // Encode special characters for XML for displayname property
+      if (key === "displayname") {
+        item[key] = file.name
+          .replace(/&/g, "&amp;")
+          .replace(/</g, "&lt;")
+          .replace(/>/g, "&gt;")
+          .replace(/"/g, "&quot;")
+          .replace(/'/g, "&apos;");
+      }
+
+      // Add the file size
+      if (key === "getcontentlength") {
+        item[key] = file.byte || 0;
+      }
+
+      // Add the resource type
+      if (key === "resourcetype") {
+        item[key] = file.type === "folder" ? { collection: "" } : "";
+      }
+
+      // Add the content type
+      if (key == "getcontenttype") {
+        item[key] = file.mime;
+      }
+
+      if (key === "getetag") {
+        const stamp =
+          file.etag || file.hash || file.mtime || file.updatedAt || "";
+        item[key] =
+          `"${Buffer.from(`${file.name || ""}:${file.byte || 0}:${stamp}`).toString("base64url")}"`;
+      }
+
+      // Add the creation date
+      if (key === "creationdate" && file.ctime) {
+        item[key] = new Date(file.ctime).toUTCString();
+      }
+
+      // Add the last modified date
+      if (key === "getlastmodified" && file.mtime) {
+        item[key] = new Date(file.mtime).toUTCString();
+      }
+
+      // Set the available quota bytes to indicate unlimited
+      if (key === "quota-available-bytes") {
+        item[key] = -1;
+      }
+
+      // Set the used quota bytes to indicate unlimited
+      if (key === "quota-used-bytes") {
+        item[key] = -1;
+      }
+    }
+
+    // Construct the href.
+    // The collection itself uses base+path; its children append /name.
+    // Collections get a trailing slash (RFC 4918 §5.2).
+    const isSelf = file._self === true;
+    let href = (
+      isSelf ? base + path : base + path + "/" + encodeURIComponent(file.name)
+    ).replace(/\/{2,}/g, "/");
+    if (file.type === "folder" && !href.endsWith("/")) href += "/";
+    // Return the WebDAV propstat object
+    return {
+      href,
+      propstat: {
+        status: "HTTP/1.1 200 OK",
+        prop: item,
+      },
+    };
+  });
+};
+
+const fixNs = (data, prefix) => {
+  if (!prefix) return data;
+  Object.keys(data).forEach((key) => {
+    const val = data[key];
+    if (key != "$" && prefix) {
+      if (Array.isArray(val) || typeof val == "object") {
+        fixNs(val, prefix);
+      }
+      delete data[key];
+      data[`${prefix}:${key}`] = val;
+    } else {
+      if (val.xmlns) {
+        val[`xmlns:${prefix}`] = val.xmlns;
+        delete val.xmlns;
+      }
+    }
+  });
+  return data;
+};
+
+const createXML = (data, options) => {
+  const {
+    ns: { prefix, uri },
+  } = options;
+
+  const obj = {
+    multistatus: {
+      response: convData(data || [], options),
+    },
+  };
+  if (uri) {
+    obj.multistatus.$ = {
+      xmlns: uri,
+    };
+  }
+
+  const builder = new xml2js.Builder({
+    renderOpts: { pretty: false },
+    xmldec: { version: "1.0", encoding: "UTF-8" },
+  });
+
+  const xml = builder.buildObject(fixNs(obj, prefix));
+  return xml;
+};
+
+module.exports = async (ctx) => {
+  const options = Object.assign(
+    {
+      path: ctx.path,
+      base: ctx.base,
+      depth: ctx.depth,
+    },
+    propParse(await parseXML(ctx.req)),
+  );
+
+  let data = {};
+  data.item = await ctx.driver.stat(ctx.path);
+  // console.log(data.item);
+  if (ctx.depth == "1") {
+    try {
+      data.files = await ctx.driver.list(ctx.path);
+    } catch (error) {
+      return { status: "500" };
+    }
+  }
+
+  if (!data) return { status: "404" };
+
+  if (data.error) {
+    if (data.error.code == 401) {
+      // Windows seems to require this being the last header sent
+      // (changed according to PECL bug #3138)
+      return {
+        headers: {
+          "WWW-Authenticate": `Basic realm="ShareList WebDAV"`,
+        },
+        status: "401",
+      };
+    } else {
+      return {
+        status: "404",
+      };
+    }
+  }
+
+  //return itself
+  // Mark the requested resource as "self" so its href is built as base+path
+  // (children append /name). Depth:1 must include the collection itself
+  // followed by its members (RFC 4918 §9.1).
+  const selfItem = Object.assign({}, data.item, { _self: true });
+  if (ctx.depth == "0") {
+    return {
+      status: "207",
+      headers: {
+        "content-type": 'text/xml; charset="utf-8"',
+      },
+      body: createXML([selfItem], options),
+    };
+  } else if (ctx.depth == "1") {
+    const listResult = data.files;
+    const children = Array.isArray(listResult)
+      ? listResult
+      : Array.isArray(listResult && listResult.data)
+        ? listResult.data
+        : Array.isArray(listResult && listResult.list)
+          ? listResult.list
+          : [];
+    return {
+      status: "207",
+      headers: {
+        // "content-type": 'text/xml; charset="utf-8"',
+        "content-type": 'application/xml; charset="utf-8"',
+      },
+      body: createXML([selfItem].concat(children), options),
+    };
+  } else if (ctx.depth == "infinity") {
+    return {
+      status: "404",
+    };
+  }
+};

package/operations/proppatch.js

@@ -0,0 +1,5 @@
+module.exports = async (ctx) => {
+  return {
+    status: "200",
+  };
+};

package/operations/put.js

@@ -0,0 +1,66 @@
+const { basename, dirname } = require("pathe");
+const fs = require("node:fs");
+const path = require("node:path");
+
+module.exports = async (ctx) => {
+  try {
+    const rawPath = decodeURIComponent(ctx.path);
+    const name = basename(rawPath);
+    const upath = dirname(rawPath);
+
+    const contentLength = parseInt(ctx.req.headers["content-length"] || 0);
+    const mimeType =
+      ctx.req.headers["content-type"] || "application/octet-stream";
+
+    const tempDir = ctx.config?.temp;
+    if (!tempDir) {
+      return { status: "500", body: "temp dir not configured" };
+    }
+
+    const tempFile = path.join(tempDir, `webdav-upload-${Date.now()}-${name}`);
+    const uploadStream =
+      ctx.req._webdavStream ||
+      (ctx.req.readable && !ctx.req.readableEnded ? ctx.req : null);
+
+    if (uploadStream && contentLength > 0) {
+      await new Promise((resolve, reject) => {
+        const ws = fs.createWriteStream(tempFile);
+        uploadStream.pipe(ws);
+        ws.on("finish", resolve);
+        ws.on("error", reject);
+        uploadStream.on("error", reject);
+      });
+    } else {
+      fs.writeFileSync(tempFile, "");
+    }
+
+    const tempStat = fs.statSync(tempFile);
+
+    if (tempStat.size === 0 && contentLength > 0) {
+      return { status: "502", body: "upload failed: empty file" };
+    }
+
+    try {
+      const result = await ctx.driver.upload(upath, {
+        name,
+        size: tempStat.size,
+        absolutePath: tempFile,
+        mimeType,
+      });
+
+      if (result && typeof result.upload === "function") {
+        await result.upload();
+      }
+    } catch (error) {
+      return { status: "502", body: String(error) };
+    } finally {
+      try {
+        fs.unlinkSync(tempFile);
+      } catch (_) {}
+    }
+
+    return { status: "200" };
+  } catch (err) {
+    return { status: "502", body: String(err?.message || err) };
+  }
+};

package/operations/shared.js

@@ -0,0 +1,26 @@
+const { parseStringPromise, processors } = require("xml2js");
+
+const parseBody = (req, charset) => {
+  return new Promise((resolve, reject) => {
+    const data = [];
+    const stream = req._webdavStream || req;
+    stream
+      .on("data", (chunk) => {
+        data.push(chunk);
+      })
+      .on("error", reject)
+      .on("end", () => resolve(Buffer.concat(data).toString(charset)));
+  });
+};
+
+const parseXML = async (req) => {
+  const txt = await parseBody(req);
+  if (!txt.trim()) return null;
+  return await parseStringPromise(txt, {
+    // explicitChildren: true,
+    explicitArray: false,
+    tagNameProcessors: [processors.stripPrefix],
+  });
+};
+
+module.exports = parseXML;

package/operations/unlock.js

@@ -0,0 +1 @@
+module.exports = {};

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@filebox/webdav-server",
+  "version": "1.0.0",
+  "description": "WebDAV server adapter for FileBox drivers",
+  "main": "./index.js",
+  "exports": {
+    ".": {
+      "require": "./index.js",
+      "default": "./index.js"
+    }
+  },
+  "files": [
+    "index.js",
+    "context.js",
+    "operations",
+    "LICENSE",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@filebox/proxy": "^1.0.0",
+    "pathe": "^1.1.2",
+    "xml2js": "^0.6.0"
+  }
+}