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: () => BrowserBookmarkPlugin
});
module.exports = __toCommonJS(main_exports);
var import_obsidian8 = require("obsidian");

// src/types.ts
var DEFAULT_SETTINGS = {
  openIn: "tab",
  interceptLinks: false,
  showFavicons: true,
  showRibbonIcon: true,
  readLaterFolderName: "Read Later"
};
var DEFAULT_DATA = {
  items: [],
  settings: DEFAULT_SETTINGS
};
var VIEW_TYPE_BROWSER_BOOKMARK = "browser-bookmark-view";
var PINNED_PARENT_ID = "__pinned__";
function generateId() {
  return Date.now().toString(36) + Math.random().toString(36).substring(2, 9);
}

// src/store.ts
var BookmarkStore = class {
  constructor(plugin) {
    this.listeners = [];
    this.plugin = plugin;
    this.data = { items: [], settings: { ...DEFAULT_SETTINGS } };
  }
  async load() {
    var _a, _b;
    const saved = await this.plugin.loadData();
    this.data = {
      items: (_a = saved == null ? void 0 : saved.items) != null ? _a : DEFAULT_DATA.items,
      settings: { ...DEFAULT_SETTINGS, ...(_b = saved == null ? void 0 : saved.settings) != null ? _b : {} }
    };
  }
  async save() {
    await this.plugin.saveData(this.data);
  }
  onChange(listener) {
    this.listeners.push(listener);
    return () => {
      this.listeners = this.listeners.filter((l) => l !== listener);
    };
  }
  notify() {
    for (const listener of this.listeners)
      listener();
  }
  get settings() {
    return this.data.settings;
  }
  async updateSettings(patch) {
    this.data.settings = { ...this.data.settings, ...patch };
    await this.save();
    this.notify();
  }
  get items() {
    return this.data.items;
  }
  children(parentId) {
    return this.data.items.filter((item) => item.parentId === parentId).sort((a, b) => a.order - b.order);
  }
  nextOrder(parentId) {
    const siblings = this.children(parentId);
    return siblings.length > 0 ? Math.max(...siblings.map((s) => s.order)) + 1 : 0;
  }
  async addBookmark(title, url, parentId = null, fields = {}) {
    const node = {
      id: generateId(),
      type: "bookmark",
      title,
      url,
      parentId,
      order: this.nextOrder(parentId),
      iconType: fields.iconType,
      iconValue: fields.iconValue,
      description: fields.description
    };
    this.data.items.push(node);
    await this.save();
    this.notify();
    return node;
  }
  /**
   * Finds a root-level folder by exact title, creating it if missing. Used to
   * land bookmarks saved from the companion browser extension in a
   * consistent place (e.g. "Read Later") without the extension needing any
   * visibility into the vault's folder tree.
   */
  async getOrCreateRootFolder(title) {
    const existing = this.children(null).find((item) => item.type === "folder" && item.title === title);
    if (existing)
      return existing;
    return this.addFolder(title, null);
  }
  async addFolder(title, parentId = null) {
    const node = {
      id: generateId(),
      type: "folder",
      title,
      parentId,
      order: this.nextOrder(parentId),
      collapsed: false
    };
    this.data.items.push(node);
    await this.save();
    this.notify();
    return node;
  }
  /** Normalizes a URL for comparison: trims whitespace and a single trailing slash. */
  static normalizeUrl(url) {
    const trimmed = url.trim();
    return trimmed.endsWith("/") ? trimmed.slice(0, -1) : trimmed;
  }
  /** Finds an existing bookmark with the same URL, excluding `excludeId` (the one being edited). */
  findByUrl(url, excludeId) {
    const target = BookmarkStore.normalizeUrl(url);
    if (!target)
      return void 0;
    return this.data.items.find(
      (item) => item.type === "bookmark" && item.id !== excludeId && item.url !== void 0 && BookmarkStore.normalizeUrl(item.url) === target
    );
  }
  /**
   * Appends a batch of already-fully-formed nodes (e.g. from a bookmark
   * import) in one save+notify, instead of one per node -- an import can be
   * hundreds of nodes, and addBookmark/addFolder each write the whole
   * data.json to disk, which would otherwise thrash on a big import.
   */
  async importNodes(nodes) {
    if (nodes.length === 0)
      return;
    this.data.items.push(...nodes);
    await this.save();
    this.notify();
  }
  async rename(id, title) {
    const node = this.data.items.find((i) => i.id === id);
    if (!node)
      return;
    node.title = title;
    await this.save();
    this.notify();
  }
  async updateBookmark(id, title, url, fields = {}) {
    const node = this.data.items.find((i) => i.id === id);
    if (!node)
      return;
    node.title = title;
    node.url = url;
    node.iconType = fields.iconType;
    node.iconValue = fields.iconValue;
    node.description = fields.description;
    await this.save();
    this.notify();
  }
  async toggleCollapsed(id) {
    const node = this.data.items.find((i) => i.id === id);
    if (!node || node.type !== "folder")
      return;
    node.collapsed = !node.collapsed;
    await this.save();
    this.notify();
  }
  async toggleOpenExternally(id) {
    const node = this.data.items.find((i) => i.id === id);
    if (!node || node.type !== "bookmark")
      return;
    node.openExternally = !node.openExternally;
    await this.save();
    this.notify();
  }
  /** Removes a node. If it's a folder, its descendants are removed too. */
  async remove(id) {
    const idsToRemove = /* @__PURE__ */ new Set([id]);
    let grew = true;
    while (grew) {
      grew = false;
      for (const item of this.data.items) {
        if (item.parentId && idsToRemove.has(item.parentId) && !idsToRemove.has(item.id)) {
          idsToRemove.add(item.id);
          grew = true;
        }
      }
    }
    this.data.items = this.data.items.filter((i) => !idsToRemove.has(i.id));
    await this.save();
    this.notify();
  }
  /** Returns true if `ancestorId` is `id` itself or one of its ancestors. */
  isDescendantOf(id, ancestorId) {
    let current = this.data.items.find((i) => i.id === id);
    while (current) {
      if (current.id === ancestorId)
        return true;
      current = current.parentId ? this.data.items.find((i) => i.id === current.parentId) : void 0;
    }
    return false;
  }
  /**
   * Moves `id` to be a child of `newParentId`, inserted at `index` among its
   * new siblings. Reordering within the same parent is just a move to a new
   * index there, so this single method covers both drag gestures. Pinning is
   * also just a move -- `PINNED_PARENT_ID` is a reserved parentId, not a real
   * folder, so no special-casing is needed for rename/delete/reorder on a
   * pinned bookmark, only for the two convenience wrappers below.
   */
  async moveInto(id, newParentId, index) {
    const node = this.data.items.find((i) => i.id === id);
    if (!node)
      return;
    if (newParentId && (newParentId === id || this.isDescendantOf(newParentId, id)))
      return;
    node.parentId = newParentId;
    const siblings = this.children(newParentId).filter((s) => s.id !== id);
    siblings.splice(Math.max(0, Math.min(index, siblings.length)), 0, node);
    siblings.forEach((s, i) => {
      s.order = i;
    });
    await this.save();
    this.notify();
  }
  get pinned() {
    return this.children(PINNED_PARENT_ID);
  }
  async pin(id) {
    await this.moveInto(id, PINNED_PARENT_ID, this.children(PINNED_PARENT_ID).length);
  }
  /** Unpins to the root of the tree, not back to wherever it was before pinning -- simpler and more predictable than tracking a prior location that could itself have been deleted or reorganized since. */
  async unpin(id) {
    await this.moveInto(id, null, this.children(null).length);
  }
};

// src/views/BookmarkListView.ts
var import_obsidian6 = require("obsidian");

