main.js

/*
THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
if you want to view the source, please visit the github repository of this plugin
*/

var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

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

// src/utils/base64/arrayBufferBase64.ts
var BYTE_CHUNK_SIZE = 32768;
function encodeArrayBufferToBase64(buffer) {
  const bytes = new Uint8Array(buffer);
  let binary = "";
  for (let offset = 0; offset < bytes.length; offset += BYTE_CHUNK_SIZE) {
    const chunk = bytes.subarray(offset, offset + BYTE_CHUNK_SIZE);
    for (const byte of chunk) {
      binary += String.fromCharCode(byte);
    }
  }
  return btoa(binary);
}
function decodeBase64ToArrayBuffer(base64) {
  const binary = atob(base64);
  const bytes = new Uint8Array(binary.length);
  for (let index = 0; index < binary.length; index++) {
    bytes[index] = binary.charCodeAt(index);
  }
  return bytes.buffer;
}

// src/utils/base64/imageMime.ts
var DEFAULT_IMAGE_MIME_TYPE = "image/png";
var EXTENSION_TO_MIME_TYPE = {
  png: "image/png",
  jpg: "image/jpeg",
  jpeg: "image/jpeg",
  gif: "image/gif",
  webp: "image/webp",
  bmp: "image/bmp",
  svg: "image/svg+xml",
  avif: "image/avif"
};
var MIME_TYPE_TO_EXTENSION = {
  "image/png": "png",
  "image/jpeg": "jpeg",
  "image/gif": "gif",
  "image/webp": "webp",
  "image/bmp": "bmp",
  "image/svg+xml": "svg",
  "image/avif": "avif"
};
function inferMimeTypeFromFilename(filename) {
  var _a, _b;
  if (!filename) {
    return DEFAULT_IMAGE_MIME_TYPE;
  }
  const extension = (_a = filename.split(".").pop()) == null ? void 0 : _a.toLowerCase();
  if (!extension) {
    return DEFAULT_IMAGE_MIME_TYPE;
  }
  return (_b = EXTENSION_TO_MIME_TYPE[extension]) != null ? _b : DEFAULT_IMAGE_MIME_TYPE;
}
function normalizeImageMimeType(mimeType, filename) {
  if (!mimeType) {
    return inferMimeTypeFromFilename(filename);
  }
  if (mimeType === "image/jpg") {
    return "image/jpeg";
  }
  return mimeType;
}
function normalizeImageFilename(filename, mimeType) {
  var _a;
  const safeFilename = (filename == null ? void 0 : filename.trim()) || "image";
  if (safeFilename.includes(".")) {
    return safeFilename;
  }
  const extension = (_a = MIME_TYPE_TO_EXTENSION[mimeType]) != null ? _a : "png";
  return `${safeFilename}.${extension}`;
}
function replaceFilenameExtension(filename, mimeType) {
  const baseName = filename.includes(".") ? filename.slice(0, filename.lastIndexOf(".")) : filename;
  return normalizeImageFilename(baseName, mimeType);
}

// src/utils/base64/base64File.ts
function parseMarkdownImageDataUrl(link) {
  const match = link.match(/^!\[(.*?)\]\(data:(image\/[^;]+);base64,([^\)]+)\)$/);
  if (!match) {
    return null;
  }
  return {
    filename: match[1],
    mimeType: normalizeImageMimeType(match[2], match[1]),
    base64: match[3]
  };
}
var Base64File = class _Base64File {
  constructor(bufferOrInit, filename, mimeType) {
    const init = bufferOrInit instanceof ArrayBuffer ? { buffer: bufferOrInit, filename, mimeType } : bufferOrInit;
    const resolvedMimeType = normalizeImageMimeType(init.mimeType, init.filename);
    this.buffer = init.buffer;
    this.mimeType = resolvedMimeType;
    this.filename = normalizeImageFilename(init.filename, resolvedMimeType);
  }
  /**
   * Reports the raw binary size of the wrapped image payload.
   */
  get size() {
    return this.buffer.byteLength;
  }
  /**
   * Encodes the wrapped binary image into base64 text.
   */
  toBase64String() {
    return encodeArrayBufferToBase64(this.buffer);
  }
  /**
   * Builds an inline Markdown image using the file's current MIME type and filename.
   */
  toMarkdownImage() {
    return `![${this.filename}](data:${this.mimeType};base64,${this.toBase64String()})`;
  }
  /**
   * Preserves compatibility with the existing plugin API for base64 string generation.
   */
  to64String() {
    return this.toBase64String();
  }
  /**
   * Preserves compatibility with the existing plugin API for inline Markdown generation.
   */
  to64Link() {
    return this.toMarkdownImage();
  }
  /**
   * Rehydrates a Base64File from an inline Markdown image data URL.
   */
  static from64Link(link) {
    const parsed = parseMarkdownImageDataUrl(link);
    if (!parsed) {
      return null;
    }
    return new _Base64File({
      buffer: decodeBase64ToArrayBuffer(parsed.base64),
      filename: parsed.filename,
      mimeType: parsed.mimeType
    });
  }
  /**
   * Rehydrates a Base64File from raw base64 data and optional image metadata.
   */
  static from64String(base64, filename, mimeType) {
    return new _Base64File({
      buffer: decodeBase64ToArrayBuffer(base64),
      filename,
      mimeType
    });
  }
  /**
   * Builds a Base64File from a browser File while preserving browser-provided MIME metadata.
   */
  static async fromFile(file) {
    const arrayBuffer = await file.arrayBuffer();
    return new _Base64File({
      buffer: arrayBuffer,
      filename: file.name,
      mimeType: file.type || inferMimeTypeFromFilename(file.name)
    });
  }
  /**
   * Builds a Base64File from an Obsidian vault file while inferring MIME metadata from its name.
   */
  static async fromTFile(tfile) {
    const arrayBuffer = await tfile.vault.readBinary(tfile);
    return new _Base64File({
      buffer: arrayBuffer,
      filename: tfile.name,
      mimeType: inferMimeTypeFromFilename(tfile.name)
    });
  }
};

