Add Diceroll story-steering extension Before each response, quietly asks the current model for 5-10 short continuation options with probabilities (structured output with plain-text fallback), rolls a weighted die, and injects the chosen direction after the latest user message for that generation only. Both side prompts share the main chat's exact history prefix so the provider prompt cache is reused. Swipes/regenerates reuse the rolled direction unless re-rolling is enabled; a debug mode shows the option table and injected prompt under each message.

ce847b8b518928c40f2b1603fecc143114ecd24a

permissionBRICK <40219477+permissionBRICK@users.noreply.github.com>

Parents: 1385bdd1ce3c8b3af2691f342db02a8735e56997

public/scripts/extensions/diceroll/index.js+509 -0 Viewed

+import { extension_settings, renderExtensionTemplateAsync, saveMetadataDebounced } from '../../extensions.js';
+import {
+    chat,
+    chat_metadata,
+    event_types,
+    eventSource,
+    extension_prompt_roles,
+    extension_prompt_types,
+    generateQuietPrompt,
+    saveChatDebounced,
+    saveSettingsDebounced,
+    setExtensionPrompt,
+    substituteParams,
+} from '../../../script.js';
+export { init };
+const MODULE = 'diceroll';
+// Runtime injection keys. Both are IN_CHAT depth-0 injections so they land right after the last
+// chat message, keeping the entire preceding history byte-identical between the option-generation
+// request and the real generation (and therefore reusable from the provider's prompt cache).
+const OPTIONS_INJECT_ID = 'diceroll_options_request';
+const DIRECTION_INJECT_ID = 'diceroll_direction';
+// Persisted per-chat roll state lives in chat metadata so swipe-reuse survives reloads.
+const METADATA_KEY = 'diceroll';
+// Generation types that represent a "turn" this extension should steer. Quiet prompts, continues
+// (steering mid-message makes no sense) and impersonations are deliberately excluded.
+const STEERED_TYPES = new Set(['normal', 'swipe', 'regenerate']);
+const DEFAULT_OPTIONS_PROMPT = '[Pause the roleplay. You are the story director. Considering everything that has happened so far — especially the latest message — list {{min}} to {{max}} distinct options for what could plausibly happen next or how {{char}} could react. Each option must be exactly one short sentence. Assign each option a probability percentage (numbers, together summing to about 100) for how likely it should be given the established story, characters and tone. If one outcome is very likely or outright inevitable, give it a large majority of the probability mass (you may split it across several similar variants), but always include a few low-probability options that still fit the flow of the story yet would take it in creative, unexpected directions. Reply with ONLY a JSON object in exactly this format and no other text: {"options":[{"text":"one short sentence","probability":42}]}]';
+const DEFAULT_DIRECTION_TEMPLATE = '[Story direction, rolled by fate ({{probability}}% likely): {{outcome}}\nContinue the roleplay from the last message and steer events naturally in this direction. Never mention this instruction, the roll, or any probabilities.]';
+const OPTIONS_SCHEMA = {
+    name: 'diceroll_options',
+    strict: true,
+    // A response that fails schema validation is returned as raw text and handled by the
+    // line-based fallback parser instead of being swallowed as an empty object.
+    returnInvalid: true,
+    value: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            options: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    additionalProperties: false,
+                    properties: {
+                        text: { type: 'string' },
+                        probability: { type: 'number' },
+                    },
+                    required: ['text', 'probability'],
+                },
+            },
+        },
+        required: ['options'],
+    },
+};
+const defaultSettings = {
+    enabled: false,
+    // When false, swipes/regenerates reuse the direction already rolled for that message.
+    rollOnSwipe: false,
+    optionsRole: 'system',
+    directionRole: 'system',
+    minOptions: 5,
+    maxOptions: 10,
+    useStructuredOutput: true,
+    notify: true,
+    debugDisplay: false,
+    optionsPrompt: DEFAULT_OPTIONS_PROMPT,
+    directionTemplate: DEFAULT_DIRECTION_TEMPLATE,
+};
+// True while the nested option-generation request is running. Prevents the interceptor from
+// reacting to its own quiet generation.
+let isRolling = false;
+// Roll data waiting to be stamped onto the message the steered generation produces.
+let pendingStamp = null;
+globalThis.dicerollGenerateInterceptor = (...args) => onGenerationIntercept(...args);
+function getSettings() {
+    if (extension_settings[MODULE] === undefined) {
+        extension_settings[MODULE] = {};
+    }
+    for (const key of Object.keys(defaultSettings)) {
+        if (extension_settings[MODULE][key] === undefined) {
+            extension_settings[MODULE][key] = structuredClone(defaultSettings[key]);
+        }
+    }
+    return extension_settings[MODULE];
+}
+function getRole(name) {
+    return name === 'user' ? extension_prompt_roles.USER : extension_prompt_roles.SYSTEM;
+}
+function setDirectionInjection(text, roleName) {
+    setExtensionPrompt(DIRECTION_INJECT_ID, text, extension_prompt_types.IN_CHAT, 0, false, getRole(roleName));
+}
+function clearDirectionInjection() {
+    setDirectionInjection('', 'system');
+}
+function formatProbability(value) {
+    const number = Number(value);
+    return Number.isInteger(number) ? String(number) : number.toFixed(1);
+}
+/**
+ * Runs the option-generation request: the full current chat history plus the instruction injected
+ * at depth 0, through the currently selected model/API.
+ * @param {object} s Settings
+ * @returns {Promise<string>} Raw model response
+ */
+async function generateOptions(s) {
+    const instruction = substituteParams(
+        String(s.optionsPrompt)
+            .replaceAll('{{min}}', String(s.minOptions))
+            .replaceAll('{{max}}', String(s.maxOptions)),
+    );
+    setExtensionPrompt(OPTIONS_INJECT_ID, instruction, extension_prompt_types.IN_CHAT, 0, false, getRole(s.optionsRole));
+    try {
+        return await generateQuietPrompt({
+            quietPrompt: '',
+            jsonSchema: s.useStructuredOutput ? OPTIONS_SCHEMA : null,
+        });
+    } finally {
+        setExtensionPrompt(OPTIONS_INJECT_ID, '', extension_prompt_types.IN_CHAT, 0);
+    }
+}
+function tryParseJson(text) {
+    const candidates = [text];
+    const objStart = text.indexOf('{');
+    const objEnd = text.lastIndexOf('}');
+    if (objStart >= 0 && objEnd > objStart) {
+        candidates.push(text.slice(objStart, objEnd + 1));
+    }
+    const arrStart = text.indexOf('[');
+    const arrEnd = text.lastIndexOf(']');
+    if (arrStart >= 0 && arrEnd > arrStart) {
+        candidates.push(text.slice(arrStart, arrEnd + 1));
+    }
+    for (const candidate of candidates) {
+        try {
+            return JSON.parse(candidate);
+        } catch {
+            // try the next candidate
+        }
+    }
+    return null;
+}
+/**
+ * Parses model output into a weighted option list. Prefers JSON (structured output or inline),
+ * falls back to "text (25%)" / "25% - text" style lines.
+ * @param {string} raw Raw model response
+ * @returns {{text: string, probability: number}[]|null} At least two options, or null
+ */
+function parseOptions(raw) {
+    const text = String(raw ?? '').trim();
+    if (!text) {
+        return null;
+    }
+    let options = [];
+    const parsed = tryParseJson(text);
+    const list = Array.isArray(parsed) ? parsed : (Array.isArray(parsed?.options) ? parsed.options : null);
+    if (list) {
+        options = list.map(item => ({
+            text: String(item?.text ?? item?.option ?? '').trim(),
+            probability: Number(item?.probability ?? item?.percent ?? item?.chance),
+        }));
+    } else {
+        const trailing = /^(.+?)\s*[-–—:([]?\s*(\d{1,3}(?:\.\d+)?)\s*%\s*[)\]]?\s*$/;
+        const leading = /^(\d{1,3}(?:\.\d+)?)\s*%\s*[-–—:]?\s*(.+)$/;
+        for (let line of text.split('\n')) {
+            line = line.replace(/^\s*(?:[-*•]|\d+[.)])\s*/, '').trim();
+            let match = line.match(trailing);
+            if (match) {
+                options.push({ text: match[1].trim(), probability: Number(match[2]) });
+                continue;
+            }
+            match = line.match(leading);
+            if (match) {
+                options.push({ text: match[2].trim(), probability: Number(match[1]) });
+            }
+        }
+    }
+    options = options.filter(option => option.text && Number.isFinite(option.probability) && option.probability > 0);
+    // Models occasionally return fractions instead of percentages.
+    const total = options.reduce((sum, option) => sum + option.probability, 0);
+    if (total > 0 && total <= 1.5) {
+        options = options.map(option => ({ ...option, probability: option.probability * 100 }));
+    }
+    return options.length >= 2 ? options : null;
+}
+/**
+ * Weighted random roll over the options.
+ * @param {{text: string, probability: number}[]} options Parsed options
+ * @returns {{options: object[], chosenIndex: number, roll: number, total: number}}
+ */
+function rollOptions(options) {
+    const total = options.reduce((sum, option) => sum + option.probability, 0);
+    const roll = Math.random() * total;
+    let cumulative = 0;
+    let chosenIndex = options.length - 1;
+    for (let i = 0; i < options.length; i++) {
+        cumulative += options[i].probability;
+        if (roll < cumulative) {
+            chosenIndex = i;
+            break;
+        }
+    }
+    return { options, chosenIndex, roll, total };
+}
+function buildDirectionText(rollData, s) {
+    const chosen = rollData.options[rollData.chosenIndex];
+    return substituteParams(
+        String(s.directionTemplate)
+            .replaceAll('{{outcome}}', chosen.text)
+            .replaceAll('{{probability}}', formatProbability(chosen.probability)),
+    );
+}
+/**
+ * Temporarily hides the message being swiped away so the option request sees the same history as
+ * the swipe generation itself (which pops the last message from its prompt).
+ * @returns {(() => void)|null} Restore function
+ */
+function hideLastMessageForSwipe() {
+    const target = chat[chat.length - 1];
+    if (!target || target.is_user || target.is_system) {
+        return null;
+    }
+    target.is_system = true;
+    return () => {
+        target.is_system = false;
+    };
+}
+/**
+ * Generation interceptor. Runs the option roll before the actual generation and injects the
+ * rolled direction for the upcoming prompt build.
+ * @param {object[]} coreChat Filtered chat that will be used for the prompt
+ * @param {number} _contextSize Max context size
+ * @param {(immediately: boolean) => void} _abort Abort function
+ * @param {string} type Generation type
+ */
+async function onGenerationIntercept(coreChat, _contextSize, _abort, type) {
+    const s = getSettings();
+    // The nested option request triggers interceptors itself (as type 'quiet').
+    if (isRolling || type === 'quiet') {
+        return;
+    }
+    if (!s.enabled) {
+        clearDirectionInjection();
+        return;
+    }
+    // Tool-call recursion re-enters Generate as 'normal'; keep the current steering untouched
+    // instead of rolling again mid-turn.
+    const lastMessage = chat[chat.length - 1];
+    if (lastMessage && !lastMessage.is_user && Array.isArray(lastMessage.extra?.tool_invocations)) {
+        return;
+    }
+    // Never leak a stale direction into an unrelated generation type.
+    clearDirectionInjection();
+    pendingStamp = null;
+    if (!STEERED_TYPES.has(type) || !chat.length) {
+        return;
+    }
+    // The roll belongs to the current user turn; swipes/regenerates of the same turn can reuse it.
+    const anchor = chat.findLastIndex(x => x.is_user);
+    const stored = chat_metadata[METADATA_KEY];
+    const isRedo = type === 'swipe' || type === 'regenerate';
+    if (isRedo && !s.rollOnSwipe && stored?.direction && stored.anchor === anchor) {
+        pendingStamp = stored;
+        setDirectionInjection(stored.direction, s.directionRole);
+        return;
+    }
+    let rollData = null;
+    isRolling = true;
+    const restoreHidden = type === 'swipe' ? hideLastMessageForSwipe() : null;
+    try {
+        const raw = await generateOptions(s);
+        const options = parseOptions(raw);
+        if (!options) {
+            throw new Error('Could not parse any options from the model response.');
+        }
+        rollData = rollOptions(options);
+    } catch (error) {
+        console.error('[Diceroll] Option generation failed:', error);
+        toastr.warning('Continuing without steering. ' + (error?.message ?? ''), 'Diceroll: option roll failed', { escapeHtml: true });
+    } finally {
+        restoreHidden?.();
+        isRolling = false;
+    }
+    if (!rollData) {
+        return;
+    }
+    const data = {
+        anchor,
+        options: rollData.options,
+        chosenIndex: rollData.chosenIndex,
+        roll: rollData.roll,
+        total: rollData.total,
+        direction: '',
+    };
+    data.direction = buildDirectionText(rollData, s);
+    chat_metadata[METADATA_KEY] = data;
+    saveMetadataDebounced();
+    pendingStamp = data;
+    setDirectionInjection(data.direction, s.directionRole);
+    if (s.notify) {
+        const chosen = rollData.options[rollData.chosenIndex];
+        toastr.info(`${chosen.text} (${formatProbability(chosen.probability)}%)`, '🎲 Diceroll', { escapeHtml: true });
+    }
+}
+/**
+ * Copies the roll that steered a finished generation onto the produced message, so the debug view
+ * stays correct per message and survives reloads.
+ * @param {number} chatId Message index
+ */
+function stampMessage(chatId) {
+    if (!pendingStamp) {
+        return;
+    }
+    const message = chat[chatId];
+    if (!message || message.is_user || message.is_system) {
+        return;
+    }
+    message.extra = message.extra || {};
+    message.extra.diceroll = structuredClone(pendingStamp);
+    pendingStamp = null;
+    saveChatDebounced();
+}
+function renderDebugForMessage(chatId) {
+    const mesElement = $(`#chat .mes[mesid="${chatId}"]`);
+    if (!mesElement.length) {
+        return;
+    }
+    mesElement.find('.diceroll_debug').remove();
+    const data = chat[chatId]?.extra?.diceroll;
+    if (!getSettings().debugDisplay || !data || !Array.isArray(data.options)) {
+        return;
+    }
+    const chosen = data.options[data.chosenIndex];
+    const details = $('<details class="diceroll_debug"></details>');
+    const rollInfo = Number.isFinite(data.roll) ? `, roll ${data.roll.toFixed(1)}/${formatProbability(data.total)}` : '';
+    details.append($('<summary></summary>').text(`🎲 ${chosen?.text ?? '?'} (${formatProbability(chosen?.probability ?? 0)}%${rollInfo})`));
+    const table = $('<table class="diceroll_debug_table"></table>');
+    data.options.forEach((option, index) => {
+        const row = $('<tr></tr>').toggleClass('diceroll_chosen', index === data.chosenIndex);
+        row.append($('<td></td>').text(`${formatProbability(option.probability)}%`));
+        row.append($('<td></td>').text(option.text));
+        table.append(row);
+    });
+    details.append(table);
+    details.append($('<div class="diceroll_debug_direction"></div>').text(data.direction ?? ''));
+    const anchorElement = mesElement.find('.mes_block .mes_text').first();
+    if (anchorElement.length) {
+        anchorElement.after(details);
+    } else {
+        mesElement.append(details);
+    }
+}
+function renderAllDebug() {
+    $('#chat .mes').each((_, element) => {
+        renderDebugForMessage(Number(element.getAttribute('mesid')));
+    });
+}
+function loadSettingsUi() {
+    const s = getSettings();
+    $('#diceroll_enabled').prop('checked', s.enabled);
+    $('#diceroll_roll_on_swipe').prop('checked', s.rollOnSwipe);
+    $('#diceroll_structured').prop('checked', s.useStructuredOutput);
+    $('#diceroll_notify').prop('checked', s.notify);
+    $('#diceroll_debug').prop('checked', s.debugDisplay);
+    $('#diceroll_min_options').val(s.minOptions);
+    $('#diceroll_max_options').val(s.maxOptions);
+    $('#diceroll_options_role').val(s.optionsRole);
+    $('#diceroll_direction_role').val(s.directionRole);
+    $('#diceroll_options_prompt').val(s.optionsPrompt);
+    $('#diceroll_direction_template').val(s.directionTemplate);
+}
+function setupListeners() {
+    const bindCheckbox = (id, key, onChange = null) => {
+        $(id).on('change', function () {
+            getSettings()[key] = !!$(this).prop('checked');
+            saveSettingsDebounced();
+            onChange?.();
+        });
+    };
+    bindCheckbox('#diceroll_enabled', 'enabled', () => {
+        if (!getSettings().enabled) {
+            clearDirectionInjection();
+        }
+    });
+    bindCheckbox('#diceroll_roll_on_swipe', 'rollOnSwipe');
+    bindCheckbox('#diceroll_structured', 'useStructuredOutput');
+    bindCheckbox('#diceroll_notify', 'notify');
+    bindCheckbox('#diceroll_debug', 'debugDisplay', renderAllDebug);
+    $('#diceroll_min_options').on('input', function () {
+        getSettings().minOptions = Math.max(2, Number($(this).val()) || defaultSettings.minOptions);
+        saveSettingsDebounced();
+    });
+    $('#diceroll_max_options').on('input', function () {
+        getSettings().maxOptions = Math.max(2, Number($(this).val()) || defaultSettings.maxOptions);
+        saveSettingsDebounced();
+    });
+    $('#diceroll_options_role').on('change', function () {
+        getSettings().optionsRole = String($(this).val());
+        saveSettingsDebounced();
+    });
+    $('#diceroll_direction_role').on('change', function () {
+        getSettings().directionRole = String($(this).val());
+        saveSettingsDebounced();
+    });
+    $('#diceroll_options_prompt').on('input', function () {
+        getSettings().optionsPrompt = String($(this).val());
+        saveSettingsDebounced();
+    });
+    $('#diceroll_direction_template').on('input', function () {
+        getSettings().directionTemplate = String($(this).val());
+        saveSettingsDebounced();
+    });
+    $('#diceroll_options_prompt_restore').on('click', () => {
+        getSettings().optionsPrompt = DEFAULT_OPTIONS_PROMPT;
+        $('#diceroll_options_prompt').val(DEFAULT_OPTIONS_PROMPT);
+        saveSettingsDebounced();
+    });
+    $('#diceroll_direction_template_restore').on('click', () => {
+        getSettings().directionTemplate = DEFAULT_DIRECTION_TEMPLATE;
+        $('#diceroll_direction_template').val(DEFAULT_DIRECTION_TEMPLATE);
+        saveSettingsDebounced();
+    });
+}
+async function init() {
+    const settingsHtml = await renderExtensionTemplateAsync(MODULE, 'settings');
+    $('#extensions_settings2').append(settingsHtml);
+    loadSettingsUi();
+    setupListeners();
+    // A new user message starts a new turn; any previous roll no longer applies.
+    eventSource.on(event_types.MESSAGE_SENT, () => {
+        delete chat_metadata[METADATA_KEY];
+    });
+    eventSource.on(event_types.MESSAGE_RECEIVED, (chatId) => stampMessage(chatId));
+    eventSource.on(event_types.CHARACTER_MESSAGE_RENDERED, (chatId) => {
+        stampMessage(chatId);
+        renderDebugForMessage(chatId);
+    });
+    eventSource.on(event_types.MESSAGE_SWIPED, (chatId) => renderDebugForMessage(chatId));
+    eventSource.on(event_types.CHAT_CHANGED, () => {
+        pendingStamp = null;
+        clearDirectionInjection();
+        renderAllDebug();
+    });
+    // The direction is consumed by exactly one generation. GENERATION_ENDED also fires when the
+    // nested option request finishes, which is why clearing is skipped while a roll is in flight.
+    const onGenerationDone = () => {
+        if (isRolling) {
+            return;
+        }
+        pendingStamp = null;
+        clearDirectionInjection();
+    };
+    eventSource.on(event_types.GENERATION_ENDED, onGenerationDone);
+    eventSource.on(event_types.GENERATION_STOPPED, onGenerationDone);
+}

