zen-fs-webdav 0.1.0

package/dist/index.js

@@ -0,0 +1,768 @@
+// zen-fs-webdav - https://github.com/weijia/zen-fs-webdav
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  WebDAVError: () => WebDAVError,
+  createWebDAVFileSystem: () => createWebDAVFileSystem
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var WebDAVError = class _WebDAVError extends Error {
+  constructor(message, status, cause) {
+    super(message);
+    this.name = "WebDAVError";
+    this.status = status;
+    this.cause = cause;
+    Object.setPrototypeOf(this, _WebDAVError.prototype);
+  }
+  toString() {
+    if (typeof this.status === "number") {
+      return `${this.name}: ${this.message} (Status: ${this.status})`;
+    }
+    return `${this.name}: ${this.message}`;
+  }
+  static fromResponse(response, message) {
+    const msg = message ? `${message}: ${response.status} ${response.statusText}` : `${response.status} ${response.statusText}`;
+    return new _WebDAVError(msg, response.status);
+  }
+  static fromError(error) {
+    if (error instanceof _WebDAVError) {
+      return error;
+    }
+    if (error instanceof Error) {
+      const msg = error.message || "Unknown WebDAV error";
+      return new _WebDAVError(msg, void 0, error);
+    }
+    return new _WebDAVError("Unknown WebDAV error");
+  }
+};
+var NotFoundError = class _NotFoundError extends WebDAVError {
+  constructor(path) {
+    super(`\u6587\u4EF6\u672A\u627E\u5230: ${path}`, 404);
+    this.name = "NotFoundError";
+    Object.setPrototypeOf(this, _NotFoundError.prototype);
+  }
+};
+var AuthenticationError = class _AuthenticationError extends WebDAVError {
+  constructor(message = "\u8BA4\u8BC1\u5931\u8D25") {
+    super(message, 401);
+    this.name = "AuthenticationError";
+    Object.setPrototypeOf(this, _AuthenticationError.prototype);
+  }
+};
+var AuthorizationError = class _AuthorizationError extends WebDAVError {
+  constructor(message = "\u6743\u9650\u88AB\u62D2\u7EDD") {
+    super(message, 403);
+    this.name = "AuthorizationError";
+    Object.setPrototypeOf(this, _AuthorizationError.prototype);
+  }
+};
+var ServerError = class _ServerError extends WebDAVError {
+  constructor(message = "\u670D\u52A1\u5668\u9519\u8BEF", statusCode = 500) {
+    super(message, statusCode);
+    this.name = "ServerError";
+    Object.setPrototypeOf(this, _ServerError.prototype);
+  }
+};
+var FileExistsError = class _FileExistsError extends WebDAVError {
+  constructor(path) {
+    super(`\u6587\u4EF6\u5DF2\u5B58\u5728: ${path}`, 412);
+    this.name = "FileExistsError";
+    Object.setPrototypeOf(this, _FileExistsError.prototype);
+  }
+};
+var TimeoutError = class _TimeoutError extends WebDAVError {
+  constructor(message = "\u8FDE\u63A5\u8D85\u65F6") {
+    super(message, 408);
+    this.name = "TimeoutError";
+    Object.setPrototypeOf(this, _TimeoutError.prototype);
+  }
+};
+var NetworkError = class _NetworkError extends WebDAVError {
+  constructor(originalError, message = "\u7F51\u7EDC\u9519\u8BEF") {
+    super(originalError ? `${message}: ${originalError.message}` : message, 0, originalError);
+    this.name = "NetworkError";
+    Object.setPrototypeOf(this, _NetworkError.prototype);
+  }
+};
+var ArgumentError = class _ArgumentError extends WebDAVError {
+  constructor(message) {
+    super(`\u65E0\u6548\u53C2\u6570: ${message}`);
+    this.name = "ArgumentError";
+    Object.setPrototypeOf(this, _ArgumentError.prototype);
+  }
+};
+
+// src/constants.ts
+var WebDAVNamespace = {
+  DAV: "DAV:",
+  CALDAV: "urn:ietf:params:xml:ns:caldav",
+  CARDDAV: "urn:ietf:params:xml:ns:carddav",
+  OWNCLOUD: "http://owncloud.org/ns",
+  NEXTCLOUD: "http://nextcloud.org/ns"
+};
+var XML_NAMESPACE_PREFIX = {
+  "d": WebDAVNamespace.DAV,
+  "oc": WebDAVNamespace.OWNCLOUD,
+  "nc": WebDAVNamespace.NEXTCLOUD
+};
+
+// src/utils.ts
+var import_fast_xml_parser = require("fast-xml-parser");
+function normalizePath(path) {
+  if (!path.startsWith("/")) {
+    path = "/" + path;
+  }
+  path = path.replace(/\/+/g, "/");
+  if (path.length > 1 && path.endsWith("/")) {
+    path = path.slice(0, -1);
+  }
+  return path;
+}
+function createBasicAuthHeader(username, password) {
+  const btoa = (str) => {
+    if (typeof window !== "undefined" && window.btoa) {
+      return window.btoa(str);
+    } else if (typeof Buffer !== "undefined") {
+      return Buffer.from(str).toString("base64");
+    } else {
+      throw new Error("Base64 encoding not available");
+    }
+  };
+  return `Basic ${btoa(`${username}:${password}`)}`;
+}
+function getContentType(filename) {
+  const ext = filename.split(".").pop()?.toLowerCase();
+  switch (ext) {
+    case "txt":
+      return "text/plain";
+    case "html":
+    case "htm":
+      return "text/html";
+    case "json":
+      return "application/json";
+    case "xml":
+      return "application/xml";
+    case "jpg":
+    case "jpeg":
+      return "image/jpeg";
+    case "png":
+      return "image/png";
+    case "gif":
+      return "image/gif";
+    case "pdf":
+      return "application/pdf";
+    case "csv":
+      return "text/csv";
+    case "js":
+      return "application/javascript";
+    case "css":
+      return "text/css";
+    case "zip":
+      return "application/zip";
+    default:
+      return "application/octet-stream";
+  }
+}
+function getDirFromPath(path) {
+  if (!path || path === "/") return "/";
+  const normalized = path.replace(/\/+$/, "");
+  const idx = normalized.lastIndexOf("/");
+  if (idx <= 0) return "/";
+  return normalized.slice(0, idx) || "/";
+}
+function parseWebDAVXml(xml, basePath) {
+  const decode = require("he").decode;
+  const result = [];
+  if (!xml) return result;
+  const parser = new import_fast_xml_parser.XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: "@_",
+    trimValues: true
+  });
+  const json = parser.parse(xml);
+  function getCaseInsensitive(obj, ...keys) {
+    if (!obj) return void 0;
+    for (const key of keys) {
+      if (obj[key] !== void 0) return obj[key];
+      const found = Object.keys(obj).find((k) => k.toLowerCase() === key.toLowerCase());
+      if (found) return obj[found];
+    }
+    return void 0;
+  }
+  const multistatus = getCaseInsensitive(json, "d:multistatus", "multistatus");
+  const responses = getCaseInsensitive(multistatus, "d:response", "response") || [];
+  const arr = Array.isArray(responses) ? responses : [responses];
+  const isBasePathFile = basePath && !basePath.endsWith("/");
+  for (const item of arr) {
+    const href = decode(getCaseInsensitive(item, "d:href", "href") || "");
+    const propstat = getCaseInsensitive(item, "d:propstat", "propstat", "d:prop", "prop") || {};
+    const prop = getCaseInsensitive(propstat, "d:prop", "prop") || propstat;
+    const resourcetype = getCaseInsensitive(prop, "d:resourcetype", "resourcetype");
+    const collection = resourcetype && getCaseInsensitive(resourcetype, "d:collection", "collection");
+    const isDirectory = !!(resourcetype && collection !== void 0);
+    let name;
+    if (isBasePathFile) {
+      name = href.split("/").filter(Boolean).pop() || "";
+    } else {
+      name = href.replace(basePath, "").replace(/^\//, "").replace(/\/$/, "");
+    }
+    if (!name) continue;
+    result.push({
+      path: href,
+      name,
+      isDirectory,
+      isFile: !isDirectory,
+      size: parseInt(String(getCaseInsensitive(prop, "d:getcontentlength", "getcontentlength") ?? "0"), 10),
+      lastModified: getCaseInsensitive(prop, "d:getlastmodified", "getlastmodified") ? new Date(String(getCaseInsensitive(prop, "d:getlastmodified", "getlastmodified"))) : void 0
+    });
+  }
+  return result;
+}
+function joinUrl(base, ...paths) {
+  let url = base;
+  let basePath = "";
+  try {
+    const u = new URL(base);
+    basePath = u.pathname.replace(/\/+$/, "");
+  } catch {
+    basePath = base.startsWith("/") ? base.replace(/\/+$/, "") : "";
+  }
+  if (paths.length > 0 && basePath) {
+    let p = paths[0];
+    if (p) {
+      const baseFirst = basePath.split("/").filter(Boolean)[0];
+      const pParts = p.split("/").filter(Boolean);
+      if (baseFirst && pParts[0] === baseFirst) {
+        pParts.shift();
+        p = pParts.join("/");
+        if (p && !p.startsWith("/")) p = "/" + p;
+        paths[0] = p;
+      }
+    }
+  }
+  for (const p of paths) {
+    if (!p) continue;
+    if (!url.endsWith("/")) url += "/";
+    url += p.startsWith("/") ? p.slice(1) : p;
+  }
+  url = url.replace(/([^:]\/)\/+/g, "$1");
+  return url;
+}
+
+// src/webdav-fs.ts
+var WebDAVFS = class {
+  /**
+   * 创建WebDAV文件系统实例
+   * @param options WebDAV选项
+   */
+  constructor(options) {
+    if (!options.baseUrl) {
+      throw new ArgumentError("\u5FC5\u987B\u63D0\u4F9BbaseUrl");
+    }
+    this.baseUrl = options.baseUrl.endsWith("/") ? options.baseUrl.slice(0, -1) : options.baseUrl;
+    if (options.username && options.password) {
+      this.auth = { username: options.username, password: options.password };
+    } else {
+      this.auth = void 0;
+    }
+    this.timeout = options.timeout || 3e4;
+    this.headers = options.headers || {};
+  }
+  /**
+   * 创建请求头
+   * @param customHeaders 自定义请求头
+   * @returns 合并后的请求头
+   */
+  createHeaders(customHeaders) {
+    const headers = {
+      ...this.headers,
+      ...customHeaders
+    };
+    if (this.auth) {
+      headers["Authorization"] = createBasicAuthHeader(this.auth.username, this.auth.password);
+    }
+    return headers;
+  }
+  /**
+   * 执行HTTP请求
+   * @param method HTTP方法
+   * @param path 请求路径
+   * @param options 请求选项
+   * @returns 响应对象
+   */
+  async request(method, path, options = {}) {
+    const normalizedPath = normalizePath(path);
+    const url = joinUrl(this.baseUrl, normalizedPath);
+    const headers = this.createHeaders(options.headers);
+    const controller = typeof AbortController !== "undefined" ? new AbortController() : void 0;
+    const timeoutId = controller ? setTimeout(() => controller.abort(), this.timeout) : void 0;
+    try {
+      const response = await fetch(url, {
+        method,
+        headers,
+        body: options.body,
+        signal: controller?.signal,
+        credentials: "include"
+      });
+      if (timeoutId) clearTimeout(timeoutId);
+      const responseHeaders = {};
+      response.headers.forEach((value, key) => {
+        responseHeaders[key.toLowerCase()] = value;
+      });
+      let data;
+      if (options.responseType === "arraybuffer") {
+        data = await response.arrayBuffer();
+      } else if (options.responseType === "blob") {
+        data = await response.blob();
+      } else if (options.responseType === "json") {
+        data = await response.json();
+      } else {
+        data = await response.text();
+      }
+      return {
+        data,
+        status: response.status,
+        headers: responseHeaders
+      };
+    } catch (error) {
+      if (timeoutId) clearTimeout(timeoutId);
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new TimeoutError(`\u8BF7\u6C42\u8D85\u65F6: ${url}`);
+      } else {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new NetworkError(error instanceof Error ? error : new Error(String(error)), `\u7F51\u7EDC\u9519\u8BEF: ${errorMessage}`);
+      }
+    }
+  }
+  /**
+   * 处理响应错误
+   * @param status HTTP状态码
+   * @param path 请求路径
+   * @param error 原始错误
+   */
+  handleResponseError(status, path, error) {
+    switch (status) {
+      case 401:
+        throw new AuthenticationError(`\u8BA4\u8BC1\u5931\u8D25: ${path}`);
+      case 403:
+        throw new AuthorizationError(`\u65E0\u6743\u9650\u8BBF\u95EE: ${path}`);
+      case 404:
+        throw new NotFoundError(`\u8D44\u6E90\u4E0D\u5B58\u5728: ${path}`);
+      case 409:
+        throw new FileExistsError(`\u8D44\u6E90\u5DF2\u5B58\u5728: ${path}`);
+      default:
+        throw new ServerError(`\u670D\u52A1\u5668\u9519\u8BEF (${status}): ${path}`, status);
+    }
+  }
+  /**
+   * 读取文件内容
+   * @param path 文件路径
+   * @param options 读取选项
+   * @returns 文件内容
+   */
+  async readFile(path, options = {}) {
+    const normalizedPath = normalizePath(path);
+    try {
+      const response = await this.request("GET", normalizedPath, {
+        headers: options.headers,
+        responseType: "arraybuffer"
+      });
+      if (response.status >= 400) {
+        this.handleResponseError(response.status, normalizedPath);
+      }
+      const arrayBuffer = response.data;
+      const uint8Array = new Uint8Array(arrayBuffer);
+      const buffer = Buffer.from(uint8Array);
+      if (options.encoding) {
+        return buffer.toString(options.encoding);
+      } else {
+        return buffer;
+      }
+    } catch (error) {
+      if (error instanceof WebDAVError) {
+        throw error;
+      }
+      throw new WebDAVError(`\u8BFB\u53D6\u6587\u4EF6\u5931\u8D25: ${normalizedPath}`, void 0, error);
+    }
+  }
+  /**
+   * 写入文件内容
+   * @param path 文件路径
+   * @param data 文件内容
+   * @param options 写入选项
+   * @returns 操作结果
+   */
+  async writeFile(path, data, options = {}) {
+    const normalizedPath = normalizePath(path);
+    const getFilenameFromPath = (p) => {
+      const parts = p.split("/");
+      return parts[parts.length - 1] || "";
+    };
+    const contentType = options.contentType || getContentType(getFilenameFromPath(normalizedPath));
+    if (options.overwrite === false) {
+      const exists = await this.exists(normalizedPath);
+      if (exists) {
+        throw new FileExistsError(normalizedPath);
+      }
+    }
+    const headers = {
+      "Content-Type": contentType
+    };
+    try {
+      const response = await this.request("PUT", normalizedPath, {
+        headers,
+        body: data
+      });
+      if (response.status >= 400) {
+        this.handleResponseError(response.status, normalizedPath);
+      }
+      return {
+        success: response.status >= 200 && response.status < 300,
+        statusCode: response.status
+      };
+    } catch (error) {
+      if (error instanceof WebDAVError) {
+        throw error;
+      }
+      throw new WebDAVError(`\u5199\u5165\u6587\u4EF6\u5931\u8D25: ${normalizedPath}`);
+    }
+  }
+  /**
+   * 删除文件
+   * @param path 文件路径
+   * @returns 操作结果
+   */
+  async deleteFile(path) {
+    const normalizedPath = normalizePath(path);
+    try {
+      const stat = await this.stat(normalizedPath);
+      if (stat.isDirectory) {
+        throw new ArgumentError(`\u8DEF\u5F84\u6307\u5411\u4E00\u4E2A\u76EE\u5F55\uFF0C\u8BF7\u4F7F\u7528rmdir\u65B9\u6CD5: ${normalizedPath}`);
+      }
+      const response = await this.request("DELETE", normalizedPath);
+      if (response.status >= 400) {
+        this.handleResponseError(response.status, normalizedPath);
+      }
+      return {
+        success: response.status >= 200 && response.status < 300,
+        statusCode: response.status
+      };
+    } catch (error) {
+      if (error instanceof WebDAVError) {
+        throw error;
+      }
+      throw new WebDAVError(`\u5220\u9664\u6587\u4EF6\u5931\u8D25: ${normalizedPath}`);
+    }
+  }
+  /**
+   * 读取目录内容
+   * @param path 目录路径
+   * @param options 读取选项
+   * @returns 文件统计信息数组
+   */
+  async readDir(path, options = {}) {
+    const normalizedPath = normalizePath(path);
+    try {
+      const headers = {
+        "Depth": options.recursive ? "infinity" : "1",
+        "Content-Type": "application/xml"
+      };
+      const response = await this.request("PROPFIND", normalizedPath, {
+        headers
+      });
+      if (response.status >= 400) {
+        this.handleResponseError(response.status, normalizedPath);
+      }
+      const files = parseWebDAVXml(response.data, normalizedPath);
+      const result = files.filter((file) => {
+        if (file.path === normalizedPath) {
+          return false;
+        }
+        if (!options.includeHidden && file.name.startsWith(".")) {
+          return false;
+        }
+        return true;
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof WebDAVError) {
+        throw error;
+      }
+      throw new WebDAVError(`\u8BFB\u53D6\u76EE\u5F55\u5931\u8D25: ${normalizedPath}`);
+    }
+  }
+  /**
+   * 创建目录
+   * @param path 目录路径
+   * @param options 创建选项
+   * @returns 操作结果
+   */
+  async mkdir(path, options = {}) {
+    const normalizedPath = normalizePath(path);
+    try {
+      try {
+        const stat = await this.stat(normalizedPath);
+        if (stat.isDirectory) {
+          return;
+        }
+        throw new FileExistsError(normalizedPath);
+      } catch (error) {
+        if (!(error instanceof NotFoundError)) {
+          throw error;
+        }
+      }
+      if (options.recursive !== false) {
+        const parentDir = getDirFromPath(normalizedPath);
+        if (parentDir !== "/" && parentDir !== normalizedPath) {
+          try {
+            await this.stat(parentDir);
+          } catch (error) {
+            if (error instanceof NotFoundError) {
+              await this.mkdir(parentDir, options);
+            } else {
+              throw error;
+            }
+          }
+        }
+      }
+      const response = await this.request("MKCOL", normalizedPath);
+      if (response.status >= 400) {
+        this.handleResponseError(response.status, normalizedPath);
+      }
+      return;
+    } catch (error) {
+      if (error instanceof WebDAVError) {
+        throw error;
+      }
+      throw new WebDAVError(`\u521B\u5EFA\u76EE\u5F55\u5931\u8D25: ${normalizedPath}`);
+    }
+  }
+  /**
+   * 删除文件或目录，行为类似于 Node.js 的 fs.rm
+   * @param path 路径
+   * @param options { recursive?: boolean, force?: boolean }
+   */
+  async rm(path, options) {
+    const { recursive = false, force = false } = options || {};
+    try {
+      const stat = await this.stat(path);
+      if (stat.isDirectory) {
+        if (recursive) {
+          const files = await this.readDir(path);
+          for (const file of files) {
+            const childPath = path.replace(/\/$/, "") + "/" + file.name;
+            await this.rm(childPath, { recursive: true, force });
+          }
+        } else {
+          const files = await this.readDir(path);
+          if (files.length > 0) {
+            throw new WebDAVError(`Directory not empty: ${path}`);
+          }
+        }
+      }
+      await this._delete(path);
+    } catch (err) {
+      if (force && (err instanceof Error && "code" in err && err.code === "ENOENT" || err instanceof Error && "status" in err && err.status === 404)) {
+        return;
+      }
+      throw err;
+    }
+  }
+  /**
+   * 兼容旧的 rmdir 方法，内部重定向到 rm
+   * @deprecated 请使用 rm
+   */
+  async rmdir(path, options) {
+    let opts = {};
+    if (typeof options === "boolean") {
+      opts.recursive = options;
+    } else if (typeof options === "object" && options !== null) {
+      opts = options;
+    }
+    return this.rm(path, opts);
+  }
+  /**
+   * 删除文件或目录
+   * @param path 文件或目录路径
+   * @returns 操作结果
+   */
+  async _delete(path) {
+    const normalizedPath = normalizePath(path);
+    try {
+      const response = await this.request("DELETE", normalizedPath);
+      if (response.status >= 400) {
+        this.handleResponseError(response.status, normalizedPath);
+      }
+      return {
+        success: response.status >= 200 && response.status < 300,
+        statusCode: response.status
+      };
+    } catch (error) {
+      if (error instanceof WebDAVError) {
+        throw error;
+      }
+      throw new WebDAVError(`\u5220\u9664\u5931\u8D25: ${normalizedPath}`, void 0, error);
+    }
+  }
+  /**
+   * 获取文件或目录的统计信息
+   * @param path 文件或目录路径
+   * @returns 文件统计信息
+   */
+  async stat(path) {
+    const normalizedPath = normalizePath(path);
+    try {
+      const headers = {
+        "Depth": "0",
+        "Content-Type": "application/xml"
+      };
+      const response = await this.request("PROPFIND", normalizedPath, {
+        headers
+      });
+      if (response.status === 404) {
+        throw new NotFoundError(normalizedPath);
+      } else if (response.status >= 400) {
+        this.handleResponseError(response.status, normalizedPath);
+      }
+      const files = parseWebDAVXml(response.data, normalizedPath);
+      if (files.length === 0) {
+        throw new NotFoundError(normalizedPath);
+      }
+      const stat = files[0];
+      return stat;
+    } catch (error) {
+      if (error instanceof WebDAVError) {
+        throw error;
+      }
+      throw new WebDAVError(`\u83B7\u53D6\u6587\u4EF6\u4FE1\u606F\u5931\u8D25: ${normalizedPath}`, void 0, error);
+    }
+  }
+  /**
+   * 检查文件或目录是否存在
+   * @param path 文件或目录路径
+   * @returns 是否存在
+   */
+  async exists(path) {
+    try {
+      await this.stat(path);
+      return true;
+    } catch (error) {
+      if (error instanceof NotFoundError) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  /**
+   * 复制文件或目录
+   * @param source 源路径
+   * @param destination 目标路径
+   * @param overwrite 是否覆盖已存在的文件
+   * @returns 操作结果
+   */
+  async copy(source, destination, overwrite = true) {
+    const normalizedSource = normalizePath(source);
+    const normalizedDestination = normalizePath(destination);
+    try {
+      await this.stat(normalizedSource);
+      if (!overwrite) {
+        const exists = await this.exists(normalizedDestination);
+        if (exists) {
+          throw new FileExistsError(normalizedDestination);
+        }
+      }
+      const headers = {
+        "Destination": joinUrl(this.baseUrl, normalizedDestination),
+        "Overwrite": overwrite ? "T" : "F"
+      };
+      const response = await this.request("COPY", normalizedSource, {
+        headers
+      });
+      if (response.status >= 400) {
+        this.handleResponseError(response.status, normalizedSource);
+      }
+      return {
+        success: response.status >= 200 && response.status < 300,
+        statusCode: response.status
+      };
+    } catch (error) {
+      if (error instanceof WebDAVError) {
+        throw error;
+      }
+      throw new WebDAVError(`\u590D\u5236\u5931\u8D25: ${normalizedSource} -> ${normalizedDestination}`, void 0, error);
+    }
+  }
+  /**
+   * 移动文件或目录
+   * @param source 源路径
+   * @param destination 目标路径
+   * @param overwrite 是否覆盖已存在的文件
+   * @returns 操作结果
+   */
+  async move(source, destination, overwrite = true) {
+    const normalizedSource = normalizePath(source);
+    const normalizedDestination = normalizePath(destination);
+    try {
+      await this.stat(normalizedSource);
+      if (!overwrite) {
+        const exists = await this.exists(normalizedDestination);
+        if (exists) {
+          throw new FileExistsError(normalizedDestination);
+        }
+      }
+      const headers = {
+        "Destination": joinUrl(this.baseUrl, normalizedDestination),
+        "Overwrite": overwrite ? "T" : "F"
+      };
+      const response = await this.request("MOVE", normalizedSource, {
+        headers
+      });
+      if (response.status >= 400) {
+        this.handleResponseError(response.status, normalizedSource);
+      }
+      return {
+        success: response.status >= 200 && response.status < 300,
+        statusCode: response.status
+      };
+    } catch (error) {
+      if (error instanceof WebDAVError) {
+        throw error;
+      }
+      throw new WebDAVError(`\u79FB\u52A8\u5931\u8D25: ${normalizedSource} -> ${normalizedDestination}`, void 0, error);
+    }
+  }
+  /**
+   * 删除文件（fs/unlink 兼容方法）
+   * @param path 文件路径
+   */
+  async unlink(path) {
+    await this.deleteFile(path);
+  }
+};
+
+// src/webdav.ts
+function createWebDAVFileSystem(options) {
+  return new WebDAVFS(options);
+}
+//# sourceMappingURL=index.js.map