// src/utils/base64/base64Conversion.ts
var Base64Conversion = class {
  /**
   * Extracts the first image payload from a clipboard paste event.
   */
  async fromClipboardEvent(event) {
    var _a;
    const items = (_a = event.clipboardData) == null ? void 0 : _a.items;
    if (!items) {
      return null;
    }
    for (const item of Array.from(items)) {
      if (!item.type.startsWith("image/")) {
        continue;
      }
      const file = item.getAsFile();
      if (file) {
        return this.fromFile(file);
      }
    }
    return null;
  }
  /**
   * Extracts the first image payload from the async clipboard API when available.
   */
  async fromClipboard() {
    var _a;
    try {
      const items = await navigator.clipboard.read();
      for (const item of items) {
        const imageType = item.types.find((type) => type.startsWith("image/"));
        if (!imageType) {
          continue;
        }
        const blob = await item.getType(imageType);
        const arrayBuffer = await blob.arrayBuffer();
        return new Base64File({
          buffer: arrayBuffer,
          filename: `clipboard.${(_a = imageType.split("/")[1]) != null ? _a : "png"}`,
          mimeType: imageType
        });
      }
    } catch (e) {
      return null;
    }
    return null;
  }
  /**
   * Converts a browser File into the plugin's image wrapper.
   */
  async fromFile(file) {
    return Base64File.fromFile(file);
  }
  /**
   * Converts an Obsidian vault file into the plugin's image wrapper.
   */
  async fromTFile(tfile) {
    return Base64File.fromTFile(tfile);
  }
  /**
   * Resizes an image and returns a PNG payload suitable for inline embedding.
   */
  async resize(file, percentage) {
    return new Promise((resolve, reject) => {
      const blob = new Blob([file.buffer], { type: file.mimeType });
      const imageUrl = URL.createObjectURL(blob);
      const img = new Image();
      img.onload = () => {
        const canvas = document.createElement("canvas");
        const ctx = canvas.getContext("2d");
        if (!ctx) {
          URL.revokeObjectURL(imageUrl);
          reject(new Error("Could not get canvas context"));
          return;
        }
        const newWidth = Math.round(img.width * (percentage / 100));
        const newHeight = Math.round(img.height * (percentage / 100));
        canvas.width = newWidth;
        canvas.height = newHeight;
        ctx.drawImage(img, 0, 0, newWidth, newHeight);
        canvas.toBlob(async (resizedBlob) => {
          if (!resizedBlob) {
            URL.revokeObjectURL(imageUrl);
            reject(new Error("Could not create blob from canvas"));
            return;
          }
          try {
            const arrayBuffer = await resizedBlob.arrayBuffer();
            URL.revokeObjectURL(imageUrl);
            resolve(new Base64File({
              buffer: arrayBuffer,
              filename: replaceFilenameExtension(file.filename, "image/png"),
              mimeType: "image/png"
            }));
          } catch (error) {
            URL.revokeObjectURL(imageUrl);
            reject(error);
          }
        }, "image/png");
      };
      img.onerror = () => {
        URL.revokeObjectURL(imageUrl);
        reject(new Error("Failed to load image"));
      };
      img.src = imageUrl;
    });
  }
};

// src/utils/base64/imagePersistence.ts
function splitFilenameParts(filename) {
  const lastDot = filename.lastIndexOf(".");
  if (lastDot <= 0) {
    return {
      stem: filename,
      extension: ""
    };
  }
  return {
    stem: filename.slice(0, lastDot),
    extension: filename.slice(lastDot + 1)
  };
}
function buildOriginalBackupFilename(file, timestamp) {
  const mimeType = normalizeImageMimeType(file.mimeType, file.filename);
  const filename = normalizeImageFilename(file.filename, mimeType);
  const { stem, extension } = splitFilenameParts(filename);
  return extension ? `${stem}_original_${timestamp}.${extension}` : `${stem}_original_${timestamp}`;
}
function createImageFile(file, filename = file.filename) {
  const mimeType = normalizeImageMimeType(file.mimeType, filename);
  const resolvedFilename = normalizeImageFilename(filename, mimeType);
  return new File([file.buffer], resolvedFilename, { type: mimeType });
}

// src/coms/antiLinkExpand.ts
var import_view = require("@codemirror/view");
var INLINE_IMAGE_DATA_URL_REGEX = /data:image\/[^;]+;base64,[^)]+/g;
function findInlineImageDataUrlRanges(text, offset = 0) {
  const ranges = [];
  const regex = new RegExp(INLINE_IMAGE_DATA_URL_REGEX);
  let match;
  while ((match = regex.exec(text)) !== null) {
    ranges.push({
      from: offset + match.index,
      to: offset + match.index + match[0].length
    });
  }
  return ranges;
}
function buildVisibleInlineImageDecorations(view) {
  const decorations = [];
  for (const visibleRange of view.visibleRanges) {
    const text = view.state.doc.sliceString(visibleRange.from, visibleRange.to);
    const matches = findInlineImageDataUrlRanges(text, visibleRange.from);
    for (const match of matches) {
      decorations.push(import_view.Decoration.replace({
        widget: new InlineImageDataUrlWidget(),
        inclusive: true
      }).range(match.from, match.to));
    }
  }
  return import_view.Decoration.set(decorations, true);
}
var InlineImageDataUrlWidget = class extends import_view.WidgetType {
  /**
   * Creates the compact inline replacement widget used in the editor.
   */
  constructor() {
    super();
  }
  /**
   * Builds the DOM element that visually replaces the inline data URL text.
   */
  toDOM() {
    const span = document.createElement("span");
    span.textContent = "...";
    return span;
  }
};
var InlineImageDecorationPlugin = class {
  /**
   * Creates the initial decoration set for the active editor viewport.
   */
  constructor(view) {
    this.decorations = buildVisibleInlineImageDecorations(view);
  }
  /**
   * Refreshes decorations when edits or viewport changes affect visible inline data URLs.
   */
  update(update) {
    if (update.docChanged || update.viewportChanged) {
      this.decorations = buildVisibleInlineImageDecorations(update.view);
    }
  }
};
var linkDecorations = import_view.ViewPlugin.fromClass(InlineImageDecorationPlugin, {
  decorations: (plugin) => plugin.decorations
});

