jekyll-dice-tray 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 808fa6526e8321dc1118a09748a1e24818889bf88af1ecdf729b9a423c6b7291
+  data.tar.gz: d56b7f208211cb62b0ec536c41fc2a51d74756b99fbbbed4a9db6c10e42204cb
+SHA512:
+  metadata.gz: e58e36fe768267500d132ec2a7d293ed49ef84421ddf39738bde6e1ef4f0d36d38cfee77f8322c00474888c567a20ba4285a6b2772f905c8b502c6527bbdffd3
+  data.tar.gz: fd4dc912ec0a339d843d3cedde8c33c418f0804e3b4db2609025e9dd49e8ec181c6a339ae37232d802979f8f274aa9c242430d3b912f68c0197d2ae035b008ba

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 directsun
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,37 @@
+# jekyll-dice-tray
+
+A Jekyll plugin gem that:
+
+- Adds an overlay dice tray that accepts dice rolling input
+- Recognizes dice expressions in rendered pages like `d4`, `1d6`, `1d20+1` and turns them into clickable links that roll in the tray
+- Recognizes THAC0-style bracket modifiers like `THAC0 18 [+1]` or `18 [+1]` in a THAC0 table row/column; the `+1` inside the brackets is clickable and rolls `d20+1` (other `[+n]` text is left alone)
+- Persists input history, result history, minimize status
+- `/help` - help
+- `/clear` - clears results and input history
+
+## Install
+
+Add to your site `Gemfile`:
+
+```ruby
+gem "jekyll-dice-tray"
+```
+
+Then in `_config.yml`:
+
+```yml
+plugins:
+  - jekyll-dice-tray
+```
+
+## Configuration
+
+Optional `_config.yml` settings:
+
+```yml
+dice_tray:
+  enabled: true
+  assets_path: /assets/jekyll-dice-tray
+  inject_tray: true
+  link_dice_in_markdown: true
+```

data/assets/jekyll-dice-tray/dice_tray.css

