zreader 0.0.0-stage → 0.2.0

package/dist/core/index.js

@@ -0,0 +1,935 @@
+import { BLOCK_TAGS, createBlockIdAllocator, createSlugger, normalizeBlockText } from '../chunk-ISI35TCM.js';
+export { BLOCK_TAGS, BLOCK_TAG_NAMES, createBlockIdAllocator, createSlugger, hashString, normalizeBlockText } from '../chunk-ISI35TCM.js';
+import { DEFAULT_CLIENT_OPTIONS, FONT_FAMILIES, MEASURES, LEADINGS, TEXT_SIZES } from '../chunk-DYQNGV46.js';
+export { DEFAULT_CLIENT_OPTIONS, FONT_FAMILIES, HIGHLIGHT_COLORS, LEADINGS, MEASURES, TEXT_SIZES, THEMES } from '../chunk-DYQNGV46.js';
+import search from 'approx-string-match';
+
+// src/core/storage.ts
+var StorageQuotaError = class extends Error {
+  constructor(key, cause) {
+    super(`Storage quota exceeded while writing "${key}"`);
+    this.key = key;
+    this.name = "StorageQuotaError";
+    this.cause = cause;
+  }
+  key;
+};
+function isQuotaError(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  return e.name === "QuotaExceededError" || e.name === "NS_ERROR_DOM_QUOTA_REACHED" || e.code === 22 || e.code === 1014;
+}
+function createMemoryAdapter(initial = {}) {
+  const map = new Map(Object.entries(initial));
+  return {
+    get: (k) => map.get(k) ?? null,
+    set: (k, v) => void map.set(k, v),
+    remove: (k) => void map.delete(k),
+    keys: (prefix = "") => [...map.keys()].filter((k) => k.startsWith(prefix)),
+    subscribe: () => () => {
+    },
+    dump: () => Object.fromEntries(map)
+  };
+}
+function getLocalStorage() {
+  try {
+    if (typeof window === "undefined" || !window.localStorage) return null;
+    const probe = "__zr_probe__";
+    window.localStorage.setItem(probe, "1");
+    window.localStorage.removeItem(probe);
+    return window.localStorage;
+  } catch {
+    return null;
+  }
+}
+function createLocalStorageAdapter(storage = getLocalStorage()) {
+  if (!storage) return createMemoryAdapter();
+  return {
+    get: (k) => {
+      try {
+        return storage.getItem(k);
+      } catch {
+        return null;
+      }
+    },
+    set: (k, v) => {
+      try {
+        storage.setItem(k, v);
+      } catch (err) {
+        if (isQuotaError(err)) throw new StorageQuotaError(k, err);
+        throw err;
+      }
+    },
+    remove: (k) => {
+      try {
+        storage.removeItem(k);
+      } catch {
+      }
+    },
+    keys: (prefix = "") => {
+      const out = [];
+      for (let i = 0; i < storage.length; i++) {
+        const k = storage.key(i);
+        if (k != null && k.startsWith(prefix)) out.push(k);
+      }
+      return out;
+    },
+    subscribe: (listener) => {
+      if (typeof window === "undefined") return () => {
+      };
+      const onStorage = (e) => {
+        if (e.storageArea && e.storageArea !== storage) return;
+        listener(e.key);
+      };
+      window.addEventListener("storage", onStorage);
+      return () => window.removeEventListener("storage", onStorage);
+    }
+  };
+}
+async function requestPersistentStorage() {
+  try {
+    if (typeof navigator === "undefined" || !navigator.storage?.persist) return false;
+    if (await navigator.storage.persisted()) return true;
+    return await navigator.storage.persist();
+  } catch {
+    return false;
+  }
+}
+
+// src/core/schema.ts
+var MIGRATIONS = {
+  settings: [],
+  highlights: [],
+  bookmarks: [],
+  progress: [],
+  pad: []
+};
+function currentVersion(type, migrations = MIGRATIONS) {
+  return migrations[type].length + 1;
+}
+function wrap(type, data, migrations = MIGRATIONS) {
+  return JSON.stringify({ v: currentVersion(type, migrations), data });
+}
+function unwrap(type, raw, migrations = MIGRATIONS) {
+  if (raw == null) return void 0;
+  let env;
+  try {
+    env = JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+  if (!isObj(env) || typeof env.v !== "number" || !("data" in env)) return void 0;
+  const target = currentVersion(type, migrations);
+  if (env.v > target) return void 0;
+  let data = env.data;
+  for (let v = env.v; v < target; v++) {
+    const m = migrations[type][v - 1];
+    if (!m) return void 0;
+    data = m(data);
+  }
+  return data;
+}
+function isObj(x) {
+  return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+var str = (x) => typeof x === "string";
+var num = (x) => typeof x === "number" && Number.isFinite(x);
+var optStr = (x) => x === void 0 || str(x);
+function isAnchor(x) {
+  return isObj(x) && str(x.blockId) && num(x.blockStart) && num(x.start) && num(x.end) && x.end >= x.start && str(x.exact) && str(x.prefix) && str(x.suffix) && optStr(x.contentHash);
+}
+function isHighlight(x) {
+  return isObj(x) && str(x.id) && str(x.bookId) && str(x.chapterId) && isAnchor(x.anchor) && str(x.color) && optStr(x.note) && str(x.createdAt) && str(x.updatedAt);
+}
+function isBookmark(x) {
+  return isObj(x) && str(x.id) && str(x.bookId) && str(x.chapterId) && optStr(x.blockId) && optStr(x.label) && optStr(x.excerpt) && str(x.createdAt) && str(x.updatedAt);
+}
+function isChapterProgress(x) {
+  return isObj(x) && str(x.chapterId) && optStr(x.blockId) && num(x.percent) && typeof x.completed === "boolean" && str(x.updatedAt);
+}
+function sanitizeProgress(x, bookId) {
+  const out = { bookId, chapters: {} };
+  if (!isObj(x)) return out;
+  if (isObj(x.chapters)) {
+    for (const [k, v] of Object.entries(x.chapters)) if (isChapterProgress(v)) out.chapters[k] = v;
+  }
+  if (isObj(x.last) && str(x.last.chapterId) && str(x.last.updatedAt) && optStr(x.last.blockId)) {
+    out.last = { chapterId: x.last.chapterId, blockId: x.last.blockId, updatedAt: x.last.updatedAt };
+  }
+  return out;
+}
+function sanitizeList(x, guard) {
+  return Array.isArray(x) ? x.filter(guard) : [];
+}
+function sanitizePad(x) {
+  if (!isObj(x) || !str(x.markdown) || !str(x.updatedAt)) return void 0;
+  return { markdown: x.markdown, json: x.json, updatedAt: x.updatedAt };
+}
+var oneOf = (list) => (v) => typeof v === "string" && list.includes(v);
+function sanitizeSettings(x, defaults) {
+  if (!isObj(x)) return defaults;
+  const pick = (k, ok) => ok(x[k]) ? x[k] : defaults[k];
+  return {
+    textSize: pick("textSize", oneOf(TEXT_SIZES)),
+    leading: pick("leading", oneOf(LEADINGS)),
+    measure: pick("measure", oneOf(MEASURES)),
+    fontFamily: pick("fontFamily", oneOf(FONT_FAMILIES)),
+    highlightMode: pick("highlightMode", (v) => typeof v === "boolean"),
+    updatedAt: pick("updatedAt", str)
+  };
+}
+
+// src/core/store.ts
+var enc = encodeURIComponent;
+function padKeySuffix(scope) {
+  switch (scope.kind) {
+    case "global":
+      return "pad:global";
+    case "book":
+      return `pad:book:${enc(scope.bookId)}`;
+    case "chapter":
+      return `pad:chapter:${enc(scope.bookId)}:${enc(scope.chapterId)}`;
+  }
+}
+function defaultId() {
+  const c = globalThis.crypto;
+  if (c?.randomUUID) return c.randomUUID();
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function createReaderStore(opts = {}) {
+  const adapter = opts.adapter ?? createLocalStorageAdapter();
+  const options = { ...DEFAULT_CLIENT_OPTIONS, ...opts.options };
+  const prefix = `${options.storagePrefix}:v1:`;
+  const writeDelay = opts.writeDelay ?? 200;
+  const onError = opts.onError ?? ((e) => console.warn("[zreader]", e));
+  const now = () => (opts.now ? opts.now() : /* @__PURE__ */ new Date()).toISOString();
+  const newId = opts.id ?? defaultId;
+  const defaultSettings = { ...options.defaultSettings, updatedAt: (/* @__PURE__ */ new Date(0)).toISOString() };
+  const cells = /* @__PURE__ */ new Map();
+  function cell(suffix, type, parse) {
+    const key = prefix + suffix;
+    const existing = cells.get(key);
+    if (existing) return existing;
+    let value = parse(unwrap(type, adapter.get(key)));
+    let timer;
+    let dirty = false;
+    const listeners = /* @__PURE__ */ new Set();
+    const emit = () => listeners.forEach((l) => l());
+    const flush = () => {
+      if (timer) clearTimeout(timer);
+      timer = void 0;
+      if (!dirty) return;
+      dirty = false;
+      try {
+        adapter.set(key, wrap(type, value));
+      } catch (err) {
+        onError(err instanceof StorageQuotaError ? err : new StorageQuotaError(key, err));
+      }
+    };
+    const c = {
+      key,
+      get: () => value,
+      set: (next) => {
+        const v = typeof next === "function" ? next(value) : next;
+        if (Object.is(v, value)) return;
+        value = v;
+        dirty = true;
+        emit();
+        if (writeDelay <= 0) flush();
+        else {
+          if (timer) clearTimeout(timer);
+          timer = setTimeout(flush, writeDelay);
+        }
+      },
+      subscribe: (l) => {
+        listeners.add(l);
+        return () => listeners.delete(l);
+      },
+      reload: () => {
+        if (dirty) return;
+        value = parse(unwrap(type, adapter.get(key)));
+        emit();
+      },
+      flush
+    };
+    cells.set(key, c);
+    return c;
+  }
+  const flushAll = () => cells.forEach((c) => c.flush());
+  let connections = 0;
+  let disconnect;
+  function connect() {
+    if (connections++ === 0) {
+      const unsubscribeAdapter = adapter.subscribe((key) => {
+        if (key == null) cells.forEach((c) => c.reload());
+        else cells.get(key)?.reload();
+      });
+      const onHide = () => flushAll();
+      const onVisibility = () => {
+        if (document.visibilityState === "hidden") flushAll();
+      };
+      if (typeof window !== "undefined") {
+        window.addEventListener("pagehide", onHide);
+        document.addEventListener("visibilitychange", onVisibility);
+      }
+      disconnect = () => {
+        flushAll();
+        unsubscribeAdapter();
+        if (typeof window !== "undefined") {
+          window.removeEventListener("pagehide", onHide);
+          document.removeEventListener("visibilitychange", onVisibility);
+        }
+      };
+    }
+    let done = false;
+    return () => {
+      if (done) return;
+      done = true;
+      if (--connections === 0) disconnect?.();
+    };
+  }
+  const settings = () => cell("settings", "settings", (x) => sanitizeSettings(x, defaultSettings));
+  const highlights = (bookId) => cell(`book:${enc(bookId)}:highlights`, "highlights", (x) => sanitizeList(x, isHighlight));
+  const bookmarks = (bookId) => cell(`book:${enc(bookId)}:bookmarks`, "bookmarks", (x) => sanitizeList(x, isBookmark));
+  const progress = (bookId) => cell(`book:${enc(bookId)}:progress`, "progress", (x) => sanitizeProgress(x, bookId));
+  const emptyPad = { markdown: "", updatedAt: (/* @__PURE__ */ new Date(0)).toISOString() };
+  const pad = (scope) => cell(padKeySuffix(scope), "pad", (x) => sanitizePad(x) ?? emptyPad);
+  const emptyList = [];
+  const emptyProgress = /* @__PURE__ */ new Map();
+  const server = {
+    settings: defaultSettings,
+    list: emptyList,
+    pad: emptyPad,
+    progress(bookId) {
+      let p = emptyProgress.get(bookId);
+      if (!p) emptyProgress.set(bookId, p = { bookId, chapters: {} });
+      return p;
+    }
+  };
+  const api = {
+    options,
+    adapter,
+    server,
+    prefix,
+    settings,
+    highlights,
+    bookmarks,
+    progress,
+    pad,
+    updateSettings(patch) {
+      settings().set((s) => ({ ...s, ...patch, updatedAt: now() }));
+    },
+    resetSettings() {
+      settings().set({ ...defaultSettings, updatedAt: now() });
+    },
+    addHighlight(input) {
+      const t = now();
+      const h = {
+        id: newId(),
+        bookId: input.bookId,
+        chapterId: input.chapterId,
+        anchor: input.anchor,
+        color: input.color ?? options.defaultHighlightColor,
+        ...input.note ? { note: input.note } : {},
+        createdAt: t,
+        updatedAt: t
+      };
+      highlights(input.bookId).set((list) => [...list, h]);
+      return h;
+    },
+    updateHighlight(bookId, id, patch) {
+      highlights(bookId).set(
+        (list) => list.map((h) => {
+          if (h.id !== id) return h;
+          const next = { ...h, ...patch, updatedAt: now() };
+          if (patch.note !== void 0 && !patch.note.trim()) delete next.note;
+          return next;
+        })
+      );
+    },
+    removeHighlight(bookId, id) {
+      highlights(bookId).set((list) => list.filter((h) => h.id !== id));
+    },
+    addBookmark(input) {
+      const t = now();
+      const b = { ...input, id: newId(), createdAt: t, updatedAt: t };
+      bookmarks(input.bookId).set((list) => [...list, b]);
+      return b;
+    },
+    removeBookmark(bookId, id) {
+      bookmarks(bookId).set((list) => list.filter((b) => b.id !== id));
+    },
+    findChapterBookmark(bookId, chapterId) {
+      return bookmarks(bookId).get().find((b) => b.chapterId === chapterId && !b.blockId);
+    },
+    /** Toggle a whole-chapter bookmark. Returns whether the chapter is now bookmarked. */
+    toggleChapterBookmark(bookId, chapterId, label) {
+      const existing = api.findChapterBookmark(bookId, chapterId);
+      if (existing) {
+        api.removeBookmark(bookId, existing.id);
+        return false;
+      }
+      api.addBookmark({ bookId, chapterId, ...label ? { label } : {} });
+      return true;
+    },
+    recordProgress(bookId, chapterId, p) {
+      const t = now();
+      const percent = Math.max(0, Math.min(1, p.percent));
+      progress(bookId).set((prev) => {
+        const old = prev.chapters[chapterId];
+        const completed = (old?.completed ?? false) || percent >= options.progress.completeAt;
+        if (old && old.blockId === p.blockId && Math.abs(old.percent - percent) < 5e-3 && old.completed === completed) {
+          return prev;
+        }
+        return {
+          ...prev,
+          chapters: {
+            ...prev.chapters,
+            [chapterId]: { chapterId, blockId: p.blockId, percent, completed, updatedAt: t }
+          },
+          last: { chapterId, blockId: p.blockId, updatedAt: t }
+        };
+      });
+    },
+    markChapterComplete(bookId, chapterId, completed = true) {
+      const t = now();
+      progress(bookId).set((prev) => {
+        const old = prev.chapters[chapterId];
+        return {
+          ...prev,
+          chapters: {
+            ...prev.chapters,
+            [chapterId]: {
+              chapterId,
+              blockId: old?.blockId,
+              percent: completed ? 1 : old?.percent ?? 0,
+              completed,
+              updatedAt: t
+            }
+          }
+        };
+      });
+    },
+    savePad(scope, markdown, json) {
+      pad(scope).set({ markdown, ...json !== void 0 ? { json } : {}, updatedAt: now() });
+    },
+    /** Append markdown to a pad from outside the editor (drops the JSON cache so the editor re-parses). */
+    appendToPad(scope, markdown) {
+      pad(scope).set((p) => ({
+        markdown: p.markdown.trim() ? `${p.markdown.replace(/\s+$/, "")}
+
+${markdown}
+` : `${markdown}
+`,
+        updatedAt: now()
+      }));
+    },
+    clearPad(scope) {
+      adapter.remove(prefix + padKeySuffix(scope));
+      cells.get(prefix + padKeySuffix(scope))?.reload();
+    },
+    /** All storage keys owned by this store's prefix. */
+    keys() {
+      return adapter.keys(prefix);
+    },
+    flush: flushAll,
+    connect,
+    /** Drop cached cells so the next read comes from storage (used after imports). */
+    reloadAll() {
+      cells.forEach((c) => {
+        c.flush();
+        c.reload();
+      });
+    }
+  };
+  return api;
+}
+function quoteToMarkdown(text, opts = {}) {
+  const quote = text.trim().split(/\r?\n/).map((l) => `> ${l}`).join("\n");
+  const link = opts.href ? `
+>
+> \u2014 [source](${opts.href})` : "";
+  const note = opts.note ? `
+
+${opts.note}` : "";
+  return `${quote}${link}${note}`;
+}
+function highlightToMarkdown(h, href) {
+  return quoteToMarkdown(h.anchor.exact, { href, note: h.note });
+}
+
+// src/core/backup.ts
+var BACKUP_FORMAT = "zreader-backup";
+var LEGACY_BACKUP_FORMATS = ["alr-backup"];
+var BACKUP_VERSION = 1;
+function recordTypeForKey(key) {
+  if (key === "settings") return "settings";
+  if (key.startsWith("pad:")) return "pad";
+  const m = /^book:[^:]+:(highlights|bookmarks|progress)$/.exec(key);
+  return m?.[1] ?? null;
+}
+function bookIdFromKey(key) {
+  return decodeURIComponent(key.split(":")[1] ?? "");
+}
+function exportBackup(store, opts = {}) {
+  store.flush();
+  const records = {};
+  for (const fullKey of store.keys()) {
+    const key = fullKey.slice(store.prefix.length);
+    if (!recordTypeForKey(key)) continue;
+    if (opts.bookId) {
+      const enc2 = encodeURIComponent(opts.bookId);
+      if (!key.startsWith(`book:${enc2}:`) && !key.startsWith(`pad:book:${enc2}`) && !key.startsWith(`pad:chapter:${enc2}:`))
+        continue;
+    }
+    try {
+      const env = JSON.parse(store.adapter.get(fullKey) ?? "null");
+      if (isObj(env) && typeof env.v === "number") records[key] = env;
+    } catch {
+    }
+  }
+  return { format: BACKUP_FORMAT, schemaVersion: BACKUP_VERSION, exportedAt: (/* @__PURE__ */ new Date()).toISOString(), records };
+}
+var BackupFormatError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BackupFormatError";
+  }
+};
+function parseBackup(input) {
+  let data = input;
+  if (typeof input === "string") {
+    try {
+      data = JSON.parse(input);
+    } catch {
+      throw new BackupFormatError("Backup is not valid JSON");
+    }
+  }
+  if (!isObj(data) || data.format !== BACKUP_FORMAT && !LEGACY_BACKUP_FORMATS.includes(String(data.format)))
+    throw new BackupFormatError("Not a zreader backup");
+  if (typeof data.schemaVersion !== "number" || data.schemaVersion > BACKUP_VERSION)
+    throw new BackupFormatError("Backup was created by a newer version of the reader");
+  if (!isObj(data.records)) throw new BackupFormatError("Backup has no records");
+  return data;
+}
+function newer(a, b) {
+  return a.updatedAt >= b.updatedAt ? a : b;
+}
+function mergeById(local, incoming) {
+  const map = new Map(local.map((x) => [x.id, x]));
+  for (const x of incoming) {
+    const cur = map.get(x.id);
+    map.set(x.id, cur ? newer(cur, x) : x);
+  }
+  return [...map.values()].sort((a, b) => a.id < b.id ? -1 : 1);
+}
+function mergeProgress(local, incoming) {
+  const chapters = { ...local.chapters };
+  for (const [k, v] of Object.entries(incoming.chapters)) {
+    const cur = chapters[k];
+    chapters[k] = cur ? newer(cur, v) : v;
+  }
+  const last = local.last && incoming.last ? newer(local.last, incoming.last) : local.last ?? incoming.last;
+  return { bookId: local.bookId, chapters, ...last ? { last } : {} };
+}
+function importBackup(store, input, opts = {}) {
+  const backup = parseBackup(input);
+  const mode = opts.mode ?? "merge";
+  store.flush();
+  if (mode === "replace") for (const k of store.keys()) store.adapter.remove(k);
+  let imported = 0;
+  let skipped = 0;
+  const defaults = sanitizeSettings(void 0, store.settings().get());
+  for (const [key, env] of Object.entries(backup.records)) {
+    const type = recordTypeForKey(key);
+    if (!type) {
+      skipped++;
+      continue;
+    }
+    const data = unwrap(type, JSON.stringify(env));
+    if (data === void 0) {
+      skipped++;
+      continue;
+    }
+    const fullKey = store.prefix + key;
+    const localRaw = mode === "merge" ? unwrap(type, store.adapter.get(fullKey)) : void 0;
+    let out;
+    switch (type) {
+      case "highlights":
+        out = mergeById(sanitizeList(localRaw, isHighlight), sanitizeList(data, isHighlight));
+        break;
+      case "bookmarks":
+        out = mergeById(sanitizeList(localRaw, isBookmark), sanitizeList(data, isBookmark));
+        break;
+      case "progress": {
+        const id = bookIdFromKey(key);
+        out = mergeProgress(sanitizeProgress(localRaw, id), sanitizeProgress(data, id));
+        break;
+      }
+      case "pad": {
+        const inc = sanitizePad(data);
+        const loc = sanitizePad(localRaw);
+        if (!inc) {
+          skipped++;
+          continue;
+        }
+        out = loc ? newer(loc, inc) : inc;
+        break;
+      }
+      case "settings": {
+        const inc = sanitizeSettings(data, defaults);
+        out = localRaw === void 0 ? inc : newer(sanitizeSettings(localRaw, defaults), inc);
+        break;
+      }
+    }
+    try {
+      store.adapter.set(fullKey, wrap(type, out));
+      imported++;
+    } catch {
+      skipped++;
+    }
+  }
+  store.reloadAll();
+  return { imported, skipped };
+}
+function highlightsToMarkdown(title, highlights, chapterTitle = (c) => c) {
+  const byChapter = /* @__PURE__ */ new Map();
+  for (const h of highlights) {
+    const list = byChapter.get(h.chapterId) ?? [];
+    list.push(h);
+    byChapter.set(h.chapterId, list);
+  }
+  const out = [`# ${title} \u2014 highlights`, ""];
+  for (const [chapterId, list] of byChapter) {
+    out.push(`## ${chapterTitle(chapterId)}`, "");
+    for (const h of [...list].sort((a, b) => a.anchor.start - b.anchor.start)) {
+      out.push(...h.anchor.exact.trim().split(/\r?\n/).map((l) => `> ${l}`));
+      if (h.note) out.push("", h.note);
+      out.push("");
+    }
+  }
+  return out.join("\n");
+}
+var CONTEXT_LENGTH = 32;
+function quoteFor(text, start, end) {
+  return {
+    exact: text.slice(start, end),
+    prefix: text.slice(Math.max(0, start - CONTEXT_LENGTH), start),
+    suffix: text.slice(end, end + CONTEXT_LENGTH)
+  };
+}
+function commonSuffixLen(a, b) {
+  let i = 0;
+  while (i < a.length && i < b.length && a[a.length - 1 - i] === b[b.length - 1 - i]) i++;
+  return i;
+}
+function commonPrefixLen(a, b) {
+  let i = 0;
+  while (i < a.length && i < b.length && a[i] === b[i]) i++;
+  return i;
+}
+function score(text, anchor, start, end, errors = 0) {
+  const prefix = text.slice(Math.max(0, start - CONTEXT_LENGTH), start);
+  const suffix = text.slice(end, end + CONTEXT_LENGTH);
+  const ctx = commonSuffixLen(prefix, anchor.prefix) + commonPrefixLen(suffix, anchor.suffix);
+  const distance = Math.abs(start - anchor.start) / Math.max(1, text.length);
+  return ctx * 2 - errors * 4 - distance * 10;
+}
+function resolveInText(text, anchor, blockOffset) {
+  const { exact } = anchor;
+  if (!exact) return null;
+  if (text.slice(anchor.start, anchor.end) === exact) return { start: anchor.start, end: anchor.end, strategy: "position" };
+  if (blockOffset !== void 0) {
+    const s = blockOffset + anchor.blockStart;
+    if (text.slice(s, s + exact.length) === exact) return { start: s, end: s + exact.length, strategy: "block" };
+  }
+  let best = null;
+  for (let i = text.indexOf(exact); i !== -1; i = text.indexOf(exact, i + 1)) {
+    const sc = score(text, anchor, i, i + exact.length);
+    if (!best || sc > best.score) best = { start: i, end: i + exact.length, score: sc };
+  }
+  if (best) return { start: best.start, end: best.end, strategy: "quote" };
+  if (exact.length < 8) return null;
+  const maxErrors = Math.min(64, Math.floor(exact.length * 0.15));
+  const matches = search(text, exact, maxErrors);
+  let fuzzy = null;
+  for (const m of matches) {
+    const sc = score(text, anchor, m.start, m.end, m.errors);
+    if (!fuzzy || sc > fuzzy.score) fuzzy = { start: m.start, end: m.end, score: sc };
+  }
+  return fuzzy ? { start: fuzzy.start, end: fuzzy.end, strategy: "fuzzy" } : null;
+}
+function segmentSentences(text, locale) {
+  const Seg = Intl.Segmenter;
+  if (Seg) {
+    return [...new Seg(locale, { granularity: "sentence" }).segment(text)].map((s) => ({
+      index: s.index,
+      segment: s.segment
+    }));
+  }
+  const out = [];
+  const re = /[^.!?…]*(?:[.!?…]+["'”’)\]]*|$)\s*/g;
+  let m;
+  while ((m = re.exec(text)) && m[0]) {
+    out.push({ index: m.index, segment: m[0] });
+  }
+  return out;
+}
+function trimSpan(text, start, end) {
+  while (start < end && /\s/.test(text[start] ?? "")) start++;
+  while (end > start && /\s/.test(text[end - 1] ?? "")) end--;
+  return { start, end };
+}
+function sentenceAt(blockText, offset, locale) {
+  const segs = segmentSentences(blockText, locale);
+  const clamped = Math.max(0, Math.min(offset, Math.max(0, blockText.length - 1)));
+  for (const s of segs) {
+    if (clamped >= s.index && clamped < s.index + s.segment.length) {
+      return trimSpan(blockText, s.index, s.index + s.segment.length);
+    }
+  }
+  return trimSpan(blockText, 0, blockText.length);
+}
+function expandToSentences(blockText, start, end, locale) {
+  const a = sentenceAt(blockText, start, locale);
+  const b = sentenceAt(blockText, Math.max(start, end - 1), locale);
+  return { start: Math.min(a.start, b.start), end: Math.max(a.end, b.end) };
+}
+var WORD = /[\p{L}\p{N}_'’-]/u;
+function snapToWords(text, start, end) {
+  while (start > 0 && WORD.test(text[start - 1] ?? "") && WORD.test(text[start] ?? "")) start--;
+  while (end < text.length && WORD.test(text[end] ?? "") && WORD.test(text[end - 1] ?? "")) end++;
+  return trimSpan(text, start, end);
+}
+
+// src/core/dom.ts
+var BLOCK_ATTR = "data-block-id";
+var IGNORE_ATTR = "data-zr-ignore";
+var BLOCK_SELECTOR = Array.from(BLOCK_TAGS).join(",");
+var HEADING_TAG = /^H([1-6])$/;
+function ensureBlockIds(root) {
+  if (root.querySelector(`[${BLOCK_ATTR}]`)) return { assigned: 0 };
+  const allocate = createBlockIdAllocator();
+  const slugger = createSlugger();
+  let assigned = 0;
+  for (const el of Array.from(root.querySelectorAll(BLOCK_SELECTOR))) {
+    const text = normalizeBlockText(el.textContent ?? "");
+    if (HEADING_TAG.test(el.tagName)) {
+      const existing = el.getAttribute("id");
+      if (existing) slugger.keep(existing);
+      else el.setAttribute("id", slugger.slug(text));
+    }
+    if (el.querySelector(BLOCK_SELECTOR)) continue;
+    if (!text) continue;
+    el.setAttribute(BLOCK_ATTR, allocate(el.tagName, text));
+    assigned++;
+  }
+  return { assigned };
+}
+function collectToc(root, depth = [2, 3]) {
+  const out = [];
+  for (const el of Array.from(root.querySelectorAll("h1,h2,h3,h4,h5,h6"))) {
+    const d = Number(HEADING_TAG.exec(el.tagName)?.[1] ?? 0);
+    const id = el.getAttribute("id");
+    const text = normalizeBlockText(el.textContent ?? "");
+    if (id && text && d >= depth[0] && d <= depth[1]) out.push({ id, depth: d, text });
+  }
+  return out;
+}
+function buildTextIndex(root) {
+  const entries = [];
+  let text = "";
+  const doc = root.ownerDocument;
+  const walker = doc.createTreeWalker(root, 4, {
+    acceptNode(node) {
+      const parent = node.parentElement;
+      if (!parent) return 2;
+      if (parent.closest(`[${IGNORE_ATTR}],script,style,noscript,template`)) return 2;
+      return 1;
+    }
+  });
+  for (let n = walker.nextNode(); n; n = walker.nextNode()) {
+    const t = n;
+    const len = t.data.length;
+    if (!len) continue;
+    entries.push({ node: t, start: text.length, end: text.length + len });
+    text += t.data;
+  }
+  return { root, text, entries };
+}
+function pointToOffset(index, container, offset) {
+  if (container.nodeType === 3) {
+    const e = index.entries.find((x) => x.node === container);
+    if (e) return e.start + Math.min(offset, e.end - e.start);
+  }
+  const doc = index.root.ownerDocument;
+  const probe = doc.createRange();
+  probe.setStart(container, offset);
+  probe.collapse(true);
+  let lo = 0;
+  let hi = index.entries.length;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    const node = index.entries[mid].node;
+    let cmp;
+    try {
+      cmp = probe.comparePoint(node, 0);
+    } catch {
+      cmp = 1;
+    }
+    if (cmp < 0 && !(container.nodeType === 3 && node === container)) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo < index.entries.length ? index.entries[lo].start : index.text.length;
+}
+function offsetToPoint(index, offset, preferNext = false) {
+  const { entries } = index;
+  if (!entries.length) return null;
+  let lo = 0;
+  let hi = entries.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    if (entries[mid].end < offset || preferNext && entries[mid].end === offset) lo = mid + 1;
+    else hi = mid;
+  }
+  const e = entries[lo];
+  return { node: e.node, offset: Math.max(0, Math.min(offset - e.start, e.end - e.start)) };
+}
+function rangeToSpan(index, range) {
+  if (!index.root.contains(range.commonAncestorContainer) && range.commonAncestorContainer !== index.root) {
+    const r = range.cloneRange();
+    try {
+      if (!index.root.contains(r.startContainer)) r.setStart(index.root, 0);
+      if (!index.root.contains(r.endContainer)) r.setEnd(index.root, index.root.childNodes.length);
+    } catch {
+      return null;
+    }
+    range = r;
+  }
+  const start = pointToOffset(index, range.startContainer, range.startOffset);
+  const end = pointToOffset(index, range.endContainer, range.endOffset);
+  return end > start ? { start, end } : null;
+}
+function spanToRange(index, span) {
+  const a = offsetToPoint(index, span.start, true);
+  const b = offsetToPoint(index, span.end);
+  if (!a || !b) return null;
+  const r = index.root.ownerDocument.createRange();
+  r.setStart(a.node, a.offset);
+  r.setEnd(b.node, b.offset);
+  return r;
+}
+function blockElementAt(index, offset) {
+  const p = offsetToPoint(index, offset, true);
+  return p?.node.parentElement?.closest(`[${BLOCK_ATTR}]`) ?? null;
+}
+function blockSpan(index, el) {
+  let start = -1;
+  let end = -1;
+  for (const e of index.entries) {
+    if (el.contains(e.node)) {
+      if (start < 0) start = e.start;
+      end = e.end;
+    } else if (start >= 0) break;
+  }
+  return start < 0 ? null : { start, end };
+}
+function findBlock(root, blockId) {
+  const esc = typeof CSS !== "undefined" && CSS.escape ? CSS.escape(blockId) : blockId.replace(/"/g, '\\"');
+  return root.querySelector(`[${BLOCK_ATTR}="${esc}"]`);
+}
+function describeSpan(index, span, contentHash) {
+  const block = blockElementAt(index, span.start);
+  if (!block) return null;
+  const bs = blockSpan(index, block);
+  const q = quoteFor(index.text, span.start, span.end);
+  return {
+    blockId: block.getAttribute(BLOCK_ATTR) ?? "",
+    blockStart: span.start - (bs?.start ?? 0),
+    start: span.start,
+    end: span.end,
+    ...q,
+    ...contentHash ? { contentHash } : {}
+  };
+}
+function resolveAnchor(index, anchor) {
+  const block = anchor.blockId ? findBlock(index.root, anchor.blockId) : null;
+  const bs = block ? blockSpan(index, block) : null;
+  return resolveInText(index.text, anchor, bs?.start);
+}
+function selectionSpan(index, selection) {
+  if (!selection || selection.rangeCount === 0 || selection.isCollapsed) return null;
+  const range = selection.getRangeAt(0);
+  if (!index.root.contains(range.commonAncestorContainer) && !range.intersectsNode(index.root)) return null;
+  const span = rangeToSpan(index, range);
+  if (!span) return null;
+  const snapped = snapToWords(index.text, span.start, span.end);
+  return snapped.end > snapped.start ? snapped : null;
+}
+function sentenceSpanAt(index, offset, locale) {
+  const block = blockElementAt(index, offset);
+  const bs = block ? blockSpan(index, block) : { start: 0, end: index.text.length };
+  if (!bs) return null;
+  const local = sentenceAt(index.text.slice(bs.start, bs.end), offset - bs.start, locale);
+  return local.end > local.start ? { start: bs.start + local.start, end: bs.start + local.end } : null;
+}
+function expandSpanToSentences(index, span, locale) {
+  const a = sentenceSpanAt(index, span.start, locale);
+  const b = sentenceSpanAt(index, Math.max(span.start, span.end - 1), locale);
+  return { start: Math.min(a?.start ?? span.start, b?.start ?? span.start), end: Math.max(a?.end ?? span.end, b?.end ?? span.end) };
+}
+function offsetFromPoint(index, x, y) {
+  const doc = index.root.ownerDocument;
+  let node = null;
+  let off = 0;
+  if (doc.caretPositionFromPoint) {
+    const p = doc.caretPositionFromPoint(x, y);
+    if (p) {
+      node = p.offsetNode;
+      off = p.offset;
+    }
+  } else if (doc.caretRangeFromPoint) {
+    const r = doc.caretRangeFromPoint(x, y);
+    if (r) {
+      node = r.startContainer;
+      off = r.startOffset;
+    }
+  }
+  if (!node || !index.root.contains(node)) return null;
+  return pointToOffset(index, node, off);
+}
+function supportsHighlightApi() {
+  return typeof CSS !== "undefined" && "highlights" in CSS && typeof globalThis.Highlight === "function";
+}
+function highlightName(color, namespace = "zr") {
+  return `${namespace}-${color}`;
+}
+function paintHighlights(resolved, opts = {}) {
+  if (!supportsHighlightApi()) return () => {
+  };
+  const ns = opts.namespace ?? "zr";
+  const byName = /* @__PURE__ */ new Map();
+  for (const r of resolved) {
+    const name = highlightName(r.highlight.id === opts.activeId ? "active" : r.highlight.color, ns);
+    const list = byName.get(name) ?? [];
+    list.push(r.range);
+    byName.set(name, list);
+  }
+  const registry = CSS.highlights;
+  const Ctor = globalThis.Highlight;
+  for (const [name, ranges] of byName) registry.set(name, new Ctor(...ranges));
+  return () => byName.forEach((_, name) => registry.delete(name));
+}
+function highlightAtOffset(resolved, offset) {
+  let best = null;
+  for (const r of resolved) {
+    if (offset >= r.span.start && offset < r.span.end) {
+      if (!best || r.span.end - r.span.start < best.span.end - best.span.start) best = r;
+    }
+  }
+  return best;
+}
+
+export { BACKUP_FORMAT, BACKUP_VERSION, BLOCK_ATTR, BackupFormatError, CONTEXT_LENGTH, IGNORE_ATTR, LEGACY_BACKUP_FORMATS, MIGRATIONS, StorageQuotaError, blockElementAt, blockSpan, buildTextIndex, collectToc, createLocalStorageAdapter, createMemoryAdapter, createReaderStore, currentVersion, defaultId, describeSpan, ensureBlockIds, expandSpanToSentences, expandToSentences, exportBackup, findBlock, getLocalStorage, highlightAtOffset, highlightName, highlightToMarkdown, highlightsToMarkdown, importBackup, isAnchor, isBookmark, isHighlight, offsetFromPoint, offsetToPoint, padKeySuffix, paintHighlights, parseBackup, pointToOffset, quoteFor, quoteToMarkdown, rangeToSpan, recordTypeForKey, requestPersistentStorage, resolveAnchor, resolveInText, selectionSpan, sentenceAt, sentenceSpanAt, snapToWords, spanToRange, supportsHighlightApi, unwrap, wrap };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map