// src/comsContext/export.ts
var import_obsidian = require("obsidian");
function toArrayBuffer(buffer) {
  return Uint8Array.from(buffer).buffer;
}
var ExportToVaultModal = class extends import_obsidian.Modal {
  /**
   * Stores the initial filename and binary image contents for the export dialog.
   */
  constructor(app, filename, buffer) {
    super(app);
    this.filename = filename;
    this.buffer = buffer;
  }
  /**
   * Builds the export form and saves the image into the current note's attachment location.
   */
  onOpen() {
    const { contentEl } = this;
    contentEl.createEl("h2", { text: "Export to Vault" });
    const form = contentEl.createEl("form");
    const filenameContainer = form.createEl("div", { cls: "setting-item" });
    filenameContainer.createEl("label", { text: "Filename" });
    const filenameInput = filenameContainer.createEl("input", {
      type: "text",
      value: this.filename
    });
    const buttonContainer = form.createEl("div", { cls: "setting-item" });
    const exportButton = buttonContainer.createEl("button", {
      text: "Save to Vault",
      cls: "mod-cta"
    });
    exportButton.addEventListener("click", async (e) => {
      e.preventDefault();
      const filename = filenameInput.value || "image.png";
      const activeFile = this.app.workspace.getActiveFile();
      if (activeFile) {
        const targetPath = await this.app.fileManager.getAvailablePathForAttachment(
          filename,
          activeFile.path
        );
        await this.app.vault.createBinary(
          targetPath,
          this.buffer
        );
        new import_obsidian.Notice(`Image saved to ${targetPath}`);
      }
      this.close();
    });
  }
  /**
   * Clears the modal contents after the export dialog closes.
   */
  onClose() {
    const { contentEl } = this;
    contentEl.empty();
  }
};
async function registerExportToLocal(plugin) {
  plugin.registerEvent(
    plugin.app.workspace.on("editor-menu", (menu, editor) => {
      const cursor = editor.getCursor();
      const line = editor.getLine(cursor.line);
      const base64Regex = /!\[.*?\]\(data:image\/[^;]+;base64,[^)]+\)/;
      const isBase64Image = base64Regex.test(line);
      if (isBase64Image) {
        menu.addItem((item) => {
          item.setTitle("Export to Vault").setIcon("vault").onClick(async () => {
            const base64Match = line.match(/data:image\/[^;]+;base64,([^)]+)/);
            if (!base64Match) return;
            const base64Data = base64Match[1];
            const buffer = Buffer.from(base64Data, "base64");
            new ExportToVaultModal(plugin.app, "image.png", toArrayBuffer(buffer)).open();
          });
        });
      }
    })
  );
}

// src/comsContext/convert.ts
var import_obsidian2 = require("obsidian");
var ConvertToBase64Modal = class extends import_obsidian2.Modal {
  /**
   * Captures the target image file and editor used for the one-line replacement.
   */
  constructor(app, file, editor) {
    super(app);
    this.file = file;
    this.editor = editor;
  }
  /**
   * Replaces the current local image embed with an inline Markdown image in the active editor line.
   */
  async onOpen() {
    const { contentEl } = this;
    contentEl.createEl("h2", { text: "Convert to Base64" });
    try {
      const inlineImage = await Base64File.fromTFile(this.file);
      const markdown = `![[${this.file.name}]]`;
      const newMarkdown = inlineImage.to64Link();
      const cursor = this.editor.getCursor();
      const line = this.editor.getLine(cursor.line);
      const newLine = line.replace(markdown, newMarkdown);
      const lineStart = this.editor.posToOffset({
        line: cursor.line,
        ch: 0
      });
      const lineEnd = this.editor.posToOffset({
        line: cursor.line,
        ch: line.length
      });
      this.editor.replaceRange(
        newLine,
        this.editor.offsetToPos(lineStart),
        this.editor.offsetToPos(lineEnd)
      );
      new import_obsidian2.Notice("Image converted to base64");
    } catch (error) {
      const message = error instanceof Error ? error.message : "Unknown error";
      new import_obsidian2.Notice("Failed to convert image: " + message);
    }
    this.close();
  }
  /**
   * Clears modal contents when the temporary conversion dialog closes.
   */
  onClose() {
    const { contentEl } = this;
    contentEl.empty();
  }
};
async function fetchOnlineImage(url) {
  try {
    const response = await fetch(url);
    if (!response.ok) {
      throw new Error(`Failed to fetch image: HTTP ${response.status}`);
    }
    const contentType = response.headers.get("content-type");
    if (!contentType) {
      throw new Error("No content type received from server");
    }
    const mimeType = contentType.split(";")[0].trim();
    if (!contentType.startsWith("image/")) {
      throw new Error(
        `URL does not point to an image (content-type: ${contentType})`
      );
    }
    const blob = await response.blob();
    if (!blob.type.startsWith("image/")) {
      throw new Error(`Invalid image format (blob type: ${blob.type})`);
    }
    const arrayBuffer = await blob.arrayBuffer();
    let filename = url.split("/").pop() || "image";
    filename = filename.split("?")[0];
    if (!filename.includes(".")) {
      const ext = mimeType.split("/")[1] || "png";
      filename = `${filename}.${ext}`;
    }
    return new Base64File({ buffer: arrayBuffer, filename, mimeType });
  } catch (error) {
    if (error instanceof Error) {
      throw new Error(`Failed to fetch online image: ${error.message}`);
    }
    throw new Error("Failed to fetch online image: Unknown error");
  }
}
async function handleImageResizing(base64File, plugin, activeFile) {
  const sizeInKB = base64File.size / 1024;
  let processedFile = base64File;
  let shouldSaveAsAttachment = false;
  if (plugin.settings.enableResizing) {
    if (plugin.settings.resizeStrategy === "smaller") {
      if (sizeInKB > plugin.settings.smallerThreshold) {
        shouldSaveAsAttachment = true;
      }
    } else {
      if (sizeInKB > plugin.settings.largerThreshold || plugin.settings.resizeSmallerFiles) {
        processedFile = await plugin.conversion.resize(
          base64File,
          plugin.settings.resizePercentage
        );
        if (plugin.settings.backupOriginalImage && activeFile) {
          const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
          const backupFilename = buildOriginalBackupFilename(base64File, timestamp);
          const targetPath = await plugin.app.fileManager.getAvailablePathForAttachment(
            backupFilename,
            activeFile.path
          );
          const file = createImageFile(base64File, backupFilename);
          await plugin.app.vault.createBinary(
            targetPath,
            await file.arrayBuffer()
          );
        }
      }
    }
  }
  return { processedFile, shouldSaveAsAttachment };
}
async function convertOnlineImageToBase64(imageUrl, plugin, editor, line, cursor, onlineMatch) {
  try {
    const base64File = await fetchOnlineImage(imageUrl);
    const activeFile = plugin.app.workspace.getActiveFile();
    const { processedFile, shouldSaveAsAttachment } = await handleImageResizing(
      base64File,
      plugin,
      activeFile
    );
    if (shouldSaveAsAttachment && activeFile) {
      const file = createImageFile(base64File);
      const targetPath = await plugin.app.fileManager.getAvailablePathForAttachment(
        base64File.filename,
        activeFile.path
      );
      const newFile = await plugin.app.vault.createBinary(
        targetPath,
        await file.arrayBuffer()
      );
      const link = plugin.app.fileManager.generateMarkdownLink(
        newFile,
        activeFile.path
      );
      const newLine2 = line.replace(onlineMatch[0], link);
      const lineStart2 = editor.posToOffset({
        line: cursor.line,
        ch: 0
      });
      const lineEnd2 = editor.posToOffset({
        line: cursor.line,
        ch: line.length
      });
      editor.replaceRange(
        newLine2,
        editor.offsetToPos(lineStart2),
        editor.offsetToPos(lineEnd2)
      );
      new import_obsidian2.Notice("Image saved as attachment due to size");
      return;
    }
    const newLine = line.replace(onlineMatch[0], processedFile.to64Link());
    const lineStart = editor.posToOffset({
      line: cursor.line,
      ch: 0
    });
    const lineEnd = editor.posToOffset({
      line: cursor.line,
      ch: line.length
    });
    editor.replaceRange(
      newLine,
      editor.offsetToPos(lineStart),
      editor.offsetToPos(lineEnd)
    );
    new import_obsidian2.Notice("Online image converted to base64");
  } catch (error) {
    const message = error instanceof Error ? error.message : "Failed to convert online image: Unknown error";
    new import_obsidian2.Notice(message);
  }
}
async function registerConvertImage(plugin) {
  plugin.registerEvent(
    plugin.app.workspace.on("editor-menu", async (menu, editor) => {
      const cursor = editor.getCursor();
      const line = editor.getLine(cursor.line);
      const localImageRegex = /!\[\[([^\]\n]+\.(png|jpg|jpeg))\]\]/;
      const onlineImageRegex = /!\[([^\]]*)\]\((https?:\/\/[^\)]+)\)/;
      const localMatch = line.match(localImageRegex);
      const onlineMatch = line.match(onlineImageRegex);
      if (localMatch) {
        const imagePath = localMatch[1];
        const activeFile = plugin.app.workspace.getActiveFile();
        if (!activeFile) return;
        const file = plugin.app.metadataCache.getFirstLinkpathDest(
          imagePath,
          activeFile.path
        );
        if (file instanceof import_obsidian2.TFile) {
          menu.addItem((item) => {
            item.setTitle("Convert to Base64").setIcon("code-glyph").onClick(async () => {
              new ConvertToBase64Modal(
                plugin.app,
                file,
                editor
              ).open();
            });
          });
        }
      } else if (onlineMatch) {
        const imageUrl = onlineMatch[2];
        menu.addItem((item) => {
          item.setTitle("Convert online image to base64").setIcon("code-glyph").onClick(async () => {
            await convertOnlineImageToBase64(
              imageUrl,
              plugin,
              editor,
              line,
              cursor,
              onlineMatch
            );
          });
        });
      }
    })
  );
}