@@ -0,0 +1,183 @@
+.jekyll-dice-tray-hidden {
+  display: none !important;
+}
+
+#jekyll-dice-tray {
+  position: fixed;
+  right: 16px;
+  bottom: 16px;
+  z-index: 2147483647;
+  width: 320px;
+  max-width: calc(100vw - 32px);
+  font-family: system-ui, -apple-system, Segoe UI, Roboto, Ubuntu, Cantarell, Noto Sans, sans-serif;
+}
+
+#jekyll-dice-tray .jdt-header {
+  display: flex;
+  justify-content: flex-end;
+}
+
+#jekyll-dice-tray .jdt-toggle {
+  border: 1px solid rgba(0, 0, 0, 0.2);
+  background: rgba(255, 255, 255, 0.95);
+  color: #111;
+  border-radius: 999px;
+  padding: 8px 12px;
+  cursor: pointer;
+  box-shadow: 0 8px 24px rgba(0, 0, 0, 0.18);
+}
+
+#jekyll-dice-tray .jdt-body {
+  margin-top: 10px;
+  border: 1px solid rgba(0, 0, 0, 0.12);
+  background: rgba(255, 255, 255, 0.98);
+  border-radius: 12px;
+  box-shadow: 0 18px 48px rgba(0, 0, 0, 0.22);
+  overflow: hidden;
+  display: flex;
+  flex-direction: column;
+  max-height: 360px;
+}
+
+#jekyll-dice-tray[data-expanded="false"] .jdt-body {
+  display: none;
+}
+
+#jekyll-dice-tray .jdt-clue {
+  padding: 10px 12px 0 12px;
+  color: rgba(0, 0, 0, 0.55);
+  font-size: 12px;
+  line-height: 1.35;
+}
+
+#jekyll-dice-tray .jdt-clue code {
+  background: rgba(0, 0, 0, 0.05);
+  padding: 1px 4px;
+  border-radius: 6px;
+}
+
+#jekyll-dice-tray .jdt-input {
+  width: calc(100% - 24px);
+  margin: 10px 12px 12px 12px;
+  padding: 10px 10px;
+  border: 1px solid rgba(0, 0, 0, 0.15);
+  border-radius: 10px;
+  font-size: 14px;
+}
+
+#jekyll-dice-tray .jdt-log {
+  flex: 1 1 auto;
+  min-height: 120px;
+  overflow: auto;
+  padding: 0 12px 0 12px;
+}
+
+#jekyll-dice-tray .jdt-entry {
+  border-top: 1px solid rgba(0, 0, 0, 0.06);
+  padding: 8px 0;
+  font-size: 13px;
+}
+
+#jekyll-dice-tray .jdt-entry:first-child {
+  border-top: none;
+}
+
+#jekyll-dice-tray .jdt-entry .jdt-expr {
+  color: rgba(0, 0, 0, 0.6);
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+}
+
+#jekyll-dice-tray .jdt-entry .jdt-total {
+  font-weight: 700;
+  margin-left: 8px;
+}
+
+#jekyll-dice-tray .jdt-result {
+  margin-top: 4px;
+  font-size: 13px;
+}
+
+#jekyll-dice-tray .jdt-result strong {
+  font-weight: 800;
+}
+
+#jekyll-dice-tray .jdt-result .jdt-rolls {
+  color: rgba(0, 0, 0, 0.6);
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+}
+
+#jekyll-dice-tray .jdt-result .jdt-loser {
+  color: rgba(0, 0, 0, 0.42);
+}
+
+#jekyll-dice-tray .jdt-result .jdt-vs-sep {
+  color: rgba(0, 0, 0, 0.45);
+}
+
+#jekyll-dice-tray .jdt-entry .jdt-details {
+  margin-top: 4px;
+  color: rgba(0, 0, 0, 0.55);
+  font-size: 12px;
+}
+
+a.dice-tray-roll {
+  text-decoration: underline;
+  text-underline-offset: 2px;
+  color: #ff0000;
+}
+
+a.dice-tray-roll:visited {
+  color: #ff0000;
+}
+
+@media (prefers-color-scheme: dark) {
+  #jekyll-dice-tray .jdt-toggle {
+    border-color: rgba(255, 255, 255, 0.18);
+    background: rgba(22, 22, 22, 0.96);
+    color: #f2f2f2;
+  }
+
+  #jekyll-dice-tray .jdt-body {
+    border-color: rgba(255, 255, 255, 0.12);
+    background: rgba(22, 22, 22, 0.98);
+  }
+
+  #jekyll-dice-tray .jdt-clue {
+    color: rgba(255, 255, 255, 0.6);
+  }
+
+  #jekyll-dice-tray .jdt-clue code {
+    background: rgba(255, 255, 255, 0.08);
+  }
+
+  #jekyll-dice-tray .jdt-input {
+    background: rgba(0, 0, 0, 0.2);
+    border-color: rgba(255, 255, 255, 0.12);
+    color: #f2f2f2;
+  }
+
+  #jekyll-dice-tray .jdt-entry {
+    border-top-color: rgba(255, 255, 255, 0.08);
+  }
+
+  #jekyll-dice-tray .jdt-entry .jdt-expr {
+    color: rgba(255, 255, 255, 0.65);
+  }
+
+  #jekyll-dice-tray .jdt-entry .jdt-details {
+    color: rgba(255, 255, 255, 0.6);
+  }
+
+  #jekyll-dice-tray .jdt-result .jdt-rolls {
+    color: rgba(255, 255, 255, 0.65);
+  }
+
+  #jekyll-dice-tray .jdt-result .jdt-loser {
+    color: rgba(255, 255, 255, 0.45);
+  }
+
+  #jekyll-dice-tray .jdt-result .jdt-vs-sep {
+    color: rgba(255, 255, 255, 0.48);
+  }
+}
+

data/assets/jekyll-dice-tray/dice_tray.js

