fixing the site

assets/scripts/gallery-init.js

@@ -0,0 +1,255 @@
+document.addEventListener('DOMContentLoaded', () => {
+  if (typeof window.BiggerPicture !== 'function') {
+    console.error('[gallery-init] BiggerPicture not found. Check script path.');
+    return;
+  }
+
+  // 1) Wrap Org-exported images so they’re clickable
+  const imgs = document.querySelectorAll('.figure img, img.org-svg');
+  imgs.forEach((img) => {
+    if (img.closest('a')) return;                 // already wrapped
+    const a = document.createElement('a');
+    const href = img.currentSrc || img.src;
+    a.href = href;
+    a.dataset.img = href;                         // lets BP pre-size/raster slides
+    a.dataset.alt = img.alt || '';
+    const setDims = () => {
+      a.dataset.width  = img.naturalWidth  || img.width  || 1920;
+      a.dataset.height = img.naturalHeight || img.height || 1080;
+    };
+    if (img.complete) setDims(); else img.addEventListener('load', setDims);
+    img.style.cursor = 'zoom-in';
+    img.parentElement.insertBefore(a, img);
+    a.appendChild(img);
+  });
+
+  // 2) One global BP instance
+  const bp = BiggerPicture({ target: document.body });
+
+  // SVG pan/zoom handle
+  let activePanZoom = null;
+  const destroyPanZoom = () => { try { activePanZoom?.destroy(); } catch(_){} activePanZoom = null; };
+
+  // Simple rotate state (for non-SVG images)
+  let activeContainer = null;
+  let currentRotation = 0;
+  let rotateControls = null;
+
+  
+  // 3) Build galleries per content container
+  const containers = document.querySelectorAll('main, article, .content, body');
+  containers.forEach((container) => {
+    const links = Array.from(container.querySelectorAll('.figure a, a:has(img.org-svg)'));
+    if (!links.length) return;
+
+    // Start the lightbox on click
+    links.forEach((link, index) => {
+      link.addEventListener('click', (e) => {
+        e.preventDefault();
+        document.querySelectorAll(".theme-toggle").forEach(el => {
+          el.classList.add("hidden");
+        });
+
+        bp.open({
+          // IMPORTANT: pass the anchor ELEMENTS, not custom objects
+          items: links,
+          el: link,
+          caption: (el) => el.querySelector('img')?.alt || el.title || '',
+          maxZoom: 40, // for raster images (PNG/JPG); SVG handled separately
+
+          // Fade-out polish + cleanup
+          onClose(containerEl) {
+            destroyPanZoom();
+            teardownRotation();
+            if (containerEl) containerEl.classList.add('bp-fadeout');
+            const themeToggle = document.querySelector(".theme-toggle");
+            if (themeToggle) {
+              themeToggle.classList.remove("hidden");
+            }
+          },
+
+          // Called once after open and on every slide change
+          onOpen(containerEl)  { setupRotation(containerEl); enhanceSVG(containerEl); },
+          onUpdate(containerEl){ setupRotation(containerEl); enhanceSVG(containerEl); }
+        });
+      });
+    });
+  });
+
+  // 4) Simple rotate buttons for raster images
+  function ensureRotateControls() {
+    if (rotateControls) return rotateControls;
+
+    const wrapper = document.createElement('div');
+    wrapper.className = 'bp-rotate-controls';
+    Object.assign(wrapper.style, {
+      position: 'fixed',
+      bottom: '1.5rem',
+      right: '1.5rem',
+      display: 'flex',
+      gap: '0.5rem',
+      zIndex: '9999',
+      pointerEvents: 'auto'
+    });
+
+    const mkBtn = (label, title) => {
+      const btn = document.createElement('button');
+      btn.type = 'button';
+      btn.textContent = label;
+      btn.title = title;
+      btn.setAttribute('aria-label', title);
+      Object.assign(btn.style, {
+        padding: '0.4rem 0.6rem',
+        borderRadius: '999px',
+        border: 'none',
+        fontSize: '1.2rem',
+        cursor: 'pointer',
+        background: 'rgba(30,30,30,0.8)',
+        color: '#fff'
+      });
+      return btn;
+    };
+
+    const left  = mkBtn('⟲', 'Rotate image 90° left');
+    const right = mkBtn('⟳', 'Rotate image 90° right');
+
+    left.addEventListener('click', (e) => {
+      e.stopPropagation();                // don’t close the lightbox
+      if (!activeContainer) return;
+      currentRotation = (currentRotation - 90 + 360) % 360;
+      applyRotation();
+    });
+
+    right.addEventListener('click', (e) => {
+      e.stopPropagation();
+      if (!activeContainer) return;
+      currentRotation = (currentRotation + 90) % 360;
+      applyRotation();
+    });
+
+    wrapper.append(left, right);
+    document.body.appendChild(wrapper);
+    rotateControls = wrapper;
+    return rotateControls;
+  }
+
+  function ensureRotateWrapper() {
+    if (!activeContainer) return null;
+
+    const imgRoot = activeContainer.querySelector('.bp-img');
+    if (!imgRoot) return null;
+
+    let imgEl = imgRoot.querySelector('img');
+    if (!imgEl) return null;
+
+    const src = (imgEl.currentSrc || imgEl.src || '').toLowerCase();
+    // We only rotate raster images; SVGs are handled via svg-pan-zoom
+    if (src.endsWith('.svg')) return null;
+
+    let wrapper = imgRoot.querySelector('.bp-rotate-wrapper');
+    if (!wrapper) {
+      wrapper = document.createElement('div');
+      wrapper.className = 'bp-rotate-wrapper';
+      wrapper.style.display = 'inline-block';
+      wrapper.style.transformOrigin = 'center center';
+
+      imgRoot.appendChild(wrapper);
+      wrapper.appendChild(imgEl);
+    } else if (!wrapper.contains(imgEl)) {
+      // Slide changed and BiggerPicture replaced the <img>
+      wrapper.innerHTML = '';
+      wrapper.appendChild(imgEl);
+    }
+
+    return wrapper;
+  }
+
+  function applyRotation() {
+    const wrapper = ensureRotateWrapper();
+    if (!wrapper) return;
+    wrapper.style.transform = `rotate(${currentRotation}deg)`;
+  }
+
+  function setupRotation(containerEl) {
+    activeContainer = containerEl;
+    currentRotation = 0;
+    const controls = ensureRotateControls();
+    controls.style.display = 'flex';
+    applyRotation();
+  }
+
+  function teardownRotation() {
+    activeContainer = null;
+    currentRotation = 0;
+    if (rotateControls) {
+      rotateControls.style.display = 'none';
+    }
+  }
+
+  
+  // 4) If current slide is an SVG, swap to inline + enable svg-pan-zoom
+  async function enhanceSVG(containerEl) {
+    try {
+      destroyPanZoom();
+
+      const imgEl = containerEl.querySelector('.bp-img img');
+      if (!imgEl) return;
+
+      const src = imgEl.currentSrc || imgEl.src || '';
+      const isSVG = src.toLowerCase().endsWith('.svg');
+      const htmlLayer = containerEl.querySelector('.bp-html');
+      if (!isSVG || !htmlLayer) {
+        // ensure any previous holder is removed and bitmap is visible
+        const old = htmlLayer?.querySelector('.bp-svg-holder');
+        if (old) old.remove();
+        imgEl.style.visibility = '';
+        return;
+      }
+
+      // Create/clear holder
+      let holder = htmlLayer.querySelector('.bp-svg-holder');
+      if (!holder) {
+        holder = document.createElement('div');
+        holder.className = 'bp-svg-holder';
+        holder.style.maxWidth = '95vw';
+        holder.style.maxHeight = '95vh';
+        htmlLayer.appendChild(holder);
+      }
+      holder.innerHTML = '';
+
+      // Hide the bitmap so only the inline SVG shows
+      imgEl.style.visibility = 'hidden';
+
+      // Inline the SVG
+      const res = await fetch(src, { cache: 'force-cache' });
+      const text = await res.text();
+      holder.innerHTML = text;
+
+      const svg = holder.querySelector('svg');
+      if (!svg) { imgEl.style.visibility = ''; return; }
+
+      svg.style.maxWidth  = '95vw';
+      svg.style.maxHeight = '95vh';
+      svg.style.display   = 'block';
+
+      if (typeof window.svgPanZoom === 'function') {
+        activePanZoom = svgPanZoom(svg, {
+          zoomEnabled: true,
+          controlIconsEnabled: true,
+          fit: true,
+          center: true,
+          minZoom: 0.05,
+          maxZoom: 400,          // effectively "unlimited"
+          zoomScaleSensitivity: 0.25,
+          dblClickZoomEnabled: true
+        });
+        // Keep wheel inside lightbox
+        holder.addEventListener('wheel', (e) => e.stopPropagation(), { passive: true });
+      } else {
+        console.warn('[gallery-init] svg-pan-zoom not loaded');
+      }
+    } catch (err) {
+      console.error('[gallery-init] SVG enhance failed:', err);
+    }
+  }
+});

