@bendyline/docblocks 1.1.2 → 2.0.0

package/dist/chunk-IM7LCQJ6.js

@@ -1,850 +0,0 @@
-import {
-  maybeGetDocBlocksHost
-} from "./chunk-ME76RUMR.js";
-
-// src/filesystem/indexeddb-provider.ts
-import { LocalForageAdapter } from "@bendyline/squisq/storage";
-function normalisePath(p) {
-  return p.replace(/\\/g, "/").replace(/\/+/g, "/").replace(/^\//, "").replace(/\/$/, "");
-}
-function parentDir(p) {
-  const idx = p.lastIndexOf("/");
-  return idx === -1 ? "" : p.slice(0, idx);
-}
-function baseName(p) {
-  const idx = p.lastIndexOf("/");
-  return idx === -1 ? p : p.slice(idx + 1);
-}
-function contentKey(path) {
-  return `fs:${path}:content`;
-}
-function binaryKey(path) {
-  return `fs:${path}:binary`;
-}
-function metaKey(path) {
-  return `fs:${path}:meta`;
-}
-var DIRS_KEY = "fs:dirs";
-var IndexedDBFileSystemProvider = class {
-  constructor(id, label) {
-    this.id = id;
-    this.label = label;
-    this.store = new LocalForageAdapter({
-      name: `docblocks-fs-${id}`,
-      storeName: "files"
-    });
-  }
-  // ── Directory tracking ──────────────────────────────────────────
-  async getDirs() {
-    const raw = await this.store.get(DIRS_KEY);
-    return new Set(raw ?? []);
-  }
-  async saveDirs(dirs) {
-    await this.store.set(DIRS_KEY, [...dirs]);
-  }
-  /** Ensure a directory (and all ancestors) are tracked. */
-  async ensureDir(dirPath) {
-    if (!dirPath) return;
-    const dirs = await this.getDirs();
-    const parts = dirPath.split("/");
-    let current = "";
-    let changed = false;
-    for (const part of parts) {
-      current = current ? `${current}/${part}` : part;
-      if (!dirs.has(current)) {
-        dirs.add(current);
-        changed = true;
-      }
-    }
-    if (changed) {
-      await this.saveDirs(dirs);
-    }
-  }
-  // ── FileSystemProvider implementation ───────────────────────────
-  async readFile(path) {
-    const p = normalisePath(path);
-    return this.store.get(contentKey(p));
-  }
-  async writeFile(path, content) {
-    const p = normalisePath(path);
-    const parent = parentDir(p);
-    if (parent) {
-      await this.ensureDir(parent);
-    }
-    const meta = {
-      name: baseName(p),
-      path: p,
-      size: new Blob([content]).size,
-      lastModified: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    await this.store.set(contentKey(p), content);
-    await this.store.set(metaKey(p), meta);
-  }
-  async delete(path) {
-    const p = normalisePath(path);
-    await this.store.remove(contentKey(p));
-    await this.store.remove(binaryKey(p));
-    await this.store.remove(metaKey(p));
-    const dirs = await this.getDirs();
-    if (dirs.has(p)) {
-      const prefix = p + "/";
-      const toRemove = [p];
-      for (const d of dirs) {
-        if (d.startsWith(prefix)) {
-          toRemove.push(d);
-        }
-      }
-      for (const d of toRemove) {
-        dirs.delete(d);
-      }
-      await this.saveDirs(dirs);
-      const allKeys = await this.store.keys();
-      const filePrefix = `fs:${p}/`;
-      const keysToRemove = allKeys.filter((k) => k.startsWith(filePrefix));
-      await Promise.all(keysToRemove.map((k) => this.store.remove(k)));
-    }
-  }
-  async rename(oldPath, newPath) {
-    const op = normalisePath(oldPath);
-    const np = normalisePath(newPath);
-    if (op === np) return;
-    if (!op || !np) {
-      throw new Error("Cannot rename the filesystem root");
-    }
-    if (np.startsWith(op + "/")) {
-      throw new Error("Cannot move a directory into itself");
-    }
-    const dirs = await this.getDirs();
-    if (dirs.has(op)) {
-      const newParent2 = parentDir(np);
-      if (newParent2) {
-        await this.ensureDir(newParent2);
-      }
-      const allKeys = await this.store.keys();
-      const oldKeyPrefix = `fs:${op}/`;
-      const newKeyPrefix = `fs:${np}/`;
-      const metaSuffix = ":meta";
-      const keysToMove = allKeys.filter((k) => k.startsWith(oldKeyPrefix));
-      await Promise.all(
-        keysToMove.map(async (oldKey) => {
-          const newKey = newKeyPrefix + oldKey.slice(oldKeyPrefix.length);
-          if (oldKey.endsWith(metaSuffix)) {
-            const meta2 = await this.store.get(oldKey);
-            if (meta2) {
-              const newFilePath = newKey.slice(3, -metaSuffix.length);
-              await this.store.set(metaKey(newFilePath), {
-                ...meta2,
-                name: baseName(newFilePath),
-                path: newFilePath
-              });
-            }
-          } else {
-            const value = await this.store.get(oldKey);
-            if (value !== null) {
-              await this.store.set(newKey, value);
-            }
-          }
-          await this.store.remove(oldKey);
-        })
-      );
-      dirs.delete(op);
-      dirs.add(np);
-      const oldPrefix = op + "/";
-      const newPrefix = np + "/";
-      for (const d of [...dirs]) {
-        if (d.startsWith(oldPrefix)) {
-          dirs.delete(d);
-          dirs.add(newPrefix + d.slice(oldPrefix.length));
-        }
-      }
-      await this.saveDirs(dirs);
-      return;
-    }
-    const content = await this.store.get(contentKey(op));
-    const binary = await this.store.get(binaryKey(op));
-    const meta = await this.store.get(metaKey(op));
-    if (content !== null) {
-      await this.store.set(contentKey(np), content);
-    }
-    if (binary !== null) {
-      await this.store.set(binaryKey(np), binary);
-    }
-    if (meta) {
-      await this.store.set(metaKey(np), {
-        ...meta,
-        name: baseName(np),
-        path: np
-      });
-    }
-    const newParent = parentDir(np);
-    if (newParent) {
-      await this.ensureDir(newParent);
-    }
-    await this.store.remove(contentKey(op));
-    await this.store.remove(binaryKey(op));
-    await this.store.remove(metaKey(op));
-  }
-  async readDirectory(path) {
-    const p = normalisePath(path);
-    const dirs = await this.getDirs();
-    const entries = [];
-    const seen = /* @__PURE__ */ new Set();
-    const prefix = p ? p + "/" : "";
-    for (const d of dirs) {
-      if (!p && !d.includes("/")) {
-        if (!seen.has(d)) {
-          seen.add(d);
-          entries.push({ kind: "directory", name: d, path: d });
-        }
-      } else if (p && d.startsWith(prefix)) {
-        const rest = d.slice(prefix.length);
-        if (!rest.includes("/")) {
-          if (!seen.has(rest)) {
-            seen.add(rest);
-            entries.push({ kind: "directory", name: rest, path: d });
-          }
-        }
-      }
-    }
-    const allKeys = await this.store.keys();
-    const metaPrefix = p ? `fs:${p}/` : "fs:";
-    const metaSuffix = ":meta";
-    for (const key of allKeys) {
-      if (!key.startsWith(metaPrefix) || !key.endsWith(metaSuffix)) continue;
-      const filePath = key.slice(3, -metaSuffix.length);
-      const rel = p ? filePath.slice(prefix.length) : filePath;
-      if (rel.includes("/")) continue;
-      if (!seen.has(rel)) {
-        seen.add(rel);
-        entries.push({ kind: "file", name: rel, path: filePath });
-      }
-    }
-    entries.sort((a, b) => {
-      if (a.kind !== b.kind) return a.kind === "directory" ? -1 : 1;
-      return a.name.localeCompare(b.name);
-    });
-    return entries;
-  }
-  async exists(path) {
-    const p = normalisePath(path);
-    const dirs = await this.getDirs();
-    if (dirs.has(p)) return true;
-    const meta = await this.store.get(metaKey(p));
-    return meta !== null;
-  }
-  async createDirectory(path) {
-    const p = normalisePath(path);
-    await this.ensureDir(p);
-  }
-  async stat(path) {
-    const p = normalisePath(path);
-    return this.store.get(metaKey(p));
-  }
-  async readBinary(path) {
-    const p = normalisePath(path);
-    return this.store.get(binaryKey(p));
-  }
-  async writeBinary(path, data) {
-    const p = normalisePath(path);
-    const parent = parentDir(p);
-    if (parent) {
-      await this.ensureDir(parent);
-    }
-    const meta = {
-      name: baseName(p),
-      path: p,
-      size: data.byteLength,
-      lastModified: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    await this.store.set(binaryKey(p), data);
-    await this.store.set(metaKey(p), meta);
-  }
-};
-
-// src/filesystem/indexeddb-content-container.ts
-import { findDocumentPath } from "@bendyline/squisq/storage";
-var EXTENSION_MIME_MAP = {
-  ".md": "text/markdown",
-  ".txt": "text/plain",
-  ".json": "application/json",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".png": "image/png",
-  ".gif": "image/gif",
-  ".svg": "image/svg+xml",
-  ".webp": "image/webp",
-  ".avif": "image/avif",
-  ".mp4": "video/mp4",
-  ".webm": "video/webm",
-  ".mp3": "audio/mpeg",
-  ".wav": "audio/wav",
-  ".ogg": "audio/ogg"
-};
-function guessMimeType(path) {
-  const dot = path.lastIndexOf(".");
-  if (dot === -1) return "application/octet-stream";
-  const ext = path.slice(dot).toLowerCase();
-  return EXTENSION_MIME_MAP[ext] ?? "application/octet-stream";
-}
-var IndexedDBContentContainer = class {
-  constructor(workspaceId) {
-    this.provider = new IndexedDBFileSystemProvider(`${workspaceId}-media`, "Media Storage");
-  }
-  async readFile(path) {
-    return this.provider.readBinary(path);
-  }
-  async writeFile(path, data, _mimeType) {
-    await this.provider.writeBinary(path, data);
-  }
-  async removeFile(path) {
-    await this.provider.delete(path);
-  }
-  async listFiles(prefix) {
-    const entries = [];
-    const walk = async (dir) => {
-      const children = await this.provider.readDirectory(dir);
-      for (const child of children) {
-        if (child.kind === "directory") {
-          await walk(child.path);
-        } else {
-          const filePath = child.path.replace(/^\//, "");
-          if (prefix && !filePath.startsWith(prefix)) continue;
-          const meta = await this.provider.stat(child.path);
-          entries.push({
-            path: filePath,
-            mimeType: guessMimeType(filePath),
-            size: meta?.size ?? 0
-          });
-        }
-      }
-    };
-    await walk("/");
-    return entries;
-  }
-  async exists(path) {
-    return this.provider.exists(path);
-  }
-  async getDocumentPath() {
-    return findDocumentPath(await this.listFiles());
-  }
-  async readDocument() {
-    const docPath = await this.getDocumentPath();
-    if (!docPath) return null;
-    const data = await this.readFile(docPath);
-    if (!data) return null;
-    return new TextDecoder().decode(data);
-  }
-  async writeDocument(markdown, filename) {
-    const name = filename ?? "index.md";
-    const data = new TextEncoder().encode(markdown);
-    await this.writeFile(name, data, "text/markdown");
-  }
-};
-
-// src/filesystem/filesystem-content-container.ts
-import { findDocumentPath as findDocumentPath2 } from "@bendyline/squisq/storage";
-var EXTENSION_MIME_MAP2 = {
-  ".md": "text/markdown",
-  ".txt": "text/plain",
-  ".json": "application/json",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".png": "image/png",
-  ".gif": "image/gif",
-  ".svg": "image/svg+xml",
-  ".webp": "image/webp",
-  ".avif": "image/avif",
-  ".mp4": "video/mp4",
-  ".webm": "video/webm",
-  ".mp3": "audio/mpeg",
-  ".wav": "audio/wav",
-  ".ogg": "audio/ogg"
-};
-function guessMimeType2(path) {
-  const dot = path.lastIndexOf(".");
-  if (dot === -1) return "application/octet-stream";
-  const ext = path.slice(dot).toLowerCase();
-  return EXTENSION_MIME_MAP2[ext] ?? "application/octet-stream";
-}
-function joinPrefix(prefix, p) {
-  const clean = p.replace(/^\/+/, "");
-  return prefix.replace(/\/+$/, "") + "/" + clean;
-}
-var FileSystemContentContainer = class {
-  constructor(provider, prefix = ".docblocks/media") {
-    this.provider = provider;
-    this.prefix = prefix.replace(/^\/+/, "").replace(/\/+$/, "");
-  }
-  async readFile(path) {
-    const full = joinPrefix(this.prefix, path);
-    const binary = await this.provider.readBinary(full);
-    if (binary) return binary;
-    const text = await this.provider.readFile(full);
-    if (text === null) return null;
-    return new TextEncoder().encode(text).buffer;
-  }
-  async writeFile(path, data, _mimeType) {
-    await this.provider.writeBinary(joinPrefix(this.prefix, path), data);
-  }
-  async removeFile(path) {
-    await this.provider.delete(joinPrefix(this.prefix, path));
-  }
-  async listFiles(prefix) {
-    const entries = [];
-    const walk = async (dir) => {
-      let children;
-      try {
-        children = await this.provider.readDirectory(dir);
-      } catch {
-        return;
-      }
-      for (const child of children) {
-        if (child.kind === "directory") {
-          await walk(child.path);
-        } else {
-          const rel = child.path.replace(new RegExp("^/?" + this.prefix + "/?"), "");
-          if (prefix && !rel.startsWith(prefix)) continue;
-          const meta = await this.provider.stat(child.path);
-          entries.push({
-            path: rel,
-            mimeType: guessMimeType2(rel),
-            size: meta?.size ?? 0
-          });
-        }
-      }
-    };
-    await walk("/" + this.prefix);
-    return entries;
-  }
-  async exists(path) {
-    return this.provider.exists(joinPrefix(this.prefix, path));
-  }
-  async getDocumentPath() {
-    return findDocumentPath2(await this.listFiles());
-  }
-  async readDocument() {
-    const docPath = await this.getDocumentPath();
-    if (!docPath) return null;
-    const data = await this.readFile(docPath);
-    if (!data) return null;
-    return new TextDecoder().decode(data);
-  }
-  async writeDocument(markdown, filename) {
-    const name = filename ?? "index.md";
-    const data = new TextEncoder().encode(markdown);
-    await this.writeFile(name, data, "text/markdown");
-  }
-};
-
-// src/filesystem/file-media-provider.ts
-function stripExt(name) {
-  return name.replace(/\.[^.]+$/, "");
-}
-function createFileMediaProvider(container, markdownBasename) {
-  const folder = stripExt(markdownBasename) + "_files";
-  const prefix = folder + "/";
-  const blobUrlCache = /* @__PURE__ */ new Map();
-  function toKey(ref) {
-    const clean = ref.replace(/^\/+/, "");
-    return clean.startsWith(prefix) ? clean : prefix + clean;
-  }
-  return {
-    async resolveUrl(ref) {
-      const key = toKey(ref);
-      const cached = blobUrlCache.get(key);
-      if (cached) return cached;
-      const data = await container.readFile(key);
-      if (!data) return ref;
-      const entries = await container.listFiles();
-      const entry = entries.find((e) => e.path === key);
-      const mimeType = entry?.mimeType ?? "application/octet-stream";
-      const url = URL.createObjectURL(new Blob([data], { type: mimeType }));
-      blobUrlCache.set(key, url);
-      return url;
-    },
-    async listMedia() {
-      const entries = await container.listFiles(prefix);
-      return entries.filter((e) => !e.path.toLowerCase().endsWith(".md")).map((e) => ({
-        name: e.path,
-        mimeType: e.mimeType,
-        size: e.size
-      }));
-    },
-    async addMedia(name, data, mimeType) {
-      const key = toKey(name);
-      const cached = blobUrlCache.get(key);
-      if (cached) {
-        URL.revokeObjectURL(cached);
-        blobUrlCache.delete(key);
-      }
-      const buffer = data instanceof Blob ? new Uint8Array(await data.arrayBuffer()) : data;
-      await container.writeFile(key, buffer, mimeType);
-      return key;
-    },
-    async removeMedia(ref) {
-      const key = toKey(ref);
-      const cached = blobUrlCache.get(key);
-      if (cached) {
-        URL.revokeObjectURL(cached);
-        blobUrlCache.delete(key);
-      }
-      await container.removeFile(key);
-    },
-    dispose() {
-      for (const url of blobUrlCache.values()) {
-        URL.revokeObjectURL(url);
-      }
-      blobUrlCache.clear();
-    }
-  };
-}
-
-// src/filesystem/native-provider.ts
-function isNativeFileSystemSupported() {
-  return typeof globalThis !== "undefined" && "showDirectoryPicker" in globalThis;
-}
-var HANDLE_DB_NAME = "docblocks-handles";
-var HANDLE_STORE_NAME = "directory-handles";
-function openHandleDB() {
-  return new Promise((resolve, reject) => {
-    const req = indexedDB.open(HANDLE_DB_NAME, 1);
-    req.onupgradeneeded = () => {
-      req.result.createObjectStore(HANDLE_STORE_NAME);
-    };
-    req.onsuccess = () => resolve(req.result);
-    req.onerror = () => reject(req.error);
-  });
-}
-async function storeDirectoryHandle(workspaceId, handle) {
-  const db = await openHandleDB();
-  return new Promise((resolve, reject) => {
-    const tx = db.transaction(HANDLE_STORE_NAME, "readwrite");
-    tx.objectStore(HANDLE_STORE_NAME).put(handle, workspaceId);
-    tx.oncomplete = () => {
-      db.close();
-      resolve();
-    };
-    tx.onerror = () => {
-      db.close();
-      reject(tx.error);
-    };
-  });
-}
-async function loadDirectoryHandle(workspaceId) {
-  const db = await openHandleDB();
-  return new Promise((resolve, reject) => {
-    const tx = db.transaction(HANDLE_STORE_NAME, "readonly");
-    const req = tx.objectStore(HANDLE_STORE_NAME).get(workspaceId);
-    req.onsuccess = () => {
-      db.close();
-      resolve(req.result ?? null);
-    };
-    req.onerror = () => {
-      db.close();
-      reject(req.error);
-    };
-  });
-}
-async function removeDirectoryHandle(workspaceId) {
-  const db = await openHandleDB();
-  return new Promise((resolve, reject) => {
-    const tx = db.transaction(HANDLE_STORE_NAME, "readwrite");
-    tx.objectStore(HANDLE_STORE_NAME).delete(workspaceId);
-    tx.oncomplete = () => {
-      db.close();
-      resolve();
-    };
-    tx.onerror = () => {
-      db.close();
-      reject(tx.error);
-    };
-  });
-}
-function normalisePath2(p) {
-  return p.replace(/\\/g, "/").replace(/\/+/g, "/").replace(/^\//, "").replace(/\/$/, "");
-}
-async function resolveDir(root, dirPath) {
-  if (!dirPath) return root;
-  const parts = dirPath.split("/");
-  let current = root;
-  for (const part of parts) {
-    try {
-      current = await current.getDirectoryHandle(part);
-    } catch {
-      return null;
-    }
-  }
-  return current;
-}
-async function resolveDirCreate(root, dirPath) {
-  if (!dirPath) return root;
-  const parts = dirPath.split("/");
-  let current = root;
-  for (const part of parts) {
-    current = await current.getDirectoryHandle(part, { create: true });
-  }
-  return current;
-}
-function parentDir2(p) {
-  const idx = p.lastIndexOf("/");
-  return idx === -1 ? "" : p.slice(0, idx);
-}
-function baseName2(p) {
-  const idx = p.lastIndexOf("/");
-  return idx === -1 ? p : p.slice(idx + 1);
-}
-function toWritableBinary(data) {
-  if (data instanceof ArrayBuffer) return data;
-  const copy = new Uint8Array(data.byteLength);
-  copy.set(data);
-  return copy.buffer;
-}
-var NativeFileSystemProvider = class {
-  constructor(id, root) {
-    this.id = id;
-    this.label = root.name;
-    this.root = root;
-  }
-  async copyDirectory(oldDirPath, newDirPath) {
-    const source = await resolveDir(this.root, oldDirPath);
-    if (!source) return false;
-    await resolveDirCreate(this.root, newDirPath);
-    for await (const [name, handle] of source) {
-      const oldChild = oldDirPath ? `${oldDirPath}/${name}` : name;
-      const newChild = newDirPath ? `${newDirPath}/${name}` : name;
-      if (handle.kind === "directory") {
-        await this.copyDirectory(oldChild, newChild);
-      } else {
-        const fileHandle = await source.getFileHandle(name);
-        const file = await fileHandle.getFile();
-        await this.writeBinary(newChild, await file.arrayBuffer());
-      }
-    }
-    return true;
-  }
-  async readFile(path) {
-    const p = normalisePath2(path);
-    const dir = await resolveDir(this.root, parentDir2(p));
-    if (!dir) return null;
-    try {
-      const fileHandle = await dir.getFileHandle(baseName2(p));
-      const file = await fileHandle.getFile();
-      return file.text();
-    } catch {
-      return null;
-    }
-  }
-  async writeFile(path, content) {
-    const p = normalisePath2(path);
-    const dir = await resolveDirCreate(this.root, parentDir2(p));
-    const fileHandle = await dir.getFileHandle(baseName2(p), { create: true });
-    const writable = await fileHandle.createWritable();
-    await writable.write(content);
-    await writable.close();
-  }
-  async delete(path) {
-    const p = normalisePath2(path);
-    const parent = parentDir2(p);
-    const name = baseName2(p);
-    const dir = await resolveDir(this.root, parent);
-    if (!dir) return;
-    await dir.removeEntry(name, { recursive: true });
-  }
-  async rename(oldPath, newPath) {
-    const op = normalisePath2(oldPath);
-    const np = normalisePath2(newPath);
-    if (op === np) return;
-    if (!op || !np) {
-      throw new Error("Cannot rename the filesystem root");
-    }
-    if (np.startsWith(op + "/")) {
-      throw new Error("Cannot move a directory into itself");
-    }
-    const oldParent = await resolveDir(this.root, parentDir2(op));
-    if (!oldParent) return;
-    try {
-      const fileHandle = await oldParent.getFileHandle(baseName2(op));
-      const file = await fileHandle.getFile();
-      await this.writeBinary(np, await file.arrayBuffer());
-      await this.delete(op);
-      return;
-    } catch {
-    }
-    const copied = await this.copyDirectory(op, np);
-    if (copied) {
-      await this.delete(op);
-    }
-  }
-  async readDirectory(path) {
-    const p = normalisePath2(path);
-    const dir = await resolveDir(this.root, p);
-    if (!dir) return [];
-    const entries = [];
-    for await (const [name, handle] of dir) {
-      const entryPath = p ? `${p}/${name}` : name;
-      if (handle.kind === "directory") {
-        entries.push({ kind: "directory", name, path: entryPath });
-      } else {
-        entries.push({ kind: "file", name, path: entryPath });
-      }
-    }
-    entries.sort((a, b) => {
-      if (a.kind !== b.kind) return a.kind === "directory" ? -1 : 1;
-      return a.name.localeCompare(b.name);
-    });
-    return entries;
-  }
-  async exists(path) {
-    const p = normalisePath2(path);
-    const parent = parentDir2(p);
-    const name = baseName2(p);
-    const dir = await resolveDir(this.root, parent);
-    if (!dir) return false;
-    try {
-      await dir.getFileHandle(name);
-      return true;
-    } catch {
-      try {
-        await dir.getDirectoryHandle(name);
-        return true;
-      } catch {
-        return false;
-      }
-    }
-  }
-  async createDirectory(path) {
-    const p = normalisePath2(path);
-    await resolveDirCreate(this.root, p);
-  }
-  async stat(path) {
-    const p = normalisePath2(path);
-    const dir = await resolveDir(this.root, parentDir2(p));
-    if (!dir) return null;
-    try {
-      const fileHandle = await dir.getFileHandle(baseName2(p));
-      const file = await fileHandle.getFile();
-      return {
-        name: file.name,
-        path: p,
-        size: file.size,
-        lastModified: new Date(file.lastModified).toISOString()
-      };
-    } catch {
-      return null;
-    }
-  }
-  async readBinary(path) {
-    const p = normalisePath2(path);
-    const dir = await resolveDir(this.root, parentDir2(p));
-    if (!dir) return null;
-    try {
-      const fileHandle = await dir.getFileHandle(baseName2(p));
-      const file = await fileHandle.getFile();
-      return file.arrayBuffer();
-    } catch {
-      return null;
-    }
-  }
-  async writeBinary(path, data) {
-    const p = normalisePath2(path);
-    const dir = await resolveDirCreate(this.root, parentDir2(p));
-    const fileHandle = await dir.getFileHandle(baseName2(p), { create: true });
-    const writable = await fileHandle.createWritable();
-    await writable.write(toWritableBinary(data));
-    await writable.close();
-  }
-};
-async function openNativeFolder() {
-  if (!isNativeFileSystemSupported()) {
-    throw new Error("File System Access API is not supported in this browser");
-  }
-  const handle = await globalThis.showDirectoryPicker();
-  const id = `native-${handle.name}-${Date.now()}`;
-  await storeDirectoryHandle(id, handle);
-  return new NativeFileSystemProvider(id, handle);
-}
-async function restoreNativeFolder(workspaceId) {
-  const handle = await loadDirectoryHandle(workspaceId);
-  if (!handle) return null;
-  const opts = { mode: "readwrite" };
-  const h = handle;
-  if (await h.queryPermission(opts) === "granted") {
-    return new NativeFileSystemProvider(workspaceId, handle);
-  }
-  if (await h.requestPermission(opts) === "granted") {
-    return new NativeFileSystemProvider(workspaceId, handle);
-  }
-  return null;
-}
-
-// src/filesystem/electron-provider.ts
-function getHostFs() {
-  const host = maybeGetDocBlocksHost();
-  if (!host) {
-    throw new Error(
-      "ElectronFileSystemProvider: docBlocksHost is not available \u2014 not running under Electron?"
-    );
-  }
-  return host.fs;
-}
-var ElectronFileSystemProvider = class {
-  constructor(id, label, rootPath) {
-    this.id = id;
-    this.label = label;
-    this.rootPath = rootPath;
-  }
-  /** Absolute path this provider is rooted at. */
-  getRootPath() {
-    return this.rootPath;
-  }
-  readFile(path) {
-    return getHostFs().readFile(this.rootPath, path);
-  }
-  writeFile(path, content) {
-    return getHostFs().writeFile(this.rootPath, path, content);
-  }
-  delete(path) {
-    return getHostFs().delete(this.rootPath, path);
-  }
-  rename(oldPath, newPath) {
-    return getHostFs().rename(this.rootPath, oldPath, newPath);
-  }
-  readDirectory(path) {
-    return getHostFs().readDirectory(this.rootPath, path);
-  }
-  exists(path) {
-    return getHostFs().exists(this.rootPath, path);
-  }
-  createDirectory(path) {
-    return getHostFs().createDirectory(this.rootPath, path);
-  }
-  stat(path) {
-    return getHostFs().stat(this.rootPath, path);
-  }
-  readBinary(path) {
-    return getHostFs().readBinary(this.rootPath, path);
-  }
-  writeBinary(path, data) {
-    return getHostFs().writeBinary(this.rootPath, path, data);
-  }
-  /** Subscribe to external change notifications under this root. */
-  watch(onChange) {
-    return getHostFs().watch(this.rootPath, onChange);
-  }
-};
-
-export {
-  IndexedDBFileSystemProvider,
-  IndexedDBContentContainer,
-  FileSystemContentContainer,
-  createFileMediaProvider,
-  isNativeFileSystemSupported,
-  storeDirectoryHandle,
-  loadDirectoryHandle,
-  removeDirectoryHandle,
-  NativeFileSystemProvider,
-  openNativeFolder,
-  restoreNativeFolder,
-  ElectronFileSystemProvider
-};
-//# sourceMappingURL=chunk-IM7LCQJ6.js.map