@@ -0,0 +1,483 @@
+(function () {
+  "use strict";
+
+  var STORAGE_PREFIX = "jekyll_dice_tray:";
+  var STORAGE_EXPANDED = STORAGE_PREFIX + "expanded";
+  var STORAGE_HISTORY = STORAGE_PREFIX + "history_v1";
+  var STORAGE_INPUT_HISTORY = STORAGE_PREFIX + "input_history_v1";
+
+  function qs(sel, root) {
+    return (root || document).querySelector(sel);
+  }
+
+  function el(tag, attrs, text) {
+    var n = document.createElement(tag);
+    if (attrs) {
+      Object.keys(attrs).forEach(function (k) {
+        n.setAttribute(k, attrs[k]);
+      });
+    }
+    if (text != null) n.textContent = text;
+    return n;
+  }
+
+  function nowTime() {
+    try {
+      return new Date().toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+    } catch (_) {
+      return new Date().toLocaleTimeString();
+    }
+  }
+
+  function randInt(min, max) {
+    min = Math.ceil(min);
+    max = Math.floor(max);
+    var span = max - min + 1;
+    if (span <= 0) return min;
+
+    if (window.crypto && window.crypto.getRandomValues) {
+      var arr = new Uint32Array(1);
+      window.crypto.getRandomValues(arr);
+      return min + (arr[0] % span);
+    }
+    return min + Math.floor(Math.random() * span);
+  }
+
+  function parseExpr(input) {
+    var s = String(input || "").trim();
+    if (!s) return { kind: "empty" };
+    if (s === "/help") return { kind: "help" };
+    if (s === "/clear") return { kind: "clear" };
+
+    // Allow whitespace variations like "d20 + 2"
+    var compact = s.replace(/\s+/g, "");
+
+    // Advantage/Disadvantage roll:
+    // - "d12+d6(+2)" => take higher of the two totals
+    // - "d12-d6(+2)" => take lower of the two totals
+    // Modifier applies after choosing.
+    // Only allow single-die expressions on each side: dX+dY or dX-dY (no leading counts).
+    var best = compact.match(/^d(\d{1,4})([+-])d(\d{1,4})([+-]\d{1,5})?$/i);
+    if (best) {
+      var c1 = 1;
+      var s1 = parseInt(best[1], 10);
+      var op = best[2]; // "+" => take higher, "-" => take lower
+      var c2 = 1;
+      var s2 = parseInt(best[3], 10);
+      var modB = best[4] ? parseInt(best[4], 10) : 0;
+
+      if (!Number.isFinite(c1) || !Number.isFinite(s1) || !Number.isFinite(c2) || !Number.isFinite(s2) || !Number.isFinite(modB)) {
+        return { kind: "invalid", raw: s };
+      }
+      if (c1 < 1) c1 = 1;
+      if (c1 > 100) c1 = 100;
+      if (s1 < 2) s1 = 2;
+      if (s1 > 10000) s1 = 10000;
+      if (c2 < 1) c2 = 1;
+      if (c2 > 100) c2 = 100;
+      if (s2 < 2) s2 = 2;
+      if (s2 > 10000) s2 = 10000;
+      if (modB < -100000) modB = -100000;
+      if (modB > 100000) modB = 100000;
+
+      var left = "d" + String(s1);
+      var right = "d" + String(s2);
+      var normalizedB = left + op + right + (modB ? (modB > 0 ? "+" + modB : "" + modB) : "");
+      return {
+        kind: "bestof2",
+        left: { count: c1, sides: s1 },
+        right: { count: c2, sides: s2 },
+        op: op,
+        mod: modB,
+        normalized: normalizedB,
+      };
+    }
+
+    var m = compact.match(/^(\d{0,3})d(\d{1,4})([+-]\d{1,5})?$/i);
+    if (!m) return { kind: "invalid", raw: s };
+
+    var count = m[1] ? parseInt(m[1], 10) : 1;
+    var sides = parseInt(m[2], 10);
+    var mod = m[3] ? parseInt(m[3], 10) : 0;
+
+    if (!Number.isFinite(count) || !Number.isFinite(sides) || !Number.isFinite(mod)) {
+      return { kind: "invalid", raw: s };
+    }
+    if (count < 1) count = 1;
+    if (count > 100) count = 100;
+    if (sides < 2) sides = 2;
+    if (sides > 10000) sides = 10000;
+    if (mod < -100000) mod = -100000;
+    if (mod > 100000) mod = 100000;
+
+    var normalized = String(count) + "d" + String(sides) + (mod ? (mod > 0 ? "+" + mod : "" + mod) : "");
+    return { kind: "roll", count: count, sides: sides, mod: mod, normalized: normalized };
+  }
+
+  function rollDice(count, sides) {
+    var rolls = [];
+    var total = 0;
+    for (var i = 0; i < count; i++) {
+      var r = randInt(1, sides);
+      rolls.push(r);
+      total += r;
+    }
+    return { rolls: rolls, total: total };
+  }
+
+  function mountTray(root) {
+    var toggle = qs(".jdt-toggle", root);
+    var body = qs(".jdt-body", root);
+    var input = qs(".jdt-input", root);
+    var log = qs(".jdt-log", root);
+
+    function loadBool(key, fallback) {
+      try {
+        var v = localStorage.getItem(key);
+        if (v === null) return fallback;
+        return v === "true";
+      } catch (_) {
+        return fallback;
+      }
+    }
+
+    function saveBool(key, val) {
+      try {
+        localStorage.setItem(key, val ? "true" : "false");
+      } catch (_) {}
+    }
+
+    function loadHistory() {
+      try {
+        var raw = localStorage.getItem(STORAGE_HISTORY);
+        if (!raw) return [];
+        var parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed : [];
+      } catch (_) {
+        return [];
+      }
+    }
+
+    function loadInputHistory() {
+      try {
+        var raw = localStorage.getItem(STORAGE_INPUT_HISTORY);
+        if (!raw) return [];
+        var parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed : [];
+      } catch (_) {
+        return [];
+      }
+    }
+
+    function saveInputHistory(items) {
+      try {
+        localStorage.setItem(STORAGE_INPUT_HISTORY, JSON.stringify(items));
+      } catch (_) {}
+    }
+
+    function saveHistory(items) {
+      try {
+        localStorage.setItem(STORAGE_HISTORY, JSON.stringify(items));
+      } catch (_) {}
+    }
+
+    var history = loadHistory();
+    var inputHistory = loadInputHistory();
+    var inputHistoryIdx = inputHistory.length; // points just past last
+
+    function clearStorageAndUi() {
+      try {
+        // clear dice tray history
+        localStorage.removeItem(STORAGE_HISTORY);
+        // clear input history (up-arrow)
+        localStorage.removeItem(STORAGE_INPUT_HISTORY);
+      } catch (_) {}
+
+      history = [];
+      inputHistory = [];
+      inputHistoryIdx = 0;
+      log.innerHTML = "";
+
+      // Confirmation (not persisted); keep current expanded/minimized state
+      var entry = el("div", { class: "jdt-entry", title: "/clear" });
+      entry.appendChild(el("div", { class: "jdt-expr" }, "Cleared dice tray history and input history."));
+      entry.appendChild(el("div", { class: "jdt-details" }, nowTime()));
+      log.appendChild(entry);
+      log.scrollTop = log.scrollHeight;
+    }
+
+    function setExpanded(expanded) {
+      toggle.setAttribute("aria-expanded", expanded ? "true" : "false");
+      root.setAttribute("data-expanded", expanded ? "true" : "false");
+      // Some themes override [hidden], so enforce display too.
+      body.hidden = !expanded;
+      body.style.display = expanded ? "" : "none";
+      saveBool(STORAGE_EXPANDED, expanded);
+      if (expanded) {
+        setTimeout(function () {
+          input && input.focus();
+        }, 0);
+      }
+    }
+
+    function renderHistory() {
+      log.innerHTML = "";
+      history.forEach(function (item) {
+        if (!item || typeof item !== "object") return;
+        if (item.kind === "system") {
+          addSystemEntry(item.title || "", item.body || "", item.time || "");
+        } else if (item.kind === "bestof2") {
+          addBestOf2Entry(
+            item.expr || "",
+            item.chosen_total,
+            item.left_rolls || [],
+            item.right_rolls || [],
+            !!item.left_is_winner,
+            item.left_label || "",
+            item.right_label || "",
+            item.mod || 0,
+            item.time || "",
+            item.mode || "high"
+          );
+        } else if (item.kind === "roll") {
+          addRollEntry(item.expr || "", item.total, item.rolls || [], item.mod || 0, item.time || "");
+        }
+      });
+      log.scrollTop = log.scrollHeight;
+    }
+
+    function pushHistory(item) {
+      history.push(item);
+      // keep it bounded
+      if (history.length > 200) history = history.slice(history.length - 200);
+      saveHistory(history);
+    }
+
+    function addSystemEntry(title, body, timeStr) {
+      var entry = el("div", { class: "jdt-entry" });
+      entry.appendChild(el("div", { class: "jdt-expr" }, title));
+      if (body) entry.appendChild(el("div", { class: "jdt-details" }, body));
+      entry.appendChild(el("div", { class: "jdt-details" }, timeStr));
+      log.appendChild(entry); // newest at bottom
+      log.scrollTop = log.scrollHeight;
+
+      pushHistory({ kind: "system", title: title, body: body, time: timeStr });
+    }
+
+    function addRollEntry(expr, total, rolls, mod, timeStr) {
+      var entry = el("div", { class: "jdt-entry", title: expr });
+      // expression
+      //entry.appendChild(el("div", { class: "jdt-expr" }, expr));
+
+      var result = el("div", { class: "jdt-result" });
+      result.appendChild(el("strong", null, String(total)));
+      var rollsText = "[" + rolls.join(", ") + "]";
+      if (mod) {
+        rollsText += " " + (mod > 0 ? "+" + mod : "" + mod);
+      }
+      result.appendChild(el("span", { class: "jdt-rolls" }, " " + rollsText));
+
+      // result
+      entry.appendChild(result);
+
+      // time
+      //entry.appendChild(el("div", { class: "jdt-details" }, timeStr));
+      log.appendChild(entry); // newest at bottom
+      log.scrollTop = log.scrollHeight;
+
+      pushHistory({ kind: "roll", expr: expr, total: total, rolls: rolls, mod: mod, time: timeStr });
+    }
+
+    function addBestOf2Entry(expr, chosenTotal, leftRolls, rightRolls, leftIsWinner, leftLabel, rightLabel, mod, timeStr, mode) {
+      var entry = el("div", { class: "jdt-entry", title: expr });
+      entry.appendChild(el("div", { class: "jdt-expr" }, expr));
+
+      var result = el("div", { class: "jdt-result" });
+      result.appendChild(el("strong", null, String(chosenTotal)));
+
+      // Single bracket containing both pools in left->right order.
+      var bracket = el("span", { class: "jdt-rolls" }, " [");
+      var leftSpan = el("span", { class: "jdt-vs-part" }, leftRolls.join(", "));
+      leftSpan.setAttribute("title", leftLabel);
+      if (!leftIsWinner) leftSpan.className += " jdt-loser";
+      bracket.appendChild(leftSpan);
+
+      bracket.appendChild(el("span", { class: "jdt-vs-sep" }, ", "));
+
+      var rightSpan = el("span", { class: "jdt-vs-part" }, rightRolls.join(", "));
+      rightSpan.setAttribute("title", rightLabel);
+      if (leftIsWinner) rightSpan.className += " jdt-loser";
+      bracket.appendChild(rightSpan);
+
+      bracket.appendChild(el("span", null, "]"));
+      bracket.setAttribute("title", mode === "low" ? "Take lower" : "Take higher");
+      result.appendChild(bracket);
+
+      if (mod) {
+        result.appendChild(el("span", { class: "jdt-rolls" }, " " + (mod > 0 ? "+" + mod : "" + mod)));
+      }
+
+      entry.appendChild(result);
+      entry.appendChild(el("div", { class: "jdt-details" }, timeStr));
+
+      log.appendChild(entry);
+      log.scrollTop = log.scrollHeight;
+
+      pushHistory({
+        kind: "bestof2",
+        expr: expr,
+        chosen_total: chosenTotal,
+        left_rolls: leftRolls,
+        right_rolls: rightRolls,
+        left_is_winner: leftIsWinner,
+        left_label: leftLabel,
+        right_label: rightLabel,
+        mode: mode,
+        mod: mod,
+        time: timeStr,
+      });
+    }
+
+    function showHelp() {
+      addSystemEntry(
+        "Usage: 1d6, d4, 2d8+1",
+        "Click linked dice like 1d20+5 or bracket modifiers like [+1] (rolls d20+1). Commands: /help, /clear",
+        nowTime()
+      );
+    }
+
+    function doRoll(raw) {
+      var p = parseExpr(raw);
+      if (p.kind === "empty") return;
+      if (p.kind === "help") return showHelp();
+      if (p.kind === "clear") return clearStorageAndUi();
+      if (p.kind !== "roll" && p.kind !== "bestof2") {
+        addSystemEntry("Unrecognized roll: " + p.raw, "Try: 1d6, d4, 2d8+1 or /help", nowTime());
+        return;
+      }
+
+      if (p.kind === "bestof2") {
+        var left = rollDice(p.left.count, p.left.sides);
+        var right = rollDice(p.right.count, p.right.sides);
+        var leftLabel = String(p.left.count) + "d" + String(p.left.sides);
+        var rightLabel = String(p.right.count) + "d" + String(p.right.sides);
+
+        var mode = p.op === "-" ? "low" : "high";
+        var leftIsWinner = mode === "low" ? left.total <= right.total : left.total >= right.total;
+        var chosenPreMod = leftIsWinner ? left.total : right.total;
+        var chosenTotal = chosenPreMod + p.mod;
+
+        addBestOf2Entry(
+          p.normalized,
+          chosenTotal,
+          left.rolls,
+          right.rolls,
+          leftIsWinner,
+          leftLabel,
+          rightLabel,
+          p.mod,
+          nowTime(),
+          mode
+        );
+        return;
+      }
+
+      var r = rollDice(p.count, p.sides);
+      var total = r.total + p.mod;
+      addRollEntry(p.normalized, total, r.rolls, p.mod, nowTime());
+    }
+
+    toggle.addEventListener("click", function () {
+      var expanded = toggle.getAttribute("aria-expanded") === "true";
+      setExpanded(!expanded);
+    });
+
+    input.addEventListener("keydown", function (e) {
+      if (e.key !== "Enter") return;
+      var v = input.value;
+      input.value = "";
+      setExpanded(true);
+
+      var raw = String(v || "").trim();
+      if (raw) {
+        if (inputHistory.length === 0 || inputHistory[inputHistory.length - 1] !== raw) {
+          inputHistory.push(raw);
+          if (inputHistory.length > 100) inputHistory = inputHistory.slice(inputHistory.length - 100);
+          saveInputHistory(inputHistory);
+        }
+      }
+      inputHistoryIdx = inputHistory.length;
+
+      doRoll(v);
+    });
+
+    input.addEventListener("keydown", function (e) {
+      if (e.key !== "Escape") return;
+      setExpanded(false);
+    });
+
+    input.addEventListener("keydown", function (e) {
+      if (e.key !== "ArrowUp" && e.key !== "ArrowDown") return;
+      if (!inputHistory || inputHistory.length === 0) return;
+      e.preventDefault();
+
+      if (e.key === "ArrowUp") {
+        inputHistoryIdx = Math.max(0, inputHistoryIdx - 1);
+        input.value = inputHistory[inputHistoryIdx] || "";
+      } else {
+        inputHistoryIdx = Math.min(inputHistory.length, inputHistoryIdx + 1);
+        input.value = inputHistoryIdx === inputHistory.length ? "" : inputHistory[inputHistoryIdx] || "";
+      }
+      setTimeout(function () {
+        try {
+          input.setSelectionRange(input.value.length, input.value.length);
+        } catch (_) {}
+      }, 0);
+    });
+
+    input.addEventListener("input", function () {
+      inputHistoryIdx = inputHistory.length;
+    });
+
+    document.addEventListener("click", function (e) {
+      var a = e.target && e.target.closest ? e.target.closest("a.dice-tray-roll") : null;
+      if (!a) return;
+      var expr = a.getAttribute("data-dice") || a.textContent;
+      if (!expr) return;
+      e.preventDefault();
+      setExpanded(true);
+      doRoll(expr);
+    });
+
+    // Public API
+    window.JekyllDiceTray = {
+      roll: function (expr) {
+        setExpanded(true);
+        doRoll(expr);
+      },
+      open: function () {
+        setExpanded(true);
+      },
+      close: function () {
+        setExpanded(false);
+      },
+    };
+
+    // hydrate history and persisted expanded state (default minimized)
+    renderHistory();
+    setExpanded(loadBool(STORAGE_EXPANDED, false));
+  }
+
+  function boot() {
+    var root = document.getElementById("jekyll-dice-tray");
+    if (!root) return;
+    mountTray(root);
+  }
+
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", boot);
+  } else {
+    boot();
+  }
+})();
+

