@aiquants/markdown-explorer 0.0.0-stage → 0.2.0

package/dist/server.js

@@ -0,0 +1,1253 @@
+import { a as et, b as Et, f as Re, c as yt, d as bt, g as St, h as Tt, E as xt, j as Ot, i as te, k as kt, r as tt, l as Rt, m as _t, n as rt, o as Nt, p as At, q as de, s as ee, e as It } from "./dataRoute-Bkfwfp1R.js";
+import { D as Qn, M as qn, t as eo } from "./dataRoute-Bkfwfp1R.js";
+import { createHash as Mt, createHmac as Pt } from "node:crypto";
+import { data as Ie, redirect as vt } from "react-router";
+import { w as $t, d as jt, a as Lt, i as zt, r as Dt, p as Ct, b as Ht, f as Bt, N as Ft } from "./location-fVl2R1ee.js";
+import { existsSync as Ut, statSync as Gt, realpathSync as Xt, constants as ce } from "node:fs";
+import { extname as Jt, isAbsolute as Me, relative as Pe, sep as ve, join as Wt, resolve as Yt } from "node:path";
+import { fileURLToPath as be } from "node:url";
+import { Worker as Kt } from "node:worker_threads";
+import { open as nt, lstat as Vt, realpath as Zt, readdir as Qt } from "node:fs/promises";
+import { Readable as qt } from "node:stream";
+const $e = Object.freeze({ kind: "anonymous" }), Wn = Object.freeze({
+  authenticate: async () => ({ status: "signed-in", principal: $e }),
+  principalKey: () => $e.kind,
+  signedOutPage: (e, t) => new Response(null, { status: 401, headers: t })
+}), er = "application/octet-stream", ot = "application/pdf", tr = /* @__PURE__ */ new Set([
+  "image/png",
+  "image/apng",
+  "image/jpeg",
+  "image/gif",
+  "image/webp",
+  "image/avif",
+  "image/bmp",
+  "image/x-icon",
+  "image/vnd.microsoft.icon",
+  "audio/mpeg",
+  "audio/mp4",
+  "audio/aac",
+  "audio/ogg",
+  "audio/opus",
+  "audio/wav",
+  "audio/wave",
+  "audio/x-wav",
+  "audio/webm",
+  "audio/flac",
+  "audio/x-flac",
+  "audio/x-m4a",
+  "video/mp4",
+  "video/webm",
+  "video/ogg",
+  "video/quicktime",
+  ot
+]), st = "default-src 'none'; media-src 'self'; style-src 'unsafe-inline'", rr = `${st}; sandbox`, nr = `${st}; sandbox allow-same-origin`, je = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/u, or = /^[\t\n\r ]+|[\t\n\r ]+$/gu, _e = /^[\t ]+|[\t ]+$/gu, sr = (e) => {
+  const t = [];
+  let r = "", n = 0;
+  for (; ; ) {
+    for (; n < e.length && e[n] !== '"' && e[n] !== ","; )
+      r += e[n], n += 1;
+    if (n < e.length && e[n] === '"') {
+      const s = n;
+      for (n += 1; n < e.length && e[n] !== '"'; )
+        n += e[n] === "\\" ? 2 : 1;
+      if (n = Math.min(n + 1, e.length), r += e.slice(s, n), n < e.length) continue;
+    }
+    if (t.push(r.replace(_e, "")), r = "", n >= e.length) return t;
+    n += 1;
+  }
+}, ir = (e) => {
+  const t = e.replace(or, ""), r = t.indexOf("/");
+  if (r < 0) return null;
+  const n = t.slice(0, r), s = t.indexOf(";", r + 1), o = t.slice(r + 1, s < 0 ? t.length : s).replace(/[\t\n\r ]+$/u, "");
+  return je.test(n) && je.test(o) ? `${n}/${o}`.toLowerCase() : null;
+}, ar = (e) => {
+  let t = null;
+  for (const r of sr(e)) {
+    const n = ir(r);
+    n !== null && n !== "*/*" && (t = n);
+  }
+  return t;
+}, cr = /['()*]/gu, ur = (e) => encodeURIComponent(e).replace(cr, (t) => `%${t.charCodeAt(0).toString(16).toUpperCase()}`), lr = Object.freeze({
+  "Cache-Control": "private, max-age=60, stale-while-revalidate=600, no-transform",
+  Vary: "Cookie"
+}), dr = (e, t) => {
+  const r = ar(e), n = r !== null && tr.has(r), s = n && (r.startsWith("audio/") || r.startsWith("video/"));
+  return {
+    contentType: r === null ? er : r,
+    inline: n,
+    headers: {
+      "X-Content-Type-Options": "nosniff",
+      "Content-Disposition": `${n ? "inline" : "attachment"}; filename*=UTF-8''${ur(t)}`,
+      ...r === ot ? {} : { "Content-Security-Policy": s ? nr : rr },
+      "Cross-Origin-Resource-Policy": "same-origin"
+    }
+  };
+}, fr = /^bytes=(?:(\d+)-(\d*)|-(\d+))$/iu, fe = Object.freeze({ kind: "whole" }), Le = Object.freeze({ kind: "unsatisfiable" }), mr = (e, t, r) => {
+  const n = e.get("Range");
+  if (n === null) return fe;
+  const s = e.get("If-Range");
+  if (s !== null && s !== r) return fe;
+  const o = fr.exec(n);
+  if (o === null) return fe;
+  const [, c, m, g] = o;
+  if (g !== void 0) {
+    const w = Number(g);
+    if (w === 0) return Le;
+    const _ = Math.max(0, t - w);
+    return { kind: "partial", range: { offset: _, length: t - _ } };
+  }
+  const T = Number(c), l = m === "" ? Number.POSITIVE_INFINITY : Number(m);
+  return l < T ? fe : T >= t ? Le : { kind: "partial", range: { offset: T, length: Math.min(l, t - 1) - T + 1 } };
+}, ze = "W/", pr = (e) => {
+  const t = [];
+  let r = 0, n = !1;
+  for (let s = 0; s < e.length; s += 1)
+    e[s] === '"' ? n = !n : e[s] === "," && !n && (t.push(e.slice(r, s).replace(_e, "")), r = s + 1);
+  return t.push(e.slice(r).replace(_e, "")), t;
+}, De = (e) => e.startsWith(ze) ? e.slice(ze.length) : e, wr = (e, t) => {
+  if (e === null) return !1;
+  const r = pr(e);
+  if (r.length === 1 && r[0] === "*") return !0;
+  const n = De(t);
+  return r.some((s) => De(s) === n);
+}, hr = (e, t) => {
+  let r = t;
+  return e.pipeThrough(
+    new TransformStream({
+      transform: (n, s) => {
+        const o = n.byteLength > r ? n.subarray(0, r) : n;
+        r -= o.byteLength, s.enqueue(o), r === 0 && s.terminate();
+      },
+      flush: (n) => {
+        r > 0 && n.error(new RangeError("[markdown-explorer] the asset ended before its declared length"));
+      }
+    })
+  );
+}, Se = async (e, t, r, n, s) => {
+  if (n !== null && r.set("Content-Length", String(n)), e.method.toUpperCase() === "HEAD") return new Response(null, { status: t, headers: r });
+  const o = await s();
+  return new Response(n === null ? o : hr(o, n), { status: t, headers: r });
+}, gr = (e, t) => {
+  const r = new Headers(e);
+  for (const [n, s] of Object.entries({ "Accept-Ranges": "bytes", "Content-Range": `bytes */${t}`, "Cache-Control": "private, no-store", "X-Content-Type-Options": "nosniff" })) r.set(n, s);
+  return new Response(null, { status: 416, headers: r });
+}, Er = async (e, t, r) => {
+  const n = `"${t.version}"`, s = dr(t.contentType, t.name), o = new Headers(r);
+  for (const [g, T] of Object.entries({ ...s.headers, ...lr, ETag: n })) o.set(g, T);
+  if (wr(e.headers.get("If-None-Match"), n)) return new Response(null, { status: 304, headers: o });
+  if (o.set("Content-Type", s.contentType), t.size === null) return Se(e, 200, o, null, () => t.open(null));
+  if (t.size === 0)
+    return o.set("Content-Length", "0"), new Response(null, { status: 200, headers: o });
+  o.set("Accept-Ranges", "bytes");
+  const c = mr(e.headers, t.size, n);
+  if (c.kind === "unsatisfiable") return gr(r, t.size);
+  if (c.kind === "whole") return Se(e, 200, o, t.size, () => t.open(null));
+  const { range: m } = c;
+  return o.set("Content-Range", `bytes ${m.offset}-${m.offset + m.length - 1}/${t.size}`), Se(e, 206, o, m.length, () => t.open(m));
+}, Te = (e, t) => {
+  const r = new AbortController(), n = t(AbortSignal.any([e.signal, r.signal]));
+  return new Promise((s) => {
+    let o;
+    const c = setTimeout(() => {
+      s(e.late), o = setTimeout(() => r.abort(), e.handOverMs);
+    }, e.timeoutMs), m = () => {
+      clearTimeout(c), clearTimeout(o);
+    };
+    n.then(
+      (g) => {
+        m(), s(g);
+      },
+      () => {
+        m(), s(e.late);
+      }
+    );
+  });
+}, yr = Object.freeze({
+  error: (e, t) => {
+    console.error(e, t);
+  }
+}), it = /* @__PURE__ */ Symbol.for("@aiquants/markdown-explorer:ExplorerError");
+class Ee extends Error {
+  reason;
+  code;
+  constructor(t, r = {}) {
+    if (!et(t)) throw new RangeError(`[markdown-explorer] ExplorerError needs a failure reason; got ${JSON.stringify(t)}`);
+    if (r.code !== void 0 && !Et(r.code)) throw new RangeError(`[markdown-explorer] an ExplorerError code must be 1 to 64 lowercase letters, digits or hyphens; got ${JSON.stringify(r.code)}`);
+    super(`[markdown-explorer] ${t}`, r.cause === void 0 ? void 0 : { cause: r.cause }), this.name = "ExplorerError", this.reason = t, this.code = r.code, Object.defineProperty(this, it, { value: !0 });
+  }
+}
+const br = (e) => e instanceof Error && Object.hasOwn(e, it) && et(e.reason), Sr = (e) => typeof e == "object" && e !== null && e.name === "AbortError", Ne = (e, t, r) => {
+  try {
+    e.error(t, r);
+  } catch (n) {
+    console.error("[markdown-explorer] the logger threw while reporting a failure", { operation: r.operation, error: n });
+  }
+}, q = (e, t) => Ne(e, `[markdown-explorer] ${t.operation} failed`, t), Tr = (e, t) => Ne(e, `[markdown-explorer] ${t.operation} left out an entry`, t), xr = (e, t) => Ne(e, `[markdown-explorer] ${t.operation} refused a path the deny rules match`, { ...t, error: new RangeError("[markdown-explorer] the path matches a deny rule") }), Ce = (e, t) => {
+  e === null || typeof e != "object" && typeof e != "function" || Promise.resolve(e).then(void 0, t);
+}, Q = (e, t, r, n) => br(e) ? Re(e.reason, e.code) : (Sr(e) || r.aborted || q(n, { ...t, error: e }), { reason: "failed" }), He = (e, t) => {
+  if (!Number.isSafeInteger(t) || t <= 0) throw new RangeError(`[markdown-explorer] a cache ${e} must be a positive integer; got ${String(t)}`);
+}, at = (e, t) => {
+  He("capacity", e), t !== void 0 && He("weight budget", t.max);
+  const r = /* @__PURE__ */ new Map();
+  let n = 0;
+  const s = (o) => {
+    const c = r.get(o);
+    c !== void 0 && (r.delete(o), n -= c.weight);
+  };
+  return {
+    get: (o) => {
+      const c = r.get(o);
+      if (c !== void 0)
+        return r.delete(o), r.set(o, c), c.value;
+    },
+    set: (o, c) => {
+      s(o);
+      const m = t === void 0 ? 0 : t.of(o, c);
+      if (!(t !== void 0 && m > t.max)) {
+        r.set(o, { value: c, weight: m }), n += m;
+        for (const g of r.keys()) {
+          if (r.size <= e && (t === void 0 || n <= t.max)) break;
+          s(g);
+        }
+      }
+    },
+    delete: s,
+    size: () => r.size,
+    weight: () => n
+  };
+}, ct = (e) => Math.max(1, e - 1), Or = 2147483647, Be = Object.freeze({ status: "aborted" }), ne = (e, t, r) => {
+  const n = (e.get(t) ?? 0) + r;
+  n === 0 ? e.delete(t) : e.set(t, n);
+}, ie = (e, t, r) => {
+  if (!Number.isSafeInteger(t) || t <= 0 || t > r) throw new RangeError(`[markdown-explorer] a worker pool's ${e} must be an integer in 1..${String(r)}; got ${String(t)}`);
+}, kr = (e) => e !== null && typeof e == "object" && e.ready === !0 && !("id" in e), Rr = (e, t) => e !== null && typeof e == "object" && e.id === t && "output" in e, _r = ({ url: e, size: t, deadlineMs: r, jobsPerScope: n, maxQueuedJobs: s, heapLimits: o }) => {
+  ie("size", t, Number.MAX_SAFE_INTEGER), ie("deadline", r, Or), ie("jobsPerScope", n, Number.MAX_SAFE_INTEGER), ie("maxQueuedJobs", s, Number.MAX_SAFE_INTEGER), ie("maxOldGenerationSizeMb", o.maxOldGenerationSizeMb, Number.MAX_SAFE_INTEGER), ie("maxYoungGenerationSizeMb", o.maxYoungGenerationSizeMb, Number.MAX_SAFE_INTEGER);
+  const c = Object.freeze({ maxOldGenerationSizeMb: o.maxOldGenerationSizeMb, maxYoungGenerationSizeMb: o.maxYoungGenerationSizeMb }), m = /* @__PURE__ */ new Set(), g = [], T = /* @__PURE__ */ new Map(), l = /* @__PURE__ */ new Map(), w = ct(t);
+  let _ = 0;
+  const R = (u, a) => {
+    const { job: E } = u;
+    u.timer !== null && clearTimeout(u.timer), u.timer = null, u.job = null, u.sent = !1, E !== null && (ne(T, E.scope, -1), ne(l, E.scope, -1), E.settle(a));
+  }, I = (u) => {
+    const [a] = g.splice(u, 1);
+    a?.detach();
+  }, O = () => {
+    let u = -1, a = w, E = Number.POSITIVE_INFINITY;
+    for (const [b, k] of g.entries()) {
+      const A = T.get(k.scope) ?? 0, D = l.get(k.scope) ?? 0;
+      (A < a || A === a && u >= 0 && D < E) && (u = b, a = A, E = D);
+    }
+    return u;
+  }, x = (u, a) => {
+    m.has(u) && (m.delete(u), R(u, a), u.worker.terminate().catch(() => {
+    }), L());
+  }, v = (u) => {
+    u.timer = setTimeout(() => {
+      x(u, { status: "timeout" });
+    }, r);
+  }, y = (u, a) => u.sent ? { status: "crashed", error: a } : { status: "unavailable", error: a }, N = (u, a) => {
+    u.sent = !0, v(u);
+    try {
+      u.worker.postMessage({ id: a.id, input: a.input });
+    } catch (E) {
+      R(u, { status: "crashed", error: E }), u.worker.unref();
+    }
+  }, z = () => {
+    const u = { worker: new Kt(e, { resourceLimits: c }), job: null, sent: !1, timer: null, ready: !1 };
+    return u.worker.unref(), u.timer = setTimeout(() => {
+      x(u, { status: "unavailable", error: new Error(`[markdown-explorer] a worker did not start within ${String(r)} ms`) });
+    }, r), u.worker.on("message", (a) => {
+      if (!u.ready && kr(a)) {
+        u.ready = !0, u.timer !== null && clearTimeout(u.timer), u.timer = null, u.job === null ? u.worker.unref() : N(u, u.job), u.job === null && L();
+        return;
+      }
+      const { job: E } = u;
+      if (E === null || !Rr(a, E.id)) {
+        x(u, y(u, new Error("[markdown-explorer] a worker sent a message that answers no job")));
+        return;
+      }
+      R(u, { status: "done", output: a.output }), u.worker.unref(), L();
+    }), u.worker.on("error", (a) => {
+      x(u, y(u, a));
+    }), u.worker.on("messageerror", (a) => {
+      x(u, y(u, a));
+    }), u.worker.on("exit", (a) => {
+      x(u, y(u, new Error(`[markdown-explorer] a worker exited with code ${String(a)}`)));
+    }), m.add(u), u;
+  }, L = () => {
+    for (; ; ) {
+      const u = O(), a = g[u];
+      if (a === void 0) return;
+      let E;
+      for (const k of m)
+        if (k.job === null) {
+          E = k;
+          break;
+        }
+      if (E === void 0 && m.size < t)
+        try {
+          E = z();
+        } catch (k) {
+          I(u), ne(l, a.scope, -1), a.settle({ status: "unavailable", error: k });
+          continue;
+        }
+      if (E === void 0) return;
+      I(u), ne(T, a.scope, 1);
+      const b = E;
+      b.job = a, b.worker.ref(), b.ready && N(b, a);
+    }
+  };
+  return {
+    run: (u, { scope: a, signal: E }) => new Promise((b) => {
+      if (E.aborted) {
+        b(Be);
+        return;
+      }
+      if ((l.get(a) ?? 0) >= n) {
+        b({ status: "refused", limit: "scope" });
+        return;
+      }
+      _ += 1;
+      const k = { id: _, input: u, scope: a, settle: b, detach: () => {
+      } };
+      g.push(k), ne(l, a, 1), L();
+      const A = g.indexOf(k);
+      if (A < 0) return;
+      if (g.length > s) {
+        I(A), ne(l, a, -1), b({ status: "refused", limit: "queue" });
+        return;
+      }
+      const D = () => {
+        const M = g.indexOf(k);
+        M < 0 || (I(M), ne(l, a, -1), b(Be));
+      };
+      E.addEventListener("abort", D, { once: !0 }), k.detach = () => {
+        E.removeEventListener("abort", D);
+      };
+    }),
+    workers: () => m.size
+  };
+}, Ae = 1024 * 1024, Nr = 3e4, Ar = 4 * Ae, Ir = 64 * Ae, Mr = 3, Pr = 2, vr = (e, t) => e + ct(t) + Mr, $r = 4, jr = 32, Lr = 512, zr = 64, Dr = 4096, Cr = 32, Fe = 4096, Hr = 4, ut = ({ workerHeapMb: e, maxHtmlBytes: t }) => Math.floor(((e - zr) * Ae - t * Cr) / Dr), Br = ({ maxHtmlBytes: e }) => e, Fr = ({ maxHtmlBytes: e }) => Hr * e, Ur = 1024, Gr = 2147483647, Xr = 64, Jr = 2 ** 29, Wr = 1024 * 1024, Yr = 64, Ue = Object.freeze({ status: "rejected", reason: "too-large", cause: null }), xe = Object.freeze({ status: "rejected", reason: "failed", cause: null }), oe = (e, t, r, n) => {
+  if (t === void 0) return r;
+  if (typeof t != "number") throw new TypeError(`[markdown-explorer] sanitizer.${e} must be a number; got ${typeof t}`);
+  if (!Number.isSafeInteger(t) || t <= 0 || t > n) throw new RangeError(`[markdown-explorer] sanitizer.${e} must be an integer in 1..${String(n)}; got ${String(t)}`);
+  return t;
+}, Kr = (e, t) => {
+  if (e !== void 0 && (e === null || typeof e != "object")) throw new TypeError("[markdown-explorer] sanitizer must be an object of { workers, deadlineMs, maxHtmlBytes, cacheBytes, workerHeapMb, jobsPerScope, maxQueuedJobs }");
+  const { workers: r, deadlineMs: n, maxHtmlBytes: s, cacheBytes: o, workerHeapMb: c, jobsPerScope: m, maxQueuedJobs: g } = e ?? {}, T = oe("workers", r, Pr, Xr), l = oe("jobsPerScope", m, vr(t, T), Number.MAX_SAFE_INTEGER), w = Object.freeze({
+    workers: T,
+    deadlineMs: oe("deadlineMs", n, Nr, Gr),
+    maxHtmlBytes: oe("maxHtmlBytes", s, Ar, Jr),
+    cacheBytes: oe("cacheBytes", o, Ir, Number.MAX_SAFE_INTEGER),
+    workerHeapMb: oe("workerHeapMb", c, Lr, Wr),
+    jobsPerScope: l,
+    maxQueuedJobs: oe("maxQueuedJobs", g, $r * l, Number.MAX_SAFE_INTEGER)
+  });
+  if (w.jobsPerScope < t)
+    throw new RangeError(`[markdown-explorer] sanitizer.jobsPerScope must be at least multiView.maxPanels (${String(t)}), because a page sends the document of every panel to the sanitizer at once for one reader; got ${String(w.jobsPerScope)}`);
+  if (w.maxQueuedJobs < t)
+    throw new RangeError(`[markdown-explorer] sanitizer.maxQueuedJobs must be at least multiView.maxPanels (${String(t)}), because a reader whose page finds every worker busy waits with the document of every panel; got ${String(w.maxQueuedJobs)}`);
+  if (ut(w) < Fe)
+    throw new RangeError(
+      `[markdown-explorer] sanitizer.workerHeapMb (${String(w.workerHeapMb)} MiB) must leave room for ${String(Fe)} parsed nodes beside HTML of sanitizer.maxHtmlBytes (${String(w.maxHtmlBytes)} bytes); raise workerHeapMb or lower maxHtmlBytes`
+    );
+  return w;
+}, Vr = () => {
+  const e = import.meta.url, t = new URL(`./sanitizeWorker${Jt(be(e))}`, e);
+  if (!Ut(be(t))) throw new Error(`[markdown-explorer] the HTML sanitizer worker is missing: ${be(t)}`);
+  return t;
+}, Ge = /* @__PURE__ */ new Map(), Zr = (e, t) => {
+  const r = [e.href, t.workers, t.deadlineMs, t.workerHeapMb, t.jobsPerScope, t.maxQueuedJobs].map(String).join("\0");
+  let n = Ge.get(r);
+  return n === void 0 && (n = _r({
+    url: e,
+    size: t.workers,
+    deadlineMs: t.deadlineMs,
+    jobsPerScope: t.jobsPerScope,
+    maxQueuedJobs: t.maxQueuedJobs,
+    heapLimits: { maxOldGenerationSizeMb: t.workerHeapMb, maxYoungGenerationSizeMb: jr }
+  }), Ge.set(r, n)), n;
+}, Qr = (e) => {
+  if (e === null || typeof e != "object") return !1;
+  const { status: t, html: r, message: n } = e;
+  return t === "sanitized" && typeof r == "string" || t === "too-large" || t === "error" && typeof n == "string";
+}, qr = (e) => e instanceof Error && e.code === "ERR_WORKER_OUT_OF_MEMORY", en = ({ iframeHosts: e, dataPath: t, options: r, pool: n }) => {
+  const s = Object.freeze([...e]), o = ut(r), c = Br(r), m = Fr(r), g = at(Ur, {
+    max: r.cacheBytes,
+    of: (O, x) => 2 * O.length + (x.status === "sanitized" ? 2 * x.html.length : Yr)
+  }), T = /* @__PURE__ */ new Map(), l = /* @__PURE__ */ new Map(), w = (O) => {
+    T.get(O.key) === O && T.delete(O.key);
+    const x = l.get(O.hash);
+    x?.delete(O), x?.size === 0 && l.delete(O.hash);
+  }, _ = async (O, x, v) => {
+    const y = await n.run({ html: O, iframeHosts: s, dataPath: t, maxNodes: o, maxAttributeChars: c, maxSanitizedChars: m }, { scope: x, signal: v });
+    if (y.status === "refused") {
+      const z = y.limit === "scope" ? `its reader already has ${String(r.jobsPerScope)} documents being sanitized or waiting` : `${String(r.maxQueuedJobs)} documents are already waiting`;
+      return { outcome: { status: "rejected", reason: "failed", cause: new Error(`[markdown-explorer] the HTML sanitizer refused a document: ${z}`) }, lasting: !1 };
+    }
+    if (y.status === "aborted") return { outcome: xe, lasting: !1 };
+    if (y.status === "timeout") return { outcome: { status: "rejected", reason: "too-large", cause: new Error(`[markdown-explorer] the HTML sanitizer did not finish within ${String(r.deadlineMs)} ms`) }, lasting: !0 };
+    if (y.status === "unavailable") return { outcome: { status: "rejected", reason: "failed", cause: new Error("[markdown-explorer] the HTML sanitizer worker could not start", { cause: y.error }) }, lasting: !1 };
+    if (y.status === "crashed" && qr(y.error))
+      return { outcome: { status: "rejected", reason: "too-large", cause: new Error(`[markdown-explorer] the HTML sanitizer ran out of its ${String(r.workerHeapMb)} MiB worker heap`, { cause: y.error }) }, lasting: !0 };
+    if (y.status === "crashed") return { outcome: { status: "rejected", reason: "failed", cause: new Error("[markdown-explorer] the HTML sanitizer worker failed", { cause: y.error }) }, lasting: !0 };
+    const { output: N } = y;
+    return Qr(N) ? N.status === "too-large" ? { outcome: Ue, lasting: !0 } : N.status === "error" ? { outcome: { status: "rejected", reason: "failed", cause: new Error(`[markdown-explorer] the HTML sanitizer failed: ${N.message}`) }, lasting: !0 } : N.html.length > m ? { outcome: { status: "rejected", reason: "too-large", cause: new Error(`[markdown-explorer] the HTML sanitizer's output of ${String(N.html.length)} characters exceeds its limit of ${String(m)}`) }, lasting: !0 } : { outcome: { status: "sanitized", html: N.html }, lasting: !0 } : { outcome: { status: "rejected", reason: "failed", cause: new Error("[markdown-explorer] the HTML sanitizer worker answered something that is not an outcome") }, lasting: !0 };
+  }, R = (O, x, v, y) => {
+    let N = () => {
+    };
+    const z = new Promise((a) => {
+      N = a;
+    }), L = { hash: x, key: v, outcome: z, answer: N, controller: new AbortController(), waiters: 0 };
+    T.set(v, L);
+    const u = l.get(x);
+    return u === void 0 ? l.set(x, /* @__PURE__ */ new Set([L])) : u.add(L), _(O, y, L.controller.signal).catch((a) => ({ outcome: { status: "rejected", reason: "failed", cause: a instanceof Error ? a : new Error(String(a)) }, lasting: !0 })).then(({ outcome: a, lasting: E }) => {
+      if (w(L), L.answer(a), !E) return;
+      const b = g.get(x), k = b ?? (a.status === "rejected" ? { ...a, cause: null } : a);
+      b === void 0 && g.set(x, k);
+      for (const A of l.get(x) ?? [])
+        w(A), A.answer(k), A.controller.abort();
+    }), L;
+  }, I = (O, x) => new Promise((v) => {
+    O.waiters += 1;
+    const y = () => {
+      O.waiters -= 1, v(xe), !(O.waiters > 0) && (w(O), O.controller.abort());
+    };
+    x.addEventListener("abort", y, { once: !0 }), O.outcome.then((N) => {
+      x.removeEventListener("abort", y), v(N);
+    });
+  });
+  return (O, { scope: x, signal: v }) => {
+    if (O.length > r.maxHtmlBytes || Buffer.byteLength(O, "utf8") > r.maxHtmlBytes) return Promise.resolve(Ue);
+    const y = Mt("sha256").update(O, "utf8").digest("base64"), N = g.get(y);
+    if (N !== void 0) return Promise.resolve(N);
+    if (v.aborted) return Promise.resolve(xe);
+    const z = `${y}\0${x}`, L = T.get(z);
+    return I(L === void 0 ? R(O, y, z, x) : L, v);
+  };
+}, ye = (e) => ({ result: e, json: JSON.stringify(e) }), Oe = Object.freeze(ye(Object.freeze({ status: "error", failure: Object.freeze({ reason: "failed" }) }))), tn = (e) => e.status === "ok" && e.entries.length > 0, rn = ({ ttlMs: e, maxEntries: t, maxBytes: r, now: n }) => {
+  const s = at(t, { max: r, of: (l, w) => 2 * w.tree.json.length }), o = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Map(), m = (l, w) => {
+    const _ = new AbortController(), R = { waiters: 0, superseded: !1, started: !1, loadTree: w }, I = c.get(l), O = (z, L) => {
+      const u = ye(z);
+      return !(R.superseded || _.signal.aborted) && tn(z) && s.set(l, { tree: u, loadedAt: L }), u;
+    }, v = (async () => {
+      if (I !== void 0 && await I, _.signal.aborted) return Oe;
+      const z = n();
+      return R.started = !0, O(await R.loadTree(_.signal, z), z);
+    })().finally(() => {
+      o.get(l) === y && o.delete(l);
+    }), y = { promise: v, controller: _, state: R };
+    o.set(l, y);
+    const N = v.then(
+      () => {
+      },
+      () => {
+      }
+    );
+    return c.set(l, N), N.then(() => {
+      c.get(l) === N && c.delete(l);
+    }), y;
+  }, g = (l, w, _) => {
+    w.state.waiters += 1;
+    const R = () => {
+      w.state.waiters -= 1, !(w.state.waiters > 0) && (o.get(l) === w && o.delete(l), w.controller.abort());
+    };
+    return _.addEventListener("abort", R, { once: !0 }), w.promise.finally(() => {
+      _.removeEventListener("abort", R);
+    });
+  }, T = (l) => {
+    s.delete(l);
+    const w = o.get(l);
+    w?.state.started && (w.state.superseded = !0, o.delete(l));
+  };
+  return {
+    load: (l, w, _) => {
+      if (w.aborted) return Promise.resolve(Oe);
+      const R = s.get(l);
+      if (R !== void 0) {
+        if (n() - R.loadedAt < e) return Promise.resolve(R.tree);
+        s.delete(l);
+      }
+      const I = o.get(l);
+      return g(l, I === void 0 ? m(l, _) : I, w);
+    },
+    refresh: (l, w, _) => {
+      if (w.aborted) return Promise.resolve(Oe);
+      T(l);
+      const R = o.get(l);
+      return R === void 0 ? g(l, m(l, _), w) : (R.state.loadTree = _, g(l, R, w));
+    },
+    forget: T
+  };
+}, nn = (e) => ({
+  load: (t, r, n) => n(r, e()).then(ye),
+  refresh: (t, r, n) => n(r, e()).then(ye),
+  forget: () => {
+  }
+}), P = (e) => {
+  throw new TypeError(`[markdown-explorer] ${e}`);
+}, on = (e) => {
+  if (e === null || typeof e != "object") return null;
+  const { name: t, path: r } = e;
+  return typeof t != "string" || typeof r != "string" ? null : t === "" ? { path: r, reason: "an empty name" } : te(r) ? null : { path: r, reason: "a path the browser cannot address (empty, too long, a lone surrogate, a control character or a backslash)" };
+}, sn = (e, t, r, n, s) => {
+  const o = /* @__PURE__ */ new Set(), c = (g) => {
+    if (!Array.isArray(g)) return P("a source returned entries that are not an array");
+    const T = [];
+    for (const l of g) {
+      const w = m(l);
+      w !== null && T.push(w);
+    }
+    return T;
+  }, m = (g) => {
+    const T = on(g);
+    if (T !== null)
+      return n(T), null;
+    const l = Ot(g);
+    if (l !== null) return P(l);
+    const w = g;
+    if (o.has(w)) return P("a source returned entries that contain themselves");
+    const { name: _, path: R, type: I, mimeType: O, children: x, lazy: v } = w;
+    if (t.deniesName(_) || t.deniesPath(R)) return null;
+    if (!s(R))
+      return n({ path: R, reason: "a path outside the source's boundary" }), null;
+    const y = O === void 0 ? { name: _, path: R } : { name: _, path: R, mimeType: O };
+    if (I === "file") return { ...y, type: I };
+    if (v === !0)
+      return r ? { ...y, type: I, lazy: !0, children: [] } : P("a lazy directory came from a source without a children function");
+    if (x === void 0) return { ...y, type: I };
+    o.add(w);
+    const N = c(x);
+    return o.delete(w), { ...y, type: I, children: N };
+  };
+  return c(e);
+}, an = /^[\x21\x23-\x7E]{1,256}$/u, lt = (e) => typeof e == "string" && an.test(e), cn = /* @__PURE__ */ new Set(["text", "image", "media", "file"]), un = (e) => typeof e == "string" && cn.has(e), ln = (e, t) => {
+  if (e !== null && typeof e == "object") {
+    const s = e, { kind: o } = s;
+    if (un(o)) {
+      if (Object.hasOwn(s, "url")) return P(`a ${o} document carries its version, not a url`);
+      if (typeof s.name != "string") return P("a document needs a name string");
+      if (!lt(s.version)) return P(`a ${o} document needs a version of 1 to 256 visible ASCII characters other than '"'`);
+      const c = t(s.version);
+      switch (o) {
+        case "image":
+        case "file":
+          return { kind: o, name: s.name, url: c };
+        case "media": {
+          const { mediaType: m } = s;
+          return St(m) ? { kind: o, name: s.name, url: c, mediaType: m } : P(`unknown media type ${typeof m == "string" ? JSON.stringify(m.slice(0, 64)) : typeof m}`);
+        }
+        case "text":
+          return typeof s.text != "string" || typeof s.truncated != "boolean" ? P("a text document needs text and truncated") : { kind: o, name: s.name, text: s.text, truncated: s.truncated, url: c };
+      }
+    }
+  }
+  const r = Tt(e);
+  if (r !== null) return P(r);
+  const n = e;
+  switch (n.kind) {
+    case "failure": {
+      const { reason: s, code: o } = n.failure;
+      return { kind: "failure", failure: Re(s, o) };
+    }
+    case "markdown":
+      return n.headings.length > xt ? { kind: "failure", failure: Re("too-large") } : { kind: "unsanitized-markdown", name: n.name, html: n.htmlContent, headings: n.headings.map(({ text: s, depth: o, id: c }) => ({ text: s, depth: o, id: c })) };
+  }
+}, dn = (e) => {
+  if (e === null || typeof e != "object") return P("an asset file must be an object");
+  const { name: t, contentType: r, size: n, version: s, open: o } = e;
+  return typeof t != "string" || t === "" ? P("an asset file needs a non-empty name") : typeof r != "string" ? P("an asset file needs a contentType string ('' when unknown)") : n !== null && !(typeof n == "number" && Number.isSafeInteger(n) && n >= 0) ? P("an asset file's size must be null or a non-negative safe integer") : lt(s) ? typeof o != "function" ? P("an asset file needs an open function") : Object.freeze({ name: t, contentType: r, size: n, version: s, open: o }) : P(`an asset file needs a version of 1 to 256 visible ASCII characters other than '"'`);
+}, fn = (e) => Array.isArray(e) ? e.map((t) => {
+  if (t === null || typeof t != "object") return P("a notice must be an object");
+  const { id: r, tone: n, title: s, body: o, action: c } = t;
+  if (typeof r != "string" || r === "" || typeof s != "string") return P("a notice needs an id and a title");
+  if (!yt(n)) return P(`unknown notice tone ${typeof n == "string" ? JSON.stringify(n.slice(0, 64)) : typeof n}`);
+  if (o !== void 0 && typeof o != "string") return P("a notice body must be a string");
+  const g = { id: r, tone: n, title: s, ...o === void 0 ? {} : { body: o } };
+  if (c === void 0) return g;
+  if (c === null || typeof c != "object") return P("a notice action must be an object");
+  const { label: T, href: l } = c;
+  return typeof T != "string" || !bt(l, kt) ? P("a notice action needs a label and an http(s), mailto or relative href") : { ...g, action: { label: T, href: l } };
+}) : P("notices must be an array"), mn = 4e3, me = Object.freeze({ ttlMs: 3e5, maxEntries: 64, maxBytes: 64 * 1024 * 1024 }), Xe = 32, dt = "private, no-store", pn = Object.freeze({
+  "Content-Type": "application/json; charset=utf-8",
+  "Cache-Control": dt,
+  "X-Content-Type-Options": "nosniff",
+  "Content-Security-Policy": "default-src 'none'; frame-ancestors 'none'; sandbox",
+  "Cross-Origin-Resource-Policy": "same-origin"
+}), wn = 22, hn = 2147483647, ke = Object.freeze([]), Je = Object.freeze(["contains", "confirm"]), X = (e, t, r) => {
+  if (!(r && t === void 0) && typeof t != "function")
+    throw new TypeError(`[markdown-explorer] ${e} must be a function; got ${typeof t}`);
+}, ge = (e, t, r) => {
+  if (typeof t != "number") throw new TypeError(`[markdown-explorer] ${e} must be a number; got ${typeof t}`);
+  if (!Number.isSafeInteger(t) || t <= 0 || t > r) throw new RangeError(`[markdown-explorer] ${e} must be an integer in 1..${String(r)}; got ${String(t)}`);
+  return t;
+}, gn = (e) => {
+  if (e === null || typeof e != "object" || !Object.isFrozen(e)) throw new TypeError("[markdown-explorer] config must be the value returned by defineExplorerConfig");
+  return Lt(e);
+}, En = (e) => {
+  if (typeof e != "string") throw new TypeError(`[markdown-explorer] scopeSecret must be a string; got ${typeof e}`);
+  if (e.length < Xe) throw new RangeError(`[markdown-explorer] scopeSecret must have at least ${String(Xe)} characters; got ${String(e.length)}`);
+  return e;
+}, yn = (e, t) => {
+  if (!Bt(t)) throw new TypeError(`[markdown-explorer] ${e}.boundary must be a plain object { contains, confirm? }`);
+  for (const r of Object.keys(t))
+    if (!Je.includes(r)) throw new RangeError(`[markdown-explorer] ${e}.boundary.${r} is not an option; expected ${Je.join(", ")}`);
+  X(`${e}.boundary.contains`, t.contains, !1), X(`${e}.boundary.confirm`, t.confirm, !0);
+}, bn = (e) => {
+  if (!Array.isArray(e)) throw new TypeError("[markdown-explorer] sources must be an array");
+  const t = e;
+  if (t.length === 0) throw new RangeError("[markdown-explorer] sources must hold at least one source");
+  const r = /* @__PURE__ */ new Set();
+  for (const [n, s] of t.entries()) {
+    if (s === null || typeof s != "object") throw new TypeError(`[markdown-explorer] sources[${String(n)}] must be an object`);
+    const { id: o, label: c, boundary: m, tree: g, children: T, cacheScope: l } = s;
+    if (!zt(o))
+      throw new RangeError(`[markdown-explorer] sources[${String(n)}].id must use lowercase letters, digits and "-" and start with a letter or digit; got ${typeof o == "string" ? JSON.stringify(o) : typeof o}`);
+    const w = `source ${JSON.stringify(o)}`;
+    if (r.has(o)) throw new RangeError(`[markdown-explorer] source ids must be unique; ${JSON.stringify(o)} repeats at sources[${String(n)}]`);
+    if (r.add(o), typeof c != "string" && typeof c != "function") throw new TypeError(`[markdown-explorer] ${w}.label must be a string or a function`);
+    if (typeof c == "string" && c.trim() === "") throw new RangeError(`[markdown-explorer] ${w}.label must not be blank`);
+    if (yn(w, m), X(`${w}.tree`, g, !1), X(`${w}.children`, T, !0), l !== void 0 && l !== "principal" && l !== "shared") throw new RangeError(`[markdown-explorer] ${w}.cacheScope must be "principal" or "shared"; got ${JSON.stringify(l)}`);
+  }
+  return t;
+}, Sn = (e) => {
+  if (e === !1) return !1;
+  if (e === void 0) return me;
+  if (e === null || typeof e != "object") throw new TypeError("[markdown-explorer] treeCache must be { ttlMs, maxEntries, maxBytes } or false");
+  const { ttlMs: t, maxEntries: r, maxBytes: n } = e;
+  return {
+    ttlMs: t === void 0 ? me.ttlMs : ge("treeCache.ttlMs", t, Number.MAX_SAFE_INTEGER),
+    maxEntries: r === void 0 ? me.maxEntries : ge("treeCache.maxEntries", r, Number.MAX_SAFE_INTEGER),
+    maxBytes: n === void 0 ? me.maxBytes : ge("treeCache.maxBytes", n, Number.MAX_SAFE_INTEGER)
+  };
+}, We = (e) => {
+  if (e === null || typeof e != "object") throw new TypeError("[markdown-explorer] authenticate must resolve to { status, ... }");
+  const { status: t } = e;
+  if (t !== "signed-in" && t !== "signed-out" && t !== "forbidden") throw new TypeError(`[markdown-explorer] authenticate resolved to an unknown status ${JSON.stringify(t)}`);
+  return e;
+}, Ye = (e, t) => {
+  if (!(t instanceof Response)) throw new TypeError(`[markdown-explorer] ${e} must return a Response`);
+  return t;
+}, Ke = (e, t) => {
+  if (typeof t != "string" || t === "") throw new TypeError("[markdown-explorer] principalKey must return a non-empty string");
+  return Pt("sha256", e).update(t, "utf8").digest("base64url").slice(0, wn);
+}, Tn = (e) => e.view === "multi" ? e.docs : e.doc === null ? [] : [e.doc], pe = (e, t) => {
+  const r = e.getAll(t), [n] = r;
+  return r.length === 1 && n !== void 0 && n !== "" ? n : null;
+}, ae = (e, t, r, n = {}) => {
+  const s = new Headers(r);
+  for (const [o, c] of Object.entries({ ...pn, ...n })) s.set(o, c);
+  return new Response(t, { status: e, headers: s });
+}, F = (e, t, r) => ae(_t[e.reason], JSON.stringify({ failure: e }), t, r), Ve = (e) => {
+  if (e.headers.get(rt) !== Nt) return !1;
+  const t = e.headers.get("Sec-Fetch-Site");
+  return t === null || t === "same-origin";
+}, xn = ({ parentHeaders: e, loaderHeaders: t, errorHeaders: r }) => {
+  const n = new Headers(), s = r === void 0 ? [e, t] : [e, t, r];
+  for (const o of s)
+    for (const [c, m] of o)
+      c !== "set-cookie" && n.set(c, m);
+  return n;
+}, Yn = (e) => {
+  if (e === null || typeof e != "object") throw new TypeError("[markdown-explorer] the server configuration must be an object");
+  const t = gn(e.config), r = En(e.scopeSecret);
+  X("authenticate", e.authenticate, !1), X("principalKey", e.principalKey, !1), X("document", e.document, !1), X("asset", e.asset, !1), X("signedOutPage", e.signedOutPage, !1), X("forbiddenPage", e.forbiddenPage, !0), X("notices", e.notices, !0), X("onTreeRefreshed", e.onTreeRefreshed, !0);
+  const n = bn(e.sources), s = $t(
+    t,
+    n.map((i) => i.id)
+  ), o = e.logger;
+  if (o !== void 0 && (o === null || typeof o != "object" || typeof o.error != "function"))
+    throw new TypeError("[markdown-explorer] logger must be an object with an error function");
+  const c = e.logger === void 0 ? yr : e.logger, m = tt(e.deny), g = e.deferredTimeoutMs === void 0 ? mn : ge("deferredTimeoutMs", e.deferredTimeoutMs, hn), T = Sn(e.treeCache), l = () => Date.now(), w = T === !1 ? nn(l) : rn({ ...T, now: l }), _ = Kr(e.sanitizer, t.multiView.maxPanels), R = en({ iframeHosts: t.iframeHosts, dataPath: t.dataPath, options: _, pool: Zr(Vr(), _) }), I = new Map(n.map((i) => [i.id, i])), O = jt(t), { authenticate: x, principalKey: v, signedOutPage: y, forbiddenPage: N, onTreeRefreshed: z } = e, L = (i, h) => {
+    if (typeof i.label == "string") return i.label;
+    const d = i.label(h);
+    if (typeof d != "string" || d.trim() === "") throw new TypeError(`[markdown-explorer] the label of source ${JSON.stringify(i.id)} must be a non-blank string`);
+    return d;
+  }, u = (i, h) => i.cacheScope === "shared" ? i.id : `${i.id}\0${h}`, a = (i, h) => {
+    const d = (f) => q(c, { operation: "boundary", sourceId: i.id, path: h, error: f });
+    let p;
+    try {
+      p = i.boundary.contains(h);
+    } catch (f) {
+      return d(f), !1;
+    }
+    return typeof p == "boolean" ? p : (Ce(p, d), d(new TypeError(`[markdown-explorer] boundary.contains of source ${JSON.stringify(i.id)} must return a boolean; got ${typeof p}`)), !1);
+  }, E = async (i, h, d) => {
+    const { confirm: p } = i.boundary;
+    if (p === void 0) return { status: "inside", readPath: d };
+    let f;
+    try {
+      f = await p(h, d);
+    } catch (K) {
+      return { status: "error", failure: Q(K, { operation: "boundary", sourceId: i.id, path: d }, h.signal, c) };
+    }
+    const S = (K) => (q(c, { operation: "boundary", sourceId: i.id, path: d, error: new TypeError(`[markdown-explorer] boundary.confirm of source ${JSON.stringify(i.id)} ${K}`) }), { status: "outside" });
+    if (f === null || typeof f != "object") return S(`must resolve to { inside, readPath? }; got ${f === null ? "null" : typeof f}`);
+    const { inside: j, readPath: C } = f;
+    return j === !1 ? { status: "outside" } : j !== !0 || typeof C != "string" ? S("must resolve to { inside: false } or { inside: true, readPath: string }") : !te(C) || m.deniesPath(C) ? (q(c, { operation: "boundary", sourceId: i.id, path: d, error: new RangeError(`[markdown-explorer] boundary.confirm of source ${JSON.stringify(i.id)} answered a readPath the explorer does not serve (unacceptable or denied)`) }), { status: "error", failure: { reason: "failed" } }) : { status: "inside", readPath: C };
+  }, b = async (i, h) => {
+    const d = n.filter((f) => a(f, h));
+    if (d.length === 0) return { status: "error", failure: { reason: "forbidden" } };
+    if (d.some((f) => f.boundary.confirm === void 0)) return { status: "inside", readPath: h };
+    let p = null;
+    for (const f of d) {
+      const S = await E(f, i, h);
+      if (S.status === "inside") return S;
+      S.status === "error" && p === null && (p = S.failure);
+    }
+    return { status: "error", failure: p === null ? { reason: "forbidden" } : p };
+  }, k = (i, h, d) => {
+    const p = ({ path: f, reason: S }) => Tr(c, { operation: d.operation, sourceId: d.sourceId, path: f, error: new TypeError(`[markdown-explorer] an entry with ${S} was left out`) });
+    try {
+      return { status: "ok", entries: sn(i, m, h.children !== void 0, p, (f) => a(h, f)) };
+    } catch (f) {
+      return q(c, { ...d, error: f }), { status: "error", failure: { reason: "failed" } };
+    }
+  }, A = async (i, h, d) => {
+    let p;
+    try {
+      p = await i.tree(h);
+    } catch (S) {
+      return { status: "error", failure: Q(S, { operation: "tree", sourceId: i.id }, h.signal, c) };
+    }
+    const f = k(p, i, { operation: "tree", sourceId: i.id });
+    return f.status === "ok" ? { status: "ok", entries: f.entries, loadedAt: d } : f;
+  }, D = (i, h, d, p) => (f, S) => A(i, { principal: h, request: d, signal: f, refresh: p }, S), M = (i, h, d, p, f) => w.load(u(i, d), f, D(i, h, p, !1)), U = (i, h, d, p) => w.refresh(u(i, d), p.signal, D(i, h, p, !0)), G = (i, h) => {
+    if (z === void 0) return;
+    const d = (p) => q(c, { operation: "refresh", sourceId: i.id, error: p });
+    try {
+      Ce(z(h), d);
+    } catch (p) {
+      d(p);
+    }
+  }, B = async (i, h, d, p) => {
+    if (m.deniesPath(p) || !a(i, p)) return { status: "error", failure: { reason: "forbidden" } };
+    const f = await E(i, d, p);
+    if (f.status === "outside") return { status: "error", failure: { reason: "forbidden" } };
+    if (f.status === "error") return { status: "error", failure: f.failure };
+    let S;
+    try {
+      S = await h(d, p, f.readPath);
+    } catch (j) {
+      return { status: "error", failure: Q(j, { operation: "children", sourceId: i.id, path: p }, d.signal, c) };
+    }
+    return k(S, i, { operation: "children", sourceId: i.id, path: p });
+  }, Z = async (i, h, d) => {
+    if (m.deniesPath(d)) return ee("forbidden");
+    const p = await b(i, d);
+    if (p.status === "error") return { kind: "failure", failure: p.failure };
+    let f;
+    try {
+      f = await e.document(i, d, p.readPath);
+    } catch (C) {
+      return { kind: "failure", failure: Q(C, { operation: "document", path: d }, i.signal, c) };
+    }
+    let S;
+    try {
+      S = ln(f, (C) => It(t.dataPath, d, C));
+    } catch (C) {
+      return q(c, { operation: "document", path: d, error: C }), ee("failed");
+    }
+    if (S.kind !== "unsanitized-markdown") return S;
+    const j = await R(S.html, { scope: h, signal: i.signal });
+    return j.status === "sanitized" ? { kind: "markdown", name: S.name, htmlContent: j.html, headings: S.headings } : (j.cause !== null && q(c, { operation: "document", path: d, error: j.cause }), ee(j.reason));
+  }, $ = async (i) => {
+    if (e.notices === void 0) return ke;
+    try {
+      return fn(await e.notices(i));
+    } catch (h) {
+      return Q(h, { operation: "notices" }, i.signal, c), ke;
+    }
+  }, J = async (i, h, d) => {
+    const p = pe(h, de.path);
+    if (p === null || !te(p)) return F({ reason: "invalid" }, d);
+    if (m.deniesPath(p))
+      return xr(c, { operation: "asset", path: p }), F({ reason: "forbidden" }, d);
+    const f = await b(i, p);
+    if (f.status === "error") return F(f.failure, d);
+    try {
+      const S = dn(await e.asset(i, p, f.readPath));
+      return await Er(i.request, S, d);
+    } catch (S) {
+      return F(Q(S, { operation: "asset", path: p }, i.signal, c), d);
+    }
+  }, W = async ({ request: i, url: h, params: d }) => {
+    const p = We(await x(i)), f = new Headers(p.headers);
+    if (f.set("Cache-Control", dt), p.status === "signed-out") throw Ye("signedOutPage", y(i, f));
+    if (p.status === "forbidden") throw N === void 0 ? Ie(null, { status: 403, headers: f }) : Ye("forbiddenPage", N(i, f));
+    const S = Dt(s, d["*"], h.searchParams);
+    if (S.kind === "redirect") throw vt(S.href, { headers: f });
+    const { location: j } = S, { principal: C } = p, K = Ke(r, v(C)), le = I.get(j.source);
+    if (le === void 0) throw new RangeError(`[markdown-explorer] no source for ${JSON.stringify(j.source)}`);
+    const re = { signal: i.signal, timeoutMs: g, late: null, handOverMs: g }, V = {
+      scope: K,
+      sources: n.map((H) => ({ id: H.id, label: L(H, C) })),
+      settings: Ct(Ht(i.headers.get("Cookie"), t.settingsCookie), O),
+      tree: j.view === "single" ? null : {
+        sourceId: j.source,
+        result: Te(re, (H) => M(le, C, K, i, H).then((se) => se.result))
+      },
+      documents: Tn(j).map((H) => ({ path: H, document: Te(re, (se) => Z({ principal: C, request: i, signal: se, refresh: !1 }, K, H)) })),
+      notices: Te({ signal: i.signal, timeoutMs: g, late: ke, handOverMs: 0 }, (H) => $({ principal: C, request: i, signal: H, refresh: !1 }))
+    };
+    return Ie(V, { headers: f });
+  }, Y = async (i, h, d) => {
+    let p;
+    try {
+      p = We(await x(h));
+    } catch (H) {
+      return F(Q(H, { operation: "authenticate" }, h.signal, c));
+    }
+    const f = new Headers(p.headers);
+    if (p.status === "signed-out") return F({ reason: "unauthorized" }, f);
+    if (p.status === "forbidden") return F({ reason: "forbidden" }, f);
+    const { principal: S } = p;
+    if (i === "asset") return J({ principal: S, request: h, signal: h.signal, refresh: !1 }, d, f);
+    const j = Ke(r, v(S));
+    f.set(At, j);
+    const C = { principal: S, request: h, signal: h.signal, refresh: !1 }, K = () => F({ reason: "invalid" }, f);
+    if (i === "document") {
+      const H = pe(d, de.path);
+      if (H === null || !te(H)) return K();
+      const se = h.headers.has(rt);
+      return se && !Ve(h) ? F({ reason: "forbidden" }, f) : ae(200, JSON.stringify(await Z({ ...C, refresh: se }, j, H)), f);
+    }
+    const le = pe(d, de.source), re = pe(d, de.path);
+    if (le === null || i === "children" && (re === null || !te(re))) return K();
+    const V = I.get(le);
+    if (V === void 0) return F({ reason: "not-found" }, f);
+    if (i === "tree") return ae(200, (await M(V, S, j, h, h.signal)).json, f);
+    if (i === "refresh") {
+      const H = await U(V, S, j, h);
+      return h.signal.aborted || G(V, u(V, j)), ae(200, H.json, f);
+    }
+    return V.children === void 0 || re === null ? F({ reason: "not-found" }, f) : ae(200, JSON.stringify(await B(V, V.children, C, re)), f);
+  }, ue = async (i, h, d) => {
+    if (new URL(i.url).pathname.endsWith(".data")) return F({ reason: "not-found" });
+    if (!Rt(d)) return F({ reason: "not-found" });
+    const p = i.method.toUpperCase(), f = d === "refresh";
+    if (f ? p !== "POST" : p !== "GET" && p !== "HEAD") return ae(405, JSON.stringify({ failure: { reason: "invalid" } }), void 0, { Allow: f ? "POST" : "GET, HEAD" });
+    if (f && !Ve(i)) return F({ reason: "forbidden" });
+    try {
+      return await Y(d, i, h.searchParams);
+    } catch (S) {
+      return F(Q(S, { operation: d }, i.signal, c));
+    }
+  };
+  return Object.freeze({
+    loader: W,
+    headers: xn,
+    dataLoader: ({ request: i, url: h, params: d }) => ue(i, h, d["*"]),
+    dataAction: ({ request: i, url: h, params: d }) => ue(i, h, d["*"]),
+    forgetTree: (i) => {
+      if (typeof i != "string") throw new TypeError(`[markdown-explorer] forgetTree needs the string key onTreeRefreshed received; got ${typeof i}`);
+      w.forget(i);
+    }
+  });
+}, we = Object.freeze({ maxEntries: 2e4, maxDocumentBytes: 2 * 1024 * 1024, textPreviewBytes: 8 * 1024, walkConcurrency: 8 }), On = /* @__PURE__ */ new Set(["md", "markdown", "mdx"]), ft = new Map([
+  ...[
+    ["png", "image/png"],
+    ["jpg", "image/jpeg"],
+    ["jpeg", "image/jpeg"],
+    ["gif", "image/gif"],
+    ["svg", "image/svg+xml"],
+    ["webp", "image/webp"],
+    ["ico", "image/x-icon"],
+    ["bmp", "image/bmp"],
+    ["tif", "image/tiff"],
+    ["tiff", "image/tiff"],
+    ["avif", "image/avif"]
+  ].map(([e, t]) => [e, { kind: "image", contentType: t }]),
+  ...[
+    ["mp4", "video/mp4"],
+    ["m4v", "video/mp4"],
+    ["webm", "video/webm"],
+    ["mov", "video/quicktime"],
+    ["avi", "video/x-msvideo"],
+    ["mkv", "video/x-matroska"],
+    ["ogv", "video/ogg"]
+  ].map(([e, t]) => [e, { kind: "media", mediaType: "video", contentType: t }]),
+  ...[
+    ["mp3", "audio/mpeg"],
+    ["wav", "audio/wav"],
+    ["ogg", "audio/ogg"],
+    ["oga", "audio/ogg"],
+    ["opus", "audio/ogg"],
+    ["m4a", "audio/mp4"],
+    ["flac", "audio/flac"],
+    ["aac", "audio/aac"],
+    ["wma", "audio/x-ms-wma"]
+  ].map(([e, t]) => [e, { kind: "media", mediaType: "audio", contentType: t }]),
+  ["pdf", { kind: "media", mediaType: "pdf", contentType: "application/pdf" }]
+]), kn = /* @__PURE__ */ new Set([
+  "txt",
+  "text",
+  "log",
+  "csv",
+  "tsv",
+  "json",
+  "jsonc",
+  "json5",
+  "ndjson",
+  "yaml",
+  "yml",
+  "toml",
+  "ini",
+  "cfg",
+  "conf",
+  "properties",
+  "xml",
+  "xsl",
+  "xsd",
+  "dtd",
+  "html",
+  "htm",
+  "xhtml",
+  "css",
+  "scss",
+  "sass",
+  "less",
+  "styl",
+  "js",
+  "mjs",
+  "cjs",
+  "jsx",
+  "ts",
+  "mts",
+  "cts",
+  "tsx",
+  "vue",
+  "svelte",
+  "astro",
+  "py",
+  "pyi",
+  "rb",
+  "go",
+  "rs",
+  "java",
+  "kt",
+  "kts",
+  "scala",
+  "groovy",
+  "gradle",
+  "c",
+  "h",
+  "cc",
+  "cpp",
+  "cxx",
+  "hpp",
+  "hh",
+  "hxx",
+  "cs",
+  "fs",
+  "vb",
+  "swift",
+  "m",
+  "mm",
+  "php",
+  "pl",
+  "pm",
+  "r",
+  "jl",
+  "lua",
+  "dart",
+  "ex",
+  "exs",
+  "erl",
+  "hrl",
+  "hs",
+  "ml",
+  "mli",
+  "clj",
+  "cljs",
+  "elm",
+  "nim",
+  "zig",
+  "v",
+  "sol",
+  "tf",
+  "hcl",
+  "nix",
+  "sh",
+  "bash",
+  "zsh",
+  "fish",
+  "ps1",
+  "psm1",
+  "bat",
+  "cmd",
+  "sql",
+  "graphql",
+  "gql",
+  "proto",
+  "thrift",
+  "avsc",
+  "rst",
+  "adoc",
+  "asciidoc",
+  "tex",
+  "bib",
+  "org",
+  "textile",
+  "diff",
+  "patch",
+  "srt",
+  "vtt",
+  "ics",
+  "vcf",
+  "gitignore",
+  "gitattributes",
+  "editorconfig",
+  "dockerignore",
+  "npmignore",
+  "prettierrc",
+  "eslintrc",
+  "babelrc",
+  "mailmap"
+]), Rn = /* @__PURE__ */ new Set([
+  "readme",
+  "license",
+  "licence",
+  "copying",
+  "notice",
+  "authors",
+  "contributors",
+  "changelog",
+  "changes",
+  "todo",
+  "makefile",
+  "dockerfile",
+  "containerfile",
+  "procfile",
+  "gemfile",
+  "rakefile",
+  "vagrantfile",
+  "jenkinsfile",
+  "brewfile",
+  "codeowners"
+]), mt = typeof ce.O_NOFOLLOW == "number" ? ce.O_NOFOLLOW : 0, pt = typeof ce.O_NONBLOCK == "number" ? ce.O_NONBLOCK : 0, Ze = (e) => `${e.size}-${e.mtimeNs}`, _n = (e) => e !== "" && e !== "." && e !== ".." && !e.includes(":") && !e.endsWith(".") && !e.endsWith(" "), Qe = (e) => te(e) && e === e.normalize("NFC") && e.split("/").every(_n), wt = (e) => {
+  const t = e.toLowerCase(), r = t.lastIndexOf(".");
+  return r < 0 ? "" : t.slice(r + 1);
+}, Nn = (e) => {
+  const t = wt(e);
+  if (On.has(t)) return { kind: "markdown" };
+  const r = ft.get(t);
+  if (r !== void 0) return r.kind === "image" ? { kind: "image" } : { kind: "media", mediaType: r.mediaType };
+  const n = e.toLowerCase();
+  return kn.has(t) || !n.includes(".") && Rn.has(n) ? { kind: "text" } : { kind: "file" };
+}, ht = (e) => {
+  switch (typeof e == "object" && e !== null ? e.code : void 0) {
+    case "ENOENT":
+    case "ENOTDIR":
+      return "not-found";
+    case "ELOOP":
+    case "EACCES":
+    case "EPERM":
+      return "forbidden";
+    case "ENAMETOOLONG":
+      return "invalid";
+    case "EISDIR":
+      return "unsupported";
+    default:
+      return null;
+  }
+}, gt = (e) => {
+  const t = ht(e);
+  return t === null ? e : new Ee(t);
+}, An = (e) => {
+  const t = typeof e == "object" && e !== null ? e.code : void 0;
+  return t === "EACCES" || t === "EPERM" || t === "ENOENT" || t === "ENOTDIR";
+}, qe = async (e, t) => {
+  const r = [];
+  for await (const n of e.createReadStream({ start: 0, end: t - 1, autoClose: !1 }))
+    r.push(n);
+  return Buffer.concat(r);
+}, In = (e, t) => e !== null ? { start: e.offset, end: e.offset + e.length - 1 } : t === 0n ? {} : { start: 0, end: Number(t) - 1 }, Mn = async (e, t, r, n) => {
+  let s;
+  try {
+    s = await nt(e, ce.O_RDONLY | mt | pt);
+    const g = await s.stat({ bigint: !0 });
+    if (!g.isFile() || g.ino !== t.ino || g.dev !== t.dev || g.size !== t.size || g.mtimeNs !== t.mtimeNs) throw new Ee("not-found");
+  } catch (g) {
+    throw await s?.close(), gt(g);
+  }
+  const o = s.createReadStream(In(r, t.size)), c = qt.toWeb(o), m = () => {
+    o.destroy(n.reason);
+  };
+  return n.aborted ? m() : n.addEventListener("abort", m, { once: !0 }), c;
+}, Pn = (e, t) => {
+  const r = Ft.compare(e, t);
+  return r !== 0 ? r : e === t ? 0 : e < t ? -1 : 1;
+}, vn = (e) => {
+  let t = 0;
+  const r = [];
+  return async (n) => {
+    t < e ? t += 1 : await new Promise((s) => r.push(s));
+    try {
+      return await n();
+    } finally {
+      const s = r.shift();
+      s === void 0 ? t -= 1 : s();
+    }
+  };
+}, $n = (e, t) => {
+  if (e.isSymbolicLink()) return "symbolic-link";
+  if (!(e.isDirectory() || e.isFile())) return "special-file";
+  const { name: r } = e;
+  return r !== r.normalize("NFC") ? "not-nfc" : r.includes(":") ? "colon" : r.endsWith(".") || r.endsWith(" ") ? "trailing-dot-or-space" : te(r) ? te(t) ? null : "path-too-long" : "control-character-or-backslash";
+}, jn = /* @__PURE__ */ new Set(["id", "label", "root", "pathPrefix", "parse", "deny", "maxEntries", "maxDocumentBytes", "textPreviewBytes", "walkConcurrency", "cacheScope", "reportSkipped"]), he = (e, t, r) => {
+  if (t === void 0) return r;
+  if (typeof t != "number" || !Number.isSafeInteger(t) || t <= 0) throw new RangeError(`[markdown-explorer] ${e} must be a positive integer; got ${String(t)}`);
+  return t;
+}, Kn = (e) => {
+  if (e === null || typeof e != "object") throw new TypeError("[markdown-explorer] createFileSystemSource needs an options object");
+  for (const a of Object.keys(e))
+    if (!jn.has(a)) throw new TypeError(`[markdown-explorer] createFileSystemSource does not know the option ${JSON.stringify(a)}`);
+  const { id: t, label: r, root: n, parse: s } = e;
+  if (typeof t != "string" || t === "") throw new TypeError("[markdown-explorer] a file-system source needs a non-empty id");
+  if (typeof r != "string" || r.trim() === "") throw new TypeError("[markdown-explorer] a file-system source needs a non-blank label");
+  if (typeof s != "function") throw new TypeError("[markdown-explorer] a file-system source needs a parse function");
+  if (typeof n != "string" || !Me(n)) throw new RangeError(`[markdown-explorer] root must be an absolute path; got ${JSON.stringify(n)}`);
+  let o;
+  try {
+    o = Gt(n).isDirectory();
+  } catch (a) {
+    throw new RangeError(`[markdown-explorer] root does not exist: ${n}`, { cause: a });
+  }
+  if (!o) throw new RangeError(`[markdown-explorer] root is not a directory: ${n}`);
+  const c = Xt(n), m = e.pathPrefix;
+  if (typeof m != "string") throw new TypeError('[markdown-explorer] pathPrefix is required: "" for a source over the whole root, or relative segments ending with "/"');
+  if (m !== "" && !(m.endsWith("/") && Qe(m.slice(0, -1))))
+    throw new RangeError(`[markdown-explorer] pathPrefix must be empty or relative segments ending with "/"; got ${JSON.stringify(m)}`);
+  const g = tt(e.deny), T = he("maxEntries", e.maxEntries, we.maxEntries), l = he("maxDocumentBytes", e.maxDocumentBytes, we.maxDocumentBytes), w = he("textPreviewBytes", e.textPreviewBytes, we.textPreviewBytes), _ = he("walkConcurrency", e.walkConcurrency, we.walkConcurrency), R = e.cacheScope === void 0 ? "principal" : e.cacheScope;
+  if (R !== "principal" && R !== "shared") throw new RangeError(`[markdown-explorer] cacheScope must be "principal" or "shared"; got ${JSON.stringify(R)}`);
+  const I = e.reportSkipped;
+  if (I !== void 0 && typeof I != "function") throw new TypeError("[markdown-explorer] reportSkipped must be a function");
+  const O = I === void 0 ? (a) => {
+    console.warn(`[markdown-explorer] the file-system source ${JSON.stringify(a.sourceId)} does not list ${JSON.stringify(a.path)}: ${a.reason}`);
+  } : I, x = /* @__PURE__ */ new Set(), v = (a) => {
+    const E = Yt(c, ...a.split("/")), b = Pe(c, E);
+    return b === "" || b === ".." || b.startsWith(`..${ve}`) || Me(b) ? null : E;
+  }, y = (a, E) => {
+    const b = `${E}\0${a}`;
+    x.has(b) || x.size >= T || (x.add(b), O({ sourceId: t, path: a, reason: E }));
+  }, N = async ({ signal: a }) => {
+    a.throwIfAborted();
+    const E = new AbortController(), b = () => {
+      E.abort(a.reason);
+    };
+    a.addEventListener("abort", b, { once: !0 });
+    const k = vn(_);
+    let A = 0;
+    const D = async (M, U) => {
+      const G = await k(async () => {
+        E.signal.throwIfAborted();
+        try {
+          return await Qt(M, { withFileTypes: !0 });
+        } catch ($) {
+          if (U === "" || !An($)) throw $;
+          return null;
+        }
+      });
+      if (E.signal.throwIfAborted(), G === null)
+        return y(`${m}${U}`, "unreadable-directory"), null;
+      const B = [];
+      for (const $ of G) {
+        if (g.deniesName($.name)) continue;
+        const J = U === "" ? $.name : `${U}/${$.name}`, W = `${m}${J}`, Y = $n($, W);
+        if (Y !== null) {
+          y(W, Y);
+          continue;
+        }
+        B.push({ dirent: $, relativePath: J, path: W });
+      }
+      if (A += B.length, A > T) throw new Ee("too-large");
+      return B.sort(($, J) => Pn($.dirent.name, J.dirent.name)), (await Promise.all(
+        B.map(async ({ dirent: $, relativePath: J, path: W }) => {
+          if (!$.isDirectory()) return { name: $.name, path: W, type: "file" };
+          const Y = await D(Wt(M, $.name), J);
+          return Y === null ? null : { name: $.name, path: W, type: "directory", children: Y };
+        })
+      )).filter(($) => $ !== null);
+    };
+    try {
+      const M = await D(c, "");
+      if (M === null) throw new Error("[markdown-explorer] the source's root could not be listed");
+      return M;
+    } catch (M) {
+      throw E.abort(), M;
+    } finally {
+      a.removeEventListener("abort", b);
+    }
+  }, z = async (a) => {
+    if (!a.startsWith(m)) return { status: "refused", reason: "not-found" };
+    const E = a.slice(m.length);
+    if (!Qe(E)) return { status: "refused", reason: "invalid" };
+    if (g.deniesPath(E)) return { status: "refused", reason: "forbidden" };
+    const b = v(E);
+    if (b === null) return { status: "refused", reason: "forbidden" };
+    const k = await Vt(b, { bigint: !0 });
+    if (k.isSymbolicLink()) return { status: "refused", reason: "forbidden" };
+    if (!k.isFile()) return { status: "refused", reason: "unsupported" };
+    const A = await Zt(b);
+    return A !== b || g.deniesPath(Pe(c, A).split(ve).join("/")) ? { status: "refused", reason: "forbidden" } : { status: "file", target: b, name: E.slice(E.lastIndexOf("/") + 1), stats: k };
+  }, L = async (a, E, b) => {
+    let k;
+    try {
+      const A = await z(b);
+      if (A.status === "refused") return ee(A.reason);
+      const { target: D, name: M, stats: U } = A, G = Nn(M), B = Ze(U);
+      if (G.kind === "image") return { kind: "image", name: M, version: B };
+      if (G.kind === "media") return { kind: "media", name: M, mediaType: G.mediaType, version: B };
+      if (G.kind === "file") return { kind: "file", name: M, version: B };
+      k = await nt(D, ce.O_RDONLY | mt | pt);
+      const Z = await k.stat({ bigint: !0 });
+      if (!Z.isFile() || Z.ino !== U.ino || Z.dev !== U.dev) return ee("forbidden");
+      if (G.kind === "markdown") {
+        if (Z.size > BigInt(l)) return ee("too-large");
+        const Y = await qe(k, l + 1);
+        if (Y.length > l) return ee("too-large");
+        const ue = await s(new TextDecoder("utf-8").decode(Y), E);
+        return { kind: "markdown", name: M, htmlContent: ue.htmlContent, headings: ue.headings };
+      }
+      const $ = await qe(k, w);
+      if ($.includes(0)) return { kind: "file", name: M, version: B };
+      const J = Z.size > BigInt(w), W = new TextDecoder("utf-8").decode($, { stream: J });
+      return { kind: "text", name: M, text: W, truncated: J, version: B };
+    } catch (A) {
+      const D = ht(A);
+      if (D === null) throw A;
+      return ee(D);
+    } finally {
+      await k?.close();
+    }
+  }, u = async (a, E, b) => {
+    let k;
+    try {
+      k = await z(b);
+    } catch (B) {
+      throw gt(B);
+    }
+    if (k.status === "refused") throw new Ee(k.reason);
+    const { target: A, name: D, stats: M } = k, U = ft.get(wt(D)), G = U === void 0 ? "" : U.contentType;
+    return { name: D, contentType: G, size: Number(M.size), version: Ze(M), open: (B) => Mn(A, M, B, a.signal) };
+  };
+  return Object.freeze({
+    id: t,
+    label: r,
+    cacheScope: R,
+    boundary: Object.freeze({ contains: (a) => a.startsWith(m) }),
+    tree: N,
+    document: L,
+    asset: u
+  });
+};
+export {
+  Qn as DEFAULT_DENIED_PATH_SEGMENTS,
+  Ee as ExplorerError,
+  qn as MAX_DOCUMENT_PATH_LENGTH,
+  Wn as anonymousAccess,
+  Kn as createFileSystemSource,
+  Yn as createMarkdownExplorer,
+  te as isAcceptableDocumentPath,
+  eo as isDeniedPath
+};