// src/commands/selectAndConvert.ts
var import_obsidian3 = require("obsidian");
var CONVERT_DEBUG_PREFIX = "[image-inline:convert-images]";
function logConvertDebug(message, details) {
  if (details === void 0) {
    console.debug(CONVERT_DEBUG_PREFIX, message);
    return;
  }
  console.debug(CONVERT_DEBUG_PREFIX, message, details);
}
function logConvertWarning(message, details) {
  if (details === void 0) {
    console.warn(CONVERT_DEBUG_PREFIX, message);
    return;
  }
  console.warn(CONVERT_DEBUG_PREFIX, message, details);
}
function logConvertError(message, details) {
  if (details === void 0) {
    console.error(CONVERT_DEBUG_PREFIX, message);
    return;
  }
  console.error(CONVERT_DEBUG_PREFIX, message, details);
}
var ConvertImagesModal = class extends import_obsidian3.Modal {
  /**
   * Stores the plugin reference and default conversion options for the modal session.
   */
  constructor(app, plugin) {
    super(app);
    this.plugin = plugin;
    this.conversionScope = "note";
    this.conversionType = "toBase64";
  }
  /**
   * Builds the modal UI for choosing conversion scope and direction.
   */
  onOpen() {
    const { contentEl } = this;
    contentEl.empty();
    contentEl.createEl("h2", { text: "Convert Images" });
    const scopeContainer = contentEl.createEl("div", { cls: "setting-item" });
    scopeContainer.createEl("label", { text: "Scope" });
    const scopeSelect = scopeContainer.createEl("select");
    const scopes = [
      { value: "note", text: "Current Note" },
      { value: "folder", text: "Current Folder" },
      { value: "vault", text: "Entire Vault" }
    ];
    scopes.forEach((scope) => {
      scopeSelect.createEl("option", {
        value: scope.value,
        text: scope.text
      });
    });
    const typeContainer = contentEl.createEl("div", { cls: "setting-item" });
    typeContainer.createEl("label", { text: "Conversion Type" });
    const typeSelect = typeContainer.createEl("select");
    const types = [
      { value: "toBase64", text: "Image Files \u2192 Base64" },
      { value: "toImage", text: "Base64 \u2192 Image Files" }
    ];
    types.forEach((type) => {
      typeSelect.createEl("option", {
        value: type.value,
        text: type.text
      });
    });
    const buttonContainer = contentEl.createEl("div", { cls: "setting-item" });
    const convertButton = buttonContainer.createEl("button", {
      text: "Convert",
      cls: "mod-cta"
    });
    convertButton.addEventListener("click", async () => {
      this.conversionScope = scopeSelect.value;
      this.conversionType = typeSelect.value;
      await this.performConversion();
      this.close();
    });
  }
  /**
   * Runs the requested batch conversion over the selected note scope.
   */
  async performConversion() {
    const files = await this.getFilesInScope();
    let converted = 0;
    logConvertDebug("Starting batch conversion", {
      scope: this.conversionScope,
      conversionType: this.conversionType,
      fileCount: files.length
    });
    for (const file of files) {
      if (this.conversionType === "toBase64") {
        const modified = await this.convertToBase64(file);
        if (modified) {
          converted++;
        }
      } else {
        const modified = await this.convertToImages(file);
        if (modified) {
          converted++;
        }
      }
    }
    logConvertDebug("Completed batch conversion", {
      scope: this.conversionScope,
      conversionType: this.conversionType,
      converted,
      totalFiles: files.length
    });
    new import_obsidian3.Notice(`Converted ${converted} files`);
  }
  /**
   * Collects markdown files for the currently selected conversion scope.
   */
  async getFilesInScope() {
    switch (this.conversionScope) {
      case "note":
        const activeFile = this.app.workspace.getActiveFile();
        if (!activeFile) {
          logConvertWarning("No active file was available for note-scoped conversion");
          return [];
        }
        return [activeFile];
      case "folder":
        const currentFile = this.app.workspace.getActiveFile();
        if (!(currentFile == null ? void 0 : currentFile.parent)) {
          logConvertWarning("No active folder was available for folder-scoped conversion");
          return [];
        }
        return this.app.vault.getMarkdownFiles().filter((f) => f.parent === currentFile.parent);
      case "vault":
        return this.app.vault.getMarkdownFiles();
      default:
        return [];
    }
  }
  /**
   * Returns the active editor when the target file is currently open, otherwise null.
   */
  getActiveEditorForFile(file) {
    var _a, _b;
    const activeFile = this.app.workspace.getActiveFile();
    const activeEditor = (_b = (_a = this.app.workspace.activeEditor) == null ? void 0 : _a.editor) != null ? _b : null;
    if (!activeFile || activeFile.path !== file.path || !activeEditor) {
      return null;
    }
    return activeEditor;
  }
  /**
   * Updates a markdown file atomically in the vault or through the active editor when it is open.
   */
  async updateMarkdownFile(file, updater) {
    const activeEditor = this.getActiveEditorForFile(file);
    if (activeEditor) {
      const currentContent = activeEditor.getValue();
      const updatedContent = updater(currentContent);
      if (updatedContent === currentContent) {
        logConvertDebug("Skipped editor update because content did not change", {
          file: file.path
        });
        return false;
      }
      activeEditor.setValue(updatedContent);
      logConvertDebug("Updated open note through active editor", {
        file: file.path
      });
      return true;
    }
    let modified = false;
    await this.app.vault.process(file, (content) => {
      const updatedContent = updater(content);
      modified = updatedContent !== content;
      return updatedContent;
    });
    if (modified) {
      logConvertDebug("Updated closed note through vault.process", {
        file: file.path
      });
    } else {
      logConvertDebug("Skipped vault.process update because content did not change", {
        file: file.path
      });
    }
    return modified;
  }
  /**
   * Applies exact-string replacements to markdown content in a deterministic sequence.
   */
  applyReplacements(content, replacements) {
    let updatedContent = content;
    for (const replacement of replacements) {
      updatedContent = updatedContent.replace(replacement.from, replacement.to);
    }
    return updatedContent;
  }
  /**
   * Rewrites local image embeds in a note into MIME-aware inline data URLs.
   */
  async convertToBase64(file) {
    const content = await this.app.vault.read(file);
    const imageRegex = /!\[\[([^\]]+\.(png|jpg|jpeg))\]\]/g;
    const replacements = [];
    let match;
    while ((match = imageRegex.exec(content)) !== null) {
      const imagePath = match[1];
      const imageFile = this.app.metadataCache.getFirstLinkpathDest(imagePath, file.path);
      if (!(imageFile instanceof import_obsidian3.TFile)) {
        logConvertWarning("Skipped image embed because the linked file could not be resolved", {
          note: file.path,
          imagePath
        });
        continue;
      }
      try {
        replacements.push({
          from: match[0],
          to: (await Base64File.fromTFile(imageFile)).to64Link()
        });
      } catch (error) {
        logConvertError("Failed to convert image embed to base64", {
          note: file.path,
          imagePath: imageFile.path,
          error
        });
        continue;
      }
    }
    logConvertDebug("Prepared base64 replacements", {
      file: file.path,
      replacements: replacements.length
    });
    return this.updateMarkdownFile(file, (currentContent) => {
      return this.applyReplacements(currentContent, replacements);
    });
  }
  /**
   * Writes inline data URLs back to vault attachments while preserving their image metadata.
   */
  async convertToImages(file) {
    const content = await this.app.vault.read(file);
    const base64Regex = /!\[.*?\]\(data:image\/[^;]+;base64,[^)]+\)/g;
    const replacements = [];
    let match;
    while ((match = base64Regex.exec(content)) !== null) {
      const base64File = Base64File.from64Link(match[0]);
      if (!base64File) {
        logConvertWarning("Skipped inline image because the data URL could not be parsed", {
          note: file.path
        });
        continue;
      }
      try {
        const targetPath = await this.app.fileManager.getAvailablePathForAttachment(
          base64File.filename,
          file.path
        );
        const imageFile = createImageFile(base64File);
        await this.app.vault.createBinary(targetPath, await imageFile.arrayBuffer());
        const newFile = this.app.vault.getAbstractFileByPath(targetPath);
        if (newFile instanceof import_obsidian3.TFile) {
          replacements.push({
            from: match[0],
            to: this.app.fileManager.generateMarkdownLink(newFile, file.path)
          });
          continue;
        }
        logConvertWarning("Created an attachment but could not resolve it back from the vault", {
          note: file.path,
          targetPath
        });
      } catch (error) {
        logConvertError("Failed to materialize inline image as an attachment", {
          note: file.path,
          filename: base64File.filename,
          error
        });
      }
    }
    logConvertDebug("Prepared attachment replacements", {
      file: file.path,
      replacements: replacements.length
    });
    return this.updateMarkdownFile(file, (currentContent) => {
      return this.applyReplacements(currentContent, replacements);
    });
  }
  /**
   * Clears modal contents after the batch conversion dialog closes.
   */
  onClose() {
    const { contentEl } = this;
    contentEl.empty();
  }
};
function registerConvertCommand(plugin) {
  plugin.addCommand({
    id: "convert-images",
    name: "Convert Images",
    callback: () => {
      new ConvertImagesModal(plugin.app, plugin).open();
    }
  });
}