data/lib/jekyll/dice_tray/asset_file.rb

@@ -0,0 +1,18 @@
+module Jekyll
+  module DiceTray
+    class AssetFile < Jekyll::StaticFile
+      def initialize(site, base, dir, name, source_path:)
+        super(site, base, dir, name)
+        @source_path = source_path
+      end
+
+      def write(dest)
+        dest_path = destination(dest)
+        FileUtils.mkdir_p(File.dirname(dest_path))
+        FileUtils.cp(@source_path, dest_path)
+        true
+      end
+    end
+  end
+end
+

data/lib/jekyll/dice_tray/generator.rb

@@ -0,0 +1,35 @@
+module Jekyll
+  module DiceTray
+    class Generator < Jekyll::Generator
+      safe true
+      priority :low
+
+      def generate(site)
+        cfg = (site.config["dice_tray"] || {})
+        return if cfg["enabled"] == false
+
+        assets_path = cfg["assets_path"] || "/assets/jekyll-dice-tray"
+        assets_path = "/#{assets_path}" unless assets_path.start_with?("/")
+
+        asset_dir = File.expand_path("../../../assets/jekyll-dice-tray", __dir__)
+
+        files = {
+          "dice_tray.js" => File.join(asset_dir, "dice_tray.js"),
+          "dice_tray.css" => File.join(asset_dir, "dice_tray.css"),
+        }
+
+        files.each do |name, source_path|
+          next unless File.file?(source_path)
+          site.static_files << AssetFile.new(
+            site,
+            site.source,
+            assets_path.sub(%r{\A/}, ""),
+            name,
+            source_path: source_path
+          )
+        end
+      end
+    end
+  end
+end
+

