Readers copy pages. They paste a pricing table into a spreadsheet, an email template into their drafts, a definition into a note. What arrives in the clipboard is not the HTML, not textContent, and not quite innerText: it is the rendered text of the selection, filtered by a CSS property most of us set without thinking.

I measured it across all 76 public pages of Nakodo with the browser's own selection:

const sel = getSelection(); sel.removeAllRanges(); const range = document.createRange(); range.selectNodeContents(document.body); sel.addRange(range); const copied = sel.toString(); // what Ctrl+C would put on the clipboard 

653,476 characters

Characters copied across 76 pages 653,476
Lines 13,428
Largest page, /how-it-works 16,780
Smallest page, /alternatives 2,523
Footer, identical on every page 878
Header, identical on every page 45

The two constants are my favourite detail in this measurement. Every page on the site starts with the same 45 characters and ends with the same 878, so a reader who selects a whole page and pastes it gets a navigation menu, then the content, then 878 characters of site furniture. That is the shape of a copied web page and nothing in our markup makes it otherwise.

The header being exactly 45 characters is the first hint of what this post is about. The header holds a brand name, five links and a button, and the selectable part is:

nakodo How it works Guides Blog Pricing About 

Six lines, 45 characters, and no sign of the button that says "Open the app".

The clipboard gets less than innerText, and the gap is your buttons

On every one of the 76 pages, document.body.innerText was longer than what the selection produced. The gap ran from 52 to 178 characters, median 69.

On the home page the eight strings in innerText that never reach the clipboard are:

Open the app Start free https:// Compare every limit Start free Try Pro free for 7 days Choose Business Open the app 

Those are every call to action on the page, plus the https:// prefix glued to the front of the website field. They are missing for one reason:

$ grep -n "select-none" src/components/ui/button.tsx inline-flex shrink-0 items-center justify-center gap-2 select-none ... 

user-select: none is in the base class of our button component, which is where the shadcn generator put it, and it is a perfectly sensible default: dragging across a button should not leave it highlighted. The side effect is that a reader who copies the page loses the words that tell them what to do next.

Unselectable elements per page, counted by computed style:

Page Elements with user-select: none
/tools/engagement-rate-calculator 35
/guides/youtube-outreach-email-templates 33
/how-it-works 9
/privacy 7

The outreach-templates guide earns its 33 honestly: it holds six example messages, each with its own Copy button, and each of those buttons is three unselectable elements (the button, its icon, the icon's path). Copy the whole guide and you get all six messages and not one of the six words "Copy", which is the right outcome by accident rather than by design.

The text written for screen readers does come along

Only two of the 76 pages have any sr-only text in them at all, and on both of them, all of it lands in the clipboard.

The pricing page has four, and they are the word "Yes" sitting behind the four ticks in the comparison table. Copy that table into a spreadsheet and you get "Yes" in the cells where a tick is, which is exactly what you wanted and would not have got from an icon alone. Visually hidden text is what makes a pasted table readable.

The home page has eight, and they are a different kind of thing: status words for the icons in a small example table, including "published", "not published", and a sentence explaining why one row has no email address. Pasting that sample gets you the labels interleaved with the rows. It is not wrong, and it is not what somebody copying an example table is after.

So sr-only has a second audience nobody designs for. The rule I would draw from the two pages is that hidden text standing in for a symbol (a tick, a status dot) is a gift to the clipboard, and hidden text explaining an interface is clutter in it.

Range, Selection and innerText are three different answers

This is the part that cost me a measurement. My first pass compared regions using Range.toString() and got a number larger than the whole page:

new Range().selectNodeContents(document.querySelector("main")).toString().length; // 14,852 getSelection().toString().length; // 6,943 for the entire page 

A Range concatenates text nodes. It does not care about CSS, and it does not care whether an element is rendered, so it happily includes the contents of <script> tags. On the home page that is 362,221 characters of framework payload, and on /how-it-works it is 334,451. Measure "how much text is on this page" with a Range and you are mostly measuring your own serialised component tree.

The three APIs, ranked by how close they are to the clipboard:

API Includes hidden elements Includes <script> Honours user-select
textContent yes yes no
Range.toString() yes yes no
innerText no no no
Selection.toString() no no yes

Only the last one answers the question a reader asks.

One selection rule, and one copy helper

Two small things found in passing.

There is exactly one ::selection rule in 154 KB of stylesheet:

::selection { background: var(--color-cyano-100); color: var(--color-cyano-950); } :root { caret-color: var(--color-cyano-700); } 

A pale brand blue behind the selected text and a brand-coloured caret. Two declarations, applied every time anybody drags across anything on the site, and the cheapest branding on the whole page.

And the only programmatic copying anywhere on the public site is 20 buttons across 8 guides, all of them driven by one 16-line helper:

export async function copyText(text: string, done?: string): Promise<boolean> { try { await navigator.clipboard.writeText(text); if (done) notify({ message: done }); return true; } catch { notify({ error: "Couldn't copy. Select the text and copy it yourself." }); return false; } } 

The clipboard API can refuse: no permission, an insecure origin, an older browser. The fallback is not a hidden textarea and an execCommand that has been deprecated for years. It is a sentence telling the reader to do the thing they already know how to do, which works because the text that button copies is in a paragraph, selectable, right next to it.

What came out of it

  1. Decide about select-none on link-shaped buttons. Our primary calls to action are links wearing a button class, and copying a page silently drops their wording. Dragging over a text link should select it. The property belongs on controls that behave like controls, not on everything that looks like one.
  2. Review the eight hidden strings on the home page. The four on the pricing table should stay: they are what makes a paste make sense. The ones narrating an example table probably should not be in a copy of it.
  3. Use Selection.toString() when you audit your own text. innerText is close but blind to user-select, and a Range will quietly hand you a quarter of a megabyte of your framework's payload.

Everything here is reproducible on the live site. Open the home page, press Ctrl+A and Ctrl+C, paste it into a text editor, and look for the words "Start free". Then do the same on the pricing page and look for the word "Yes".