// src/webviewer.ts
var import_obsidian = require("obsidian");
function isWebViewerAvailable(app) {
  var _a, _b;
  if (import_obsidian.Platform.isMobile)
    return false;
  const internalPlugins = app.internalPlugins;
  return ((_b = (_a = internalPlugins == null ? void 0 : internalPlugins.plugins) == null ? void 0 : _a.webviewer) == null ? void 0 : _b.enabled) === true;
}
async function openExternally(url) {
  if (import_obsidian.Platform.isDesktop) {
    try {
      const electron = require("electron");
      await electron.shell.openExternal(url);
      return;
    } catch (err) {
      console.error("Browser Bookmark: shell.openExternal threw, falling back to window.open", err);
    }
  }
  window.open(url, "_blank");
}
async function openBookmark(app, url, paneType) {
  if (isWebViewerAvailable(app)) {
    try {
      const leaf = app.workspace.getLeaf(paneType);
      await leaf.setViewState({
        type: "webviewer",
        state: { url, navigate: true },
        active: true
      });
      await app.workspace.revealLeaf(leaf);
      return;
    } catch (e) {
    }
  }
  await openExternally(url);
}
async function openInSystemBrowser(url) {
  await openExternally(url);
}
function getActiveWebViewerPage(app) {
  var _a;
  const leaf = app.workspace.getMostRecentLeaf();
  if (!leaf)
    return null;
  const state = leaf.getViewState();
  if (state.type !== "webviewer")
    return null;
  const url = (_a = state.state) == null ? void 0 : _a.url;
  if (!url)
    return null;
  return { url, title: leaf.getDisplayText() || url };
}