public/scripts/extensions/diceroll/manifest.json+15 -0 Viewed

+{
+    "display_name": "Diceroll",
+    "loading_order": 100,
+    "requires": [],
+    "optional": [],
+    "js": "index.js",
+    "css": "style.css",
+    "author": "SillyTavern",
+    "version": "1.0.0",
+    "homePage": "https://github.com/SillyTavern/SillyTavern",
+    "generate_interceptor": "dicerollGenerateInterceptor",
+    "hooks": {
+        "activate": "init"
+    }
+}

public/scripts/extensions/diceroll/settings.html+79 -0 Viewed

+<div id="diceroll_settings">
+    <div class="inline-drawer">
+        <div class="inline-drawer-toggle inline-drawer-header">
+            <b data-i18n="ext_diceroll_title">Diceroll</b>
+            <div class="inline-drawer-icon fa-solid fa-circle-chevron-down down"></div>
+        </div>
+        <div class="inline-drawer-content">
+            <label class="checkbox_label" for="diceroll_enabled">
+                <input id="diceroll_enabled" type="checkbox" />
+                <span data-i18n="ext_diceroll_enable">Enable Diceroll</span>
+            </label>
+            <small data-i18n="ext_diceroll_help">Before each response, the current model is quietly asked (with the exact same chat history, so the prompt cache is reused) to list short options for how the story could continue, each with a probability. A weighted dice roll picks one, and the chosen direction is injected after the latest user message for that one generation only — it is never saved to the chat, and the next turn's history stays clean.</small>
+            <label class="checkbox_label" for="diceroll_roll_on_swipe">
+                <input id="diceroll_roll_on_swipe" type="checkbox" />
+                <span data-i18n="ext_diceroll_roll_on_swipe">Roll again on swipes and regenerates</span>
+            </label>
+            <small data-i18n="ext_diceroll_roll_on_swipe_help">When off, swiping or regenerating reuses the direction already rolled for that turn.</small>
+            <label class="checkbox_label" for="diceroll_structured">
+                <input id="diceroll_structured" type="checkbox" />
+                <span data-i18n="ext_diceroll_structured">Request structured output (JSON schema)</span>
+            </label>
+            <small data-i18n="ext_diceroll_structured_help">Turn off if your backend rejects requests containing a JSON schema; the options are then parsed from plain text.</small>
+            <label class="checkbox_label" for="diceroll_notify">
+                <input id="diceroll_notify" type="checkbox" />
+                <span data-i18n="ext_diceroll_notify">Show a notification with the rolled outcome</span>
+            </label>
+            <label class="checkbox_label" for="diceroll_debug">
+                <input id="diceroll_debug" type="checkbox" />
+                <span data-i18n="ext_diceroll_debug">Debug: show the roll table and injected direction under each message</span>
+            </label>
+            <div class="flex-container">
+                <div class="flex1">
+                    <label for="diceroll_min_options" data-i18n="ext_diceroll_min">Min options</label>
+                    <input id="diceroll_min_options" class="text_pole" type="number" min="2" max="20" step="1" />
+                </div>
+                <div class="flex1">
+                    <label for="diceroll_max_options" data-i18n="ext_diceroll_max">Max options</label>
+                    <input id="diceroll_max_options" class="text_pole" type="number" min="2" max="20" step="1" />
+                </div>
+            </div>
+            <div class="flex-container">
+                <div class="flex1">
+                    <label for="diceroll_options_role" data-i18n="ext_diceroll_options_role">Option request sent as</label>
+                    <select id="diceroll_options_role" class="text_pole">
+                        <option value="system" data-i18n="ext_diceroll_role_system">System message</option>
+                        <option value="user" data-i18n="ext_diceroll_role_user">User message</option>
+                    </select>
+                </div>
+                <div class="flex1">
+                    <label for="diceroll_direction_role" data-i18n="ext_diceroll_direction_role">Direction sent as</label>
+                    <select id="diceroll_direction_role" class="text_pole">
+                        <option value="system" data-i18n="ext_diceroll_role_system">System message</option>
+                        <option value="user" data-i18n="ext_diceroll_role_user">User message</option>
+                    </select>
+                </div>
+            </div>
+            <label for="diceroll_options_prompt" data-i18n="ext_diceroll_options_prompt">Option-generation prompt (\{{min}}, \{{max}} available)</label>
+            <textarea id="diceroll_options_prompt" class="text_pole textarea_compact" rows="7"></textarea>
+            <div id="diceroll_options_prompt_restore" class="menu_button menu_button_icon">
+                <i class="fa-solid fa-clock-rotate-left"></i>
+                <span data-i18n="ext_diceroll_restore">Restore default</span>
+            </div>
+            <label for="diceroll_direction_template" data-i18n="ext_diceroll_direction_template">Direction message template (\{{outcome}}, \{{probability}} available)</label>
+            <textarea id="diceroll_direction_template" class="text_pole textarea_compact" rows="4"></textarea>
+            <div id="diceroll_direction_template_restore" class="menu_button menu_button_icon">
+                <i class="fa-solid fa-clock-rotate-left"></i>
+                <span data-i18n="ext_diceroll_restore">Restore default</span>
+            </div>
+        </div>
+    </div>
+</div>

public/scripts/extensions/diceroll/style.css+42 -0 Viewed

+.diceroll_debug {
+    margin-top: 5px;
+    padding: 5px 10px;
+    border: 1px dashed var(--SmartThemeBorderColor, #888);
+    border-radius: 5px;
+    font-size: calc(var(--mainFontSize) * 0.85);
+    opacity: 0.85;
+}
+.diceroll_debug summary {
+    cursor: pointer;
+}
+.diceroll_debug_table {
+    border-collapse: collapse;
+    margin: 5px 0;
+    width: 100%;
+}
+.diceroll_debug_table td {
+    padding: 1px 8px 1px 0;
+    vertical-align: top;
+    border: none;
+}
+.diceroll_debug_table td:first-child {
+    text-align: right;
+    white-space: nowrap;
+    font-variant-numeric: tabular-nums;
+    width: 1%;
+}
+.diceroll_debug_table tr.diceroll_chosen {
+    font-weight: bold;
+    color: var(--SmartThemeQuoteColor, inherit);
+}
+.diceroll_debug_direction {
+    white-space: pre-wrap;
+    font-style: italic;
+    margin-top: 4px;
+}