assets/scripts/script.js

@@ -0,0 +1,434 @@
+/* =========================================================
+   BOOTSTRAP
+   ========================================================= */
+
+document.addEventListener("DOMContentLoaded", () => {
+  initCopyButtons();
+  initFootnoteSidenotes();
+  initThemeToggle();
+  initCountdowns();
+  initTOCHighlighting();
+  initStackedNavigation();
+  restoreStackFromURL();
+  initClearPanesButton();
+  initInitialPaneControls();
+
+});
+
+/* =========================================================
+   COPY BUTTONS (code blocks)
+   ========================================================= */
+
+function initCopyButtons() {
+  document.querySelectorAll("pre.src").forEach(codeBlock => {
+    if (codeBlock.querySelector(".copy-btn")) return; // idempotent
+
+    const button = document.createElement("button");
+    button.className = "copy-btn";
+    button.textContent = "Copy";
+    codeBlock.appendChild(button);
+
+    button.addEventListener("click", async () => {
+      const text = codeBlock.innerText.replace(button.innerText, "").trim();
+      try {
+        await navigator.clipboard.writeText(text);
+        button.textContent = "Copied!";
+        setTimeout(() => (button.textContent = "Copy"), 1500);
+      } catch {
+        button.textContent = "Failed";
+        setTimeout(() => (button.textContent = "Copy"), 1500);
+      }
+    });
+  });
+}
+
+/* =========================================================
+   FOOTNOTES → SIDENOTES
+   ========================================================= */
+
+function initFootnoteSidenotes() {
+  document.querySelectorAll('a.footref[href^="#fn"]').forEach(ref => {
+    const sup = ref.closest("sup") || ref;
+
+    if (sup.nextElementSibling?.classList.contains("footnote-sidenote")) return;
+
+    const targetId = ref.getAttribute("href").slice(1);
+    const anchor = document.getElementById(targetId);
+    if (!anchor) return;
+
+    const footdef = anchor.closest(".footdef") || anchor.parentElement;
+    if (!footdef) return;
+
+    let paras = footdef.querySelectorAll("p.footpara");
+    if (!paras.length) {
+      paras = footdef.querySelectorAll(".footpara:not(:has(.footpara))");
+    }
+
+    let parts = [];
+    if (paras.length) {
+      const seen = new Set();
+      parts = [...paras]
+        .map(p => {
+          const txt = p.textContent.trim().replace(/\s+/g, " ");
+          if (seen.has(txt)) return "";
+          seen.add(txt);
+          return p.innerHTML.trim();
+        })
+        .filter(Boolean);
+    }
+
+    if (!parts.length) {
+      const clone = footdef.cloneNode(true);
+      clone
+        .querySelectorAll("sup.footnum, a[role='doc-backlink']")
+        .forEach(n => n.remove());
+      parts = [clone.innerHTML.trim()];
+    }
+
+    const sidenote = document.createElement("span");
+    sidenote.className = "sidenote footnote-sidenote";
+    sidenote.dataset.fn = ref.textContent.trim();
+    sidenote.innerHTML = parts.join(" ");
+
+    sup.insertAdjacentElement("afterend", sidenote);
+  });
+}
+
+/* =========================================================
+   THEME TOGGLE
+   ========================================================= */
+
+function initThemeToggle() {
+  const root = document.documentElement;
+  const key = "theme";
+  const saved = localStorage.getItem(key);
+
+  if (saved === "dark" || saved === "light") {
+    root.setAttribute("data-theme", saved);
+  }
+
+  const btn = document.getElementById("theme-toggle");
+  if (!btn) return;
+
+  btn.addEventListener("click", () => {
+    const current = root.getAttribute("data-theme");
+    const next = current === "dark" ? "light" : "dark";
+    root.setAttribute("data-theme", next);
+    localStorage.setItem(key, next);
+  });
+}
+
+/* =========================================================
+   COUNTDOWNS
+   ========================================================= */
+
+function initCountdowns() {
+  const els = document.querySelectorAll("time.countdown");
+  if (!els.length) return;
+
+  const plural = (n, w) => `${n} ${w}${n === 1 ? "" : "s"}`;
+
+  const render = el => {
+    const raw = el.getAttribute("datetime");
+    const label = el.dataset.label || "";
+    const target = new Date(raw);
+    if (isNaN(target)) {
+      el.textContent = "—";
+      return;
+    }
+
+    let diff = target - new Date();
+    if (diff <= 0) {
+      el.textContent = `${label ? label + " " : ""}today`;
+      el.classList.add("expired");
+      return;
+    }
+
+    const d = Math.floor(diff / 86400000); diff %= 86400000;
+    const h = Math.floor(diff / 3600000);  diff %= 3600000;
+    const m = Math.floor(diff / 60000);    diff %= 60000;
+    const s = Math.floor(diff / 1000);
+
+    const parts = [];
+    if (d) parts.push(plural(d, "day"));
+    parts.push(`${h}h ${m}m ${s}s`);
+
+    el.textContent = `${label ? label + " in: " : ""}${parts.join(" ")}`;
+  };
+
+  const tick = () => els.forEach(render);
+  tick();
+  setInterval(tick, 1000);
+}
+
+/* =========================================================
+   TABLE OF CONTENTS HIGHLIGHTING
+   ========================================================= */
+
+function initTOCHighlighting() {
+  const toc = document.querySelector("#text-table-of-contents");
+  if (!toc) return;
+
+  const links = [...toc.querySelectorAll('a[href^="#"]')];
+  if (!links.length) return;
+
+  const linkById = new Map();
+  links.forEach(a => {
+    const id = decodeURIComponent(a.hash.slice(1));
+    const el = document.getElementById(id);
+    if (el) linkById.set(id, a);
+  });
+
+  const headings = [...document.querySelectorAll("h2[id], h3[id], h4[id]")]
+    .filter(h => linkById.has(h.id));
+
+  const setActive = id => {
+    links.forEach(a => {
+      const active = a.hash === `#${id}`;
+      a.classList.toggle("is-active", active);
+      a.toggleAttribute("aria-current", active);
+    });
+  };
+
+  const headerOffset =
+    6.5 * parseFloat(getComputedStyle(document.documentElement).fontSize);
+
+  const visible = new Map();
+
+  const observer = new IntersectionObserver(entries => {
+    entries.forEach(entry => {
+      const id = entry.target.id;
+      if (entry.isIntersecting) {
+        visible.set(id, entry.target.getBoundingClientRect().top - headerOffset);
+      } else {
+        visible.delete(id);
+      }
+    });
+
+    if (visible.size) {
+      const [id] = [...visible.entries()]
+        .sort((a, b) => Math.abs(a[1]) - Math.abs(b[1]))[0];
+      setActive(id);
+    }
+  }, {
+    rootMargin: `-${headerOffset}px 0px -70% 0px`,
+    threshold: [0, 0.01, 0.1]
+  });
+
+  headings.forEach(h => observer.observe(h));
+
+  toc.addEventListener("click", e => {
+    const a = e.target.closest('a[href^="#"]');
+    if (!a) return;
+    const id = decodeURIComponent(a.hash.slice(1));
+    const el = document.getElementById(id);
+    if (!el) return;
+
+    e.preventDefault();
+    el.scrollIntoView({ behavior: "smooth", block: "start" });
+    el.setAttribute("tabindex", "-1");
+    el.focus({ preventScroll: true });
+    history.pushState(null, "", `#${id}`);
+  });
+}
+
+let fullscreenSnapshot = null;
+
+
+/* =========================================================
+   STACKED NAVIGATION (PANES)
+   ========================================================= */
+
+function initStackedNavigation() {
+  document.addEventListener("click", e => {
+    const link = e.target.closest("a");
+    if (!link) return;
+
+    const href = link.getAttribute("href");
+    if (!href || href.startsWith("#")) return;
+
+    const url = new URL(href, location.href);
+    if (url.origin !== location.origin) return;
+    if (!url.pathname.endsWith(".html")) return;
+
+    e.preventDefault();
+    pushPane(url.pathname + url.hash);
+  });
+}
+
+async function pushPane(urlWithHash) {
+  const track = document.querySelector(".stack-track");
+  if (!track) return;
+
+  const existing = [...track.children].find(p => p.dataset.url === urlWithHash);
+  if (existing) {
+    existing.scrollIntoView({ behavior: "smooth", inline: "end" });
+    return;
+  }
+
+  const [url, hash] = urlWithHash.split("#");
+  const res = await fetch(url);
+  const doc = new DOMParser().parseFromString(await res.text(), "text/html");
+
+  const content = doc.querySelector("#content");
+  if (!content) return;
+
+  const pane = document.createElement("article");
+  pane.className = "stack-pane";
+  pane.dataset.url = urlWithHash;
+
+  pane.appendChild(content);
+  track.appendChild(pane);
+  pane.scrollIntoView({ behavior: "smooth", inline: "end" });
+
+  if (hash) {
+    requestAnimationFrame(() => {
+      pane.querySelector(`#${CSS.escape(hash)}`)
+        ?.scrollIntoView({ behavior: "smooth", block: "start" });
+    });
+  }
+  
+  // Find the title-section and attach event listeners to the controls
+  const titleSection = pane.querySelector(".title-section");
+  if (titleSection) {
+    const closeBtn = titleSection.querySelector(".pane-close");
+    const fullscreenBtn = titleSection.querySelector(".pane-fullscreen");
+    
+    if (closeBtn) {
+      closeBtn.addEventListener("click", () => {
+        if (document.body.classList.contains("pane-fullscreen")) {
+          exitFullscreen({ removePane: pane });
+          return;
+        }
+        pane.remove();
+        updateURL();
+      });
+    }
+    
+    if (fullscreenBtn) {
+      fullscreenBtn.addEventListener("click", () => {
+        if (pane.classList.contains("is-fullscreen")) {
+          exitFullscreen();
+        } else {
+          enterFullscreen(pane);
+        }
+      });
+    }
+  }
+  
+  updateURL();
+}
+
+function initInitialPaneControls() {
+  // Initialize controls for the initial pane (pane-root) that's already in the HTML
+  const initialPane = document.querySelector(".pane-root");
+  if (!initialPane) return;
+  
+  const titleSection = initialPane.querySelector(".title-section");
+  if (!titleSection) return;
+  
+  const closeBtn = titleSection.querySelector(".pane-close");
+  const fullscreenBtn = titleSection.querySelector(".pane-fullscreen");
+  
+  if (closeBtn) {
+    closeBtn.addEventListener("click", () => {
+      if (document.body.classList.contains("pane-fullscreen")) {
+        exitFullscreen({ removePane: initialPane });
+        return;
+      }
+      initialPane.remove();
+      updateURL();
+    });
+  }
+  
+  if (fullscreenBtn) {
+    fullscreenBtn.addEventListener("click", () => {
+      if (initialPane.classList.contains("is-fullscreen")) {
+        exitFullscreen();
+      } else {
+        enterFullscreen(initialPane);
+      }
+    });
+  }
+}
+
+document.addEventListener("keydown", e => {
+  if (e.key === "Escape" && document.body.classList.contains("pane-fullscreen")) {
+    exitFullscreen();
+  }
+});
+
+
+function enterFullscreen(pane) {
+  if (!fullscreenSnapshot) {
+    fullscreenSnapshot = [...document.querySelectorAll(".stack-pane")]
+      .map(p => p.dataset.url);
+  }
+
+  document.querySelectorAll(".stack-pane").forEach(p => {
+    if (p !== pane) p.remove();
+  });
+
+  document.body.classList.add("pane-fullscreen");
+  pane.classList.add("is-fullscreen");
+
+  updateURL();
+}
+
+
+async function exitFullscreen({ removePane } = {}) {
+  if (!fullscreenSnapshot) return;
+
+  const removeUrl = removePane?.dataset.url;
+
+  document.body.classList.remove("pane-fullscreen");
+
+  document
+    .querySelectorAll(".stack-pane.is-fullscreen")
+    .forEach(p => p.remove());
+
+  // Restore stack EXCEPT the removed pane
+  for (const url of fullscreenSnapshot) {
+    if (url === removeUrl) continue;
+    await pushPane(url);
+  }
+
+  fullscreenSnapshot = null;
+  updateURL();
+}
+
+
+function clearAllPanes() {
+  const panes = [...document.querySelectorAll(".stack-pane")];
+
+  panes.slice(1).forEach(pane => pane.remove());
+
+  updateURL();
+}
+
+function updateURL() {
+  const urls = [...document.querySelectorAll(".stack-pane")]
+    .map(p => p.dataset.url);
+
+  const params = new URLSearchParams(location.search);
+  params.set("stackedNotes", urls.join("|"));
+  history.replaceState({}, "", "?" + params.toString());
+}
+
+async function restoreStackFromURL() {
+  const params = new URLSearchParams(location.search);
+  const stack = params.get("stackedNotes");
+  if (!stack) return;
+
+  for (const url of stack.split("|").slice(1)) {
+    await pushPane(url);
+  }
+}
+function initClearPanesButton() {
+  const btn = document.getElementById("close-all");
+  if (!btn) return;
+
+  btn.addEventListener("click", () => {
+    clearAllPanes();
+  });
+}