// src/import.ts
var import_obsidian2 = require("obsidian");
function loadNodeFsModulesSync() {
  const fs = require("fs");
  const os = require("os");
  const path = require("path");
  return { fs, os, path };
}
function findArcSidebarFile() {
  if (!import_obsidian2.Platform.isDesktop)
    return null;
  try {
    const { fs, os, path } = loadNodeFsModulesSync();
    if (import_obsidian2.Platform.isMacOS) {
      const filePath = path.join(os.homedir(), "Library", "Application Support", "Arc", "StorableSidebar.json");
      return fs.existsSync(filePath) ? filePath : null;
    }
    if (import_obsidian2.Platform.isWin) {
      const packagesDir = path.join(os.homedir(), "AppData", "Local", "Packages");
      if (!fs.existsSync(packagesDir))
        return null;
      const arcDir = fs.readdirSync(packagesDir).find((name) => name.startsWith("TheBrowserCompany.Arc"));
      if (!arcDir)
        return null;
      const filePath = path.join(packagesDir, arcDir, "LocalCache", "Local", "Arc", "StorableSidebar.json");
      return fs.existsSync(filePath) ? filePath : null;
    }
  } catch (e) {
  }
  return null;
}
function readArcSidebarFile(path) {
  const { fs } = loadNodeFsModulesSync();
  return fs.readFileSync(path, "utf8");
}
function emptyBatch() {
  return { nodes: [], bookmarkCount: 0, folderCount: 0 };
}
function finalizeImport(batch, wrapperTitle) {
  var _a;
  const wrapperId = generateId();
  const wrapper = {
    id: wrapperId,
    type: "folder",
    title: wrapperTitle,
    parentId: null,
    order: 0,
    collapsed: false
  };
  const nodes = batch.nodes.map(
    (node) => node.parentId === null ? { ...node, parentId: wrapperId } : node
  );
  const orderCounters = /* @__PURE__ */ new Map();
  for (const node of nodes) {
    const count = (_a = orderCounters.get(node.parentId)) != null ? _a : 0;
    node.order = count;
    orderCounters.set(node.parentId, count + 1);
  }
  return [wrapper, ...nodes];
}
function parseNetscapeHtml(html) {
  const doc = new DOMParser().parseFromString(html, "text/html");
  const rootDl = doc.querySelector("dl");
  const batch = emptyBatch();
  if (!rootDl)
    return batch;
  walkNetscapeDl(rootDl, null, batch);
  return batch;
}
function walkNetscapeDl(dl, parentId, batch) {
  var _a, _b, _c;
  const children = Array.from(dl.children);
  for (let i = 0; i < children.length; i++) {
    const el = children[i];
    if (el.tagName === "DL") {
      walkNetscapeDl(el, parentId, batch);
      continue;
    }
    if (el.tagName !== "DT")
      continue;
    const h3 = el.querySelector(":scope > h3");
    const a = el.querySelector(":scope > a");
    if (h3) {
      const folderId = generateId();
      batch.nodes.push({
        id: folderId,
        type: "folder",
        title: ((_a = h3.textContent) == null ? void 0 : _a.trim()) || "Imported folder",
        parentId,
        order: 0,
        collapsed: false
      });
      batch.folderCount++;
      let childDl = el.querySelector(":scope > dl");
      if (!childDl && ((_b = children[i + 1]) == null ? void 0 : _b.tagName) === "DL") {
        childDl = children[i + 1];
        i++;
      }
      if (childDl)
        walkNetscapeDl(childDl, folderId, batch);
    } else if (a) {
      const url = a.getAttribute("href");
      if (!url)
        continue;
      batch.nodes.push({
        id: generateId(),
        type: "bookmark",
        title: ((_c = a.textContent) == null ? void 0 : _c.trim()) || url,
        url,
        parentId,
        order: 0
      });
      batch.bookmarkCount++;
    }
  }
}
function cleanArcUrl(url) {
  return url.replace(/\\\//g, "/").trim();
}
function isRecord(value) {
  return typeof value === "object" && value !== null;
}
function parseArcSidebarJson(json) {
  var _a, _b;
  const batch = emptyBatch();
  const data = JSON.parse(json);
  if (!isRecord(data))
    return batch;
  const containers = (_a = data.sidebar) == null ? void 0 : _a.containers;
  if (!Array.isArray(containers))
    return batch;
  const container = containers.find(
    (c) => isRecord(c) && Array.isArray(c.items) && Array.isArray(c.spaces)
  );
  if (!container)
    return batch;
  const itemsById = /* @__PURE__ */ new Map();
  for (const raw of container.items) {
    if (isRecord(raw) && typeof raw.id === "string")
      itemsById.set(raw.id, raw);
  }
  const extractPinnedContainerIds = (space) => {
    var _a2;
    const source = (_a2 = space.newContainerIDs) != null ? _a2 : space.containerIDs;
    if (!Array.isArray(source))
      return [];
    const ids = [];
    for (let i = 0; i < source.length; i++) {
      const marker = source[i];
      const label = typeof marker === "string" ? marker : isRecord(marker) ? Object.keys(marker)[0] : void 0;
      if (label !== "pinned")
        continue;
      const idEntry = source[i + 1];
      if (typeof idEntry === "string")
        ids.push(idEntry);
    }
    return ids;
  };
  const walkChildren = (childrenIds, parentId) => {
    var _a2, _b2, _c, _d;
    for (const rawId of childrenIds != null ? childrenIds : []) {
      if (typeof rawId !== "string")
        continue;
      const item = itemsById.get(rawId);
      if (!item)
        continue;
      if ((_a2 = item.data) == null ? void 0 : _a2.tab) {
        const rawUrl = item.data.tab.savedURL;
        if (!rawUrl)
          continue;
        const url = cleanArcUrl(rawUrl);
        batch.nodes.push({
          id: generateId(),
          type: "bookmark",
          title: ((_b2 = item.data.tab.savedTitle) == null ? void 0 : _b2.trim()) || url,
          url,
          parentId,
          order: 0
        });
        batch.bookmarkCount++;
      } else if ((_c = item.data) == null ? void 0 : _c.list) {
        const folderId = generateId();
        batch.nodes.push({
          id: folderId,
          type: "folder",
          title: ((_d = item.title) == null ? void 0 : _d.trim()) || "Imported folder",
          parentId,
          order: 0,
          collapsed: false
        });
        batch.folderCount++;
        walkChildren(item.childrenIds, folderId);
      } else {
        walkChildren(item.childrenIds, parentId);
      }
    }
  };
  for (const rawSpace of container.spaces) {
    if (!isRecord(rawSpace))
      continue;
    const space = rawSpace;
    const spaceFolderId = generateId();
    const beforeCount = batch.nodes.length;
    const spaceNode = {
      id: spaceFolderId,
      type: "folder",
      title: ((_b = space.title) == null ? void 0 : _b.trim()) || "Arc space",
      parentId: null,
      order: 0,
      collapsed: false
    };
    for (const containerId of extractPinnedContainerIds(space)) {
      const containerItem = itemsById.get(containerId);
      if (containerItem)
        walkChildren(containerItem.childrenIds, spaceFolderId);
    }
    if (batch.nodes.length > beforeCount) {
      batch.nodes.splice(beforeCount, 0, spaceNode);
      batch.folderCount++;
    }
  }
  return batch;
}

// src/export.ts
function escapeHtml(text) {
  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
}
function childrenOf(items, parentId) {
  return items.filter((item) => item.parentId === parentId).sort((a, b) => a.order - b.order);
}
function renderNode(items, node, depth) {
  var _a;
  const indent = "  ".repeat(depth);
  if (node.type === "folder") {
    const kids = childrenOf(items, node.id);
    return `${indent}<DT><H3>${escapeHtml(node.title)}</H3>
${indent}<DL><p>
` + kids.map((kid) => renderNode(items, kid, depth + 1)).join("") + `${indent}</DL><p>
`;
  }
  return `${indent}<DT><A HREF="${escapeHtml((_a = node.url) != null ? _a : "")}">${escapeHtml(node.title)}</A>
`;
}
function exportToNetscapeHtml(items) {
  const rootItems = childrenOf(items, null);
  const pinnedItems = childrenOf(items, PINNED_PARENT_ID);
  let body = rootItems.map((node) => renderNode(items, node, 1)).join("");
  if (pinnedItems.length > 0) {
    body += "  <DT><H3>Pinned</H3>\n  <DL><p>\n" + pinnedItems.map((node) => renderNode(items, node, 2)).join("") + "  </DL><p>\n";
  }
  return '<!DOCTYPE NETSCAPE-Bookmark-file-1>\n<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8">\n<TITLE>Bookmarks</TITLE>\n<H1>Bookmarks</H1>\n<DL><p>\n' + body + "</DL><p>\n";
}

// src/modals/BookmarkEditModal.ts
var import_obsidian3 = require("obsidian");
var BookmarkEditModal = class extends import_obsidian3.Modal {
  constructor(app, heading, initial, onSubmit, findDuplicateTitle) {
    var _a, _b, _c, _d, _e;
    super(app);
    this.heading = heading;
    this.onSubmit = onSubmit;
    this.findDuplicateTitle = findDuplicateTitle;
    this.title_ = (_a = initial.title) != null ? _a : "";
    this.url = (_b = initial.url) != null ? _b : "";
    this.description = (_c = initial.description) != null ? _c : "";
    this.iconType = (_d = initial.iconType) != null ? _d : "auto";
    this.iconValue = (_e = initial.iconValue) != null ? _e : "";
  }
  onOpen() {
    const { contentEl } = this;
    contentEl.empty();
    contentEl.createEl("h2", { text: this.heading });
    new import_obsidian3.Setting(contentEl).setName("Title").addText(
      (text) => text.setPlaceholder("My bookmark").setValue(this.title_).onChange((value) => this.title_ = value)
    );
    new import_obsidian3.Setting(contentEl).setName("Description").setDesc("Optional. Shown below the title in the sidebar, e.g. as a reminder of why you saved it.").addText(
      (text) => text.setPlaceholder("What this is for").setValue(this.description).onChange((value) => this.description = value)
    );
    let updateWarning = () => {
    };
    new import_obsidian3.Setting(contentEl).setName("URL").addText(
      (text) => text.setPlaceholder("https://example.com").setValue(this.url).onChange((value) => {
        this.url = value;
        updateWarning();
      })
    );
    const warningEl = contentEl.createDiv({ cls: "browser-bookmark-modal-warning" });
    updateWarning = () => {
      var _a;
      const existing = (_a = this.findDuplicateTitle) == null ? void 0 : _a.call(this, this.url.trim());
      warningEl.setText(existing ? `Already bookmarked as "${existing}".` : "");
      warningEl.toggleClass("is-visible", Boolean(existing));
    };
    updateWarning();
    let updateIconUi = () => {
    };
    new import_obsidian3.Setting(contentEl).setName("Icon").setDesc("Auto uses the site's favicon.").addDropdown(
      (dropdown) => dropdown.addOption("auto", "Auto (favicon)").addOption("lucide", "Icon name").addOption("image", "Image URL").setValue(this.iconType).onChange((value) => {
        this.iconType = value;
        updateIconUi();
      })
    );
    let iconValueInputEl;
    const iconValueSetting = new import_obsidian3.Setting(contentEl).addText((text) => {
      text.setValue(this.iconValue).onChange((value) => {
        this.iconValue = value;
        updateIconUi();
      });
      iconValueInputEl = text.inputEl;
    });
    const previewEl = contentEl.createDiv({ cls: "browser-bookmark-icon-preview" });
    updateIconUi = () => {
      const isAuto = this.iconType === "auto";
      iconValueSetting.settingEl.toggleClass("browser-bookmark-hidden", isAuto);
      if (this.iconType === "lucide") {
        iconValueSetting.setName("Icon name");
        iconValueInputEl.placeholder = "e.g. star, bookmark, book-marked";
      } else if (this.iconType === "image") {
        iconValueSetting.setName("Image URL");
        iconValueInputEl.placeholder = "https://example.com/icon.png";
      }
      previewEl.empty();
      const value = this.iconValue.trim();
      if (isAuto || !value)
        return;
      if (this.iconType === "lucide") {
        (0, import_obsidian3.setIcon)(previewEl, value);
      } else {
        const img = previewEl.createEl("img", { attr: { src: value } });
        img.addEventListener(
          "error",
          () => {
            img.remove();
            previewEl.setText("Could not load that image.");
          },
          { once: true }
        );
      }
    };
    updateIconUi();
    new import_obsidian3.Setting(contentEl).addButton(
      (btn) => btn.setButtonText("Save").setCta().onClick(() => {
        const trimmedUrl = this.url.trim();
        if (!trimmedUrl) {
          new import_obsidian3.Notice("A URL is required.");
          return;
        }
        const trimmedTitle = this.title_.trim() || trimmedUrl;
        const trimmedIconValue = this.iconValue.trim();
        const useCustomIcon = this.iconType !== "auto" && Boolean(trimmedIconValue);
        this.onSubmit({
          title: trimmedTitle,
          url: trimmedUrl,
          description: this.description.trim() || void 0,
          iconType: useCustomIcon ? this.iconType : void 0,
          iconValue: useCustomIcon ? trimmedIconValue : void 0
        });
        this.close();
      })
    );
  }
  onClose() {
    this.contentEl.empty();
  }
};

// src/modals/FolderEditModal.ts
var import_obsidian4 = require("obsidian");
var FolderEditModal = class extends import_obsidian4.Modal {
  constructor(app, heading, initialName, onSubmit) {
    super(app);
    this.heading = heading;
    this.onSubmit = onSubmit;
    this.name = initialName;
  }
  onOpen() {
    const { contentEl } = this;
    contentEl.empty();
    contentEl.createEl("h2", { text: this.heading });
    new import_obsidian4.Setting(contentEl).setName("Folder name").addText((text) => {
      text.setPlaceholder("New folder").setValue(this.name).onChange((value) => this.name = value);
      text.inputEl.focus();
    });
    new import_obsidian4.Setting(contentEl).addButton(
      (btn) => btn.setButtonText("Save").setCta().onClick(() => {
        const trimmed = this.name.trim();
        if (!trimmed) {
          new import_obsidian4.Notice("A folder name is required.");
          return;
        }
        this.onSubmit(trimmed);
        this.close();
      })
    );
  }
  onClose() {
    this.contentEl.empty();
  }
};

// src/modals/ImportPreviewModal.ts
var import_obsidian5 = require("obsidian");
var PREVIEW_LIMIT = 12;
var ImportPreviewModal = class extends import_obsidian5.Modal {
  constructor(app, batch, defaultFolderName, onConfirm) {
    super(app);
    this.batch = batch;
    this.onConfirm = onConfirm;
    this.folderName = defaultFolderName;
  }
  onOpen() {
    const { contentEl } = this;
    contentEl.empty();
    contentEl.createEl("h2", { text: "Import bookmarks" });
    const bookmarkLabel = `${this.batch.bookmarkCount} bookmark${this.batch.bookmarkCount === 1 ? "" : "s"}`;
    const folderLabel = `${this.batch.folderCount} folder${this.batch.folderCount === 1 ? "" : "s"}`;
    contentEl.createEl("p", { text: `Found ${bookmarkLabel} in ${folderLabel}.` });
    new import_obsidian5.Setting(contentEl).setName("Import into new folder").addText(
      (text) => text.setValue(this.folderName).onChange((value) => this.folderName = value)
    );
    const topLevel = this.batch.nodes.filter((n) => n.parentId === null);
    if (topLevel.length > 0) {
      contentEl.createEl("p", {
        text: "Top-level items:",
        cls: "browser-bookmark-import-preview-label"
      });
      const list = contentEl.createEl("ul", { cls: "browser-bookmark-import-preview-list" });
      for (const node of topLevel.slice(0, PREVIEW_LIMIT)) {
        list.createEl("li", { text: node.title });
      }
      if (topLevel.length > PREVIEW_LIMIT) {
        list.createEl("li", {
          text: `\u2026and ${topLevel.length - PREVIEW_LIMIT} more`,
          cls: "browser-bookmark-import-preview-more"
        });
      }
    }
    new import_obsidian5.Setting(contentEl).addButton((btn) => btn.setButtonText("Cancel").onClick(() => this.close())).addButton(
      (btn) => btn.setButtonText("Import").setCta().onClick(() => {
        const name = this.folderName.trim();
        if (!name) {
          new import_obsidian5.Notice("A folder name is required.");
          return;
        }
        this.onConfirm(name);
        this.close();
      })
    );
  }
  onClose() {
    this.contentEl.empty();
  }
};

// src/views/BookmarkListView.ts
function extractLinkFromDataTransfer(dt) {
  var _a;
  if (!dt)
    return null;
  const uriList = dt.getData("text/uri-list");
  const line = uriList.split("\n").map((s) => s.trim()).find((s) => s && !s.startsWith("#"));
  if (line)
    return { title: line, url: line };
  const html = dt.getData("text/html");
  if (html) {
    const anchor = new DOMParser().parseFromString(html, "text/html").querySelector("a[href]");
    const href = anchor == null ? void 0 : anchor.getAttribute("href");
    if (href)
      return { title: ((_a = anchor == null ? void 0 : anchor.textContent) == null ? void 0 : _a.trim()) || href, url: href };
  }
  const text = dt.getData("text/plain").trim();
  if (text) {
    const markdownLink = text.match(/^\[([^\]]+)\]\((\S+)\)$/);
    if (markdownLink)
      return { title: markdownLink[1], url: markdownLink[2] };
    try {
      return { title: text, url: new URL(text).href };
    } catch (e) {
    }
  }
  return null;
}
function hasLinkData(dt) {
  if (!dt)
    return false;
  return dt.types.includes("text/uri-list") || dt.types.includes("text/html") || dt.types.includes("text/plain");
}
var BookmarkListView = class extends import_obsidian6.ItemView {
  constructor(leaf, plugin) {
    super(leaf);
    this.plugin = plugin;
    this.draggedId = null;
    this.dropMarkedEl = null;
    this.unsubscribe = null;
    this.searchActive = false;
    this.searchQuery = "";
    this.visibleOrder = [];
    this.focusedId = null;
    this.store = plugin.store;
  }
  getViewType() {
    return VIEW_TYPE_BROWSER_BOOKMARK;
  }
  getDisplayText() {
    return "Browser bookmarks";
  }
  getIcon() {
    return "bookmark";
  }
  async onOpen() {
    const container = this.contentEl;
    container.empty();
    container.addClass("browser-bookmark-view");
    const toolbar = container.createDiv({ cls: "browser-bookmark-toolbar" });
    this.makeIconButton(toolbar, "file-plus", "New bookmark", () => this.createBookmark(null));
    this.makeIconButton(toolbar, "folder-plus", "New folder", () => this.createFolder(null));
    this.makeIconButton(toolbar, "download", "Import / export bookmarks", (evt) => this.openImportMenu(evt));
    this.makeIconButton(toolbar, "search", "Search", () => this.toggleSearch()).addClass(
      "browser-bookmark-search-toggle"
    );
    this.pinnedRowEl = container.createDiv({ cls: "browser-bookmark-pinned-row" });
    this.registerPinnedRowDropZone();
    this.searchInputEl = container.createEl("input", {
      cls: "browser-bookmark-search-input",
      attr: { type: "text", placeholder: "Search bookmarks\u2026" }
    });
    this.searchInputEl.addEventListener("input", () => {
      this.searchQuery = this.searchInputEl.value;
      this.render();
    });
    this.searchInputEl.addEventListener("keydown", (evt) => {
      if (evt.key === "Escape") {
        evt.preventDefault();
        this.toggleSearch(false);
      }
    });
    this.treeEl = container.createDiv({ cls: "browser-bookmark-tree", attr: { tabindex: "0" } });
    this.registerRootDropZone(this.treeEl);
    this.treeEl.addEventListener("keydown", (evt) => this.handleKeydown(evt));
    this.unsubscribe = this.store.onChange(() => this.render());
    this.render();
  }
  toggleSearch(forceOpen) {
    this.searchActive = forceOpen != null ? forceOpen : !this.searchActive;
    this.searchInputEl.toggleClass("is-visible", this.searchActive);
    if (this.searchActive) {
      this.searchInputEl.focus();
    } else {
      this.searchInputEl.value = "";
      this.searchQuery = "";
      this.render();
    }
  }
  async onClose() {
    var _a;
    (_a = this.unsubscribe) == null ? void 0 : _a.call(this);
  }
  makeIconButton(parent, icon, label, onClick) {
    const btn = parent.createDiv({ cls: "browser-bookmark-icon-btn", attr: { "aria-label": label } });
    (0, import_obsidian6.setIcon)(btn, icon);
    btn.addEventListener("click", onClick);
    return btn;
  }
  matchesQuery(node, query) {
    var _a, _b;
    if (node.type === "bookmark") {
      return node.title.toLowerCase().includes(query) || ((_a = node.url) != null ? _a : "").toLowerCase().includes(query) || ((_b = node.description) != null ? _b : "").toLowerCase().includes(query);
    }
    return this.store.children(node.id).some((child) => this.matchesQuery(child, query));
  }
  render() {
    this.renderPinnedRow();
    this.treeEl.empty();
    this.visibleOrder = [];
    const query = this.searchQuery.trim().toLowerCase();
    const roots = this.store.children(null).filter((n) => !query || this.matchesQuery(n, query));
    if (roots.length === 0) {
      this.treeEl.createDiv({
        cls: "browser-bookmark-empty",
        text: query ? "No matches." : "No bookmarks yet."
      });
      return;
    }
    for (const node of roots)
      this.renderNode(this.treeEl, node, 0, query);
  }
  renderNode(parentEl, node, depth, query) {
    if (node.type === "folder")
      this.renderFolder(parentEl, node, depth, query);
    else
      this.renderBookmark(parentEl, node, depth);
  }
  renderRowShell(parentEl, node, depth, extraCls = "") {
    const row = parentEl.createDiv({
      cls: `browser-bookmark-row ${extraCls}`.trim(),
      attr: { "data-node-id": node.id, style: `padding-left: ${8 + depth * 16}px` }
    });
    const grip = row.createDiv({ cls: "browser-bookmark-grip", attr: { draggable: "true" } });
    (0, import_obsidian6.setIcon)(grip, "grip-vertical");
    this.wireDrag(row, grip, node);
    this.visibleOrder.push(node.id);
    if (node.id === this.focusedId)
      row.addClass("is-focused");
    row.addEventListener("mousedown", (evt) => {
      if (evt.target.tagName === "INPUT")
        return;
      this.setFocus(node.id);
    });
    return row;
  }
  renderFolder(parentEl, node, depth, query) {
    const wrapper = parentEl.createDiv({ cls: "browser-bookmark-folder" });
    const row = this.renderRowShell(wrapper, node, depth, "browser-bookmark-group-header");
    const expanded = query ? true : !node.collapsed;
    const chevron = row.createDiv({ cls: "browser-bookmark-chevron" });
    (0, import_obsidian6.setIcon)(chevron, expanded ? "chevron-down" : "chevron-right");
    const title = row.createSpan({ cls: "browser-bookmark-title browser-bookmark-folder-title" });
    title.setText(node.title);
    this.wireRename(title, node);
    this.wireRowClick(row, () => {
      if (!query)
        void this.store.toggleCollapsed(node.id);
    });
    row.addEventListener("contextmenu", (evt) => {
      evt.preventDefault();
      this.showFolderMenu(node, evt);
    });
    if (expanded) {
      const childWrap = wrapper.createDiv({ cls: "browser-bookmark-group-children" });
      const children = this.store.children(node.id).filter((child) => !query || this.matchesQuery(child, query));
      for (const child of children)
        this.renderNode(childWrap, child, depth + 1, query);
    }
  }
  renderBookmark(parentEl, node, depth) {
    const row = this.renderRowShell(parentEl, node, depth, "browser-bookmark-link-row");
    this.renderFavicon(row, node);
    const textCol = row.createDiv({ cls: "browser-bookmark-text-col" });
    const title = textCol.createSpan({ cls: "browser-bookmark-title" });
    title.setText(node.title);
    this.wireRename(title, node);
    if (node.description) {
      textCol.createDiv({ cls: "browser-bookmark-description", text: node.description });
    }
    this.wireRowClick(row, () => this.openDefault(node));
    row.addEventListener("contextmenu", (evt) => {
      evt.preventDefault();
      this.showBookmarkMenu(node, evt);
    });
  }
  /**
   * Shows, in order: a custom Lucide icon or custom image (set via the edit
   * modal), then the site's real favicon, then a generic globe icon as the
   * final fallback on any failure.
   */
  renderFavicon(row, node) {
    const box = row.createDiv({ cls: "browser-bookmark-favicon" });
    if (node.iconType === "lucide" && node.iconValue) {
      (0, import_obsidian6.setIcon)(box, node.iconValue);
      return;
    }
    if (node.iconType === "image" && node.iconValue) {
      const img2 = box.createEl("img", { cls: "browser-bookmark-favicon-img", attr: { src: node.iconValue } });
      img2.addEventListener(
        "error",
        () => {
          img2.remove();
          (0, import_obsidian6.setIcon)(box, "globe");
        },
        { once: true }
      );
      return;
    }
    const domain = this.store.settings.showFavicons ? this.extractDomain(node.url) : null;
    if (!domain) {
      (0, import_obsidian6.setIcon)(box, "globe");
      return;
    }
    const img = box.createEl("img", {
      cls: "browser-bookmark-favicon-img",
      attr: { src: `https://www.google.com/s2/favicons?sz=64&domain=${encodeURIComponent(domain)}` }
    });
    img.addEventListener(
      "error",
      () => {
        img.remove();
        (0, import_obsidian6.setIcon)(box, "globe");
      },
      { once: true }
    );
  }
  extractDomain(url) {
    if (!url)
      return null;
    try {
      return new URL(url).hostname;
    } catch (e) {
      return null;
    }
  }
  // ── Pinned row ───────────────────────────────────────────
  /** Hidden entirely when nothing's pinned -- no placeholder/drop-hint box. The first pin always comes from a bookmark's context menu, never a drag onto empty space, since there's nothing visible to drag onto yet. */
  renderPinnedRow() {
    const pinned = this.store.pinned;
    this.pinnedRowEl.empty();
    this.pinnedRowEl.toggleClass("is-visible", pinned.length > 0);
    for (const node of pinned)
      this.renderPinnedButton(node);
  }
  renderPinnedButton(node) {
    const btn = this.pinnedRowEl.createDiv({
      cls: "browser-bookmark-pinned-btn",
      attr: { draggable: "true", title: node.title, "data-node-id": node.id }
    });
    this.renderFavicon(btn, node);
    btn.addEventListener("click", () => this.openDefault(node));
    btn.addEventListener("contextmenu", (evt) => {
      evt.preventDefault();
      this.showBookmarkMenu(node, evt);
    });
    this.wirePinnedDrag(btn, node);
  }
  // ── Keyboard navigation ──────────────────────────────────
  setFocus(id) {
    var _a;
    const prevId = this.focusedId;
    this.focusedId = id;
    if (prevId)
      (_a = this.treeEl.querySelector(`[data-node-id="${prevId}"]`)) == null ? void 0 : _a.removeClass("is-focused");
    const el = this.treeEl.querySelector(`[data-node-id="${id}"]`);
    el == null ? void 0 : el.addClass("is-focused");
    el == null ? void 0 : el.scrollIntoView({ block: "nearest" });
    this.treeEl.focus();
  }
  moveFocus(delta) {
    if (this.visibleOrder.length === 0)
      return;
    const currentIndex = this.focusedId ? this.visibleOrder.indexOf(this.focusedId) : -1;
    const nextIndex = Math.max(0, Math.min(this.visibleOrder.length - 1, currentIndex + delta));
    const nextId = this.visibleOrder[nextIndex];
    if (nextId)
      this.setFocus(nextId);
  }
  handleKeydown(evt) {
    if (!this.focusedId) {
      if (evt.key === "ArrowDown" || evt.key === "ArrowUp") {
        evt.preventDefault();
        this.moveFocus(evt.key === "ArrowDown" ? 1 : -1);
      }
      return;
    }
    const node = this.store.items.find((i) => i.id === this.focusedId);
    if (!node)
      return;
    switch (evt.key) {
      case "ArrowDown":
        evt.preventDefault();
        this.moveFocus(1);
        break;
      case "ArrowUp":
        evt.preventDefault();
        this.moveFocus(-1);
        break;
      case "ArrowRight":
        evt.preventDefault();
        if (node.type === "folder") {
          if (node.collapsed)
            void this.store.toggleCollapsed(node.id);
          else
            this.moveFocus(1);
        }
        break;
      case "ArrowLeft":
        evt.preventDefault();
        if (node.type === "folder" && !node.collapsed)
          void this.store.toggleCollapsed(node.id);
        else if (node.parentId)
          this.setFocus(node.parentId);
        break;
      case "Enter":
        evt.preventDefault();
        if (node.type === "folder")
          void this.store.toggleCollapsed(node.id);
        else
          this.openDefault(node);
        break;
      case "F2": {
        evt.preventDefault();
        const titleEl = this.treeEl.querySelector(
          `[data-node-id="${node.id}"] .browser-bookmark-title`
        );
        if (titleEl)
          this.startRename(titleEl, node);
        break;
      }
      case "Delete":
      case "Backspace":
        evt.preventDefault();
        void this.store.remove(node.id);
        break;
    }
  }
  /**
   * A plain 'click' listener would also fire (twice) on the way to a
   * double-click, which both re-triggers `action` and races the rename
   * input swapped in by `wireRename`'s dblclick handler. Delaying the
   * action lets a following second click cancel it, so double-clicking
   * the title renames instead of opening/toggling twice first.
   */
  wireRowClick(row, action) {
    let pending = null;
    row.addEventListener("click", () => {
      if (pending !== null) {
        window.clearTimeout(pending);
        pending = null;
        return;
      }
      pending = window.setTimeout(() => {
        pending = null;
        action();
      }, 250);
    });
  }
  // ── Inline rename ────────────────────────────────────────
  wireRename(title, node) {
    title.addEventListener("dblclick", (evt) => {
      evt.stopPropagation();
      this.startRename(title, node);
    });
  }
  startRename(title, node) {
    const parent = title.parentElement;
    const input = parent.createEl("input", { cls: "browser-bookmark-rename-input" });
    input.type = "text";
    input.value = node.title;
    parent.insertBefore(input, title);
    title.remove();
    input.focus();
    input.select();
    const finish = async (commit) => {
      input.removeEventListener("blur", onBlur);
      input.removeEventListener("keydown", onKeydown);
      const value = input.value.trim();
      if (commit && value && value !== node.title) {
        await this.store.rename(node.id, value);
      } else {
        input.replaceWith(title);
      }
    };
    const onBlur = () => void finish(true);
    const onKeydown = (evt) => {
      if (evt.key === "Enter") {
        evt.preventDefault();
        void finish(true);
      } else if (evt.key === "Escape") {
        evt.preventDefault();
        void finish(false);
      }
    };
    input.addEventListener("blur", onBlur);
    input.addEventListener("keydown", onKeydown);
  }
  // ── Context menus ────────────────────────────────────────
  async copyToClipboard(text) {
    try {
      await navigator.clipboard.writeText(text);
      new import_obsidian6.Notice("Copied to clipboard.");
    } catch (err) {
      console.error("Browser Bookmark: clipboard write failed", err);
      new import_obsidian6.Notice("Could not copy to clipboard.");
    }
  }
  /**
   * The default single-click/Enter/"Open" action -- respects `openExternally`,
   * unlike the explicit split/window/system-browser menu items, which are
   * always deliberate overrides. Re-focuses the sidebar afterward: opening a
   * bookmark reveals its new Web Viewer leaf, which otherwise takes keyboard
   * focus with it and leaves arrow-key navigation unable to reach the tree
   * for the rest of the session.
   */
  openDefault(node) {
    var _a, _b;
    const opened = node.openExternally ? openInSystemBrowser((_a = node.url) != null ? _a : "") : openBookmark(this.app, (_b = node.url) != null ? _b : "", this.store.settings.openIn);
    void opened.then(() => this.treeEl.focus());
  }
  showBookmarkMenu(node, evt) {
    const menu = new import_obsidian6.Menu();
    menu.addItem(
      (item) => item.setTitle("Open").setIcon("external-link").onClick(() => this.openDefault(node))
    );
    menu.addItem(
      (item) => item.setTitle("Open in new split").setIcon("separator-vertical").onClick(() => {
        var _a;
        void openBookmark(this.app, (_a = node.url) != null ? _a : "", "split");
      })
    );
    menu.addItem(
      (item) => item.setTitle("Open in new window").setIcon("picture-in-picture-2").onClick(() => {
        var _a;
        void openBookmark(this.app, (_a = node.url) != null ? _a : "", "window");
      })
    );
    menu.addItem(
      (item) => item.setTitle("Open in system browser").setIcon("globe").onClick(() => {
        var _a;
        void openInSystemBrowser((_a = node.url) != null ? _a : "");
      })
    );
    menu.addSeparator();
    menu.addItem(
      (item) => item.setTitle("Copy link").setIcon("copy").onClick(() => {
        var _a;
        void this.copyToClipboard((_a = node.url) != null ? _a : "");
      })
    );
    menu.addItem(
      (item) => item.setTitle("Copy as Markdown link").setIcon("copy").onClick(() => {
        var _a;
        void this.copyToClipboard(`[${node.title}](${(_a = node.url) != null ? _a : ""})`);
      })
    );
    menu.addSeparator();
    menu.addItem(
      (item) => item.setTitle("Always open externally").setIcon("globe").setChecked(Boolean(node.openExternally)).onClick(() => void this.store.toggleOpenExternally(node.id))
    );
    menu.addSeparator();
    if (node.parentId === PINNED_PARENT_ID) {
      menu.addItem(
        (item) => item.setTitle("Unpin").setIcon("pin-off").onClick(() => void this.store.unpin(node.id))
      );
    } else {
      menu.addItem(
        (item) => item.setTitle("Pin to top").setIcon("pin").onClick(() => void this.store.pin(node.id))
      );
    }
    menu.addSeparator();
    menu.addItem(
      (item) => item.setTitle("Edit").setIcon("pencil").onClick(() => {
        new BookmarkEditModal(
          this.app,
          "Edit bookmark",
          node,
          ({ title, url, iconType, iconValue, description }) => {
            void this.store.updateBookmark(node.id, title, url, { iconType, iconValue, description });
          },
          (url) => {
            var _a;
            return (_a = this.store.findByUrl(url, node.id)) == null ? void 0 : _a.title;
          }
        ).open();
      })
    );
    menu.addItem(
      (item) => item.setTitle("Delete").setIcon("trash").onClick(() => {
        void this.store.remove(node.id);
      })
    );
    menu.showAtMouseEvent(evt);
  }
  showFolderMenu(node, evt) {
    const menu = new import_obsidian6.Menu();
    menu.addItem(
      (item) => item.setTitle("New bookmark here").setIcon("file-plus").onClick(() => this.createBookmark(node.id))
    );
    menu.addItem(
      (item) => item.setTitle("New subfolder here").setIcon("folder-plus").onClick(() => this.createFolder(node.id))
    );
    menu.addSeparator();
    menu.addItem(
      (item) => item.setTitle("Rename").setIcon("pencil").onClick(() => {
        new FolderEditModal(this.app, "Rename folder", node.title, (name) => {
          void this.store.rename(node.id, name);
        }).open();
      })
    );
    menu.addItem(
      (item) => item.setTitle("Delete").setIcon("trash").onClick(() => {
        void this.store.remove(node.id);
      })
    );
    menu.showAtMouseEvent(evt);
  }
  // ── Create ───────────────────────────────────────────────
  createBookmark(parentId) {
    const active = this.plugin.getActiveWebViewerPage();
    new BookmarkEditModal(
      this.app,
      "New bookmark",
      active != null ? active : {},
      ({ title, url, iconType, iconValue, description }) => {
        void this.store.addBookmark(title, url, parentId, { iconType, iconValue, description });
      },
      (url) => {
        var _a;
        return (_a = this.store.findByUrl(url)) == null ? void 0 : _a.title;
      }
    ).open();
  }
  createFolder(parentId) {
    new FolderEditModal(this.app, "New folder", "", (name) => {
      void this.store.addFolder(name, parentId);
    }).open();
  }
  // ── Import / export ──────────────────────────────────────
  openImportMenu(evt) {
    const menu = new import_obsidian6.Menu();
    menu.addItem(
      (item) => item.setTitle("Import from browser (HTML file)").setIcon("file-up").onClick(() => this.pickImportFile("html"))
    );
    menu.addItem(
      (item) => item.setTitle("Import from Arc").setIcon("file-up").onClick(() => this.pickImportFile("arc"))
    );
    menu.addSeparator();
    menu.addItem(
      (item) => item.setTitle("Export bookmarks").setIcon("file-down").onClick(() => this.exportBookmarks())
    );
    menu.showAtMouseEvent(evt);
  }
  /**
   * Standard browser download flow (Blob + object URL + a hidden <a
   * download>) -- no Electron-specific save-dialog API needed, and it's the
   * same well-tested pattern used for the import file pickers. No Notice
   * here on purpose: the save dialog it triggers can pop up asynchronously,
   * after this function has already returned, so a "done" Notice fired
   * immediately would show up before the user has even picked a location,
   * which read as confusing rather than reassuring.
   */
  exportBookmarks() {
    const html = exportToNetscapeHtml(this.store.items);
    const blob = new Blob([html], { type: "text/html" });
    const url = URL.createObjectURL(blob);
    const dateLabel = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
    const link = createEl("a", { attr: { href: url, download: `browser-bookmark-export-${dateLabel}.html` } });
    link.hide();
    document.body.appendChild(link);
    link.click();
    document.body.removeChild(link);
    URL.revokeObjectURL(url);
  }
  /**
   * Stays synchronous end-to-end: `findArcSidebarFile` and its fallback to
   * `pickFileManually` (which opens the native file picker) both need to run
   * in the exact same tick as the click that invoked this, or the fallback
   * gets rejected as not coming from a real user gesture.
   */
  pickImportFile(kind) {
    if (kind === "arc") {
      const path = findArcSidebarFile();
      if (path) {
        void this.importArcFromPath(path);
        return;
      }
      new import_obsidian6.Notice("Couldn't find Arc's data file automatically -- pick it manually.");
    }
    this.pickFileManually(kind);
  }
  pickFileManually(kind) {
    const input = createEl("input", {
      attr: { type: "file", accept: kind === "html" ? ".html,.htm" : ".json" }
    });
    input.hide();
    document.body.appendChild(input);
    input.addEventListener("change", () => {
      var _a;
      const file = (_a = input.files) == null ? void 0 : _a[0];
      document.body.removeChild(input);
      if (file)
        void this.handleImportFile(kind, file);
    });
    input.click();
  }
  async importArcFromPath(path) {
    try {
      await this.processImportText("arc", readArcSidebarFile(path));
    } catch (err) {
      console.error("Browser Bookmark: Arc import failed", err);
      new import_obsidian6.Notice("Could not read Arc's data file -- see the developer console for details.");
    }
  }
  async handleImportFile(kind, file) {
    try {
      await this.processImportText(kind, await file.text());
    } catch (err) {
      console.error("Browser Bookmark: import failed", err);
      new import_obsidian6.Notice("Could not import that file -- see the developer console for details.");
    }
  }
  async processImportText(kind, text) {
    const batch = kind === "html" ? parseNetscapeHtml(text) : parseArcSidebarJson(text);
    if (batch.nodes.length === 0) {
      new import_obsidian6.Notice("No bookmarks found in that file.");
      return;
    }
    const dateLabel = (/* @__PURE__ */ new Date()).toLocaleDateString();
    const defaultTitle = kind === "html" ? `Imported bookmarks (${dateLabel})` : `Imported from Arc (${dateLabel})`;
    new ImportPreviewModal(this.app, batch, defaultTitle, (folderName) => {
      void this.commitImport(batch, folderName);
    }).open();
  }
  async commitImport(batch, folderName) {
    await this.store.importNodes(finalizeImport(batch, folderName));
    new import_obsidian6.Notice(
      `Imported ${batch.bookmarkCount} bookmark${batch.bookmarkCount === 1 ? "" : "s"} and ${batch.folderCount} folder${batch.folderCount === 1 ? "" : "s"}.`
    );
  }
  // ── Drag and drop ────────────────────────────────────────
  wireDrag(row, grip, node) {
    grip.addEventListener("dragstart", (evt) => {
      var _a;
      this.draggedId = node.id;
      row.addClass("browser-bookmark-dragging");
      (_a = evt.dataTransfer) == null ? void 0 : _a.setData("text/plain", node.id);
      evt.dataTransfer.effectAllowed = "move";
    });
    grip.addEventListener("dragend", () => {
      row.removeClass("browser-bookmark-dragging");
      this.clearDropMarker();
      this.draggedId = null;
    });
    row.addEventListener("dragover", (evt) => {
      if (this.draggedId) {
        if (this.draggedId === node.id)
          return;
        evt.preventDefault();
        this.markDropTarget(row, this.computeDropPosition(row, node, evt));
        return;
      }
      if (hasLinkData(evt.dataTransfer)) {
        evt.preventDefault();
        this.markDropTarget(row, node.type === "folder" ? "into" : "after");
      }
    });
    row.addEventListener("dragleave", () => this.clearDropMarker());
    row.addEventListener("drop", (evt) => {
      if (this.draggedId) {
        if (this.draggedId === node.id)
          return;
        evt.preventDefault();
        void this.handleDrop(this.draggedId, node, this.computeDropPosition(row, node, evt));
        this.clearDropMarker();
        return;
      }
      const link = extractLinkFromDataTransfer(evt.dataTransfer);
      if (link) {
        evt.preventDefault();
        const parentId = node.type === "folder" ? node.id : node.parentId;
        void this.store.addBookmark(link.title, link.url, parentId);
      }
      this.clearDropMarker();
    });
  }
  computeDropPosition(row, node, evt) {
    const rect = row.getBoundingClientRect();
    const fraction = (evt.clientY - rect.top) / rect.height;
    if (node.type === "folder" && fraction > 0.25 && fraction < 0.75)
      return "into";
    return fraction < 0.5 ? "before" : "after";
  }
  markDropTarget(row, position) {
    if (this.dropMarkedEl && this.dropMarkedEl !== row)
      this.clearDropMarker();
    row.removeClass("browser-bookmark-drop-before", "browser-bookmark-drop-after", "browser-bookmark-drop-into");
    row.addClass(`browser-bookmark-drop-${position}`);
    this.dropMarkedEl = row;
  }
  clearDropMarker() {
    var _a;
    (_a = this.dropMarkedEl) == null ? void 0 : _a.removeClass(
      "browser-bookmark-drop-before",
      "browser-bookmark-drop-after",
      "browser-bookmark-drop-into"
    );
    this.dropMarkedEl = null;
  }
  registerRootDropZone(treeEl) {
    treeEl.addEventListener("dragover", (evt) => {
      if (evt.target !== treeEl)
        return;
      if (this.draggedId || hasLinkData(evt.dataTransfer))
        evt.preventDefault();
    });
    treeEl.addEventListener("drop", (evt) => {
      if (evt.target !== treeEl)
        return;
      if (this.draggedId) {
        evt.preventDefault();
        const index = this.store.children(null).filter((n) => n.id !== this.draggedId).length;
        void this.store.moveInto(this.draggedId, null, index);
        return;
      }
      const link = extractLinkFromDataTransfer(evt.dataTransfer);
      if (link) {
        evt.preventDefault();
        void this.store.addBookmark(link.title, link.url, null);
      }
    });
  }
  /**
   * Pinned buttons sit in a horizontal, wrapping row, so reordering compares
   * cursor X against the button's left/right halves instead of the tree
   * rows' top/bottom split. No grip handle here -- the whole button is the
   * drag source, which is fine for a small icon-only target since a native
   * click and a native drag-start are already mutually exclusive gestures
   * (the tree rows need the separate grip specifically because their click
   * target is mostly title text, where that ambiguity actually bites).
   */
  wirePinnedDrag(btn, node) {
    btn.addEventListener("dragstart", (evt) => {
      var _a;
      this.draggedId = node.id;
      btn.addClass("browser-bookmark-dragging");
      (_a = evt.dataTransfer) == null ? void 0 : _a.setData("text/plain", node.id);
      evt.dataTransfer.effectAllowed = "move";
    });
    btn.addEventListener("dragend", () => {
      btn.removeClass("browser-bookmark-dragging");
      this.clearDropMarker();
      this.draggedId = null;
    });
    btn.addEventListener("dragover", (evt) => {
      var _a;
      if (!this.draggedId || this.draggedId === node.id)
        return;
      if (((_a = this.store.items.find((i) => i.id === this.draggedId)) == null ? void 0 : _a.type) !== "bookmark")
        return;
      evt.preventDefault();
      this.markDropTarget(btn, this.computeHorizontalDropPosition(btn, evt));
    });
    btn.addEventListener("dragleave", () => this.clearDropMarker());
    btn.addEventListener("drop", (evt) => {
      if (!this.draggedId || this.draggedId === node.id)
        return;
      evt.preventDefault();
      void this.handlePinnedDrop(this.draggedId, node, this.computeHorizontalDropPosition(btn, evt));
      this.clearDropMarker();
    });
  }
  computeHorizontalDropPosition(el, evt) {
    const rect = el.getBoundingClientRect();
    return evt.clientX - rect.left < rect.width / 2 ? "before" : "after";
  }
  async handlePinnedDrop(draggedId, target, position) {
    const draggedNode = this.store.items.find((i) => i.id === draggedId);
    if ((draggedNode == null ? void 0 : draggedNode.type) !== "bookmark")
      return;
    const siblings = this.store.pinned.filter((n) => n.id !== draggedId);
    let index = siblings.findIndex((n) => n.id === target.id);
    if (index === -1)
      index = siblings.length;
    if (position === "after")
      index += 1;
    await this.store.moveInto(draggedId, PINNED_PARENT_ID, index);
  }
  registerPinnedRowDropZone() {
    this.pinnedRowEl.addEventListener("dragover", (evt) => {
      var _a;
      if (evt.target !== this.pinnedRowEl || !this.draggedId)
        return;
      if (((_a = this.store.items.find((i) => i.id === this.draggedId)) == null ? void 0 : _a.type) !== "bookmark")
        return;
      evt.preventDefault();
    });
    this.pinnedRowEl.addEventListener("drop", (evt) => {
      if (evt.target !== this.pinnedRowEl || !this.draggedId)
        return;
      const node = this.store.items.find((i) => i.id === this.draggedId);
      if ((node == null ? void 0 : node.type) !== "bookmark")
        return;
      evt.preventDefault();
      void this.store.moveInto(this.draggedId, PINNED_PARENT_ID, this.store.pinned.length);
    });
  }
  async handleDrop(draggedId, target, position) {
    if (position === "into") {
      const index2 = this.store.children(target.id).filter((n) => n.id !== draggedId).length;
      await this.store.moveInto(draggedId, target.id, index2);
      return;
    }
    const siblings = this.store.children(target.parentId).filter((n) => n.id !== draggedId);
    let index = siblings.findIndex((n) => n.id === target.id);
    if (index === -1)
      index = siblings.length;
    if (position === "after")
      index += 1;
    await this.store.moveInto(draggedId, target.parentId, index);
  }
};

