☰

Diamondberry

Utility for GdC.

  1. // ==UserScript==
  2. // @name         Diamondberry
  3. // @namespace    https://greasyfork.org/hexa.cat
  4. // @version      1.7
  5. // @description  Utility for GdC.
  6. // @author       hexa.cat
  7. // @match        https://chatroom.talkwithstranger.com/*
  8. // @grant        none
  9. // @run-at       document-end
  10. // @license      MPL 2.0
  11. // ==/UserScript==
  12. (function () {
  13.   /***** IMPORT HIGHLIGHT.JS & STYLES *****/
  14.   if (!document.querySelector('link[href*="highlight.js"]')) {
  15.     const hlStyle = document.createElement('link');
  16.     hlStyle.rel = 'stylesheet';
  17.     hlStyle.href = 'https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.7.0/styles/github-dark.min.css';
  18.     document.head.appendChild(hlStyle);
  19.   }
  20.   if (!window.hljs) {
  21.     const hlScript = document.createElement('script');
  22.     hlScript.src = 'https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.7.0/highlight.min.js';
  23.     document.head.appendChild(hlScript);
  24.   }
  25.   
  26.   /***** INJECT CSS *****/
  27.   const style = document.createElement('style');
  28.   style.textContent = `
  29.     @import url(https://fonts.bunny.net/css?family=noto-color-emoji:400);
  30.     
  31.     /* Emoji */
  32.     .emoji {
  33.       font-family: "Noto Color Emoji", serif !important;
  34.       font-weight: 400;
  35.       font-style: normal;
  36.     }
  37.     
  38.     /* Headers: H1–H6 with custom sizes and weights.
  39.        Inline elements inside headers inherit the header’s weight. */
  40.     h1 { font-size: 1.5em; font-weight: 900 !important; margin: 0.3em 0; }
  41.     h2 { font-size: 1.4em; font-weight: 800 !important; margin: 0.3em 0; }
  42.     h3 { font-size: 1.3em; font-weight: 700 !important; margin: 0.3em 0; }
  43.     h4 { font-size: 1.2em; font-weight: 600 !important; margin: 0.3em 0; }
  44.     h5 { font-size: 1.1em; font-weight: 600 !important; margin: 0.3em 0; }
  45.     h6 { font-size: 1em;   font-weight: 600 !important; margin: 0.3em 0; }
  46.     h1 *, h2 *, h3 *, h4 *, h5 *, h6 * { font-weight: inherit !important; }
  47.     
  48.     /* Dark themed code block container & copy button */
  49.     .code-block-container {
  50.       position: relative;
  51.       margin: 0.5em 0;
  52.     }
  53.     pre {
  54.       background: #2F3136;
  55.       color: #DCDDDE;
  56.       padding: 8px;
  57.       overflow: auto;
  58.       border-radius: 4px;
  59.       margin: 0;
  60.     }
  61.     code {
  62.       background: transparent;
  63.       color: inherit;
  64.     }
  65.     .hljs {
  66.       background: transparent !important;
  67.       color: inherit !important;
  68.     }
  69.     .code-copy-button {
  70.       position: absolute;
  71.       top: 8px;
  72.       right: 8px;
  73.       z-index: 10;
  74.       background: rgba(0, 0, 0, 0.5);
  75.       border: none;
  76.       color: white;
  77.       padding: 2px 6px;
  78.       font-size: 0.8em;
  79.       border-radius: 3px;
  80.       cursor: pointer;
  81.     }
  82.     
  83.     /* Spoiler styling: 1px black dot as cursor */
  84.     .spoiler {
  85.       background-color: black;
  86.       color: black;
  87.       padding: 0 2px;
  88.       border-radius: 2px;
  89.       cursor: url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" width="1" height="1"><rect width="1" height="1" fill="black"/></svg>') 0 0, auto;
  90.     }
  91.     .spoiler:hover {
  92.       color: white;
  93.     }
  94.     
  95.     /* Subtext styling */
  96.     .subtext { font-size: 0.9em; color: #777; margin: 0.2em 0; }
  97.  
  98.     /* Hide .call-alert and .toast-container */
  99.   .call-alert { display: none !important; }
  100.   .toast-container { display: none !important; }
  101.   `;
  102.   document.head.appendChild(style);
  103.   // Wait for the DOM to be fully loaded.
  104. document.addEventListener('DOMContentLoaded', function() {
  105.   // Check if the send button exists.
  106.   const sendButton = document.querySelector('.btn-send');
  107.   if (sendButton) {
  108.     sendButton.addEventListener('click', function() {
  109.       // Get the editor's content.
  110.       const editor = document.querySelector('.emojionearea-editor');
  111.       if (editor) {
  112.         // Retrieve the text (works if the editor is a contenteditable div or textarea).
  113.         let text = editor.innerText || editor.value;
  114.         // Replace every single backslash with two backslashes.
  115.         text = text.replace(/\\/g, '\\\\');
  116.         // Update the editor with the modified text.
  117.         // (This means that when the system auto–unescapes a backslash,
  118.         // it will leave one behind—allowing your inline processing to detect it.)
  119.         if (editor.innerText !== undefined) {
  120.           editor.innerText = text;
  121.         } else {
  122.           editor.value = text;
  123.         }
  124.       }
  125.     });
  126.   }
  127. });
  128.  
  129.   
  130. /***** INLINE PROCESSING *****/
  131. // The helper functions below work as follows:
  132. //
  133. // protectEscapes() looks for any occurrence of a backslash followed by any character.
  134. // Because the system automatically removes a single backslash, if you want to output
  135. // a literal markdown control character (such as "*" or "_") you must type TWO backslashes.
  136. // For example, to display a literal asterisk, type "\\*" in your input. The raw text then
  137. // becomes "\*", which our function will catch and convert into a placeholder.
  138. // Later, restoreEscapes() puts the intended literal character back in place.
  139. function protectEscapes(text) {
  140.   // Match a backslash followed by any character.
  141.   // Note: due to the system’s behavior, a user must type two backslashes to produce
  142.   // a raw backslash. For example, to get a literal asterisk, type "\\*".
  143.   return text.replace(/\\(.)/g, function(match, p1) {
  144.     return "%%LITERAL_" + p1.charCodeAt(0) + "%%";
  145.   });
  146. }
  147.  
  148. function restoreEscapes(text) {
  149.   return text.replace(/%%LITERAL_(\d+)%%/g, function(match, p1) {
  150.     return String.fromCharCode(p1);
  151.   });
  152. }
  153.  
  154. function processInline(text) {
  155.   // First, protect escaped characters.
  156.   text = protectEscapes(text);
  157.   
  158.   // Process combined bold+italic markers (either "*_" or "_*").
  159.   text = text.replace(/(?:\*_|_\*)([\s\S]+?)(?:_\*|\*_)/g, '<strong><em>$1</em></strong>');
  160.   
  161.   // Underline combinations (allowing multiline)
  162.   text = text.replace(/__\*\*\*([\s\S]+?)\*\*\*__/g, '<u><strong><em>$1</em></strong></u>');
  163.   text = text.replace(/__\*\*([\s\S]+?)\*\*__/g, '<u><strong>$1</strong></u>');
  164.   text = text.replace(/__\*([\s\S]+?)\*__/g, '<u><em>$1</em></u>');
  165.   text = text.replace(/__(.+?)__/g, '<u>$1</u>');
  166.   
  167.   // Bold+italic (triple asterisks), bold (double asterisks), and italics (single asterisk, underscore, single quote, or double quote)
  168.   text = text.replace(/\*\*\*([\s\S]+?)\*\*\*/g, '<strong><em>$1</em></strong>');
  169.   text = text.replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>');
  170.   text = text.replace(/\*([\s\S]+?)\*/g, '<em>$1</em>');
  171.   text = text.replace(/_([\s\S]+?)_/g, '<em>$1</em>');
  172.   text = text.replace(/"([\s\S]+?)"/g, '<em>$1</em>');
  173.   
  174.   // Strikethrough
  175.   text = text.replace(/~~([\s\S]+?)~~/g, '<del>$1</del>');
  176.   
  177.   // Links (masked and unembeddable)
  178.   text = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2" rel="noopener noreferrer">$1</a>');
  179.   text = text.replace(/<((?:https?:\/\/)[^>]+)>/g, '<a href="$1" rel="noopener noreferrer">$1</a>');
  180.   
  181.   // Plain links
  182.   text = text.replace(/((?:https?:\/\/)[^\s<]+)/g, '<a href="$1" rel="noopener noreferrer">$1</a>');
  183.   
  184.   // Spoiler tags
  185.   text = text.replace(/\|\|([\s\S]+?)\|\|/g, '<span class="spoiler">$1</span>');
  186.   
  187.   // Finally, restore the escaped characters.
  188.   text = restoreEscapes(text);
  189.   
  190.   return text;
  191. }
  192.  
  193.  
  194.   
  195.   /***** BLOCK-LEVEL PARSING *****/
  196.   function parseMarkdown(text) {
  197.     // 1. Protect code blocks with placeholders.
  198.     let codeBlockPlaceholders = [];
  199.     text = text.replace(/```(\w+)?\n([\s\S]*?)\n?```/g, function(match, lang, code) {
  200.       let placeholder = `%%%CODEBLOCK${codeBlockPlaceholders.length}%%%`;
  201.       codeBlockPlaceholders.push({ placeholder, lang: lang || '', code });
  202.       return placeholder;
  203.     });
  204.     
  205.     // 2. Protect inline code with placeholders.
  206.     let inlineCodePlaceholders = [];
  207.     text = text.replace(/`([^`]+?)`/g, function(match, code) {
  208.       let placeholder = `%%%INLINECODE${inlineCodePlaceholders.length}%%%`;
  209.       inlineCodePlaceholders.push({ placeholder, code });
  210.       return placeholder;
  211.     });
  212.     
  213.     // 3. Process headers (H1–H6) and subtext.
  214.     text = text.replace(/^######\s+(.*)$/gm, function(match, p1) {
  215.       return '<h6>' + processInline(p1.trim()) + '</h6>';
  216.     });
  217.     text = text.replace(/^#####\s+(.*)$/gm, function(match, p1) {
  218.       return '<h5>' + processInline(p1.trim()) + '</h5>';
  219.     });
  220.     text = text.replace(/^####\s+(.*)$/gm, function(match, p1) {
  221.       return '<h4>' + processInline(p1.trim()) + '</h4>';
  222.     });
  223.     text = text.replace(/^###\s+(.*)$/gm, function(match, p1) {
  224.       return '<h3>' + processInline(p1.trim()) + '</h3>';
  225.     });
  226.     text = text.replace(/^##\s+(.*)$/gm, function(match, p1) {
  227.       return '<h2>' + processInline(p1.trim()) + '</h2>';
  228.     });
  229.     text = text.replace(/^#\s+(.*)$/gm, function(match, p1) {
  230.       return '<h1>' + processInline(p1.trim()) + '</h1>';
  231.     });
  232.     text = text.replace(/^-#\s+(.*)$/gm, function(match, p1) {
  233.       return '<div class="subtext">' + processInline(p1.trim()) + '</div>';
  234.     });
  235.     
  236.     // 4. Process block quotes.
  237.     text = text.replace(/^>>>\s+([\s\S]+?)(?=\n\S|$)/gm, function(match, p1) {
  238.       return '<blockquote>' + processInline(p1.trim()) + '</blockquote>';
  239.     });
  240.     text = text.replace(/^>\s+(.*)$/gm, function(match, p1) {
  241.       return '<blockquote>' + processInline(p1.trim()) + '</blockquote>';
  242.     });
  243.     
  244.     // 5. Process the remaining text as paragraphs.
  245.     // Split on blank lines.
  246.     let paragraphs = text.split(/\n\s*\n/);
  247.     for (let i = 0; i < paragraphs.length; i++) {
  248.       let para = paragraphs[i].trim();
  249.       // If the paragraph already starts with a block-level tag, leave it.
  250.       if (/^<(h[1-6]|blockquote|ul|ol|div|pre)/i.test(para)) {
  251.         paragraphs[i] = para;
  252.       } else {
  253.         // Check if the paragraph is a list.
  254.         let lines = para.split('\n');
  255.         let isUnordered = lines.every(line => /^\s*[-*]\s+/.test(line));
  256.         let isOrdered = lines.every(line => /^\s*\d+\.\s+/.test(line));
  257.         if (isUnordered) {
  258.           let out = "<ul>\n";
  259.           for (let line of lines) {
  260.             let item = line.replace(/^\s*[-*]\s+/, '');
  261.             out += "<li>" + processInline(item.trim()) + "</li>\n";
  262.           }
  263.           out += "</ul>";
  264.           paragraphs[i] = out;
  265.         } else if (isOrdered) {
  266.           let out = "<ol>\n";
  267.           for (let line of lines) {
  268.             let item = line.replace(/^\s*\d+\.\s+/, '');
  269.             out += "<li>" + processInline(item.trim()) + "</li>\n";
  270.           }
  271.           out += "</ol>";
  272.           paragraphs[i] = out;
  273.         } else {
  274.           // Normal paragraph: process inline on the entire block and convert internal newlines to <br>.
  275.           paragraphs[i] = processInline(para).replace(/\n/g, '<br>');
  276.         }
  277.       }
  278.     }
  279.     text = paragraphs.join("\n");
  280.     
  281.     // 6. Reinstate inline code placeholders.
  282.     for (let obj of inlineCodePlaceholders) {
  283.       text = text.replace(obj.placeholder, `<code>${obj.code}</code>`);
  284.     }
  285.     
  286.     // 7. Reinstate code block placeholders with a copy button.
  287.     for (let obj of codeBlockPlaceholders) {
  288.       let replacement;
  289.       if (obj.lang) {
  290.         replacement = `<div class="code-block-container">
  291.   <button class="code-copy-button">Copy</button>
  292.   <pre><code class="hljs language-${obj.lang}">${obj.code}</code></pre>
  293. </div>`;
  294.       } else {
  295.         replacement = `<div class="code-block-container">
  296.   <button class="code-copy-button">Copy</button>
  297.   <pre><code class="hljs">${obj.code}</code></pre>
  298. </div>`;
  299.       }
  300.       text = text.replace(obj.placeholder, replacement);
  301.     }
  302.     
  303.     return text;
  304.   }
  305.   
  306.   /***** EMOJI WRAPPING *****/
  307.   const emojiRegex = /([\u{1F300}-\u{1F5FF}\u{1F600}-\u{1F64F}\u{1F680}-\u{1F6FF}\u{1F700}-\u{1F77F}\u{1F780}-\u{1F7FF}\u{1F800}-\u{1F8FF}\u{1F900}-\u{1F9FF}\u{1FBA0}-\u{1FBAF}\u{1FAD0}-\u{1FADF}\u{1FA00}-\u{1FA6F}\u{1FA70}-\u{1FAFF}]+)/gu;
  308.   function wrapEmojisInTextNode(textNode) {
  309.     const text = textNode.nodeValue;
  310.     if (!emojiRegex.test(text)) return;
  311.     emojiRegex.lastIndex = 0;
  312.     const parts = text.split(emojiRegex);
  313.     const fragment = document.createDocumentFragment();
  314.     let emojiSpan = null;
  315.     for (const part of parts) {
  316.       if (emojiRegex.test(part)) {
  317.         if (!emojiSpan) {
  318.           emojiSpan = document.createElement('span');
  319.           emojiSpan.className = 'emoji';
  320.         }
  321.         emojiSpan.textContent += part;
  322.       } else {
  323.         if (emojiSpan) {
  324.           fragment.appendChild(emojiSpan);
  325.           emojiSpan = null;
  326.         }
  327.         if (part) {
  328.           fragment.appendChild(document.createTextNode(part));
  329.         }
  330.       }
  331.     }
  332.     if (emojiSpan) {
  333.       fragment.appendChild(emojiSpan);
  334.     }
  335.     textNode.parentNode.replaceChild(fragment, textNode);
  336.   }
  337.   function wrapEmojis(node) {
  338.     if (node.nodeType === Node.TEXT_NODE) {
  339.       wrapEmojisInTextNode(node);
  340.     } else if (node.nodeType === Node.ELEMENT_NODE) {
  341.       if (node.classList.contains('emoji')) return;
  342.       Array.from(node.childNodes).forEach(child => wrapEmojis(child));
  343.     }
  344.   }
  345.   /***** PROCESS CHAT MESSAGES *****/
  346.   function formatChatMessage(el) {
  347.     if (el.dataset.formatted === 'true') return;
  348.     
  349.     // Replace <img class="emojione"> with its alt text.
  350.     el.querySelectorAll('img.emojione').forEach(img => {
  351.       const alt = img.getAttribute('alt') || '';
  352.       const span = document.createElement('span');
  353.       span.className = 'emoji';
  354.       span.textContent = alt;
  355.       img.parentNode.replaceChild(span, img);
  356.     });
  357.     
  358.     const raw = el.innerText;
  359.     const html = parseMarkdown(raw);
  360.     el.innerHTML = html;
  361.     
  362.     // Apply highlight.js to code blocks if available.
  363.     el.querySelectorAll('pre code').forEach(block => {
  364.       if (window.hljs) {
  365.         hljs.highlightElement(block);
  366.       }
  367.     });
  368.     
  369.     wrapEmojis(el);
  370.     el.dataset.formatted = 'true';
  371.     
  372.     // Attach copy-button functionality.
  373.     el.querySelectorAll('.code-copy-button').forEach(button => {
  374.       button.addEventListener('click', function() {
  375.         const codeElem = button.parentElement.querySelector('pre code');
  376.         if (codeElem) {
  377.           const codeText = codeElem.innerText;
  378.           navigator.clipboard.writeText(codeText).then(() => {
  379.             button.innerText = 'Copied!';
  380.             setTimeout(() => { button.innerText = 'Copy'; }, 2000);
  381.           });
  382.         }
  383.       });
  384.     });
  385.   }
  386.   
  387.   /***** INITIALIZATION & OBSERVER *****/
  388.   const isMod = document.querySelector('#is_mod').value === "1";
  389.   const originalContentMap = new Map();
  390.  
  391.   document.querySelectorAll('.chat-txt, .file-caption').forEach(el => {
  392.     if (isMod) {
  393.       console.log(el.innerText);
  394.       originalContentMap.set(el, el.innerHTML);
  395.     }
  396.     formatChatMessage(el);
  397.   });
  398.  
  399.   const observer = new MutationObserver(mutations => {
  400.     mutations.forEach(mutation => {
  401.       mutation.addedNodes.forEach(node => {
  402.         if (node.nodeType === Node.ELEMENT_NODE) {
  403.           if ((node.matches('.chat-txt') || node.matches('.file-caption')) && !node.dataset.formatted) {
  404.             if (isMod) {
  405.               console.log(node.innerText);
  406.               originalContentMap.set(node, node.innerHTML);
  407.             }
  408.             formatChatMessage(node);
  409.           } else {
  410.             node.querySelectorAll('.chat-txt, .file-caption').forEach(el => {
  411.               if (isMod) {
  412.                 console.log(el.innerText);
  413.                 originalContentMap.set(el, el.innerHTML);
  414.               }
  415.               formatChatMessage(el);
  416.             });
  417.           }
  418.         }
  419.       });
  420.       mutation.target.querySelectorAll('.chat-txt.deleted').forEach(deletedNode => {
  421.         const chtElement = deletedNode.closest('.cht');
  422.         if (chtElement) {
  423.           if (isMod) {
  424.             const originalContent = originalContentMap.get(deletedNode);
  425.             if (originalContent) {
  426.               deletedNode.innerHTML = originalContent;
  427.               deletedNode.style.color = 'red';
  428.               deletedNode.style.fontWeight = 'bold';
  429.               deletedNode.classList.remove('deleted');
  430.             }
  431.           } else {
  432.             chtElement.style.display = 'none';
  433.           }
  434.         }
  435.       });
  436.     });
  437.   });
  438.  
  439.   observer.observe(document.body, { childList: true, subtree: true });
  440.   let messageCount = 0;
  441.  
  442.   function addMexMessage() {
  443.     const _chatBox = document.querySelector('.chat-box');
  444.     if (_chatBox) {
  445.       const _mexMessage = document.createElement('div');
  446.       _mexMessage.className = 'chat-txt mex-message';
  447.       _mexMessage.style.display = 'none';
  448.       _mexMessage.innerText = `
  449.       --------------------
  450.       This was sent with Diamondberry
  451.       Add it here: https://diamondberry.run
  452.       Note that whoever sent this doesn't see this message lol`;
  453.       _chatBox.appendChild(_mexMessage);
  454.     }
  455.   }
  456.  
  457.   function _formatChatMessage(el) {
  458.     if (el.dataset.formatted === 'true') return;
  459.  
  460.     // Replace <img class="emojione"> with its alt text.
  461.     el.querySelectorAll('img.emojione').forEach(img => {
  462.       const alt = img.getAttribute('alt') || '';
  463.       const span = document.createElement('span');
  464.       span.className = 'emoji';
  465.       span.textContent = alt;
  466.       img.parentNode.replaceChild(span, img);
  467.     });
  468.  
  469.     const raw = el.innerText;
  470.     const html = parseMarkdown(raw);
  471.     el.innerHTML = html;
  472.  
  473.     // Apply highlight.js to code blocks if available.
  474.     el.querySelectorAll('pre code').forEach(block => {
  475.       if (window.hljs) {
  476.         hljs.highlightElement(block);
  477.       }
  478.     });
  479.  
  480.     wrapEmojis(el);
  481.     el.dataset.formatted = 'true';
  482.  
  483.     // Attach copy-button functionality.
  484.     el.querySelectorAll('.code-copy-button').forEach(button => {
  485.       button.addEventListener('click', function() {
  486.         const codeElem = button.parentElement.querySelector('pre code');
  487.         if (codeElem) {
  488.           const codeText = codeElem.innerText;
  489.           navigator.clipboard.writeText(codeText).then(() => {
  490.             button.innerText = 'Copied!';
  491.             setTimeout(() => { button.innerText = 'Copy'; }, 2000);
  492.           });
  493.         }
  494.       });
  495.     });
  496.  
  497.     // Check for mex message and hide it
  498.     if (el.innerText.toLowerCase().includes('mex')) {
  499.       el.style.display = 'none';
  500.     }
  501.   }
  502.  
  503.   document.addEventListener('DOMContentLoaded', function() {
  504.     const sendButton = document.querySelector('.btn-send');
  505.     if (sendButton) {
  506.       sendButton.addEventListener('click', function() {
  507.         messageCount++;
  508.         if (messageCount % 2 === 1) {
  509.           addMexMessage();
  510.         }
  511.       });
  512.     }
  513.   });
  514. })();