data/lib/jekyll/dice_tray/hooks.rb

@@ -0,0 +1,29 @@
+module Jekyll
+  module DiceTray
+    module Hooks
+      def self.register!
+        Jekyll::Hooks.register(%i[pages documents], :post_render) do |doc|
+          site = doc.site
+          cfg = (site.config["dice_tray"] || {})
+          next if cfg["enabled"] == false
+          next unless doc.respond_to?(:output_ext) && doc.output_ext == ".html"
+
+          assets_path = cfg["assets_path"] || "/assets/jekyll-dice-tray"
+          assets_path = "/#{assets_path}" unless assets_path.start_with?("/")
+
+          begin
+            out = doc.output.to_s
+            out = HtmlRewriter.rewrite(out) if cfg.fetch("link_dice_in_markdown", true)
+            out = HtmlRewriter.inject_tray(out, assets_path: assets_path) if cfg.fetch("inject_tray", true)
+            doc.output = out
+          rescue StandardError => e
+            Jekyll.logger.warn("jekyll-dice-tray:", "Failed to process #{doc.relative_path}: #{e.class}: #{e.message}")
+          end
+        end
+      end
+    end
+  end
+end
+
+Jekyll::DiceTray::Hooks.register!
+

data/lib/jekyll/dice_tray/html_rewriter.rb

