Before threaded conversations were a design feature and before email clients formatted quotes visually, the internet had a simpler quoting convention: prepend a greater-than sign to text you were responding to. > This is what you said. And this is my reply. It was a purely textual formatting convention inherited from early ARPANET email culture, carried through Usenet, and still in active use in plain-text email workflows and IRC in the early 2000s.

PasteQuote automated this. It was a Firefox extension from the Palancar suite (palancar.net) that modified the paste action in text input fields: instead of pasting clipboard text as-is, it prepended > to each line, formatting the pasted content as a quote in the traditional style. One keystroke, properly formatted quote block.

What PasteQuote Was

PasteQuote intercepted paste events in Firefox’s text input fields and textareas, and transformed the clipboard content before inserting it. Specifically, it split the clipboard text by line breaks and prepended the > prefix to each line, then inserted the resulting block at the cursor position.

The target users were people doing a significant portion of their communication through:

Usenet newsgroups. Usenet was still heavily active in the mid-2000s, and proper quoting — trimmed to just the relevant passage, with > prefixes clearly showing what you were responding to — was a point of community etiquette. Web-based Usenet interfaces (including Google Groups in its early form) used browser textareas for composing replies. PasteQuote made proper quoting fast.

Plain-text email. Webmail users composing in Thunderbird or using early webmail interfaces in Firefox who preferred plain-text formatting over HTML-formatted email. The > quoting convention was the plain-text equivalent of inline block quotes.

IRC and early forum software. Any text-based discussion format where block quoting wasn’t a built-in formatting feature.

The extension operated in the background. It didn’t add a button or toolbar element — it simply modified the behavior of the paste keyboard shortcut (Ctrl+V / Cmd+V) when the focus was in a text input. Some versions offered a separate paste-as-quote shortcut to preserve the normal paste behavior.

How It Worked Technically

PasteQuote used Firefox’s XUL event handling to intercept paste events at the browser level. The technical approach involved overriding the default paste handler for <textarea> and <input type="text"> elements:

// Simplified representation of the approach
document.addEventListener('paste', function(e) {
  const target = e.target;
  if (target.tagName === 'TEXTAREA' || 
      (target.tagName === 'INPUT' && target.type === 'text')) {
    
    e.preventDefault(); // Intercept the paste
    
    const clipboardText = e.clipboardData.getData('text/plain');
    const quoted = clipboardText
      .split('\n')
      .map(line => '> ' + line)
      .join('\n');
    
    // Insert at cursor position
    const start = target.selectionStart;
    const end = target.selectionEnd;
    target.value = target.value.substring(0, start) + 
                   quoted + 
                   target.value.substring(end);
    target.selectionStart = target.selectionEnd = start + quoted.length;
  }
}, true);

The event capture model (true as the third addEventListener argument) was important — it allowed the extension to intercept the event before the page’s own JavaScript handlers ran, preventing conflicts with rich text editors that had their own paste handling.

Handling the clipboard required access to the clipboard contents, which in the XUL era was done via the nsIClipboard XPCOM service. In modern WebExtensions, the Clipboard API and the clipboardRead permission provide this access.

The edge case of preserving existing indentation levels — so that > Already quoted text would become >> Already quoted text — required line-level parsing that PasteQuote handled in its more developed versions. This double-quoting behavior matched Usenet convention where multiple levels of quoting indicated longer reply chains.

The Decline of the Quoting Convention

PasteQuote’s obsolescence was driven less by technical change and more by communication culture change. The > quoting convention declined in mainstream use for several reasons:

HTML email became the default. By the mid-2000s, webmail services (Gmail, Hotmail, Yahoo Mail) had standardized on HTML-formatted email with built-in block quoting — visually distinguished, collapsible, clearly formatted. The > convention was a workaround for limitations that HTML email had solved.

Threaded conversations replaced linear quoting. Modern email clients, Slack, Discord, and forum software present conversations as threaded structures. You reply to a specific message by clicking a reply button; the context is preserved visually without any manual quoting. The entire premise of “paste and quote” became unnecessary.