assets/scripts/script.js~

@@ -0,0 +1,335 @@
+
+
+/* Event listener function for the COPY BUTTON */
+document.addEventListener("DOMContentLoaded", function () {
+    document.querySelectorAll("pre.src").forEach(function (codeBlock) {
+	const button = document.createElement("button");
+	button.innerText = "Copy";
+	button.className = "copy-btn";
+
+	// Append button inside <pre>
+	codeBlock.appendChild(button);
+
+	button.addEventListener("click", function () {
+	    const text = codeBlock.innerText.replace(button.innerText, ""); // exclude button text
+	    navigator.clipboard.writeText(text.trim()).then(() => {
+		button.innerText = "Copied!";
+		setTimeout(() => (button.innerText = "Copy"), 1500);
+	    });
+	});
+    });
+});
+
+
+/* Event listener for footnotes and sidenotes*/
+document.addEventListener("DOMContentLoaded", () => {
+    document.querySelectorAll('a.footref[href^="#fn"]').forEach(ref => {
+	const sup = ref.closest("sup") || ref;
+	// idempotent: don't insert twice
+	if (sup.nextElementSibling && sup.nextElementSibling.classList?.contains("footnote-sidenote")) return;
+	
+	const targetId = ref.getAttribute("href").replace(/^#/, ""); // works for fn.2 or fn2
+
+	const anchor   = document.getElementById(targetId);
+	if (!anchor) return;
+	
+	const footdef = anchor.closest(".footdef") || anchor.parentElement;
+	if (!footdef) return;
+	
+	// 1) Prefer leaf paragraphs to avoid div+p duplication
+	let paras = footdef.querySelectorAll("p.footpara");
+	if (!paras.length) {
+	    // fallback: any .footpara elements that don't contain another .footpara
+	    paras = footdef.querySelectorAll(".footpara:not(:has(.footpara))");
+	}
+
+	// 2) Build HTML, de-duplicating by text content
+	let parts = [];
+	if (paras.length) {
+	    const seen = new Set();
+	    parts = Array.from(paras).map(p => {
+		const txt = p.textContent.trim().replace(/\s+/g, " ");
+		if (seen.has(txt)) return "";
+		seen.add(txt);
+		return p.innerHTML.trim();
+	    }).filter(Boolean);
+	}
+
+	// 3) Fallback: clean full block if no paras found
+	if (!parts.length) {
+	    const clone = footdef.cloneNode(true);
+	    clone.querySelectorAll("sup.footnum, a[role='doc-backlink']").forEach(n => n.remove());
+	    parts = [clone.innerHTML.trim()];
+	}
+
+	// 4) Insert the sidenote
+	const sn = document.createElement("span");
+	sn.className = "sidenote footnote-sidenote";
+	sn.setAttribute("data-fn", (ref.textContent || "").trim());
+	sn.innerHTML = parts.join(" ");
+	
+	sup.insertAdjacentElement("afterend", sn);
+    });
+});
+
+
+/* Function for setting the theme */
+(function(){
+    const root = document.documentElement;
+    const storageKey = "theme";
+    const saved = localStorage.getItem(storageKey);
+    if (saved === "dark" || saved === "light") {
+	root.setAttribute("data-theme", saved);
+    }
+    const btn = document.getElementById("theme-toggle");
+    if (!btn) return;
+    btn.addEventListener("click", () => {
+	const current = root.getAttribute("data-theme");
+	const next = current === "dark" ? "light" : "dark";
+	// If no current (auto), assume we’re toggling to dark first
+	const target = current ? next : "dark";
+	root.setAttribute("data-theme", target);
+	localStorage.setItem(storageKey, target);
+    });
+})();
+
+
+// Simple, timezone-safe if you pass UTC (…Z) in the datetime
+document.addEventListener('DOMContentLoaded', () => {
+  const els = document.querySelectorAll('time.countdown');
+  if (!els.length) return;
+
+  const plural = (n, w) => `${n} ${w}${n === 1 ? '' : 's'}`;
+
+  const render = (el) => {
+    const raw = el.getAttribute('datetime');
+    const label = el.dataset.label || '';
+    const target = new Date(raw);           // Prefer ISO like 2025-12-31T00:00:00Z
+    if (isNaN(target)) { el.textContent = '—'; return; }
+
+    const now = new Date();
+    let diff = target - now;
+
+    if (diff <= 0) {
+      el.textContent = `${label ? label + ' ' : ''}today`;
+      el.classList.add('expired');
+      return;
+    }
+
+    const d = Math.floor(diff / 86400000);  diff -= d * 86400000;
+    const h = Math.floor(diff / 3600000);   diff -= h * 3600000;
+    const m = Math.floor(diff / 60000);     diff -= m * 60000;
+    const s = Math.floor(diff / 1000);
+
+    const pieces = [];
+    if (d) pieces.push(plural(d, 'day'));
+    pieces.push(`${h}h ${m}m ${s}s`);
+
+    el.textContent = `${label ? label + ' in : ' : ''}${pieces.join(' ')}`;
+  };
+
+  const tick = () => els.forEach(render);
+  tick();
+  setInterval(tick, 1000); // update every second
+});
+
+
+
+/* Event listener for scrolling and changing the active label on the TOC */
+document.addEventListener("DOMContentLoaded", () => {
+    const toc = document.querySelector("#text-table-of-contents");
+    if (!toc) { console.warn("No #text-table-of-contents found"); return; }
+
+    const links = toc.querySelectorAll('a[href^="#"]'); // '^=' is a starts with operator.
+    // <a href="#introduction">Intro</a>   matches  
+    if (!links.length) { console.warn("No ToC links found"); return; }
+
+    // Map: id -> link
+    const linkById = new Map();
+    links.forEach(a => {
+	const id = decodeURIComponent(a.getAttribute("href").slice(1));
+	const el = document.getElementById(id);
+	if (el) linkById.set(id, a);
+    });
+    if (!linkById.size) { console.warn("No matching headings with IDs"); return; }
+
+    // Headings to observe (h2–h4 usually)
+    const headings = [...document.querySelectorAll("h2[id], h3[id], h4[id]")]
+	  .filter(h => linkById.has(h.id));
+
+    // Helper to mark active
+    const setActive = (id) => {
+	links.forEach(a => {
+	    const active = a.getAttribute("href") === `#${id}`;
+	    a.classList.toggle("is-active", active);
+	    if (active) a.setAttribute("aria-current", "true");
+	    else a.removeAttribute("aria-current");
+	});
+    };
+
+    // Calculate sticky header offset in px
+    const headerOffsetPx = 6.5 * parseFloat(getComputedStyle(document.documentElement).fontSize);
+
+    // Track visible headings (id -> distance from top)
+    const visible = new Map();
+
+    const observer = new IntersectionObserver((entries) => {
+	entries.forEach(entry => {
+	    const id = entry.target.id;
+	    if (entry.isIntersecting) {
+		// How far from the top (after header offset)
+		const dist = entry.target.getBoundingClientRect().top - headerOffsetPx;
+		visible.set(id, dist);
+	    } else {
+		visible.delete(id);
+	    }
+	});
+	
+	if (visible.size) {
+	    // Choose the heading closest to the top (>= -headerOffset)
+	    const topMost = [...visible.entries()]
+		  .sort((a,b) => Math.abs(a[1]) - Math.abs(b[1]))[0][0];
+	    setActive(topMost);
+	    // console.log("Active:", topMost, visible);
+	}
+    }, {
+	root: null,                                   // track relative to viewport
+	rootMargin: `-${headerOffsetPx}px 0px -70% 0px`,
+	threshold: [0, 0.01, 0.1]                     // fire as soon as it enters
+    });
+    
+    headings.forEach(h => observer.observe(h));
+
+    // Initial highlight (in case load mid‑page)
+    let bestId = null, bestDist = Infinity;
+    headings.forEach(h => {
+	const top = h.getBoundingClientRect().top - headerOffsetPx;
+	const dist = top < 0 ? Math.abs(top) : top + 1e6;
+	if (dist < bestDist) { bestDist = dist; bestId = h.id; }
+    });
+    if (bestId) setActive(bestId);
+    
+    // smooth-scroll ToC clicks
+    toc.addEventListener("click", (e) => {
+	const a = e.target.closest('a[href^="#"]');
+	if (!a) return;
+	const id = decodeURIComponent(a.hash.slice(1));
+	const el = document.getElementById(id);
+	if (!el) return;
+	e.preventDefault();
+	el.scrollIntoView({ behavior: "smooth", block: "start" });
+	el.setAttribute("tabindex", "-1");
+	el.focus({ preventScroll: true });
+	history.pushState(null, "", `#${id}`);
+    });
+});
+
+
+document.addEventListener("click", (e) => {
+  const link = e.target.closest("a");
+  if (!link) return;
+
+  const href = link.getAttribute("href");
+  if (!href) return;
+
+  // Ignore pure fragment links (#foo)
+  if (href.startsWith("#")) return;
+
+  // Resolve relative → absolute
+  const url = new URL(href, window.location.href);
+
+  // Only intercept same-origin HTML pages
+  if (url.origin !== window.location.origin) return;
+  if (!url.pathname.endsWith(".html")) return;
+
+  e.preventDefault();
+
+  pushPane(url.pathname + url.hash);
+});
+
+async function pushPane(urlWithHash) {
+  const [url, hash] = urlWithHash.split("#");
+
+  const track = document.querySelector(".stack-track");
+
+const existing = [...track.children].find(p => p.dataset.url === urlWithHash);
+if (existing) {
+  existing.scrollIntoView({ behavior: "smooth", inline: "end" });
+  return;
+}
+  const res = await fetch(url);
+  const html = await res.text();
+  const doc = new DOMParser().parseFromString(html, "text/html");
+
+  const content = doc.querySelector("#content");
+  if (!content) return;
+
+  const pane = document.createElement("article");
+  pane.className = "stack-pane";
+  pane.dataset.url = urlWithHash;
+  
+  pane.innerHTML = `
+  <div class="pane-header">
+    <button class="pane-close" aria-label="Close pane">×</button>
+  </div>
+`;
+
+  pane.appendChild(content);
+  track.appendChild(pane);
+  pane.scrollIntoView({ behavior: "smooth", inline: "end" });
+
+  // Scroll to the anchor if present
+  if (hash) {
+    requestAnimationFrame(() => {
+      const target = pane.querySelector(`#${CSS.escape(hash)}`);
+      target?.scrollIntoView({ behavior: "smooth", block: "start" });
+    });
+  }
+pane.querySelector(".pane-close").addEventListener("click", () => {
+  pane.remove();
+  updateURL();
+});
+
+  updateURL();
+}
+
+function updateURL() {
+  const panes = [...document.querySelectorAll(".stack-pane")];
+
+  const urls = panes.map(p => p.dataset.url);
+
+  const params = new URLSearchParams(window.location.search);
+  params.set("stackedNotes", urls.join("|"));
+
+  history.replaceState({}, "", "?" + params.toString());
+}
+
+window.addEventListener("DOMContentLoaded", async () => {
+  const params = new URLSearchParams(window.location.search);
+  const stack = params.get("stackedNotes");
+  if (!stack) return;
+
+  const urls = stack.split("|");
+
+  // First pane is already rendered by Org
+  const base = urls[0];
+  const current = window.location.pathname + window.location.hash;
+
+  // Only continue if URL matches base
+  if (base !== current && !base.startsWith(window.location.pathname)) {
+    console.warn("Stack base mismatch:", base, current);
+    return;
+  }
+
+  // Load remaining panes sequentially
+  for (const url of urls.slice(1)) {
+    await pushPane(url);
+  }
+
+  // Scroll to last pane
+  const panes = document.querySelectorAll(".stack-pane");
+  panes[panes.length - 1]?.scrollIntoView({
+    behavior: "auto",
+    inline: "end"
+  });
+});

assets/scripts/search.js

@@ -0,0 +1,180 @@
+/* =========================================================
+   STATE
+   ========================================================= */
+
+let index = [];
+let activeIndex = -1;
+
+const box = document.getElementById("search-box");
+const results = document.getElementById("search-results");
+
+/* =========================================================
+   LOAD SEARCH INDEX
+   ========================================================= */
+
+fetch("/search-index.json")
+  .then(r => r.json())
+  .then(data => {
+    index = Array.isArray(data) ? data : [];
+  })
+  .catch(err => {
+    console.error("Failed to load search index:", err);
+  });
+
+/* =========================================================
+   RENDER RESULTS
+   ========================================================= */
+
+function renderResults(items) {
+  clearResults();
+
+  items.forEach((entry, i) => {
+    const row = document.createElement("div");
+    row.dataset.index = i;
+
+    const link = document.createElement("a");
+    link.href = entry.url;
+    link.textContent = entry.title;
+
+    link.addEventListener("click", ev => {
+      ev.preventDefault();
+      ev.stopPropagation();
+      clearSearch();
+      pushPane(entry.url);
+    });
+
+    row.appendChild(link);
+
+    row.addEventListener("mouseenter", () => setActive(i));
+    row.addEventListener("mouseleave", clearActive);
+
+    results.appendChild(row);
+  });
+}
+
+/* =========================================================
+   ACTIVE ITEM HANDLING
+   ========================================================= */
+
+function setActive(i) {
+  const items = [...results.children];
+
+  items.forEach(el => el.classList.remove("active"));
+
+  if (items[i]) {
+    items[i].classList.add("active");
+    activeIndex = i;
+  }
+}
+
+function clearActive() {
+  [...results.children].forEach(el => el.classList.remove("active"));
+  activeIndex = -1;
+}
+
+/* =========================================================
+   INPUT HANDLER
+   ========================================================= */
+
+box.addEventListener("input", () => {
+  const query = box.value.trim().toLowerCase();
+
+  clearResults();
+  if (query.length < 2) return;
+
+  const matches = index
+    .map(entry => ({
+      ...entry,
+      score: fuzzyScore(query, entry.title)
+    }))
+    .filter(entry => entry.score > 0)
+    .sort((a, b) => b.score - a.score)
+    .slice(0, 20); // optional cap
+
+  renderResults(matches);
+});
+
+/* =========================================================
+   KEYBOARD NAVIGATION
+   ========================================================= */
+
+box.addEventListener("keydown", e => {
+  const items = [...results.children];
+  if (!items.length) return;
+
+  switch (e.key) {
+    case "ArrowDown":
+      e.preventDefault();
+      setActive((activeIndex + 1) % items.length);
+      break;
+
+    case "ArrowUp":
+      e.preventDefault();
+      setActive((activeIndex - 1 + items.length) % items.length);
+      break;
+
+    case "Enter":
+      if (activeIndex < 0) return;
+
+      e.preventDefault();
+      e.stopPropagation();
+
+      const link = items[activeIndex].querySelector("a");
+      if (link) {
+        clearSearch();
+        pushPane(link.getAttribute("href"));
+      }
+      break;
+
+    case "Escape":
+      clearSearch();
+      break;
+  }
+});
+
+/* =========================================================
+   CLICK OUTSIDE TO CLOSE
+   ========================================================= */
+
+document.addEventListener("click", e => {
+  if (!e.target.closest(".banner-search")) {
+    clearSearch();
+  }
+});
+
+/* =========================================================
+   HELPERS
+   ========================================================= */
+
+function clearResults() {
+  results.innerHTML = "";
+}
+
+function clearSearch() {
+  clearResults();
+  activeIndex = -1;
+}
+function fuzzyScore(query, text) {
+  query = query.toLowerCase();
+  text = text.toLowerCase();
+
+  let score = 0;
+  let qi = 0;
+  let consecutive = 0;
+
+  for (let ti = 0; ti < text.length && qi < query.length; ti++) {
+    if (text[ti] === query[qi]) {
+      qi++;
+      consecutive++;
+      score += 5 + consecutive * 2; // reward runs
+    } else {
+      consecutive = 0;
+    }
+  }
+
+  if (qi !== query.length) return 0;
+
+  score += Math.max(0, 20 - text.length);
+
+  return score;
+}

assets/scripts/search.js~

@@ -0,0 +1,34 @@
+let index = [];
+
+fetch("/search-index.json")
+  .then(r => r.json())
+  .then(data => index = data);
+
+const box = document.getElementById("search-box");
+const results = document.getElementById("search-results");
+
+
+document.addEventListener("click", (e) => {
+  const searchBox = document.getElementById("search-box");
+  const results = document.getElementById("search-results");
+
+});
+
+
+box.addEventListener("input", () => {
+  const q = box.value.toLowerCase();
+  results.innerHTML = "";
+
+  if (q.length < 2) return;
+
+  index
+    .filter(e =>
+      e.title.toLowerCase().includes(q) 
+    )
+    //.slice(0, 10)
+    .forEach(e => {
+      const div = document.createElement("div");
+      div.innerHTML = `<a href="${e.url}">${e.title}</a>`;
+      results.appendChild(div);
+    });
+});