@@ -0,0 +1,211 @@
+module Jekyll
+  module DiceTray
+    module HtmlRewriter
+      DICE_RE = /
+        (?<![A-Za-z0-9_])
+        (?:
+          (?:\d{1,3})?d\d{1,4}
+          (?:\s*[+-]\s*\d{1,5})?
+          (?:
+            \s*[+-]\s*(?:\d{1,3})?d\d{1,4}
+            (?:\s*[+-]\s*\d{1,5})?
+          )?
+        )
+        (?![A-Za-z0-9_])
+      /x
+
+      THAC0_WORD_RE = /THAC0/i
+
+      BRACKET_INNER_RE = /
+        [+-]?
+        \d{1,5}
+        (?:\s*[+-]\s*\d{1,5})*
+      /x
+
+      # "THAC0 18 [+1]" in one run of text — link the inner "+1", roll d20+1.
+      THAC0_INLINE_RE = /
+        THAC0\s*:?\s*
+        \d{1,2}
+        \s*
+        \[
+        \s*
+        (?<mod>#{BRACKET_INNER_RE})
+        \s*
+        \]
+      /ix
+
+      # "18 [+1]" in a THAC0 table row or under a THAC0 column header.
+      THAC0_VALUE_BRACKET_RE = /
+        (?<!\d)
+        \d{1,2}
+        \s*
+        \[
+        \s*
+        (?<mod>#{BRACKET_INNER_RE})
+        \s*
+        \]
+      /x
+
+      SKIP_ANCESTORS = %w[pre code a script style textarea].freeze
+
+      def self.bracket_mod_to_roll_expr(inner)
+        compact = inner.gsub(/\s+/, "")
+        mod = 0
+        compact.scan(/[+-]?\d+/) { |term| mod += term.to_i }
+        return "d20" if mod.zero?
+
+        mod.positive? ? "d20+#{mod}" : "d20#{mod}"
+      end
+
+      def self.thac0_row_context?(node)
+        tr = node.ancestors.find { |a| a.element? && a.name == "tr" }
+        tr && tr.text.match?(THAC0_WORD_RE)
+      end
+
+      def self.thac0_table_context?(node)
+        return false unless node.ancestors.any? { |a| a.element? && a.name == "td" }
+
+        table = node.ancestors.find { |a| a.element? && a.name == "table" }
+        return false unless table
+
+        caption = table.at_css("caption")
+        return true if caption&.text&.match?(THAC0_WORD_RE)
+
+        first_row = table.at_css("tr")
+        first_row && first_row.text.match?(THAC0_WORD_RE)
+      end
+
+      def self.thac0_bracket_context?(node)
+        thac0_row_context?(node) || thac0_table_context?(node)
+      end
+
+      def self.bracket_mod_hit(text, m)
+        {
+          start: m.begin(0),
+          end: m.end(0),
+          expr: bracket_mod_to_roll_expr(m[:mod]),
+          label_start: m.begin(:mod),
+          label_end: m.end(:mod),
+          prefix: text[m.begin(0)...m.begin(:mod)],
+          suffix: text[m.end(:mod)...m.end(0)],
+        }
+      end
+
+      def self.collect_roll_matches(text, node)
+        matches = []
+
+        text.to_enum(:scan, DICE_RE).each do
+          m = Regexp.last_match
+          matches << {
+            start: m.begin(0),
+            end: m.end(0),
+            expr: m[0],
+            label_start: m.begin(0),
+            label_end: m.end(0),
+          }
+        end
+
+        text.to_enum(:scan, THAC0_INLINE_RE).each do
+          matches << bracket_mod_hit(text, Regexp.last_match)
+        end
+
+        if thac0_bracket_context?(node)
+          text.to_enum(:scan, THAC0_VALUE_BRACKET_RE).each do
+            matches << bracket_mod_hit(text, Regexp.last_match)
+          end
+        end
+
+        matches.sort_by! { |hit| hit[:start] }
+        accepted = []
+        matches.each do |hit|
+          next if accepted.any? { |prev| hit[:start] < prev[:end] && hit[:end] > prev[:start] }
+
+          accepted << hit
+        end
+        accepted
+      end
+
+      def self.rewrite(html)
+        frag = Nokogiri::HTML::DocumentFragment.parse(html)
+
+        frag.traverse do |node|
+          next unless node.text?
+          next if node.content.nil? || node.content.empty?
+          next if node.ancestors.any? { |a| SKIP_ANCESTORS.include?(a.name) }
+
+          text = node.content
+          hits = collect_roll_matches(text, node)
+          next if hits.empty?
+
+          new_nodes = []
+          last = 0
+
+          hits.each do |hit|
+            start_idx = hit[:start]
+            end_idx = hit[:end]
+
+            new_nodes << Nokogiri::XML::Text.new(text[last...start_idx], frag.document) if start_idx > last
+
+            if hit[:prefix]
+              new_nodes << Nokogiri::XML::Text.new(hit[:prefix], frag.document) if !hit[:prefix].empty?
+
+              a = Nokogiri::XML::Node.new("a", frag.document)
+              a["href"] = "#"
+              a["class"] = "dice-tray-roll"
+              a["data-dice"] = hit[:expr]
+              a.content = text[hit[:label_start]...hit[:label_end]]
+              new_nodes << a
+
+              new_nodes << Nokogiri::XML::Text.new(hit[:suffix], frag.document) if !hit[:suffix].empty?
+            else
+              a = Nokogiri::XML::Node.new("a", frag.document)
+              a["href"] = "#"
+              a["class"] = "dice-tray-roll"
+              a["data-dice"] = hit[:expr]
+              a.content = text[hit[:label_start]...hit[:label_end]]
+              new_nodes << a
+            end
+
+            last = end_idx
+          end
+
+          new_nodes << Nokogiri::XML::Text.new(text[last..], frag.document) if last < text.length
+
+          node.replace(new_nodes.map(&:to_html).join)
+        end
+
+        frag.to_html
+      end
+
+      def self.inject_tray(html, assets_path:)
+        return html if html.include?('data-dice-tray-root="true"')
+
+        tray = <<~HTML
+          <div id="jekyll-dice-tray" data-dice-tray-root="true" aria-live="polite">
+            <div class="jdt-header">
+              <button type="button" class="jdt-toggle" aria-expanded="false" title="Toggle dice tray">Dice</button>
+            </div>
+            <div class="jdt-body" hidden>
+              <div class="jdt-clue">Type <code>1d20+5</code> or <code>/help</code>, then press Enter.</div>
+              <div class="jdt-log" role="log" aria-label="Dice roll log"></div>
+              <input class="jdt-input" type="text" inputmode="text" autocomplete="off" spellcheck="false"
+                placeholder="Roll: 1d6, d4, 2d8+1, /help" />
+            </div>
+          </div>
+        HTML
+
+        tags = <<~HTML
+          <link rel="stylesheet" href="#{assets_path}/dice_tray.css" />
+          <script defer src="#{assets_path}/dice_tray.js"></script>
+        HTML
+
+        if html.include?("</body>")
+          html.sub("</body>", "#{tray}\n#{tags}\n</body>")
+        else
+          "#{html}\n#{tray}\n#{tags}\n"
+        end
+      end
+    end
+  end
+end
+

data/lib/jekyll/dice_tray/version.rb

@@ -0,0 +1,6 @@
+module Jekyll
+  module DiceTray
+    VERSION = "0.1.0"
+  end
+end
+

data/lib/jekyll-dice-tray.rb

@@ -0,0 +1,9 @@
+require "jekyll"
+require "nokogiri"
+
+require_relative "jekyll/dice_tray/version"
+require_relative "jekyll/dice_tray/asset_file"
+require_relative "jekyll/dice_tray/generator"
+require_relative "jekyll/dice_tray/html_rewriter"
+require_relative "jekyll/dice_tray/hooks"
+

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: jekyll-dice-tray
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- directsun
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: jekyll
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.7'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.7'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.14'
+email: []
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- assets/jekyll-dice-tray/dice_tray.css
+- assets/jekyll-dice-tray/dice_tray.js
+- lib/jekyll-dice-tray.rb
+- lib/jekyll/dice_tray/asset_file.rb
+- lib/jekyll/dice_tray/generator.rb
+- lib/jekyll/dice_tray/hooks.rb
+- lib/jekyll/dice_tray/html_rewriter.rb
+- lib/jekyll/dice_tray/version.rb
+homepage: https://github.com/sunflowermans/dice-tray
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Jekyll plugin that adds an overlay dice tray and clickable dice rolls.
+test_files: []