@wdprlib/runtime 0.1.0

package/dist/index.js

@@ -0,0 +1,857 @@
+// packages/runtime/src/utils/dom.ts
+function isElement(target) {
+  return target !== null && "nodeType" in target && target.nodeType === 1;
+}
+
+// packages/runtime/src/utils/tooltip.ts
+var activeTooltip = null;
+function showTooltipEl(anchor, tip) {
+  hideTooltip();
+  const doc = anchor.ownerDocument;
+  tip.style.position = "absolute";
+  tip.style.zIndex = "10000";
+  doc.body.appendChild(tip);
+  const anchorRect = anchor.getBoundingClientRect();
+  const tipRect = tip.getBoundingClientRect();
+  const win = doc.defaultView ?? window;
+  let left = anchorRect.left + win.scrollX;
+  let top = anchorRect.bottom + win.scrollY + 4;
+  if (left + tipRect.width > win.innerWidth + win.scrollX) {
+    left = win.innerWidth + win.scrollX - tipRect.width - 8;
+  }
+  if (top + tipRect.height > win.innerHeight + win.scrollY) {
+    top = anchorRect.top + win.scrollY - tipRect.height - 4;
+  }
+  tip.style.left = `${left}px`;
+  tip.style.top = `${top}px`;
+  activeTooltip = tip;
+}
+function showTooltip(anchor, source) {
+  const doc = anchor.ownerDocument;
+  const tip = doc.createElement("div");
+  tip.className = "hovertip";
+  tip.style.width = "auto";
+  tip.style.backgroundColor = "white";
+  const content = doc.createElement("div");
+  content.className = "content";
+  const clone = source.cloneNode(true);
+  while (clone.firstChild) {
+    content.appendChild(clone.firstChild);
+  }
+  tip.appendChild(content);
+  showTooltipEl(anchor, tip);
+}
+function hideTooltip() {
+  if (activeTooltip) {
+    activeTooltip.remove();
+    activeTooltip = null;
+  }
+}
+
+// packages/runtime/src/bibcite.ts
+function initBibcite(root) {
+  function handleMouseEnter(e) {
+    const target = e.target;
+    if (!isElement(target))
+      return;
+    const link = target.closest("a.bibcite");
+    if (!link)
+      return;
+    const href = link.getAttribute("href");
+    if (!href?.startsWith("#"))
+      return;
+    const bibitem = root.ownerDocument.getElementById(href.slice(1));
+    if (!bibitem)
+      return;
+    const id = href.slice(1).replace(/^bibitem-/, "");
+    const tip = buildBibciteTooltip(root.ownerDocument, bibitem, id);
+    showTooltipEl(link, tip);
+  }
+  function handleMouseLeave(e) {
+    const target = e.target;
+    if (!isElement(target))
+      return;
+    if (target.closest("a.bibcite")) {
+      hideTooltip();
+    }
+  }
+  root.addEventListener("mouseenter", handleMouseEnter, true);
+  root.addEventListener("mouseleave", handleMouseLeave, true);
+  return {
+    destroy() {
+      root.removeEventListener("mouseenter", handleMouseEnter, true);
+      root.removeEventListener("mouseleave", handleMouseLeave, true);
+    }
+  };
+}
+function buildBibciteTooltip(doc, bibitemEl, id) {
+  const tip = doc.createElement("div");
+  tip.className = "hovertip";
+  tip.style.width = "auto";
+  tip.style.backgroundColor = "white";
+  const content = doc.createElement("div");
+  content.className = "content";
+  const refWrap = doc.createElement("div");
+  refWrap.className = "reference";
+  const heading = doc.createElement("div");
+  heading.className = "r-heading";
+  heading.textContent = `Reference ${id}.`;
+  refWrap.appendChild(heading);
+  const rContent = doc.createElement("div");
+  rContent.className = "r-content";
+  const clone = bibitemEl.cloneNode(true);
+  const firstText = clone.firstChild;
+  if (firstText?.nodeType === Node.TEXT_NODE) {
+    firstText.textContent = firstText.textContent?.replace(/^\s*[0-9]+\.\s*/, "") ?? "";
+  }
+  while (clone.firstChild)
+    rContent.appendChild(clone.firstChild);
+  refWrap.appendChild(rContent);
+  const footer = doc.createElement("div");
+  footer.className = "r-footer";
+  footer.textContent = "(click to scroll to bibliography)";
+  refWrap.appendChild(footer);
+  content.appendChild(refWrap);
+  tip.appendChild(content);
+  return tip;
+}
+
+// packages/runtime/src/collapsible.ts
+function initCollapsible(root, options) {
+  const useFade = options?.fade !== false;
+  function handleClick(e) {
+    const target = e.target;
+    if (!isElement(target))
+      return;
+    const link = target.closest("a.collapsible-block-link");
+    if (!link)
+      return;
+    const block = link.closest(".collapsible-block");
+    if (!block)
+      return;
+    e.preventDefault();
+    const folded = block.querySelector(".collapsible-block-folded");
+    const unfolded = block.querySelector(".collapsible-block-unfolded");
+    if (!folded || !unfolded)
+      return;
+    const isFolded = folded.style.display !== "none";
+    if (isFolded) {
+      folded.style.display = "none";
+      unfolded.style.display = "block";
+      if (useFade) {
+        const content = unfolded.querySelector(".collapsible-block-content");
+        if (content)
+          fadeIn(content);
+      }
+    } else {
+      folded.style.display = "block";
+      unfolded.style.display = "none";
+    }
+  }
+  root.addEventListener("click", handleClick);
+  return {
+    destroy() {
+      root.removeEventListener("click", handleClick);
+    }
+  };
+}
+function fadeIn(el) {
+  el.style.opacity = "0";
+  el.style.transition = "opacity 200ms ease-in";
+  el.offsetHeight;
+  el.style.opacity = "1";
+  const onEnd = () => {
+    el.style.transition = "";
+    el.style.opacity = "";
+    el.removeEventListener("transitionend", onEnd);
+  };
+  el.addEventListener("transitionend", onEnd);
+}
+
+// packages/runtime/src/email.ts
+function isValidEmail(email) {
+  return /^[a-zA-Z0-9._+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/.test(email);
+}
+function initEmail(root) {
+  const elements = root.querySelectorAll("span.wiki-email");
+  for (const el of elements) {
+    processEmail(el);
+  }
+}
+function processEmail(el) {
+  const obfuscated = el.textContent;
+  if (!obfuscated)
+    return;
+  const reversed = obfuscated.split("").reverse().join("");
+  const email = reversed.replace(/\|/g, "@");
+  if (!isValidEmail(email)) {
+    return;
+  }
+  const doc = el.ownerDocument;
+  const link = doc.createElement("a");
+  link.href = `mailto:${email}`;
+  link.textContent = email;
+  el.replaceWith(link);
+}
+
+// packages/runtime/src/foldable-list.ts
+function initFoldableList(root) {
+  const containers = root.querySelectorAll(".foldable-list-container");
+  for (const container of containers) {
+    setupFoldableList(container);
+  }
+  function handleContainerClick(e) {
+    const target = e.target;
+    if (!isElement(target))
+      return;
+    if (target.tagName === "A" && target.href !== "#" && target.href !== "javascript:;") {
+      const href = target.getAttribute("href");
+      if (href !== "#" && href !== "javascript:;") {
+        return;
+      }
+    }
+    e.preventDefault();
+    let li = target;
+    while (li && li.tagName?.toLowerCase() !== "li") {
+      li = li.parentElement;
+    }
+    if (!li)
+      return;
+    if (!li.classList.contains("folded") && !li.classList.contains("unfolded")) {
+      return;
+    }
+    if (li.classList.contains("folded")) {
+      li.classList.remove("folded");
+      li.classList.add("unfolded");
+    } else {
+      li.classList.remove("unfolded");
+      li.classList.add("folded");
+    }
+  }
+  for (const container of containers) {
+    container.addEventListener("click", handleContainerClick);
+  }
+  return {
+    destroy() {
+      for (const container of containers) {
+        container.removeEventListener("click", handleContainerClick);
+      }
+    }
+  };
+}
+function setupFoldableList(container) {
+  const items = container.querySelectorAll("li");
+  for (const item of items) {
+    const nestedList = item.querySelector(":scope > ul, :scope > ol");
+    if (!nestedList)
+      continue;
+    if (item.querySelector(".foldable-list-toggle"))
+      continue;
+    item.classList.add("folded");
+    const toggle = container.ownerDocument.createElement("a");
+    toggle.className = "foldable-list-toggle";
+    toggle.href = "javascript:;";
+    item.insertBefore(toggle, item.firstChild);
+  }
+}
+
+// packages/runtime/src/utils/scroll.ts
+function scrollToElement(id, doc) {
+  const d = doc ?? document;
+  const el = d.getElementById(id);
+  if (!el)
+    return;
+  el.scrollIntoView({ behavior: "smooth", block: "center" });
+  el.classList.add("wdpr-blink");
+  setTimeout(() => {
+    el.classList.remove("wdpr-blink");
+  }, 1500);
+}
+
+// packages/runtime/src/footnote.ts
+function initFootnote(root) {
+  const doc = root.ownerDocument;
+  const container = doc.createElement("div");
+  container.id = "odialog-hovertips";
+  container.style.position = "absolute";
+  container.style.zIndex = "100";
+  container.style.top = "0";
+  container.style.width = "100%";
+  doc.body.appendChild(container);
+  const tooltipMap = new Map;
+  const frefs = root.querySelectorAll("a.footnoteref");
+  for (const fref of frefs) {
+    const id = getFootnoteId(fref);
+    if (!id)
+      continue;
+    const footnote = doc.getElementById(id);
+    if (!footnote)
+      continue;
+    const numId = id.replace(/^footnote-/, "");
+    const tip = buildFootnoteTooltip(doc, footnote, numId);
+    container.appendChild(tip);
+    tooltipMap.set(fref.id, tip);
+  }
+  function handleClick(e) {
+    const target = e.target;
+    if (!isElement(target))
+      return;
+    const link = target.closest("a");
+    if (!link)
+      return;
+    if (link.classList.contains("footnoteref")) {
+      e.preventDefault();
+      const id = getFootnoteId(link);
+      if (id)
+        scrollToElement(id, doc);
+      return;
+    }
+    const footnoteItem = link.closest(".footnote-footer");
+    if (footnoteItem) {
+      const backrefId = getBackrefId(link, footnoteItem);
+      if (backrefId) {
+        e.preventDefault();
+        scrollToElement(backrefId, doc);
+      }
+    }
+  }
+  function handleMouseEnter(e) {
+    const target = e.target;
+    if (!isElement(target))
+      return;
+    const link = target.closest("a.footnoteref");
+    if (!link)
+      return;
+    const tip = tooltipMap.get(link.id);
+    if (!tip)
+      return;
+    positionTooltip(tip, link);
+    tip.style.display = "block";
+  }
+  function handleMouseLeave(e) {
+    const target = e.target;
+    if (!isElement(target))
+      return;
+    if (target.closest("a.footnoteref")) {
+      for (const tip of tooltipMap.values()) {
+        tip.style.display = "none";
+      }
+    }
+  }
+  root.addEventListener("click", handleClick);
+  root.addEventListener("mouseenter", handleMouseEnter, true);
+  root.addEventListener("mouseleave", handleMouseLeave, true);
+  return {
+    destroy() {
+      root.removeEventListener("click", handleClick);
+      root.removeEventListener("mouseenter", handleMouseEnter, true);
+      root.removeEventListener("mouseleave", handleMouseLeave, true);
+      container.remove();
+    }
+  };
+}
+function positionTooltip(tip, anchor) {
+  const doc = anchor.ownerDocument;
+  const win = doc.defaultView ?? window;
+  const anchorRect = anchor.getBoundingClientRect();
+  let left = anchorRect.left + win.scrollX;
+  let top = anchorRect.bottom + win.scrollY + 4;
+  tip.style.display = "block";
+  const tipRect = tip.getBoundingClientRect();
+  tip.style.display = "none";
+  if (left + tipRect.width > win.innerWidth + win.scrollX) {
+    left = win.innerWidth + win.scrollX - tipRect.width - 8;
+  }
+  if (top + tipRect.height > win.innerHeight + win.scrollY) {
+    top = anchorRect.top + win.scrollY - tipRect.height - 4;
+  }
+  tip.style.left = `${left}px`;
+  tip.style.top = `${top}px`;
+}
+function buildFootnoteTooltip(doc, footnoteEl, id) {
+  const tip = doc.createElement("div");
+  tip.className = "hovertip";
+  tip.style.width = "auto";
+  tip.style.backgroundColor = "white";
+  tip.style.position = "absolute";
+  tip.style.display = "none";
+  tip.style.border = "1px solid black";
+  const content = doc.createElement("div");
+  content.className = "content";
+  const footnoteWrap = doc.createElement("div");
+  footnoteWrap.className = "footnote";
+  const heading = doc.createElement("div");
+  heading.className = "f-heading";
+  heading.textContent = `Footnote ${id}.`;
+  footnoteWrap.appendChild(heading);
+  const fContent = doc.createElement("div");
+  fContent.className = "f-content";
+  const clone = footnoteEl.cloneNode(true);
+  const firstLink = clone.querySelector("a");
+  if (firstLink) {
+    const next = firstLink.nextSibling;
+    if (next?.nodeType === Node.TEXT_NODE && next.textContent?.startsWith(". ")) {
+      next.textContent = next.textContent.slice(2);
+    }
+    firstLink.remove();
+  }
+  while (clone.firstChild)
+    fContent.appendChild(clone.firstChild);
+  footnoteWrap.appendChild(fContent);
+  const footer = doc.createElement("div");
+  footer.className = "f-footer";
+  footer.textContent = "(click to scroll to footnotes)";
+  footnoteWrap.appendChild(footer);
+  content.appendChild(footnoteWrap);
+  tip.appendChild(content);
+  return tip;
+}
+function getFootnoteId(link) {
+  const href = link.getAttribute("href");
+  if (href?.startsWith("#"))
+    return href.slice(1);
+  const id = link.id;
+  if (id.startsWith("footnoteref-")) {
+    return `footnote-${id.slice("footnoteref-".length)}`;
+  }
+  return null;
+}
+function getBackrefId(link, footer) {
+  const href = link.getAttribute("href");
+  if (href?.startsWith("#"))
+    return href.slice(1);
+  if (footer.id.startsWith("footnote-")) {
+    const num = footer.id.slice("footnote-".length);
+    return `footnoteref-${num}`;
+  }
+  return null;
+}
+
+// packages/runtime/src/html-block.ts
+var MAX_HEIGHT = 1e5;
+function isResizeMessage(data) {
+  if (typeof data !== "object" || data === null || data.type !== "wdpr-html-block-resize" || typeof data.height !== "number") {
+    return false;
+  }
+  const height = data.height;
+  return Number.isFinite(height) && height >= 0 && height <= MAX_HEIGHT;
+}
+function initHtmlBlockResize(root) {
+  function handleMessage(e) {
+    if (!isResizeMessage(e.data))
+      return;
+    const iframes = root.querySelectorAll("iframe.html-block-iframe");
+    for (const iframe of iframes) {
+      if (iframe.contentWindow === e.source) {
+        iframe.style.height = `${e.data.height}px`;
+        break;
+      }
+    }
+  }
+  window.addEventListener("message", handleMessage);
+  return {
+    destroy() {
+      window.removeEventListener("message", handleMessage);
+    }
+  };
+}
+var HTML_BLOCK_RESIZE_SCRIPT = `(function(){
+  function notifyHeight() {
+    var height = (document.documentElement.scrollHeight || document.body.scrollHeight) + 2;
+    parent.postMessage({ type: 'wdpr-html-block-resize', height: height }, '*');
+  }
+  if (typeof ResizeObserver !== 'undefined') {
+    new ResizeObserver(notifyHeight).observe(document.body);
+  } else {
+    setInterval(notifyHeight, 250);
+  }
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', notifyHeight);
+  } else {
+    notifyHeight();
+  }
+  window.addEventListener('load', notifyHeight);
+})();`;
+
+// packages/runtime/src/math.ts
+var scriptLoaded = false;
+function initMath(root, options) {
+  const mathUrl = options?.mathUrl;
+  if (mathUrl) {
+    const hasMath = root.querySelector(".math-equation, .math-inline") !== null;
+    if (hasMath && !scriptLoaded) {
+      loadScript(root.ownerDocument, mathUrl);
+      scriptLoaded = true;
+    }
+  }
+  function handleMouseEnter(e) {
+    const target = e.target;
+    if (!isElement(target))
+      return;
+    const link = target.closest("a.eref");
+    if (!link)
+      return;
+    const href = link.getAttribute("href");
+    if (!href?.startsWith("#"))
+      return;
+    const equation = root.ownerDocument.getElementById(href.slice(1));
+    if (!equation)
+      return;
+    showTooltip(link, equation);
+  }
+  function handleMouseLeave(e) {
+    const target = e.target;
+    if (!isElement(target))
+      return;
+    if (target.closest("a.eref")) {
+      hideTooltip();
+    }
+  }
+  root.addEventListener("mouseenter", handleMouseEnter, true);
+  root.addEventListener("mouseleave", handleMouseLeave, true);
+  return {
+    destroy() {
+      root.removeEventListener("mouseenter", handleMouseEnter, true);
+      root.removeEventListener("mouseleave", handleMouseLeave, true);
+    }
+  };
+}
+function isValidScriptUrl(url) {
+  try {
+    const parsed = new URL(url, globalThis.location?.href);
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function loadScript(doc, url) {
+  if (!isValidScriptUrl(url)) {
+    console.error("[wdparser] Invalid script URL scheme:", url);
+    return;
+  }
+  const script = doc.createElement("script");
+  script.src = url;
+  script.async = true;
+  doc.head.appendChild(script);
+}
+
+// packages/runtime/src/modules/join.ts
+function initJoin(root, options) {
+  const onJoin = options?.onJoin;
+  function handleClick(e) {
+    if (!onJoin)
+      return;
+    const target = e.target;
+    if (!isElement(target))
+      return;
+    const btn = target.closest(".join-btn");
+    if (!btn)
+      return;
+    e.preventDefault();
+    onJoin();
+  }
+  root.addEventListener("click", handleClick);
+  return {
+    destroy() {
+      root.removeEventListener("click", handleClick);
+    }
+  };
+}
+
+// packages/runtime/src/modules/rate.ts
+function initRate(root, options) {
+  const onRate = options?.onRate;
+  function handleClick(e) {
+    if (!onRate)
+      return;
+    const target = e.target;
+    if (!isElement(target))
+      return;
+    const btn = target.closest(".btn, .rateup, .ratedown, .cancel");
+    if (!btn)
+      return;
+    const widget = btn.closest(".page-rate-widget-box");
+    if (!widget)
+      return;
+    e.preventDefault();
+    const pageId = widget.dataset["pageId"] ?? "";
+    let points = 0;
+    if (btn.classList.contains("rateup") || btn.classList.contains("btn-rate-up")) {
+      points = 1;
+    } else if (btn.classList.contains("ratedown") || btn.classList.contains("btn-rate-down")) {
+      points = -1;
+    } else if (btn.classList.contains("cancel") || btn.classList.contains("btn-cancel")) {
+      points = 0;
+    }
+    onRate(pageId, points).then((result) => {
+      updateRateDisplay(widget, result.points, result.votes);
+    });
+  }
+  root.addEventListener("click", handleClick);
+  return {
+    destroy() {
+      root.removeEventListener("click", handleClick);
+    }
+  };
+}
+function updateRateDisplay(widget, points, votes) {
+  const rateNum = widget.querySelector(".rate-points .number");
+  if (rateNum) {
+    const prefix = points > 0 ? "+" : "";
+    rateNum.textContent = `${prefix}${points}`;
+  }
+  const voteCount = widget.querySelector(".vote-count");
+  if (voteCount) {
+    voteCount.textContent = String(votes);
+  }
+}
+
+// packages/runtime/src/odate.ts
+var DAYS_SHORT = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+var DAYS_LONG = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+var MONTHS_SHORT = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec"
+];
+var MONTHS_LONG = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+function initOdate(root) {
+  const elements = root.querySelectorAll("span.odate");
+  for (const el of elements) {
+    processOdate(el);
+  }
+}
+function processOdate(el) {
+  const classes = el.className.split(/\s+/);
+  let timestamp = null;
+  let format = "%e %b %Y, %H:%M";
+  for (const cls of classes) {
+    if (cls.startsWith("time_")) {
+      const val = Number(cls.slice(5));
+      if (!Number.isNaN(val))
+        timestamp = val;
+    } else if (cls.startsWith("format%")) {
+      format = decodeFormat(cls.slice(6));
+    }
+  }
+  if (timestamp === null)
+    return;
+  const date = new Date(timestamp * 1000);
+  el.textContent = formatDate(date, format);
+}
+function decodeFormat(encoded) {
+  try {
+    return decodeURIComponent(encoded.replace(/\|/g, "%"));
+  } catch {
+    return encoded;
+  }
+}
+function formatDate(date, format) {
+  let result = "";
+  let i = 0;
+  while (i < format.length) {
+    if (format[i] === "%" && i + 1 < format.length) {
+      i++;
+      const spec = format[i];
+      result += formatSpec(date, spec ?? "");
+      i++;
+    } else {
+      result += format[i];
+      i++;
+    }
+  }
+  return result;
+}
+function formatSpec(date, spec) {
+  switch (spec) {
+    case "Y":
+      return String(date.getFullYear());
+    case "y":
+      return String(date.getFullYear()).slice(-2);
+    case "m":
+      return pad2(date.getMonth() + 1);
+    case "d":
+      return pad2(date.getDate());
+    case "e":
+      return String(date.getDate());
+    case "H":
+      return pad2(date.getHours());
+    case "M":
+      return pad2(date.getMinutes());
+    case "S":
+      return pad2(date.getSeconds());
+    case "a":
+      return DAYS_SHORT[date.getDay()] ?? "";
+    case "A":
+      return DAYS_LONG[date.getDay()] ?? "";
+    case "b":
+      return MONTHS_SHORT[date.getMonth()] ?? "";
+    case "B":
+      return MONTHS_LONG[date.getMonth()] ?? "";
+    case "j":
+      return String(getDayOfYear(date));
+    case "O":
+      return getOrdinalSuffix(date.getDate());
+    case "%":
+      return "%";
+    default:
+      return `%${spec}`;
+  }
+}
+function pad2(n) {
+  return n < 10 ? `0${n}` : String(n);
+}
+function getDayOfYear(date) {
+  const start = new Date(date.getFullYear(), 0, 0);
+  const diff = date.getTime() - start.getTime();
+  return Math.floor(diff / 86400000);
+}
+function getOrdinalSuffix(day) {
+  if (day >= 11 && day <= 13)
+    return `${day}th`;
+  switch (day % 10) {
+    case 1:
+      return `${day}st`;
+    case 2:
+      return `${day}nd`;
+    case 3:
+      return `${day}rd`;
+    default:
+      return `${day}th`;
+  }
+}
+
+// packages/runtime/src/tabview.ts
+function initTabview(root) {
+  function handleClick(e) {
+    const target = e.target;
+    if (!isElement(target))
+      return;
+    const navItem = target.closest(".yui-navset .yui-nav li");
+    if (!navItem)
+      return;
+    const navset = navItem.closest(".yui-navset");
+    if (!navset)
+      return;
+    e.preventDefault();
+    const nav = navset.querySelector(".yui-nav");
+    const content = navset.querySelector(".yui-content");
+    if (!nav || !content)
+      return;
+    const navItems = Array.from(nav.querySelectorAll(":scope > li"));
+    const contentDivs = Array.from(content.querySelectorAll(":scope > div"));
+    const index = navItems.indexOf(navItem);
+    if (index === -1)
+      return;
+    for (const item of navItems) {
+      item.classList.remove("selected");
+    }
+    navItem.classList.add("selected");
+    for (let i = 0;i < contentDivs.length; i++) {
+      const div = contentDivs[i];
+      if (div) {
+        div.style.display = i === index ? "" : "none";
+      }
+    }
+  }
+  root.addEventListener("click", handleClick);
+  return {
+    destroy() {
+      root.removeEventListener("click", handleClick);
+    }
+  };
+}
+
+// packages/runtime/src/toc.ts
+function initToc(root) {
+  function handleClick(e) {
+    const target = e.target;
+    if (!isElement(target))
+      return;
+    const link = target.closest("a");
+    if (!link)
+      return;
+    const actionBar = link.closest("#toc-action-bar");
+    if (!actionBar)
+      return;
+    e.preventDefault();
+    const toc = actionBar.closest("#toc");
+    if (!toc)
+      return;
+    const tocList = toc.querySelector("#toc-list");
+    if (!tocList)
+      return;
+    const links = Array.from(actionBar.querySelectorAll("a"));
+    const foldLink = links[0];
+    const unfoldLink = links[1];
+    if (!foldLink || !unfoldLink)
+      return;
+    const isVisible = tocList.style.display !== "none";
+    if (isVisible) {
+      tocList.style.display = "none";
+      foldLink.style.display = "none";
+      unfoldLink.style.display = "";
+    } else {
+      tocList.style.display = "";
+      foldLink.style.display = "";
+      unfoldLink.style.display = "none";
+    }
+  }
+  root.addEventListener("click", handleClick);
+  return {
+    destroy() {
+      root.removeEventListener("click", handleClick);
+    }
+  };
+}
+
+// packages/runtime/src/index.ts
+function initWdprRuntime(options) {
+  const root = options?.root ?? document.body;
+  const cleanups = [];
+  cleanups.push(initCollapsible(root, options));
+  cleanups.push(initTabview(root));
+  cleanups.push(initToc(root));
+  cleanups.push(initFootnote(root));
+  cleanups.push(initBibcite(root));
+  cleanups.push(initFoldableList(root));
+  cleanups.push(initRate(root, options));
+  cleanups.push(initJoin(root, options));
+  cleanups.push(initHtmlBlockResize(root));
+  cleanups.push(initMath(root, options));
+  initOdate(root);
+  initEmail(root);
+  return {
+    destroy() {
+      for (const cleanup of cleanups) {
+        cleanup.destroy();
+      }
+    }
+  };
+}
+export {
+  initWdprRuntime,
+  HTML_BLOCK_RESIZE_SCRIPT
+};