// src/commands/selectAndExport.ts
var import_obsidian4 = require("obsidian");
var EXPORT_DEBUG_PREFIX = "[image-inline:export-images]";
function logExportDebug(message, details) {
  if (details === void 0) {
    console.debug(EXPORT_DEBUG_PREFIX, message);
    return;
  }
  console.debug(EXPORT_DEBUG_PREFIX, message, details);
}
function logExportWarning(message, details) {
  if (details === void 0) {
    console.warn(EXPORT_DEBUG_PREFIX, message);
    return;
  }
  console.warn(EXPORT_DEBUG_PREFIX, message, details);
}
function logExportError(message, details) {
  if (details === void 0) {
    console.error(EXPORT_DEBUG_PREFIX, message);
    return;
  }
  console.error(EXPORT_DEBUG_PREFIX, message, details);
}
var ExportImagesModal = class extends import_obsidian4.Modal {
  /**
   * Stores the plugin reference and default export scope for the modal session.
   */
  constructor(app, plugin) {
    super(app);
    this.plugin = plugin;
    this.conversionScope = "note";
  }
  /**
   * Builds the modal UI for choosing which notes should be exported.
   */
  onOpen() {
    const { contentEl } = this;
    contentEl.empty();
    contentEl.createEl("h2", { text: "Export Images" });
    const scopeContainer = contentEl.createEl("div", { cls: "setting-item" });
    scopeContainer.createEl("label", { text: "Scope" });
    const scopeSelect = scopeContainer.createEl("select");
    const scopes = [
      { value: "note", text: "Current Note" },
      { value: "folder", text: "Current Folder" },
      { value: "vault", text: "Entire Vault" }
    ];
    scopes.forEach((scope) => {
      scopeSelect.createEl("option", {
        value: scope.value,
        text: scope.text
      });
    });
    const buttonContainer = contentEl.createEl("div", { cls: "setting-item" });
    const exportButton = buttonContainer.createEl("button", {
      text: "Export",
      cls: "mod-cta"
    });
    exportButton.addEventListener("click", async () => {
      this.conversionScope = scopeSelect.value;
      await this.exportImages();
      this.close();
    });
  }
  /**
   * Exports inline and linked images from the selected note scope into attachments.
   */
  async exportImages() {
    const files = await this.getFilesInScope();
    let exportedCount = 0;
    let skippedCount = 0;
    logExportDebug("Starting image export", {
      scope: this.conversionScope,
      fileCount: files.length
    });
    for (const file of files) {
      const content = await this.app.vault.read(file);
      const base64Regex = /!\[.*?\]\(data:image\/[^;]+;base64,([^)]+)\)/g;
      const imageRegex = /!\[\[([^\]]+\.(png|jpg|jpeg))\]\]/g;
      let base64Match;
      let imageMatch;
      while ((base64Match = base64Regex.exec(content)) !== null) {
        try {
          const base64Data = base64Match[1];
          const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
          const filename = `base64_image_${timestamp}_${exportedCount}.png`;
          const binary = atob(base64Data);
          const array = new Uint8Array(binary.length);
          for (let i = 0; i < binary.length; i++) {
            array[i] = binary.charCodeAt(i);
          }
          const targetPath = await this.app.fileManager.getAvailablePathForAttachment(
            filename,
            file.path
          );
          const existingFile = this.app.vault.getAbstractFileByPath(targetPath);
          if (existingFile instanceof import_obsidian4.TFile) {
            const existingSize = (await this.app.vault.readBinary(existingFile)).byteLength;
            if (existingSize === array.buffer.byteLength) {
              skippedCount++;
              logExportDebug("Skipped exporting base64 image because a matching attachment already exists", {
                note: file.path,
                targetPath
              });
              continue;
            }
          }
          await this.app.vault.createBinary(targetPath, array.buffer);
          exportedCount++;
          logExportDebug("Exported inline base64 image to attachment", {
            note: file.path,
            targetPath
          });
        } catch (error) {
          logExportError("Failed to export inline base64 image", {
            note: file.path,
            error
          });
        }
      }
      while ((imageMatch = imageRegex.exec(content)) !== null) {
        try {
          const imagePath = imageMatch[1];
          const imageFile = this.app.metadataCache.getFirstLinkpathDest(imagePath, file.path);
          if (imageFile instanceof import_obsidian4.TFile) {
            const arrayBuffer = await this.app.vault.readBinary(imageFile);
            const targetPath = await this.app.fileManager.getAvailablePathForAttachment(
              imageFile.name,
              file.path
            );
            const existingFile = this.app.vault.getAbstractFileByPath(targetPath);
            if (existingFile instanceof import_obsidian4.TFile) {
              const existingSize = (await this.app.vault.readBinary(existingFile)).byteLength;
              if (existingSize === arrayBuffer.byteLength) {
                skippedCount++;
                logExportDebug("Skipped exporting linked image because a matching attachment already exists", {
                  note: file.path,
                  sourceImage: imageFile.path,
                  targetPath
                });
                continue;
              }
            }
            await this.app.vault.createBinary(targetPath, arrayBuffer);
            exportedCount++;
            logExportDebug("Exported linked image to attachment", {
              note: file.path,
              sourceImage: imageFile.path,
              targetPath
            });
          } else {
            logExportWarning("Skipped linked image export because the embed target could not be resolved", {
              note: file.path,
              imagePath
            });
          }
        } catch (error) {
          logExportError("Failed to export linked image embed", {
            note: file.path,
            error
          });
        }
      }
    }
    logExportDebug("Completed image export", {
      scope: this.conversionScope,
      exportedCount,
      skippedCount,
      totalFiles: files.length
    });
    if (exportedCount > 0 || skippedCount > 0) {
      new import_obsidian4.Notice(`Exported ${exportedCount} images, skipped ${skippedCount} duplicates`);
    } else {
      new import_obsidian4.Notice("No images found to export");
    }
  }
  /**
   * Collects markdown files for the currently selected export scope.
   */
  async getFilesInScope() {
    switch (this.conversionScope) {
      case "note":
        const activeFile = this.app.workspace.getActiveFile();
        if (!activeFile) {
          logExportWarning("No active file was available for note-scoped export");
          return [];
        }
        return [activeFile];
      case "folder":
        const currentFile = this.app.workspace.getActiveFile();
        if (!(currentFile == null ? void 0 : currentFile.parent)) {
          logExportWarning("No active folder was available for folder-scoped export");
          return [];
        }
        return this.app.vault.getMarkdownFiles().filter((f) => f.parent === currentFile.parent);
      case "vault":
        return this.app.vault.getMarkdownFiles();
      default:
        return [];
    }
  }
  /**
   * Clears modal contents after the export dialog closes.
   */
  onClose() {
    const { contentEl } = this;
    contentEl.empty();
  }
};
function registerExportCommand(plugin) {
  plugin.addCommand({
    id: "export-images",
    name: "Export Images",
    callback: () => {
      new ExportImagesModal(plugin.app, plugin).open();
    }
  });
}