// src/settings.ts
var import_obsidian7 = require("obsidian");
var BrowserBookmarkSettingTab = class extends import_obsidian7.PluginSettingTab {
  constructor(app, plugin) {
    super(app, plugin);
    this.plugin = plugin;
  }
  /** Declarative settings (1.13.0+): gets these into Obsidian's settings search. */
  getSettingDefinitions() {
    return [
      {
        name: "Open bookmarks in",
        desc: "Where clicking a bookmark opens Obsidian's web viewer.",
        control: {
          type: "dropdown",
          key: "openIn",
          options: { tab: "New tab", split: "Split pane", window: "New window" }
        }
      },
      {
        name: "Intercept external links in notes",
        desc: "Open external links clicked in your notes with the web viewer instead of your system browser.",
        control: { type: "toggle", key: "interceptLinks" }
      },
      {
        name: "Show favicons",
        desc: "Fetch each bookmark's real site icon from Google's favicon service. Turn off to always show a plain globe icon instead (no requests sent for your bookmarked domains).",
        control: { type: "toggle", key: "showFavicons" }
      },
      {
        name: "Show ribbon icon",
        desc: "Show a bookmark icon in the left ribbon to open the sidebar.",
        control: { type: "toggle", key: "showRibbonIcon" }
      },
      {
        name: "Read later folder",
        desc: "Root-level folder that bookmarks saved from the companion browser extension land in, created automatically on first save. Leave blank to save to the root instead.",
        control: { type: "text", key: "readLaterFolderName", placeholder: "Read Later" }
      }
    ];
  }
  getControlValue(key) {
    return this.plugin.store.settings[key];
  }
  async setControlValue(key, value) {
    await this.plugin.store.updateSettings({ [key]: value });
    if (key === "showRibbonIcon")
      this.plugin.updateRibbonIcon();
  }
  /**
   * Fallback for Obsidian versions older than 1.13.0 (this plugin supports
   * back to 1.8.3, when the Web Viewer core plugin shipped). Not called at
   * all once getSettingDefinitions() above is available.
   */
  display() {
    const { containerEl } = this;
    containerEl.empty();
    new import_obsidian7.Setting(containerEl).setName("Open bookmarks in").setDesc("Where clicking a bookmark opens Obsidian's web viewer.").addDropdown(
      (dropdown) => dropdown.addOption("tab", "New tab").addOption("split", "Split pane").addOption("window", "New window").setValue(this.plugin.store.settings.openIn).onChange(async (value) => {
        await this.plugin.store.updateSettings({ openIn: value });
      })
    );
    new import_obsidian7.Setting(containerEl).setName("Intercept external links in notes").setDesc("Open external links clicked in your notes with the web viewer instead of your system browser.").addToggle(
      (toggle) => toggle.setValue(this.plugin.store.settings.interceptLinks).onChange(async (value) => {
        await this.plugin.store.updateSettings({ interceptLinks: value });
      })
    );
    new import_obsidian7.Setting(containerEl).setName("Show favicons").setDesc(
      "Fetch each bookmark's real site icon from Google's favicon service. Turn off to always show a plain globe icon instead (no requests sent for your bookmarked domains)."
    ).addToggle(
      (toggle) => toggle.setValue(this.plugin.store.settings.showFavicons).onChange(async (value) => {
        await this.plugin.store.updateSettings({ showFavicons: value });
      })
    );
    new import_obsidian7.Setting(containerEl).setName("Show ribbon icon").setDesc("Show a bookmark icon in the left ribbon to open the sidebar.").addToggle(
      (toggle) => toggle.setValue(this.plugin.store.settings.showRibbonIcon).onChange(async (value) => {
        await this.plugin.store.updateSettings({ showRibbonIcon: value });
        this.plugin.updateRibbonIcon();
      })
    );
    new import_obsidian7.Setting(containerEl).setName("Read later folder").setDesc(
      "Root-level folder that bookmarks saved from the companion browser extension land in, created automatically on first save. Leave blank to save to the root instead."
    ).addText(
      (text) => text.setPlaceholder("Read Later").setValue(this.plugin.store.settings.readLaterFolderName).onChange(async (value) => {
        await this.plugin.store.updateSettings({ readLaterFolderName: value });
      })
    );
  }
};

