import { S as Source } from './types-D8ZUfj4U.cjs'; /** * `--live-scroll-velocity` (signed px/frame, decays toward 0 when idle), * `--live-scroll-direction` (1 down / -1 up / 0). * * Idles when the page isn't scrolling: a scroll event wakes a per-frame sampler * that decays the velocity and then stops itself once it reaches 0. */ declare const scrollVelocity: Source; /** `--live-online` (0/1) */ declare const online: Source; /** * `--live-page-focused` (1/0) — whether the document currently has focus: the * tab is frontmost *and* its window is focused. Goes `0` when the user switches * to another tab, window, or app, and back to `1` on return. Driven by window * `focus`/`blur`, seeded from `document.hasFocus()`. * * Note: a blurred-but-still-visible window (e.g. clicking another app side by * side) keeps rAF alive, so the `0` flushes and CSS can react. Switching tabs * pauses rAF, so the change applies on return — invisible while hidden anyway. */ declare const pageFocused: Source; /** * `--live-page-visible` (1/0) — whether the tab is currently visible * (foreground) versus hidden (backgrounded, minimized, or switched away). * * Distinct from `page-focused`: a *visible* tab can still be *unfocused* (another * window holds focus while this one stays on screen). Visibility gates the things * that should pause when truly hidden — video, polling, expensive effects — where * focus gates the things that react to "is the user looking here right now." * Driven by `visibilitychange`, seeded from `document.visibilityState`. * * The `0` is real but never *paints*: the shared frame loop freezes on the same * `visibilitychange` (nothing can be shown to a hidden tab), so the queued `0` is * coalesced away by the `1` on return. Read it in JS, or use it to hold state * across a hide — don't expect CSS to render a hidden state. */ declare const pageVisible: Source; /** * `--const-nav-type` — how the user arrived at this page, read once from * `performance.getEntriesByType('navigation')[0].type`: * * - `navigate` — a fresh navigation (typed URL, link, form, or script) * - `reload` — the page was reloaded * - `back_forward` — history traversal (Back/Forward, often a bfcache restore) * - `prerender` — the page was prerendered * * Written once as a string on the `const` cadence, so it pairs with style queries * — `@container style(--const-nav-type: reload) { … }` — to branch styling on how * the visit started. Falls back to `navigate` where Navigation Timing is absent. * * Typed (`configure({ typed: true })`) registers it as a `` so the * string survives `@property`. Note it rides the batched writer like any plugin, * so it lands the frame *after* bind, not before first paint — for a FOUC-safe, * pre-paint constant, read the same value synchronously in a `` script. */ declare const navType: Source; /** * Every `` value on the page that JavaScript can read but CSS can't, * exposed as write-once `--const-meta-*` properties on `:root`. Each meta with a * `name` (or `property`, for Open Graph / Twitter) plus `content` becomes * `--const-meta-`, where the slug lowercases the name and turns any run of * non-alphanumerics into a single dash: * * → --const-meta-theme-color * → --const-meta-og-image * → --const-meta-color-scheme * * so CSS can read page metadata directly: * * .bar { background: var(--const-meta-theme-color); } * .hero { background-image: url(var(--const-meta-og-image)); } * @container style(--const-meta-color-scheme: dark) { … } * * **First match wins** for a repeated name, and a meta with a `media` attribute * is skipped when that query doesn't currently match — so the *active* * `theme-color` variant (light vs dark) is the one written. Values are read once * at bind on the `const` cadence (these don't change), so meta tags a framework * swaps in *after* bind aren't tracked; for a value needed before first paint, * read it in a `` script instead. Global source — bind once. * * These names are discovered at runtime, so the source can't declare `props` for * them and they stay **untyped** even under `configure({ typed: true })` — which * is what keeps the values intact, since the `` default would reject a * colour or a URL and compute it to `0`. */ declare const meta: Source; /** * `--live-net-downlink`, `--live-net-rtt`, `--live-net-save-data` (0/1), * `--live-net-type` (slow-2g=1, 2g=2, 3g=3, 4g=4, else 0). */ declare const network: Source; /** `--live-battery-level` (0–1), `--live-battery-charging` (0/1) */ declare const battery: Source; /** * `--live-now` (epoch seconds), `--live-hours`, `--live-minutes`, `--live-seconds`. * Re-armed to each whole second so it doesn't drift. */ declare const clock: Source; declare const fps: Source; /** * `--live-vvp-scale`, `--live-vvp-offset-top`, `--live-vvp-height` * from `window.visualViewport`. */ declare const visualViewport: Source; declare const keyboard: Source; /** * `--live-pointer-x/y` (px) and `--live-pointer-x/y-ratio` (0–1 across viewport), * written to `:root`. * * High-frequency (a write per `pointermove`), so it's an opt-in plugin rather * than a core source: import it from `prop-for-that/plugins`, or — under `auto` * — request it declaratively (``) and it's * loaded on demand. */ declare const pointer: Source; /** * `--live-local-pointer-x-ratio`, `--live-local-pointer-y-ratio` (0–1 within the * element's box), `--live-local-pointer-inside` (0/1). * * Shares the page's single `pointermove` listener, but reads the element's rect * on **every move** so it stays correct through layout shifts, which a cached * rect would miss. That's one `getBoundingClientRect` per bound element per * move — cheap when layout is clean, but bind it to the few elements that need * it rather than to every card in a grid. * * Seeded to zeros so all three properties resolve on frame one. Until the first * move the ratios are meaningless, so gate on `--live-local-pointer-inside` * (`0` until the pointer is actually over the element) rather than assuming the * pointer starts in the top-left corner. */ declare const pointerLocal: Source; /** * For `