main.js

"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);

// main.ts
var main_exports = {};
__export(main_exports, {
  default: () => SecureWebdavImagesPlugin
});
module.exports = __toCommonJS(main_exports);
var import_obsidian4 = require("obsidian");

// secure-webdav-image-support.ts
var import_obsidian = require("obsidian");
var SECURE_PROTOCOL = "webdav-secure:";
var SECURE_CODE_BLOCK = "secure-webdav";
var SecureWebdavRenderChild = class extends import_obsidian.MarkdownRenderChild {
  constructor(containerEl) {
    super(containerEl);
  }
  onunload() {
  }
};
var SecureWebdavImageSupport = class {
  constructor(deps) {
    this.deps = deps;
  }
  buildSecureImageMarkup(remoteUrl, alt) {
    const remotePath = this.extractRemotePath(remoteUrl);
    if (!remotePath) {
      return `![](${remoteUrl})`;
    }
    return this.buildSecureImageCodeBlock(remotePath, alt);
  }
  buildSecureImageCodeBlock(remotePath, alt) {
    const normalizedAlt = (alt || remotePath).replace(/\r?\n/g, " ").trim();
    const normalizedPath = remotePath.replace(/\r?\n/g, "").trim();
    return [`\`\`\`${SECURE_CODE_BLOCK}`, `path: ${normalizedPath}`, `alt: ${normalizedAlt}`, "```"].join("\n");
  }
  parseSecureImageBlock(source) {
    const result = { path: "", alt: "" };
    for (const rawLine of source.split(/\r?\n/)) {
      const line = rawLine.trim();
      if (!line) {
        continue;
      }
      const separatorIndex = line.indexOf(":");
      if (separatorIndex === -1) {
        continue;
      }
      const key = line.slice(0, separatorIndex).trim().toLowerCase();
      const value = line.slice(separatorIndex + 1).trim();
      if (key === "path") {
        result.path = value;
      } else if (key === "alt") {
        result.alt = value;
      }
    }
    return result.path ? result : null;
  }
  async processSecureImages(el, ctx) {
    const secureCodeBlocks = Array.from(el.querySelectorAll(`pre > code.language-${SECURE_CODE_BLOCK}`));
    await Promise.all(
      secureCodeBlocks.map(async (codeEl) => {
        const pre = codeEl.parentElement;
        if (!(pre instanceof HTMLElement) || pre.hasAttribute("data-secure-webdav-rendered")) {
          return;
        }
        const parsed = this.parseSecureImageBlock(codeEl.textContent ?? "");
        if (!parsed?.path) {
          return;
        }
        pre.setAttribute("data-secure-webdav-rendered", "true");
        await this.renderSecureImageIntoElement(pre, parsed.path, parsed.alt || parsed.path);
      })
    );
    const secureNodes = Array.from(el.querySelectorAll("[data-secure-webdav]"));
    await Promise.all(
      secureNodes.map(async (node) => {
        if (node instanceof HTMLImageElement) {
          await this.swapImageSource(node);
          return;
        }
        const remotePath = node.getAttribute("data-secure-webdav");
        if (!remotePath) {
          return;
        }
        const img = document.createElement("img");
        img.alt = node.getAttribute("aria-label") ?? node.getAttribute("alt") ?? "Secure WebDAV image";
        img.setAttribute("data-secure-webdav", remotePath);
        img.classList.add("secure-webdav-image", "is-loading");
        node.replaceWith(img);
        await this.swapImageSource(img);
      })
    );
    const secureLinks = Array.from(el.querySelectorAll(`img[src^="${SECURE_PROTOCOL}//"]`));
    await Promise.all(secureLinks.map(async (img) => this.swapImageSource(img)));
    ctx.addChild(new SecureWebdavRenderChild(el));
  }
  async processSecureCodeBlock(source, el, ctx) {
    const parsed = this.parseSecureImageBlock(source);
    if (!parsed?.path) {
      el.createEl("div", {
        text: this.deps.t("\u5B89\u5168\u56FE\u7247\u4EE3\u7801\u5757\u683C\u5F0F\u65E0\u6548\u3002", "Invalid secure image code block format.")
      });
      return;
    }
    await this.renderSecureImageIntoElement(el, parsed.path, parsed.alt || parsed.path);
    ctx.addChild(new SecureWebdavRenderChild(el));
  }
  extractRemotePath(src) {
    const prefix = `${SECURE_PROTOCOL}//`;
    if (!src.startsWith(prefix)) {
      return null;
    }
    return src.slice(prefix.length);
  }
  async renderSecureImageIntoElement(el, remotePath, alt) {
    const img = document.createElement("img");
    img.alt = alt;
    img.setAttribute("data-secure-webdav", remotePath);
    img.classList.add("secure-webdav-image", "is-loading");
    el.empty();
    el.appendChild(img);
    await this.swapImageSource(img);
  }
  async swapImageSource(img) {
    const remotePath = img.getAttribute("data-secure-webdav") ?? this.extractRemotePath(img.getAttribute("src") ?? "");
    if (!remotePath) {
      return;
    }
    img.classList.add("secure-webdav-image", "is-loading");
    const originalAlt = img.alt;
    img.alt = originalAlt || this.deps.t("\u52A0\u8F7D\u5B89\u5168\u56FE\u7247\u4E2D...", "Loading secure image...");
    try {
      const blobUrl = await this.deps.fetchSecureImageBlobUrl(remotePath);
      img.src = blobUrl;
      img.alt = originalAlt;
      img.style.display = "block";
      img.style.maxWidth = "100%";
      img.classList.remove("is-loading", "is-error");
    } catch (error) {
      console.error("Secure WebDAV image load failed", error);
      img.replaceWith(this.buildErrorElement(remotePath, error));
    }
  }
  buildErrorElement(remotePath, error) {
    const el = document.createElement("div");
    el.className = "secure-webdav-image is-error";
    const message = error instanceof Error ? error.message : String(error);
    el.textContent = this.deps.t(
      `\u5B89\u5168\u56FE\u7247\u52A0\u8F7D\u5931\u8D25\uFF1A${remotePath}\uFF08${message}\uFF09`,
      `Secure image failed: ${remotePath} (${message})`
    );
    return el;
  }
};

// secure-webdav-upload-queue.ts
var import_obsidian2 = require("obsidian");
var SecureWebdavUploadQueueSupport = class {
  constructor(deps) {
    this.deps = deps;
    this.processingTaskIds = /* @__PURE__ */ new Set();
    this.retryTimeouts = /* @__PURE__ */ new Map();
    this.pendingTaskPromises = /* @__PURE__ */ new Map();
  }
  dispose() {
    for (const timeoutId of this.retryTimeouts.values()) {
      window.clearTimeout(timeoutId);
    }
    this.retryTimeouts.clear();
  }
  hasPendingWork() {
    return this.deps.getQueue().length > 0 || this.processingTaskIds.size > 0 || this.pendingTaskPromises.size > 0;
  }
  async enqueueEditorImageUpload(noteFile, editor, imageFile, fileName) {
    try {
      const arrayBuffer = await imageFile.arrayBuffer();
      const task = this.createUploadTask(
        noteFile.path,
        arrayBuffer,
        imageFile.type || this.deps.getMimeTypeFromFileName(fileName),
        fileName
      );
      this.insertPlaceholder(editor, task.placeholder);
      this.deps.setQueue([...this.deps.getQueue(), task]);
      await this.deps.savePluginState();
      void this.processPendingTasks();
      new import_obsidian2.Notice(this.deps.t("\u5DF2\u52A0\u5165\u56FE\u7247\u81EA\u52A8\u4E0A\u4F20\u961F\u5217\u3002", "Image added to the auto-upload queue."));
    } catch (error) {
      console.error("Failed to queue secure image upload", error);
      new import_obsidian2.Notice(
        this.deps.describeError(
          this.deps.t("\u52A0\u5165\u56FE\u7247\u81EA\u52A8\u4E0A\u4F20\u961F\u5217\u5931\u8D25", "Failed to queue image for auto-upload"),
          error
        ),
        8e3
      );
    }
  }
  createUploadTask(notePath, binary, mimeType, fileName) {
    const id = `secure-webdav-task-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
    return {
      id,
      notePath,
      placeholder: this.buildPendingPlaceholder(id, fileName),
      mimeType,
      fileName,
      dataBase64: this.deps.arrayBufferToBase64(binary),
      attempts: 0,
      createdAt: Date.now()
    };
  }
  buildPendingPlaceholder(taskId, fileName) {
    const safeName = this.deps.escapeHtml(fileName);
    return `<span class="secure-webdav-pending" data-secure-webdav-task="${taskId}" aria-label="${safeName}">${this.deps.escapeHtml(this.deps.t(`\u3010\u56FE\u7247\u4E0A\u4F20\u4E2D\uFF5C${fileName}\u3011`, `[Uploading image | ${fileName}]`))}</span>`;
  }
  buildFailedPlaceholder(fileName, message) {
    const safeName = this.deps.escapeHtml(fileName);
    const safeMessage = this.deps.escapeHtml(message ?? this.deps.t("\u672A\u77E5\u9519\u8BEF", "Unknown error"));
    const label = this.deps.escapeHtml(this.deps.t(`\u3010\u56FE\u7247\u4E0A\u4F20\u5931\u8D25\uFF5C${fileName}\u3011`, `[Image upload failed | ${fileName}]`));
    return `<span class="secure-webdav-failed" aria-label="${safeName}">${label}: ${safeMessage}</span>`;
  }
  async processPendingTasks() {
    const running = [];
    for (const task of this.deps.getQueue()) {
      if (this.processingTaskIds.has(task.id)) {
        continue;
      }
      running.push(this.startPendingTask(task));
    }
    await Promise.allSettled(running);
  }
  startPendingTask(task) {
    const existing = this.pendingTaskPromises.get(task.id);
    if (existing) {
      return existing;
    }
    const promise = this.processTask(task).finally(() => {
      this.pendingTaskPromises.delete(task.id);
    });
    this.pendingTaskPromises.set(task.id, promise);
    return promise;
  }
  async processTask(task) {
    this.processingTaskIds.add(task.id);
    try {
      const binary = this.deps.base64ToArrayBuffer(task.dataBase64);
      const prepared = await this.deps.prepareUploadPayload(
        binary,
        task.mimeType || this.deps.getMimeTypeFromFileName(task.fileName),
        task.fileName
      );
      const remoteName = await this.deps.buildRemoteFileNameFromBinary(prepared.fileName, prepared.binary);
      const remotePath = this.deps.buildRemotePath(remoteName);
      const response = await this.deps.requestUrl({
        url: this.deps.buildUploadUrl(remotePath),
        method: "PUT",
        headers: {
          Authorization: this.deps.buildAuthHeader(),
          "Content-Type": prepared.mimeType
        },
        body: prepared.binary
      });
      if (response.status < 200 || response.status >= 300) {
        throw new Error(`Upload failed with status ${response.status}`);
      }
      const replaced = await this.replacePlaceholder(
        task.notePath,
        task.id,
        task.placeholder,
        this.deps.buildSecureImageMarkup(`webdav-secure://${remotePath}`, prepared.fileName)
      );
      if (!replaced) {
        throw new Error(
          this.deps.t(
            "\u4E0A\u4F20\u6210\u529F\uFF0C\u4F46\u6CA1\u6709\u5728\u7B14\u8BB0\u4E2D\u627E\u5230\u53EF\u66FF\u6362\u7684\u5360\u4F4D\u7B26\u3002",
            "Upload succeeded, but no matching placeholder was found in the note."
          )
        );
      }
      this.deps.setQueue(this.deps.getQueue().filter((item) => item.id !== task.id));
      await this.deps.savePluginState();
      this.deps.schedulePriorityNoteSync(task.notePath, "image-add");
      new import_obsidian2.Notice(this.deps.t("\u56FE\u7247\u4E0A\u4F20\u6210\u529F\u3002", "Image uploaded successfully."));
    } catch (error) {
      console.error("Secure WebDAV queued upload failed", error);
      task.attempts += 1;
      task.lastError = error instanceof Error ? error.message : String(error);
      await this.deps.savePluginState();
      if (task.attempts >= this.deps.settings().maxRetryAttempts) {
        await this.replacePlaceholder(
          task.notePath,
          task.id,
          task.placeholder,
          this.buildFailedPlaceholder(task.fileName, task.lastError)
        );
        this.deps.setQueue(this.deps.getQueue().filter((item) => item.id !== task.id));
        await this.deps.savePluginState();
        new import_obsidian2.Notice(this.deps.describeError(this.deps.t("\u56FE\u7247\u4E0A\u4F20\u6700\u7EC8\u5931\u8D25", "Image upload failed permanently"), error), 8e3);
      } else {
        this.scheduleRetry(task);
      }
    } finally {
      this.processingTaskIds.delete(task.id);
    }
  }
  scheduleRetry(task) {
    const existing = this.retryTimeouts.get(task.id);
    if (existing) {
      window.clearTimeout(existing);
    }
    const delay = Math.max(1, this.deps.settings().retryDelaySeconds) * 1e3 * task.attempts;
    const timeoutId = window.setTimeout(() => {
      this.retryTimeouts.delete(task.id);
      void this.startPendingTask(task);
    }, delay);
    this.retryTimeouts.set(task.id, timeoutId);
  }
  insertPlaceholder(editor, placeholder) {
    editor.replaceSelection(`${placeholder}
`);
  }
  async replacePlaceholder(notePath, taskId, placeholder, replacement) {
    const replacedInEditor = this.replacePlaceholderInOpenEditors(notePath, taskId, placeholder, replacement);
    if (replacedInEditor) {
      return true;
    }
    const file = this.deps.app.vault.getAbstractFileByPath(notePath);
    if (!(file instanceof import_obsidian2.TFile)) {
      return false;
    }
    const content = await this.deps.app.vault.read(file);
    if (content.includes(placeholder)) {
      const updated = content.replace(placeholder, replacement);
      if (updated !== content) {
        await this.deps.app.vault.modify(file, updated);
        return true;
      }
    }
    const pattern = new RegExp(
      `<span[^>]*data-secure-webdav-task="${this.deps.escapeRegExp(taskId)}"[^>]*>.*?<\\/span>`,
      "s"
    );
    if (pattern.test(content)) {
      const updated = content.replace(pattern, replacement);
      if (updated !== content) {
        await this.deps.app.vault.modify(file, updated);
        return true;
      }
    }
    return false;
  }
  replacePlaceholderInOpenEditors(notePath, taskId, placeholder, replacement) {
    let replaced = false;
    const leaves = this.deps.app.workspace.getLeavesOfType("markdown");
    for (const leaf of leaves) {
      const view = leaf.view;
      if (!(view instanceof import_obsidian2.MarkdownView)) {
        continue;
      }
      if (!view.file || view.file.path !== notePath) {
        continue;
      }
      const editor = view.editor;
      const content = editor.getValue();
      let updated = content;
      if (content.includes(placeholder)) {
        updated = content.replace(placeholder, replacement);
      } else {
        const pattern = new RegExp(
          `<span[^>]*data-secure-webdav-task="${this.deps.escapeRegExp(taskId)}"[^>]*>.*?<\\/span>`,
          "s"
        );
        updated = content.replace(pattern, replacement);
      }
      if (updated !== content) {
        editor.setValue(updated);
        replaced = true;
      }
    }
    return replaced;
  }
};

// secure-webdav-sync-support.ts
var import_obsidian3 = require("obsidian");
var SecureWebdavSyncSupport = class {
  constructor(deps) {
    this.deps = deps;
  }
  isExcludedSyncPath(path) {
    const normalizedPath = (0, import_obsidian3.normalizePath)(path).replace(/^\/+/, "").replace(/\/+$/, "");
    if (!normalizedPath) {
      return false;
    }
    const folders = this.deps.getExcludedSyncFolders?.() ?? [];
    return folders.some((folder) => {
      const normalizedFolder = (0, import_obsidian3.normalizePath)(folder).replace(/^\/+/, "").replace(/\/+$/, "");
      return normalizedFolder.length > 0 && (normalizedPath === normalizedFolder || normalizedPath.startsWith(`${normalizedFolder}/`));
    });
  }
  shouldSkipContentSyncPath(path) {
    const normalizedPath = (0, import_obsidian3.normalizePath)(path);
    if (this.isExcludedSyncPath(normalizedPath) || normalizedPath.startsWith(".obsidian/") || normalizedPath.startsWith(".trash/") || normalizedPath.startsWith(".git/") || normalizedPath.startsWith("node_modules/") || normalizedPath.startsWith("_plugin_packages/") || normalizedPath.startsWith(".tmp-") || normalizedPath.startsWith(".obsidian/plugins/secure-webdav-images/") || normalizedPath.includes(".sync-conflict-")) {
      return true;
    }
    return /\.(png|jpe?g|gif|webp|bmp|svg)$/i.test(normalizedPath);
  }
  shouldSkipDirectorySyncPath(dirPath) {
    const p = (0, import_obsidian3.normalizePath)(dirPath);
    return this.isExcludedSyncPath(p) || p.startsWith(".obsidian") || p.startsWith(".trash") || p.startsWith(".git") || p.startsWith("node_modules") || p.startsWith("_plugin_packages") || p.startsWith(".tmp-");
  }
  collectLocalSyncedDirectories() {
    const dirs = /* @__PURE__ */ new Set();
    for (const f of this.deps.app.vault.getAllFolders()) {
      if (f instanceof import_obsidian3.TFolder && !f.isRoot() && !this.shouldSkipDirectorySyncPath(f.path)) {
        dirs.add((0, import_obsidian3.normalizePath)(f.path));
      }
    }
    return dirs;
  }
  collectVaultContentFiles() {
    return this.deps.app.vault.getFiles().filter((file) => !this.shouldSkipContentSyncPath(file.path)).sort((a, b) => a.path.localeCompare(b.path));
  }
  buildSyncSignature(file) {
    return `${file.stat.mtime}:${file.stat.size}`;
  }
  buildRemoteSyncSignature(remote) {
    return `${remote.lastModified}:${remote.size}`;
  }
  isLegacySignature(sig) {
    if (typeof sig !== "string" || !sig) return true;
    const parts = sig.split(":");
    if (parts.length === 2 && parts.every((p) => /^\d+$/.test(p))) return false;
    if (parts.length === 3 && /^\d+$/.test(parts[0]) && /^\d+$/.test(parts[1]) && /^[a-f0-9]{16}$/.test(parts[2])) return false;
    return true;
  }
  buildVaultSyncRemotePath(vaultPath) {
    return `${this.normalizeFolder(this.deps.getVaultSyncRemoteFolder())}${vaultPath}`;
  }
  buildRemoteEventFolder() {
    return `${this.normalizeFolder(this.deps.getVaultSyncRemoteFolder()).replace(/\/$/, "")}${this.deps.eventFolderSuffix}`;
  }
  remotePathToVaultPath(remotePath) {
    const root = this.normalizeFolder(this.deps.getVaultSyncRemoteFolder());
    if (!remotePath.startsWith(root)) {
      return null;
    }
    return remotePath.slice(root.length).replace(/^\/+/, "");
  }
  normalizeFolder(input) {
    return normalizeFolder(input);
  }
};
function normalizeFolder(input) {
  return input.replace(/^\/+/, "").replace(/\/+$/, "") + "/";
}

// main.ts
var DEFAULT_SETTINGS = {
  webdavUrl: "",
  username: "",
  password: "",
  remoteFolder: "/remote-images/",
  vaultSyncRemoteFolder: "/vault-sync/",
  excludedSyncFolders: ["kb"],
  namingStrategy: "hash",
  language: "auto",
  autoSyncIntervalMinutes: 0,
  maxRetryAttempts: 5,
  retryDelaySeconds: 5,
  compressImages: true,
  compressThresholdKb: 300,
  maxImageDimension: 2200,
  jpegQuality: 82,
  autoUpdateCheckIntervalHours: 24
};
var MIME_MAP = {
  jpg: "image/jpeg",
  jpeg: "image/jpeg",
  png: "image/png",
  gif: "image/gif",
  webp: "image/webp",
  svg: "image/svg+xml",
  bmp: "image/bmp",
  "image/jpeg": "jpg",
  "image/png": "png",
  "image/gif": "gif",
  "image/webp": "webp",
  "image/bmp": "bmp",
  "image/svg+xml": "svg"
};
// ── v2.0.0 Entity / MixedEntity data models ──

// Entity: a file's state snapshot at one point in time
class SyncEntity {
  constructor(opts = {}) {
    this.key = opts.key ?? "";            // vaultPath
    this.mtimeCli = opts.mtimeCli ?? 0;   // local mtime (ms)
    this.mtimeSvr = opts.mtimeSvr ?? 0;   // remote Last-Modified (ms)
    this.size = opts.size ?? 0;           // file size (bytes)
    this.hash = opts.hash ?? "";          // SHA-256 first 16 hex chars (content-based)
    this.remotePath = opts.remotePath ?? ""; // WebDAV path
    this.syncTime = opts.syncTime ?? 0;   // timestamp when this snapshot was recorded
  }

  signature() {
    if (this.hash) return `${this.mtimeCli}:${this.size}:${this.hash}`;
    return `${this.mtimeCli}:${this.size}`;
  }

}

// 4-bit state enum for the decision matrix
const LOCAL_UNCHANGED = 0, LOCAL_MODIFIED = 1, LOCAL_DELETED = 2, LOCAL_NEW = 3;
const REMOTE_UNCHANGED = 0, REMOTE_MODIFIED = 1, REMOTE_DELETED = 2, REMOTE_NEW = 3;

// MixedEntity: merged three-way view for one file path
class MixedEntity {
  constructor(key) {
    this.key = key;           // vaultPath
    this.local = null;        // SyncEntity | null
    this.prevSync = null;     // SyncEntity | null (from localforage)
    this.remote = null;       // SyncEntity | null
    this.decision = "skip";   // skip | pull | push | deleteLocal | deleteRemote | conflict | cleanHistory
    this.decisionBranch = 0;  // 0-15 (localState<<2 | remoteState)
  }
}

// Determine local state relative to prevSync record
function classifyLocalState(local, prevSync) {
  if (!prevSync) {
    return local ? LOCAL_NEW : LOCAL_UNCHANGED;
  }
  if (!local) {
    return LOCAL_DELETED;
  }
  const localSig = local.signature();
  const prevSig = prevSync.signature();
  if (localSig === prevSig) return LOCAL_UNCHANGED;
  // If prevSync lacks a content hash (stored from a pull where we only know
  // server mtime+size), compare only mtime:size so a freshly-downloaded file
  // isn't falsely flagged as locally modified.
  const prevParts = prevSig.split(":");
  if (prevParts.length === 2 && /^\d+$/.test(prevParts[0]) && /^\d+$/.test(prevParts[1])) {
    const localTrimmed = localSig.split(":").slice(0, 2).join(":");
    if (localTrimmed === prevSig) return LOCAL_UNCHANGED;
  }
  return LOCAL_MODIFIED;
}

// Determine remote state relative to prevSync record
function classifyRemoteState(remote, prevSync) {
  if (!prevSync) {
    return remote ? REMOTE_NEW : REMOTE_UNCHANGED;
  }
  if (!remote) {
    return REMOTE_DELETED;
  }
  // Remote entities (from PROPFIND) never carry a content hash.
  // Use mtimeSvr (server-confirmed mtime) when available; otherwise
  // fall back to mtimeCli from prevSync.
  const remoteSig = remote.signature();
  const prevMtime = prevSync.mtimeSvr || prevSync.mtimeCli;
  const prevSigForRemote = `${prevMtime}:${prevSync.size}`;
  if (remoteSig !== prevSigForRemote) {
    return REMOTE_MODIFIED;
  }
  return REMOTE_UNCHANGED;
}

function parseStoredSyncSignature(sig) {
  if (typeof sig !== "string" || !sig) {
    return { mtime: 0, size: 0, hash: "", valid: false };
  }
  const parts = sig.split(":");
  if (parts.length !== 2 && parts.length !== 3) {
    return { mtime: 0, size: 0, hash: "", valid: false };
  }
  const mtime = Number(parts[0]);
  const size = Number(parts[1]);
  if (!Number.isFinite(mtime) || !Number.isFinite(size)) {
    return { mtime: 0, size: 0, hash: "", valid: false };
  }
  const hash = parts.length === 3 ? parts[2] : "";
  return { mtime, size, hash, valid: true };
}

// 4×4 decision matrix (based on remotely-save V3)
//
//                 remote: unchanged    modified     deleted      new
// local unchanged:   skip           pull         deleteLocal  pull
// local modified:    push           conflict     push         conflict
// local deleted:     deleteRemote   pull         cleanHistory skip-or-pull
// local new:         push           conflict     push         conflict
//
// * [unchanged, deleted]: file in prevSync but not on remote → deleteLocal.
//   Three-way comparison gives us confidence the deletion is authoritative.
//
// Extra rules:
// - conflict + local.hash === remote.hash → skip (content identical)
// - conflict + remote.hash matches another local file → skip (content dedup)

function computeDecision(mixed, localContentIndex = null) {
  const localState = classifyLocalState(mixed.local, mixed.prevSync);
  const remoteState = classifyRemoteState(mixed.remote, mixed.prevSync);
  mixed.decisionBranch = (localState << 2) | remoteState;
  if (localState === LOCAL_UNCHANGED) {
    if (remoteState === REMOTE_UNCHANGED)   { mixed.decision = "skip"; }
    else if (remoteState === REMOTE_MODIFIED) { mixed.decision = "pull"; }
    else if (remoteState === REMOTE_DELETED)  { mixed.decision = "deleteLocal"; }
    else if (remoteState === REMOTE_NEW)      { mixed.decision = "pull"; }
  } else if (localState === LOCAL_MODIFIED) {
    if (remoteState === REMOTE_UNCHANGED)   { mixed.decision = "push"; }
    else if (remoteState === REMOTE_MODIFIED) { mixed.decision = "conflict"; }
    else if (remoteState === REMOTE_DELETED)  { mixed.decision = "push"; }
    else if (remoteState === REMOTE_NEW)      { mixed.decision = "conflict"; }
  } else if (localState === LOCAL_DELETED) {
    if (remoteState === REMOTE_UNCHANGED)   { mixed.decision = "deleteRemote"; }
    else if (remoteState === REMOTE_MODIFIED) { mixed.decision = "pull"; }
    else if (remoteState === REMOTE_DELETED)  { mixed.decision = "cleanHistory"; }
    else if (remoteState === REMOTE_NEW) {
      // Local deleted, remote new — could be a rename from another path, or a genuine new file
      mixed.decision = "pull";
    }
  } else if (localState === LOCAL_NEW) {
    if (remoteState === REMOTE_UNCHANGED)   { mixed.decision = "push"; }
    else if (remoteState === REMOTE_MODIFIED) { mixed.decision = "conflict"; }
    else if (remoteState === REMOTE_DELETED)  { mixed.decision = "push"; }
    else if (remoteState === REMOTE_NEW)      { mixed.decision = "conflict"; }
  }

  // Content-based conflict resolution
  if (mixed.decision === "conflict" && mixed.local && mixed.remote) {
    // Same content hash → no real conflict
    if (mixed.local.hash && mixed.remote.hash && mixed.local.hash === mixed.remote.hash) {
      mixed.decision = "skip";
    }
    // Remote content matches another local file → content-aware dedup
    else if (localContentIndex && mixed.remote.hash) {
      const matchingPaths = localContentIndex.get(mixed.remote.hash);
      if (matchingPaths && matchingPaths.size > 0) {
        // Remote content exists locally at another path → skip, let that path handle it
        mixed.decision = "skip";
      }
    }
  }

  return mixed;
}

var SecureWebdavImagesPlugin = class extends import_obsidian4.Plugin {
  constructor() {
    super(...arguments);
    this.settings = DEFAULT_SETTINGS;
    this.queue = [];
    this.blobUrls = /* @__PURE__ */ new Set();
    this.maxBlobUrls = 100;
    this.noteRemoteRefs = /* @__PURE__ */ new Map();
    this.syncIndex = /* @__PURE__ */ new Map();
    this.syncedDirectories = /* @__PURE__ */ new Set();
    this.pendingVaultSyncPaths = /* @__PURE__ */ new Set();
    this.pendingVaultDeletionPaths = /* @__PURE__ */ new Map();
    this.pendingVaultRenamePaths = /* @__PURE__ */ new Map();
    this.pendingVaultMutationPromises = /* @__PURE__ */ new Set();
    this.lastVaultSyncAt = 0;
    this.lastVaultSyncStatus = "";
    this.syncInProgress = false;
    this.autoSyncTickInProgress = false;
    this.eventFolderSuffix = ".__secure-webdav-events__/";
    this.clientId = "";
    this.recentVaultMutations = [];
    this.lastAutoUpdateCheckAt = 0;
    this.localDB = null;  // v2.0.0: localforage instance for prevSyncRecords
    this.localControlRoot = "";
    this.localDeviceStateLoaded = false;
    this.suppressedVaultEventPaths = /* @__PURE__ */ new Map();
    this.autoSyncIntervalId = null;
    this.autoUpdateIntervalId = null;
  }
  // ── v2.0.0: prevSyncRecords storage via localStorage ──
  // Obsidian plugins run in Electron renderer; localStorage is available.
  // We use it directly instead of localforage to avoid an external dependency
  // that can't be required/imported in the single-file plugin bundle.
  getLocalDB() {
    if (!this._localDB) {
      const PREV = "swdi_prev:";
      const META = "swdi_meta:";
      this._localDB = {
        async getPrevSyncRecord(key) {
          const v = localStorage.getItem(PREV + key);
          return v ? JSON.parse(v) : null;
        },
        async setPrevSyncRecord(key, entity) {
          localStorage.setItem(PREV + key, JSON.stringify(entity));
        },
        async deletePrevSyncRecord(key) {
          localStorage.removeItem(PREV + key);
        },
        async getAllPrevSyncRecords() {
          const result = new Map();
          for (let i = 0; i < localStorage.length; i++) {
            const k = localStorage.key(i);
            if (k && k.startsWith(PREV)) {
              result.set(k.slice(PREV.length), JSON.parse(localStorage.getItem(k)));
            }
          }
          return result;
        },
        async clearPrevSyncRecords() {
          const keys = [];
          for (let i = 0; i < localStorage.length; i++) {
            const k = localStorage.key(i);
            if (k && k.startsWith(PREV)) keys.push(k);
          }
          keys.forEach((k) => localStorage.removeItem(k));
        },
        async getPluginMeta(key) {
          const v = localStorage.getItem(META + key);
          return v ? JSON.parse(v) : null;
        },
        async setPluginMeta(key, value) {
          localStorage.setItem(META + key, JSON.stringify(value));
        },
        async deletePluginMeta(key) {
          localStorage.removeItem(META + key);
        },
      };
    }
    return this._localDB;
  }
  initializeSupportModules() {
    this.imageSupport = new SecureWebdavImageSupport({
      t: this.t.bind(this),
      fetchSecureImageBlobUrl: this.fetchSecureImageBlobUrl.bind(this)
    });
    this.uploadQueue = new SecureWebdavUploadQueueSupport({
      app: this.app,
      t: this.t.bind(this),
      settings: () => this.settings,
      getQueue: () => this.queue,
      setQueue: (queue) => {
        this.queue = queue;
      },
      savePluginState: this.savePluginState.bind(this),
      schedulePriorityNoteSync: this.schedulePriorityNoteSync.bind(this),
      requestUrl: this.requestUrl.bind(this),
      buildUploadUrl: this.buildUploadUrl.bind(this),
      buildAuthHeader: this.buildAuthHeader.bind(this),
      prepareUploadPayload: this.prepareUploadPayload.bind(this),
      buildRemoteFileNameFromBinary: this.buildRemoteFileNameFromBinary.bind(this),
      buildRemotePath: this.buildRemotePath.bind(this),
      buildSecureImageMarkup: this.imageSupport.buildSecureImageMarkup.bind(this.imageSupport),
      getMimeTypeFromFileName: this.getMimeTypeFromFileName.bind(this),
      arrayBufferToBase64: this.arrayBufferToBase64.bind(this),
      base64ToArrayBuffer: this.base64ToArrayBuffer.bind(this),
      escapeHtml: this.escapeHtml.bind(this),
      escapeRegExp: this.escapeRegExp.bind(this),
      describeError: this.describeError.bind(this)
    });
    this.syncSupport = new SecureWebdavSyncSupport({
      app: this.app,
      getVaultSyncRemoteFolder: () => this.settings.vaultSyncRemoteFolder,
      getExcludedSyncFolders: () => this.settings.excludedSyncFolders ?? []
    });
  }
  async onload() {
    await this.loadPluginState();
    await this.ensureLocalControlReady();
    await this.loadLocalDeviceState();
    this.initializeSupportModules();
    // v2.0.0: initialize localforage for prevSyncRecords
    this.localDB = this.getLocalDB();
    this.addSettingTab(new SecureWebdavSettingTab(this.app, this));
    this.addCommand({
      id: "upload-current-note-local-images",
      name: this.t("上传当前笔记中的本地图片到 WebDAV", "Upload local images in current note to WebDAV"),
      checkCallback: (checking) => {
        const file = this.app.workspace.getActiveFile();
        if (!file) {
          return false;
        }
        if (!checking) {
          void this.uploadImagesInNote(file);
        }
        return true;
      }
    });
    this.addCommand({
      id: "test-webdav-connection",
      name: this.t("测试 WebDAV 连接", "Test WebDAV connection"),
      callback: () => {
        void this.runConnectionTest(true);
      }
    });
    this.addCommand({
      id: "sync-vault-content-to-webdav",
      name: this.t("同步内容到 WebDAV", "Sync vault content to WebDAV"),
      callback: () => {
        void this.runSync();
      }
    });
    const syncRibbon = this.addRibbonIcon("refresh-cw", this.t("\u540C\u6B65\u5230 WebDAV", "Sync to WebDAV"), () => {
      void this.runSync();
    });
    syncRibbon.addClass("secure-webdav-sync-ribbon");
    this.registerMarkdownPostProcessor((el, ctx) => {
      void this.imageSupport.processSecureImages(el, ctx);
    });
    try {
      this.registerMarkdownCodeBlockProcessor(SECURE_CODE_BLOCK, (source, el, ctx) => {
        void this.imageSupport.processSecureCodeBlock(source, el, ctx);
      });
    } catch {
      console.warn("[secure-webdav-images] code block processor already registered, skipping");
    }
    this.registerEvent(
      this.app.workspace.on("editor-paste", (evt, editor, info) => {
        void this.handleEditorPaste(evt, editor, info);
      })
    );
    this.registerEvent(
      this.app.workspace.on("editor-drop", (evt, editor, info) => {
        void this.handleEditorDrop(evt, editor, info);
      })
    );
    await this.rebuildReferenceIndex();
    this.restartBackgroundSchedulers();
    void this.uploadQueue.processPendingTasks();
    this.register(() => {
      for (const blobUrl of this.blobUrls) {
        URL.revokeObjectURL(blobUrl);
      }
      this.blobUrls.clear();
      this.uploadQueue.dispose();
    });
  }
  onunload() {
    this.stopAutoSync();
    this.stopAutoUpdateCheck();
    for (const blobUrl of this.blobUrls) {
      URL.revokeObjectURL(blobUrl);
    }
    this.blobUrls.clear();
    this.uploadQueue?.dispose();
  }
  async loadPluginState() {
    const loaded = await this.loadData();
    if (!loaded || typeof loaded !== "object") {
      this.settings = { ...DEFAULT_SETTINGS };
      this.queue = [];
        this.syncIndex = /* @__PURE__ */ new Map();
      this.syncedDirectories = /* @__PURE__ */ new Set();
        this.pendingVaultSyncPaths = /* @__PURE__ */ new Set();
      this.pendingVaultRenamePaths = /* @__PURE__ */ new Map();
      this.clientId = this.generateClientId();
      this.lastAutoUpdateCheckAt = 0;
      return;
    }
    const candidate = loaded;
    if ("settings" in candidate || "queue" in candidate) {
      this.settings = { ...DEFAULT_SETTINGS, ...candidate.settings ?? {} };
      this.queue = Array.isArray(candidate.queue) ? candidate.queue : [];
      this.pendingVaultSyncPaths = new Set(
        Array.isArray(candidate.pendingVaultSyncPaths) ? candidate.pendingVaultSyncPaths.filter((path) => typeof path === "string") : []
      );
      for (const [path, rawEntry] of Object.entries(candidate.pendingVaultDeletionPaths ?? {})) {
        if (!rawEntry || typeof rawEntry !== "object") {
          continue;
        }
        const entry = rawEntry;
        const remotePath = typeof entry.remotePath === "string" && entry.remotePath.length > 0 ? entry.remotePath : `${this.normalizeFolder(this.settings.vaultSyncRemoteFolder)}${path}`;
        const remoteSignature = typeof entry.remoteSignature === "string" ? entry.remoteSignature : void 0;
        const creationTime = typeof entry.creationTime === "number" ? entry.creationTime : 0;
        const recordedAt = typeof entry.recordedAt === "number" ? entry.recordedAt : 0;
        this.pendingVaultDeletionPaths.set(path, { remotePath, remoteSignature, creationTime, recordedAt });
      }
      this.pendingVaultRenamePaths = /* @__PURE__ */ new Map();
      for (const [oldPath, rawEntry] of Object.entries(candidate.pendingVaultRenamePaths ?? {})) {
        if (!rawEntry || typeof rawEntry !== "object") {
          continue;
        }
        const entry = rawEntry;
        const newPath = typeof entry.newPath === "string" ? entry.newPath : "";
        if (!newPath) {
          continue;
        }
        const oldRemotePath = typeof entry.oldRemotePath === "string" && entry.oldRemotePath.length > 0 ? entry.oldRemotePath : `${this.normalizeFolder(this.settings.vaultSyncRemoteFolder)}${oldPath}`;
        const oldRemoteSignature = typeof entry.oldRemoteSignature === "string" ? entry.oldRemoteSignature : void 0;
        const recordedAt = typeof entry.recordedAt === "number" ? entry.recordedAt : Date.now();
        this.pendingVaultRenamePaths.set(oldPath, {
          oldPath,
          newPath,
          oldRemotePath,
          oldRemoteSignature,
          recordedAt
        });
      }
      this.syncIndex = /* @__PURE__ */ new Map();
      for (const [path, rawEntry] of Object.entries(candidate.syncIndex ?? {})) {
        const normalized = this.normalizeSyncIndexEntry(path, rawEntry);
        if (normalized) {
          this.syncIndex.set(path, normalized);
        }
      }
      this.lastVaultSyncAt = typeof candidate.lastVaultSyncAt === "number" ? candidate.lastVaultSyncAt : 0;
      this.lastVaultSyncStatus = typeof candidate.lastVaultSyncStatus === "string" ? candidate.lastVaultSyncStatus : "";
      this.syncedDirectories = new Set(
        Array.isArray(candidate.syncedDirectories) ? candidate.syncedDirectories : []
      );
      this.clientId = typeof candidate.clientId === "string" && candidate.clientId.length > 0 ? candidate.clientId : this.generateClientId();
      this.lastAutoUpdateCheckAt = typeof candidate.lastAutoUpdateCheckAt === "number" ? candidate.lastAutoUpdateCheckAt : 0;
      this.normalizeEffectiveSettings();
      return;
    }
    this.settings = { ...DEFAULT_SETTINGS, ...candidate };
    this.queue = [];
    this.syncIndex = /* @__PURE__ */ new Map();
    this.syncedDirectories = /* @__PURE__ */ new Set();
    this.pendingVaultSyncPaths = /* @__PURE__ */ new Set();
    this.pendingVaultDeletionPaths = /* @__PURE__ */ new Map();
    this.pendingVaultRenamePaths = /* @__PURE__ */ new Map();
    this.lastVaultSyncAt = 0;
    this.lastVaultSyncStatus = "";
    this.clientId = this.generateClientId();
    this.recentVaultMutations = [];
    this.lastAutoUpdateCheckAt = 0;
    this.normalizeEffectiveSettings();
  }
  normalizeEffectiveSettings() {
    delete this.settings.deleteLocalAfterUpload;
    delete this.settings.deleteRemoteWhenUnreferenced;
    this.settings.autoSyncIntervalMinutes = Math.max(0, Math.floor(this.settings.autoSyncIntervalMinutes || 0));
    this.settings.autoUpdateCheckIntervalHours = Math.max(0, Math.min(168, Math.floor(this.settings.autoUpdateCheckIntervalHours ?? 24)));
    const rawExcluded = this.settings.excludedSyncFolders;
    const excluded = Array.isArray(rawExcluded) ? rawExcluded : typeof rawExcluded === "string" ? rawExcluded.split(/[,\n]/) : DEFAULT_SETTINGS.excludedSyncFolders;
    this.settings.excludedSyncFolders = [
      ...new Set(
        excluded.map((value) => (0, import_obsidian4.normalizePath)(String(value).trim()).replace(/^\/+/, "").replace(/\/+$/, "")).filter((value) => value.length > 0)
      )
    ];
  }
  normalizeFolder(input) {
    return normalizeFolder(input);
  }
  generateClientId() {
    let hostname = "unknown";
    try {
      const os = require("os");
      hostname = os.hostname().toLowerCase().replace(/[^a-z0-9-]/g, "-");
    } catch (_) {}
    return `${hostname}-kim`;
  }
  getPluginInstallDir() {
    let basePath;
    try {
      basePath = this.app.vault.adapter.basePath;
    } catch {
      basePath = this.app.vault.getRoot().vault.adapter.basePath;
    }
    return `${basePath}/.obsidian/plugins/${this.manifest.id}/`;
  }
  getRuntimePluginVersion() {
    return this.manifest.version || "0.0.0";
  }
  readInstalledPluginVersion() {
    try {
      const fs = require("fs");
      const path = require("path");
      const manifestPath = path.join(this.getPluginInstallDir(), "manifest.json");
      const raw = fs.readFileSync(manifestPath, "utf8");
      const parsed = JSON.parse(raw);
      if (parsed && typeof parsed.version === "string" && parsed.version.length > 0) {
        return parsed.version;
      }
    } catch (_) {
    }
    const cached = this.app.plugins?.manifests?.[this.manifest.id]?.version;
    return typeof cached === "string" && cached.length > 0 ? cached : this.getRuntimePluginVersion();
  }
  hasPendingPluginReload() {
    return this.compareSemver(this.readInstalledPluginVersion(), this.getRuntimePluginVersion()) > 0;
  }
  formatPluginVersionStatusLabel() {
    const runtimeVersion = this.getRuntimePluginVersion();
    const installedVersion = this.readInstalledPluginVersion();
    if (runtimeVersion === installedVersion) {
      return this.t(`运行中版本与磁盘版本一致：v${runtimeVersion}`, `Running version matches installed version: v${runtimeVersion}`);
    }
    return this.t(
      `当前运行 v${runtimeVersion}，磁盘已安装 v${installedVersion}。重新加载插件后生效。`,
      `Running v${runtimeVersion}, installed on disk v${installedVersion}. Reload the plugin to apply it.`
    );
  }
  setupAutoSync() {
    this.stopAutoSync();
    const minutes = this.settings.autoSyncIntervalMinutes;
    if (minutes <= 0) {
      return;
    }
    const intervalMs = minutes * 60 * 1e3;
    this.autoSyncIntervalId = window.setInterval(() => {
      void this.runAutoSyncTick();
    }, intervalMs);
    this.registerInterval(this.autoSyncIntervalId);
  }
  compareSemver(a, b) {
    const pa = a.replace(/^v/, "").split(".").map(Number);
    const pb = b.replace(/^v/, "").split(".").map(Number);
    for (let i = 0; i < 3; i++) {
      const na = pa[i] || 0;
      const nb = pb[i] || 0;
      if (na !== nb) return na > nb ? 1 : -1;
    }
    return 0;
  }
  setupAutoUpdateCheck() {
    this.stopAutoUpdateCheck();
    const hours = this.settings.autoUpdateCheckIntervalHours;
    if (hours <= 0) return;
    const intervalMs = hours * 3600 * 1e3;
    this.autoUpdateIntervalId = window.setInterval(() => {
      void this.checkForPluginUpdate(false);
    }, intervalMs);
    this.registerInterval(this.autoUpdateIntervalId);
  }
  stopAutoSync() {
    if (this.autoSyncIntervalId !== null) {
      window.clearInterval(this.autoSyncIntervalId);
      this.autoSyncIntervalId = null;
    }
  }
  stopAutoUpdateCheck() {
    if (this.autoUpdateIntervalId !== null) {
      window.clearInterval(this.autoUpdateIntervalId);
      this.autoUpdateIntervalId = null;
    }
  }
  restartBackgroundSchedulers() {
    this.setupAutoSync();
    this.setupAutoUpdateCheck();
  }
  async fetchLatestRelease() {
    const url = "https://api.github.com/repos/Kim-Huang-JunKai/obsidian-secure-webdav-images/releases/latest";
    try {
      const resp = await this.requestUrl({ url, method: "GET" });
      if (resp.status !== 200) return null;
      const text = this.decodeUtf8(resp.arrayBuffer);
      const data = JSON.parse(text);
      if (!data || !data.tag_name || !Array.isArray(data.assets)) return null;
      return {
        tagName: data.tag_name,
        assets: data.assets.map((a) => ({ name: a.name, downloadUrl: a.browser_download_url, size: a.size }))
      };
    } catch (e) {
      console.warn("[secure-webdav-images] fetch latest release failed:", e);
      return null;
    }
  }
  async checkForPluginUpdate(showNotice) {
    const release = await this.fetchLatestRelease();
    this.lastAutoUpdateCheckAt = Date.now();
    await this.savePluginState();
    if (!release) {
      if (showNotice) {
        new import_obsidian4.Notice(this.t("检查更新失败，无法连接 GitHub。", "Update check failed: cannot reach GitHub."));
      }
      return;
    }
    const remoteVersion = release.tagName.replace(/^v/, "");
    const runtimeVersion = this.getRuntimePluginVersion();
    const installedVersion = this.readInstalledPluginVersion();
    const cmp = this.compareSemver(remoteVersion, installedVersion);
    if (cmp <= 0) {
      if (showNotice) {
        if (this.compareSemver(installedVersion, runtimeVersion) > 0) {
          new import_obsidian4.Notice(
            this.t(
              `磁盘已安装 v${installedVersion}，当前运行仍是 v${runtimeVersion}。请重新加载插件使更新生效。`,
              `Installed on disk: v${installedVersion}, still running: v${runtimeVersion}. Reload the plugin to apply the update.`
            ),
            8e3
          );
        } else {
          new import_obsidian4.Notice(this.t(`当前已是最新版本 v${installedVersion}。`, `Already up to date: v${installedVersion}.`));
        }
      }
      return;
    }
    if (showNotice) {
      new import_obsidian4.Notice(this.t(`发现新版本 v${remoteVersion}，正在下载更新...`, `New version v${remoteVersion} found, downloading update...`));
    }
    await this.performUpdate(release);
  }
  async performUpdate(release) {
    const requiredFiles = ["main.js", "manifest.json", "styles.css"];
    const assetMap = /* @__PURE__ */ new Map();
    for (const asset of release.assets) {
      if (requiredFiles.includes(asset.name)) {
        assetMap.set(asset.name, asset);
      }
    }
    if (assetMap.size < requiredFiles.length) {
      new import_obsidian4.Notice(this.t("更新失败：Release 缺少必要文件。", "Update failed: Release is missing required files."));
      return;
    }
    const pluginDir = this.getPluginInstallDir();
    const fs = require("fs");
    const path = require("path");
    const downloaded = [];
    try {
      for (const fileName of requiredFiles) {
        const asset = assetMap.get(fileName);
        if (!asset) continue;
        const resp = await this.requestUrl({ url: asset.downloadUrl, method: "GET" });
        if (resp.status !== 200) {
          throw new Error(`Download ${fileName} returned status ${resp.status}`);
        }
        const tmpPath = path.join(pluginDir, fileName + ".tmp");
        fs.writeFileSync(tmpPath, Buffer.from(resp.arrayBuffer));
        downloaded.push({ tmpPath, fileName });
      }
      for (const { tmpPath, fileName } of downloaded) {
        const finalPath = path.join(pluginDir, fileName);
        fs.renameSync(tmpPath, finalPath);
      }
      const remoteVersion = release.tagName.replace(/^v/, "");
      new import_obsidian4.Notice(
        this.t(
          `磁盘版本已更新到 v${remoteVersion}。当前运行仍可能是旧版本，请重新加载插件或重启 Obsidian。`,
          `Installed version updated to v${remoteVersion}. The running plugin may still be older; reload the plugin or restart Obsidian.`
        ),
        1e4
      );
    } catch (e) {
      for (const { tmpPath } of downloaded) {
        try { fs.unlinkSync(tmpPath); } catch {}
      }
      new import_obsidian4.Notice(
        this.t(`更新失败：${e.message}`, `Update failed: ${e.message}`),
        1e4
      );
    }
  }
  async runAutoSyncTick() {
    if (this.autoSyncTickInProgress) {
      return;
    }
    this.autoSyncTickInProgress = true;
    try {
      await this.syncVaultContent("auto");
    } catch (error) {
      console.error("Auto sync tick failed", error);
    } finally {
      this.autoSyncTickInProgress = false;
    }
  }
  async savePluginState() {
    await this.saveData({
      settings: this.settings,
      queue: this.queue,
      pendingVaultSyncPaths: [...this.pendingVaultSyncPaths],
      pendingVaultRenamePaths: Object.fromEntries(this.pendingVaultRenamePaths.entries()),
      syncIndex: Object.fromEntries(this.syncIndex.entries()),
      syncedDirectories: [...this.syncedDirectories],
      lastVaultSyncAt: this.lastVaultSyncAt,
      lastVaultSyncStatus: this.lastVaultSyncStatus,
      clientId: this.clientId,
      lastAutoUpdateCheckAt: this.lastAutoUpdateCheckAt
    });
  }
  async saveSettings() {
    this.normalizeEffectiveSettings();
    await this.savePluginState();
    this.restartBackgroundSchedulers();
  }
  getVaultBasePath() {
    try {
      return this.app.vault.adapter.basePath;
    } catch {
      return this.app.vault.getRoot().vault.adapter.basePath;
    }
  }
  computeLocalControlRoot() {
    if (this.localControlRoot) {
      return this.localControlRoot;
    }
    const crypto = require("crypto");
    const path = require("path");
    const os = require("os");
    const vaultBasePath = this.getVaultBasePath() || this.app?.vault?.getName?.() || "default-vault";
    const vaultKey = crypto.createHash("sha1").update(vaultBasePath).digest("hex").slice(0, 16);
    this.localControlRoot = path.join(os.homedir(), ".secure-webdav-images", vaultKey);
    return this.localControlRoot;
  }
  getLocalControlFilePath(name) {
    const path = require("path");
    return path.join(this.computeLocalControlRoot(), name);
  }
  async ensureLocalControlReady() {
    const fs = require("fs/promises");
    const path = require("path");
    const root = this.computeLocalControlRoot();
    await fs.mkdir(root, { recursive: true });
    await fs.mkdir(path.join(root, "versions"), { recursive: true });
  }
  generateLocalDeviceClientId() {
    let hostname = "unknown";
    try {
      const os = require("os");
      hostname = os.hostname().toLowerCase().replace(/[^a-z0-9-]/g, "-");
    } catch {
    }
    const crypto = require("crypto");
    const randomSuffix = crypto.randomBytes(4).toString("hex");
    return `${hostname}-${randomSuffix}-kim`;
  }
  async loadLocalDeviceState() {
    if (this.localDeviceStateLoaded) {
      return;
    }
    const fs = require("fs/promises");
    const deviceStatePath = this.getLocalControlFilePath("device-state.json");
    let raw = null;
    try {
      raw = JSON.parse(await fs.readFile(deviceStatePath, "utf8"));
    } catch {
      raw = null;
    }
    const clientId = typeof raw?.clientId === "string" && raw.clientId.length > 0 ? raw.clientId : this.generateLocalDeviceClientId();
    this.clientId = clientId;
    this.localDeviceStateLoaded = true;
    await this.saveLocalDeviceState();
  }
  async saveLocalDeviceState() {
    if (!this.localDeviceStateLoaded) {
      return;
    }
    const fs = require("fs/promises");
    const payload = {
      clientId: this.clientId,

    };
    await fs.writeFile(this.getLocalControlFilePath("device-state.json"), JSON.stringify(payload, null, 2), "utf8");
  }
  buildSuppressedVaultEventKey(kind, path) {
    return `${kind}:${(0, import_obsidian4.normalizePath)(path)}`;
  }
  suppressVaultEvent(kind, path, ttlMs = 8e3) {
    this.suppressedVaultEventPaths.set(this.buildSuppressedVaultEventKey(kind, path), Date.now() + ttlMs);
  }
  consumeSuppressedVaultEvent(kind, path) {
    const key = this.buildSuppressedVaultEventKey(kind, path);
    const expiresAt = this.suppressedVaultEventPaths.get(key);
    if (!expiresAt) {
      return false;
    }
    if (expiresAt < Date.now()) {
      this.suppressedVaultEventPaths.delete(key);
      return false;
    }
    this.suppressedVaultEventPaths.delete(key);
    return true;
  }
  normalizeSyncIndexEntry(vaultPath, rawEntry) {
    if (!rawEntry || typeof rawEntry !== "object") {
      return null;
    }
    const candidate = rawEntry;
    const remotePath = typeof candidate.remotePath === "string" && candidate.remotePath.length > 0 ? candidate.remotePath : this.syncSupport.buildVaultSyncRemotePath(vaultPath);
    const localSignature = typeof candidate.localSignature === "string" ? candidate.localSignature : typeof candidate.signature === "string" ? candidate.signature : "";
    const remoteSignature = typeof candidate.remoteSignature === "string" ? candidate.remoteSignature : typeof candidate.signature === "string" ? candidate.signature : "";
    return {
      localSignature,
      remoteSignature,
      remotePath
    };
  }
  t(zh, en) {
    return this.getLanguage() === "zh" ? zh : en;
  }
  getLanguage() {
    if (this.settings.language === "auto") {
      const locale = typeof navigator !== "undefined" ? navigator.language.toLowerCase() : "en";
      return locale.startsWith("zh") ? "zh" : "en";
    }
    return this.settings.language;
  }
  formatLastSyncLabel() {
    if (!this.lastVaultSyncAt) {
      return this.t("\u4E0A\u6B21\u540C\u6B65\uFF1A\u5C1A\u672A\u6267\u884C", "Last sync: not run yet");
    }
    return this.t(
      `\u4E0A\u6B21\u540C\u6B65\uFF1A${new Date(this.lastVaultSyncAt).toLocaleString()}`,
      `Last sync: ${new Date(this.lastVaultSyncAt).toLocaleString()}`
    );
  }
  formatSyncStatusLabel() {
    return this.lastVaultSyncStatus ? this.t(`\u6700\u8FD1\u72B6\u6001\uFF1A${this.lastVaultSyncStatus}`, `Recent status: ${this.lastVaultSyncStatus}`) : this.t("\u6700\u8FD1\u72B6\u6001\uFF1A\u6682\u65E0", "Recent status: none");
  }
  async runSync() {
    await this.syncVaultContent("manual");
  }

  // ── v2.0.0 unified incremental sync ──

  async syncVaultContent(triggerSource = "manual") {
    if (this.syncInProgress) {
      if (triggerSource === "manual") {
        new import_obsidian4.Notice(this.t("同步正在进行中。", "A sync is already in progress."), 4e3);
      }
      return;
    }
    this.syncInProgress = true;
    try {
      this.ensureConfigured();
      await this.waitForPendingVaultMutations();
      const uploadsReady = await this.preparePendingUploadsForSync(triggerSource === "manual");
      if (!uploadsReady) {
        return;
      }      await this.rebuildReferenceIndex();
      const counts = {
        uploaded: 0,
        downloaded: 0,
        skipped: 0,
        deletedLocal: 0,
        deletedRemote: 0,
        conflicts: 0,
        deletedRemoteDirectories: 0,
        createdRemoteDirectories: 0,
        deletedLocalDirectories: 0,
        createdLocalDirectories: 0
      };
      // Process pending renames first. Deletions are resolved by the
      // three-way comparison below, matching the Remotely Save V3 model.
      const preflightCounts = { uploaded: 0, deletedRemoteFiles: 0, skipped: 0 };
      await this.processPendingVaultRenames(preflightCounts);
      counts.uploaded += preflightCounts.uploaded;
      counts.deletedRemote += preflightCounts.deletedRemoteFiles;
      // Three-way collection + decision matrix
      const decisions = await this.collectEntities(counts);
      await this.executeDecisions(decisions, counts);
      // Update prevSyncRecords in localforage
      await this.persistPrevSyncRecords(decisions);
      // Directory reconciliation
      const remoteInventory = await this.listRemoteTree(this.settings.vaultSyncRemoteFolder);
      const dirStats = await this.reconcileDirectories(remoteInventory.directories);
      counts.deletedRemoteDirectories = dirStats.deletedRemote;
      counts.createdRemoteDirectories = dirStats.createdRemote;
      counts.deletedLocalDirectories = dirStats.deletedLocal;
      counts.createdLocalDirectories = dirStats.createdLocal;
      this.pendingVaultSyncPaths.clear();
      this.pendingVaultDeletionPaths.clear();
      this.lastVaultSyncAt = Date.now();
      const totalDeletedRemote = counts.deletedRemote + counts.deletedRemoteDirectories;
      const totalDeletedLocal = counts.deletedLocal + counts.deletedLocalDirectories;
      this.lastVaultSyncStatus = this.t(
        `同步完成：上传 ${counts.uploaded} 个，下载 ${counts.downloaded} 个，跳过 ${counts.skipped} 个，删除远端 ${totalDeletedRemote} 个、本地 ${totalDeletedLocal} 个，冲突 ${counts.conflicts} 个。`,
        `Sync done: uploaded ${counts.uploaded}, downloaded ${counts.downloaded}, skipped ${counts.skipped}, deleted ${totalDeletedRemote} remote and ${totalDeletedLocal} local, ${counts.conflicts} conflict(s).`
      );
      await this.saveLocalDeviceState();      await this.savePluginState();
      if (triggerSource === "manual") {
        new import_obsidian4.Notice(this.lastVaultSyncStatus, 8e3);
      }
    } catch (error) {
      console.error("Vault content sync failed", error);
      this.lastVaultSyncAt = Date.now();
      this.lastVaultSyncStatus = this.describeError(this.t("内容同步失败", "Content sync failed"), error);      await this.savePluginState();
      if (triggerSource === "manual") {
        new import_obsidian4.Notice(this.lastVaultSyncStatus, 8e3);
      }
    } finally {
      this.syncInProgress = false;
    }
  }

  // Build local file Entity map
  async buildLocalEntityMap() {
    const map = new Map();
    const files = this.syncSupport.collectVaultContentFiles();
    for (const file of files) {
      const sig = await this.buildCurrentLocalSignature(file, void 0);
      const parts = sig.split(":");
      const hash = parts.length >= 3 ? parts[2] : "";
      map.set(file.path, new SyncEntity({
        key: file.path,
        mtimeCli: file.stat.mtime,
        size: file.stat.size,
        hash,
        remotePath: this.syncSupport.buildVaultSyncRemotePath(file.path)
      }));
    }
    return map;
  }

  // Build remote file Entity map from PROPFIND
  async buildRemoteEntityMap() {
    const map = new Map();
    const vaultPrefix = this.normalizeFolder(this.settings.vaultSyncRemoteFolder);
    const { files } = await this.listRemoteTree(this.settings.vaultSyncRemoteFolder);
    for (const [remotePath, remote] of files.entries()) {
      const vaultPath = this.remotePathToVaultPath(remotePath, vaultPrefix);
      if (!vaultPath) continue;
      if (this.syncSupport.shouldSkipContentSyncPath(vaultPath)) continue;
      map.set(vaultPath, new SyncEntity({
        key: vaultPath,
        mtimeCli: remote.lastModified,  // server mtime, used in signature() for comparison
        mtimeSvr: remote.lastModified,
        size: remote.size,
        hash: "",
        remotePath,
        syncTime: 0
      }));
    }
    return map;
  }

  remotePathToVaultPath(remotePath, vaultPrefix) {
    if (!remotePath.startsWith(vaultPrefix)) return null;
    return remotePath.slice(vaultPrefix.length);
  }

  // Three-way collection: local + remote + prevSync → MixedEntity decisions
  async collectEntities(counts) {
    const localMap = await this.buildLocalEntityMap();
    const remoteMap = await this.buildRemoteEntityMap();
    let rawPrevSync = await this.localDB.getAllPrevSyncRecords();

    // v2.0.0 migration: seed prevSyncRecords from old syncIndex if localDB is empty.
    // Only runs once per plugin session.
    if (rawPrevSync.size === 0 && this.syncIndex.size > 0 && !this._v2PrevSyncMigrationDone) {
      this._v2PrevSyncMigrationDone = true;
      for (const [path, entry] of this.syncIndex.entries()) {
        const localState = localMap.get(path) || null;
        const remoteState = remoteMap.get(path) || null;
        const parsedLocal = parseStoredSyncSignature(entry.localSignature);
        const parsedRemote = parseStoredSyncSignature(entry.remoteSignature);
        const resolvedMtimeCli = parsedLocal.valid ? parsedLocal.mtime : localState?.mtimeCli || parsedRemote.mtime || remoteState?.mtimeSvr || remoteState?.mtimeCli || 0;
        const resolvedMtimeSvr = parsedRemote.valid ? parsedRemote.mtime : remoteState?.mtimeSvr || remoteState?.mtimeCli || 0;
        const resolvedSize = parsedLocal.valid ? parsedLocal.size : parsedRemote.valid ? parsedRemote.size : localState?.size || remoteState?.size || 0;
        const resolvedHash = parsedLocal.valid && parsedLocal.hash ? parsedLocal.hash : localState?.hash || "";
        const entity = new SyncEntity({
          key: path,
          mtimeCli: resolvedMtimeCli,
          mtimeSvr: resolvedMtimeSvr,
          size: resolvedSize,
          hash: resolvedHash,
          remotePath: entry.remotePath || remoteState?.remotePath || this.syncSupport.buildVaultSyncRemotePath(path),
          syncTime: Date.now()
        });
        await this.localDB.setPrevSyncRecord(path, entity);
      }
      rawPrevSync = await this.localDB.getAllPrevSyncRecords();
    }

    // Rehydrate plain objects back into SyncEntity instances (localforage/IndexedDB
    // serializes to JSON so methods like signature() are lost on the round trip).
    const prevSyncMap = new Map();
    for (const [key, entry] of rawPrevSync.entries()) {
      prevSyncMap.set(key, new SyncEntity(entry));
    }

    // Build content index for dedup
    const localContentIndex = new Map();
    for (const [path, entity] of localMap.entries()) {
      if (entity.hash) {
        if (!localContentIndex.has(entity.hash)) {
          localContentIndex.set(entity.hash, new Set());
        }
        localContentIndex.get(entity.hash).add(path);
      }
    }

    const allKeys = new Set([
      ...localMap.keys(),
      ...remoteMap.keys(),
      ...prevSyncMap.keys()
    ]);

    const decisions = new Map();
    for (const key of allKeys) {
      const mixed = new MixedEntity(key);
      mixed.local = localMap.get(key) || null;
      mixed.remote = remoteMap.get(key) || null;
      mixed.prevSync = prevSyncMap.get(key) || null;
      computeDecision(mixed, localContentIndex);
      decisions.set(key, mixed);
      // Track counts
      if (mixed.decision === "skip") counts.skipped++;
    }
    return decisions;
  }

  // Execute decisions in priority order
  async executeDecisions(decisions, counts) {
    const byDecision = { deleteLocal: [], deleteRemote: [], pull: [], push: [], conflict: [], skip: [], cleanHistory: [] };
    for (const [key, mixed] of decisions.entries()) {
      (byDecision[mixed.decision] || byDecision.skip).push(mixed);
    }

    // Phase 1: deleteLocal
    for (const mixed of byDecision.deleteLocal) {
      try {
        const file = this.getVaultFileByPath(mixed.key);
        if (file instanceof import_obsidian4.TFile) {
          await this.removeLocalVaultFile(file);
          counts.deletedLocal++;
        }
      } catch (e) {
        console.error(`deleteLocal failed for ${mixed.key}:`, e);
      }
    }

    // Phase 2: deleteRemote
    for (const mixed of byDecision.deleteRemote) {
      const remotePath = mixed.remote?.remotePath || mixed.prevSync?.remotePath || this.syncSupport.buildVaultSyncRemotePath(mixed.key);
      try {
        await this.deleteRemoteContentFile(remotePath);
        counts.deletedRemote++;
      } catch (e) {
        console.error(`deleteRemote failed for ${mixed.key}:`, e);
      }
    }

    // Phase 3: pull (download from remote)
    for (const mixed of byDecision.pull) {
      if (!mixed.remote?.remotePath) continue;
      try {
        const existingFile = this.getVaultFileByPath(mixed.key);
        await this.downloadRemoteFileToVault(mixed.key, mixed.remote, existingFile);
        counts.downloaded++;
      } catch (e) {
        console.error(`pull failed for ${mixed.key}:`, e);
      }
    }

    // Phase 4: push (upload to remote)
    for (const mixed of byDecision.push) {
      const file = this.getVaultFileByPath(mixed.key);
      if (!(file instanceof import_obsidian4.TFile)) continue;
      const remotePath = this.syncSupport.buildVaultSyncRemotePath(mixed.key);
      try {
        const uploaded = await this.uploadContentFileToRemote(file, remotePath);
        // Stash the server-confirmed remote state so persistPrevSyncRecords can
        // store an entity that's comparable with future PROPFIND listings.
        mixed._uploadedRemote = uploaded;
        counts.uploaded++;
      } catch (e) {
        console.error(`push failed for ${mixed.key}:`, e);
      }
    }

    // Phase 5: conflict
    for (const mixed of byDecision.conflict) {
      try {
        const localFile = this.getVaultFileByPath(mixed.key);
        if (localFile instanceof import_obsidian4.TFile) {
          await this.createLocalConflictCopy(localFile, null, "sync");
          counts.conflicts++;
        }
      } catch (e) {
        console.error(`conflict copy failed for ${mixed.key}:`, e);
      }
    }

    // cleanHistory: nothing to do
  }

  // Persist current state as new prevSyncRecords
  async persistPrevSyncRecords(decisions) {
    for (const [key, mixed] of decisions.entries()) {
      if (mixed.decision === "cleanHistory") {
        await this.localDB.deletePrevSyncRecord(key);
        this.syncIndex.delete(key);
        continue;
      }
      // Keep prevSync for deleteLocal/deleteRemote so the next sync can
      // detect the deletion via three-way comparison (remotely-save V3 model).
      // Only cleanHistory (both sides gone) removes the record.
      if (mixed.decision === "deleteLocal" || mixed.decision === "deleteRemote") {
        this.syncIndex.delete(key);
        continue;
      }
      // Store the "winner" state.
      // For push: use the server-confirmed remote state so future
      // classifyRemoteState comparisons (which compare mtime:size against
      // PROPFIND listings) match correctly.
      let entity;
      if (mixed.decision === "push" && mixed._uploadedRemote) {
        const ur = mixed._uploadedRemote;
        entity = new SyncEntity({
          key,
          mtimeCli: mixed.local ? mixed.local.mtimeCli : (ur.lastModified ?? 0),
          mtimeSvr: ur.lastModified ?? 0,
          size: mixed.local ? mixed.local.size : (ur.size ?? 0),
          hash: mixed.local ? mixed.local.hash : "",
          remotePath: ur.remotePath ?? this.syncSupport.buildVaultSyncRemotePath(key),
          syncTime: Date.now()
        });
      } else if (mixed.decision === "pull" && mixed.remote) {
        // For pull: use the remote entity so it's comparable with future PROPFIND.
        entity = new SyncEntity({
          key,
          mtimeCli: mixed.remote.mtimeSvr || mixed.remote.mtimeCli || 0,
          mtimeSvr: mixed.remote.mtimeSvr || 0,
          size: mixed.remote.size ?? 0,
          hash: "",
          remotePath: mixed.remote.remotePath ?? "",
          syncTime: Date.now()
        });
      } else {
        entity = mixed.local || mixed.remote;
      }
      // Preserve server mtime from prevSync so classifyRemoteState
      // can compare using the correct server-side timestamp next sync.
      if (entity && !entity.mtimeSvr && mixed.prevSync && mixed.prevSync.mtimeSvr) {
        entity = new SyncEntity({
          key: entity.key,
          mtimeCli: entity.mtimeCli,
          mtimeSvr: mixed.prevSync.mtimeSvr,
          size: entity.size,
          hash: entity.hash || "",
          remotePath: entity.remotePath || "",
          syncTime: Date.now()
        });
      }
      if (entity) {
        entity.syncTime = Date.now();
        await this.localDB.setPrevSyncRecord(key, entity);
        const remoteLastModified = entity.mtimeSvr || mixed.prevSync?.mtimeSvr || entity.mtimeCli || 0;
        // Backward-compat: also update syncIndex
        this.syncIndex.set(key, {
          localSignature: entity.signature(),
          remoteSignature: this.syncSupport.buildRemoteSyncSignature({
            lastModified: remoteLastModified,
            size: entity.size
          }),
          remotePath: entity.remotePath
        });
      }
    }
  }

  async rebuildReferenceIndex() {
    const next = /* @__PURE__ */ new Map();
    for (const file of this.app.vault.getMarkdownFiles()) {
      const content = await this.app.vault.read(file);
      next.set(file.path, this.extractRemotePathsFromText(content));
    }
    this.noteRemoteRefs = next;
  }
  async handleVaultModify(file) {
    if (!(file instanceof import_obsidian4.TFile)) {
      return;
    }
    if (this.consumeSuppressedVaultEvent("modify", file.path)) {
      return;
    }
    this.markPendingVaultSync(file.path);
    const isCreate = !this.syncIndex.has(file.path);
    const indexed = this.syncIndex.get(file.path);
    this.appendRecentMutation({
      kind: isCreate ? "create" : "modify",
      path: file.path,
      localSignature: indexed?.localSignature,
      remotePath: indexed?.remotePath,
      remoteSignature: indexed?.remoteSignature
    });
    if (file.extension === "md") {
      const content = await this.app.vault.read(file);
      const nextRefs = this.extractRemotePathsFromText(content);
      const previousRefs = this.noteRemoteRefs.get(file.path) ?? /* @__PURE__ */ new Set();
      this.noteRemoteRefs.set(file.path, nextRefs);
      const added = [...nextRefs].filter((value) => !previousRefs.has(value));
      const removed = [...previousRefs].filter((value) => !nextRefs.has(value));
      if (added.length > 0) {
      }
      if (removed.length > 0) {
      }
    }
    await this.savePluginState();
  }
  async handleVaultDelete(file) {
    if (!(file instanceof import_obsidian4.TFile)) {
      return;
    }
    if (this.consumeSuppressedVaultEvent("delete", file.path)) {
      return;
    }
    if (!this.syncSupport.shouldSkipContentSyncPath(file.path)) {      const indexed = this.syncIndex.get(file.path);
      this.appendRecentMutation({
        kind: "delete",
        path: file.path,
        remotePath: indexed?.remotePath,
        remoteSignature: indexed?.remoteSignature
      });
      this.markPendingVaultDeletion(file.path, file.stat?.ctime);
      this.syncIndex.delete(file.path);
      await this.savePluginState();
    }
    if (file.extension === "md") {
      this.noteRemoteRefs.delete(file.path);
    }
  }
  async handleVaultRename(file, oldPath) {
    if (!(file instanceof import_obsidian4.TFile)) {
      return;
    }
    if (this.consumeSuppressedVaultEvent("rename", oldPath) || this.consumeSuppressedVaultEvent("rename", file.path)) {
      return;
    }
    if (!this.syncSupport.shouldSkipContentSyncPath(oldPath)) {
      const indexed = this.syncIndex.get(oldPath);
      const trackedOldPath = this.recordPendingVaultRename(oldPath, file.path);
      this.markPendingVaultDeletion(oldPath);
      // Keep syncIndex entry for oldPath so three-way comparison can
      // detect LOCAL_DELETED and properly handle the rename (remotely-save V3).
      this.appendRecentMutation({
        kind: "rename",
        path: oldPath,
        oldPath,
        newPath: file.path,
        remotePath: indexed?.remotePath,
        remoteSignature: indexed?.remoteSignature
      });
      await this.savePluginState();
    }
    if (!this.syncSupport.shouldSkipContentSyncPath(file.path)) {
      this.markPendingVaultSync(file.path);
      await this.savePluginState();
    }
    if (file.extension === "md") {
      const refs = this.noteRemoteRefs.get(oldPath);
      if (refs) {
        this.noteRemoteRefs.delete(oldPath);
        this.noteRemoteRefs.set(file.path, refs);
      }
      if (!this.syncSupport.shouldSkipContentSyncPath(file.path)) {
      }
    }
  }
  markPendingVaultSync(path) {
    if (this.syncSupport.shouldSkipContentSyncPath(path)) {
      this.pendingVaultSyncPaths.delete(path);
      return;
    }
    this.pendingVaultSyncPaths.add(path);
  }
  markPendingVaultDeletion(path, creationTime) {
    if (this.syncSupport.shouldSkipContentSyncPath(path)) {
      this.pendingVaultSyncPaths.delete(path);
      this.pendingVaultDeletionPaths.delete(path);
      return;
    }
    const existing = this.syncIndex.get(path);
    this.pendingVaultSyncPaths.delete(path);
    this.pendingVaultDeletionPaths.set(path, {
      remotePath: existing?.remotePath ?? this.syncSupport.buildVaultSyncRemotePath(path),
      remoteSignature: existing?.remoteSignature,
      creationTime: creationTime || 0,
      recordedAt: Date.now()
    });
  }
  findPendingVaultRenameByNewPath(newPath) {
    return [...this.pendingVaultRenamePaths.values()].find((entry) => entry.newPath === newPath) ?? null;
  }
  recordPendingVaultRename(oldPath, newPath) {
    const normalizedOldPath = (0, import_obsidian4.normalizePath)(oldPath);
    const normalizedNewPath = (0, import_obsidian4.normalizePath)(newPath);
    const existing = this.findPendingVaultRenameByNewPath(normalizedOldPath);
    const previous = existing ?? this.pendingVaultRenamePaths.get(normalizedOldPath) ?? null;
    if (existing) {
      this.pendingVaultRenamePaths.delete(existing.oldPath);
    }
    const indexed = this.syncIndex.get(normalizedOldPath);
    const trackedOldPath = previous?.oldPath ?? normalizedOldPath;
    const oldRemotePath = previous?.oldRemotePath ?? indexed?.remotePath ?? this.syncSupport.buildVaultSyncRemotePath(normalizedOldPath);
    const oldRemoteSignature = previous?.oldRemoteSignature ?? indexed?.remoteSignature;
    const recordedAt = previous?.recordedAt ?? Date.now();
    this.pendingVaultRenamePaths.set(trackedOldPath, {
      oldPath: trackedOldPath,
      newPath: normalizedNewPath,
      oldRemotePath,
      oldRemoteSignature,
      recordedAt
    });
    return trackedOldPath;
  }
  appendRecentMutation(entry) {
    // No-op: recentVaultMutations removed — three-way comparison handles everything
  }
  extractRemotePathsFromText(content) {
    const refs = /* @__PURE__ */ new Set();
    const spanRegex = /data-secure-webdav="([^"]+)"/g;
    const protocolRegex = /webdav-secure:\/\/([^\s)"]+)/g;
    const codeBlockRegex = /```secure-webdav\s+([\s\S]*?)```/g;
    let match;
    while ((match = spanRegex.exec(content)) !== null) {
      refs.add(this.unescapeHtml(match[1]));
    }
    while ((match = protocolRegex.exec(content)) !== null) {
      refs.add(this.unescapeHtml(match[1]));
    }
    while ((match = codeBlockRegex.exec(content)) !== null) {
      const parsed = this.imageSupport.parseSecureImageBlock(match[1]);
      if (parsed?.path) {
        refs.add(parsed.path);
      }
    }
    return refs;
  }
  schedulePriorityNoteSync(notePath, reason) {
    this.markPendingVaultSync(notePath);
  }
  async flushPriorityRenameSync(oldPath) {
    return;
  }
  async buildUploadReplacements(content, noteFile, uploadCache) {
    const seen = /* @__PURE__ */ new Map();
    const wikiMatches = [...content.matchAll(/!\[\[([^\]]+)\]\]/g)];
    const markdownMatches = [...content.matchAll(/!\[[^\]]*]\(([^)]+)\)/g)];
    const htmlImageMatches = [...content.matchAll(/<img\b[^>]*src=["']([^"']+)["'][^>]*>/gi)];
    for (const match of wikiMatches) {
      const rawLink = match[1].split("|")[0].trim();
      const file = this.resolveLinkedFile(rawLink, noteFile.path);
      if (!file || !this.isImageFile(file)) {
        continue;
      }
      if (!seen.has(match[0])) {
        const remoteUrl = await this.uploadVaultFile(file, uploadCache);
        seen.set(match[0], {
          original: match[0],
          rewritten: this.imageSupport.buildSecureImageMarkup(remoteUrl, file.basename),
          sourceFile: file
        });
      }
    }
    for (const match of markdownMatches) {
      const rawLink = decodeURIComponent(match[1].trim().replace(/^<|>$/g, ""));
      if (/^(webdav-secure:|data:)/i.test(rawLink)) {
        continue;
      }
      if (this.isHttpUrl(rawLink)) {
        if (!seen.has(match[0])) {
          try {
            const remoteUrl = await this.uploadRemoteImageUrl(rawLink, uploadCache);
            const altText = this.extractMarkdownAltText(match[0]) || this.getDisplayNameFromUrl(rawLink);
            seen.set(match[0], {
              original: match[0],
              rewritten: this.imageSupport.buildSecureImageMarkup(remoteUrl, altText)
            });
          } catch (e) {
            console.warn(`[secure-webdav-images] \u8DF3\u8FC7\u5931\u8D25\u7684\u8FDC\u7A0B\u56FE\u7247 ${rawLink}`, e?.message);
          }
        }
        continue;
      }
      const file = this.resolveLinkedFile(rawLink, noteFile.path);
      if (!file || !this.isImageFile(file)) {
        continue;
      }
      if (!seen.has(match[0])) {
        const remoteUrl = await this.uploadVaultFile(file, uploadCache);
        seen.set(match[0], {
          original: match[0],
          rewritten: this.imageSupport.buildSecureImageMarkup(remoteUrl, file.basename),
          sourceFile: file
        });
      }
    }
    for (const match of htmlImageMatches) {
      const rawLink = this.unescapeHtml(match[1].trim());
      if (!this.isHttpUrl(rawLink) || seen.has(match[0])) {
        continue;
      }
      try {
        const remoteUrl = await this.uploadRemoteImageUrl(rawLink, uploadCache);
        const altText = this.extractHtmlImageAltText(match[0]) || this.getDisplayNameFromUrl(rawLink);
        seen.set(match[0], {
          original: match[0],
          rewritten: this.imageSupport.buildSecureImageMarkup(remoteUrl, altText)
        });
      } catch (e) {
        console.warn(`[secure-webdav-images] \u8DF3\u8FC7\u5931\u8D25\u7684\u8FDC\u7A0B\u56FE\u7247 ${rawLink}`, e?.message);
      }
    }
    return [...seen.values()];
  }
  extractMarkdownAltText(markdownImage) {
    const match = markdownImage.match(/^!\[([^\]]*)\]/);
    return match?.[1]?.trim() ?? "";
  }
  extractHtmlImageAltText(htmlImage) {
    const match = htmlImage.match(/\balt=["']([^"']*)["']/i);
    return match ? this.unescapeHtml(match[1].trim()) : "";
  }
  isHttpUrl(value) {
    return /^https?:\/\//i.test(value);
  }
  getDisplayNameFromUrl(rawUrl) {
    try {
      const url = new URL(rawUrl);
      const fileName = this.sanitizeFileName(url.pathname.split("/").pop() || "");
      if (fileName) {
        return fileName.replace(/\.[^.]+$/, "");
      }
    } catch {
    }
    return this.t("\u7F51\u9875\u56FE\u7247", "Web image");
  }
  resolveLinkedFile(link, sourcePath) {
    const cleaned = link.replace(/#.*/, "").trim();
    const target = this.app.metadataCache.getFirstLinkpathDest(cleaned, sourcePath);
    return target instanceof import_obsidian4.TFile ? target : null;
  }
  isImageFile(file) {
    return /^(png|jpe?g|gif|webp|bmp|svg)$/i.test(file.extension);
  }
  async uploadVaultFile(file, uploadCache) {
    if (uploadCache?.has(file.path)) {
      return uploadCache.get(file.path);
    }
    this.ensureConfigured();
    const binary = await this.app.vault.readBinary(file);
    const prepared = await this.prepareUploadPayload(binary, this.getMimeType(file.extension), file.name);
    const remoteName = await this.buildRemoteFileNameFromBinary(prepared.fileName, prepared.binary);
    const remotePath = this.buildRemotePath(remoteName);
    await this.uploadBinary(remotePath, prepared.binary, prepared.mimeType);
    const remoteUrl = `${SECURE_PROTOCOL}//${remotePath}`;
    uploadCache?.set(file.path, remoteUrl);
    return remoteUrl;
  }
  async uploadRemoteImageUrl(imageUrl, uploadCache) {
    const cacheKey = `remote:${imageUrl}`;
    if (uploadCache?.has(cacheKey)) {
      return uploadCache.get(cacheKey);
    }
    this.ensureConfigured();
    const response = await this.requestUrl({
      url: imageUrl,
      method: "GET",
      followRedirects: true
    });
    this.assertResponseSuccess(response, "Remote image download");
    const contentType = response.headers["content-type"] ?? "";
    if (!this.isImageContentType(contentType) && !this.looksLikeImageUrl(imageUrl)) {
      throw new Error(this.t("\u8FDC\u7A0B\u94FE\u63A5\u4E0D\u662F\u53EF\u8BC6\u522B\u7684\u56FE\u7247\u8D44\u6E90\u3002", "The remote URL does not look like an image resource."));
    }
    const fileName = this.buildRemoteSourceFileName(imageUrl, contentType);
    const prepared = await this.prepareUploadPayload(
      response.arrayBuffer,
      this.normalizeImageMimeType(contentType, fileName),
      fileName
    );
    const remoteName = await this.buildRemoteFileNameFromBinary(prepared.fileName, prepared.binary);
    const remotePath = this.buildRemotePath(remoteName);
    await this.uploadBinary(remotePath, prepared.binary, prepared.mimeType);
    const remoteUrl = `${SECURE_PROTOCOL}//${remotePath}`;
    uploadCache?.set(cacheKey, remoteUrl);
    return remoteUrl;
  }
  isImageContentType(contentType) {
    return /^image\//i.test(contentType.trim());
  }
  looksLikeImageUrl(rawUrl) {
    try {
      const url = new URL(rawUrl);
      return /\.(png|jpe?g|gif|webp|bmp|svg)$/i.test(url.pathname);
    } catch {
      return false;
    }
  }
  buildRemoteSourceFileName(rawUrl, contentType) {
    try {
      const url = new URL(rawUrl);
      const candidate = this.sanitizeFileName(url.pathname.split("/").pop() || "");
      if (candidate && /\.[a-z0-9]+$/i.test(candidate)) {
        return candidate;
      }
      const extension = this.getExtensionFromMimeType(contentType) || "png";
      return candidate ? `${candidate}.${extension}` : `remote-image.${extension}`;
    } catch {
      const extension = this.getExtensionFromMimeType(contentType) || "png";
      return `remote-image.${extension}`;
    }
  }
  sanitizeFileName(fileName) {
    return fileName.replace(/[\\/:*?"<>|]+/g, "-").trim();
  }
  getExtensionFromMimeType(contentType) {
    const mimeType = contentType.split(";")[0].trim().toLowerCase();
    return MIME_MAP[mimeType] ?? "";
  }
  normalizeImageMimeType(contentType, fileName) {
    const mimeType = contentType.split(";")[0].trim().toLowerCase();
    if (mimeType && mimeType !== "application/octet-stream") {
      return mimeType;
    }
    return this.getMimeTypeFromFileName(fileName);
  }
  async uploadBinary(remotePath, binary, mimeType) {
    await this.ensureRemoteDirectories(remotePath);
    const url = this.buildUploadUrl(remotePath);
    const response = await this.requestUrl({
      url,
      method: "PUT",
      headers: {
        Authorization: this.buildAuthHeader(),
        "Content-Type": mimeType
      },
      body: binary
    });
    if (response.status < 200 || response.status >= 300) {
      throw new Error(`Upload failed with status ${response.status} for ${remotePath}`);
    }
  }
  async handleEditorPaste(evt, editor, info) {
    if (evt.defaultPrevented || !info.file) {
      return;
    }
    const imageFile = this.extractImageFileFromClipboard(evt);
    if (imageFile) {
      evt.preventDefault();
      const fileName = imageFile.name || this.buildClipboardFileName(imageFile.type);
      await this.uploadQueue.enqueueEditorImageUpload(info.file, editor, imageFile, fileName);
      return;
    }
    const html = evt.clipboardData?.getData("text/html")?.trim() ?? "";
    if (!html || !this.htmlContainsRemoteImages(html)) {
      return;
    }
    evt.preventDefault();
    await this.handleHtmlPasteWithRemoteImages(info.file, editor, html);
  }
  async handleEditorDrop(evt, editor, info) {
    if (evt.defaultPrevented || !info.file) {
      return;
    }
    const imageFile = this.extractImageFileFromDrop(evt);
    if (!imageFile) {
      return;
    }
    evt.preventDefault();
    const fileName = imageFile.name || this.buildClipboardFileName(imageFile.type);
    await this.uploadQueue.enqueueEditorImageUpload(info.file, editor, imageFile, fileName);
  }
  extractImageFileFromClipboard(evt) {
    const direct = Array.from(evt.clipboardData?.files ?? []).find((file) => file.type.startsWith("image/"));
    if (direct) {
      return direct;
    }
    const item = Array.from(evt.clipboardData?.items ?? []).find((entry) => entry.type.startsWith("image/"));
    return item?.getAsFile() ?? null;
  }
  htmlContainsRemoteImages(html) {
    return /<img\b[^>]*src=["']https?:\/\/[^"']+["'][^>]*>/i.test(html);
  }
  async handleHtmlPasteWithRemoteImages(noteFile, editor, html) {
    try {
      const rendered = await this.convertHtmlClipboardToSecureMarkdown(html, noteFile);
      if (!rendered.trim()) {
        return;
      }
      editor.replaceSelection(rendered);
      new import_obsidian4.Notice(this.t("\u5DF2\u5C06\u7F51\u9875\u56FE\u6587\u7C98\u8D34\u5E76\u6293\u53D6\u8FDC\u7A0B\u56FE\u7247\u3002", "Pasted web content and captured remote images."));
    } catch (error) {
      console.error("Failed to paste HTML content with remote images", error);
      new import_obsidian4.Notice(
        this.describeError(
          this.t("\u5904\u7406\u7F51\u9875\u56FE\u6587\u7C98\u8D34\u5931\u8D25", "Failed to process pasted web content"),
          error
        ),
        8e3
      );
    }
  }
  async convertHtmlClipboardToSecureMarkdown(html, noteFile) {
    const parser = new DOMParser();
    const document2 = parser.parseFromString(html, "text/html");
    const uploadCache = /* @__PURE__ */ new Map();
    const renderedBlocks = [];
    for (const node of Array.from(document2.body.childNodes)) {
      const block = await this.renderPastedHtmlNode(node, noteFile, uploadCache, 0);
      if (block.trim()) {
        renderedBlocks.push(block.trim());
      }
    }
    return renderedBlocks.join("\n\n") + "\n";
  }
  async renderPastedHtmlNode(node, noteFile, uploadCache, listDepth) {
    if (node.nodeType === Node.TEXT_NODE) {
      return this.normalizeClipboardText(node.textContent ?? "");
    }
    if (!(node instanceof HTMLElement)) {
      return "";
    }
    const tag = node.tagName.toLowerCase();
    if (tag === "img") {
      const src = this.unescapeHtml(node.getAttribute("src")?.trim() ?? "");
      if (!this.isHttpUrl(src)) {
        return "";
      }
      const alt = (node.getAttribute("alt") ?? "").trim() || this.getDisplayNameFromUrl(src);
      const remoteUrl = await this.uploadRemoteImageUrl(src, uploadCache);
      return this.imageSupport.buildSecureImageMarkup(remoteUrl, alt);
    }
    if (tag === "br") {
      return "\n";
    }
    if (tag === "ul" || tag === "ol") {
      const items = [];
      let index = 1;
      for (const child of Array.from(node.children)) {
        if (child.tagName.toLowerCase() !== "li") {
          continue;
        }
        const rendered = (await this.renderPastedHtmlNode(child, noteFile, uploadCache, listDepth + 1)).trim();
        if (!rendered) {
          continue;
        }
        const prefix = tag === "ol" ? `${index}. ` : "- ";
        items.push(`${"  ".repeat(Math.max(0, listDepth))}${prefix}${rendered}`);
        index += 1;
      }
      return items.join("\n");
    }
    if (tag === "li") {
      const parts = await this.renderPastedHtmlChildren(node, noteFile, uploadCache, listDepth);
      return parts.join("").trim();
    }
    if (/^h[1-6]$/.test(tag)) {
      const level = Number.parseInt(tag[1], 10);
      const text = (await this.renderPastedHtmlChildren(node, noteFile, uploadCache, listDepth)).join("").trim();
      return text ? `${"#".repeat(level)} ${text}` : "";
    }
    if (tag === "a") {
      const href = node.getAttribute("href")?.trim() ?? "";
      const text = (await this.renderPastedHtmlChildren(node, noteFile, uploadCache, listDepth)).join("").trim();
      if (href && /^https?:\/\//i.test(href) && text) {
        return `[${text}](${href})`;
      }
      return text;
    }
    const inlineTags = /* @__PURE__ */ new Set(["strong", "b", "em", "i", "span", "code", "small", "sup", "sub"]);
    if (inlineTags.has(tag)) {
      return (await this.renderPastedHtmlChildren(node, noteFile, uploadCache, listDepth)).join("");
    }
    const blockTags = /* @__PURE__ */ new Set([
      "p",
      "div",
      "article",
      "section",
      "figure",
      "figcaption",
      "blockquote",
      "pre",
      "table",
      "thead",
      "tbody",
      "tr",
      "td",
      "th"
    ]);
    if (blockTags.has(tag)) {
      const text = (await this.renderPastedHtmlChildren(node, noteFile, uploadCache, listDepth)).join("").trim();
      return text;
    }
    return (await this.renderPastedHtmlChildren(node, noteFile, uploadCache, listDepth)).join("");
  }
  async renderPastedHtmlChildren(element, noteFile, uploadCache, listDepth) {
    const parts = [];
    for (const child of Array.from(element.childNodes)) {
      const rendered = await this.renderPastedHtmlNode(child, noteFile, uploadCache, listDepth);
      if (!rendered) {
        continue;
      }
      if (parts.length > 0 && !rendered.startsWith("\n") && !parts[parts.length - 1].endsWith("\n")) {
        const previous = parts[parts.length - 1];
        const needsSpace = /\S$/.test(previous) && /^\S/.test(rendered);
        if (needsSpace) {
          parts.push(" ");
        }
      }
      parts.push(rendered);
    }
    return parts;
  }
  normalizeClipboardText(value) {
    return value.replace(/\s+/g, " ");
  }
  extractImageFileFromDrop(evt) {
    return Array.from(evt.dataTransfer?.files ?? []).find((file) => file.type.startsWith("image/")) ?? null;
  }
  async enqueueEditorImageUpload(noteFile, editor, imageFile, fileName) {
    await this.uploadQueue.enqueueEditorImageUpload(noteFile, editor, imageFile, fileName);
  }
  async processPendingVaultRenames(counts, targetOldPaths) {
    const requested = targetOldPaths ? new Set(targetOldPaths.map((path) => (0, import_obsidian4.normalizePath)(path))) : null;
    for (const [oldPath, entry] of [...this.pendingVaultRenamePaths.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
      if (requested && !requested.has(oldPath)) {
        continue;
      }
      if (this.syncSupport.shouldSkipContentSyncPath(oldPath) || this.syncSupport.shouldSkipContentSyncPath(entry.newPath)) {
        this.pendingVaultRenamePaths.delete(oldPath);
        this.pendingVaultDeletionPaths.delete(oldPath);
        counts.skipped += 1;
        continue;
      }
      this.pendingVaultDeletionPaths.delete(oldPath);
      // Old remote path deletion and syncIndex cleanup are deferred to the
      // three-way comparison in collectEntities/executeDecisions, which
      // correctly classifies LOCAL_DELETED and preserves prevSync so the
      // next sync can still detect the deletion (remotely-save V3 model).
      const file = this.getVaultFileByPath(entry.newPath);
      if (!(file instanceof import_obsidian4.TFile)) {
        this.pendingVaultRenamePaths.delete(oldPath);
        counts.skipped += 1;
        continue;
      }
      const remotePath = this.syncSupport.buildVaultSyncRemotePath(file.path);
      // Defer old remote path deletion and new file upload to the three-way
      // comparison in collectEntities/executeDecisions.
      // Old path: LOCAL_DELETED + REMOTE_UNCHANGED → deleteRemote
      // New path: LOCAL_NEW + REMOTE_DELETED → push
      this.pendingVaultSyncPaths.delete(file.path);
      this.pendingVaultRenamePaths.delete(oldPath);
      const recentMutation = this.recentVaultMutations.find((m) => m.kind === "rename" && m.oldPath === oldPath && m.status === "pending");
      if (recentMutation) {
        recentMutation.status = "applied";
        recentMutation.newPath = entry.newPath;
        recentMutation.remotePath = remotePath;
      }
    }
  }
  async processPendingVaultUploads(counts) {
    for (const path of [...this.pendingVaultSyncPaths].sort((a, b) => a.localeCompare(b))) {
      if (this.syncSupport.shouldSkipContentSyncPath(path)) {
        this.pendingVaultSyncPaths.delete(path);
        counts.skipped += 1;
        continue;
      }
      const file = this.getVaultFileByPath(path);
      if (!(file instanceof import_obsidian4.TFile)) {
        this.pendingVaultSyncPaths.delete(path);
        counts.skipped += 1;
        continue;
      }
      const markdownContent = file.extension === "md" ? await this.readMarkdownContentPreferEditor(file) : void 0;
      const remotePath = this.syncSupport.buildVaultSyncRemotePath(file.path);
      const previous = this.syncIndex.get(path);
      const localSignature = await this.buildCurrentLocalSignature(file, markdownContent);
      if (previous && !this.syncSupport.isLegacySignature(previous.localSignature) && previous.localSignature === localSignature && previous.remotePath === remotePath) {
        let remote2;
        try { remote2 = await this.statRemoteFile(remotePath); } catch { remote2 = null; }
        if (remote2 && this.syncSupport.buildRemoteSyncSignature(remote2) === previous.remoteSignature) {
          this.pendingVaultSyncPaths.delete(path);
          counts.skipped += 1;
          continue;
        }
      }
      let remote;
      try { remote = await this.statRemoteFile(remotePath); } catch { remote = null; }
      if (remote && previous && remote.lastModified > Number(previous.remoteSignature?.split(":")[0] || 0)) {
        const localMtime = file.stat.mtime;
        if (remote.lastModified > localMtime) {
          if (previous.localSignature && previous.localSignature !== localSignature) {
            await this.createLocalConflictCopy(file, markdownContent ?? void 0, "local");
            counts.conflicts += 1;
          }
          await this.downloadRemoteFileToVault(path, remote, file);
          const refreshed = this.getVaultFileByPath(path);
          if (refreshed) {
            this.syncIndex.set(path, {
              localSignature: await this.buildCurrentLocalSignature(refreshed),
              remoteSignature: remote.signature,
              remotePath
            });
          }
          this.pendingVaultSyncPaths.delete(path);
          counts.downloadedRemote += 1;          continue;
        }
      }
      let uploadedRemote = null;
      try {
        uploadedRemote = await this.uploadContentFileToRemote(file, remotePath, markdownContent);
        this.syncIndex.set(file.path, {
          localSignature,
          remoteSignature: uploadedRemote.signature,
          remotePath
        });
        this.pendingVaultSyncPaths.delete(path);
        counts.uploaded += 1;
      } catch (uploadError) {
        console.error(`Upload failed for ${path}:`, uploadError);
        counts.skipped += 1;
      }
      const recentMutation = this.recentVaultMutations.find((m) => m.path === path && (m.kind === "create" || m.kind === "modify") && m.status === "pending");
      if (recentMutation && uploadedRemote) {
        recentMutation.status = "applied";
        recentMutation.remotePath = remotePath;
        recentMutation.remoteSignature = uploadedRemote.signature;
      }
      if (!uploadedRemote) {
        continue;
      }
    }
  }
  formatConflictTimestamp() {
    const value = /* @__PURE__ */ new Date();
    const pad = (input) => String(input).padStart(2, "0");
    return `${value.getFullYear()}${pad(value.getMonth() + 1)}${pad(value.getDate())}-${pad(value.getHours())}${pad(value.getMinutes())}${pad(value.getSeconds())}`;
  }
  buildConflictCopyPath(originalPath, label) {
    const normalized = (0, import_obsidian4.normalizePath)(originalPath);
    const slashIndex = normalized.lastIndexOf("/");
    const dir = slashIndex >= 0 ? normalized.slice(0, slashIndex + 1) : "";
    const name = slashIndex >= 0 ? normalized.slice(slashIndex + 1) : normalized;
    const dotIndex = name.lastIndexOf(".");
    const stem = dotIndex > 0 ? name.slice(0, dotIndex) : name;
    const ext = dotIndex > 0 ? name.slice(dotIndex) : "";
    const suffix = `.sync-conflict-${this.formatConflictTimestamp()}-${label}`;
    return `${dir}${stem}${suffix}${ext}`;
  }
  findExistingConflictCopyPath(originalPath) {
    const normalized = (0, import_obsidian4.normalizePath)(originalPath);
    const slashIndex = normalized.lastIndexOf("/");
    const dir = slashIndex >= 0 ? normalized.slice(0, slashIndex + 1) : "";
    const name = slashIndex >= 0 ? normalized.slice(slashIndex + 1) : normalized;
    const dotIndex = name.lastIndexOf(".");
    const stem = dotIndex > 0 ? name.slice(0, dotIndex) : name;
    const ext = dotIndex > 0 ? name.slice(dotIndex) : "";
    const prefix = `${dir}${stem}.sync-conflict-`;
    return this.app.vault.getFiles().map((file) => file.path).find((path) => path.startsWith(prefix) && (!ext || path.endsWith(ext))) ?? null;
  }
  async createLocalConflictCopy(file, markdownContent, label) {
    const existing = this.findExistingConflictCopyPath(file.path);
    if (existing) {
      return existing;
    }
    let targetPath = this.buildConflictCopyPath(file.path, label);
    let attempt = 1;
    while (this.app.vault.getAbstractFileByPath(targetPath)) {
      const normalized = (0, import_obsidian4.normalizePath)(targetPath);
      const dotIndex = normalized.lastIndexOf(".");
      targetPath = dotIndex > 0 ? `${normalized.slice(0, dotIndex)}-${attempt}${normalized.slice(dotIndex)}` : `${normalized}-${attempt}`;
      attempt += 1;
    }
    await this.ensureLocalParentFolders(targetPath);
    if (file.extension === "md") {
      await this.app.vault.create(targetPath, markdownContent ?? await this.readMarkdownContentPreferEditor(file));
    } else {
      await this.app.vault.createBinary(targetPath, await this.app.vault.readBinary(file));
    }
    this.markPendingVaultSync(targetPath);
    return targetPath;
  }
  async deleteRemoteContentFile(remotePath) {
    try {
      const response = await this.requestUrl({
        url: this.buildUploadUrl(remotePath),
        method: "DELETE",
        headers: {
          Authorization: this.buildAuthHeader()
        }
      });
      if (response.status !== 404 && (response.status < 200 || response.status >= 300)) {
        throw new Error(`DELETE failed with status ${response.status}`);
      }
    } catch (error) {
      console.error("Failed to delete remote synced content", remotePath, error);
      throw error;
    }
  }
  getVaultFileByPath(path) {
    const file = this.app.vault.getAbstractFileByPath(path);
    return file instanceof import_obsidian4.TFile ? file : null;
  }
  async removeLocalVaultFile(file) {    this.suppressVaultEvent("delete", file.path);
    try {
      await this.app.vault.delete(file, true);
    } catch (deleteError) {
      try {
        await this.app.vault.trash(file, true);
      } catch {
        throw deleteError;
      }
    }
  }
  async ensureLocalParentFolders(path) {
    const normalized = (0, import_obsidian4.normalizePath)(path);
    const segments = normalized.split("/").filter((value) => value.length > 0);
    if (segments.length <= 1) {
      return;
    }
    let current = "";
    for (let index = 0; index < segments.length - 1; index += 1) {
      current = current ? `${current}/${segments[index]}` : segments[index];
      if (!await this.app.vault.adapter.exists(current)) {
        try {
          await this.app.vault.adapter.mkdir(current);
        } catch (e) {
          const msg = e instanceof Error ? e.message : String(e);
          if (!msg.includes("already exists")) {
            throw e;
          }
        }
      }
    }
  }
  async downloadRemoteFileToVault(vaultPath, remote, existingFile) {
    const response = await this.requestUrl({
      url: this.buildUploadUrl(remote.remotePath),
      method: "GET",
      headers: {
        Authorization: this.buildAuthHeader()
      }
    });
    this.assertResponseSuccess(response, "GET");
    await this.ensureLocalParentFolders(vaultPath);
    const options = {
      mtime: (remote.lastModified || remote.mtimeSvr || 0) > 0 ? (remote.lastModified || remote.mtimeSvr) : Date.now()
    };
    const isMd = vaultPath.toLowerCase().endsWith(".md");
    const current = existingFile ?? this.getVaultFileByPath(vaultPath) ?? this.app.vault.getAbstractFileByPath(vaultPath);
    if (current && current instanceof import_obsidian4.TFile) {      this.suppressVaultEvent("modify", current.path);
      if (current.extension === "md") {
        await this.app.vault.modify(current, this.decodeUtf8(response.arrayBuffer), options);
      } else {
        await this.app.vault.modifyBinary(current, response.arrayBuffer, options);
      }
      return;
    }
    try {
      this.suppressVaultEvent("modify", vaultPath);
      if (isMd) {
        await this.app.vault.create(vaultPath, this.decodeUtf8(response.arrayBuffer), options);
      } else {
        await this.app.vault.createBinary(vaultPath, response.arrayBuffer, options);
      }
    } catch (e) {
      const msg = e instanceof Error ? e.message : String(e);
      if (msg.includes("already exists")) {
        const file = this.app.vault.getAbstractFileByPath(vaultPath);
        if (file && file instanceof import_obsidian4.TFile) {
          this.suppressVaultEvent("modify", file.path);
          if (file.extension === "md") {
            await this.app.vault.modify(file, this.decodeUtf8(response.arrayBuffer), options);
          } else {
            await this.app.vault.modifyBinary(file, response.arrayBuffer, options);
          }
          return;
        }
      }
      throw e;
    }
  }
  async statRemoteFile(remotePath) {
    const response = await this.requestUrl({
      url: this.buildUploadUrl(remotePath),
      method: "PROPFIND",
      headers: {
        Authorization: this.buildAuthHeader(),
        Depth: "0"
      }
    });
    if (response.status === 404) {
      return null;
    }
    this.assertResponseSuccess(response, `PROPFIND for ${remotePath}`);
    const xmlText = this.decodeUtf8(response.arrayBuffer);
    const entries = this.parsePropfindDirectoryListing(xmlText, remotePath, true);
    return entries.find((entry) => !entry.isCollection)?.file ?? null;
  }
  async uploadContentFileToRemote(file, remotePath, markdownContent) {
    let binary;
    if (file.extension === "md") {
      const content = markdownContent ?? await this.readMarkdownContentPreferEditor(file);
      binary = this.encodeUtf8(content);
    } else {
      binary = await this.app.vault.readBinary(file);
    }
    await this.uploadBinary(remotePath, binary, this.getMimeType(file.extension));
    let remote = null;
    try {
      remote = await this.statRemoteFile(remotePath);
    } catch {
      remote = null;
    }
    if (remote) {
      return remote;
    }
    let fallbackSig = this.syncSupport.buildSyncSignature(file);
    if (file.extension === "md" && (markdownContent ?? binary)) {
      const content = markdownContent ?? this.decodeUtf8(binary);
      const contentBuffer = this.encodeUtf8(content);
      const hash = (await this.computeSha256Hex(contentBuffer)).slice(0, 16);
      fallbackSig = `${file.stat.mtime}:${file.stat.size}:${hash}`;
    }
    return {
      remotePath,
      lastModified: file.stat.mtime,
      size: file.stat.size,
      signature: fallbackSig
    };
  }
  async readMarkdownContentPreferEditor(file) {
    return await this.app.vault.read(file);
  }
  async buildCurrentLocalSignature(file, markdownContent) {
    if (file.extension === "md") {
      const content = typeof markdownContent === "string" ? markdownContent : await this.readMarkdownContentPreferEditor(file);
      const contentBuffer = this.encodeUtf8(content);
      const hash = (await this.computeSha256Hex(contentBuffer)).slice(0, 16);
      return `${file.stat.mtime}:${file.stat.size}:${hash}`;
    }
    return this.syncSupport.buildSyncSignature(file);
  }
  async ensureRemoteDirectories(remotePath) {
    const parts = remotePath.split("/").filter((value) => value.length > 0);
    if (parts.length <= 1) {
      return;
    }
    let current = "";
    for (let index = 0; index < parts.length - 1; index += 1) {
      current = current ? `${current}/${parts[index]}` : parts[index];
      const response = await this.requestUrl({
        url: this.buildUploadUrl(current),
        method: "MKCOL",
        headers: {
          Authorization: this.buildAuthHeader()
        }
      });
      if (![200, 201, 204, 207, 301, 302, 307, 308, 403, 405].includes(response.status)) {
        throw new Error(`MKCOL failed for ${current} with status ${response.status}`);
      }
    }
  }
  async listRemoteTree(rootFolder) {
    const files = /* @__PURE__ */ new Map();
    const directories = /* @__PURE__ */ new Set();
    const pending = [normalizeFolder(rootFolder)];
    const visited = /* @__PURE__ */ new Set();
    while (pending.length > 0) {
      const current = normalizeFolder(pending.pop() ?? rootFolder);
      if (visited.has(current)) {
        continue;
      }
      visited.add(current);
      const entries = await this.listRemoteDirectory(current);
      for (const entry of entries) {
        if (entry.isCollection) {
          directories.add(entry.remotePath);
          pending.push(entry.remotePath);
          continue;
        }
        if (entry.file) {
          files.set(entry.remotePath, entry.file);
        }
      }
    }
    return { files, directories };
  }
  async listRemoteDirectory(remoteDirectory) {
    const requestedPath = normalizeFolder(remoteDirectory);
    const response = await this.requestUrl({
      url: this.buildUploadUrl(requestedPath),
      method: "PROPFIND",
      headers: {
        Authorization: this.buildAuthHeader(),
        Depth: "1"
      }
    });
    if (response.status === 404) {
      return [];
    }
    this.assertResponseSuccess(response, `PROPFIND for ${requestedPath}`);
    const xmlText = this.decodeUtf8(response.arrayBuffer);
    return this.parsePropfindDirectoryListing(xmlText, requestedPath);
  }
  parsePropfindDirectoryListing(xmlText, requestedPath, includeRequested = false) {
    if (typeof DOMParser === "undefined") {
      return this.parsePropfindDirectoryListingFallback(xmlText, requestedPath, includeRequested);
    }
    const parser = new DOMParser();
    const document2 = parser.parseFromString(xmlText, "application/xml");
    if (document2.getElementsByTagName("parsererror").length > 0) {
      throw new Error(this.t("\u65E0\u6CD5\u89E3\u6790 WebDAV \u76EE\u5F55\u6E05\u5355\u3002", "Failed to parse the WebDAV directory listing."));
    }
    const entries = /* @__PURE__ */ new Map();
    for (const element of Array.from(document2.getElementsByTagName("*"))) {
      if (element.localName !== "response") {
        continue;
      }
      const href = this.getXmlLocalNameText(element, "href");
      if (!href) {
        continue;
      }
      const remotePath = this.hrefToRemotePath(href);
      if (!remotePath) {
        continue;
      }
      const isCollection = this.xmlTreeHasLocalName(element, "collection");
      const normalizedPath = isCollection ? normalizeFolder(remotePath) : remotePath.replace(/\/+$/, "");
      if (!includeRequested && (normalizedPath === requestedPath || normalizedPath === requestedPath.replace(/\/+$/, ""))) {
        continue;
      }
      const sizeText = this.getXmlLocalNameText(element, "getcontentlength");
      const parsedSize = Number.parseInt(sizeText, 10);
      const size = Number.isFinite(parsedSize) ? parsedSize : 0;
      const modifiedText = this.getXmlLocalNameText(element, "getlastmodified");
      const parsedMtime = Date.parse(modifiedText);
      const lastModified = Number.isFinite(parsedMtime) ? parsedMtime : 0;
      entries.set(normalizedPath, {
        remotePath: normalizedPath,
        isCollection,
        file: isCollection ? void 0 : {
          remotePath: normalizedPath,
          lastModified,
          size,
          signature: this.syncSupport.buildRemoteSyncSignature({
            lastModified,
            size
          })
        }
      });
    }
    return [...entries.values()];
  }
  parsePropfindDirectoryListingFallback(xmlText, requestedPath, includeRequested = false) {
    const entries = /* @__PURE__ */ new Map();
    const responses = xmlText.match(/<(?:[\w-]+:)?response\b[\s\S]*?<\/(?:[\w-]+:)?response>/gi) ?? [];
    for (const block of responses) {
      const href = this.decodeXmlEntities(this.extractXmlLocalNameValueFromText(block, "href"));
      if (!href) {
        continue;
      }
      const remotePath = this.hrefToRemotePath(href);
      if (!remotePath) {
        continue;
      }
      const isCollection = /<(?:[\w-]+:)?collection\b(?:[^>]*)\/?>/i.test(block) || /<(?:[\w-]+:)?collection\b[\s\S]*?<\/(?:[\w-]+:)?collection>/i.test(block);
      const normalizedPath = isCollection ? normalizeFolder(remotePath) : remotePath.replace(/\/+$/, "");
      if (!includeRequested && (normalizedPath === requestedPath || normalizedPath === requestedPath.replace(/\/+$/, ""))) {
        continue;
      }
      const sizeText = this.extractXmlLocalNameValueFromText(block, "getcontentlength");
      const parsedSize = Number.parseInt(sizeText, 10);
      const size = Number.isFinite(parsedSize) ? parsedSize : 0;
      const modifiedText = this.extractXmlLocalNameValueFromText(block, "getlastmodified");
      const parsedMtime = Date.parse(modifiedText);
      const lastModified = Number.isFinite(parsedMtime) ? parsedMtime : 0;
      entries.set(normalizedPath, {
        remotePath: normalizedPath,
        isCollection,
        file: isCollection ? void 0 : {
          remotePath: normalizedPath,
          lastModified,
          size,
          signature: this.syncSupport.buildRemoteSyncSignature({
            lastModified,
            size
          })
        }
      });
    }
    return [...entries.values()];
  }
  extractXmlLocalNameValueFromText(xmlText, localName) {
    const pattern = new RegExp(`<(?:[\\w-]+:)?${localName}\\b[^>]*>([\\s\\S]*?)<\\/(?:[\\w-]+:)?${localName}>`, "i");
    const match = xmlText.match(pattern);
    return match?.[1]?.trim() ?? "";
  }
  decodeXmlEntities(value) {
    return value.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, "\"").replace(/&#39;/g, "'").replace(/&#x2F;/gi, "/");
  }
  getXmlLocalNameText(parent, localName) {
    for (const element of Array.from(parent.getElementsByTagName("*"))) {
      if (element.localName === localName) {
        return element.textContent?.trim() ?? "";
      }
    }
    return "";
  }
  xmlTreeHasLocalName(parent, localName) {
    return Array.from(parent.getElementsByTagName("*")).some((element) => element.localName === localName);
  }
  hrefToRemotePath(href) {
    const baseUrl = `${this.settings.webdavUrl.replace(/\/+$/, "")}/`;
    const resolved = new URL(href, baseUrl);
    const basePath = new URL(baseUrl).pathname.replace(/\/+$/, "/");
    const decodedPath = this.decodePathname(resolved.pathname);
    if (!decodedPath.startsWith(basePath)) {
      return null;
    }
    return decodedPath.slice(basePath.length).replace(/^\/+/, "");
  }
  decodePathname(pathname) {
    return pathname.split("/").map((segment) => {
      if (!segment) {
        return "";
      }
      try {
        return decodeURIComponent(segment);
      } catch {
        return segment;
      }
    }).join("/");
  }
  async reconcileDirectories(remoteDirectories) {
    const stats = { createdLocal: 0, createdRemote: 0, deletedLocal: 0, deletedRemote: 0 };
    const remoteLocalPaths = /* @__PURE__ */ new Set();
    for (const remoteDir of remoteDirectories) {
      const localPath = this.syncSupport.remotePathToVaultPath(remoteDir);
      if (localPath !== null && localPath.length > 0 && !this.syncSupport.shouldSkipDirectorySyncPath(localPath)) {
        remoteLocalPaths.add((0, import_obsidian4.normalizePath)(localPath));
      }
    }
    const localDirPaths = this.syncSupport.collectLocalSyncedDirectories();
    const knownDirPaths = this.syncedDirectories;
    const newSyncedDirs = /* @__PURE__ */ new Set();
    const localOnly = [...localDirPaths].filter((p) => !remoteLocalPaths.has(p));
    const remoteOnly = [...remoteLocalPaths].filter((p) => !localDirPaths.has(p));
    for (const dirPath of [...localOnly].sort((a, b) => a.length - b.length)) {
      if (knownDirPaths.has(dirPath)) {
        // Was synced before, now only local → remote deleted it → delete locally
        // Only delete if the directory is actually empty (files are handled by three-way sync)
        const hasFiles = this.app.vault.getFiles().some(f => f.path.startsWith(dirPath + "/"));
        if (!hasFiles) {
          const folder = this.app.vault.getAbstractFileByPath(dirPath);
          if (folder instanceof import_obsidian4.TFolder) {
            try {
              await this.app.vault.delete(folder, true);
              stats.deletedLocal += 1;
            } catch {
              newSyncedDirs.add(dirPath);
            }
          }
        } else {
          newSyncedDirs.add(dirPath);
        }
      } else {
        // New local directory → create on remote (ensure parents + the directory itself)
        const remoteDir = normalizeFolder(this.settings.vaultSyncRemoteFolder) + dirPath;
        try {
          await this.ensureRemoteDirectories(remoteDir + "/_");
          stats.createdRemote += 1;
        } catch {
        }
        newSyncedDirs.add(dirPath);
      }
    }
    for (const dirPath of localDirPaths) {
      if (remoteLocalPaths.has(dirPath)) {
        newSyncedDirs.add(dirPath);
      }
    }
    for (const dirPath of [...remoteOnly].sort((a, b) => a.length - b.length)) {
      if (knownDirPaths.has(dirPath)) {
        // Was synced before, now only on remote → user deleted locally → delete from remote
        const remotePath = normalizeFolder(this.settings.vaultSyncRemoteFolder) + dirPath;
        try {
          const response = await this.requestUrl({
            url: this.buildUploadUrl(remotePath),
            method: "DELETE",
            headers: { Authorization: this.buildAuthHeader() }
          });
          if ([200, 202, 204, 404].includes(response.status)) {
            if (response.status !== 404) stats.deletedRemote += 1;
          }
        } catch {
          // If delete fails (e.g. network), keep dir in synced list
          newSyncedDirs.add(dirPath);
        }
      } else {
        if (!await this.app.vault.adapter.exists(dirPath)) {
          try {
            await this.app.vault.adapter.mkdir(dirPath);
          } catch (e) {
            const msg = e instanceof Error ? e.message : String(e);
            if (!msg.includes("already exists")) {
              throw e;
            }
          }
        }
        stats.createdLocal += 1;
        newSyncedDirs.add(dirPath);
      }
    }
    this.syncedDirectories = newSyncedDirs;
    return stats;
  }
  async processPendingTasks() {
    await this.uploadQueue.processPendingTasks();
  }
  async waitForPendingVaultMutations() {
    while (this.pendingVaultMutationPromises.size > 0) {
      await Promise.allSettled([...this.pendingVaultMutationPromises]);
    }
  }
  async preparePendingUploadsForSync(showNotice) {
    await this.uploadQueue.processPendingTasks();
    if (this.uploadQueue.hasPendingWork()) {
      this.lastVaultSyncAt = Date.now();
      this.lastVaultSyncStatus = this.t(
        "\u68C0\u6D4B\u5230\u56FE\u7247\u4E0A\u4F20\u4ECD\u5728\u8FDB\u884C\u6216\u7B49\u5F85\u91CD\u8BD5\uFF0C\u5DF2\u6682\u7F13\u672C\u6B21\u7B14\u8BB0\u540C\u6B65\uFF0C\u907F\u514D\u65E7\u7248\u7B14\u8BB0\u8986\u76D6\u65B0\u56FE\u7247\u5F15\u7528\u3002",
        "Image uploads are still running or waiting for retry, so note sync was deferred to avoid old note content overwriting new image references."
      );
      await this.savePluginState();
      if (showNotice) {
        new import_obsidian4.Notice(this.lastVaultSyncStatus, 8e3);
      }
      return false;
    }
    return true;
  }
  async uploadImagesInNote(noteFile) {
    try {
      const content = await this.app.vault.read(noteFile);
      const replacements = await this.buildUploadReplacements(content, noteFile);
      if (replacements.length === 0) {
        new import_obsidian4.Notice(this.t("\u5F53\u524D\u7B14\u8BB0\u4E2D\u6CA1\u6709\u627E\u5230\u672C\u5730\u56FE\u7247\u3002", "No local images found in the current note."));
        return;
      }
      let updated = content;
      for (const replacement of replacements) {
        updated = updated.split(replacement.original).join(replacement.rewritten);
      }
      if (updated === content) {
        new import_obsidian4.Notice(this.t("\u6CA1\u6709\u9700\u8981\u6539\u5199\u7684\u56FE\u7247\u94FE\u63A5\u3002", "No images were rewritten."));
        return;
      }
      await this.app.vault.modify(noteFile, updated);
      if (this.shouldDeleteLocalImagesAfterUpload()) {
        for (const replacement of replacements) {
          if (replacement.sourceFile) {
            await this.trashIfExists(replacement.sourceFile);
          }
        }
      }
      new import_obsidian4.Notice(this.t(`\u5DF2\u4E0A\u4F20 ${replacements.length} \u5F20\u56FE\u7247\u5230 WebDAV\u3002`, `Uploaded ${replacements.length} image(s) to WebDAV.`));
    } catch (error) {
      console.error("Secure WebDAV upload failed", error);
      new import_obsidian4.Notice(this.describeError(this.t("\u4E0A\u4F20\u5931\u8D25", "Upload failed"), error), 8e3);
    }
  }
  escapeHtml(value) {
    return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
  }
  unescapeHtml(value) {
    return value.replace(/&quot;/g, '"').replace(/&gt;/g, ">").replace(/&lt;/g, "<").replace(/&amp;/g, "&");
  }
  async fetchSecureImageBlobUrl(remotePath) {
    const response = await this.requestUrl({
      url: this.buildUploadUrl(remotePath),
      method: "GET",
      headers: {
        Authorization: this.buildAuthHeader()
      }
    });
    this.assertResponseSuccess(response, "Fetch secure image");
    const blob = new Blob([response.arrayBuffer], {
      type: response.headers["content-type"] ?? "application/octet-stream"
    });
    const blobUrl = URL.createObjectURL(blob);
    this.evictBlobUrlsIfNeeded();
    this.blobUrls.add(blobUrl);
    return blobUrl;
  }
  evictBlobUrlsIfNeeded() {
    while (this.blobUrls.size >= this.maxBlobUrls) {
      const oldest = this.blobUrls.values().next().value;
      this.blobUrls.delete(oldest);
      URL.revokeObjectURL(oldest);
    }
  }
  arrayBufferToBase64(buffer) {
    const bytes = new Uint8Array(buffer);
    const chunkSize = 32768;
    let binary = "";
    for (let index = 0; index < bytes.length; index += chunkSize) {
      const chunk = bytes.subarray(index, index + chunkSize);
      binary += String.fromCharCode(...chunk);
    }
    return btoa(binary);
  }
  base64ToArrayBuffer(base64) {
    const binary = atob(base64);
    const bytes = new Uint8Array(binary.length);
    for (let index = 0; index < binary.length; index += 1) {
      bytes[index] = binary.charCodeAt(index);
    }
    return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
  }
  buildClipboardFileName(mimeType) {
    const extension = mimeType.split("/")[1]?.replace("jpeg", "jpg") || "png";
    return `pasted-image-${Date.now()}.${extension}`;
  }
  escapeRegExp(value) {
    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
  }
  buildRemotePath(fileName) {
    return `${normalizeFolder(this.settings.remoteFolder)}${fileName}`;
  }
  async buildRemoteFileNameFromBinary(fileName, binary) {
    const extension = this.getExtensionFromFileName(fileName);
    if (this.settings.namingStrategy === "hash") {
      const hash = (await this.computeSha256Hex(binary)).slice(0, 16);
      return `${hash}.${extension}`;
    }
    return `${Date.now()}-${fileName}`;
  }
  buildUploadUrl(remotePath) {
    const base = this.settings.webdavUrl.replace(/\/+$/, "");
    return `${base}/${remotePath.split("/").map(encodeURIComponent).join("/")}`;
  }
  buildAuthHeader() {
    const token = this.arrayBufferToBase64(this.encodeUtf8(`${this.settings.username}:${this.settings.password}`));
    return `Basic ${token}`;
  }
  ensureConfigured() {
    if (!this.settings.webdavUrl || !this.settings.username || !this.settings.password) {
      throw new Error(this.t("WebDAV \u914D\u7F6E\u4E0D\u5B8C\u6574\u3002", "WebDAV settings are incomplete."));
    }
  }
  assertResponseSuccess(response, context) {
    if (response.status < 200 || response.status >= 300) {
      throw new Error(`${context} failed with status ${response.status}`);
    }
  }
  getMimeType(extension) {
    return MIME_MAP[extension.toLowerCase()] ?? "application/octet-stream";
  }
  getMimeTypeFromFileName(fileName) {
    return this.getMimeType(this.getExtensionFromFileName(fileName));
  }
  getExtensionFromFileName(fileName) {
    const pieces = fileName.split(".");
    return pieces.length > 1 ? pieces[pieces.length - 1].toLowerCase() : "png";
  }
  shouldDeleteLocalImagesAfterUpload() {
    return true;
  }
  async prepareUploadPayload(binary, mimeType, fileName) {
    if (!this.settings.compressImages) {
      return { binary, mimeType, fileName };
    }
    const prepared = await this.compressImageIfNeeded(binary, mimeType, fileName);
    return prepared ?? { binary, mimeType, fileName };
  }
  async compressImageIfNeeded(binary, mimeType, fileName) {
    if (!/^image\/(png|jpeg|jpg|webp)$/i.test(mimeType)) {
      return null;
    }
    const thresholdBytes = this.settings.compressThresholdKb * 1024;
    const sourceBlob = new Blob([binary], { type: mimeType });
    const image = await this.loadImageElement(sourceBlob);
    const largestSide = Math.max(image.naturalWidth, image.naturalHeight);
    const needsResize = largestSide > this.settings.maxImageDimension;
    const needsCompress = sourceBlob.size > thresholdBytes || needsResize;
    if (!needsCompress) {
      return null;
    }
    const scale = needsResize ? this.settings.maxImageDimension / largestSide : 1;
    const targetWidth = Math.max(1, Math.round(image.naturalWidth * scale));
    const targetHeight = Math.max(1, Math.round(image.naturalHeight * scale));
    const canvas = document.createElement("canvas");
    canvas.width = targetWidth;
    canvas.height = targetHeight;
    const context = canvas.getContext("2d");
    if (!context) {
      return null;
    }
    context.drawImage(image, 0, 0, targetWidth, targetHeight);
    const outputMime = mimeType.toLowerCase() === "image/jpg" ? "image/jpeg" : mimeType;
    const quality = Math.max(0.4, Math.min(0.98, this.settings.jpegQuality / 100));
    const compressedBlob = await new Promise((resolve) => {
      canvas.toBlob(resolve, outputMime, quality);
    });
    if (!compressedBlob) {
      return null;
    }
    if (!needsResize && compressedBlob.size >= sourceBlob.size) {
      return null;
    }
    const nextBinary = await compressedBlob.arrayBuffer();
    const nextExtension = this.extensionFromMimeType(outputMime) ?? this.getExtensionFromFileName(fileName);
    const nextFileName = fileName.replace(/\.[^.]+$/, "") + `.${nextExtension}`;
    return {
      binary: nextBinary,
      mimeType: outputMime,
      fileName: nextFileName
    };
  }
  loadImageElement(blob) {
    return new Promise((resolve, reject) => {
      const url = URL.createObjectURL(blob);
      const image = new Image();
      image.onload = () => {
        URL.revokeObjectURL(url);
        resolve(image);
      };
      image.onerror = (error) => {
        URL.revokeObjectURL(url);
        reject(error);
      };
      image.src = url;
    });
  }
  extensionFromMimeType(mimeType) {
    return MIME_MAP[mimeType] ?? null;
  }
  async trashIfExists(file) {
    try {
      await this.app.vault.trash(file, true);
    } catch (error) {
      console.warn("Failed to trash local image after upload", error);
    }
  }
  async migrateAllLegacySecureImages() {
    try {
      const uploadCache = /* @__PURE__ */ new Map();
      const candidateLocalImages = /* @__PURE__ */ new Map();
      let changedFiles = 0;
      for (const file of this.app.vault.getMarkdownFiles()) {
        const content = await this.app.vault.read(file);
        const replacements = await this.buildUploadReplacements(content, file, uploadCache);
        for (const replacement of replacements) {
          if (replacement.sourceFile) {
            candidateLocalImages.set(replacement.sourceFile.path, replacement.sourceFile);
          }
        }
        let updated = content;
        for (const replacement of replacements) {
          updated = updated.split(replacement.original).join(replacement.rewritten);
        }
        updated = updated.replace(
          /<span class="secure-webdav-embed" data-secure-webdav="([^"]+)" aria-label="([^"]*)">.*?<\/span>/g,
          (_match, remotePath, alt) => this.imageSupport.buildSecureImageCodeBlock(
            this.unescapeHtml(remotePath),
            this.unescapeHtml(alt) || this.unescapeHtml(remotePath)
          )
        ).replace(
          /!\[[^\]]*]\(webdav-secure:\/\/([^)]+)\)/g,
          (_match, remotePath) => this.imageSupport.buildSecureImageCodeBlock(this.unescapeHtml(remotePath), this.unescapeHtml(remotePath))
        );
        if (updated === content) {
          continue;
        }
        await this.app.vault.modify(file, updated);
        changedFiles += 1;
      }
      if (changedFiles === 0) {
        new import_obsidian4.Notice(
          this.t(
            "\u6574\u5E93\u91CC\u6CA1\u6709\u53D1\u73B0\u53EF\u8FC1\u79FB\u7684\u65E7\u7248\u5B89\u5168\u56FE\u7247\u6807\u7B7E\u3002",
            "No legacy secure image tags were found in the vault."
          )
        );
        return;
      }
      if (this.shouldDeleteLocalImagesAfterUpload()) {
        await this.trashMigratedImagesIfSafe(candidateLocalImages);
      }
      new import_obsidian4.Notice(
        this.t(
          `\u5DF2\u8FC1\u79FB ${changedFiles} \u7BC7\u7B14\u8BB0\u5230\u65B0\u7684\u5B89\u5168\u56FE\u7247\u4EE3\u7801\u5757\u683C\u5F0F\u3002`,
          `Migrated ${changedFiles} note(s) to the new secure image code-block format.`
        ),
        8e3
      );
    } catch (error) {
      console.error("Failed to migrate secure images to code blocks", error);
      new import_obsidian4.Notice(this.describeError(this.t("\u8FC1\u79FB\u5B89\u5168\u56FE\u7247\u683C\u5F0F\u5931\u8D25", "Failed to migrate secure image format"), error), 8e3);
    }
  }
  async trashMigratedImagesIfSafe(candidateLocalImages) {
    if (candidateLocalImages.size === 0) {
      return;
    }
    const remainingRefs = /* @__PURE__ */ new Set();
    for (const note of this.app.vault.getMarkdownFiles()) {
      const content = await this.app.vault.read(note);
      const wikiMatches = [...content.matchAll(/!\[\[([^\]]+)\]\]/g)];
      const markdownMatches = [...content.matchAll(/!\[[^\]]*]\(([^)]+)\)/g)];
      for (const match of wikiMatches) {
        const rawLink = match[1].split("|")[0].trim();
        const target = this.resolveLinkedFile(rawLink, note.path);
        if (target && this.isImageFile(target)) {
          remainingRefs.add(target.path);
        }
      }
      for (const match of markdownMatches) {
        const rawLink = decodeURIComponent(match[1].trim().replace(/^<|>$/g, ""));
        if (/^(https?:|webdav-secure:|data:)/i.test(rawLink)) {
          continue;
        }
        const target = this.resolveLinkedFile(rawLink, note.path);
        if (target && this.isImageFile(target)) {
          remainingRefs.add(target.path);
        }
      }
    }
    for (const [path, file] of candidateLocalImages.entries()) {
      if (remainingRefs.has(path)) {
        continue;
      }
      await this.trashIfExists(file);
    }
  }
  async runConnectionTest(showModal = false) {
    try {
      this.ensureConfigured();
      const probeName = `.secure-webdav-probe-${Date.now()}.txt`;
      const remotePath = this.buildRemotePath(probeName);
      const uploadUrl = this.buildUploadUrl(remotePath);
      const probeArrayBuffer = this.encodeUtf8(`secure-webdav probe ${(/* @__PURE__ */ new Date()).toISOString()}`);
      const putResponse = await this.requestUrl({
        url: uploadUrl,
        method: "PUT",
        headers: {
          Authorization: this.buildAuthHeader(),
          "Content-Type": "text/plain; charset=utf-8"
        },
        body: probeArrayBuffer
      });
      if (putResponse.status < 200 || putResponse.status >= 300) {
        throw new Error(`PUT failed with status ${putResponse.status}`);
      }
      const getResponse = await this.requestUrl({
        url: uploadUrl,
        method: "GET",
        headers: {
          Authorization: this.buildAuthHeader()
        }
      });
      if (getResponse.status < 200 || getResponse.status >= 300) {
        throw new Error(`GET failed with status ${getResponse.status}`);
      }
      const deleteResponse = await this.requestUrl({
        url: uploadUrl,
        method: "DELETE",
        headers: {
          Authorization: this.buildAuthHeader()
        }
      });
      if (deleteResponse.status < 200 || deleteResponse.status >= 300) {
        throw new Error(`DELETE failed with status ${deleteResponse.status}`);
      }
      const message = this.t(
        `WebDAV \u6D4B\u8BD5\u901A\u8FC7\u3002PUT ${putResponse.status}\uFF0CGET ${getResponse.status}\uFF0CDELETE ${deleteResponse.status}\u3002`,
        `WebDAV test passed. PUT ${putResponse.status}, GET ${getResponse.status}, DELETE ${deleteResponse.status}.`
      );
      new import_obsidian4.Notice(message, 6e3);
      if (showModal) {
        new ResultModal(this.app, this.t("WebDAV \u8FDE\u63A5", "WebDAV Connection"), message).open();
      }
      return true;
    } catch (error) {
      console.error("Secure WebDAV test failed", error);
      const message = this.describeError(this.t("WebDAV \u6D4B\u8BD5\u5931\u8D25", "WebDAV test failed"), error);
      new import_obsidian4.Notice(message, 8e3);
      if (showModal) {
        new ResultModal(this.app, this.t("WebDAV \u8FDE\u63A5", "WebDAV Connection"), message).open();
      }
      return false;
    }
  }
  describeError(prefix, error) {
    const message = error instanceof Error ? error.message : String(error);
    return `${prefix}: ${message}`;
  }
  async requestUrl(options) {
    const response = await (0, import_obsidian4.requestUrl)({
      url: options.url,
      method: options.method,
      headers: options.headers,
      body: options.body,
      throw: false
    });
    return {
      status: response.status,
      headers: response.headers,
      arrayBuffer: response.arrayBuffer
    };
  }
  encodeUtf8(value) {
    const bytes = new TextEncoder().encode(value);
    return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
  }
  decodeUtf8(buffer) {
    return new TextDecoder().decode(buffer);
  }
  async computeSha256Hex(buffer) {
    const digest = await crypto.subtle.digest("SHA-256", buffer);
    return Array.from(new Uint8Array(digest)).map((value) => value.toString(16).padStart(2, "0")).join("");
  }
};
var SecureWebdavSettingTab = class extends import_obsidian4.PluginSettingTab {
  constructor(app, plugin) {
    super(app, plugin);
    this.plugin = plugin;
  }
  display() {
    const { containerEl } = this;
    containerEl.empty();
    const runtimeVersion = this.plugin.getRuntimePluginVersion();
    const installedVersion = this.plugin.readInstalledPluginVersion();
    containerEl.createEl("h2", { text: "Secure WebDAV Images" });
    containerEl.createEl("p", {
      text: this.plugin.t(
        "\u8FD9\u4E2A\u63D2\u4EF6\u53EA\u628A\u56FE\u7247\u5265\u79BB\u5230\u5355\u72EC\u7684\u8FDC\u7AEF\u76EE\u5F55\uFF0C\u5E76\u4FDD\u5B58\u4E3A secure-webdav \u81EA\u5B9A\u4E49\u4EE3\u7801\u5757\uFF1B\u5176\u4ED6\u7B14\u8BB0\u548C\u9644\u4EF6\u6309\u539F\u8DEF\u5F84\u539F\u6837\u540C\u6B65\u3002",
        "This plugin separates only images into a dedicated remote folder and stores them as secure-webdav custom code blocks. Notes and other attachments are synced as-is with their original paths."
      )
    });
    new import_obsidian4.Setting(containerEl).setName(this.plugin.t("\u5F53\u524D\u8FD0\u884C\u7248\u672C", "Current running version")).setDesc(
      this.plugin.t(
        "\u5F53\u524D\u771F\u6B63\u5728 Obsidian \u8FDB\u7A0B\u91CC\u8FD0\u884C\u7684\u63D2\u4EF6\u7248\u672C\u3002",
        "The plugin version currently running inside Obsidian."
      )
    ).addText((text) => {
      text.setValue(runtimeVersion);
      text.setDisabled(true);
    });
    new import_obsidian4.Setting(containerEl).setName(this.plugin.t("\u78C1\u76D8\u5DF2\u5B89\u88C5\u7248\u672C", "Installed version on disk")).setDesc(
      this.plugin.t(
        "\u63D2\u4EF6\u76EE\u5F55 manifest.json \u4E2D\u7684\u7248\u672C\u3002\u5982\u679C\u9AD8\u4E8E\u8FD0\u884C\u7248\u672C\uFF0C\u8BF4\u660E\u9700\u8981\u91CD\u65B0\u52A0\u8F7D\u63D2\u4EF6\u3002",
        "The version recorded in manifest.json on disk. If it is newer than the running version, reload the plugin."
      )
    ).addText((text) => {
      text.setValue(installedVersion);
      text.setDisabled(true);
    });
    if (this.plugin.hasPendingPluginReload()) {
      containerEl.createEl("p", {
        text: this.plugin.formatPluginVersionStatusLabel(),
        cls: "secure-webdav-setting-warning"
      });
    }
    new import_obsidian4.Setting(containerEl).setName(this.plugin.t("检查更新", "Check for updates")).setDesc(
      this.plugin.lastAutoUpdateCheckAt
        ? this.plugin.t(
            `上次检查：${new Date(this.plugin.lastAutoUpdateCheckAt).toLocaleString()}`,
            `Last checked: ${new Date(this.plugin.lastAutoUpdateCheckAt).toLocaleString()}`
          )
        : this.plugin.t("尚未检查过更新", "No update check yet")
    ).addButton((btn) => {
      btn.setButtonText(this.plugin.t("立即检查", "Check now"));
      btn.onClick(() => {
        btn.setButtonText(this.plugin.t("检查中...", "Checking..."));
        btn.setDisabled(true);
        void this.plugin.checkForPluginUpdate(true).finally(() => {
          btn.setButtonText(this.plugin.t("立即检查", "Check now"));
          btn.setDisabled(false);
        });
      });
    });
    new import_obsidian4.Setting(containerEl).setName(this.plugin.t("自动检查更新间隔（小时）", "Auto update check interval (hours)")).setDesc(
      this.plugin.t("每隔指定小时数自动检查 GitHub 是否有新版本。设为 0 可关闭自动检查。", "Automatically check GitHub for new versions every N hours. Set to 0 to disable.")
    ).addText((text) => {
      text.setValue(String(this.plugin.settings.autoUpdateCheckIntervalHours));
      text.onChange(async (value) => {
        const num = parseInt(value, 10);
        if (!isNaN(num) && num >= 0) {
          this.plugin.settings.autoUpdateCheckIntervalHours = num;
          await this.plugin.saveSettings();
        }
      });
    });
    containerEl.createEl("h3", { text: this.plugin.t("\u754C\u9762\u8BED\u8A00", "Interface language") });
    new import_obsidian4.Setting(containerEl).setName(this.plugin.t("\u8BED\u8A00", "Language")).setDesc(this.plugin.t("\u8BBE\u7F6E\u9875\u652F\u6301\u81EA\u52A8\u3001\u4E2D\u6587\u3001\u82F1\u6587\u5207\u6362\u3002", "Switch the settings UI between auto, Chinese, and English.")).addDropdown(
      (dropdown) => dropdown.addOption("auto", this.plugin.t("\u81EA\u52A8", "Auto")).addOption("zh", "\u4E2D\u6587").addOption("en", "English").setValue(this.plugin.settings.language).onChange(async (value) => {
        this.plugin.settings.language = value;
        await this.plugin.saveSettings();
        this.display();
      })
    );
    containerEl.createEl("h3", { text: this.plugin.t("\u8FDE\u63A5\u8BBE\u7F6E", "Connection") });
    new import_obsidian4.Setting(containerEl).setName(this.plugin.t("WebDAV \u57FA\u7840\u5730\u5740", "WebDAV base URL")).setDesc(this.plugin.t("\u670D\u52A1\u5668\u57FA\u7840\u5730\u5740\uFF0C\u4F8B\u5982\uFF1Ahttp://your-webdav-host:port", "Base server URL. Example: http://your-webdav-host:port")).addText(
      (text) => text.setPlaceholder("http://your-webdav-host:port").setValue(this.plugin.settings.webdavUrl).onChange(async (value) => {
        this.plugin.settings.webdavUrl = value.trim();
        await this.plugin.saveSettings();
      })
    );
    new import_obsidian4.Setting(containerEl).setName(this.plugin.t("\u8D26\u53F7", "Username")).addText(
      (text) => text.setValue(this.plugin.settings.username).onChange(async (value) => {
        this.plugin.settings.username = value.trim();
        await this.plugin.saveSettings();
      })
    );
    new import_obsidian4.Setting(containerEl).setName(this.plugin.t("\u5BC6\u7801", "Password")).setDesc(this.plugin.t("\u9ED8\u8BA4\u9690\u85CF\uFF0C\u53EF\u70B9\u51FB\u53F3\u4FA7\u6309\u94AE\u663E\u793A\u6216\u9690\u85CF\u3002", "Hidden by default. Use the button on the right to show or hide it.")).addText((text) => {
      text.inputEl.type = "password";
      text.setValue(this.plugin.settings.password).onChange(async (value) => {
        this.plugin.settings.password = value;
        await this.plugin.saveSettings();
      });
    }).addExtraButton((button) => {
      let visible = false;
      button.setIcon("eye");
      button.setTooltip(this.plugin.t("\u663E\u793A\u5BC6\u7801", "Show password"));
      button.onClick(() => {
        const input = button.extraSettingsEl.parentElement?.querySelector("input");
        if (!(input instanceof HTMLInputElement)) {
          return;
        }
        visible = !visible;
        input.type = visible ? "text" : "password";
        button.setIcon(visible ? "eye-off" : "eye");
        button.setTooltip(this.plugin.t(visible ? "\u9690\u85CF\u5BC6\u7801" : "\u663E\u793A\u5BC6\u7801", visible ? "Hide password" : "Show password"));
      });
    });
    new import_obsidian4.Setting(containerEl).setName(this.plugin.t("\u56FE\u7247\u8FDC\u7A0B\u76EE\u5F55", "Image remote folder")).setDesc(
      this.plugin.t(
        "\u4E13\u95E8\u7528\u4E8E\u5B58\u653E\u8FDC\u7A0B\u56FE\u7247\u7684 WebDAV \u76EE\u5F55\uFF0C\u4F8B\u5982\uFF1A/remote-images/\u3002\u56FE\u7247\u4E0A\u4F20\u6210\u529F\u540E\u4F1A\u7ACB\u5373\u5220\u9664\u672C\u5730\u56FE\u7247\u6587\u4EF6\u3002",
        "Dedicated WebDAV folder for remote images, for example: /remote-images/. Local image files are deleted immediately after upload succeeds."
      )
    ).addText(
      (text) => text.setValue(this.plugin.settings.remoteFolder).onChange(async (value) => {
        this.plugin.settings.remoteFolder = (0, import_obsidian4.normalizePath)(value.trim() || "/remote-images/");
        await this.plugin.saveSettings();
      })
    );
    new import_obsidian4.Setting(containerEl).setName(this.plugin.t("\u6D4B\u8BD5\u8FDE\u63A5", "Test connection")).setDesc(this.plugin.t("\u4F7F\u7528\u4E34\u65F6\u63A2\u9488\u6587\u4EF6\u9A8C\u8BC1 PUT\u3001GET\u3001DELETE \u662F\u5426\u6B63\u5E38\u3002", "Verify PUT, GET, and DELETE using a temporary probe file.")).addButton(
      (button) => button.setButtonText(this.plugin.t("\u5F00\u59CB\u6D4B\u8BD5", "Run test")).onClick(async () => {
        button.setDisabled(true);
        try {
          await this.plugin.runConnectionTest(true);
        } finally {
          button.setDisabled(false);
        }
      })
    );
    containerEl.createEl("h3", { text: this.plugin.t("\u540C\u6B65\u8BBE\u7F6E", "Sync") });
    new import_obsidian4.Setting(containerEl).setName(this.plugin.t("\u8FDC\u7A0B\u7B14\u8BB0\u76EE\u5F55", "Remote notes folder")).setDesc(
      this.plugin.t(
        "\u7528\u4E8E\u5B58\u653E\u7B14\u8BB0\u548C\u5176\u4ED6\u975E\u56FE\u7247\u9644\u4EF6\u539F\u6837\u540C\u6B65\u526F\u672C\u7684\u8FDC\u7AEF\u76EE\u5F55\uFF0C\u4F8B\u5982\uFF1A/vault-sync/\u3002\u63D2\u4EF6\u4F1A\u81EA\u52A8\u540C\u6B65\u6574\u4E2A vault\uFF0C\u5E76\u8DF3\u8FC7 .obsidian\u3001\u63D2\u4EF6\u76EE\u5F55\u548C\u56FE\u7247\u6587\u4EF6\u3002",
        "Remote folder used for notes and other non-image attachments synced as-is, for example: /vault-sync/. The plugin syncs the whole vault and automatically skips .obsidian, the plugin directory, and image files."
      )
    ).addText(
      (text) => text.setValue(this.plugin.settings.vaultSyncRemoteFolder).onChange(async (value) => {
        this.plugin.settings.vaultSyncRemoteFolder = (0, import_obsidian4.normalizePath)(value.trim() || "/vault-sync/");
        await this.plugin.saveSettings();
      })
    );
    new import_obsidian4.Setting(containerEl).setName(this.plugin.t("\u4E0D\u540C\u6B65\u76EE\u5F55", "Excluded sync folders")).setDesc(
      this.plugin.t(
        "\u8FD9\u4E9B vault \u76EE\u5F55\u4E0D\u4F1A\u88AB\u5185\u5BB9\u540C\u6B65\u4E0A\u4F20\u3001\u4ECE\u8FDC\u7AEF\u6062\u590D\u6216\u8FDB\u884C\u76EE\u5F55\u5BF9\u8D26\u3002\u652F\u6301\u9017\u53F7\u6216\u6362\u884C\u5206\u9694\uFF0C\u9ED8\u8BA4\uFF1Akb\u3002",
        "These vault folders are not uploaded, restored from remote, or reconciled as directories. Separate entries with commas or new lines. Default: kb."
      )
    ).addTextArea(
      (text) => text.setPlaceholder("kb").setValue((this.plugin.settings.excludedSyncFolders ?? []).join("\n")).onChange(async (value) => {
        this.plugin.settings.excludedSyncFolders = value.split(/[,\n]/);
        this.plugin.normalizeEffectiveSettings();
        await this.plugin.saveSettings();
      })
    );
    new import_obsidian4.Setting(containerEl).setName(this.plugin.t("\u81EA\u52A8\u540C\u6B65\u9891\u7387", "Auto sync frequency")).setDesc(
      this.plugin.t(
        "\u4EE5\u5206\u949F\u4E3A\u5355\u4F4D\u8BBE\u7F6E\u5B9A\u65F6\u589E\u91CF\u540C\u6B65\u95F4\u9694\u3002\u8BBE\u4E3A 0 \u5173\u95ED\u3002\u4E09\u5411\u5185\u5BB9\u54C8\u5E0C\u5BF9\u6BD4\u4EC5\u540C\u6B65\u53D8\u66F4\u6587\u4EF6\u3002",
        "Set the scheduled incremental sync interval in minutes. Use 0 to turn it off. Three-way content-hash comparison syncs only changed files."
      )
    ).addText(
      (text) => text.setPlaceholder("0").setValue(String(this.plugin.settings.autoSyncIntervalMinutes)).onChange(async (value) => {
        const parsed = Number.parseInt(value, 10);
        if (!Number.isNaN(parsed)) {
          this.plugin.settings.autoSyncIntervalMinutes = Math.max(0, parsed);
          await this.plugin.saveSettings();
        }
      })
    );
    new import_obsidian4.Setting(containerEl).setName(this.plugin.t("\u540C\u6B65\u72B6\u6001", "Sync status")).setDesc(
      this.plugin.t(
        `${this.plugin.formatLastSyncLabel()}
${this.plugin.formatSyncStatusLabel()}
${this.plugin.t("\u8BF4\u660E\uFF1A\u589E\u91CF\u7248\u672C\u540C\u6B65\u4F1A\u5BF9\u6BD4\u672C\u5730\u6587\u4EF6\u3001\u8FDC\u7AEF\u6587\u4EF6\u4E0E\u4E0A\u6B21\u540C\u6B65\u5FEB\u7167\uFF08IndexedDB\uFF09\uFF0C\u57FA\u4E8E\u5185\u5BB9\u54C8\u5E0C\u4E09\u5411\u5BF9\u6BD4\uFF0C\u7CBE\u786E\u8BC6\u522B\u6587\u4EF6\u53D8\u66F4\u5E76\u505A\u51FA\u63A8\u9001/\u62C9\u53D6/\u51B2\u7A81\u5904\u7406\u3002", "Incremental version sync compares local files, remote files, and the previous sync snapshot (IndexedDB) via content-hash three-way comparison, precisely detecting changes and making push/pull/conflict decisions.")}`,
        `${this.plugin.formatLastSyncLabel()}
${this.plugin.formatSyncStatusLabel()}
${this.plugin.t("\u8BF4\u660E\uFF1A\u589E\u91CF\u7248\u672C\u540C\u6B65\u4F1A\u5BF9\u6BD4\u672C\u5730\u6587\u4EF6\u3001\u8FDC\u7AEF\u6587\u4EF6\u4E0E\u4E0A\u6B21\u540C\u6B65\u5FEB\u7167\uFF08IndexedDB\uFF09\uFF0C\u57FA\u4E8E\u5185\u5BB9\u54C8\u5E0C\u4E09\u5411\u5BF9\u6BD4\uFF0C\u7CBE\u786E\u8BC6\u522B\u6587\u4EF6\u53D8\u66F4\u5E76\u505A\u51FA\u63A8\u9001/\u62C9\u53D6/\u51B2\u7A81\u5904\u7406\u3002", "Incremental version sync compares local files, remote files, and the previous sync snapshot (IndexedDB) via content-hash three-way comparison, precisely detecting changes and making push/pull/conflict decisions.")}`
      )
    ).addButton(
      (button) => button.setButtonText(this.plugin.t("\u7ACB\u5373\u540C\u6B65", "Sync now")).onClick(async () => {
        button.setDisabled(true);
        try {
          await this.plugin.syncVaultContent("manual");
          this.display();
        } finally {
          button.setDisabled(false);
        }
      })
    );
    containerEl.createEl("h3", { text: this.plugin.t("\u4E00\u6B21\u6027\u5DE5\u5177", "One-time tools") });
    new import_obsidian4.Setting(containerEl).setName(this.plugin.t("\u8FC1\u79FB\u6574\u5E93\u539F\u751F\u56FE\u7247\u5F15\u7528", "Migrate native image embeds in vault")).setDesc(
      this.plugin.t(
        "\u626B\u63CF\u6574\u5E93\u6240\u6709 Markdown \u7B14\u8BB0\uFF0C\u628A Obsidian \u539F\u751F\u672C\u5730\u56FE\u7247\u5F15\u7528\uFF08\u5982 ![]() \u548C ![[...]]\uFF09\u4E0A\u4F20\u5230\u8FDC\u7AEF\u56FE\u7247\u76EE\u5F55\uFF0C\u5E76\u6539\u5199\u4E3A secure-webdav \u4EE3\u7801\u5757\u3002\u65E7\u7248 span \u548C\u65E9\u671F webdav-secure \u94FE\u63A5\u4E5F\u4F1A\u4E00\u5E76\u6536\u655B\u5230\u65B0\u683C\u5F0F\u3002",
        "Scan all Markdown notes in the vault, upload native local image embeds (such as ![]() and ![[...]]) to the remote image folder, and rewrite them as secure-webdav code blocks. Legacy span tags and early webdav-secure links are also normalized to the new format."
      )
    ).addButton(
      (button) => button.setButtonText(this.plugin.t("\u5F00\u59CB\u8FC1\u79FB", "Run migration")).onClick(async () => {
        button.setDisabled(true);
        try {
          await this.plugin.migrateAllLegacySecureImages();
        } finally {
          button.setDisabled(false);
        }
      })
    );
  }
};
var ResultModal = class extends import_obsidian4.Modal {
  constructor(app, titleText, bodyText) {
    super(app);
    this.titleText = titleText;
    this.bodyText = bodyText;
  }
  async onOpen() {
    const { contentEl } = this;
    contentEl.empty();
    contentEl.createEl("h3", { text: this.titleText });
    contentEl.createEl("pre", { text: this.bodyText });
  }
  onClose() {
    this.contentEl.empty();
  }
};
//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["main.ts", "secure-webdav-image-support.ts", "secure-webdav-upload-queue.ts", "secure-webdav-sync-support.ts"],
  "sourcesContent": ["\uFEFFimport {\n  App,\n  Editor,\n  MarkdownFileInfo,\n  MarkdownView,\n  Modal,\n  Notice,\n  Plugin,\n  PluginSettingTab,\n  Setting,\n  TAbstractFile,\n  TFile,\n  TFolder,\n  normalizePath,\n  requestUrl as obsidianRequestUrl,\n} from \"obsidian\";\nimport { SECURE_CODE_BLOCK, SECURE_PROTOCOL, SecureWebdavImageSupport } from \"./secure-webdav-image-support\";\nimport { SecureWebdavUploadQueueSupport, type UploadTask } from \"./secure-webdav-upload-queue\";\nimport {\n  SecureWebdavSyncSupport,\n  type DeletionTombstone,\n  normalizeFolder,\n} from \"./secure-webdav-sync-support\";\n\ntype SecureWebdavSettings = {\n  webdavUrl: string;\n  username: string;\n  password: string;\n  remoteFolder: string;\n  vaultSyncRemoteFolder: string;\n  excludedSyncFolders: string[];\n  namingStrategy: \"timestamp\" | \"hash\";\n  deleteLocalAfterUpload: boolean;\n  language: \"auto\" | \"zh\" | \"en\";\n  noteStorageMode: \"full-local\" | \"lazy-notes\";\n  noteEvictAfterDays: number;\n  autoSyncIntervalMinutes: number;\n  maxRetryAttempts: number;\n  retryDelaySeconds: number;\n  deleteRemoteWhenUnreferenced: boolean;\n  compressImages: boolean;\n  compressThresholdKb: number;\n  maxImageDimension: number;\n  jpegQuality: number;\n};\n\ntype SyncIndexEntry = {\n  localSignature: string;\n  remoteSignature: string;\n  remotePath: string;\n};\n\ntype RemoteFileState = {\n  remotePath: string;\n  lastModified: number;\n  size: number;\n  signature: string;\n};\n\ntype MissingLazyRemoteRecord = {\n  firstDetectedAt: number;\n  lastDetectedAt: number;\n  missCount: number;\n};\n\ntype PendingDeletionEntry = {\n  remotePath: string;\n  remoteSignature?: string;\n};\n\ntype PendingRenameEntry = {\n  oldPath: string;\n  newPath: string;\n  oldRemotePath: string;\n  oldRemoteSignature?: string;\n  recordedAt: number;\n};\n\ntype RemoteInventory = {\n  files: Map<string, RemoteFileState>;\n  directories: Set<string>;\n};\n\nconst DEFAULT_SETTINGS: SecureWebdavSettings = {\n  webdavUrl: \"\",\n  username: \"\",\n  password: \"\",\n  remoteFolder: \"/remote-images/\",\n  vaultSyncRemoteFolder: \"/vault-sync/\",\n  excludedSyncFolders: [\"kb\"],\n  namingStrategy: \"hash\",\n  deleteLocalAfterUpload: true,\n  language: \"auto\",\n  noteStorageMode: \"full-local\",\n  noteEvictAfterDays: 30,\n  autoSyncIntervalMinutes: 0,\n  maxRetryAttempts: 5,\n  retryDelaySeconds: 5,\n  deleteRemoteWhenUnreferenced: true,\n  compressImages: true,\n  compressThresholdKb: 300,\n  maxImageDimension: 2200,\n  jpegQuality: 82,\n};\n\nconst MIME_MAP: Record<string, string> = {\n  jpg: \"image/jpeg\",\n  jpeg: \"image/jpeg\",\n  png: \"image/png\",\n  gif: \"image/gif\",\n  webp: \"image/webp\",\n  svg: \"image/svg+xml\",\n  bmp: \"image/bmp\",\n  \"image/jpeg\": \"jpg\",\n  \"image/png\": \"png\",\n  \"image/gif\": \"gif\",\n  \"image/webp\": \"webp\",\n  \"image/bmp\": \"bmp\",\n  \"image/svg+xml\": \"svg\",\n};\n\nconst SECURE_NOTE_STUB = \"secure-webdav-note-stub\";\n\nexport default class SecureWebdavImagesPlugin extends Plugin {\n  settings: SecureWebdavSettings = DEFAULT_SETTINGS;\n  queue: UploadTask[] = [];\n  private blobUrls = new Set<string>();\n  private readonly maxBlobUrls = 100;\n  private noteRemoteRefs = new Map<string, Set<string>>();\n  private remoteCleanupInFlight = new Set<string>();\n  private noteAccessTimestamps = new Map<string, number>();\n  private syncIndex = new Map<string, SyncIndexEntry>();\n  private syncedDirectories = new Set<string>();\n  private missingLazyRemoteNotes = new Map<string, MissingLazyRemoteRecord>();\n  private pendingVaultSyncPaths = new Set<string>();\n  private pendingVaultDeletionPaths = new Map<string, PendingDeletionEntry>();\n  private pendingVaultRenamePaths = new Map<string, PendingRenameEntry>();\n  private pendingVaultMutationPromises = new Set<Promise<void>>();\n  private priorityNoteSyncTimeouts = new Map<string, number>();\n  private priorityNoteSyncsInFlight = new Set<string>();\n  private priorityRenameSyncTimeouts = new Map<string, number>();\n  private priorityRenameSyncsInFlight = new Set<string>();\n  private lastVaultSyncAt = 0;\n  private lastVaultSyncStatus = \"\";\n  private syncInProgress = false;\n  private autoSyncTickInProgress = false;\n  // Image parsing and rendering live in a dedicated helper so sync changes\n  // do not accidentally break display behaviour again.\n  private imageSupport!: SecureWebdavImageSupport;\n  // Upload queue state is isolated so retries and placeholder replacement do\n  // not keep sprawling across the main plugin class.\n  private uploadQueue!: SecureWebdavUploadQueueSupport;\n  // Sync metadata helpers are isolated so reconciliation rules stay explicit.\n  private syncSupport!: SecureWebdavSyncSupport;\n\n  private readonly deletionFolderSuffix = \".__secure-webdav-deletions__/\";\n  private readonly missingLazyRemoteConfirmations = 2;\n\n  private initializeSupportModules() {\n    // Keep runtime-only integration here: the image module owns parsing and\n    // rendering, while the plugin still owns WebDAV access and lifecycle.\n    this.imageSupport = new SecureWebdavImageSupport({\n      t: this.t.bind(this),\n      fetchSecureImageBlobUrl: this.fetchSecureImageBlobUrl.bind(this),\n    });\n    this.uploadQueue = new SecureWebdavUploadQueueSupport({\n      app: this.app,\n      t: this.t.bind(this),\n      settings: () => this.settings,\n      getQueue: () => this.queue,\n      setQueue: (queue) => {\n        this.queue = queue;\n      },\n      savePluginState: this.savePluginState.bind(this),\n      schedulePriorityNoteSync: this.schedulePriorityNoteSync.bind(this),\n      requestUrl: this.requestUrl.bind(this),\n      buildUploadUrl: this.buildUploadUrl.bind(this),\n      buildAuthHeader: this.buildAuthHeader.bind(this),\n      prepareUploadPayload: this.prepareUploadPayload.bind(this),\n      buildRemoteFileNameFromBinary: this.buildRemoteFileNameFromBinary.bind(this),\n      buildRemotePath: this.buildRemotePath.bind(this),\n      buildSecureImageMarkup: this.imageSupport.buildSecureImageMarkup.bind(this.imageSupport),\n      getMimeTypeFromFileName: this.getMimeTypeFromFileName.bind(this),\n      arrayBufferToBase64: this.arrayBufferToBase64.bind(this),\n      base64ToArrayBuffer: this.base64ToArrayBuffer.bind(this),\n      escapeHtml: this.escapeHtml.bind(this),\n      escapeRegExp: this.escapeRegExp.bind(this),\n      describeError: this.describeError.bind(this),\n    });\n    this.syncSupport = new SecureWebdavSyncSupport({\n      app: this.app,\n      getVaultSyncRemoteFolder: () => this.settings.vaultSyncRemoteFolder,\n      getExcludedSyncFolders: () => this.settings.excludedSyncFolders ?? [],\n      deletionFolderSuffix: this.deletionFolderSuffix,\n      encodeBase64Url: (value) =>\n        this.arrayBufferToBase64(this.encodeUtf8(value)).replace(/\\+/g, \"-\").replace(/\\//g, \"_\").replace(/=+$/g, \"\"),\n      decodeBase64Url: (value) => {\n        const normalized = value.replace(/-/g, \"+\").replace(/_/g, \"/\");\n        const padded = normalized + \"=\".repeat((4 - (normalized.length % 4 || 4)) % 4);\n        return this.decodeUtf8(this.base64ToArrayBuffer(padded));\n      },\n    });\n  }\n\n  async onload() {\n    await this.loadPluginState();\n    this.initializeSupportModules();\n\n    this.addSettingTab(new SecureWebdavSettingTab(this.app, this));\n\n    this.addCommand({\n      id: \"upload-current-note-local-images\",\n      name: \"Upload local images in current note to WebDAV\",\n      checkCallback: (checking) => {\n        const file = this.app.workspace.getActiveFile();\n        if (!file) {\n          return false;\n        }\n\n        if (!checking) {\n          void this.uploadImagesInNote(file);\n        }\n\n        return true;\n      },\n    });\n\n    this.addCommand({\n      id: \"test-webdav-connection\",\n      name: \"Test WebDAV connection\",\n      callback: () => {\n        void this.runConnectionTest(true);\n      },\n    });\n\n    this.addCommand({\n      id: \"sync-configured-vault-content-to-webdav\",\n      name: \"Fast sync changed vault content to WebDAV\",\n      callback: () => {\n        void this.runManualSync();\n      },\n    });\n\n    this.addCommand({\n      id: \"full-reconcile-vault-content-to-webdav\",\n      name: \"Full reconcile vault content with WebDAV\",\n      callback: () => {\n        void this.runFullReconcileSync();\n      },\n    });\n\n    const fastSyncRibbon = this.addRibbonIcon(\"zap\", this.t(\"\u5FEB\u901F\u540C\u6B65\u5230 WebDAV\", \"Fast sync to WebDAV\"), () => {\n      void this.runManualSync();\n    });\n    fastSyncRibbon.addClass(\"secure-webdav-sync-ribbon\");\n    fastSyncRibbon.addClass(\"secure-webdav-fast-sync-ribbon\");\n\n    const fullSyncRibbon = this.addRibbonIcon(\"refresh-cw\", this.t(\"\u5B8C\u6574\u540C\u6B65\u5230 WebDAV\", \"Full sync to WebDAV\"), () => {\n      void this.runFullReconcileSync();\n    });\n    fullSyncRibbon.addClass(\"secure-webdav-sync-ribbon\");\n    fullSyncRibbon.addClass(\"secure-webdav-full-sync-ribbon\");\n\n    this.registerMarkdownPostProcessor((el, ctx) => {\n      void this.imageSupport.processSecureImages(el, ctx);\n    });\n    try {\n      this.registerMarkdownCodeBlockProcessor(SECURE_CODE_BLOCK, (source, el, ctx) => {\n        void this.imageSupport.processSecureCodeBlock(source, el, ctx);\n      });\n    } catch {\n      console.warn(\"[secure-webdav-images] code block processor already registered, skipping\");\n    }\n\n    this.registerEvent(\n      this.app.workspace.on(\"file-open\", (file) => {\n        void this.handleFileOpen(file);\n      }),\n    );\n\n    this.registerEvent(\n      this.app.workspace.on(\"editor-paste\", (evt, editor, info) => {\n        void this.handleEditorPaste(evt, editor, info);\n      }),\n    );\n\n    this.registerEvent(\n      this.app.workspace.on(\"editor-drop\", (evt, editor, info) => {\n        void this.handleEditorDrop(evt, editor, info);\n      }),\n    );\n\n    await this.rebuildReferenceIndex();\n    this.registerEvent(this.app.vault.on(\"modify\", (file) => this.trackVaultMutation(() => this.handleVaultModify(file))));\n    this.registerEvent(this.app.vault.on(\"delete\", (file) => this.trackVaultMutation(() => this.handleVaultDelete(file))));\n    this.registerEvent(\n      this.app.vault.on(\"rename\", (file, oldPath) => this.trackVaultMutation(() => this.handleVaultRename(file, oldPath))),\n    );\n\n    this.setupAutoSync();\n\n    void this.uploadQueue.processPendingTasks();\n\n    this.register(() => {\n      for (const blobUrl of this.blobUrls) {\n        URL.revokeObjectURL(blobUrl);\n      }\n      this.blobUrls.clear();\n      for (const timeoutId of this.priorityNoteSyncTimeouts.values()) {\n        window.clearTimeout(timeoutId);\n      }\n      this.priorityNoteSyncTimeouts.clear();\n      for (const timeoutId of this.priorityRenameSyncTimeouts.values()) {\n        window.clearTimeout(timeoutId);\n      }\n      this.priorityRenameSyncTimeouts.clear();\n      this.uploadQueue.dispose();\n    });\n  }\n\n  onunload() {\n    for (const blobUrl of this.blobUrls) {\n      URL.revokeObjectURL(blobUrl);\n    }\n    this.blobUrls.clear();\n    this.uploadQueue?.dispose();\n    for (const timeoutId of this.priorityNoteSyncTimeouts.values()) {\n      window.clearTimeout(timeoutId);\n    }\n    this.priorityNoteSyncTimeouts.clear();\n    for (const timeoutId of this.priorityRenameSyncTimeouts.values()) {\n      window.clearTimeout(timeoutId);\n    }\n    this.priorityRenameSyncTimeouts.clear();\n  }\n\n  async loadPluginState() {\n    const loaded = await this.loadData();\n    if (!loaded || typeof loaded !== \"object\") {\n      this.settings = { ...DEFAULT_SETTINGS };\n      this.queue = [];\n      this.noteAccessTimestamps = new Map();\n      this.syncIndex = new Map();\n      this.syncedDirectories = new Set();\n      this.missingLazyRemoteNotes = new Map();\n      this.pendingVaultSyncPaths = new Set();\n      this.pendingVaultDeletionPaths = new Map();\n      this.pendingVaultRenamePaths = new Map();\n      return;\n    }\n\n    const candidate = loaded as Record<string, unknown>;\n    if (\"settings\" in candidate || \"queue\" in candidate) {\n      this.settings = { ...DEFAULT_SETTINGS, ...((candidate.settings as Partial<SecureWebdavSettings>) ?? {}) };\n      this.queue = Array.isArray(candidate.queue) ? (candidate.queue as UploadTask[]) : [];\n      this.noteAccessTimestamps = new Map(\n        Object.entries((candidate.noteAccessTimestamps as Record<string, number> | undefined) ?? {}),\n      );\n      this.missingLazyRemoteNotes = new Map(\n        Object.entries((candidate.missingLazyRemoteNotes as Record<string, MissingLazyRemoteRecord> | undefined) ?? {})\n          .filter(([, value]) => {\n            if (!value || typeof value !== \"object\") {\n              return false;\n            }\n            const record = value as Record<string, unknown>;\n            return (\n              typeof record.firstDetectedAt === \"number\" &&\n              typeof record.lastDetectedAt === \"number\" &&\n              typeof record.missCount === \"number\"\n            );\n          })\n          .map(([path, value]) => [path, value as MissingLazyRemoteRecord]),\n      );\n      this.pendingVaultSyncPaths = new Set(\n        Array.isArray(candidate.pendingVaultSyncPaths)\n          ? candidate.pendingVaultSyncPaths.filter((path): path is string => typeof path === \"string\")\n          : [],\n      );\n      this.pendingVaultDeletionPaths = new Map();\n      for (const [path, rawEntry] of Object.entries((candidate.pendingVaultDeletionPaths as Record<string, unknown> | undefined) ?? {})) {\n        if (!rawEntry || typeof rawEntry !== \"object\") {\n          continue;\n        }\n        const entry = rawEntry as Record<string, unknown>;\n        const remotePath = typeof entry.remotePath === \"string\" && entry.remotePath.length > 0\n          ? entry.remotePath\n          : `${this.normalizeFolder(this.settings.vaultSyncRemoteFolder)}${path}`;\n        const remoteSignature = typeof entry.remoteSignature === \"string\" ? entry.remoteSignature : undefined;\n        this.pendingVaultDeletionPaths.set(path, { remotePath, remoteSignature });\n      }\n      this.pendingVaultRenamePaths = new Map();\n      for (const [oldPath, rawEntry] of Object.entries((candidate.pendingVaultRenamePaths as Record<string, unknown> | undefined) ?? {})) {\n        if (!rawEntry || typeof rawEntry !== \"object\") {\n          continue;\n        }\n        const entry = rawEntry as Record<string, unknown>;\n        const newPath = typeof entry.newPath === \"string\" ? entry.newPath : \"\";\n        if (!newPath) {\n          continue;\n        }\n        const oldRemotePath = typeof entry.oldRemotePath === \"string\" && entry.oldRemotePath.length > 0\n          ? entry.oldRemotePath\n          : `${this.normalizeFolder(this.settings.vaultSyncRemoteFolder)}${oldPath}`;\n        const oldRemoteSignature = typeof entry.oldRemoteSignature === \"string\" ? entry.oldRemoteSignature : undefined;\n        const recordedAt = typeof entry.recordedAt === \"number\" ? entry.recordedAt : Date.now();\n        this.pendingVaultRenamePaths.set(oldPath, {\n          oldPath,\n          newPath,\n          oldRemotePath,\n          oldRemoteSignature,\n          recordedAt,\n        });\n      }\n      this.syncIndex = new Map();\n      for (const [path, rawEntry] of Object.entries((candidate.syncIndex as Record<string, unknown> | undefined) ?? {})) {\n        const normalized = this.normalizeSyncIndexEntry(path, rawEntry);\n        if (normalized) {\n          this.syncIndex.set(path, normalized);\n        }\n      }\n      this.lastVaultSyncAt =\n        typeof candidate.lastVaultSyncAt === \"number\" ? candidate.lastVaultSyncAt : 0;\n      this.lastVaultSyncStatus =\n        typeof candidate.lastVaultSyncStatus === \"string\" ? candidate.lastVaultSyncStatus : \"\";\n      this.syncedDirectories = new Set(\n        Array.isArray(candidate.syncedDirectories) ? candidate.syncedDirectories as string[] : [],\n      );\n      this.normalizeEffectiveSettings();\n      return;\n    }\n\n    this.settings = { ...DEFAULT_SETTINGS, ...(candidate as Partial<SecureWebdavSettings>) };\n    this.queue = [];\n    this.noteAccessTimestamps = new Map();\n    this.syncIndex = new Map();\n    this.syncedDirectories = new Set();\n    this.missingLazyRemoteNotes = new Map();\n    this.pendingVaultSyncPaths = new Set();\n    this.pendingVaultDeletionPaths = new Map();\n    this.pendingVaultRenamePaths = new Map();\n    this.lastVaultSyncAt = 0;\n    this.lastVaultSyncStatus = \"\";\n    this.normalizeEffectiveSettings();\n  }\n\n  private normalizeEffectiveSettings() {\n    // Keep the public settings surface intentionally small and deterministic.\n    this.settings.deleteLocalAfterUpload = true;\n    this.settings.autoSyncIntervalMinutes = Math.max(0, Math.floor(this.settings.autoSyncIntervalMinutes || 0));\n    const rawExcluded = this.settings.excludedSyncFolders as unknown;\n    const excluded = Array.isArray(rawExcluded)\n      ? rawExcluded\n      : typeof rawExcluded === \"string\"\n        ? rawExcluded.split(/[,\\n]/)\n        : DEFAULT_SETTINGS.excludedSyncFolders;\n    this.settings.excludedSyncFolders = [\n      ...new Set(\n        excluded\n          .map((value) => normalizePath(String(value).trim()).replace(/^\\/+/, \"\").replace(/\\/+$/, \"\"))\n          .filter((value) => value.length > 0),\n      ),\n    ];\n  }\n\n  private normalizeFolder(input: string) {\n    return normalizeFolder(input);\n  }\n\n  private setupAutoSync() {\n    const minutes = this.settings.autoSyncIntervalMinutes;\n    if (minutes <= 0) {\n      return;\n    }\n\n    const intervalMs = minutes * 60 * 1000;\n    this.registerInterval(\n      window.setInterval(() => {\n        void this.runAutoSyncTick();\n      }, intervalMs),\n    );\n  }\n\n  private async runAutoSyncTick() {\n    if (this.autoSyncTickInProgress) {\n      return;\n    }\n\n    this.autoSyncTickInProgress = true;\n    try {\n      await this.syncConfiguredVaultContent(false);\n    } finally {\n      this.autoSyncTickInProgress = false;\n    }\n  }\n\n  async savePluginState() {\n    await this.saveData({\n      settings: this.settings,\n      queue: this.queue,\n      noteAccessTimestamps: Object.fromEntries(this.noteAccessTimestamps.entries()),\n      missingLazyRemoteNotes: Object.fromEntries(this.missingLazyRemoteNotes.entries()),\n      pendingVaultSyncPaths: [...this.pendingVaultSyncPaths],\n      pendingVaultDeletionPaths: Object.fromEntries(this.pendingVaultDeletionPaths.entries()),\n      pendingVaultRenamePaths: Object.fromEntries(this.pendingVaultRenamePaths.entries()),\n      syncIndex: Object.fromEntries(this.syncIndex.entries()),\n      syncedDirectories: [...this.syncedDirectories],\n      lastVaultSyncAt: this.lastVaultSyncAt,\n      lastVaultSyncStatus: this.lastVaultSyncStatus,\n    });\n  }\n\n  async saveSettings() {\n    await this.savePluginState();\n  }\n\n  private normalizeSyncIndexEntry(vaultPath: string, rawEntry: unknown): SyncIndexEntry | null {\n    if (!rawEntry || typeof rawEntry !== \"object\") {\n      return null;\n    }\n\n    const candidate = rawEntry as Record<string, unknown>;\n    const remotePath =\n      typeof candidate.remotePath === \"string\" && candidate.remotePath.length > 0\n        ? candidate.remotePath\n        : this.syncSupport.buildVaultSyncRemotePath(vaultPath);\n    const localSignature =\n      typeof candidate.localSignature === \"string\"\n        ? candidate.localSignature\n        : typeof candidate.signature === \"string\"\n          ? candidate.signature\n          : \"\";\n    const remoteSignature =\n      typeof candidate.remoteSignature === \"string\"\n        ? candidate.remoteSignature\n        : typeof candidate.signature === \"string\"\n          ? candidate.signature\n          : \"\";\n\n    return {\n      localSignature,\n      remoteSignature,\n      remotePath,\n    };\n  }\n\n  t(zh: string, en: string) {\n    return this.getLanguage() === \"zh\" ? zh : en;\n  }\n\n  private getLanguage() {\n    if (this.settings.language === \"auto\") {\n      const locale = typeof navigator !== \"undefined\" ? navigator.language.toLowerCase() : \"en\";\n      return locale.startsWith(\"zh\") ? \"zh\" : \"en\";\n    }\n\n    return this.settings.language;\n  }\n\n  formatLastSyncLabel() {\n    if (!this.lastVaultSyncAt) {\n      return this.t(\"\u4E0A\u6B21\u540C\u6B65\uFF1A\u5C1A\u672A\u6267\u884C\", \"Last sync: not run yet\");\n    }\n\n    return this.t(\n      `\u4E0A\u6B21\u540C\u6B65\uFF1A${new Date(this.lastVaultSyncAt).toLocaleString()}`,\n      `Last sync: ${new Date(this.lastVaultSyncAt).toLocaleString()}`,\n    );\n  }\n\n  formatSyncStatusLabel() {\n    return this.lastVaultSyncStatus\n      ? this.t(`\u6700\u8FD1\u72B6\u6001\uFF1A${this.lastVaultSyncStatus}`, `Recent status: ${this.lastVaultSyncStatus}`)\n      : this.t(\"\u6700\u8FD1\u72B6\u6001\uFF1A\u6682\u65E0\", \"Recent status: none\");\n  }\n\n  async runManualSync() {\n    await this.syncPendingVaultContent(true);\n  }\n\n  async runFullReconcileSync() {\n    await this.syncConfiguredVaultContent(true);\n  }\n\n  private async rebuildReferenceIndex() {\n    const next = new Map<string, Set<string>>();\n    for (const file of this.app.vault.getMarkdownFiles()) {\n      const content = await this.app.vault.read(file);\n      next.set(file.path, this.extractRemotePathsFromText(content));\n    }\n    this.noteRemoteRefs = next;\n  }\n\n  private async handleVaultModify(file: TAbstractFile) {\n    if (!(file instanceof TFile)) {\n      return;\n    }\n\n    this.markPendingVaultSync(file.path);\n\n    if (file.extension === \"md\") {\n      const content = await this.app.vault.read(file);\n      const nextRefs = this.extractRemotePathsFromText(content);\n      const previousRefs = this.noteRemoteRefs.get(file.path) ?? new Set<string>();\n      this.noteRemoteRefs.set(file.path, nextRefs);\n\n      const added = [...nextRefs].filter((value) => !previousRefs.has(value));\n      const removed = [...previousRefs].filter((value) => !nextRefs.has(value));\n      if (added.length > 0) {\n        this.schedulePriorityNoteSync(file.path, \"image-add\");\n      }\n      if (removed.length > 0) {\n        this.schedulePriorityNoteSync(file.path, \"image-remove\");\n      }\n    }\n\n    await this.savePluginState();\n  }\n\n  private async handleVaultDelete(file: TAbstractFile) {\n    if (!(file instanceof TFile)) {\n      return;\n    }\n\n    if (!this.syncSupport.shouldSkipContentSyncPath(file.path)) {\n      this.markPendingVaultDeletion(file.path);\n      this.syncIndex.delete(file.path);\n      await this.savePluginState();\n    }\n\n    if (file.extension === \"md\") {\n      this.noteRemoteRefs.delete(file.path);\n    }\n  }\n\n  private async handleVaultRename(file: TAbstractFile, oldPath: string) {\n    if (!(file instanceof TFile)) {\n      return;\n    }\n\n    if (!this.syncSupport.shouldSkipContentSyncPath(oldPath)) {\n      const trackedOldPath = this.recordPendingVaultRename(oldPath, file.path);\n      this.markPendingVaultDeletion(oldPath);\n      this.syncIndex.delete(oldPath);\n      await this.savePluginState();\n      this.schedulePriorityRenameSync(trackedOldPath);\n    }\n\n    if (!this.syncSupport.shouldSkipContentSyncPath(file.path)) {\n      this.markPendingVaultSync(file.path);\n      await this.savePluginState();\n    }\n\n    if (file.extension === \"md\") {\n      const refs = this.noteRemoteRefs.get(oldPath);\n      if (refs) {\n        this.noteRemoteRefs.delete(oldPath);\n        this.noteRemoteRefs.set(file.path, refs);\n      }\n\n      if (!this.syncSupport.shouldSkipContentSyncPath(file.path)) {\n        this.schedulePriorityNoteSync(file.path, \"image-add\");\n      }\n    }\n  }\n\n  private markPendingVaultSync(path: string) {\n    if (this.syncSupport.shouldSkipContentSyncPath(path)) {\n      this.pendingVaultSyncPaths.delete(path);\n      return;\n    }\n\n    this.pendingVaultDeletionPaths.delete(path);\n    this.pendingVaultSyncPaths.add(path);\n  }\n\n  private markPendingVaultDeletion(path: string) {\n    if (this.syncSupport.shouldSkipContentSyncPath(path)) {\n      this.pendingVaultSyncPaths.delete(path);\n      this.pendingVaultDeletionPaths.delete(path);\n      return;\n    }\n\n    const existing = this.syncIndex.get(path);\n    this.pendingVaultSyncPaths.delete(path);\n    this.pendingVaultDeletionPaths.set(path, {\n      remotePath: existing?.remotePath ?? this.syncSupport.buildVaultSyncRemotePath(path),\n      remoteSignature: existing?.remoteSignature,\n    });\n  }\n\n  private findPendingVaultRenameByNewPath(newPath: string) {\n    return [...this.pendingVaultRenamePaths.values()].find((entry) => entry.newPath === newPath) ?? null;\n  }\n\n  private recordPendingVaultRename(oldPath: string, newPath: string) {\n    const normalizedOldPath = normalizePath(oldPath);\n    const normalizedNewPath = normalizePath(newPath);\n    const existing = this.findPendingVaultRenameByNewPath(normalizedOldPath);\n    const previous = existing ?? this.pendingVaultRenamePaths.get(normalizedOldPath) ?? null;\n    if (existing) {\n      this.pendingVaultRenamePaths.delete(existing.oldPath);\n    }\n\n    const indexed = this.syncIndex.get(normalizedOldPath);\n    const trackedOldPath = previous?.oldPath ?? normalizedOldPath;\n    const oldRemotePath = previous?.oldRemotePath ?? indexed?.remotePath ?? this.syncSupport.buildVaultSyncRemotePath(normalizedOldPath);\n    const oldRemoteSignature = previous?.oldRemoteSignature ?? indexed?.remoteSignature;\n    const recordedAt = previous?.recordedAt ?? Date.now();\n\n    this.pendingVaultRenamePaths.set(trackedOldPath, {\n      oldPath: trackedOldPath,\n      newPath: normalizedNewPath,\n      oldRemotePath,\n      oldRemoteSignature,\n      recordedAt,\n    });\n    return trackedOldPath;\n  }\n\n  private extractRemotePathsFromText(content: string) {\n    const refs = new Set<string>();\n    const spanRegex = /data-secure-webdav=\"([^\"]+)\"/g;\n    const protocolRegex = /webdav-secure:\\/\\/([^\\s)\"]+)/g;\n    const codeBlockRegex = /```secure-webdav\\s+([\\s\\S]*?)```/g;\n    let match: RegExpExecArray | null;\n\n    while ((match = spanRegex.exec(content)) !== null) {\n      refs.add(this.unescapeHtml(match[1]));\n    }\n\n    while ((match = protocolRegex.exec(content)) !== null) {\n      refs.add(this.unescapeHtml(match[1]));\n    }\n\n    while ((match = codeBlockRegex.exec(content)) !== null) {\n      const parsed = this.imageSupport.parseSecureImageBlock(match[1]);\n      if (parsed?.path) {\n        refs.add(parsed.path);\n      }\n    }\n\n    return refs;\n  }\n\n  private schedulePriorityNoteSync(notePath: string, reason: \"image-add\" | \"image-remove\") {\n    const existing = this.priorityNoteSyncTimeouts.get(notePath);\n    if (existing) {\n      window.clearTimeout(existing);\n    }\n\n    const delayMs = reason === \"image-add\" ? 1200 : 600;\n    const timeoutId = window.setTimeout(() => {\n      this.priorityNoteSyncTimeouts.delete(notePath);\n      void this.flushPriorityNoteSync(notePath, reason);\n    }, delayMs);\n    this.priorityNoteSyncTimeouts.set(notePath, timeoutId);\n  }\n\n  private async flushPriorityNoteSync(notePath: string, reason: \"image-add\" | \"image-remove\") {\n    if (this.priorityNoteSyncsInFlight.has(notePath)) {\n      return;\n    }\n\n    if (\n      this.uploadQueue.hasPendingWorkForNote(notePath) ||\n      this.pendingVaultMutationPromises.size > 0 ||\n      this.syncInProgress ||\n      this.autoSyncTickInProgress\n    ) {\n      this.schedulePriorityNoteSync(notePath, reason);\n      return;\n    }\n\n    const file = this.getVaultFileByPath(notePath);\n    if (!(file instanceof TFile) || file.extension !== \"md\" || this.syncSupport.shouldSkipContentSyncPath(file.path)) {\n      return;\n    }\n\n    this.priorityNoteSyncsInFlight.add(notePath);\n    try {\n      this.ensureConfigured();\n\n      const content = await this.readMarkdownContentPreferEditor(file);\n      if (this.parseNoteStub(content)) {\n        return;\n      }\n\n      const remotePath = this.syncSupport.buildVaultSyncRemotePath(file.path);\n      const uploadedRemote = await this.uploadContentFileToRemote(file, remotePath, content);\n      this.syncIndex.set(file.path, {\n        localSignature: await this.buildCurrentLocalSignature(file, content),\n        remoteSignature: uploadedRemote.signature,\n        remotePath,\n      });\n      this.pendingVaultSyncPaths.delete(file.path);\n      await this.deleteDeletionTombstone(file.path);\n      this.lastVaultSyncAt = Date.now();\n      this.lastVaultSyncStatus = this.t(\n        reason === \"image-add\"\n          ? `\u5DF2\u4F18\u5148\u540C\u6B65\u56FE\u7247\u65B0\u589E\u540E\u7684\u7B14\u8BB0\uFF1A${file.basename}`\n          : `\u5DF2\u4F18\u5148\u540C\u6B65\u56FE\u7247\u5220\u9664\u540E\u7684\u7B14\u8BB0\uFF1A${file.basename}`,\n        reason === \"image-add\"\n          ? `Prioritized note sync finished after image add: ${file.basename}`\n          : `Prioritized note sync finished after image removal: ${file.basename}`,\n      );\n      await this.savePluginState();\n    } catch (error) {\n      console.error(\"Priority note sync failed\", error);\n      this.lastVaultSyncAt = Date.now();\n      this.lastVaultSyncStatus = this.describeError(\n        this.t(\n          reason === \"image-add\" ? \"\u56FE\u7247\u65B0\u589E\u540E\u7684\u7B14\u8BB0\u4F18\u5148\u540C\u6B65\u5931\u8D25\" : \"\u56FE\u7247\u5220\u9664\u540E\u7684\u7B14\u8BB0\u4F18\u5148\u540C\u6B65\u5931\u8D25\",\n          reason === \"image-add\" ? \"Priority note sync after image add failed\" : \"Priority note sync after image removal failed\",\n        ),\n        error,\n      );\n      await this.savePluginState();\n      this.schedulePriorityNoteSync(notePath, reason);\n    } finally {\n      this.priorityNoteSyncsInFlight.delete(notePath);\n    }\n  }\n\n  private schedulePriorityRenameSync(oldPath: string) {\n    const existing = this.priorityRenameSyncTimeouts.get(oldPath);\n    if (existing) {\n      window.clearTimeout(existing);\n    }\n\n    const timeoutId = window.setTimeout(() => {\n      this.priorityRenameSyncTimeouts.delete(oldPath);\n      void this.flushPriorityRenameSync(oldPath);\n    }, 700);\n    this.priorityRenameSyncTimeouts.set(oldPath, timeoutId);\n  }\n\n  private async flushPriorityRenameSync(oldPath: string) {\n    if (this.priorityRenameSyncsInFlight.has(oldPath)) {\n      return;\n    }\n\n    if (\n      this.pendingVaultMutationPromises.size > 0 ||\n      this.uploadQueue.hasPendingWork() ||\n      this.syncInProgress ||\n      this.autoSyncTickInProgress\n    ) {\n      this.schedulePriorityRenameSync(oldPath);\n      return;\n    }\n\n    if (!this.pendingVaultRenamePaths.has(oldPath)) {\n      return;\n    }\n\n    this.priorityRenameSyncsInFlight.add(oldPath);\n    const counts = { uploaded: 0, deletedRemoteFiles: 0, skipped: 0 };\n    try {\n      this.ensureConfigured();\n      await this.processPendingVaultRenames(counts, [oldPath]);\n      if (counts.uploaded > 0 || counts.deletedRemoteFiles > 0) {\n        this.lastVaultSyncAt = Date.now();\n        this.lastVaultSyncStatus = this.t(\n          `\u5DF2\u4F18\u5148\u540C\u6B65\u91CD\u547D\u540D/\u79FB\u52A8\uFF1A\u4E0A\u4F20 ${counts.uploaded} \u4E2A\u6587\u4EF6\uFF0C\u5220\u9664\u8FDC\u7AEF\u65E7\u8DEF\u5F84 ${counts.deletedRemoteFiles} \u4E2A\u3002`,\n          `Prioritized rename/move sync uploaded ${counts.uploaded} file(s) and deleted ${counts.deletedRemoteFiles} stale remote path(s).`,\n        );\n        await this.savePluginState();\n      }\n    } catch (error) {\n      console.error(\"Priority rename sync failed\", error);\n      this.lastVaultSyncAt = Date.now();\n      this.lastVaultSyncStatus = this.describeError(\n        this.t(\"\u91CD\u547D\u540D/\u79FB\u52A8\u540E\u7684\u4F18\u5148\u540C\u6B65\u5931\u8D25\", \"Priority sync after rename/move failed\"),\n        error,\n      );\n      await this.savePluginState();\n      this.schedulePriorityRenameSync(oldPath);\n    } finally {\n      this.priorityRenameSyncsInFlight.delete(oldPath);\n    }\n  }\n\n\n  private async buildUploadReplacements(content: string, noteFile: TFile, uploadCache?: Map<string, string>) {\n    const seen = new Map<string, UploadRewrite>();\n    const wikiMatches = [...content.matchAll(/!\\[\\[([^\\]]+)\\]\\]/g)];\n    const markdownMatches = [...content.matchAll(/!\\[[^\\]]*]\\(([^)]+)\\)/g)];\n    const htmlImageMatches = [...content.matchAll(/<img\\b[^>]*src=[\"']([^\"']+)[\"'][^>]*>/gi)];\n\n    for (const match of wikiMatches) {\n      const rawLink = match[1].split(\"|\")[0].trim();\n      const file = this.resolveLinkedFile(rawLink, noteFile.path);\n      if (!file || !this.isImageFile(file)) {\n        continue;\n      }\n\n      if (!seen.has(match[0])) {\n        const remoteUrl = await this.uploadVaultFile(file, uploadCache);\n        seen.set(match[0], {\n          original: match[0],\n          rewritten: this.imageSupport.buildSecureImageMarkup(remoteUrl, file.basename),\n          sourceFile: file,\n        });\n      }\n    }\n\n    for (const match of markdownMatches) {\n      const rawLink = decodeURIComponent(match[1].trim().replace(/^<|>$/g, \"\"));\n      if (/^(webdav-secure:|data:)/i.test(rawLink)) {\n        continue;\n      }\n\n      if (this.isHttpUrl(rawLink)) {\n        if (!seen.has(match[0])) {\n          try {\n            const remoteUrl = await this.uploadRemoteImageUrl(rawLink, uploadCache);\n            const altText = this.extractMarkdownAltText(match[0]) || this.getDisplayNameFromUrl(rawLink);\n            seen.set(match[0], {\n              original: match[0],\n              rewritten: this.imageSupport.buildSecureImageMarkup(remoteUrl, altText),\n            });\n          } catch (e: any) {\n            console.warn(`[secure-webdav-images] \u8DF3\u8FC7\u5931\u8D25\u7684\u8FDC\u7A0B\u56FE\u7247 ${rawLink}`, e?.message);\n          }\n        }\n        continue;\n      }\n\n      const file = this.resolveLinkedFile(rawLink, noteFile.path);\n      if (!file || !this.isImageFile(file)) {\n        continue;\n      }\n\n      if (!seen.has(match[0])) {\n        const remoteUrl = await this.uploadVaultFile(file, uploadCache);\n        seen.set(match[0], {\n          original: match[0],\n          rewritten: this.imageSupport.buildSecureImageMarkup(remoteUrl, file.basename),\n          sourceFile: file,\n        });\n      }\n    }\n\n    for (const match of htmlImageMatches) {\n      const rawLink = this.unescapeHtml(match[1].trim());\n      if (!this.isHttpUrl(rawLink) || seen.has(match[0])) {\n        continue;\n      }\n\n      try {\n        const remoteUrl = await this.uploadRemoteImageUrl(rawLink, uploadCache);\n        const altText = this.extractHtmlImageAltText(match[0]) || this.getDisplayNameFromUrl(rawLink);\n        seen.set(match[0], {\n          original: match[0],\n          rewritten: this.imageSupport.buildSecureImageMarkup(remoteUrl, altText),\n        });\n      } catch (e: any) {\n        console.warn(`[secure-webdav-images] \u8DF3\u8FC7\u5931\u8D25\u7684\u8FDC\u7A0B\u56FE\u7247 ${rawLink}`, e?.message);\n      }\n    }\n\n    return [...seen.values()];\n  }\n\n  private extractMarkdownAltText(markdownImage: string) {\n    const match = markdownImage.match(/^!\\[([^\\]]*)\\]/);\n    return match?.[1]?.trim() ?? \"\";\n  }\n\n  private extractHtmlImageAltText(htmlImage: string) {\n    const match = htmlImage.match(/\\balt=[\"']([^\"']*)[\"']/i);\n    return match ? this.unescapeHtml(match[1].trim()) : \"\";\n  }\n\n  private isHttpUrl(value: string) {\n    return /^https?:\\/\\//i.test(value);\n  }\n\n  private getDisplayNameFromUrl(rawUrl: string) {\n    try {\n      const url = new URL(rawUrl);\n      const fileName = this.sanitizeFileName(url.pathname.split(\"/\").pop() || \"\");\n      if (fileName) {\n        return fileName.replace(/\\.[^.]+$/, \"\");\n      }\n    } catch {\n      // Fall through to the generic label below.\n    }\n\n    return this.t(\"\u7F51\u9875\u56FE\u7247\", \"Web image\");\n  }\n\n  private resolveLinkedFile(link: string, sourcePath: string): TFile | null {\n    const cleaned = link.replace(/#.*/, \"\").trim();\n    const target = this.app.metadataCache.getFirstLinkpathDest(cleaned, sourcePath);\n    return target instanceof TFile ? target : null;\n  }\n\n  private isImageFile(file: TFile) {\n    return /^(png|jpe?g|gif|webp|bmp|svg)$/i.test(file.extension);\n  }\n\n  private async uploadVaultFile(file: TFile, uploadCache?: Map<string, string>) {\n    if (uploadCache?.has(file.path)) {\n      return uploadCache.get(file.path)!;\n    }\n\n    this.ensureConfigured();\n    const binary = await this.app.vault.readBinary(file);\n    const prepared = await this.prepareUploadPayload(binary, this.getMimeType(file.extension), file.name);\n    const remoteName = await this.buildRemoteFileNameFromBinary(prepared.fileName, prepared.binary);\n    const remotePath = this.buildRemotePath(remoteName);\n    await this.uploadBinary(remotePath, prepared.binary, prepared.mimeType);\n    const remoteUrl = `${SECURE_PROTOCOL}//${remotePath}`;\n    uploadCache?.set(file.path, remoteUrl);\n    return remoteUrl;\n  }\n\n  private async uploadRemoteImageUrl(imageUrl: string, uploadCache?: Map<string, string>) {\n    const cacheKey = `remote:${imageUrl}`;\n    if (uploadCache?.has(cacheKey)) {\n      return uploadCache.get(cacheKey)!;\n    }\n\n    this.ensureConfigured();\n    const response = await this.requestUrl({\n      url: imageUrl,\n      method: \"GET\",\n      followRedirects: true,\n    });\n\n    this.assertResponseSuccess(response, \"Remote image download\");\n\n    const contentType = response.headers[\"content-type\"] ?? \"\";\n    if (!this.isImageContentType(contentType) && !this.looksLikeImageUrl(imageUrl)) {\n      throw new Error(this.t(\"\u8FDC\u7A0B\u94FE\u63A5\u4E0D\u662F\u53EF\u8BC6\u522B\u7684\u56FE\u7247\u8D44\u6E90\u3002\", \"The remote URL does not look like an image resource.\"));\n    }\n\n    const fileName = this.buildRemoteSourceFileName(imageUrl, contentType);\n    const prepared = await this.prepareUploadPayload(\n      response.arrayBuffer,\n      this.normalizeImageMimeType(contentType, fileName),\n      fileName,\n    );\n    const remoteName = await this.buildRemoteFileNameFromBinary(prepared.fileName, prepared.binary);\n    const remotePath = this.buildRemotePath(remoteName);\n    await this.uploadBinary(remotePath, prepared.binary, prepared.mimeType);\n    const remoteUrl = `${SECURE_PROTOCOL}//${remotePath}`;\n    uploadCache?.set(cacheKey, remoteUrl);\n    return remoteUrl;\n  }\n\n  private isImageContentType(contentType: string) {\n    return /^image\\//i.test(contentType.trim());\n  }\n\n  private looksLikeImageUrl(rawUrl: string) {\n    try {\n      const url = new URL(rawUrl);\n      return /\\.(png|jpe?g|gif|webp|bmp|svg)$/i.test(url.pathname);\n    } catch {\n      return false;\n    }\n  }\n\n  private buildRemoteSourceFileName(rawUrl: string, contentType: string) {\n    try {\n      const url = new URL(rawUrl);\n      const candidate = this.sanitizeFileName(url.pathname.split(\"/\").pop() || \"\");\n      if (candidate && /\\.[a-z0-9]+$/i.test(candidate)) {\n        return candidate;\n      }\n\n      const extension = this.getExtensionFromMimeType(contentType) || \"png\";\n      return candidate ? `${candidate}.${extension}` : `remote-image.${extension}`;\n    } catch {\n      const extension = this.getExtensionFromMimeType(contentType) || \"png\";\n      return `remote-image.${extension}`;\n    }\n  }\n\n  private sanitizeFileName(fileName: string) {\n    return fileName.replace(/[\\\\/:*?\"<>|]+/g, \"-\").trim();\n  }\n\n  private getExtensionFromMimeType(contentType: string) {\n    const mimeType = contentType.split(\";\")[0].trim().toLowerCase();\n    return MIME_MAP[mimeType] ?? \"\";\n  }\n\n  private normalizeImageMimeType(contentType: string, fileName: string) {\n    const mimeType = contentType.split(\";\")[0].trim().toLowerCase();\n    if (mimeType && mimeType !== \"application/octet-stream\") {\n      return mimeType;\n    }\n\n    return this.getMimeTypeFromFileName(fileName);\n  }\n\n  private async uploadBinary(remotePath: string, binary: ArrayBuffer, mimeType: string) {\n    await this.ensureRemoteDirectories(remotePath);\n    const response = await this.requestUrl({\n      url: this.buildUploadUrl(remotePath),\n      method: \"PUT\",\n      headers: {\n        Authorization: this.buildAuthHeader(),\n        \"Content-Type\": mimeType,\n      },\n      body: binary,\n    });\n\n    this.assertResponseSuccess(response, \"Upload\");\n  }\n\n  private async handleEditorPaste(evt: ClipboardEvent, editor: Editor, info: MarkdownView | MarkdownFileInfo) {\n    if (evt.defaultPrevented || !info.file) {\n      return;\n    }\n\n    const imageFile = this.extractImageFileFromClipboard(evt);\n    if (imageFile) {\n      evt.preventDefault();\n      const fileName = imageFile.name || this.buildClipboardFileName(imageFile.type);\n      await this.uploadQueue.enqueueEditorImageUpload(info.file, editor, imageFile, fileName);\n      return;\n    }\n\n    const html = evt.clipboardData?.getData(\"text/html\")?.trim() ?? \"\";\n    if (!html || !this.htmlContainsRemoteImages(html)) {\n      return;\n    }\n\n    evt.preventDefault();\n    await this.handleHtmlPasteWithRemoteImages(info.file, editor, html);\n  }\n\n  private async handleEditorDrop(evt: DragEvent, editor: Editor, info: MarkdownView | MarkdownFileInfo) {\n    if (evt.defaultPrevented || !info.file) {\n      return;\n    }\n\n    const imageFile = this.extractImageFileFromDrop(evt);\n    if (!imageFile) {\n      return;\n    }\n\n    evt.preventDefault();\n    const fileName = imageFile.name || this.buildClipboardFileName(imageFile.type);\n    await this.uploadQueue.enqueueEditorImageUpload(info.file, editor, imageFile, fileName);\n  }\n\n  private extractImageFileFromClipboard(evt: ClipboardEvent) {\n    const direct = Array.from(evt.clipboardData?.files ?? []).find((file) => file.type.startsWith(\"image/\"));\n    if (direct) {\n      return direct;\n    }\n\n    const item = Array.from(evt.clipboardData?.items ?? []).find((entry) => entry.type.startsWith(\"image/\"));\n    return item?.getAsFile() ?? null;\n  }\n\n  private htmlContainsRemoteImages(html: string) {\n    return /<img\\b[^>]*src=[\"']https?:\\/\\/[^\"']+[\"'][^>]*>/i.test(html);\n  }\n\n  private async handleHtmlPasteWithRemoteImages(noteFile: TFile, editor: Editor, html: string) {\n    try {\n      const rendered = await this.convertHtmlClipboardToSecureMarkdown(html, noteFile);\n      if (!rendered.trim()) {\n        return;\n      }\n\n      editor.replaceSelection(rendered);\n      new Notice(this.t(\"\u5DF2\u5C06\u7F51\u9875\u56FE\u6587\u7C98\u8D34\u5E76\u6293\u53D6\u8FDC\u7A0B\u56FE\u7247\u3002\", \"Pasted web content and captured remote images.\"));\n    } catch (error) {\n      console.error(\"Failed to paste HTML content with remote images\", error);\n      new Notice(\n        this.describeError(\n          this.t(\"\u5904\u7406\u7F51\u9875\u56FE\u6587\u7C98\u8D34\u5931\u8D25\", \"Failed to process pasted web content\"),\n          error,\n        ),\n        8000,\n      );\n    }\n  }\n\n  private async convertHtmlClipboardToSecureMarkdown(html: string, noteFile: TFile) {\n    const parser = new DOMParser();\n    const document = parser.parseFromString(html, \"text/html\");\n    const uploadCache = new Map<string, string>();\n    const renderedBlocks: string[] = [];\n\n    for (const node of Array.from(document.body.childNodes)) {\n      const block = await this.renderPastedHtmlNode(node, noteFile, uploadCache, 0);\n      if (block.trim()) {\n        renderedBlocks.push(block.trim());\n      }\n    }\n\n    return renderedBlocks.join(\"\\n\\n\") + \"\\n\";\n  }\n\n  private async renderPastedHtmlNode(\n    node: Node,\n    noteFile: TFile,\n    uploadCache: Map<string, string>,\n    listDepth: number,\n  ): Promise<string> {\n    if (node.nodeType === Node.TEXT_NODE) {\n      return this.normalizeClipboardText(node.textContent ?? \"\");\n    }\n\n    if (!(node instanceof HTMLElement)) {\n      return \"\";\n    }\n\n    const tag = node.tagName.toLowerCase();\n    if (tag === \"img\") {\n      const src = this.unescapeHtml(node.getAttribute(\"src\")?.trim() ?? \"\");\n      if (!this.isHttpUrl(src)) {\n        return \"\";\n      }\n\n      const alt = (node.getAttribute(\"alt\") ?? \"\").trim() || this.getDisplayNameFromUrl(src);\n      const remoteUrl = await this.uploadRemoteImageUrl(src, uploadCache);\n      return this.imageSupport.buildSecureImageMarkup(remoteUrl, alt);\n    }\n\n    if (tag === \"br\") {\n      return \"\\n\";\n    }\n\n    if (tag === \"ul\" || tag === \"ol\") {\n      const items: string[] = [];\n      let index = 1;\n      for (const child of Array.from(node.children)) {\n        if (child.tagName.toLowerCase() !== \"li\") {\n          continue;\n        }\n\n        const rendered = (await this.renderPastedHtmlNode(child, noteFile, uploadCache, listDepth + 1)).trim();\n        if (!rendered) {\n          continue;\n        }\n\n        const prefix = tag === \"ol\" ? `${index}. ` : \"- \";\n        items.push(`${\"  \".repeat(Math.max(0, listDepth))}${prefix}${rendered}`);\n        index += 1;\n      }\n\n      return items.join(\"\\n\");\n    }\n\n    if (tag === \"li\") {\n      const parts = await this.renderPastedHtmlChildren(node, noteFile, uploadCache, listDepth);\n      return parts.join(\"\").trim();\n    }\n\n    if (/^h[1-6]$/.test(tag)) {\n      const level = Number.parseInt(tag[1], 10);\n      const text = (await this.renderPastedHtmlChildren(node, noteFile, uploadCache, listDepth)).join(\"\").trim();\n      return text ? `${\"#\".repeat(level)} ${text}` : \"\";\n    }\n\n    if (tag === \"a\") {\n      const href = node.getAttribute(\"href\")?.trim() ?? \"\";\n      const text = (await this.renderPastedHtmlChildren(node, noteFile, uploadCache, listDepth)).join(\"\").trim();\n      if (href && /^https?:\\/\\//i.test(href) && text) {\n        return `[${text}](${href})`;\n      }\n      return text;\n    }\n\n    const inlineTags = new Set([\"strong\", \"b\", \"em\", \"i\", \"span\", \"code\", \"small\", \"sup\", \"sub\"]);\n    if (inlineTags.has(tag)) {\n      return (await this.renderPastedHtmlChildren(node, noteFile, uploadCache, listDepth)).join(\"\");\n    }\n\n    const blockTags = new Set([\n      \"p\",\n      \"div\",\n      \"article\",\n      \"section\",\n      \"figure\",\n      \"figcaption\",\n      \"blockquote\",\n      \"pre\",\n      \"table\",\n      \"thead\",\n      \"tbody\",\n      \"tr\",\n      \"td\",\n      \"th\",\n    ]);\n    if (blockTags.has(tag)) {\n      const text = (await this.renderPastedHtmlChildren(node, noteFile, uploadCache, listDepth)).join(\"\").trim();\n      return text;\n    }\n\n    return (await this.renderPastedHtmlChildren(node, noteFile, uploadCache, listDepth)).join(\"\");\n  }\n\n  private async renderPastedHtmlChildren(\n    element: HTMLElement,\n    noteFile: TFile,\n    uploadCache: Map<string, string>,\n    listDepth: number,\n  ) {\n    const parts: string[] = [];\n    for (const child of Array.from(element.childNodes)) {\n      const rendered = await this.renderPastedHtmlNode(child, noteFile, uploadCache, listDepth);\n      if (!rendered) {\n        continue;\n      }\n\n      if (parts.length > 0 && !rendered.startsWith(\"\\n\") && !parts[parts.length - 1].endsWith(\"\\n\")) {\n        const previous = parts[parts.length - 1];\n        const needsSpace = /\\S$/.test(previous) && /^\\S/.test(rendered);\n        if (needsSpace) {\n          parts.push(\" \");\n        }\n      }\n\n      parts.push(rendered);\n    }\n\n    return parts;\n  }\n\n  private normalizeClipboardText(value: string) {\n    return value.replace(/\\s+/g, \" \");\n  }\n\n  private extractImageFileFromDrop(evt: DragEvent) {\n    return Array.from(evt.dataTransfer?.files ?? []).find((file) => file.type.startsWith(\"image/\")) ?? null;\n  }\n\n  private async enqueueEditorImageUpload(noteFile: TFile, editor: Editor, imageFile: File, fileName: string) {\n\n    await this.uploadQueue.enqueueEditorImageUpload(noteFile, editor, imageFile, fileName);\n  }\n\n  async syncConfiguredVaultContent(showNotice = true) {\n    if (this.syncInProgress) {\n      if (showNotice) {\n        new Notice(this.t(\"\u540C\u6B65\u6B63\u5728\u8FDB\u884C\u4E2D\u3002\", \"A sync is already in progress.\"), 4000);\n      }\n      return;\n    }\n\n    this.syncInProgress = true;\n    try {\n      this.ensureConfigured();\n      await this.waitForPendingVaultMutations();\n      const uploadsReady = await this.preparePendingUploadsForSync(showNotice);\n      if (!uploadsReady) {\n        return;\n      }\n      await this.rebuildReferenceIndex();\n\n      const counts = {\n        uploaded: 0, restoredFromRemote: 0, downloadedOrUpdated: 0, skipped: 0,\n        deletedRemoteFiles: 0, deletedLocalFiles: 0, deletedLocalStubs: 0,\n        missingRemoteBackedNotes: 0, purgedMissingLazyNotes: 0,\n        deletedRemoteDirectories: 0, createdRemoteDirectories: 0,\n        deletedLocalDirectories: 0, createdLocalDirectories: 0,\n        evictedNotes: 0,\n      };\n\n      // Explicit local deletes/renames must land on the remote side before we\n      // inspect remote-only entries, otherwise a just-moved note can be pulled\n      // back from its old remote path and appear as a duplicate local file.\n      await this.processPendingVaultRenames(counts);\n      await this.processPendingVaultDeletions(counts);\n\n      const remoteInventory = await this.listRemoteTree(this.settings.vaultSyncRemoteFolder);\n      const deletionTombstones = await this.readDeletionTombstones();\n      const remoteFiles = remoteInventory.files;\n\n      await this.reconcileOrphanedSyncEntries(remoteFiles, deletionTombstones, counts);\n      await this.reconcileRemoteOnlyFiles(remoteFiles, deletionTombstones, counts);\n      await this.reconcileLocalFiles(remoteFiles, deletionTombstones, counts);\n\n      const dirStats = await this.reconcileDirectories(remoteInventory.directories);\n      counts.deletedRemoteDirectories = dirStats.deletedRemote;\n      counts.createdRemoteDirectories = dirStats.createdRemote;\n      counts.deletedLocalDirectories = dirStats.deletedLocal;\n      counts.createdLocalDirectories = dirStats.createdLocal;\n      await this.reconcileRemoteImages();\n      counts.evictedNotes = await this.evictStaleSyncedNotes(false);\n      this.pendingVaultSyncPaths.clear();\n      this.pendingVaultDeletionPaths.clear();\n\n      this.lastVaultSyncAt = Date.now();\n      this.lastVaultSyncStatus = this.t(\n        `\u5DF2\u53CC\u5411\u540C\u6B65\uFF1A\u4E0A\u4F20 ${counts.uploaded} \u4E2A\u6587\u4EF6\uFF0C\u4ECE\u8FDC\u7AEF\u62C9\u53D6 ${counts.restoredFromRemote + counts.downloadedOrUpdated} \u4E2A\u6587\u4EF6\uFF0C\u8DF3\u8FC7 ${counts.skipped} \u4E2A\u672A\u53D8\u5316\u6587\u4EF6\uFF0C\u5220\u9664\u8FDC\u7AEF\u5185\u5BB9 ${counts.deletedRemoteFiles} \u4E2A\u3001\u672C\u5730\u5185\u5BB9 ${counts.deletedLocalFiles} \u4E2A${counts.deletedLocalStubs > 0 ? `\uFF08\u5176\u4E2D\u5931\u6548\u5360\u4F4D\u7B14\u8BB0 ${counts.deletedLocalStubs} \u7BC7\uFF09` : \"\"}\uFF0C${counts.deletedRemoteDirectories > 0 || counts.createdRemoteDirectories > 0 ? `\u5220\u9664\u8FDC\u7AEF\u76EE\u5F55 ${counts.deletedRemoteDirectories} \u4E2A\u3001\u521B\u5EFA\u8FDC\u7AEF\u76EE\u5F55 ${counts.createdRemoteDirectories} \u4E2A\u3001` : \"\"}${counts.deletedLocalDirectories > 0 || counts.createdLocalDirectories > 0 ? `\u5220\u9664\u672C\u5730\u76EE\u5F55 ${counts.deletedLocalDirectories} \u4E2A\u3001\u521B\u5EFA\u672C\u5730\u76EE\u5F55 ${counts.createdLocalDirectories} \u4E2A\u3001` : \"\"}${counts.evictedNotes > 0 ? `\u56DE\u6536\u672C\u5730\u65E7\u7B14\u8BB0 ${counts.evictedNotes} \u7BC7\u3001` : \"\"}${counts.missingRemoteBackedNotes > 0 ? `\u53D1\u73B0 ${counts.missingRemoteBackedNotes} \u7BC7\u6309\u9700\u7B14\u8BB0\u7F3A\u5C11\u8FDC\u7AEF\u6B63\u6587\u3001` : \"\"}${counts.purgedMissingLazyNotes > 0 ? `\u786E\u8BA4\u6E05\u7406\u5931\u6548\u5360\u4F4D\u7B14\u8BB0 ${counts.purgedMissingLazyNotes} \u7BC7\u3001` : \"\"}\u3002`.replace(/\u3001\u3002/, \"\u3002\"),\n        `Bidirectional sync uploaded ${counts.uploaded} file(s), pulled ${counts.restoredFromRemote + counts.downloadedOrUpdated} file(s) from remote, skipped ${counts.skipped} unchanged file(s), deleted ${counts.deletedRemoteFiles} remote content file(s) and ${counts.deletedLocalFiles} local file(s)${counts.deletedLocalStubs > 0 ? ` (including ${counts.deletedLocalStubs} stale stub note(s))` : \"\"}${counts.deletedRemoteDirectories > 0 ? `, deleted ${counts.deletedRemoteDirectories} remote director${counts.deletedRemoteDirectories === 1 ? \"y\" : \"ies\"}` : \"\"}${counts.createdRemoteDirectories > 0 ? `, created ${counts.createdRemoteDirectories} remote director${counts.createdRemoteDirectories === 1 ? \"y\" : \"ies\"}` : \"\"}${counts.deletedLocalDirectories > 0 ? `, deleted ${counts.deletedLocalDirectories} local empty director${counts.deletedLocalDirectories === 1 ? \"y\" : \"ies\"}` : \"\"}${counts.createdLocalDirectories > 0 ? `, created ${counts.createdLocalDirectories} local director${counts.createdLocalDirectories === 1 ? \"y\" : \"ies\"}` : \"\"}${counts.evictedNotes > 0 ? `, and evicted ${counts.evictedNotes} stale local note(s)` : \"\"}${counts.missingRemoteBackedNotes > 0 ? `, while detecting ${counts.missingRemoteBackedNotes} lazy note(s) missing their remote content` : \"\"}${counts.purgedMissingLazyNotes > 0 ? `, and purged ${counts.purgedMissingLazyNotes} confirmed broken lazy placeholder(s)` : \"\"}.`,\n      );\n      await this.savePluginState();\n      if (showNotice) {\n        new Notice(this.lastVaultSyncStatus, 8000);\n      }\n    } catch (error) {\n      console.error(\"Vault content sync failed\", error);\n      this.lastVaultSyncAt = Date.now();\n      this.lastVaultSyncStatus = this.describeError(this.t(\"\u5185\u5BB9\u540C\u6B65\u5931\u8D25\", \"Content sync failed\"), error);\n      await this.savePluginState();\n      if (showNotice) {\n        new Notice(this.lastVaultSyncStatus, 8000);\n      }\n    } finally {\n      this.syncInProgress = false;\n    }\n  }\n\n  async syncPendingVaultContent(showNotice = true) {\n    if (this.syncInProgress) {\n      if (showNotice) {\n        new Notice(this.t(\"\u540C\u6B65\u6B63\u5728\u8FDB\u884C\u4E2D\u3002\", \"A sync is already in progress.\"), 4000);\n      }\n      return;\n    }\n\n    this.syncInProgress = true;\n    const counts = { uploaded: 0, deletedRemoteFiles: 0, skipped: 0, detectedLocalChanges: 0 };\n    try {\n      this.ensureConfigured();\n      await this.waitForPendingVaultMutations();\n      const uploadsReady = await this.preparePendingUploadsForSync(showNotice);\n      if (!uploadsReady) {\n        return;\n      }\n\n      await this.processPendingVaultRenames(counts);\n      await this.queueChangedLocalFilesForFastSync(counts);\n      await this.processPendingVaultDeletions(counts);\n      await this.processPendingVaultUploads(counts);\n\n      this.lastVaultSyncAt = Date.now();\n      this.lastVaultSyncStatus = this.t(\n        `\u5DF2\u5FEB\u901F\u540C\u6B65\uFF1A\u53D1\u73B0 ${counts.detectedLocalChanges} \u4E2A\u672C\u5730\u53D8\u5316\uFF0C\u4E0A\u4F20 ${counts.uploaded} \u4E2A\u6587\u4EF6\uFF0C\u5220\u9664\u8FDC\u7AEF\u5185\u5BB9 ${counts.deletedRemoteFiles} \u4E2A\uFF0C\u8DF3\u8FC7 ${counts.skipped} \u4E2A\u6587\u4EF6\u3002`,\n        `Fast sync found ${counts.detectedLocalChanges} local change(s), uploaded ${counts.uploaded} file(s), deleted ${counts.deletedRemoteFiles} remote content file(s), and skipped ${counts.skipped} file(s).`,\n      );\n      await this.savePluginState();\n      if (showNotice) {\n        new Notice(this.lastVaultSyncStatus, 6000);\n      }\n    } catch (error) {\n      console.error(\"Fast vault content sync failed\", error);\n      this.lastVaultSyncAt = Date.now();\n      this.lastVaultSyncStatus = this.describeError(this.t(\"\u5FEB\u901F\u540C\u6B65\u5931\u8D25\", \"Fast sync failed\"), error);\n      await this.savePluginState();\n      if (showNotice) {\n        new Notice(this.lastVaultSyncStatus, 8000);\n      }\n    } finally {\n      this.syncInProgress = false;\n    }\n  }\n\n  private async queueChangedLocalFilesForFastSync(counts: { detectedLocalChanges: number; skipped: number }) {\n    const files = this.syncSupport.collectVaultContentFiles();\n    const recentTouchGraceMs = 1000;\n    for (const file of files) {\n      const remotePath = this.syncSupport.buildVaultSyncRemotePath(file.path);\n      const previous = this.syncIndex.get(file.path);\n      const markdownContent = file.extension === \"md\" ? await this.readMarkdownContentPreferEditor(file) : undefined;\n      if (file.extension === \"md\" && this.parseNoteStub(markdownContent ?? \"\")) {\n        counts.skipped += 1;\n        continue;\n      }\n\n      const localSignature = await this.buildCurrentLocalSignature(file, markdownContent);\n      const touchedSinceLastSync =\n        this.lastVaultSyncAt > 0 && file.stat.mtime > this.lastVaultSyncAt + recentTouchGraceMs;\n      if (!previous || previous.remotePath !== remotePath || previous.localSignature !== localSignature || touchedSinceLastSync) {\n        if (!this.pendingVaultSyncPaths.has(file.path)) {\n          counts.detectedLocalChanges += 1;\n        }\n        this.markPendingVaultSync(file.path);\n      }\n    }\n  }\n\n  private async processPendingVaultRenames(\n    counts: { uploaded: number; deletedRemoteFiles: number; skipped: number },\n    targetOldPaths?: string[],\n  ) {\n    const requested = targetOldPaths ? new Set(targetOldPaths.map((path) => normalizePath(path))) : null;\n    for (const [oldPath, entry] of [...this.pendingVaultRenamePaths.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {\n      if (requested && !requested.has(oldPath)) {\n        continue;\n      }\n\n      if (this.syncSupport.shouldSkipContentSyncPath(oldPath) || this.syncSupport.shouldSkipContentSyncPath(entry.newPath)) {\n        this.pendingVaultRenamePaths.delete(oldPath);\n        this.pendingVaultDeletionPaths.delete(oldPath);\n        counts.skipped += 1;\n        continue;\n      }\n\n      await this.writeDeletionTombstone(oldPath, entry.oldRemoteSignature);\n      await this.deleteRemoteContentFile(entry.oldRemotePath);\n      this.pendingVaultDeletionPaths.delete(oldPath);\n      this.syncIndex.delete(oldPath);\n      counts.deletedRemoteFiles += 1;\n\n      const file = this.getVaultFileByPath(entry.newPath);\n      if (!(file instanceof TFile)) {\n        this.pendingVaultRenamePaths.delete(oldPath);\n        counts.skipped += 1;\n        continue;\n      }\n\n      const markdownContent = file.extension === \"md\" ? await this.readMarkdownContentPreferEditor(file) : undefined;\n      if (file.extension === \"md\" && this.parseNoteStub(markdownContent ?? \"\")) {\n        this.pendingVaultRenamePaths.delete(oldPath);\n        this.pendingVaultSyncPaths.delete(file.path);\n        counts.skipped += 1;\n        continue;\n      }\n\n      const remotePath = this.syncSupport.buildVaultSyncRemotePath(file.path);\n      const localSignature = await this.buildCurrentLocalSignature(file, markdownContent);\n      let remoteAtNewPath: RemoteFileState | null = null;\n      try {\n        remoteAtNewPath = await this.statRemoteFile(remotePath);\n      } catch {\n        remoteAtNewPath = null;\n      }\n      if (remoteAtNewPath && remoteAtNewPath.signature !== localSignature) {\n        await this.createLocalConflictCopy(file, markdownContent ?? undefined, \"local\");\n      }\n\n      const uploadedRemote = await this.uploadContentFileToRemote(file, remotePath, markdownContent);\n      this.syncIndex.set(file.path, {\n        localSignature,\n        remoteSignature: uploadedRemote.signature,\n        remotePath,\n      });\n      this.pendingVaultSyncPaths.delete(file.path);\n      this.pendingVaultRenamePaths.delete(oldPath);\n      await this.deleteDeletionTombstone(file.path);\n      counts.uploaded += 1;\n    }\n  }\n\n  private async processPendingVaultDeletions(counts: { deletedRemoteFiles: number; skipped: number }) {\n    for (const [path, entry] of [...this.pendingVaultDeletionPaths.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {\n      if (this.syncSupport.shouldSkipContentSyncPath(path)) {\n        this.pendingVaultDeletionPaths.delete(path);\n        counts.skipped += 1;\n        continue;\n      }\n\n      await this.writeDeletionTombstone(path, entry.remoteSignature);\n      await this.deleteRemoteContentFile(entry.remotePath);\n      this.syncIndex.delete(path);\n      this.pendingVaultDeletionPaths.delete(path);\n      counts.deletedRemoteFiles += 1;\n    }\n  }\n\n  private async processPendingVaultUploads(counts: { uploaded: number; skipped: number }) {\n    for (const path of [...this.pendingVaultSyncPaths].sort((a, b) => a.localeCompare(b))) {\n      if (this.syncSupport.shouldSkipContentSyncPath(path)) {\n        this.pendingVaultSyncPaths.delete(path);\n        counts.skipped += 1;\n        continue;\n      }\n\n      const file = this.getVaultFileByPath(path);\n      if (!(file instanceof TFile)) {\n        this.pendingVaultSyncPaths.delete(path);\n        counts.skipped += 1;\n        continue;\n      }\n\n      const markdownContent = file.extension === \"md\" ? await this.readMarkdownContentPreferEditor(file) : undefined;\n      if (file.extension === \"md\" && this.parseNoteStub(markdownContent ?? \"\")) {\n        this.pendingVaultSyncPaths.delete(path);\n        counts.skipped += 1;\n        continue;\n      }\n\n      const remotePath = this.syncSupport.buildVaultSyncRemotePath(file.path);\n      const uploadedRemote = await this.uploadContentFileToRemote(file, remotePath, markdownContent);\n      const localSignature = await this.buildCurrentLocalSignature(file, markdownContent);\n      this.syncIndex.set(file.path, {\n        localSignature,\n        remoteSignature: uploadedRemote.signature,\n        remotePath,\n      });\n      await this.deleteDeletionTombstone(file.path);\n      this.pendingVaultSyncPaths.delete(path);\n      counts.uploaded += 1;\n    }\n  }\n\n  private async reconcileOrphanedSyncEntries(\n    remoteFiles: Map<string, RemoteFileState>,\n    deletionTombstones: Map<string, DeletionTombstone>,\n    counts: { uploaded: number; restoredFromRemote: number; downloadedOrUpdated: number; skipped: number; deletedRemoteFiles: number; deletedLocalFiles: number; deletedLocalStubs: number; missingRemoteBackedNotes: number; purgedMissingLazyNotes: number },\n  ) {\n    const files = this.syncSupport.collectVaultContentFiles();\n    const currentPaths = new Set(files.map((file) => file.path));\n    for (const path of [...this.syncIndex.keys()]) {\n      if (currentPaths.has(path)) {\n        continue;\n      }\n\n      if (this.syncSupport.shouldSkipContentSyncPath(path)) {\n        this.syncIndex.delete(path);\n        continue;\n      }\n\n      const previous = this.syncIndex.get(path);\n      if (!previous) {\n        this.syncIndex.delete(path);\n        continue;\n      }\n\n      const remote = remoteFiles.get(previous.remotePath);\n      if (!remote) {\n        this.syncIndex.delete(path);\n        continue;\n      }\n\n      const tombstone = deletionTombstones.get(path);\n      if (tombstone && this.syncSupport.isTombstoneAuthoritative(tombstone, remote)) {\n        await this.deleteRemoteContentFile(remote.remotePath);\n        remoteFiles.delete(remote.remotePath);\n        this.syncIndex.delete(path);\n        counts.deletedRemoteFiles += 1;\n        continue;\n      }\n\n      if (tombstone) {\n        await this.deleteDeletionTombstone(path);\n        deletionTombstones.delete(path);\n      }\n\n      await this.downloadRemoteFileToVault(path, remote);\n      this.syncIndex.set(path, {\n        localSignature: remote.signature,\n        remoteSignature: remote.signature,\n        remotePath: remote.remotePath,\n      });\n      counts.restoredFromRemote += 1;\n    }\n  }\n\n  private async reconcileRemoteOnlyFiles(\n    remoteFiles: Map<string, RemoteFileState>,\n    deletionTombstones: Map<string, DeletionTombstone>,\n    counts: { uploaded: number; restoredFromRemote: number; downloadedOrUpdated: number; skipped: number; deletedRemoteFiles: number; deletedLocalFiles: number; deletedLocalStubs: number; missingRemoteBackedNotes: number; purgedMissingLazyNotes: number },\n  ) {\n    const files = this.syncSupport.collectVaultContentFiles();\n    const currentPaths = new Set(files.map((file) => file.path));\n    for (const remote of [...remoteFiles.values()].sort((a, b) => a.remotePath.localeCompare(b.remotePath))) {\n      const vaultPath = this.syncSupport.remotePathToVaultPath(remote.remotePath);\n      if (!vaultPath || currentPaths.has(vaultPath)) {\n        continue;\n      }\n\n      if (this.syncSupport.shouldSkipContentSyncPath(vaultPath)) {\n        continue;\n      }\n\n      if (this.pendingVaultRenamePaths.has(vaultPath)) {\n        counts.skipped += 1;\n        continue;\n      }\n\n      const tombstone = deletionTombstones.get(vaultPath);\n      if (tombstone) {\n        if (this.syncSupport.isTombstoneAuthoritative(tombstone, remote)) {\n          await this.deleteRemoteContentFile(remote.remotePath);\n          remoteFiles.delete(remote.remotePath);\n          counts.deletedRemoteFiles += 1;\n          continue;\n        }\n\n        await this.deleteDeletionTombstone(vaultPath);\n        deletionTombstones.delete(vaultPath);\n      }\n\n      await this.downloadRemoteFileToVault(vaultPath, remote);\n      this.syncIndex.set(vaultPath, {\n        localSignature: remote.signature,\n        remoteSignature: remote.signature,\n        remotePath: remote.remotePath,\n      });\n      counts.restoredFromRemote += 1;\n    }\n  }\n\n  private shouldUploadLocalWhenRemoteIsMissing(\n    file: TFile,\n    previous: SyncIndexEntry | undefined,\n    localSignature: string,\n    remotePath: string,\n  ) {\n    if (previous) {\n      return previous.remotePath !== remotePath || previous.localSignature !== localSignature;\n    }\n\n    const graceMs = 5000;\n    return !this.lastVaultSyncAt || file.stat.mtime > this.lastVaultSyncAt + graceMs;\n  }\n\n  private formatConflictTimestamp() {\n    const value = new Date();\n    const pad = (input: number) => String(input).padStart(2, \"0\");\n    return `${value.getFullYear()}${pad(value.getMonth() + 1)}${pad(value.getDate())}-${pad(value.getHours())}${pad(value.getMinutes())}${pad(value.getSeconds())}`;\n  }\n\n  private buildConflictCopyPath(originalPath: string, label: string) {\n    const normalized = normalizePath(originalPath);\n    const slashIndex = normalized.lastIndexOf(\"/\");\n    const dir = slashIndex >= 0 ? normalized.slice(0, slashIndex + 1) : \"\";\n    const name = slashIndex >= 0 ? normalized.slice(slashIndex + 1) : normalized;\n    const dotIndex = name.lastIndexOf(\".\");\n    const stem = dotIndex > 0 ? name.slice(0, dotIndex) : name;\n    const ext = dotIndex > 0 ? name.slice(dotIndex) : \"\";\n    const suffix = `.sync-conflict-${this.formatConflictTimestamp()}-${label}`;\n    return `${dir}${stem}${suffix}${ext}`;\n  }\n\n  private findExistingConflictCopyPath(originalPath: string) {\n    const normalized = normalizePath(originalPath);\n    const slashIndex = normalized.lastIndexOf(\"/\");\n    const dir = slashIndex >= 0 ? normalized.slice(0, slashIndex + 1) : \"\";\n    const name = slashIndex >= 0 ? normalized.slice(slashIndex + 1) : normalized;\n    const dotIndex = name.lastIndexOf(\".\");\n    const stem = dotIndex > 0 ? name.slice(0, dotIndex) : name;\n    const ext = dotIndex > 0 ? name.slice(dotIndex) : \"\";\n    const prefix = `${dir}${stem}.sync-conflict-`;\n    return this.app.vault.getFiles()\n      .map((file) => file.path)\n      .find((path) => path.startsWith(prefix) && (!ext || path.endsWith(ext))) ?? null;\n  }\n\n  private async createLocalConflictCopy(file: TFile, markdownContent: string | null | undefined, label: string) {\n    const existing = this.findExistingConflictCopyPath(file.path);\n    if (existing) {\n      return existing;\n    }\n\n    let targetPath = this.buildConflictCopyPath(file.path, label);\n    let attempt = 1;\n    while (this.app.vault.getAbstractFileByPath(targetPath)) {\n      const normalized = normalizePath(targetPath);\n      const dotIndex = normalized.lastIndexOf(\".\");\n      targetPath = dotIndex > 0\n        ? `${normalized.slice(0, dotIndex)}-${attempt}${normalized.slice(dotIndex)}`\n        : `${normalized}-${attempt}`;\n      attempt += 1;\n    }\n\n    await this.ensureLocalParentFolders(targetPath);\n    if (file.extension === \"md\") {\n      await this.app.vault.create(targetPath, markdownContent ?? await this.readMarkdownContentPreferEditor(file));\n    } else {\n      await this.app.vault.createBinary(targetPath, await this.app.vault.readBinary(file));\n    }\n\n    this.markPendingVaultSync(targetPath);\n    return targetPath;\n  }\n\n  private async reconcileLocalFiles(\n    remoteFiles: Map<string, RemoteFileState>,\n    deletionTombstones: Map<string, DeletionTombstone>,\n    counts: { uploaded: number; restoredFromRemote: number; downloadedOrUpdated: number; skipped: number; deletedRemoteFiles: number; deletedLocalFiles: number; deletedLocalStubs: number; missingRemoteBackedNotes: number; purgedMissingLazyNotes: number },\n  ): Promise<Set<string>> {\n    const files = this.syncSupport.collectVaultContentFiles();\n    const localRemotePaths = new Set<string>();\n\n    for (const file of files) {\n      const remotePath = this.syncSupport.buildVaultSyncRemotePath(file.path);\n      localRemotePaths.add(remotePath);\n      const remote = remoteFiles.get(remotePath);\n      const remoteSignature = remote?.signature ?? \"\";\n      const previous = this.syncIndex.get(file.path);\n      const markdownContent = file.extension === \"md\" ? await this.readMarkdownContentPreferEditor(file) : null;\n      const localSignature = await this.buildCurrentLocalSignature(file, markdownContent ?? undefined);\n\n      if (file.extension === \"md\") {\n        const stub = this.parseNoteStub(markdownContent ?? \"\");\n        if (stub) {\n          const stubRemote = remoteFiles.get(stub.remotePath);\n          const tombstone = deletionTombstones.get(file.path);\n          const resolution = await this.resolveLazyNoteStub(file, stub, stubRemote, tombstone);\n          if (resolution.action === \"deleted\") {\n            counts.deletedLocalFiles += 1;\n            counts.deletedLocalStubs += 1;\n            if (resolution.purgedMissing) {\n              counts.purgedMissingLazyNotes += 1;\n            }\n            continue;\n          }\n          if (resolution.action === \"missing\") {\n            counts.missingRemoteBackedNotes += 1;\n          }\n          this.syncIndex.set(file.path, {\n            localSignature,\n            remoteSignature: stubRemote?.signature ?? previous?.remoteSignature ?? \"\",\n            remotePath,\n          });\n          counts.skipped += 1;\n          continue;\n        }\n      }\n\n      const tombstone = deletionTombstones.get(file.path);\n      const unchangedSinceLastSync = previous?.remotePath === remotePath && previous.localSignature === localSignature;\n      if (tombstone) {\n        if (\n          unchangedSinceLastSync &&\n          this.syncSupport.shouldDeleteLocalFromTombstone(file, tombstone) &&\n          this.syncSupport.isTombstoneAuthoritative(tombstone, remote)\n        ) {\n          await this.removeLocalVaultFile(file);\n          this.syncIndex.delete(file.path);\n          counts.deletedLocalFiles += 1;\n          if (remote) {\n            await this.deleteRemoteContentFile(remote.remotePath);\n            remoteFiles.delete(remote.remotePath);\n            counts.deletedRemoteFiles += 1;\n          }\n          continue;\n        }\n\n        if (!previous || this.syncSupport.shouldDeleteLocalFromTombstone(file, tombstone)) {\n          await this.createLocalConflictCopy(file, markdownContent, \"local\");\n          counts.skipped += 1;\n          continue;\n        }\n\n        await this.deleteDeletionTombstone(file.path);\n        deletionTombstones.delete(file.path);\n      }\n\n      if (!remote && !this.shouldUploadLocalWhenRemoteIsMissing(file, previous, localSignature, remotePath)) {\n        counts.skipped += 1;\n        continue;\n      }\n\n      if (!remote) {\n        const uploadedRemote = await this.uploadContentFileToRemote(file, remotePath, markdownContent ?? undefined);\n        this.syncIndex.set(file.path, {\n          localSignature,\n          remoteSignature: uploadedRemote.signature,\n          remotePath,\n        });\n        remoteFiles.set(remotePath, uploadedRemote);\n        counts.uploaded += 1;\n        continue;\n      }\n\n      if (!previous) {\n        if (localSignature === remoteSignature) {\n          this.syncIndex.set(file.path, { localSignature, remoteSignature, remotePath });\n          await this.deleteDeletionTombstone(file.path);\n          counts.skipped += 1;\n          continue;\n        }\n\n        if (this.syncSupport.shouldDownloadRemoteVersion(file.stat.mtime, remote.lastModified)) {\n          await this.downloadRemoteFileToVault(file.path, remote, file);\n          const refreshed = this.getVaultFileByPath(file.path);\n          this.syncIndex.set(file.path, {\n            localSignature: refreshed ? await this.buildCurrentLocalSignature(refreshed) : remoteSignature,\n            remoteSignature,\n            remotePath,\n          });\n          counts.downloadedOrUpdated += 1;\n          continue;\n        }\n\n        const uploadedRemote = await this.uploadContentFileToRemote(file, remotePath, markdownContent ?? undefined);\n        this.syncIndex.set(file.path, {\n          localSignature,\n          remoteSignature: uploadedRemote.signature,\n          remotePath,\n        });\n        remoteFiles.set(remotePath, uploadedRemote);\n        await this.deleteDeletionTombstone(file.path);\n        counts.uploaded += 1;\n        continue;\n      }\n\n      const localChanged = previous.localSignature !== localSignature || previous.remotePath !== remotePath;\n      const remoteChanged = previous.remoteSignature !== remoteSignature || previous.remotePath !== remotePath;\n      if (!localChanged && !remoteChanged) {\n        counts.skipped += 1;\n        continue;\n      }\n\n      if (!localChanged && remoteChanged) {\n        await this.downloadRemoteFileToVault(file.path, remote, file);\n        const refreshed = this.getVaultFileByPath(file.path);\n        this.syncIndex.set(file.path, {\n          localSignature: refreshed ? await this.buildCurrentLocalSignature(refreshed) : remoteSignature,\n          remoteSignature,\n          remotePath,\n        });\n        counts.downloadedOrUpdated += 1;\n        continue;\n      }\n\n      if (localChanged && !remoteChanged) {\n        const uploadedRemote = await this.uploadContentFileToRemote(file, remotePath, markdownContent ?? undefined);\n        this.syncIndex.set(file.path, {\n          localSignature,\n          remoteSignature: uploadedRemote.signature,\n          remotePath,\n        });\n        remoteFiles.set(remotePath, uploadedRemote);\n        await this.deleteDeletionTombstone(file.path);\n        counts.uploaded += 1;\n        continue;\n      }\n\n      await this.createLocalConflictCopy(file, markdownContent, \"local\");\n      counts.skipped += 1;\n      continue;\n    }\n\n    return localRemotePaths;\n  }\n\n  private async deleteRemoteContentFile(remotePath: string) {\n    try {\n      const response = await this.requestUrl({\n        url: this.buildUploadUrl(remotePath),\n        method: \"DELETE\",\n        headers: {\n          Authorization: this.buildAuthHeader(),\n        },\n      });\n\n      if (response.status !== 404 && (response.status < 200 || response.status >= 300)) {\n        throw new Error(`DELETE failed with status ${response.status}`);\n      }\n    } catch (error) {\n      console.error(\"Failed to delete remote synced content\", remotePath, error);\n      throw error;\n    }\n  }\n\n  private async writeDeletionTombstone(vaultPath: string, remoteSignature?: string) {\n    const payload: DeletionTombstone = {\n      path: vaultPath,\n      deletedAt: Date.now(),\n      remoteSignature,\n    };\n    await this.uploadBinary(\n      this.syncSupport.buildDeletionRemotePath(vaultPath),\n      this.encodeUtf8(JSON.stringify(payload)),\n      \"application/json; charset=utf-8\",\n    );\n  }\n\n  private async deleteDeletionTombstone(vaultPath: string) {\n    try {\n      await this.deleteRemoteContentFile(this.syncSupport.buildDeletionRemotePath(vaultPath));\n    } catch {\n      // Tombstone cleanup should not break the main sync flow.\n    }\n  }\n\n  private async readDeletionTombstone(vaultPath: string) {\n    const response = await this.requestUrl({\n      url: this.buildUploadUrl(this.syncSupport.buildDeletionRemotePath(vaultPath)),\n      method: \"GET\",\n      headers: {\n        Authorization: this.buildAuthHeader(),\n      },\n    });\n\n    if (response.status === 404) {\n      return null;\n    }\n    this.assertResponseSuccess(response, \"GET tombstone\");\n\n    return this.syncSupport.parseDeletionTombstonePayload(this.decodeUtf8(response.arrayBuffer));\n  }\n\n  private async readDeletionTombstones() {\n    const tombstones = new Map<string, DeletionTombstone>();\n    const inventory = await this.listRemoteTree(this.syncSupport.buildDeletionFolder());\n    for (const remote of inventory.files.values()) {\n      const vaultPath = this.syncSupport.remoteDeletionPathToVaultPath(remote.remotePath);\n      if (!vaultPath) {\n        continue;\n      }\n\n      const response = await this.requestUrl({\n        url: this.buildUploadUrl(remote.remotePath),\n        method: \"GET\",\n        headers: {\n          Authorization: this.buildAuthHeader(),\n        },\n      });\n      if (response.status < 200 || response.status >= 300) {\n        continue;\n      }\n\n      const tombstone = this.syncSupport.parseDeletionTombstonePayload(this.decodeUtf8(response.arrayBuffer));\n      if (tombstone) {\n        tombstones.set(vaultPath, tombstone);\n      }\n    }\n\n    return tombstones;\n  }\n\n  private getVaultFileByPath(path: string) {\n    const file = this.app.vault.getAbstractFileByPath(path);\n    return file instanceof TFile ? file : null;\n  }\n\n  private async removeLocalVaultFile(file: TFile) {\n    try {\n      await this.app.vault.delete(file, true);\n    } catch (deleteError) {\n      try {\n        await this.app.vault.trash(file, true);\n      } catch {\n        throw deleteError;\n      }\n    }\n  }\n\n  private async ensureLocalParentFolders(path: string) {\n    const normalized = normalizePath(path);\n    const segments = normalized.split(\"/\").filter((value) => value.length > 0);\n    if (segments.length <= 1) {\n      return;\n    }\n\n    let current = \"\";\n    for (let index = 0; index < segments.length - 1; index += 1) {\n      current = current ? `${current}/${segments[index]}` : segments[index];\n      if (!(await this.app.vault.adapter.exists(current))) {\n        try {\n          await this.app.vault.adapter.mkdir(current);\n        } catch (e) {\n          const msg = e instanceof Error ? e.message : String(e);\n          if (!msg.includes(\"already exists\")) {\n            throw e;\n          }\n        }\n      }\n    }\n  }\n\n  private async downloadRemoteFileToVault(vaultPath: string, remote: RemoteFileState, existingFile?: TFile) {\n    const response = await this.requestUrl({\n      url: this.buildUploadUrl(remote.remotePath),\n      method: \"GET\",\n      headers: {\n        Authorization: this.buildAuthHeader(),\n      },\n    });\n    this.assertResponseSuccess(response, \"GET\");\n\n    await this.ensureLocalParentFolders(vaultPath);\n    const options = {\n      mtime: remote.lastModified > 0 ? remote.lastModified : Date.now(),\n    };\n    const isMd = vaultPath.toLowerCase().endsWith(\".md\");\n    const current =\n      existingFile ?? this.getVaultFileByPath(vaultPath) ?? this.app.vault.getAbstractFileByPath(vaultPath);\n    if (current && current instanceof TFile) {\n      if (current.extension === \"md\") {\n        await this.app.vault.modify(current, this.decodeUtf8(response.arrayBuffer), options);\n      } else {\n        await this.app.vault.modifyBinary(current, response.arrayBuffer, options);\n      }\n      return;\n    }\n    try {\n      if (isMd) {\n        await this.app.vault.create(vaultPath, this.decodeUtf8(response.arrayBuffer), options);\n      } else {\n        await this.app.vault.createBinary(vaultPath, response.arrayBuffer, options);\n      }\n    } catch (e) {\n      const msg = e instanceof Error ? e.message : String(e);\n      if (msg.includes(\"already exists\")) {\n        const file = this.app.vault.getAbstractFileByPath(vaultPath);\n        if (file && file instanceof TFile) {\n          if (file.extension === \"md\") {\n            await this.app.vault.modify(file, this.decodeUtf8(response.arrayBuffer), options);\n          } else {\n            await this.app.vault.modifyBinary(file, response.arrayBuffer, options);\n          }\n          return;\n        }\n      }\n      throw e;\n    }\n  }\n\n  private async verifyRemoteBinaryRoundTrip(remotePath: string, expected: ArrayBuffer) {\n    const response = await this.requestUrl({\n      url: this.buildUploadUrl(remotePath),\n      method: \"GET\",\n      headers: {\n        Authorization: this.buildAuthHeader(),\n      },\n    });\n\n    if (response.status < 200 || response.status >= 300) {\n      return false;\n    }\n\n    return this.arrayBuffersEqual(expected, response.arrayBuffer);\n  }\n\n  private async statRemoteFile(remotePath: string) {\n    const response = await this.requestUrl({\n      url: this.buildUploadUrl(remotePath),\n      method: \"PROPFIND\",\n      headers: {\n        Authorization: this.buildAuthHeader(),\n        Depth: \"0\",\n      },\n    });\n\n    if (response.status === 404) {\n      return null;\n    }\n    this.assertResponseSuccess(response, `PROPFIND for ${remotePath}`);\n\n    const xmlText = this.decodeUtf8(response.arrayBuffer);\n    const entries = this.parsePropfindDirectoryListing(xmlText, remotePath, true);\n    return entries.find((entry) => !entry.isCollection)?.file ?? null;\n  }\n\n  private async uploadContentFileToRemote(file: TFile, remotePath: string, markdownContent?: string) {\n    let binary: ArrayBuffer;\n\n    if (file.extension === \"md\") {\n      const content = markdownContent ?? (await this.readMarkdownContentPreferEditor(file));\n      if (this.parseNoteStub(content)) {\n        throw new Error(\n          this.t(\n            \"\u62D2\u7EDD\u628A\u6309\u9700\u52A0\u8F7D\u5360\u4F4D\u7B14\u8BB0\u4E0A\u4F20\u4E3A\u8FDC\u7AEF\u6B63\u6587\u3002\",\n            \"Refusing to upload a lazy-note placeholder as remote note content.\",\n          ),\n        );\n      }\n\n      binary = this.encodeUtf8(content);\n    } else {\n      binary = await this.app.vault.readBinary(file);\n    }\n\n    await this.uploadBinary(remotePath, binary, this.getMimeType(file.extension));\n    let remote: RemoteFileState | null = null;\n    try {\n      remote = await this.statRemoteFile(remotePath);\n    } catch {\n      remote = null;\n    }\n    if (remote) {\n      return remote;\n    }\n\n    return {\n      remotePath,\n      lastModified: file.stat.mtime,\n      size: file.stat.size,\n      signature: this.syncSupport.buildSyncSignature(file),\n    };\n  }\n\n  private async deleteRemoteSyncedEntry(vaultPath: string) {\n    const existing = this.syncIndex.get(vaultPath);\n    const remotePath = existing?.remotePath ?? this.syncSupport.buildVaultSyncRemotePath(vaultPath);\n    await this.deleteRemoteContentFile(remotePath);\n    this.syncIndex.delete(vaultPath);\n    await this.savePluginState();\n  }\n\n  private async handleFileOpen(file: TFile | null) {\n    if (!(file instanceof TFile) || file.extension !== \"md\") {\n      return;\n    }\n\n    this.noteAccessTimestamps.set(file.path, Date.now());\n    await this.savePluginState();\n\n    const content = await this.app.vault.read(file);\n    const stub = this.parseNoteStub(content);\n    if (!stub) {\n      return;\n    }\n\n    try {\n      const remote = await this.statRemoteFile(stub.remotePath);\n      const tombstone = !remote ? await this.readDeletionTombstone(file.path) : undefined;\n      const resolution = await this.resolveLazyNoteStub(file, stub, remote, tombstone);\n      await this.savePluginState();\n\n      if (resolution.action === \"deleted\") {\n        new Notice(\n          this.t(\n            resolution.purgedMissing\n              ? `\u8FDC\u7AEF\u6B63\u6587\u8FDE\u7EED\u7F3A\u5931\uFF0C\u5DF2\u79FB\u9664\u672C\u5730\u5931\u6548\u5360\u4F4D\u7B14\u8BB0\uFF1A${file.basename}`\n              : `\u8FDC\u7AEF\u6B63\u6587\u4E0D\u5B58\u5728\uFF0C\u5DF2\u79FB\u9664\u672C\u5730\u5360\u4F4D\u7B14\u8BB0\uFF1A${file.basename}`,\n            resolution.purgedMissing\n              ? `Remote note was missing repeatedly, removed local broken placeholder: ${file.basename}`\n              : `Remote note missing, removed local placeholder: ${file.basename}`,\n          ),\n          resolution.purgedMissing ? 8000 : 6000,\n        );\n        return;\n      }\n\n      if (resolution.action === \"missing\") {\n        new Notice(this.t(\"\u8FDC\u7AEF\u6B63\u6587\u4E0D\u5B58\u5728\uFF0C\u5F53\u524D\u5148\u4FDD\u7559\u672C\u5730\u5360\u4F4D\u7B14\u8BB0\u4EE5\u9632\u4E34\u65F6\u5F02\u5E38\uFF1B\u82E5\u518D\u6B21\u786E\u8BA4\u7F3A\u5931\uFF0C\u5C06\u81EA\u52A8\u6E05\u7406\u8BE5\u5360\u4F4D\u3002\", \"Remote note is missing. The local placeholder was kept for now in case this is transient; it will be cleaned automatically if the remote is still missing on the next confirmation.\"), 8000);\n        return;\n      }\n\n      new Notice(this.t(`\u5DF2\u4ECE\u8FDC\u7AEF\u6062\u590D\u7B14\u8BB0\uFF1A${file.basename}`, `Restored note from remote: ${file.basename}`), 6000);\n    } catch (error) {\n      console.error(\"Failed to hydrate note from remote\", error);\n      new Notice(this.describeError(this.t(\"\u8FDC\u7AEF\u6062\u590D\u7B14\u8BB0\u5931\u8D25\", \"Failed to restore note from remote\"), error), 8000);\n    }\n  }\n\n  private getOpenMarkdownContent(notePath: string) {\n    const leaves = this.app.workspace.getLeavesOfType(\"markdown\");\n    for (const leaf of leaves) {\n      const view = leaf.view;\n      if (!(view instanceof MarkdownView)) {\n        continue;\n      }\n\n      if (!view.file || view.file.path !== notePath) {\n        continue;\n      }\n\n      return view.editor.getValue();\n    }\n\n    return null;\n  }\n\n  private async readMarkdownContentPreferEditor(file: TFile) {\n    const liveContent = this.getOpenMarkdownContent(file.path);\n    if (liveContent !== null) {\n      return liveContent;\n    }\n\n    return await this.app.vault.read(file);\n  }\n\n  private async buildCurrentLocalSignature(file: TFile, markdownContent?: string) {\n    if (file.extension !== \"md\") {\n      return this.syncSupport.buildSyncSignature(file);\n    }\n\n    const content = markdownContent ?? (await this.readMarkdownContentPreferEditor(file));\n    const digest = (await this.computeSha256Hex(this.encodeUtf8(content))).slice(0, 16);\n    return `md:${content.length}:${digest}`;\n  }\n\n  private async reconcileRemoteImages() {\n    return { deletedFiles: 0, deletedDirectories: 0 };\n  }\n\n  private markMissingLazyRemote(path: string) {\n    const now = Date.now();\n    const previous = this.missingLazyRemoteNotes.get(path);\n    const next: MissingLazyRemoteRecord = previous\n      ? {\n          firstDetectedAt: previous.firstDetectedAt,\n          lastDetectedAt: now,\n          missCount: previous.missCount + 1,\n        }\n      : {\n          firstDetectedAt: now,\n          lastDetectedAt: now,\n          missCount: 1,\n        };\n    this.missingLazyRemoteNotes.set(path, next);\n    return next;\n  }\n\n  private clearMissingLazyRemote(path: string) {\n    this.missingLazyRemoteNotes.delete(path);\n  }\n\n  /**\n   * Shared logic for resolving a lazy-note stub in both handleFileOpen and\n   * syncConfiguredVaultContent.  Callers provide the already-looked-up remote\n   * state (or null) and an optional tombstone.\n   */\n  private async resolveLazyNoteStub(\n    file: TFile,\n    stub: { remotePath: string },\n    remote: RemoteFileState | null | undefined,\n    tombstone: DeletionTombstone | undefined,\n  ): Promise<{ action: \"deleted\" | \"restored\" | \"missing\"; purgedMissing?: boolean }> {\n    if (!remote) {\n      if (tombstone) {\n        await this.removeLocalVaultFile(file);\n        this.syncIndex.delete(file.path);\n        this.clearMissingLazyRemote(file.path);\n        return { action: \"deleted\", deletedStub: true };\n      }\n\n      const missingRecord = this.markMissingLazyRemote(file.path);\n      if (missingRecord.missCount >= this.missingLazyRemoteConfirmations) {\n        await this.removeLocalVaultFile(file);\n        this.syncIndex.delete(file.path);\n        this.clearMissingLazyRemote(file.path);\n        return { action: \"deleted\", deletedStub: true, purgedMissing: true };\n      }\n\n      return { action: \"missing\" };\n    }\n\n    this.clearMissingLazyRemote(file.path);\n    await this.downloadRemoteFileToVault(file.path, remote, file);\n    const refreshed = this.getVaultFileByPath(file.path);\n    this.syncIndex.set(file.path, {\n      localSignature: refreshed ? this.syncSupport.buildSyncSignature(refreshed) : remote.signature,\n      remoteSignature: remote.signature,\n      remotePath: stub.remotePath,\n    });\n    return { action: \"restored\" };\n  }\n\n  private parseNoteStub(content: string) {\n    const match = content.match(\n      /^<!--\\s*secure-webdav-note-stub\\s*\\r?\\nremote:\\s*(.+?)\\r?\\nplaceholder:\\s*(.*?)\\r?\\n-->/s,\n    );\n    if (!match) {\n      return null;\n    }\n\n    return {\n      remotePath: match[1].trim(),\n      placeholder: match[2].trim(),\n    };\n  }\n\n  private buildNoteStub(file: TFile) {\n    const remotePath = this.syncSupport.buildVaultSyncRemotePath(file.path);\n    return [\n      `<!-- ${SECURE_NOTE_STUB}`,\n      `remote: ${remotePath}`,\n      `placeholder: ${file.basename}`,\n      \"-->\",\n      \"\",\n      this.t(\n        `\u8FD9\u662F\u4E00\u7BC7\u6309\u9700\u52A0\u8F7D\u7B14\u8BB0\u7684\u672C\u5730\u5360\u4F4D\u6587\u4EF6\u3002\u6253\u5F00\u8FD9\u7BC7\u7B14\u8BB0\u65F6\uFF0C\u63D2\u4EF6\u4F1A\u4ECE\u8FDC\u7AEF\u540C\u6B65\u76EE\u5F55\u6062\u590D\u5B8C\u6574\u5185\u5BB9\u3002`,\n        `This is a local placeholder for an on-demand note. Opening the note restores the full content from the remote sync folder.`,\n      ),\n    ].join(\"\\n\");\n  }\n\n  private async evictStaleSyncedNotes(showNotice: boolean) {\n    try {\n      if (this.settings.noteStorageMode !== \"lazy-notes\") {\n        if (showNotice) {\n          new Notice(this.t(\"\u5F53\u524D\u672A\u542F\u7528\u6309\u9700\u52A0\u8F7D\u7B14\u8BB0\u6A21\u5F0F\u3002\", \"Lazy note mode is not enabled.\"), 6000);\n        }\n        return 0;\n      }\n\n      const files = this.syncSupport.collectVaultContentFiles().filter((file) => file.extension === \"md\");\n      const now = Date.now();\n      const threshold = Math.max(1, this.settings.noteEvictAfterDays) * 24 * 60 * 60 * 1000;\n      let evicted = 0;\n\n      for (const file of files) {\n        const active = this.app.workspace.getActiveFile();\n        if (active?.path === file.path) {\n          continue;\n        }\n\n        const lastAccess = this.noteAccessTimestamps.get(file.path) ?? 0;\n        if (lastAccess !== 0 && now - lastAccess < threshold) {\n          continue;\n        }\n\n        const content = await this.app.vault.read(file);\n        if (this.parseNoteStub(content)) {\n          continue;\n        }\n\n        const binary = await this.app.vault.readBinary(file);\n        const remotePath = this.syncSupport.buildVaultSyncRemotePath(file.path);\n        await this.uploadBinary(remotePath, binary, \"text/markdown; charset=utf-8\");\n        const verified = await this.verifyRemoteBinaryRoundTrip(remotePath, binary);\n        if (!verified) {\n          throw new Error(this.t(\"\u8FDC\u7AEF\u6B63\u6587\u6821\u9A8C\u5931\u8D25\uFF0C\u5DF2\u53D6\u6D88\u56DE\u6536\u672C\u5730\u7B14\u8BB0\u3002\", \"Remote note verification failed, local note eviction was cancelled.\"));\n        }\n        const remote = await this.statRemoteFile(remotePath);\n        if (!remote) {\n          throw new Error(this.t(\"\u8FDC\u7AEF\u6B63\u6587\u5143\u6570\u636E\u7F3A\u5931\uFF0C\u5DF2\u53D6\u6D88\u56DE\u6536\u672C\u5730\u7B14\u8BB0\u3002\", \"Remote note metadata is missing, local note eviction was cancelled.\"));\n        }\n        await this.app.vault.modify(file, this.buildNoteStub(file));\n        const refreshed = this.getVaultFileByPath(file.path);\n        this.syncIndex.set(file.path, {\n          localSignature: refreshed ? this.syncSupport.buildSyncSignature(refreshed) : this.syncSupport.buildSyncSignature(file),\n          remoteSignature: remote?.signature ?? `${file.stat.mtime}:${binary.byteLength}`,\n          remotePath,\n        });\n        evicted += 1;\n      }\n\n      if (showNotice) {\n        new Notice(\n          this.t(\n            `\u5DF2\u56DE\u6536 ${evicted} \u7BC7\u957F\u671F\u672A\u8BBF\u95EE\u7684\u672C\u5730\u7B14\u8BB0\u3002`,\n            `Evicted ${evicted} stale local note(s).`,\n          ),\n          8000,\n        );\n      }\n      await this.savePluginState();\n      return evicted;\n    } catch (error) {\n      console.error(\"Failed to evict stale synced notes\", error);\n      if (showNotice) {\n        new Notice(this.describeError(this.t(\"\u56DE\u6536\u672C\u5730\u7B14\u8BB0\u5931\u8D25\", \"Failed to evict local notes\"), error), 8000);\n      }\n      return 0;\n    }\n  }\n\n  private async ensureRemoteDirectories(remotePath: string) {\n    const parts = remotePath.split(\"/\").filter((value) => value.length > 0);\n    if (parts.length <= 1) {\n      return;\n    }\n\n    let current = \"\";\n    for (let index = 0; index < parts.length - 1; index += 1) {\n      current = current ? `${current}/${parts[index]}` : parts[index];\n      const response = await this.requestUrl({\n        url: this.buildUploadUrl(current),\n        method: \"MKCOL\",\n        headers: {\n          Authorization: this.buildAuthHeader(),\n        },\n      });\n\n      if (![200, 201, 204, 207, 301, 302, 307, 308, 405].includes(response.status)) {\n        throw new Error(`MKCOL failed for ${current} with status ${response.status}`);\n      }\n    }\n  }\n\n  private async listRemoteTree(rootFolder: string): Promise<RemoteInventory> {\n    const files = new Map<string, RemoteFileState>();\n    const directories = new Set<string>();\n    const pending = [normalizeFolder(rootFolder)];\n    const visited = new Set<string>();\n\n    while (pending.length > 0) {\n      const current = normalizeFolder(pending.pop() ?? rootFolder);\n      if (visited.has(current)) {\n        continue;\n      }\n\n      visited.add(current);\n      const entries = await this.listRemoteDirectory(current);\n      for (const entry of entries) {\n        if (entry.isCollection) {\n          directories.add(entry.remotePath);\n          pending.push(entry.remotePath);\n          continue;\n        }\n\n        if (entry.file) {\n          files.set(entry.remotePath, entry.file);\n        }\n      }\n    }\n\n    return { files, directories };\n  }\n\n  private async listRemoteDirectory(remoteDirectory: string) {\n    const requestedPath = normalizeFolder(remoteDirectory);\n    const response = await this.requestUrl({\n      url: this.buildUploadUrl(requestedPath),\n      method: \"PROPFIND\",\n      headers: {\n        Authorization: this.buildAuthHeader(),\n        Depth: \"1\",\n      },\n    });\n\n    if (response.status === 404) {\n      return [] as Array<{ remotePath: string; isCollection: boolean; file?: RemoteFileState }>;\n    }\n\n    this.assertResponseSuccess(response, `PROPFIND for ${requestedPath}`);\n\n    const xmlText = this.decodeUtf8(response.arrayBuffer);\n    return this.parsePropfindDirectoryListing(xmlText, requestedPath);\n  }\n\n  private parsePropfindDirectoryListing(xmlText: string, requestedPath: string, includeRequested = false) {\n    const parser = new DOMParser();\n    const document = parser.parseFromString(xmlText, \"application/xml\");\n    if (document.getElementsByTagName(\"parsererror\").length > 0) {\n      throw new Error(this.t(\"\u65E0\u6CD5\u89E3\u6790 WebDAV \u76EE\u5F55\u6E05\u5355\u3002\", \"Failed to parse the WebDAV directory listing.\"));\n    }\n\n    const entries = new Map<string, { remotePath: string; isCollection: boolean; file?: RemoteFileState }>();\n    for (const element of Array.from(document.getElementsByTagName(\"*\"))) {\n      if (element.localName !== \"response\") {\n        continue;\n      }\n\n      const href = this.getXmlLocalNameText(element, \"href\");\n      if (!href) {\n        continue;\n      }\n\n      const remotePath = this.hrefToRemotePath(href);\n      if (!remotePath) {\n        continue;\n      }\n\n      const isCollection = this.xmlTreeHasLocalName(element, \"collection\");\n      const normalizedPath = isCollection ? normalizeFolder(remotePath) : remotePath.replace(/\\/+$/, \"\");\n      if (\n        !includeRequested &&\n        (\n          normalizedPath === requestedPath ||\n          normalizedPath === requestedPath.replace(/\\/+$/, \"\")\n        )\n      ) {\n        continue;\n      }\n\n      const sizeText = this.getXmlLocalNameText(element, \"getcontentlength\");\n      const parsedSize = Number.parseInt(sizeText, 10);\n      const size = Number.isFinite(parsedSize) ? parsedSize : 0;\n      const modifiedText = this.getXmlLocalNameText(element, \"getlastmodified\");\n      const parsedMtime = Date.parse(modifiedText);\n      const lastModified = Number.isFinite(parsedMtime) ? parsedMtime : 0;\n\n      entries.set(normalizedPath, {\n        remotePath: normalizedPath,\n        isCollection,\n        file: isCollection\n          ? undefined\n          : {\n              remotePath: normalizedPath,\n              lastModified,\n              size,\n              signature: this.syncSupport.buildRemoteSyncSignature({\n                lastModified,\n                size,\n              }),\n            },\n      });\n    }\n\n    return [...entries.values()];\n  }\n\n  private getXmlLocalNameText(parent: Element, localName: string) {\n    for (const element of Array.from(parent.getElementsByTagName(\"*\"))) {\n      if (element.localName === localName) {\n        return element.textContent?.trim() ?? \"\";\n      }\n    }\n\n    return \"\";\n  }\n\n  private xmlTreeHasLocalName(parent: Element, localName: string) {\n    return Array.from(parent.getElementsByTagName(\"*\")).some((element) => element.localName === localName);\n  }\n\n  private hrefToRemotePath(href: string) {\n    const baseUrl = `${this.settings.webdavUrl.replace(/\\/+$/, \"\")}/`;\n    const resolved = new URL(href, baseUrl);\n    const basePath = new URL(baseUrl).pathname.replace(/\\/+$/, \"/\");\n    const decodedPath = this.decodePathname(resolved.pathname);\n    if (!decodedPath.startsWith(basePath)) {\n      return null;\n    }\n\n    return decodedPath.slice(basePath.length).replace(/^\\/+/, \"\");\n  }\n\n  private decodePathname(pathname: string) {\n    return pathname\n      .split(\"/\")\n      .map((segment) => {\n        if (!segment) {\n          return \"\";\n        }\n\n        try {\n          return decodeURIComponent(segment);\n        } catch {\n          return segment;\n        }\n      })\n      .join(\"/\");\n  }\n\n  private buildExpectedRemoteDirectories(remoteFilePaths: Set<string>, rootFolder: string) {\n    const expected = new Set<string>([normalizeFolder(rootFolder)]);\n    for (const remotePath of remoteFilePaths) {\n      const parts = remotePath.split(\"/\").filter((value) => value.length > 0);\n      let current = \"\";\n      for (let index = 0; index < parts.length - 1; index += 1) {\n        current = current ? `${current}/${parts[index]}` : parts[index];\n        expected.add(normalizeFolder(current));\n      }\n    }\n\n    return expected;\n  }\n\n  private async reconcileDirectories(remoteDirectories: Set<string>) {\n    const stats = { createdLocal: 0, createdRemote: 0, deletedLocal: 0, deletedRemote: 0 };\n\n    const remoteLocalPaths = new Set<string>();\n    for (const remoteDir of remoteDirectories) {\n      const localPath = this.syncSupport.remotePathToVaultPath(remoteDir);\n      if (localPath !== null && localPath.length > 0 && !this.syncSupport.shouldSkipDirectorySyncPath(localPath)) {\n        remoteLocalPaths.add(normalizePath(localPath));\n      }\n    }\n\n    const localDirPaths = this.syncSupport.collectLocalSyncedDirectories();\n    const knownDirPaths = this.syncedDirectories;\n    const newSyncedDirs = new Set<string>();\n\n    const localOnly = [...localDirPaths].filter((p) => !remoteLocalPaths.has(p));\n    const remoteOnly = [...remoteLocalPaths].filter((p) => !localDirPaths.has(p));\n\n    // Local-only directories are kept locally and created remotely if needed.\n    for (const dirPath of [...localOnly].sort((a, b) => a.length - b.length)) {\n      const remoteDir = normalizeFolder(this.settings.vaultSyncRemoteFolder) + dirPath;\n      try {\n        await this.ensureRemoteDirectories(remoteDir);\n        stats.createdRemote += 1;\n      } catch {\n        // Directory creation failures should not make reconcile destructive.\n      }\n      newSyncedDirs.add(dirPath);\n    }\n\n    // Both sides exist \u2192 keep\n    for (const dirPath of localDirPaths) {\n      if (remoteLocalPaths.has(dirPath)) {\n        newSyncedDirs.add(dirPath);\n      }\n    }\n\n    // Remote-only directories are kept remotely and recreated locally if needed.\n    for (const dirPath of [...remoteOnly].sort((a, b) => a.length - b.length)) {\n      if (!(await this.app.vault.adapter.exists(dirPath))) {\n        try {\n          await this.app.vault.adapter.mkdir(dirPath);\n        } catch (e) {\n          const msg = e instanceof Error ? e.message : String(e);\n          if (!msg.includes(\"already exists\")) {\n            throw e;\n          }\n        }\n      }\n      stats.createdLocal += 1;\n      newSyncedDirs.add(dirPath);\n    }\n\n    this.syncedDirectories = newSyncedDirs;\n    return stats;\n  }\n\n  private async deleteExtraRemoteDirectories(remoteDirectories: Set<string>, expectedDirectories: Set<string>) {\n    let deleted = 0;\n    const candidates = [...remoteDirectories]\n      .filter((remotePath) => !expectedDirectories.has(remotePath))\n      .sort((a, b) => b.length - a.length || b.localeCompare(a));\n\n    for (const remotePath of candidates) {\n      const response = await this.requestUrl({\n        url: this.buildUploadUrl(remotePath),\n        method: \"DELETE\",\n        headers: {\n          Authorization: this.buildAuthHeader(),\n        },\n      });\n\n      if ([200, 202, 204, 404].includes(response.status)) {\n        if (response.status !== 404) {\n          deleted += 1;\n        }\n        continue;\n      }\n\n      if ([405, 409].includes(response.status)) {\n        continue;\n      }\n\n      throw new Error(`DELETE directory failed for ${remotePath} with status ${response.status}`);\n    }\n\n    return deleted;\n  }\n\n  private async processPendingTasks() {\n\n    await this.uploadQueue.processPendingTasks();\n  }\n\n  private trackVaultMutation(operation: () => Promise<void>) {\n    const promise = operation()\n      .catch((error) => {\n        console.error(\"Secure WebDAV vault mutation handling failed\", error);\n      })\n      .finally(() => {\n        this.pendingVaultMutationPromises.delete(promise);\n      });\n    this.pendingVaultMutationPromises.add(promise);\n  }\n\n  private async waitForPendingVaultMutations() {\n    while (this.pendingVaultMutationPromises.size > 0) {\n      await Promise.allSettled([...this.pendingVaultMutationPromises]);\n    }\n  }\n\n  private async preparePendingUploadsForSync(showNotice: boolean) {\n\n    await this.uploadQueue.processPendingTasks();\n\n    if (this.uploadQueue.hasPendingWork()) {\n      this.lastVaultSyncAt = Date.now();\n      this.lastVaultSyncStatus = this.t(\n        \"\u68C0\u6D4B\u5230\u56FE\u7247\u4E0A\u4F20\u4ECD\u5728\u8FDB\u884C\u6216\u7B49\u5F85\u91CD\u8BD5\uFF0C\u5DF2\u6682\u7F13\u672C\u6B21\u7B14\u8BB0\u540C\u6B65\uFF0C\u907F\u514D\u65E7\u7248\u7B14\u8BB0\u8986\u76D6\u65B0\u56FE\u7247\u5F15\u7528\u3002\",\n        \"Image uploads are still running or waiting for retry, so note sync was deferred to avoid old note content overwriting new image references.\",\n      );\n      await this.savePluginState();\n      if (showNotice) {\n        new Notice(this.lastVaultSyncStatus, 8000);\n      }\n      return false;\n    }\n\n    return true;\n  }\n\n  private async uploadImagesInNote(noteFile: TFile) {\n    try {\n      const content = await this.app.vault.read(noteFile);\n      const replacements = await this.buildUploadReplacements(content, noteFile);\n\n      if (replacements.length === 0) {\n        new Notice(this.t(\"\u5F53\u524D\u7B14\u8BB0\u4E2D\u6CA1\u6709\u627E\u5230\u672C\u5730\u56FE\u7247\u3002\", \"No local images found in the current note.\"));\n        return;\n      }\n\n      let updated = content;\n      for (const replacement of replacements) {\n        updated = updated.split(replacement.original).join(replacement.rewritten);\n      }\n\n      if (updated === content) {\n        new Notice(this.t(\"\u6CA1\u6709\u9700\u8981\u6539\u5199\u7684\u56FE\u7247\u94FE\u63A5\u3002\", \"No images were rewritten.\"));\n        return;\n      }\n\n      await this.app.vault.modify(noteFile, updated);\n      this.schedulePriorityNoteSync(noteFile.path, \"image-add\");\n\n      if (this.settings.deleteLocalAfterUpload) {\n        for (const replacement of replacements) {\n          if (replacement.sourceFile) {\n            await this.trashIfExists(replacement.sourceFile);\n          }\n        }\n      }\n\n      new Notice(this.t(`\u5DF2\u4E0A\u4F20 ${replacements.length} \u5F20\u56FE\u7247\u5230 WebDAV\u3002`, `Uploaded ${replacements.length} image(s) to WebDAV.`));\n    } catch (error) {\n      console.error(\"Secure WebDAV upload failed\", error);\n      new Notice(this.describeError(this.t(\"\u4E0A\u4F20\u5931\u8D25\", \"Upload failed\"), error), 8000);\n    }\n  }\n\n  private async processTask(task: UploadTask) {\n\n    await this.uploadQueue.processTask(task);\n  }\n\n  private escapeHtml(value: string) {\n    return value\n      .replace(/&/g, \"&amp;\")\n      .replace(/\"/g, \"&quot;\")\n      .replace(/</g, \"&lt;\")\n      .replace(/>/g, \"&gt;\");\n  }\n\n  private unescapeHtml(value: string) {\n    return value\n      .replace(/&quot;/g, \"\\\"\")\n      .replace(/&gt;/g, \">\")\n      .replace(/&lt;/g, \"<\")\n      .replace(/&amp;/g, \"&\");\n  }\n\n  private async fetchSecureImageBlobUrl(remotePath: string) {\n    const response = await this.requestUrl({\n      url: this.buildUploadUrl(remotePath),\n      method: \"GET\",\n      headers: {\n        Authorization: this.buildAuthHeader(),\n      },\n    });\n\n    this.assertResponseSuccess(response, \"Fetch secure image\");\n\n    const blob = new Blob([response.arrayBuffer], {\n      type: response.headers[\"content-type\"] ?? \"application/octet-stream\",\n    });\n    const blobUrl = URL.createObjectURL(blob);\n    this.evictBlobUrlsIfNeeded();\n    this.blobUrls.add(blobUrl);\n    return blobUrl;\n  }\n\n  private evictBlobUrlsIfNeeded() {\n    while (this.blobUrls.size >= this.maxBlobUrls) {\n      const oldest = this.blobUrls.values().next().value!;\n      this.blobUrls.delete(oldest);\n      URL.revokeObjectURL(oldest);\n    }\n  }\n\n  private arrayBufferToBase64(buffer: ArrayBuffer) {\n    const bytes = new Uint8Array(buffer);\n    const chunkSize = 0x8000;\n    let binary = \"\";\n    for (let index = 0; index < bytes.length; index += chunkSize) {\n      const chunk = bytes.subarray(index, index + chunkSize);\n      binary += String.fromCharCode(...chunk);\n    }\n    return btoa(binary);\n  }\n\n  private base64ToArrayBuffer(base64: string) {\n    const binary = atob(base64);\n    const bytes = new Uint8Array(binary.length);\n    for (let index = 0; index < binary.length; index += 1) {\n      bytes[index] = binary.charCodeAt(index);\n    }\n    return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) as ArrayBuffer;\n  }\n\n  private arrayBuffersEqual(left: ArrayBuffer, right: ArrayBuffer) {\n    const a = new Uint8Array(left);\n    const b = new Uint8Array(right);\n    if (a.length !== b.length) {\n      return false;\n    }\n\n    for (let index = 0; index < a.length; index += 1) {\n      if (a[index] !== b[index]) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  private buildClipboardFileName(mimeType: string) {\n    const extension = mimeType.split(\"/\")[1]?.replace(\"jpeg\", \"jpg\") || \"png\";\n    return `pasted-image-${Date.now()}.${extension}`;\n  }\n\n  private escapeRegExp(value: string) {\n    return value.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n  }\n\n  private buildRemotePath(fileName: string) {\n    return `${normalizeFolder(this.settings.remoteFolder)}${fileName}`;\n  }\n\n  private async buildRemoteFileNameFromBinary(fileName: string, binary: ArrayBuffer) {\n    const extension = this.getExtensionFromFileName(fileName);\n    if (this.settings.namingStrategy === \"hash\") {\n      const hash = (await this.computeSha256Hex(binary)).slice(0, 16);\n      return `${hash}.${extension}`;\n    }\n\n    return `${Date.now()}-${fileName}`;\n  }\n\n  private buildUploadUrl(remotePath: string) {\n    const base = this.settings.webdavUrl.replace(/\\/+$/, \"\");\n    return `${base}/${remotePath.split(\"/\").map(encodeURIComponent).join(\"/\")}`;\n  }\n\n  private buildAuthHeader() {\n    const token = this.arrayBufferToBase64(this.encodeUtf8(`${this.settings.username}:${this.settings.password}`));\n    return `Basic ${token}`;\n  }\n\n  private ensureConfigured() {\n    if (!this.settings.webdavUrl || !this.settings.username || !this.settings.password) {\n      throw new Error(this.t(\"WebDAV \u914D\u7F6E\u4E0D\u5B8C\u6574\u3002\", \"WebDAV settings are incomplete.\"));\n    }\n  }\n\n  private assertResponseSuccess(response: { status: number }, context: string) {\n    if (response.status < 200 || response.status >= 300) {\n      throw new Error(`${context} failed with status ${response.status}`);\n    }\n  }\n\n  private getMimeType(extension: string) {\n    return MIME_MAP[extension.toLowerCase()] ?? \"application/octet-stream\";\n  }\n\n  private getMimeTypeFromFileName(fileName: string) {\n    return this.getMimeType(this.getExtensionFromFileName(fileName));\n  }\n\n  private getExtensionFromFileName(fileName: string) {\n    const pieces = fileName.split(\".\");\n    return pieces.length > 1 ? pieces[pieces.length - 1].toLowerCase() : \"png\";\n  }\n\n  private async prepareUploadPayload(binary: ArrayBuffer, mimeType: string, fileName: string) {\n    if (!this.settings.compressImages) {\n      return { binary, mimeType, fileName };\n    }\n\n    const prepared = await this.compressImageIfNeeded(binary, mimeType, fileName);\n    return prepared ?? { binary, mimeType, fileName };\n  }\n\n  private async compressImageIfNeeded(binary: ArrayBuffer, mimeType: string, fileName: string) {\n    if (!/^image\\/(png|jpeg|jpg|webp)$/i.test(mimeType)) {\n      return null;\n    }\n\n    const thresholdBytes = this.settings.compressThresholdKb * 1024;\n    const sourceBlob = new Blob([binary], { type: mimeType });\n    const image = await this.loadImageElement(sourceBlob);\n    const largestSide = Math.max(image.naturalWidth, image.naturalHeight);\n    const needsResize = largestSide > this.settings.maxImageDimension;\n    const needsCompress = sourceBlob.size > thresholdBytes || needsResize;\n    if (!needsCompress) {\n      return null;\n    }\n\n    const scale = needsResize ? this.settings.maxImageDimension / largestSide : 1;\n    const targetWidth = Math.max(1, Math.round(image.naturalWidth * scale));\n    const targetHeight = Math.max(1, Math.round(image.naturalHeight * scale));\n    const canvas = document.createElement(\"canvas\");\n    canvas.width = targetWidth;\n    canvas.height = targetHeight;\n    const context = canvas.getContext(\"2d\");\n    if (!context) {\n      return null;\n    }\n\n    context.drawImage(image, 0, 0, targetWidth, targetHeight);\n\n    const outputMime = mimeType.toLowerCase() === \"image/jpg\" ? \"image/jpeg\" : mimeType;\n    const quality = Math.max(0.4, Math.min(0.98, this.settings.jpegQuality / 100));\n    const compressedBlob = await new Promise<Blob | null>((resolve) => {\n      canvas.toBlob(resolve, outputMime, quality);\n    });\n\n    if (!compressedBlob) {\n      return null;\n    }\n\n    if (!needsResize && compressedBlob.size >= sourceBlob.size) {\n      return null;\n    }\n\n    const nextBinary = await compressedBlob.arrayBuffer();\n    const nextExtension = this.extensionFromMimeType(outputMime) ?? this.getExtensionFromFileName(fileName);\n    const nextFileName = fileName.replace(/\\.[^.]+$/, \"\") + `.${nextExtension}`;\n    return {\n      binary: nextBinary,\n      mimeType: outputMime,\n      fileName: nextFileName,\n    };\n  }\n\n  private loadImageElement(blob: Blob) {\n    return new Promise<HTMLImageElement>((resolve, reject) => {\n      const url = URL.createObjectURL(blob);\n      const image = new Image();\n      image.onload = () => {\n        URL.revokeObjectURL(url);\n        resolve(image);\n      };\n      image.onerror = (error) => {\n        URL.revokeObjectURL(url);\n        reject(error);\n      };\n      image.src = url;\n    });\n  }\n\n  private extensionFromMimeType(mimeType: string) {\n    return MIME_MAP[mimeType] ?? null;\n  }\n\n  private async trashIfExists(file: TAbstractFile) {\n    try {\n      await this.app.vault.trash(file, true);\n    } catch (error) {\n      console.warn(\"Failed to trash local image after upload\", error);\n    }\n  }\n\n  private formatEmbedLabel(fileName: string) {\n    return this.t(`\u3010\u5B89\u5168\u8FDC\u7A0B\u56FE\u7247\uFF5C${fileName}\u3011`, `[Secure remote image | ${fileName}]`);\n  }\n\n  private formatFailedLabel(fileName: string) {\n    return this.t(`\u3010\u56FE\u7247\u4E0A\u4F20\u5931\u8D25\uFF5C${fileName}\u3011`, `[Image upload failed | ${fileName}]`);\n  }\n\n  async migrateAllLegacySecureImages() {\n    try {\n      const uploadCache = new Map<string, string>();\n      const candidateLocalImages = new Map<string, TFile>();\n      let changedFiles = 0;\n      for (const file of this.app.vault.getMarkdownFiles()) {\n        const content = await this.app.vault.read(file);\n        const replacements = await this.buildUploadReplacements(content, file, uploadCache);\n        for (const replacement of replacements) {\n          if (replacement.sourceFile) {\n            candidateLocalImages.set(replacement.sourceFile.path, replacement.sourceFile);\n          }\n        }\n\n        let updated = content;\n        for (const replacement of replacements) {\n          updated = updated.split(replacement.original).join(replacement.rewritten);\n        }\n\n        updated = updated\n          .replace(\n            /<span class=\"secure-webdav-embed\" data-secure-webdav=\"([^\"]+)\" aria-label=\"([^\"]*)\">.*?<\\/span>/g,\n            (_match, remotePath: string, alt: string) =>\n              this.imageSupport.buildSecureImageCodeBlock(\n                this.unescapeHtml(remotePath),\n                this.unescapeHtml(alt) || this.unescapeHtml(remotePath),\n              ),\n          )\n          .replace(\n            /!\\[[^\\]]*]\\(webdav-secure:\\/\\/([^)]+)\\)/g,\n            (_match, remotePath: string) =>\n              this.imageSupport.buildSecureImageCodeBlock(this.unescapeHtml(remotePath), this.unescapeHtml(remotePath)),\n          );\n\n        if (updated === content) {\n          continue;\n        }\n\n        await this.app.vault.modify(file, updated);\n        changedFiles += 1;\n      }\n\n      if (changedFiles === 0) {\n        new Notice(\n          this.t(\n            \"\u6574\u5E93\u91CC\u6CA1\u6709\u53D1\u73B0\u53EF\u8FC1\u79FB\u7684\u65E7\u7248\u5B89\u5168\u56FE\u7247\u6807\u7B7E\u3002\",\n            \"No legacy secure image tags were found in the vault.\",\n          ),\n        );\n        return;\n      }\n\n      if (this.settings.deleteLocalAfterUpload) {\n        await this.trashMigratedImagesIfSafe(candidateLocalImages);\n      }\n\n      new Notice(\n      this.t(\n        `\u5DF2\u8FC1\u79FB ${changedFiles} \u7BC7\u7B14\u8BB0\u5230\u65B0\u7684\u5B89\u5168\u56FE\u7247\u4EE3\u7801\u5757\u683C\u5F0F\u3002`,\n        `Migrated ${changedFiles} note(s) to the new secure image code-block format.`,\n      ),\n        8000,\n      );\n    } catch (error) {\n      console.error(\"Failed to migrate secure images to code blocks\", error);\n      new Notice(this.describeError(this.t(\"\u8FC1\u79FB\u5B89\u5168\u56FE\u7247\u683C\u5F0F\u5931\u8D25\", \"Failed to migrate secure image format\"), error), 8000);\n    }\n  }\n\n  private async trashMigratedImagesIfSafe(candidateLocalImages: Map<string, TFile>) {\n    if (candidateLocalImages.size === 0) {\n      return;\n    }\n\n    const remainingRefs = new Set<string>();\n    for (const note of this.app.vault.getMarkdownFiles()) {\n      const content = await this.app.vault.read(note);\n      const wikiMatches = [...content.matchAll(/!\\[\\[([^\\]]+)\\]\\]/g)];\n      const markdownMatches = [...content.matchAll(/!\\[[^\\]]*]\\(([^)]+)\\)/g)];\n\n      for (const match of wikiMatches) {\n        const rawLink = match[1].split(\"|\")[0].trim();\n        const target = this.resolveLinkedFile(rawLink, note.path);\n        if (target && this.isImageFile(target)) {\n          remainingRefs.add(target.path);\n        }\n      }\n\n      for (const match of markdownMatches) {\n        const rawLink = decodeURIComponent(match[1].trim().replace(/^<|>$/g, \"\"));\n        if (/^(https?:|webdav-secure:|data:)/i.test(rawLink)) {\n          continue;\n        }\n\n        const target = this.resolveLinkedFile(rawLink, note.path);\n        if (target && this.isImageFile(target)) {\n          remainingRefs.add(target.path);\n        }\n      }\n    }\n\n    for (const [path, file] of candidateLocalImages.entries()) {\n      if (remainingRefs.has(path)) {\n        continue;\n      }\n\n      await this.trashIfExists(file);\n    }\n  }\n\n  async runConnectionTest(showModal = false) {\n    try {\n      this.ensureConfigured();\n\n      const probeName = `.secure-webdav-probe-${Date.now()}.txt`;\n      const remotePath = this.buildRemotePath(probeName);\n      const uploadUrl = this.buildUploadUrl(remotePath);\n      const probeArrayBuffer = this.encodeUtf8(`secure-webdav probe ${new Date().toISOString()}`);\n\n      const putResponse = await this.requestUrl({\n        url: uploadUrl,\n        method: \"PUT\",\n        headers: {\n          Authorization: this.buildAuthHeader(),\n          \"Content-Type\": \"text/plain; charset=utf-8\",\n        },\n        body: probeArrayBuffer,\n      });\n      if (putResponse.status < 200 || putResponse.status >= 300) {\n        throw new Error(`PUT failed with status ${putResponse.status}`);\n      }\n\n      const getResponse = await this.requestUrl({\n        url: uploadUrl,\n        method: \"GET\",\n        headers: {\n          Authorization: this.buildAuthHeader(),\n        },\n      });\n      if (getResponse.status < 200 || getResponse.status >= 300) {\n        throw new Error(`GET failed with status ${getResponse.status}`);\n      }\n\n      const deleteResponse = await this.requestUrl({\n        url: uploadUrl,\n        method: \"DELETE\",\n        headers: {\n          Authorization: this.buildAuthHeader(),\n        },\n      });\n      if (deleteResponse.status < 200 || deleteResponse.status >= 300) {\n        throw new Error(`DELETE failed with status ${deleteResponse.status}`);\n      }\n\n      const message = this.t(\n        `WebDAV \u6D4B\u8BD5\u901A\u8FC7\u3002PUT ${putResponse.status}\uFF0CGET ${getResponse.status}\uFF0CDELETE ${deleteResponse.status}\u3002`,\n        `WebDAV test passed. PUT ${putResponse.status}, GET ${getResponse.status}, DELETE ${deleteResponse.status}.`,\n      );\n      new Notice(message, 6000);\n      if (showModal) {\n        new ResultModal(this.app, this.t(\"WebDAV \u8FDE\u63A5\", \"WebDAV Connection\"), message).open();\n      }\n      return true;\n    } catch (error) {\n      console.error(\"Secure WebDAV test failed\", error);\n      const message = this.describeError(this.t(\"WebDAV \u6D4B\u8BD5\u5931\u8D25\", \"WebDAV test failed\"), error);\n      new Notice(message, 8000);\n      if (showModal) {\n        new ResultModal(this.app, this.t(\"WebDAV \u8FDE\u63A5\", \"WebDAV Connection\"), message).open();\n      }\n      return false;\n    }\n  }\n\n  private describeError(prefix: string, error: unknown) {\n    const message = error instanceof Error ? error.message : String(error);\n    return `${prefix}: ${message}`;\n  }\n\n  private async requestUrl(options: {\n    url: string;\n    method: string;\n    headers?: Record<string, string>;\n    body?: ArrayBuffer;\n    followRedirects?: boolean;\n    redirectCount?: number;\n  }): Promise<{ status: number; headers: Record<string, string>; arrayBuffer: ArrayBuffer }> {\n    const response = await obsidianRequestUrl({\n      url: options.url,\n      method: options.method,\n      headers: options.headers,\n      body: options.body,\n      throw: false,\n    });\n\n    return {\n      status: response.status,\n      headers: response.headers,\n      arrayBuffer: response.arrayBuffer,\n    };\n  }\n\n  private encodeUtf8(value: string) {\n    const bytes = new TextEncoder().encode(value);\n    return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) as ArrayBuffer;\n  }\n\n  private decodeUtf8(buffer: ArrayBuffer) {\n    return new TextDecoder().decode(buffer);\n  }\n\n  private async computeSha256Hex(buffer: ArrayBuffer) {\n    const digest = await crypto.subtle.digest(\"SHA-256\", buffer);\n    return Array.from(new Uint8Array(digest))\n      .map((value) => value.toString(16).padStart(2, \"0\"))\n      .join(\"\");\n  }\n}\n\ntype UploadRewrite = {\n  original: string;\n  rewritten: string;\n  sourceFile?: TFile;\n};\n\nclass SecureWebdavSettingTab extends PluginSettingTab {\n  plugin: SecureWebdavImagesPlugin;\n\n  constructor(app: App, plugin: SecureWebdavImagesPlugin) {\n    super(app, plugin);\n    this.plugin = plugin;\n  }\n\n  display(): void {\n    const { containerEl } = this;\n    containerEl.empty();\n\n    containerEl.createEl(\"h2\", { text: \"Secure WebDAV Images\" });\n    containerEl.createEl(\"p\", {\n      text: this.plugin.t(\n        \"\u8FD9\u4E2A\u63D2\u4EF6\u53EA\u628A\u56FE\u7247\u5265\u79BB\u5230\u5355\u72EC\u7684\u8FDC\u7AEF\u76EE\u5F55\uFF0C\u5E76\u4FDD\u5B58\u4E3A secure-webdav \u81EA\u5B9A\u4E49\u4EE3\u7801\u5757\uFF1B\u5176\u4ED6\u7B14\u8BB0\u548C\u9644\u4EF6\u6309\u539F\u8DEF\u5F84\u539F\u6837\u540C\u6B65\u3002\",\n        \"This plugin separates only images into a dedicated remote folder and stores them as secure-webdav custom code blocks. Notes and other attachments are synced as-is with their original paths.\",\n      ),\n    });\n\n    new Setting(containerEl)\n      .setName(this.plugin.t(\"\u5F53\u524D\u63D2\u4EF6\u7248\u672C\", \"Current plugin version\"))\n      .setDesc(\n        this.plugin.t(\n          \"\u591A\u7AEF\u4F7F\u7528\u65F6\u53EF\u5148\u6838\u5BF9\u8FD9\u91CC\u7684\u7248\u672C\u53F7\uFF0C\u907F\u514D\u56E0\u4E3A\u5BA2\u6237\u7AEF\u5347\u7EA7\u4E0D\u5230\u4F4D\u5BFC\u81F4\u884C\u4E3A\u4E0D\u4E00\u81F4\u3002\",\n          \"Check this version first across devices to avoid inconsistent behavior caused by incomplete upgrades.\",\n        ),\n      )\n      .addText((text) => {\n        text.setValue(this.plugin.manifest.version);\n        text.setDisabled(true);\n      });\n\n    containerEl.createEl(\"h3\", { text: this.plugin.t(\"\u754C\u9762\u8BED\u8A00\", \"Interface language\") });\n\n    new Setting(containerEl)\n      .setName(this.plugin.t(\"\u8BED\u8A00\", \"Language\"))\n      .setDesc(this.plugin.t(\"\u8BBE\u7F6E\u9875\u652F\u6301\u81EA\u52A8\u3001\u4E2D\u6587\u3001\u82F1\u6587\u5207\u6362\u3002\", \"Switch the settings UI between auto, Chinese, and English.\"))\n      .addDropdown((dropdown) =>\n        dropdown\n          .addOption(\"auto\", this.plugin.t(\"\u81EA\u52A8\", \"Auto\"))\n          .addOption(\"zh\", \"\u4E2D\u6587\")\n          .addOption(\"en\", \"English\")\n          .setValue(this.plugin.settings.language)\n          .onChange(async (value) => {\n            this.plugin.settings.language = value as \"auto\" | \"zh\" | \"en\";\n            await this.plugin.saveSettings();\n            this.display();\n          }),\n      );\n\n    containerEl.createEl(\"h3\", { text: this.plugin.t(\"\u8FDE\u63A5\u8BBE\u7F6E\", \"Connection\") });\n\n    new Setting(containerEl)\n      .setName(this.plugin.t(\"WebDAV \u57FA\u7840\u5730\u5740\", \"WebDAV base URL\"))\n      .setDesc(this.plugin.t(\"\u670D\u52A1\u5668\u57FA\u7840\u5730\u5740\uFF0C\u4F8B\u5982\uFF1Ahttp://your-webdav-host:port\", \"Base server URL. Example: http://your-webdav-host:port\"))\n      .addText((text) =>\n        text\n          .setPlaceholder(\"http://your-webdav-host:port\")\n          .setValue(this.plugin.settings.webdavUrl)\n          .onChange(async (value) => {\n            this.plugin.settings.webdavUrl = value.trim();\n            await this.plugin.saveSettings();\n          }),\n      );\n\n    new Setting(containerEl)\n      .setName(this.plugin.t(\"\u8D26\u53F7\", \"Username\"))\n      .addText((text) =>\n        text.setValue(this.plugin.settings.username).onChange(async (value) => {\n          this.plugin.settings.username = value.trim();\n          await this.plugin.saveSettings();\n        }),\n      );\n\n    new Setting(containerEl)\n      .setName(this.plugin.t(\"\u5BC6\u7801\", \"Password\"))\n      .setDesc(this.plugin.t(\"\u9ED8\u8BA4\u9690\u85CF\uFF0C\u53EF\u70B9\u51FB\u53F3\u4FA7\u6309\u94AE\u663E\u793A\u6216\u9690\u85CF\u3002\", \"Hidden by default. Use the button on the right to show or hide it.\"))\n      .addText((text) => {\n        text.inputEl.type = \"password\";\n        text.setValue(this.plugin.settings.password).onChange(async (value) => {\n          this.plugin.settings.password = value;\n          await this.plugin.saveSettings();\n        });\n      })\n      .addExtraButton((button) => {\n        let visible = false;\n        button.setIcon(\"eye\");\n        button.setTooltip(this.plugin.t(\"\u663E\u793A\u5BC6\u7801\", \"Show password\"));\n        button.onClick(() => {\n          const input = button.extraSettingsEl.parentElement?.querySelector(\"input\");\n          if (!(input instanceof HTMLInputElement)) {\n            return;\n          }\n\n          visible = !visible;\n          input.type = visible ? \"text\" : \"password\";\n          button.setIcon(visible ? \"eye-off\" : \"eye\");\n          button.setTooltip(this.plugin.t(visible ? \"\u9690\u85CF\u5BC6\u7801\" : \"\u663E\u793A\u5BC6\u7801\", visible ? \"Hide password\" : \"Show password\"));\n        });\n      });\n\n    new Setting(containerEl)\n      .setName(this.plugin.t(\"\u56FE\u7247\u8FDC\u7A0B\u76EE\u5F55\", \"Image remote folder\"))\n      .setDesc(\n        this.plugin.t(\n          \"\u4E13\u95E8\u7528\u4E8E\u5B58\u653E\u8FDC\u7A0B\u56FE\u7247\u7684 WebDAV \u76EE\u5F55\uFF0C\u4F8B\u5982\uFF1A/remote-images/\u3002\u56FE\u7247\u4E0A\u4F20\u6210\u529F\u540E\u4F1A\u7ACB\u5373\u5220\u9664\u672C\u5730\u56FE\u7247\u6587\u4EF6\u3002\",\n          \"Dedicated WebDAV folder for remote images, for example: /remote-images/. Local image files are deleted immediately after upload succeeds.\",\n        ),\n      )\n      .addText((text) =>\n        text.setValue(this.plugin.settings.remoteFolder).onChange(async (value) => {\n          this.plugin.settings.remoteFolder = normalizePath(value.trim() || \"/remote-images/\");\n          await this.plugin.saveSettings();\n        }),\n      );\n\n    new Setting(containerEl)\n      .setName(this.plugin.t(\"\u6D4B\u8BD5\u8FDE\u63A5\", \"Test connection\"))\n      .setDesc(this.plugin.t(\"\u4F7F\u7528\u4E34\u65F6\u63A2\u9488\u6587\u4EF6\u9A8C\u8BC1 PUT\u3001GET\u3001DELETE \u662F\u5426\u6B63\u5E38\u3002\", \"Verify PUT, GET, and DELETE using a temporary probe file.\"))\n      .addButton((button) =>\n        button.setButtonText(this.plugin.t(\"\u5F00\u59CB\u6D4B\u8BD5\", \"Run test\")).onClick(async () => {\n          button.setDisabled(true);\n          try {\n            await this.plugin.runConnectionTest(true);\n          } finally {\n            button.setDisabled(false);\n          }\n        }),\n      );\n\n    containerEl.createEl(\"h3\", { text: this.plugin.t(\"\u540C\u6B65\u8BBE\u7F6E\", \"Sync\") });\n\n    new Setting(containerEl)\n      .setName(this.plugin.t(\"\u8FDC\u7A0B\u7B14\u8BB0\u76EE\u5F55\", \"Remote notes folder\"))\n      .setDesc(\n        this.plugin.t(\n          \"\u7528\u4E8E\u5B58\u653E\u7B14\u8BB0\u548C\u5176\u4ED6\u975E\u56FE\u7247\u9644\u4EF6\u539F\u6837\u540C\u6B65\u526F\u672C\u7684\u8FDC\u7AEF\u76EE\u5F55\uFF0C\u4F8B\u5982\uFF1A/vault-sync/\u3002\u63D2\u4EF6\u4F1A\u81EA\u52A8\u540C\u6B65\u6574\u4E2A vault\uFF0C\u5E76\u8DF3\u8FC7 .obsidian\u3001\u63D2\u4EF6\u76EE\u5F55\u548C\u56FE\u7247\u6587\u4EF6\u3002\",\n          \"Remote folder used for notes and other non-image attachments synced as-is, for example: /vault-sync/. The plugin syncs the whole vault and automatically skips .obsidian, the plugin directory, and image files.\",\n        ),\n      )\n      .addText((text) =>\n        text.setValue(this.plugin.settings.vaultSyncRemoteFolder).onChange(async (value) => {\n          this.plugin.settings.vaultSyncRemoteFolder = normalizePath(value.trim() || \"/vault-sync/\");\n          await this.plugin.saveSettings();\n        }),\n      );\n\n    new Setting(containerEl)\n      .setName(this.plugin.t(\"\u4E0D\u540C\u6B65\u76EE\u5F55\", \"Excluded sync folders\"))\n      .setDesc(\n        this.plugin.t(\n          \"\u8FD9\u4E9B vault \u76EE\u5F55\u4E0D\u4F1A\u88AB\u5185\u5BB9\u540C\u6B65\u4E0A\u4F20\u3001\u4ECE\u8FDC\u7AEF\u6062\u590D\u6216\u8FDB\u884C\u76EE\u5F55\u5BF9\u8D26\u3002\u652F\u6301\u9017\u53F7\u6216\u6362\u884C\u5206\u9694\uFF0C\u9ED8\u8BA4\uFF1Akb\u3002\",\n          \"These vault folders are not uploaded, restored from remote, or reconciled as directories. Separate entries with commas or new lines. Default: kb.\",\n        ),\n      )\n      .addTextArea((text) =>\n        text\n          .setPlaceholder(\"kb\")\n          .setValue((this.plugin.settings.excludedSyncFolders ?? []).join(\"\\n\"))\n          .onChange(async (value) => {\n            this.plugin.settings.excludedSyncFolders = value.split(/[,\\n]/);\n            this.plugin.normalizeEffectiveSettings();\n            await this.plugin.saveSettings();\n          }),\n      );\n\n    new Setting(containerEl)\n      .setName(this.plugin.t(\"\u81EA\u52A8\u540C\u6B65\u9891\u7387\", \"Auto sync frequency\"))\n      .setDesc(\n        this.plugin.t(\n          \"\u4EE5\u5206\u949F\u4E3A\u5355\u4F4D\u8BBE\u7F6E\u81EA\u52A8\u540C\u6B65\u65F6\u95F4\u3002\u586B 0 \u8868\u793A\u5173\u95ED\u81EA\u52A8\u540C\u6B65\u3002\u8FD9\u91CC\u7684\u81EA\u52A8\u540C\u6B65\u6267\u884C\u201C\u5B8C\u6574\u540C\u6B65\u201D\uFF1A\u4F1A\u68C0\u67E5\u672C\u5730\u4E0E\u8FDC\u7AEF\u5DEE\u5F02\uFF0C\u4E0A\u4F20\u672C\u5730\u53D8\u66F4\uFF0C\u5E76\u62C9\u53D6\u8FDC\u7AEF\u66F4\u65B0\u3002\",\n          \"Set the automatic sync interval in minutes. Use 0 to turn it off. Auto sync runs the full sync flow: it checks local and remote differences, uploads local changes, and pulls remote updates.\",\n        ),\n      )\n      .addText((text) =>\n        text\n          .setPlaceholder(\"0\")\n          .setValue(String(this.plugin.settings.autoSyncIntervalMinutes))\n          .onChange(async (value) => {\n            const parsed = Number.parseInt(value, 10);\n            if (!Number.isNaN(parsed)) {\n              this.plugin.settings.autoSyncIntervalMinutes = Math.max(0, parsed);\n              await this.plugin.saveSettings();\n            }\n          }),\n      );\n\n    new Setting(containerEl)\n      .setName(this.plugin.t(\"\u7B14\u8BB0\u672C\u5730\u4FDD\u7559\u6A21\u5F0F\", \"Note local retention mode\"))\n      .setDesc(\n        this.plugin.t(\n          \"\u5B8C\u6574\u672C\u5730\uFF1A\u7B14\u8BB0\u59CB\u7EC8\u4FDD\u7559\u5728\u672C\u5730\u3002\u6309\u9700\u52A0\u8F7D\u7B14\u8BB0\uFF1A\u957F\u671F\u672A\u8BBF\u95EE\u7684 Markdown \u7B14\u8BB0\u4F1A\u88AB\u66FF\u6362\u4E3A\u672C\u5730\u5360\u4F4D\u6587\u4EF6\uFF0C\u6253\u5F00\u65F6\u518D\u4ECE\u8FDC\u7AEF\u6062\u590D\u3002\",\n          \"Full local: notes always stay local. Lazy notes: stale Markdown notes are replaced with local placeholder files and restored from remote when opened.\",\n        ),\n      )\n      .addDropdown((dropdown) =>\n        dropdown\n          .addOption(\"full-local\", this.plugin.t(\"\u5B8C\u6574\u672C\u5730\", \"Full local\"))\n          .addOption(\"lazy-notes\", this.plugin.t(\"\u6309\u9700\u52A0\u8F7D\u7B14\u8BB0\", \"Lazy notes\"))\n          .setValue(this.plugin.settings.noteStorageMode)\n          .onChange(async (value) => {\n            this.plugin.settings.noteStorageMode = value as \"full-local\" | \"lazy-notes\";\n            await this.plugin.saveSettings();\n          }),\n      );\n\n    new Setting(containerEl)\n      .setName(this.plugin.t(\"\u7B14\u8BB0\u672C\u5730\u56DE\u6536\u5929\u6570\", \"Note eviction days\"))\n      .setDesc(\n        this.plugin.t(\n          \"\u4EC5\u5728\u201C\u6309\u9700\u52A0\u8F7D\u7B14\u8BB0\u201D\u6A21\u5F0F\u4E0B\u751F\u6548\u3002\u8D85\u8FC7\u8FD9\u4E2A\u5929\u6570\u672A\u6253\u5F00\u7684 Markdown \u7B14\u8BB0\uFF0C\u4F1A\u5728\u540C\u6B65\u540E\u88AB\u66FF\u6362\u4E3A\u672C\u5730\u5360\u4F4D\u6587\u4EF6\u3002\",\n          \"Used only in lazy note mode. Markdown notes not opened within this number of days are replaced with local placeholder files after sync.\",\n        ),\n      )\n      .addText((text) =>\n        text\n          .setPlaceholder(\"30\")\n          .setValue(String(this.plugin.settings.noteEvictAfterDays))\n          .onChange(async (value) => {\n            const parsed = Number.parseInt(value, 10);\n            if (!Number.isNaN(parsed)) {\n              this.plugin.settings.noteEvictAfterDays = Math.max(1, parsed);\n              await this.plugin.saveSettings();\n            }\n          }),\n      );\n\n    new Setting(containerEl)\n      .setName(this.plugin.t(\"\u540C\u6B65\u72B6\u6001\", \"Sync status\"))\n      .setDesc(\n        this.plugin.t(\n          `${this.plugin.formatLastSyncLabel()}\\n${this.plugin.formatSyncStatusLabel()}\\n${this.plugin.t(\"\u8BF4\u660E\uFF1A\u5FEB\u901F\u540C\u6B65\u53EA\u8D1F\u8D23\u4E0A\u4F20\u672C\u5730\u65B0\u589E/\u4FEE\u6539\u6587\u4EF6\uFF0C\u5E76\u5904\u7406\u660E\u786E\u5220\u9664\u961F\u5217\uFF1B\u5B8C\u6574\u540C\u6B65\u624D\u4F1A\u540C\u65F6\u4E0A\u4F20\u672C\u5730\u53D8\u66F4\u5E76\u4E0B\u8F7D\u8FDC\u7AEF\u66F4\u65B0\u3002\u56FE\u7247\u4E0A\u4F20\u4ECD\u7531\u72EC\u7ACB\u961F\u5217\u5904\u7406\u3002\", \"Note: Fast sync only uploads local additions/edits and processes explicit deletion queues. Full sync is the mode that both uploads local changes and downloads remote updates. Image uploads continue to be handled by the separate queue.\")}`,\n          `${this.plugin.formatLastSyncLabel()}\\n${this.plugin.formatSyncStatusLabel()}\\n${this.plugin.t(\"\u8BF4\u660E\uFF1A\u5FEB\u901F\u540C\u6B65\u53EA\u8D1F\u8D23\u4E0A\u4F20\u672C\u5730\u65B0\u589E/\u4FEE\u6539\u6587\u4EF6\uFF0C\u5E76\u5904\u7406\u660E\u786E\u5220\u9664\u961F\u5217\uFF1B\u5B8C\u6574\u540C\u6B65\u624D\u4F1A\u540C\u65F6\u4E0A\u4F20\u672C\u5730\u53D8\u66F4\u5E76\u4E0B\u8F7D\u8FDC\u7AEF\u66F4\u65B0\u3002\u56FE\u7247\u4E0A\u4F20\u4ECD\u7531\u72EC\u7ACB\u961F\u5217\u5904\u7406\u3002\", \"Note: Fast sync only uploads local additions/edits and processes explicit deletion queues. Full sync is the mode that both uploads local changes and downloads remote updates. Image uploads continue to be handled by the separate queue.\")}`,\n        ),\n      )\n      .addButton((button) =>\n        button.setButtonText(this.plugin.t(\"\u5FEB\u901F\u540C\u6B65\", \"Fast sync\")).onClick(async () => {\n          button.setDisabled(true);\n          try {\n            await this.plugin.syncPendingVaultContent(true);\n            this.display();\n          } finally {\n            button.setDisabled(false);\n          }\n        }),\n      )\n      .addButton((button) =>\n        button.setButtonText(this.plugin.t(\"\u5B8C\u6574\u5BF9\u8D26\", \"Full reconcile\")).onClick(async () => {\n          button.setDisabled(true);\n          try {\n            await this.plugin.syncConfiguredVaultContent(true);\n            this.display();\n          } finally {\n            button.setDisabled(false);\n          }\n        }),\n      );\n\n    containerEl.createEl(\"h3\", { text: this.plugin.t(\"\u4E00\u6B21\u6027\u5DE5\u5177\", \"One-time tools\") });\n\n    new Setting(containerEl)\n      .setName(this.plugin.t(\"\u8FC1\u79FB\u6574\u5E93\u539F\u751F\u56FE\u7247\u5F15\u7528\", \"Migrate native image embeds in vault\"))\n      .setDesc(\n        this.plugin.t(\n          \"\u626B\u63CF\u6574\u5E93\u6240\u6709 Markdown \u7B14\u8BB0\uFF0C\u628A Obsidian \u539F\u751F\u672C\u5730\u56FE\u7247\u5F15\u7528\uFF08\u5982 ![]() \u548C ![[...]]\uFF09\u4E0A\u4F20\u5230\u8FDC\u7AEF\u56FE\u7247\u76EE\u5F55\uFF0C\u5E76\u6539\u5199\u4E3A secure-webdav \u4EE3\u7801\u5757\u3002\u65E7\u7248 span \u548C\u65E9\u671F webdav-secure \u94FE\u63A5\u4E5F\u4F1A\u4E00\u5E76\u6536\u655B\u5230\u65B0\u683C\u5F0F\u3002\",\n          \"Scan all Markdown notes in the vault, upload native local image embeds (such as ![]() and ![[...]]) to the remote image folder, and rewrite them as secure-webdav code blocks. Legacy span tags and early webdav-secure links are also normalized to the new format.\",\n        ),\n      )\n      .addButton((button) =>\n        button.setButtonText(this.plugin.t(\"\u5F00\u59CB\u8FC1\u79FB\", \"Run migration\")).onClick(async () => {\n          button.setDisabled(true);\n          try {\n            await this.plugin.migrateAllLegacySecureImages();\n          } finally {\n            button.setDisabled(false);\n          }\n        }),\n      );\n  }\n}\n\nclass ResultModal extends Modal {\n  private readonly titleText: string;\n  private readonly bodyText: string;\n\n  constructor(app: App, titleText: string, bodyText: string) {\n    super(app);\n    this.titleText = titleText;\n    this.bodyText = bodyText;\n  }\n\n  onOpen(): void {\n    const { contentEl } = this;\n    contentEl.empty();\n    contentEl.createEl(\"h3\", { text: this.titleText });\n    contentEl.createEl(\"p\", { text: this.bodyText });\n  }\n\n  onClose(): void {\n    this.contentEl.empty();\n  }\n}\n", "import { MarkdownPostProcessorContext, MarkdownRenderChild } from \"obsidian\";\n\nexport const SECURE_PROTOCOL = \"webdav-secure:\";\nexport const SECURE_CODE_BLOCK = \"secure-webdav\";\n\nexport type SecureWebdavImageBlock = {\n  path: string;\n  alt: string;\n};\n\ntype SecureWebdavImageSupportDeps = {\n  t: (zh: string, en: string) => string;\n  fetchSecureImageBlobUrl: (remotePath: string) => Promise<string>;\n};\n\nclass SecureWebdavRenderChild extends MarkdownRenderChild {\n  constructor(containerEl: HTMLElement) {\n    super(containerEl);\n  }\n\n  onunload(): void {}\n}\n\n// Keep secure image parsing and rendering isolated so sync changes do not\n// accidentally break the display pipeline again.\nexport class SecureWebdavImageSupport {\n  constructor(private readonly deps: SecureWebdavImageSupportDeps) {}\n\n  buildSecureImageMarkup(remoteUrl: string, alt: string) {\n    const remotePath = this.extractRemotePath(remoteUrl);\n    if (!remotePath) {\n      return `![](${remoteUrl})`;\n    }\n\n    return this.buildSecureImageCodeBlock(remotePath, alt);\n  }\n\n  buildSecureImageCodeBlock(remotePath: string, alt: string) {\n    const normalizedAlt = (alt || remotePath).replace(/\\r?\\n/g, \" \").trim();\n    const normalizedPath = remotePath.replace(/\\r?\\n/g, \"\").trim();\n    return [`\\`\\`\\`${SECURE_CODE_BLOCK}`, `path: ${normalizedPath}`, `alt: ${normalizedAlt}`, \"```\"].join(\"\\n\");\n  }\n\n  parseSecureImageBlock(source: string): SecureWebdavImageBlock | null {\n    const result: SecureWebdavImageBlock = { path: \"\", alt: \"\" };\n    for (const rawLine of source.split(/\\r?\\n/)) {\n      const line = rawLine.trim();\n      if (!line) {\n        continue;\n      }\n\n      const separatorIndex = line.indexOf(\":\");\n      if (separatorIndex === -1) {\n        continue;\n      }\n\n      const key = line.slice(0, separatorIndex).trim().toLowerCase();\n      const value = line.slice(separatorIndex + 1).trim();\n      if (key === \"path\") {\n        result.path = value;\n      } else if (key === \"alt\") {\n        result.alt = value;\n      }\n    }\n\n    return result.path ? result : null;\n  }\n\n  async processSecureImages(el: HTMLElement, ctx: MarkdownPostProcessorContext) {\n    const secureCodeBlocks = Array.from(el.querySelectorAll<HTMLElement>(`pre > code.language-${SECURE_CODE_BLOCK}`));\n    await Promise.all(\n      secureCodeBlocks.map(async (codeEl) => {\n        const pre = codeEl.parentElement;\n        if (!(pre instanceof HTMLElement) || pre.hasAttribute(\"data-secure-webdav-rendered\")) {\n          return;\n        }\n\n        const parsed = this.parseSecureImageBlock(codeEl.textContent ?? \"\");\n        if (!parsed?.path) {\n          return;\n        }\n\n        pre.setAttribute(\"data-secure-webdav-rendered\", \"true\");\n        await this.renderSecureImageIntoElement(pre, parsed.path, parsed.alt || parsed.path);\n      }),\n    );\n\n    const secureNodes = Array.from(el.querySelectorAll<HTMLElement>(\"[data-secure-webdav]\"));\n    await Promise.all(\n      secureNodes.map(async (node) => {\n        if (node instanceof HTMLImageElement) {\n          await this.swapImageSource(node);\n          return;\n        }\n\n        const remotePath = node.getAttribute(\"data-secure-webdav\");\n        if (!remotePath) {\n          return;\n        }\n\n        const img = document.createElement(\"img\");\n        img.alt = node.getAttribute(\"aria-label\") ?? node.getAttribute(\"alt\") ?? \"Secure WebDAV image\";\n        img.setAttribute(\"data-secure-webdav\", remotePath);\n        img.classList.add(\"secure-webdav-image\", \"is-loading\");\n        node.replaceWith(img);\n        await this.swapImageSource(img);\n      }),\n    );\n\n    const secureLinks = Array.from(el.querySelectorAll<HTMLImageElement>(`img[src^=\"${SECURE_PROTOCOL}//\"]`));\n    await Promise.all(secureLinks.map(async (img) => this.swapImageSource(img)));\n\n    ctx.addChild(new SecureWebdavRenderChild(el));\n  }\n\n  async processSecureCodeBlock(source: string, el: HTMLElement, ctx: MarkdownPostProcessorContext) {\n    const parsed = this.parseSecureImageBlock(source);\n    if (!parsed?.path) {\n      el.createEl(\"div\", {\n        text: this.deps.t(\"\u5B89\u5168\u56FE\u7247\u4EE3\u7801\u5757\u683C\u5F0F\u65E0\u6548\u3002\", \"Invalid secure image code block format.\"),\n      });\n      return;\n    }\n\n    await this.renderSecureImageIntoElement(el, parsed.path, parsed.alt || parsed.path);\n    ctx.addChild(new SecureWebdavRenderChild(el));\n  }\n\n  extractRemotePath(src: string) {\n    const prefix = `${SECURE_PROTOCOL}//`;\n    if (!src.startsWith(prefix)) {\n      return null;\n    }\n\n    return src.slice(prefix.length);\n  }\n\n  private async renderSecureImageIntoElement(el: HTMLElement, remotePath: string, alt: string) {\n    const img = document.createElement(\"img\");\n    img.alt = alt;\n    img.setAttribute(\"data-secure-webdav\", remotePath);\n    img.classList.add(\"secure-webdav-image\", \"is-loading\");\n    el.empty();\n    el.appendChild(img);\n    await this.swapImageSource(img);\n  }\n\n  private async swapImageSource(img: HTMLImageElement) {\n    const remotePath = img.getAttribute(\"data-secure-webdav\") ?? this.extractRemotePath(img.getAttribute(\"src\") ?? \"\");\n    if (!remotePath) {\n      return;\n    }\n\n    img.classList.add(\"secure-webdav-image\", \"is-loading\");\n    const originalAlt = img.alt;\n    img.alt = originalAlt || this.deps.t(\"\u52A0\u8F7D\u5B89\u5168\u56FE\u7247\u4E2D...\", \"Loading secure image...\");\n\n    try {\n      const blobUrl = await this.deps.fetchSecureImageBlobUrl(remotePath);\n      img.src = blobUrl;\n      img.alt = originalAlt;\n      img.style.display = \"block\";\n      img.style.maxWidth = \"100%\";\n      img.classList.remove(\"is-loading\", \"is-error\");\n    } catch (error) {\n      console.error(\"Secure WebDAV image load failed\", error);\n      img.replaceWith(this.buildErrorElement(remotePath, error));\n    }\n  }\n\n  private buildErrorElement(remotePath: string, error: unknown) {\n    const el = document.createElement(\"div\");\n    el.className = \"secure-webdav-image is-error\";\n    const message = error instanceof Error ? error.message : String(error);\n    el.textContent = this.deps.t(\n      `\u5B89\u5168\u56FE\u7247\u52A0\u8F7D\u5931\u8D25\uFF1A${remotePath}\uFF08${message}\uFF09`,\n      `Secure image failed: ${remotePath} (${message})`,\n    );\n    return el;\n  }\n}\n", "import { App, Editor, MarkdownView, Notice, TAbstractFile, TFile } from \"obsidian\";\n\nexport type UploadTask = {\n  id: string;\n  notePath: string;\n  placeholder: string;\n  mimeType: string;\n  fileName: string;\n  dataBase64: string;\n  attempts: number;\n  createdAt: number;\n  lastError?: string;\n};\n\ntype SecureWebdavUploadQueueDeps = {\n  app: App;\n  t: (zh: string, en: string) => string;\n  settings: () => { maxRetryAttempts: number; retryDelaySeconds: number };\n  getQueue: () => UploadTask[];\n  setQueue: (queue: UploadTask[]) => void;\n  savePluginState: () => Promise<void>;\n  schedulePriorityNoteSync: (notePath: string, reason: \"image-add\" | \"image-remove\") => void;\n  requestUrl: (options: {\n    url: string;\n    method: string;\n    headers?: Record<string, string>;\n    body?: ArrayBuffer;\n    followRedirects?: boolean;\n    redirectCount?: number;\n  }) => Promise<{ status: number; headers: Record<string, string>; arrayBuffer: ArrayBuffer }>;\n  buildUploadUrl: (remotePath: string) => string;\n  buildAuthHeader: () => string;\n  prepareUploadPayload: (\n    binary: ArrayBuffer,\n    mimeType: string,\n    fileName: string,\n  ) => Promise<{ binary: ArrayBuffer; mimeType: string; fileName: string }>;\n  buildRemoteFileNameFromBinary: (fileName: string, binary: ArrayBuffer) => Promise<string>;\n  buildRemotePath: (fileName: string) => string;\n  buildSecureImageMarkup: (remoteUrl: string, alt: string) => string;\n  getMimeTypeFromFileName: (fileName: string) => string;\n  arrayBufferToBase64: (buffer: ArrayBuffer) => string;\n  base64ToArrayBuffer: (base64: string) => ArrayBuffer;\n  escapeHtml: (value: string) => string;\n  escapeRegExp: (value: string) => string;\n  describeError: (prefix: string, error: unknown) => string;\n};\n\n// Owns the queued image upload workflow so sync and note logic can stay separate.\nexport class SecureWebdavUploadQueueSupport {\n  private processingTaskIds = new Set<string>();\n  private retryTimeouts = new Map<string, number>();\n  private pendingTaskPromises = new Map<string, Promise<void>>();\n\n  constructor(private readonly deps: SecureWebdavUploadQueueDeps) {}\n\n  dispose() {\n    for (const timeoutId of this.retryTimeouts.values()) {\n      window.clearTimeout(timeoutId);\n    }\n    this.retryTimeouts.clear();\n  }\n\n  hasPendingWork() {\n    return (\n      this.deps.getQueue().length > 0 ||\n      this.processingTaskIds.size > 0 ||\n      this.pendingTaskPromises.size > 0\n    );\n  }\n\n  hasPendingWorkForNote(notePath: string) {\n    const queue = this.deps.getQueue();\n    if (queue.some((task) => task.notePath === notePath)) {\n      return true;\n    }\n\n    for (const taskId of this.processingTaskIds) {\n      const task = queue.find((item) => item.id === taskId);\n      if (task?.notePath === notePath) {\n        return true;\n      }\n    }\n\n    for (const [taskId] of this.pendingTaskPromises) {\n      const task = queue.find((item) => item.id === taskId);\n      if (task?.notePath === notePath) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  async enqueueEditorImageUpload(noteFile: TFile, editor: Editor, imageFile: File, fileName: string) {\n    try {\n      const arrayBuffer = await imageFile.arrayBuffer();\n      const task = this.createUploadTask(\n        noteFile.path,\n        arrayBuffer,\n        imageFile.type || this.deps.getMimeTypeFromFileName(fileName),\n        fileName,\n      );\n      this.insertPlaceholder(editor, task.placeholder);\n      this.deps.setQueue([...this.deps.getQueue(), task]);\n      await this.deps.savePluginState();\n      void this.processPendingTasks();\n      new Notice(this.deps.t(\"\u5DF2\u52A0\u5165\u56FE\u7247\u81EA\u52A8\u4E0A\u4F20\u961F\u5217\u3002\", \"Image added to the auto-upload queue.\"));\n    } catch (error) {\n      console.error(\"Failed to queue secure image upload\", error);\n      new Notice(\n        this.deps.describeError(\n          this.deps.t(\"\u52A0\u5165\u56FE\u7247\u81EA\u52A8\u4E0A\u4F20\u961F\u5217\u5931\u8D25\", \"Failed to queue image for auto-upload\"),\n          error,\n        ),\n        8000,\n      );\n    }\n  }\n\n  createUploadTask(notePath: string, binary: ArrayBuffer, mimeType: string, fileName: string): UploadTask {\n    const id = `secure-webdav-task-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;\n    return {\n      id,\n      notePath,\n      placeholder: this.buildPendingPlaceholder(id, fileName),\n      mimeType,\n      fileName,\n      dataBase64: this.deps.arrayBufferToBase64(binary),\n      attempts: 0,\n      createdAt: Date.now(),\n    };\n  }\n\n  buildPendingPlaceholder(taskId: string, fileName: string) {\n    const safeName = this.deps.escapeHtml(fileName);\n    return `<span class=\"secure-webdav-pending\" data-secure-webdav-task=\"${taskId}\" aria-label=\"${safeName}\">${this.deps.escapeHtml(this.deps.t(`\u3010\u56FE\u7247\u4E0A\u4F20\u4E2D\uFF5C${fileName}\u3011`, `[Uploading image | ${fileName}]`))}</span>`;\n  }\n\n  buildFailedPlaceholder(fileName: string, message?: string) {\n    const safeName = this.deps.escapeHtml(fileName);\n    const safeMessage = this.deps.escapeHtml(message ?? this.deps.t(\"\u672A\u77E5\u9519\u8BEF\", \"Unknown error\"));\n    const label = this.deps.escapeHtml(this.deps.t(`\u3010\u56FE\u7247\u4E0A\u4F20\u5931\u8D25\uFF5C${fileName}\u3011`, `[Image upload failed | ${fileName}]`));\n    return `<span class=\"secure-webdav-failed\" aria-label=\"${safeName}\">${label}: ${safeMessage}</span>`;\n  }\n\n  async processPendingTasks() {\n    const running: Promise<void>[] = [];\n    for (const task of this.deps.getQueue()) {\n      if (this.processingTaskIds.has(task.id)) {\n        continue;\n      }\n\n      running.push(this.startPendingTask(task));\n    }\n\n    await Promise.allSettled(running);\n  }\n\n  startPendingTask(task: UploadTask) {\n    const existing = this.pendingTaskPromises.get(task.id);\n    if (existing) {\n      return existing;\n    }\n\n    const promise = this.processTask(task).finally(() => {\n      this.pendingTaskPromises.delete(task.id);\n    });\n    this.pendingTaskPromises.set(task.id, promise);\n    return promise;\n  }\n\n  async processTask(task: UploadTask) {\n    this.processingTaskIds.add(task.id);\n    try {\n      const binary = this.deps.base64ToArrayBuffer(task.dataBase64);\n      const prepared = await this.deps.prepareUploadPayload(\n        binary,\n        task.mimeType || this.deps.getMimeTypeFromFileName(task.fileName),\n        task.fileName,\n      );\n      const remoteName = await this.deps.buildRemoteFileNameFromBinary(prepared.fileName, prepared.binary);\n      const remotePath = this.deps.buildRemotePath(remoteName);\n      const response = await this.deps.requestUrl({\n        url: this.deps.buildUploadUrl(remotePath),\n        method: \"PUT\",\n        headers: {\n          Authorization: this.deps.buildAuthHeader(),\n          \"Content-Type\": prepared.mimeType,\n        },\n        body: prepared.binary,\n      });\n\n      if (response.status < 200 || response.status >= 300) {\n        throw new Error(`Upload failed with status ${response.status}`);\n      }\n\n      const replaced = await this.replacePlaceholder(\n        task.notePath,\n        task.id,\n        task.placeholder,\n        this.deps.buildSecureImageMarkup(`webdav-secure://${remotePath}`, prepared.fileName),\n      );\n      if (!replaced) {\n        throw new Error(\n          this.deps.t(\n            \"\u4E0A\u4F20\u6210\u529F\uFF0C\u4F46\u6CA1\u6709\u5728\u7B14\u8BB0\u4E2D\u627E\u5230\u53EF\u66FF\u6362\u7684\u5360\u4F4D\u7B26\u3002\",\n            \"Upload succeeded, but no matching placeholder was found in the note.\",\n          ),\n        );\n      }\n\n      this.deps.setQueue(this.deps.getQueue().filter((item) => item.id !== task.id));\n      await this.deps.savePluginState();\n      this.deps.schedulePriorityNoteSync(task.notePath, \"image-add\");\n      new Notice(this.deps.t(\"\u56FE\u7247\u4E0A\u4F20\u6210\u529F\u3002\", \"Image uploaded successfully.\"));\n    } catch (error) {\n      console.error(\"Secure WebDAV queued upload failed\", error);\n      task.attempts += 1;\n      task.lastError = error instanceof Error ? error.message : String(error);\n      await this.deps.savePluginState();\n\n      if (task.attempts >= this.deps.settings().maxRetryAttempts) {\n        await this.replacePlaceholder(\n          task.notePath,\n          task.id,\n          task.placeholder,\n          this.buildFailedPlaceholder(task.fileName, task.lastError),\n        );\n        this.deps.setQueue(this.deps.getQueue().filter((item) => item.id !== task.id));\n        await this.deps.savePluginState();\n        new Notice(this.deps.describeError(this.deps.t(\"\u56FE\u7247\u4E0A\u4F20\u6700\u7EC8\u5931\u8D25\", \"Image upload failed permanently\"), error), 8000);\n      } else {\n        this.scheduleRetry(task);\n      }\n    } finally {\n      this.processingTaskIds.delete(task.id);\n    }\n  }\n\n  scheduleRetry(task: UploadTask) {\n    const existing = this.retryTimeouts.get(task.id);\n    if (existing) {\n      window.clearTimeout(existing);\n    }\n\n    const delay = Math.max(1, this.deps.settings().retryDelaySeconds) * 1000 * task.attempts;\n    const timeoutId = window.setTimeout(() => {\n      this.retryTimeouts.delete(task.id);\n      void this.startPendingTask(task);\n    }, delay);\n    this.retryTimeouts.set(task.id, timeoutId);\n  }\n\n  private insertPlaceholder(editor: Editor, placeholder: string) {\n    editor.replaceSelection(`${placeholder}\\n`);\n  }\n\n  async replacePlaceholder(notePath: string, taskId: string, placeholder: string, replacement: string) {\n    const replacedInEditor = this.replacePlaceholderInOpenEditors(notePath, taskId, placeholder, replacement);\n    if (replacedInEditor) {\n      return true;\n    }\n\n    const file = this.deps.app.vault.getAbstractFileByPath(notePath);\n    if (!(file instanceof TFile)) {\n      return false;\n    }\n\n    const content = await this.deps.app.vault.read(file);\n    if (content.includes(placeholder)) {\n      const updated = content.replace(placeholder, replacement);\n      if (updated !== content) {\n        await this.deps.app.vault.modify(file, updated);\n        return true;\n      }\n    }\n\n    const pattern = new RegExp(\n      `<span[^>]*data-secure-webdav-task=\"${this.deps.escapeRegExp(taskId)}\"[^>]*>.*?<\\\\/span>`,\n      \"s\",\n    );\n    if (pattern.test(content)) {\n      const updated = content.replace(pattern, replacement);\n      if (updated !== content) {\n        await this.deps.app.vault.modify(file, updated);\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  private replacePlaceholderInOpenEditors(notePath: string, taskId: string, placeholder: string, replacement: string) {\n    let replaced = false;\n    const leaves = this.deps.app.workspace.getLeavesOfType(\"markdown\");\n\n    for (const leaf of leaves) {\n      const view = leaf.view;\n      if (!(view instanceof MarkdownView)) {\n        continue;\n      }\n\n      if (!view.file || view.file.path !== notePath) {\n        continue;\n      }\n\n      const editor = view.editor;\n      const content = editor.getValue();\n      let updated = content;\n\n      if (content.includes(placeholder)) {\n        updated = content.replace(placeholder, replacement);\n      } else {\n        const pattern = new RegExp(\n          `<span[^>]*data-secure-webdav-task=\"${this.deps.escapeRegExp(taskId)}\"[^>]*>.*?<\\\\/span>`,\n          \"s\",\n        );\n        updated = content.replace(pattern, replacement);\n      }\n\n      if (updated !== content) {\n        editor.setValue(updated);\n        replaced = true;\n      }\n    }\n\n    return replaced;\n  }\n}\n", "import { App, TFile, TFolder, normalizePath } from \"obsidian\";\n\nexport type DeletionTombstone = {\n  path: string;\n  deletedAt: number;\n  remoteSignature?: string;\n};\n\nexport type RemoteFileLike = {\n  remotePath: string;\n  lastModified: number;\n  size: number;\n  signature: string;\n};\n\ntype SecureWebdavSyncSupportDeps = {\n  app: App;\n  getVaultSyncRemoteFolder: () => string;\n  getExcludedSyncFolders?: () => string[];\n  deletionFolderSuffix: string;\n  encodeBase64Url: (value: string) => string;\n  decodeBase64Url: (value: string) => string;\n};\n\n// Keep sync metadata and tombstone rules isolated so queue/rendering changes\n// do not accidentally affect reconciliation behaviour.\nexport class SecureWebdavSyncSupport {\n  constructor(private readonly deps: SecureWebdavSyncSupportDeps) {}\n\n  isExcludedSyncPath(path: string) {\n    const normalizedPath = normalizePath(path).replace(/^\\/+/, \"\").replace(/\\/+$/, \"\");\n    if (!normalizedPath) {\n      return false;\n    }\n\n    const folders = this.deps.getExcludedSyncFolders?.() ?? [];\n    return folders.some((folder) => {\n      const normalizedFolder = normalizePath(folder).replace(/^\\/+/, \"\").replace(/\\/+$/, \"\");\n      return normalizedFolder.length > 0 && (normalizedPath === normalizedFolder || normalizedPath.startsWith(`${normalizedFolder}/`));\n    });\n  }\n\n  shouldSkipContentSyncPath(path: string) {\n    const normalizedPath = normalizePath(path);\n    if (\n      this.isExcludedSyncPath(normalizedPath) ||\n      normalizedPath.startsWith(\".obsidian/\") ||\n      normalizedPath.startsWith(\".trash/\") ||\n      normalizedPath.startsWith(\".git/\") ||\n      normalizedPath.startsWith(\"node_modules/\") ||\n      normalizedPath.startsWith(\"_plugin_packages/\") ||\n      normalizedPath.startsWith(\".tmp-\") ||\n      normalizedPath.startsWith(\".obsidian/plugins/secure-webdav-images/\")\n    ) {\n      return true;\n    }\n\n    return /\\.(png|jpe?g|gif|webp|bmp|svg)$/i.test(normalizedPath);\n  }\n\n  shouldSkipDirectorySyncPath(dirPath: string) {\n    const p = normalizePath(dirPath);\n    return (\n      this.isExcludedSyncPath(p) ||\n      p.startsWith(\".obsidian\") ||\n      p.startsWith(\".trash\") ||\n      p.startsWith(\".git\") ||\n      p.startsWith(\"node_modules\") ||\n      p.startsWith(\"_plugin_packages\") ||\n      p.startsWith(\".tmp-\")\n    );\n  }\n\n  collectLocalSyncedDirectories() {\n    const dirs = new Set<string>();\n    for (const f of this.deps.app.vault.getAllFolders()) {\n      if (f instanceof TFolder && !f.isRoot() && !this.shouldSkipDirectorySyncPath(f.path)) {\n        dirs.add(normalizePath(f.path));\n      }\n    }\n    return dirs;\n  }\n\n  collectVaultContentFiles() {\n    return this.deps.app.vault\n      .getFiles()\n      .filter((file) => !this.shouldSkipContentSyncPath(file.path))\n      .sort((a, b) => a.path.localeCompare(b.path));\n  }\n\n  buildSyncSignature(file: TFile) {\n    return `${file.stat.mtime}:${file.stat.size}`;\n  }\n\n  buildRemoteSyncSignature(remote: Pick<RemoteFileLike, \"lastModified\" | \"size\">) {\n    return `${remote.lastModified}:${remote.size}`;\n  }\n\n  buildVaultSyncRemotePath(vaultPath: string) {\n    return `${this.normalizeFolder(this.deps.getVaultSyncRemoteFolder())}${vaultPath}`;\n  }\n\n  buildDeletionFolder() {\n    return `${this.normalizeFolder(this.deps.getVaultSyncRemoteFolder()).replace(/\\/$/, \"\")}${this.deps.deletionFolderSuffix}`;\n  }\n\n  buildDeletionRemotePath(vaultPath: string) {\n    return `${this.buildDeletionFolder()}${this.deps.encodeBase64Url(vaultPath)}.json`;\n  }\n\n  remoteDeletionPathToVaultPath(remotePath: string) {\n    const root = this.buildDeletionFolder();\n    if (!remotePath.startsWith(root) || !remotePath.endsWith(\".json\")) {\n      return null;\n    }\n\n    const encoded = remotePath.slice(root.length, -\".json\".length);\n    try {\n      return this.deps.decodeBase64Url(encoded);\n    } catch {\n      return null;\n    }\n  }\n\n  parseDeletionTombstonePayload(raw: string): DeletionTombstone | null {\n    try {\n      const parsed = JSON.parse(raw);\n      if (!parsed || typeof parsed.path !== \"string\" || typeof parsed.deletedAt !== \"number\") {\n        return null;\n      }\n      if (parsed.remoteSignature !== undefined && typeof parsed.remoteSignature !== \"string\") {\n        return null;\n      }\n      return {\n        path: parsed.path,\n        deletedAt: parsed.deletedAt,\n        remoteSignature: parsed.remoteSignature,\n      };\n    } catch {\n      return null;\n    }\n  }\n\n  remotePathToVaultPath(remotePath: string) {\n    const root = this.normalizeFolder(this.deps.getVaultSyncRemoteFolder());\n    if (!remotePath.startsWith(root)) {\n      return null;\n    }\n\n    return remotePath.slice(root.length).replace(/^\\/+/, \"\");\n  }\n\n  shouldDownloadRemoteVersion(localMtime: number, remoteMtime: number) {\n    return remoteMtime > localMtime + 2000;\n  }\n\n  isTombstoneAuthoritative(\n    tombstone: DeletionTombstone,\n    remote?: Pick<RemoteFileLike, \"lastModified\" | \"signature\"> | null,\n  ) {\n    const graceMs = 5000;\n    if (!remote) {\n      return true;\n    }\n\n    if (tombstone.remoteSignature) {\n      return remote.signature === tombstone.remoteSignature;\n    }\n\n    return remote.lastModified <= tombstone.deletedAt + graceMs;\n  }\n\n  shouldDeleteLocalFromTombstone(file: TFile, tombstone: DeletionTombstone) {\n    const graceMs = 5000;\n    return file.stat.mtime <= tombstone.deletedAt + graceMs;\n  }\n\n  private normalizeFolder(input: string) {\n    return normalizeFolder(input);\n  }\n}\n\nexport function normalizeFolder(input: string) {\n  return input.replace(/^\\/+/, \"\").replace(/\\/+$/, \"\") + \"/\";\n}\n"],
  "mappings": "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",
  "names": ["import_obsidian", "import_obsidian", "import_obsidian", "document", "tombstone", "obsidianRequestUrl"]
}