// src/main.ts
var BrowserBookmarkPlugin = class extends import_obsidian8.Plugin {
  constructor() {
    super(...arguments);
    this.ribbonIconEl = null;
  }
  async onload() {
    this.store = new BookmarkStore(this);
    await this.store.load();
    this.registerView(VIEW_TYPE_BROWSER_BOOKMARK, (leaf) => new BookmarkListView(leaf, this));
    this.updateRibbonIcon();
    this.addCommand({
      id: "open-sidebar",
      name: "Open sidebar",
      callback: () => this.activateView()
    });
    this.addCommand({
      id: "bookmark-current-page",
      name: "Bookmark current web viewer page",
      callback: () => this.bookmarkCurrentPage()
    });
    this.addSettingTab(new BrowserBookmarkSettingTab(this.app, this));
    this.registerObsidianProtocolHandler("browser-bookmark-save", (params) => {
      void this.saveFromBrowserExtension(params.url, params.title, params.description);
    });
    this.registerDomEvent(
      document,
      "click",
      (evt) => this.maybeInterceptLink(evt),
      { capture: true }
    );
  }
  getActiveWebViewerPage() {
    return getActiveWebViewerPage(this.app);
  }
  /** Adds or removes the ribbon icon to match the current setting, live -- called on load and whenever the setting toggles. */
  updateRibbonIcon() {
    const shouldShow = this.store.settings.showRibbonIcon;
    if (shouldShow && !this.ribbonIconEl) {
      this.ribbonIconEl = this.addRibbonIcon("bookmark", "Open browser bookmarks", () => this.activateView());
    } else if (!shouldShow && this.ribbonIconEl) {
      this.ribbonIconEl.remove();
      this.ribbonIconEl = null;
    }
  }
  /**
   * Fires when a user explicitly toggles the plugin on -- not on every app
   * startup, so this opens the sidebar exactly once as a "here's your new
   * panel" default without fighting the user's own choice to close it on
   * later restarts (Obsidian's normal workspace layout persistence handles
   * that afterwards, same as any other panel).
   */
  onUserEnable() {
    void this.activateView();
  }
  bookmarkCurrentPage() {
    var _a;
    const active = (_a = getActiveWebViewerPage(this.app)) != null ? _a : {};
    new BookmarkEditModal(
      this.app,
      "Bookmark current page",
      active,
      ({ title, url, iconType, iconValue, description }) => {
        void this.store.addBookmark(title, url, null, { iconType, iconValue, description });
      },
      (url) => {
        var _a2;
        return (_a2 = this.store.findByUrl(url)) == null ? void 0 : _a2.title;
      }
    ).open();
  }
  /**
   * Handles `obsidian://browser-bookmark-save` calls from the companion
   * browser extension. `title`/`description` arrive URL-decoded already --
   * Obsidian parses the protocol URI's query string before invoking the
   * handler.
   */
  async saveFromBrowserExtension(url, title, description) {
    if (!url)
      return;
    const existing = this.store.findByUrl(url);
    if (existing) {
      new import_obsidian8.Notice(`Already saved: ${existing.title}`);
      return;
    }
    const folderName = this.store.settings.readLaterFolderName.trim();
    const parentId = folderName ? (await this.store.getOrCreateRootFolder(folderName)).id : null;
    const node = await this.store.addBookmark((title == null ? void 0 : title.trim()) || url, url, parentId, {
      description: description || void 0
    });
    new import_obsidian8.Notice(`Saved to Browser Bookmark: ${node.title}`);
  }
  maybeInterceptLink(evt) {
    if (!this.store.settings.interceptLinks)
      return;
    const target = evt.target;
    const anchor = target == null ? void 0 : target.closest("a.external-link");
    if (!(anchor == null ? void 0 : anchor.href))
      return;
    evt.preventDefault();
    evt.stopPropagation();
    void openBookmark(this.app, anchor.href, this.store.settings.openIn);
  }
  async activateView() {
    var _a;
    const { workspace } = this.app;
    let leaf = (_a = workspace.getLeavesOfType(VIEW_TYPE_BROWSER_BOOKMARK)[0]) != null ? _a : null;
    if (!leaf) {
      leaf = workspace.getRightLeaf(false);
      await (leaf == null ? void 0 : leaf.setViewState({ type: VIEW_TYPE_BROWSER_BOOKMARK, active: true }));
    }
    if (leaf)
      await workspace.revealLeaf(leaf);
  }
  onunload() {
  }
};