// src/coms/cursorEscape.ts
var import_obsidian5 = require("obsidian");

// src/coms/cursorEscapeHelpers.ts
function findInlineImageLinkBounds(line) {
  if (!(line.startsWith("![[") || line.startsWith("![")) && !line.includes("(data:image/")) {
    return null;
  }
  if (!line.includes("(data:image/")) {
    return null;
  }
  const linkStart = line.indexOf("(data:image/");
  if (linkStart === -1) {
    return null;
  }
  let openParens = 1;
  for (let index = linkStart + 1; index < line.length; index++) {
    if (line[index] === "(") {
      openParens++;
    }
    if (line[index] === ")") {
      openParens--;
    }
    if (openParens === 0) {
      return { start: linkStart, end: index };
    }
  }
  return null;
}
function getEscapedCursorCh(line, cursorCh) {
  const bounds = findInlineImageLinkBounds(line);
  if (!bounds) {
    return null;
  }
  if (cursorCh <= bounds.start || cursorCh > bounds.end) {
    return null;
  }
  return bounds.end + 1;
}

// src/coms/cursorEscape.ts
function registerCursorEscape(plugin) {
  const syncCursorEscape = () => {
    if (!plugin.settings.autoEscapeLink) {
      return;
    }
    const activeView = plugin.app.workspace.getActiveViewOfType(import_obsidian5.MarkdownView);
    if (!activeView || activeView.getViewType() !== "markdown") {
      return;
    }
    checkCursorPosition(activeView.editor);
  };
  plugin.registerDomEvent(document, "selectionchange", () => {
    syncCursorEscape();
  });
  plugin.registerEvent(plugin.app.workspace.on("editor-change", () => {
    syncCursorEscape();
  }));
}
function checkCursorPosition(editor) {
  const cursor = editor.getCursor();
  const selection = editor.getSelection();
  if (selection) {
    return;
  }
  const line = editor.getLine(cursor.line);
  const escapedCursorCh = getEscapedCursorCh(line, cursor.ch);
  if (escapedCursorCh === null) {
    return;
  }
  editor.setCursor({
    line: cursor.line,
    ch: escapedCursorCh
  });
}