Rich text editors proliferated. Webmail and early web apps in 2004-2006 often used basic <textarea> elements for composing. By 2010, most had migrated to rich text editors (TinyMCE, Quill, draft.js) with built-in quote blocks. The underlying <textarea> that PasteQuote targeted was increasingly absent from modern web apps.

Usenet declined. The primary community that maintained > quoting as a cultural norm became smaller. By 2010, Usenet was largely inaccessible to most web users, with the communities that had lived there having migrated to forums, Reddit, and social media platforms.

Why It Was Discontinued

PasteQuote was discontinued through a combination of the XUL deprecation (Firefox 57, November 2017) and the erosion of its use case. Unlike ContextSearch or DisableTarget — which addressed problems that remained relevant — PasteQuote’s core use case had genuinely diminished.

The > quoting convention survives in specific communities: plain-text email purists, Markdown-based writing tools (where > creates a blockquote in Markdown), and some developer communications. But these are specialist workflows rather than mainstream browser behavior.

Palancar’s extension suite was not migrated to WebExtensions, and PasteQuote — with its shrinking user base — was among the least compelling candidates for a rewrite.

What Replaced It

For the specific workflows where > quoting remains relevant, several modern approaches apply:

Markdown-aware tools. In Markdown, > is block-quote syntax. Text editors with Markdown support (VS Code, Typora, Obsidian, iA Writer) automatically render > prefixes as block quotes. If you’re writing Markdown — for GitHub comments, README files, or documentation — the quoting convention lives natively in the format.

Plain-text email clients. Thunderbird’s plain-text compose mode includes automatic quote-wrapping when replying. For users of Mutt, Alpine, or other terminal email clients, > quoting is the default and needs no extension.

Browser-based extensions for Markdown:

  • Markdown Here — transforms Markdown-formatted text in browser compose fields into rendered HTML before sending. This handles blockquotes via the > Markdown syntax, covering most of PasteQuote’s use case for email users who write in Markdown.

Custom userscripts. For very specific workflows where you want paste-as-quote behavior in particular web apps, a Greasemonkey or Tampermonkey userscript can replicate PasteQuote’s behavior with minimal setup.

If You’re Building Something Similar Today

A modern WebExtension equivalent for paste-as-quote behavior is technically straightforward:

// content.js
document.addEventListener('paste', function(e) {
  const target = e.target;
  if (!isTextInput(target)) return;
  
  // Only intercept if modifier key held (e.g., Ctrl+Shift+V for paste-as-quote)
  if (!e.shiftKey) return;
  
  e.preventDefault();
  
  const text = e.clipboardData.getData('text/plain');
  const quoted = text.split('\n').map(line => '> ' + line).join('\n');
  
  document.execCommand('insertText', false, quoted);
}, true);

function isTextInput(el) {
  return el.tagName === 'TEXTAREA' || 
         (el.tagName === 'INPUT' && ['text', 'search', 'email'].includes(el.type)) ||
         el.isContentEditable;
}

Using a modifier key (Shift in this example) preserves normal paste behavior and only activates quote-formatting when explicitly requested — a better UX than PasteQuote’s original always-on interception.

The document.execCommand('insertText') approach works in most contexts, though it’s technically deprecated. The modern alternative uses the Selection API and direct DOM manipulation. The Clipboard API documentation at developer.mozilla.org covers reading clipboard contents from WebExtensions.

Note that contentEditable elements — which modern rich text editors use instead of <textarea> — require different handling for text insertion, and paste interception in those contexts may conflict with the editor’s own paste handlers.

A Convention That Outlived Its Context

The > quoting convention is one of those artifacts of internet culture that feels obvious in its original context (plain-text communication where visual markup was unavailable) and quaint in a modern context (where every platform has rich text, threading, and reply context built in). PasteQuote served a real workflow that a real community relied on during a specific period of the web’s development.

The convention itself hasn’t disappeared — it’s alive in Markdown, in developer tooling, in email clients that target technical users. But the general-purpose browser extension that automated it for mainstream webmail users served its moment and then became unnecessary.

The original palancar.net extension page is archived at web.archive.org.