// src/main.ts
var DEFAULT_SETTINGS = {
  convertOnPaste: true,
  convertOnDrop: true,
  autoEscapeLink: true,
  // Default to true
  enableResizing: false,
  resizeStrategy: "smaller",
  smallerThreshold: 1e3,
  // 1MB default
  largerThreshold: 1e3,
  // 1MB default
  resizePercentage: 80,
  backupOriginalImage: true,
  resizeSmallerFiles: false
  // Default to false
};
var ImageInlinePlugin = class extends import_obsidian6.Plugin {
  /**
   * Registers commands, editor integrations, and settings when the plugin loads.
   */
  async onload() {
    await this.loadSettings();
    this.conversion = new Base64Conversion();
    this.registerEditorExtension(linkDecorations);
    await registerExportToLocal(this);
    await registerConvertImage(this);
    registerCursorEscape(this);
    await registerConvertCommand(this);
    await registerExportCommand(this);
    this.registerEvent(
      this.app.workspace.on("editor-paste", async (evt, editor) => {
        var _a;
        if (!this.settings.convertOnPaste) return;
        const items = (_a = evt.clipboardData) == null ? void 0 : _a.items;
        if (!items) return;
        const allImages = Array.from(items).every((item) => item.type.startsWith("image/"));
        if (!allImages) return;
        evt.preventDefault();
        const base64Files = [];
        for (const item of Array.from(items)) {
          if (item.type.startsWith("image/")) {
            const file = item.getAsFile();
            if (file) {
              const base64File = await this.conversion.fromFile(file);
              base64Files.push(base64File);
            }
          }
        }
        if (base64Files.length > 0) {
          await this.handleImages(base64Files, editor);
        }
      })
    );
    this.registerEvent(
      this.app.workspace.on("editor-drop", async (evt, editor) => {
        var _a;
        if (!this.settings.convertOnDrop) return;
        const files = (_a = evt.dataTransfer) == null ? void 0 : _a.files;
        if (!files || files.length === 0) return;
        const allImages = Array.from(files).every((file) => file.type.startsWith("image/"));
        if (!allImages) return;
        evt.preventDefault();
        const base64Files = [];
        for (const file of Array.from(files)) {
          if (file.type.startsWith("image/")) {
            const base64File = await this.conversion.fromFile(file);
            base64Files.push(base64File);
          }
        }
        if (base64Files.length > 0) {
          await this.handleImages(base64Files, editor);
        }
      })
    );
    this.addSettingTab(new ImageInlineSettingTab(this.app, this));
  }
  /**
   * Converts pasted or dropped images into inline Markdown or vault attachments based on settings.
   */
  async handleImages(base64Files, editor) {
    try {
      if (!this.settings.enableResizing) {
        const markdown = base64Files.map((file) => file.to64Link()).join("\n");
        editor.replaceSelection(markdown);
        return;
      }
      const processedFiles = [];
      const attachments = [];
      for (const base64File of base64Files) {
        const sizeInKB = base64File.size / 1024;
        if (this.settings.resizeStrategy === "smaller") {
          if (sizeInKB <= this.settings.smallerThreshold) {
            processedFiles.push(base64File);
          } else {
            attachments.push(base64File);
          }
        } else {
          if (sizeInKB > this.settings.largerThreshold) {
            const resizedFile = await this.conversion.resize(base64File, this.settings.resizePercentage);
            processedFiles.push(resizedFile);
            if (this.settings.backupOriginalImage) {
              const activeFile = this.app.workspace.getActiveFile();
              if (activeFile) {
                const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
                const backupFilename = buildOriginalBackupFilename(base64File, timestamp);
                const targetPath = await this.app.fileManager.getAvailablePathForAttachment(
                  backupFilename,
                  activeFile.path
                );
                const file = createImageFile(base64File, backupFilename);
                await this.app.vault.createBinary(
                  targetPath,
                  await file.arrayBuffer()
                );
              }
            }
          } else {
            processedFiles.push(base64File);
          }
        }
      }
      if (processedFiles.length > 0) {
        const markdown = processedFiles.map((file) => file.to64Link()).join("\n");
        editor.replaceSelection(markdown);
      }
      if (attachments.length > 0) {
        new import_obsidian6.Notice(`${attachments.length} image(s) will be saved as attachments`);
        for (const attachment of attachments) {
          const activeFile = this.app.workspace.getActiveFile();
          if (activeFile) {
            const file = createImageFile(attachment);
            const targetPath = await this.app.fileManager.getAvailablePathForAttachment(
              attachment.filename,
              activeFile.path
            );
            const newFile = await this.app.vault.createBinary(
              targetPath,
              await file.arrayBuffer()
            );
            const link = this.app.fileManager.generateMarkdownLink(
              newFile,
              activeFile.path
            );
            editor.replaceSelection(link + "\n");
          }
        }
      }
    } catch (error) {
      const message = error instanceof Error ? error.message : "Unknown error";
      new import_obsidian6.Notice("Failed to process images: " + message);
    }
  }
  /**
   * Loads persisted plugin settings and merges them with defaults.
   */
  async loadSettings() {
    this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());
  }
  /**
   * Persists the current plugin settings to disk.
   */
  async saveSettings() {
    await this.saveData(this.settings);
  }
};
var ImageInlineSettingTab = class extends import_obsidian6.PluginSettingTab {
  /**
   * Stores the plugin reference used by this settings tab.
   */
  constructor(app, plugin) {
    super(app, plugin);
    this.plugin = plugin;
  }
  /**
   * Builds the settings UI and wires changes back to persistent plugin state.
   */
  display() {
    const { containerEl } = this;
    containerEl.empty();
    containerEl.createEl("h2", { text: "General Settings" });
    new import_obsidian6.Setting(containerEl).setName("Convert on paste").setDesc("Convert images pasted into the editor to base64").addToggle((toggle) => toggle.setValue(this.plugin.settings.convertOnPaste).onChange(async (value) => {
      this.plugin.settings.convertOnPaste = value;
      await this.plugin.saveSettings();
    }));
    new import_obsidian6.Setting(containerEl).setName("Convert on drop").setDesc("Convert images dropped into the editor to base64").addToggle((toggle) => toggle.setValue(this.plugin.settings.convertOnDrop).onChange(async (value) => {
      this.plugin.settings.convertOnDrop = value;
      await this.plugin.saveSettings();
    }));
    new import_obsidian6.Setting(containerEl).setName("Auto escape base64 data section").setDesc("Automatically move cursor out of the base64 data section").addToggle((toggle) => toggle.setValue(this.plugin.settings.autoEscapeLink).onChange(async (value) => {
      this.plugin.settings.autoEscapeLink = value;
      await this.plugin.saveSettings();
    }));
    containerEl.createEl("h2", { text: "Image Resizing" });
    new import_obsidian6.Setting(containerEl).setName("Enable resizing").setDesc("Enable image resizing features").addToggle((toggle) => toggle.setValue(this.plugin.settings.enableResizing).onChange(async (value) => {
      this.plugin.settings.enableResizing = value;
      await this.plugin.saveSettings();
      this.display();
    }));
    if (this.plugin.settings.enableResizing) {
      new import_obsidian6.Setting(containerEl).setName("Resizing strategy").setDesc("Choose how to handle image resizing").addDropdown((dropdown) => dropdown.addOption("smaller", "Convert small images to base64").addOption("larger", "Resize large images").setValue(this.plugin.settings.resizeStrategy).onChange(async (value) => {
        this.plugin.settings.resizeStrategy = value;
        await this.plugin.saveSettings();
        this.display();
      }));
      if (this.plugin.settings.resizeStrategy === "smaller") {
        new import_obsidian6.Setting(containerEl).setName("Size threshold").setDesc("Images smaller than this size (in KB) will be converted to base64").addText((text) => text.setValue(this.plugin.settings.smallerThreshold.toString()).onChange(async (value) => {
          const num = Number(value);
          if (!isNaN(num)) {
            this.plugin.settings.smallerThreshold = num;
            await this.plugin.saveSettings();
          }
        }));
      } else {
        new import_obsidian6.Setting(containerEl).setName("Size threshold").setDesc("Images larger than this size (in KB) will be resized").addText((text) => text.setValue(this.plugin.settings.largerThreshold.toString()).onChange(async (value) => {
          const num = Number(value);
          if (!isNaN(num)) {
            this.plugin.settings.largerThreshold = num;
            await this.plugin.saveSettings();
          }
        }));
        new import_obsidian6.Setting(containerEl).setName("Resize percentage").setDesc("Percentage to resize images to (1-100)").addSlider((slider) => slider.setLimits(1, 100, 1).setValue(this.plugin.settings.resizePercentage).setDynamicTooltip().onChange(async (value) => {
          this.plugin.settings.resizePercentage = value;
          await this.plugin.saveSettings();
        }));
        new import_obsidian6.Setting(containerEl).setName("Backup original images").setDesc("Save original images to media folder when resizing").addToggle((toggle) => toggle.setValue(this.plugin.settings.backupOriginalImage).onChange(async (value) => {
          this.plugin.settings.backupOriginalImage = value;
          await this.plugin.saveSettings();
        }));
        new import_obsidian6.Setting(containerEl).setName("Resize smaller files").setDesc("Also resize files smaller than the threshold when using larger strategy").addToggle((toggle) => toggle.setValue(this.plugin.settings.resizeSmallerFiles).onChange(async (value) => {
          this.plugin.settings.resizeSmallerFiles = value;
          await this.plugin.saveSettings();
        }));
      }
    }
  }
};