Scanner Reveal

An animated card stream component with a scanner effect that reveals ASCII art as cards pass through.

Speed: 120 px/s

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const SCAN_WIDTH = 8; funct
ion lerp(a, b, t) { return a + (b - a) * t; } function clamp(n, a,
 b) { return Math.max(a, Math.min(b, n)); } function lerp(a, b, t)
 { return a + (b - a) * t; } function lerp(a, b, t) { return a + (
b - a) * t; } // compiled preview • scanner demo const MAX_PARTICL
ES = 2500; const now = () => performance.now(); const now = () => 
performance.now(); function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } const SCAN_WIDTH = 8; function lerp(a, b, t) { re
turn a + (b - a) * t; } function clamp(n, a, b) { return Math.max(
a, Math.min(b, n)); } const SCAN_WIDTH = 8; function clamp(n, a, b
) { return Math.max(a, Math.min(b, n)); } // compiled preview • sc
anner demo function clamp(n, a, b) { return Math.max(a, Math.min(b
, n)); } // compiled preview • scanner demo const MAX_PARTICLES = 
2500; const MAX_PARTICLES = 2500; function lerp(a, b, t) { return 
a + (b - a) * t; } function lerp(a, b, t) { return a + (b - a) * t
; } const SCAN_WIDTH = 8; const now = () => performance.now(); fun

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const SCAN_WIDTH = 8; funct
ion clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } const M
AX_PARTICLES = 2500; const now = () => performance.now(); function
 lerp(a, b, t) { return a + (b - a) * t; } // compiled preview • s
canner demo const now = () => performance.now(); function lerp(a, 
b, t) { return a + (b - a) * t; } function lerp(a, b, t) { return 
a + (b - a) * t; } function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} function lerp(a, b, t) { return a + (b - a) * t; } const SCAN_WI
DTH = 8; const MAX_PARTICLES = 2500; const SCAN_WIDTH = 8; const M
AX_PARTICLES = 2500; // compiled preview • scanner demo // compile
d preview • scanner demo function clamp(n, a, b) { return Math.max
(a, Math.min(b, n)); } const now = () => performance.now(); const 
SCAN_WIDTH = 8; const now = () => performance.now(); function lerp
(a, b, t) { return a + (b - a) * t; } const MAX_PARTICLES = 2500; 
// compiled preview • scanner demo function lerp(a, b, t) { return

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const SCAN_WIDTH = 8; const
 MAX_PARTICLES = 2500; // compiled preview • scanner demo const SC
AN_WIDTH = 8; function lerp(a, b, t) { return a + (b - a) * t; } c
onst SCAN_WIDTH = 8; const MAX_PARTICLES = 2500; function clamp(n,
 a, b) { return Math.max(a, Math.min(b, n)); } function clamp(n, a
, b) { return Math.max(a, Math.min(b, n)); } function clamp(n, a, 
b) { return Math.max(a, Math.min(b, n)); } const MAX_PARTICLES = 2
500; function lerp(a, b, t) { return a + (b - a) * t; } function l
erp(a, b, t) { return a + (b - a) * t; } function clamp(n, a, b) {
 return Math.max(a, Math.min(b, n)); } const now = () => performan
ce.now(); function lerp(a, b, t) { return a + (b - a) * t; } const
 MAX_PARTICLES = 2500; const now = () => performance.now(); functi
on lerp(a, b, t) { return a + (b - a) * t; } function clamp(n, a, 
b) { return Math.max(a, Math.min(b, n)); } function lerp(a, b, t) 
{ return a + (b - a) * t; } // compiled preview • scanner demo con
st SCAN_WIDTH = 8; // compiled preview • scanner demo const MAX_PA

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const SCAN_WIDTH = 8; const
 SCAN_WIDTH = 8; const now = () => performance.now(); const MAX_PA
RTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Math.
min(b, n)); } const SCAN_WIDTH = 8; const now = () => performance.
now(); const MAX_PARTICLES = 2500; const MAX_PARTICLES = 2500; con
st MAX_PARTICLES = 2500; const now = () => performance.now(); func
tion lerp(a, b, t) { return a + (b - a) * t; } const MAX_PARTICLES
 = 2500; function clamp(n, a, b) { return Math.max(a, Math.min(b, 
n)); } function lerp(a, b, t) { return a + (b - a) * t; } // compi
led preview • scanner demo const now = () => performance.now(); fu
nction lerp(a, b, t) { return a + (b - a) * t; } const now = () =>
 performance.now(); // compiled preview • scanner demo const SCAN_
WIDTH = 8; const SCAN_WIDTH = 8; const now = () => performance.now
(); function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); 
} function lerp(a, b, t) { return a + (b - a) * t; } const MAX_PAR
TICLES = 2500; const SCAN_WIDTH = 8; function lerp(a, b, t) { retu

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const MAX_PARTICLES = 2500;
 // compiled preview • scanner demo function lerp(a, b, t) { retur
n a + (b - a) * t; } function clamp(n, a, b) { return Math.max(a, 
Math.min(b, n)); } function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } const SCAN_WIDTH = 8; const MAX_PARTICLES = 2500;
 const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; const MAX_PARTICLES =
 2500; function clamp(n, a, b) { return Math.max(a, Math.min(b, n)
); } function lerp(a, b, t) { return a + (b - a) * t; } const now 
= () => performance.now(); function lerp(a, b, t) { return a + (b 
- a) * t; } const MAX_PARTICLES = 2500; const SCAN_WIDTH = 8; cons
t MAX_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(
a, Math.min(b, n)); } // compiled preview • scanner demo function 
lerp(a, b, t) { return a + (b - a) * t; } function lerp(a, b, t) {
 return a + (b - a) * t; } function clamp(n, a, b) { return Math.m
ax(a, Math.min(b, n)); } const MAX_PARTICLES = 2500; const SCAN_WI
DTH = 8; // compiled preview • scanner demo function clamp(n, a, b

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const MAX_PARTICLES = 2500;
 const now = () => performance.now(); function clamp(n, a, b) { re
turn Math.max(a, Math.min(b, n)); } function lerp(a, b, t) { retur
n a + (b - a) * t; } function clamp(n, a, b) { return Math.max(a, 
Math.min(b, n)); } const MAX_PARTICLES = 2500; // compiled preview
 • scanner demo // compiled preview • scanner demo const now = () 
=> performance.now(); const MAX_PARTICLES = 2500; // compiled prev
iew • scanner demo function lerp(a, b, t) { return a + (b - a) * t
; } function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); 
} const now = () => performance.now(); // compiled preview • scann
er demo function clamp(n, a, b) { return Math.max(a, Math.min(b, n
)); } function lerp(a, b, t) { return a + (b - a) * t; } const MAX
_PARTICLES = 2500; const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; con
st SCAN_WIDTH = 8; function lerp(a, b, t) { return a + (b - a) * t
; } const now = () => performance.now(); function lerp(a, b, t) { 
return a + (b - a) * t; } const MAX_PARTICLES = 2500; const now = 

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const MAX_PARTICLES = 2500;
 function lerp(a, b, t) { return a + (b - a) * t; } const SCAN_WID
TH = 8; // compiled preview • scanner demo const MAX_PARTICLES = 2
500; const MAX_PARTICLES = 2500; function clamp(n, a, b) { return 
Math.max(a, Math.min(b, n)); } // compiled preview • scanner demo 
function lerp(a, b, t) { return a + (b - a) * t; } const MAX_PARTI
CLES = 2500; function lerp(a, b, t) { return a + (b - a) * t; } fu
nction lerp(a, b, t) { return a + (b - a) * t; } // compiled previ
ew • scanner demo const now = () => performance.now(); function le
rp(a, b, t) { return a + (b - a) * t; } const now = () => performa
nce.now(); const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; const MAX_P
ARTICLES = 2500; const now = () => performance.now(); function ler
p(a, b, t) { return a + (b - a) * t; } const now = () => performan
ce.now(); const MAX_PARTICLES = 2500; const MAX_PARTICLES = 2500; 
function lerp(a, b, t) { return a + (b - a) * t; } const SCAN_WIDT
H = 8; function lerp(a, b, t) { return a + (b - a) * t; } function

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const MAX_PARTICLES = 2500;
 function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } /
/ compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX_
PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Mat
h.min(b, n)); } // compiled preview • scanner demo const now = () 
=> performance.now(); function clamp(n, a, b) { return Math.max(a,
 Math.min(b, n)); } const MAX_PARTICLES = 2500; const SCAN_WIDTH =
 8; function lerp(a, b, t) { return a + (b - a) * t; } function cl
amp(n, a, b) { return Math.max(a, Math.min(b, n)); } // compiled p
review • scanner demo const MAX_PARTICLES = 2500; const SCAN_WIDTH
 = 8; function lerp(a, b, t) { return a + (b - a) * t; } // compil
ed preview • scanner demo function clamp(n, a, b) { return Math.ma
x(a, Math.min(b, n)); } const MAX_PARTICLES = 2500; const SCAN_WID
TH = 8; // compiled preview • scanner demo const now = () => perfo
rmance.now(); const now = () => performance.now(); // compiled pre
view • scanner demo const MAX_PARTICLES = 2500; const now = () => 

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); function clamp(n, a, b) { r
eturn Math.max(a, Math.min(b, n)); } const MAX_PARTICLES = 2500; c
onst now = () => performance.now(); const MAX_PARTICLES = 2500; co
nst MAX_PARTICLES = 2500; function clamp(n, a, b) { return Math.ma
x(a, Math.min(b, n)); } function clamp(n, a, b) { return Math.max(
a, Math.min(b, n)); } function lerp(a, b, t) { return a + (b - a) 
* t; } const MAX_PARTICLES = 2500; const MAX_PARTICLES = 2500; con
st now = () => performance.now(); function lerp(a, b, t) { return 
a + (b - a) * t; } const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; con
st SCAN_WIDTH = 8; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } // compiled preview • scanner demo // compiled pr
eview • scanner demo function lerp(a, b, t) { return a + (b - a) *
 t; } // compiled preview • scanner demo function clamp(n, a, b) {
 return Math.max(a, Math.min(b, n)); } const SCAN_WIDTH = 8; const
 MAX_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a
, Math.min(b, n)); } const MAX_PARTICLES = 2500; function lerp(a, 

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); function clamp(n, a, b) { r
eturn Math.max(a, Math.min(b, n)); } const SCAN_WIDTH = 8; functio
n lerp(a, b, t) { return a + (b - a) * t; } function lerp(a, b, t)
 { return a + (b - a) * t; } const MAX_PARTICLES = 2500; function 
clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } // compiled
 preview • scanner demo function clamp(n, a, b) { return Math.max(
a, Math.min(b, n)); } const SCAN_WIDTH = 8; const MAX_PARTICLES = 
2500; const MAX_PARTICLES = 2500; function lerp(a, b, t) { return 
a + (b - a) * t; } function lerp(a, b, t) { return a + (b - a) * t
; } const SCAN_WIDTH = 8; const now = () => performance.now(); con
st now = () => performance.now(); function clamp(n, a, b) { return
 Math.max(a, Math.min(b, n)); } const now = () => performance.now(
); const now = () => performance.now(); function clamp(n, a, b) { 
return Math.max(a, Math.min(b, n)); } // compiled preview • scanne
r demo const MAX_PARTICLES = 2500; const now = () => performance.n
ow(); // compiled preview • scanner demo function lerp(a, b, t) { 

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); function clamp(n, a, b) { r
eturn Math.max(a, Math.min(b, n)); } // compiled preview • scanner
 demo function clamp(n, a, b) { return Math.max(a, Math.min(b, n))
; } const now = () => performance.now(); const SCAN_WIDTH = 8; fun
ction lerp(a, b, t) { return a + (b - a) * t; } function clamp(n, 
a, b) { return Math.max(a, Math.min(b, n)); } const MAX_PARTICLES 
= 2500; const now = () => performance.now(); const MAX_PARTICLES =
 2500; // compiled preview • scanner demo function lerp(a, b, t) {
 return a + (b - a) * t; } const MAX_PARTICLES = 2500; const MAX_P
ARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Math
.min(b, n)); } // compiled preview • scanner demo // compiled prev
iew • scanner demo function lerp(a, b, t) { return a + (b - a) * t
; } // compiled preview • scanner demo const SCAN_WIDTH = 8; funct
ion clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } functio
n clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } function 
clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } function le

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); function clamp(n, a, b) { r
eturn Math.max(a, Math.min(b, n)); } const now = () => performance
.now(); const SCAN_WIDTH = 8; // compiled preview • scanner demo c
onst SCAN_WIDTH = 8; function lerp(a, b, t) { return a + (b - a) *
 t; } const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; function lerp(a,
 b, t) { return a + (b - a) * t; } const MAX_PARTICLES = 2500; fun
ction clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } const
 now = () => performance.now(); const now = () => performance.now(
); function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); }
 const SCAN_WIDTH = 8; const MAX_PARTICLES = 2500; const MAX_PARTI
CLES = 2500; function clamp(n, a, b) { return Math.max(a, Math.min
(b, n)); } const SCAN_WIDTH = 8; function lerp(a, b, t) { return a
 + (b - a) * t; } // compiled preview • scanner demo function lerp
(a, b, t) { return a + (b - a) * t; } // compiled preview • scanne
r demo const SCAN_WIDTH = 8; const MAX_PARTICLES = 2500; function 
clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } function cl

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); function lerp(a, b, t) { re
turn a + (b - a) * t; } function lerp(a, b, t) { return a + (b - a
) * t; } // compiled preview • scanner demo const SCAN_WIDTH = 8; 
const SCAN_WIDTH = 8; function lerp(a, b, t) { return a + (b - a) 
* t; } function lerp(a, b, t) { return a + (b - a) * t; } const SC
AN_WIDTH = 8; function clamp(n, a, b) { return Math.max(a, Math.mi
n(b, n)); } const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; const now 
= () => performance.now(); function clamp(n, a, b) { return Math.m
ax(a, Math.min(b, n)); } function clamp(n, a, b) { return Math.max
(a, Math.min(b, n)); } const now = () => performance.now(); functi
on lerp(a, b, t) { return a + (b - a) * t; } const now = () => per
formance.now(); const MAX_PARTICLES = 2500; const MAX_PARTICLES = 
2500; const MAX_PARTICLES = 2500; function clamp(n, a, b) { return
 Math.max(a, Math.min(b, n)); } const now = () => performance.now(
); function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); }
 const now = () => performance.now(); function lerp(a, b, t) { ret

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); function lerp(a, b, t) { re
turn a + (b - a) * t; } function clamp(n, a, b) { return Math.max(
a, Math.min(b, n)); } const now = () => performance.now(); functio
n clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } // compil
ed preview • scanner demo const now = () => performance.now(); con
st SCAN_WIDTH = 8; // compiled preview • scanner demo const MAX_PA
RTICLES = 2500; const SCAN_WIDTH = 8; function lerp(a, b, t) { ret
urn a + (b - a) * t; } const now = () => performance.now(); // com
piled preview • scanner demo function lerp(a, b, t) { return a + (
b - a) * t; } function lerp(a, b, t) { return a + (b - a) * t; } /
/ compiled preview • scanner demo const SCAN_WIDTH = 8; const SCAN
_WIDTH = 8; function clamp(n, a, b) { return Math.max(a, Math.min(
b, n)); } const now = () => performance.now(); // compiled preview
 • scanner demo // compiled preview • scanner demo // compiled pre
view • scanner demo const MAX_PARTICLES = 2500; // compiled previe
w • scanner demo // compiled preview • scanner demo const now = ()

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); function lerp(a, b, t) { re
turn a + (b - a) * t; } const MAX_PARTICLES = 2500; function lerp(
a, b, t) { return a + (b - a) * t; } function lerp(a, b, t) { retu
rn a + (b - a) * t; } // compiled preview • scanner demo const now
 = () => performance.now(); function lerp(a, b, t) { return a + (b
 - a) * t; } const now = () => performance.now(); const SCAN_WIDTH
 = 8; const SCAN_WIDTH = 8; const MAX_PARTICLES = 2500; const now 
= () => performance.now(); function lerp(a, b, t) { return a + (b 
- a) * t; } const now = () => performance.now(); const MAX_PARTICL
ES = 2500; const MAX_PARTICLES = 2500; function lerp(a, b, t) { re
turn a + (b - a) * t; } // compiled preview • scanner demo functio
n lerp(a, b, t) { return a + (b - a) * t; } function clamp(n, a, b
) { return Math.max(a, Math.min(b, n)); } function clamp(n, a, b) 
{ return Math.max(a, Math.min(b, n)); } const SCAN_WIDTH = 8; func
tion clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } // com
piled preview • scanner demo const MAX_PARTICLES = 2500; const MAX

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); function lerp(a, b, t) { re
turn a + (b - a) * t; } const SCAN_WIDTH = 8; const MAX_PARTICLES 
= 2500; const now = () => performance.now(); // compiled preview •
 scanner demo // compiled preview • scanner demo const SCAN_WIDTH 
= 8; function lerp(a, b, t) { return a + (b - a) * t; } // compile
d preview • scanner demo const SCAN_WIDTH = 8; const now = () => p
erformance.now(); const now = () => performance.now(); const SCAN_
WIDTH = 8; const now = () => performance.now(); // compiled previe
w • scanner demo function lerp(a, b, t) { return a + (b - a) * t; 
} const SCAN_WIDTH = 8; // compiled preview • scanner demo const n
ow = () => performance.now(); // compiled preview • scanner demo /
/ compiled preview • scanner demo function clamp(n, a, b) { return
 Math.max(a, Math.min(b, n)); } // compiled preview • scanner demo
 function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } function clamp(n
, a, b) { return Math.max(a, Math.min(b, n)); } const SCAN_WIDTH =

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const now = () => performan
ce.now(); // compiled preview • scanner demo const SCAN_WIDTH = 8;
 const SCAN_WIDTH = 8; const now = () => performance.now(); // com
piled preview • scanner demo const now = () => performance.now(); 
function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } fu
nction lerp(a, b, t) { return a + (b - a) * t; } const SCAN_WIDTH 
= 8; function clamp(n, a, b) { return Math.max(a, Math.min(b, n));
 } const now = () => performance.now(); function lerp(a, b, t) { r
eturn a + (b - a) * t; } // compiled preview • scanner demo functi
on lerp(a, b, t) { return a + (b - a) * t; } const now = () => per
formance.now(); function clamp(n, a, b) { return Math.max(a, Math.
min(b, n)); } const now = () => performance.now(); // compiled pre
view • scanner demo function lerp(a, b, t) { return a + (b - a) * 
t; } function clamp(n, a, b) { return Math.max(a, Math.min(b, n));
 } function lerp(a, b, t) { return a + (b - a) * t; } function cla
mp(n, a, b) { return Math.max(a, Math.min(b, n)); } const SCAN_WID

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const now = () => performan
ce.now(); const now = () => performance.now(); // compiled preview
 • scanner demo const MAX_PARTICLES = 2500; const now = () => perf
ormance.now(); // compiled preview • scanner demo const MAX_PARTIC
LES = 2500; function clamp(n, a, b) { return Math.max(a, Math.min(
b, n)); } function clamp(n, a, b) { return Math.max(a, Math.min(b,
 n)); } const SCAN_WIDTH = 8; // compiled preview • scanner demo c
onst now = () => performance.now(); const MAX_PARTICLES = 2500; co
nst SCAN_WIDTH = 8; const MAX_PARTICLES = 2500; const SCAN_WIDTH =
 8; // compiled preview • scanner demo function lerp(a, b, t) { re
turn a + (b - a) * t; } const SCAN_WIDTH = 8; const SCAN_WIDTH = 8
; // compiled preview • scanner demo const now = () => performance
.now(); const SCAN_WIDTH = 8; const now = () => performance.now();
 const MAX_PARTICLES = 2500; const SCAN_WIDTH = 8; function clamp(
n, a, b) { return Math.max(a, Math.min(b, n)); } const MAX_PARTICL
ES = 2500; function lerp(a, b, t) { return a + (b - a) * t; } func

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const now = () => performan
ce.now(); function lerp(a, b, t) { return a + (b - a) * t; } const
 now = () => performance.now(); function clamp(n, a, b) { return M
ath.max(a, Math.min(b, n)); } const now = () => performance.now();
 const SCAN_WIDTH = 8; const now = () => performance.now(); const 
MAX_PARTICLES = 2500; const MAX_PARTICLES = 2500; const SCAN_WIDTH
 = 8; function lerp(a, b, t) { return a + (b - a) * t; } const now
 = () => performance.now(); const now = () => performance.now(); c
onst SCAN_WIDTH = 8; const SCAN_WIDTH = 8; function clamp(n, a, b)
 { return Math.max(a, Math.min(b, n)); } function clamp(n, a, b) {
 return Math.max(a, Math.min(b, n)); } function clamp(n, a, b) { r
eturn Math.max(a, Math.min(b, n)); } const MAX_PARTICLES = 2500; c
onst now = () => performance.now(); function clamp(n, a, b) { retu
rn Math.max(a, Math.min(b, n)); } // compiled preview • scanner de
mo function lerp(a, b, t) { return a + (b - a) * t; } const MAX_PA
RTICLES = 2500; function lerp(a, b, t) { return a + (b - a) * t; }

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const now = () => performan
ce.now(); function clamp(n, a, b) { return Math.max(a, Math.min(b,
 n)); } function clamp(n, a, b) { return Math.max(a, Math.min(b, n
)); } function lerp(a, b, t) { return a + (b - a) * t; } function 
lerp(a, b, t) { return a + (b - a) * t; } const SCAN_WIDTH = 8; co
nst MAX_PARTICLES = 2500; const SCAN_WIDTH = 8; const SCAN_WIDTH =
 8; const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; const now = () => 
performance.now(); function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } const MAX_PARTICLES = 2500; const now = () => per
formance.now(); const now = () => performance.now(); const now = (
) => performance.now(); const MAX_PARTICLES = 2500; function clamp
(n, a, b) { return Math.max(a, Math.min(b, n)); } const MAX_PARTIC
LES = 2500; // compiled preview • scanner demo const SCAN_WIDTH = 
8; const SCAN_WIDTH = 8; // compiled preview • scanner demo // com
piled preview • scanner demo function lerp(a, b, t) { return a + (
b - a) * t; } const now = () => performance.now(); function clamp(

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); // compiled preview • scann
er demo const MAX_PARTICLES = 2500; const MAX_PARTICLES = 2500; //
 compiled preview • scanner demo function lerp(a, b, t) { return a
 + (b - a) * t; } const SCAN_WIDTH = 8; const now = () => performa
nce.now(); // compiled preview • scanner demo // compiled preview 
• scanner demo const SCAN_WIDTH = 8; const now = () => performance
.now(); const now = () => performance.now(); // compiled preview •
 scanner demo function clamp(n, a, b) { return Math.max(a, Math.mi
n(b, n)); } function clamp(n, a, b) { return Math.max(a, Math.min(
b, n)); } const SCAN_WIDTH = 8; const MAX_PARTICLES = 2500; const 
SCAN_WIDTH = 8; function lerp(a, b, t) { return a + (b - a) * t; }
 // compiled preview • scanner demo const MAX_PARTICLES = 2500; co
nst MAX_PARTICLES = 2500; function lerp(a, b, t) { return a + (b -
 a) * t; } function clamp(n, a, b) { return Math.max(a, Math.min(b
, n)); } const MAX_PARTICLES = 2500; // compiled preview • scanner
 demo // compiled preview • scanner demo const SCAN_WIDTH = 8; con

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); // compiled preview • scann
er demo const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; const SCAN_WID
TH = 8; function lerp(a, b, t) { return a + (b - a) * t; } const M
AX_PARTICLES = 2500; const MAX_PARTICLES = 2500; const now = () =>
 performance.now(); const now = () => performance.now(); // compil
ed preview • scanner demo const MAX_PARTICLES = 2500; const now = 
() => performance.now(); function lerp(a, b, t) { return a + (b - 
a) * t; } function clamp(n, a, b) { return Math.max(a, Math.min(b,
 n)); } const SCAN_WIDTH = 8; const MAX_PARTICLES = 2500; const no
w = () => performance.now(); // compiled preview • scanner demo co
nst now = () => performance.now(); function clamp(n, a, b) { retur
n Math.max(a, Math.min(b, n)); } const now = () => performance.now
(); function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); 
} const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; function lerp(a, b, 
t) { return a + (b - a) * t; } const SCAN_WIDTH = 8; const SCAN_WI
DTH = 8; function lerp(a, b, t) { return a + (b - a) * t; } // com

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); // compiled preview • scann
er demo // compiled preview • scanner demo // compiled preview • s
canner demo const MAX_PARTICLES = 2500; function clamp(n, a, b) { 
return Math.max(a, Math.min(b, n)); } const MAX_PARTICLES = 2500; 
// compiled preview • scanner demo function lerp(a, b, t) { return
 a + (b - a) * t; } function clamp(n, a, b) { return Math.max(a, M
ath.min(b, n)); } // compiled preview • scanner demo // compiled p
review • scanner demo // compiled preview • scanner demo const SCA
N_WIDTH = 8; function lerp(a, b, t) { return a + (b - a) * t; } co
nst now = () => performance.now(); function lerp(a, b, t) { return
 a + (b - a) * t; } const SCAN_WIDTH = 8; // compiled preview • sc
anner demo const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; const MAX_P
ARTICLES = 2500; function lerp(a, b, t) { return a + (b - a) * t; 
} function lerp(a, b, t) { return a + (b - a) * t; } function lerp
(a, b, t) { return a + (b - a) * t; } // compiled preview • scanne
r demo function clamp(n, a, b) { return Math.max(a, Math.min(b, n)

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); // compiled preview • scann
er demo const now = () => performance.now(); const now = () => per
formance.now(); function lerp(a, b, t) { return a + (b - a) * t; }
 function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } fun
ction clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } funct
ion lerp(a, b, t) { return a + (b - a) * t; } const MAX_PARTICLES 
= 2500; // compiled preview • scanner demo function clamp(n, a, b)
 { return Math.max(a, Math.min(b, n)); } // compiled preview • sca
nner demo const now = () => performance.now(); const now = () => p
erformance.now(); function lerp(a, b, t) { return a + (b - a) * t;
 } // compiled preview • scanner demo function lerp(a, b, t) { ret
urn a + (b - a) * t; } const now = () => performance.now(); const 
MAX_PARTICLES = 2500; function lerp(a, b, t) { return a + (b - a) 
* t; } const now = () => performance.now(); const now = () => perf
ormance.now(); const MAX_PARTICLES = 2500; const MAX_PARTICLES = 2

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const SCAN_WIDTH = 8; funct
ion lerp(a, b, t) { return a + (b - a) * t; } function clamp(n, a,
 b) { return Math.max(a, Math.min(b, n)); } const now = () => perf
ormance.now(); function clamp(n, a, b) { return Math.max(a, Math.m
in(b, n)); } function clamp(n, a, b) { return Math.max(a, Math.min
(b, n)); } // compiled preview • scanner demo function clamp(n, a,
 b) { return Math.max(a, Math.min(b, n)); } const SCAN_WIDTH = 8; 
// compiled preview • scanner demo const SCAN_WIDTH = 8; // compil
ed preview • scanner demo const MAX_PARTICLES = 2500; const now = 
() => performance.now(); const MAX_PARTICLES = 2500; const MAX_PAR
TICLES = 2500; const SCAN_WIDTH = 8; function lerp(a, b, t) { retu
rn a + (b - a) * t; } function clamp(n, a, b) { return Math.max(a,
 Math.min(b, n)); } const MAX_PARTICLES = 2500; const MAX_PARTICLE
S = 2500; // compiled preview • scanner demo const now = () => per
formance.now(); const now = () => performance.now(); function lerp
(a, b, t) { return a + (b - a) * t; } // compiled preview • scanne

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const SCAN_WIDTH = 8; funct
ion clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } const M
AX_PARTICLES = 2500; // compiled preview • scanner demo const MAX_
PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Mat
h.min(b, n)); } function clamp(n, a, b) { return Math.max(a, Math.
min(b, n)); } const MAX_PARTICLES = 2500; // compiled preview • sc
anner demo // compiled preview • scanner demo function lerp(a, b, 
t) { return a + (b - a) * t; } // compiled preview • scanner demo 
const now = () => performance.now(); // compiled preview • scanner
 demo // compiled preview • scanner demo function lerp(a, b, t) { 
return a + (b - a) * t; } function clamp(n, a, b) { return Math.ma
x(a, Math.min(b, n)); } function clamp(n, a, b) { return Math.max(
a, Math.min(b, n)); } function lerp(a, b, t) { return a + (b - a) 
* t; } const now = () => performance.now(); const now = () => perf
ormance.now(); const MAX_PARTICLES = 2500; const MAX_PARTICLES = 2
500; function clamp(n, a, b) { return Math.max(a, Math.min(b, n));

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const SCAN_WIDTH = 8; const
 MAX_PARTICLES = 2500; const SCAN_WIDTH = 8; const SCAN_WIDTH = 8;
 const MAX_PARTICLES = 2500; function lerp(a, b, t) { return a + (
b - a) * t; } // compiled preview • scanner demo const SCAN_WIDTH 
= 8; const now = () => performance.now(); // compiled preview • sc
anner demo const MAX_PARTICLES = 2500; // compiled preview • scann
er demo function clamp(n, a, b) { return Math.max(a, Math.min(b, n
)); } const SCAN_WIDTH = 8; function lerp(a, b, t) { return a + (b
 - a) * t; } // compiled preview • scanner demo // compiled previe
w • scanner demo const MAX_PARTICLES = 2500; const now = () => per
formance.now(); function clamp(n, a, b) { return Math.max(a, Math.
min(b, n)); } const MAX_PARTICLES = 2500; function clamp(n, a, b) 
{ return Math.max(a, Math.min(b, n)); } const now = () => performa
nce.now(); // compiled preview • scanner demo const MAX_PARTICLES 
= 2500; function clamp(n, a, b) { return Math.max(a, Math.min(b, n
)); } const now = () => performance.now(); const now = () => perfo

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const SCAN_WIDTH = 8; const
 SCAN_WIDTH = 8; // compiled preview • scanner demo function clamp
(n, a, b) { return Math.max(a, Math.min(b, n)); } const MAX_PARTIC
LES = 2500; function lerp(a, b, t) { return a + (b - a) * t; } fun
ction clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } // co
mpiled preview • scanner demo function clamp(n, a, b) { return Mat
h.max(a, Math.min(b, n)); } // compiled preview • scanner demo con
st now = () => performance.now(); // compiled preview • scanner de
mo // compiled preview • scanner demo const SCAN_WIDTH = 8; const 
MAX_PARTICLES = 2500; const SCAN_WIDTH = 8; function clamp(n, a, b
) { return Math.max(a, Math.min(b, n)); } const SCAN_WIDTH = 8; //
 compiled preview • scanner demo // compiled preview • scanner dem
o const now = () => performance.now(); function lerp(a, b, t) { re
turn a + (b - a) * t; } const MAX_PARTICLES = 2500; function lerp(
a, b, t) { return a + (b - a) * t; } function lerp(a, b, t) { retu
rn a + (b - a) * t; } const now = () => performance.now(); // comp

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const SCAN_WIDTH = 8; // co
mpiled preview • scanner demo function lerp(a, b, t) { return a + 
(b - a) * t; } function lerp(a, b, t) { return a + (b - a) * t; } 
const SCAN_WIDTH = 8; const now = () => performance.now(); const S
CAN_WIDTH = 8; const now = () => performance.now(); const MAX_PART
ICLES = 2500; // compiled preview • scanner demo function clamp(n,
 a, b) { return Math.max(a, Math.min(b, n)); } // compiled preview
 • scanner demo function lerp(a, b, t) { return a + (b - a) * t; }
 const MAX_PARTICLES = 2500; const SCAN_WIDTH = 8; function clamp(
n, a, b) { return Math.max(a, Math.min(b, n)); } const now = () =>
 performance.now(); // compiled preview • scanner demo const SCAN_
WIDTH = 8; function lerp(a, b, t) { return a + (b - a) * t; } cons
t MAX_PARTICLES = 2500; const now = () => performance.now(); const
 now = () => performance.now(); const SCAN_WIDTH = 8; // compiled 
preview • scanner demo const SCAN_WIDTH = 8; const SCAN_WIDTH = 8;
 // compiled preview • scanner demo function lerp(a, b, t) { retur

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const MAX_PARTICLES = 2500;
 const now = () => performance.now(); function clamp(n, a, b) { re
turn Math.max(a, Math.min(b, n)); } const now = () => performance.
now(); const SCAN_WIDTH = 8; const now = () => performance.now(); 
function lerp(a, b, t) { return a + (b - a) * t; } const now = () 
=> performance.now(); const SCAN_WIDTH = 8; // compiled preview • 
scanner demo // compiled preview • scanner demo // compiled previe
w • scanner demo const SCAN_WIDTH = 8; function clamp(n, a, b) { r
eturn Math.max(a, Math.min(b, n)); } const now = () => performance
.now(); const now = () => performance.now(); const MAX_PARTICLES =
 2500; // compiled preview • scanner demo const MAX_PARTICLES = 25
00; const SCAN_WIDTH = 8; const now = () => performance.now(); // 
compiled preview • scanner demo const MAX_PARTICLES = 2500; const 
now = () => performance.now(); const MAX_PARTICLES = 2500; const M
AX_PARTICLES = 2500; const MAX_PARTICLES = 2500; function lerp(a, 
b, t) { return a + (b - a) * t; } function clamp(n, a, b) { return

// Code for scanner-reveal/basic

// Code for scanner-reveal/basic

Installation

Loading installation instructions...

Usage

import { ScannerReveal } from "@/components/pluto-ui/scanner-reveal"

<ScannerReveal
  items={[
    { id: "1", image: "/path/to/image.jpg" },
    { id: "2", image: "/path/to/image2.jpg" },
  ]}
/>

Props

Prop	Type	Default	Description
`items`	`ScannerRevealItem[]`	required	Array of items to display in the stream
`className`	`string`	`undefined`	Additional CSS classes
`speed`	`number`	`120`	Initial scrolling speed in pixels per second
`cardWidth`	`number`	`400`	Width of each card in pixels
`cardHeight`	`number`	`250`	Height of each card in pixels
`cardGap`	`number`	`60`	Gap between cards in pixels
`showControls`	`boolean`	`true`	Show play/pause, reset, and direction controls
`showSpeedIndicator`	`boolean`	`true`	Show the current speed indicator
`scannerColor`	`string`	`"rgba(0, 255, 255, 1)"`	Color of the scanner line
`particleIntensity`	`number`	`0.8`	Intensity of particle effects (0-1)
`autoPlay`	`boolean`	`true`	Start animation automatically
`onItemScanned`	`(item: ScannerRevealItem, index: number) => void`	`undefined`	Callback when an item passes through the scanner

ScannerRevealItem

Property	Type	Description
`id`	`string`	Unique identifier for the item
`image`	`string`	URL of the image to display
`content`	`ReactNode`	Custom React content to display (alternative to image)
`asciiContent`	`string`	Custom ASCII art content (auto-generated if not provided)

Examples

Basic Usage

Speed: 120 px/s

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const SCAN_WIDTH = 8; funct
ion lerp(a, b, t) { return a + (b - a) * t; } function clamp(n, a,
 b) { return Math.max(a, Math.min(b, n)); } function lerp(a, b, t)
 { return a + (b - a) * t; } function lerp(a, b, t) { return a + (
b - a) * t; } // compiled preview • scanner demo const MAX_PARTICL
ES = 2500; const now = () => performance.now(); const now = () => 
performance.now(); function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } const SCAN_WIDTH = 8; function lerp(a, b, t) { re
turn a + (b - a) * t; } function clamp(n, a, b) { return Math.max(
a, Math.min(b, n)); } const SCAN_WIDTH = 8; function clamp(n, a, b
) { return Math.max(a, Math.min(b, n)); } // compiled preview • sc
anner demo function clamp(n, a, b) { return Math.max(a, Math.min(b
, n)); } // compiled preview • scanner demo const MAX_PARTICLES = 
2500; const MAX_PARTICLES = 2500; function lerp(a, b, t) { return 
a + (b - a) * t; } function lerp(a, b, t) { return a + (b - a) * t
; } const SCAN_WIDTH = 8; const now = () => performance.now(); fun

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const SCAN_WIDTH = 8; funct
ion clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } const M
AX_PARTICLES = 2500; const now = () => performance.now(); function
 lerp(a, b, t) { return a + (b - a) * t; } // compiled preview • s
canner demo const now = () => performance.now(); function lerp(a, 
b, t) { return a + (b - a) * t; } function lerp(a, b, t) { return 
a + (b - a) * t; } function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} function lerp(a, b, t) { return a + (b - a) * t; } const SCAN_WI
DTH = 8; const MAX_PARTICLES = 2500; const SCAN_WIDTH = 8; const M
AX_PARTICLES = 2500; // compiled preview • scanner demo // compile
d preview • scanner demo function clamp(n, a, b) { return Math.max
(a, Math.min(b, n)); } const now = () => performance.now(); const 
SCAN_WIDTH = 8; const now = () => performance.now(); function lerp
(a, b, t) { return a + (b - a) * t; } const MAX_PARTICLES = 2500; 
// compiled preview • scanner demo function lerp(a, b, t) { return

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const SCAN_WIDTH = 8; const
 MAX_PARTICLES = 2500; // compiled preview • scanner demo const SC
AN_WIDTH = 8; function lerp(a, b, t) { return a + (b - a) * t; } c
onst SCAN_WIDTH = 8; const MAX_PARTICLES = 2500; function clamp(n,
 a, b) { return Math.max(a, Math.min(b, n)); } function clamp(n, a
, b) { return Math.max(a, Math.min(b, n)); } function clamp(n, a, 
b) { return Math.max(a, Math.min(b, n)); } const MAX_PARTICLES = 2
500; function lerp(a, b, t) { return a + (b - a) * t; } function l
erp(a, b, t) { return a + (b - a) * t; } function clamp(n, a, b) {
 return Math.max(a, Math.min(b, n)); } const now = () => performan
ce.now(); function lerp(a, b, t) { return a + (b - a) * t; } const
 MAX_PARTICLES = 2500; const now = () => performance.now(); functi
on lerp(a, b, t) { return a + (b - a) * t; } function clamp(n, a, 
b) { return Math.max(a, Math.min(b, n)); } function lerp(a, b, t) 
{ return a + (b - a) * t; } // compiled preview • scanner demo con
st SCAN_WIDTH = 8; // compiled preview • scanner demo const MAX_PA

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const SCAN_WIDTH = 8; const
 SCAN_WIDTH = 8; const now = () => performance.now(); const MAX_PA
RTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Math.
min(b, n)); } const SCAN_WIDTH = 8; const now = () => performance.
now(); const MAX_PARTICLES = 2500; const MAX_PARTICLES = 2500; con
st MAX_PARTICLES = 2500; const now = () => performance.now(); func
tion lerp(a, b, t) { return a + (b - a) * t; } const MAX_PARTICLES
 = 2500; function clamp(n, a, b) { return Math.max(a, Math.min(b, 
n)); } function lerp(a, b, t) { return a + (b - a) * t; } // compi
led preview • scanner demo const now = () => performance.now(); fu
nction lerp(a, b, t) { return a + (b - a) * t; } const now = () =>
 performance.now(); // compiled preview • scanner demo const SCAN_
WIDTH = 8; const SCAN_WIDTH = 8; const now = () => performance.now
(); function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); 
} function lerp(a, b, t) { return a + (b - a) * t; } const MAX_PAR
TICLES = 2500; const SCAN_WIDTH = 8; function lerp(a, b, t) { retu

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const MAX_PARTICLES = 2500;
 // compiled preview • scanner demo function lerp(a, b, t) { retur
n a + (b - a) * t; } function clamp(n, a, b) { return Math.max(a, 
Math.min(b, n)); } function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } const SCAN_WIDTH = 8; const MAX_PARTICLES = 2500;
 const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; const MAX_PARTICLES =
 2500; function clamp(n, a, b) { return Math.max(a, Math.min(b, n)
); } function lerp(a, b, t) { return a + (b - a) * t; } const now 
= () => performance.now(); function lerp(a, b, t) { return a + (b 
- a) * t; } const MAX_PARTICLES = 2500; const SCAN_WIDTH = 8; cons
t MAX_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(
a, Math.min(b, n)); } // compiled preview • scanner demo function 
lerp(a, b, t) { return a + (b - a) * t; } function lerp(a, b, t) {
 return a + (b - a) * t; } function clamp(n, a, b) { return Math.m
ax(a, Math.min(b, n)); } const MAX_PARTICLES = 2500; const SCAN_WI
DTH = 8; // compiled preview • scanner demo function clamp(n, a, b

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const MAX_PARTICLES = 2500;
 const now = () => performance.now(); function clamp(n, a, b) { re
turn Math.max(a, Math.min(b, n)); } function lerp(a, b, t) { retur
n a + (b - a) * t; } function clamp(n, a, b) { return Math.max(a, 
Math.min(b, n)); } const MAX_PARTICLES = 2500; // compiled preview
 • scanner demo // compiled preview • scanner demo const now = () 
=> performance.now(); const MAX_PARTICLES = 2500; // compiled prev
iew • scanner demo function lerp(a, b, t) { return a + (b - a) * t
; } function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); 
} const now = () => performance.now(); // compiled preview • scann
er demo function clamp(n, a, b) { return Math.max(a, Math.min(b, n
)); } function lerp(a, b, t) { return a + (b - a) * t; } const MAX
_PARTICLES = 2500; const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; con
st SCAN_WIDTH = 8; function lerp(a, b, t) { return a + (b - a) * t
; } const now = () => performance.now(); function lerp(a, b, t) { 
return a + (b - a) * t; } const MAX_PARTICLES = 2500; const now = 

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const MAX_PARTICLES = 2500;
 function lerp(a, b, t) { return a + (b - a) * t; } const SCAN_WID
TH = 8; // compiled preview • scanner demo const MAX_PARTICLES = 2
500; const MAX_PARTICLES = 2500; function clamp(n, a, b) { return 
Math.max(a, Math.min(b, n)); } // compiled preview • scanner demo 
function lerp(a, b, t) { return a + (b - a) * t; } const MAX_PARTI
CLES = 2500; function lerp(a, b, t) { return a + (b - a) * t; } fu
nction lerp(a, b, t) { return a + (b - a) * t; } // compiled previ
ew • scanner demo const now = () => performance.now(); function le
rp(a, b, t) { return a + (b - a) * t; } const now = () => performa
nce.now(); const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; const MAX_P
ARTICLES = 2500; const now = () => performance.now(); function ler
p(a, b, t) { return a + (b - a) * t; } const now = () => performan
ce.now(); const MAX_PARTICLES = 2500; const MAX_PARTICLES = 2500; 
function lerp(a, b, t) { return a + (b - a) * t; } const SCAN_WIDT
H = 8; function lerp(a, b, t) { return a + (b - a) * t; } function

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const MAX_PARTICLES = 2500;
 function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } /
/ compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX_
PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Mat
h.min(b, n)); } // compiled preview • scanner demo const now = () 
=> performance.now(); function clamp(n, a, b) { return Math.max(a,
 Math.min(b, n)); } const MAX_PARTICLES = 2500; const SCAN_WIDTH =
 8; function lerp(a, b, t) { return a + (b - a) * t; } function cl
amp(n, a, b) { return Math.max(a, Math.min(b, n)); } // compiled p
review • scanner demo const MAX_PARTICLES = 2500; const SCAN_WIDTH
 = 8; function lerp(a, b, t) { return a + (b - a) * t; } // compil
ed preview • scanner demo function clamp(n, a, b) { return Math.ma
x(a, Math.min(b, n)); } const MAX_PARTICLES = 2500; const SCAN_WID
TH = 8; // compiled preview • scanner demo const now = () => perfo
rmance.now(); const now = () => performance.now(); // compiled pre
view • scanner demo const MAX_PARTICLES = 2500; const now = () => 

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); function clamp(n, a, b) { r
eturn Math.max(a, Math.min(b, n)); } const MAX_PARTICLES = 2500; c
onst now = () => performance.now(); const MAX_PARTICLES = 2500; co
nst MAX_PARTICLES = 2500; function clamp(n, a, b) { return Math.ma
x(a, Math.min(b, n)); } function clamp(n, a, b) { return Math.max(
a, Math.min(b, n)); } function lerp(a, b, t) { return a + (b - a) 
* t; } const MAX_PARTICLES = 2500; const MAX_PARTICLES = 2500; con
st now = () => performance.now(); function lerp(a, b, t) { return 
a + (b - a) * t; } const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; con
st SCAN_WIDTH = 8; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } // compiled preview • scanner demo // compiled pr
eview • scanner demo function lerp(a, b, t) { return a + (b - a) *
 t; } // compiled preview • scanner demo function clamp(n, a, b) {
 return Math.max(a, Math.min(b, n)); } const SCAN_WIDTH = 8; const
 MAX_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a
, Math.min(b, n)); } const MAX_PARTICLES = 2500; function lerp(a, 

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); function clamp(n, a, b) { r
eturn Math.max(a, Math.min(b, n)); } const SCAN_WIDTH = 8; functio
n lerp(a, b, t) { return a + (b - a) * t; } function lerp(a, b, t)
 { return a + (b - a) * t; } const MAX_PARTICLES = 2500; function 
clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } // compiled
 preview • scanner demo function clamp(n, a, b) { return Math.max(
a, Math.min(b, n)); } const SCAN_WIDTH = 8; const MAX_PARTICLES = 
2500; const MAX_PARTICLES = 2500; function lerp(a, b, t) { return 
a + (b - a) * t; } function lerp(a, b, t) { return a + (b - a) * t
; } const SCAN_WIDTH = 8; const now = () => performance.now(); con
st now = () => performance.now(); function clamp(n, a, b) { return
 Math.max(a, Math.min(b, n)); } const now = () => performance.now(
); const now = () => performance.now(); function clamp(n, a, b) { 
return Math.max(a, Math.min(b, n)); } // compiled preview • scanne
r demo const MAX_PARTICLES = 2500; const now = () => performance.n
ow(); // compiled preview • scanner demo function lerp(a, b, t) { 

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); function clamp(n, a, b) { r
eturn Math.max(a, Math.min(b, n)); } // compiled preview • scanner
 demo function clamp(n, a, b) { return Math.max(a, Math.min(b, n))
; } const now = () => performance.now(); const SCAN_WIDTH = 8; fun
ction lerp(a, b, t) { return a + (b - a) * t; } function clamp(n, 
a, b) { return Math.max(a, Math.min(b, n)); } const MAX_PARTICLES 
= 2500; const now = () => performance.now(); const MAX_PARTICLES =
 2500; // compiled preview • scanner demo function lerp(a, b, t) {
 return a + (b - a) * t; } const MAX_PARTICLES = 2500; const MAX_P
ARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Math
.min(b, n)); } // compiled preview • scanner demo // compiled prev
iew • scanner demo function lerp(a, b, t) { return a + (b - a) * t
; } // compiled preview • scanner demo const SCAN_WIDTH = 8; funct
ion clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } functio
n clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } function 
clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } function le

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); function clamp(n, a, b) { r
eturn Math.max(a, Math.min(b, n)); } const now = () => performance
.now(); const SCAN_WIDTH = 8; // compiled preview • scanner demo c
onst SCAN_WIDTH = 8; function lerp(a, b, t) { return a + (b - a) *
 t; } const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; function lerp(a,
 b, t) { return a + (b - a) * t; } const MAX_PARTICLES = 2500; fun
ction clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } const
 now = () => performance.now(); const now = () => performance.now(
); function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); }
 const SCAN_WIDTH = 8; const MAX_PARTICLES = 2500; const MAX_PARTI
CLES = 2500; function clamp(n, a, b) { return Math.max(a, Math.min
(b, n)); } const SCAN_WIDTH = 8; function lerp(a, b, t) { return a
 + (b - a) * t; } // compiled preview • scanner demo function lerp
(a, b, t) { return a + (b - a) * t; } // compiled preview • scanne
r demo const SCAN_WIDTH = 8; const MAX_PARTICLES = 2500; function 
clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } function cl

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); function lerp(a, b, t) { re
turn a + (b - a) * t; } function lerp(a, b, t) { return a + (b - a
) * t; } // compiled preview • scanner demo const SCAN_WIDTH = 8; 
const SCAN_WIDTH = 8; function lerp(a, b, t) { return a + (b - a) 
* t; } function lerp(a, b, t) { return a + (b - a) * t; } const SC
AN_WIDTH = 8; function clamp(n, a, b) { return Math.max(a, Math.mi
n(b, n)); } const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; const now 
= () => performance.now(); function clamp(n, a, b) { return Math.m
ax(a, Math.min(b, n)); } function clamp(n, a, b) { return Math.max
(a, Math.min(b, n)); } const now = () => performance.now(); functi
on lerp(a, b, t) { return a + (b - a) * t; } const now = () => per
formance.now(); const MAX_PARTICLES = 2500; const MAX_PARTICLES = 
2500; const MAX_PARTICLES = 2500; function clamp(n, a, b) { return
 Math.max(a, Math.min(b, n)); } const now = () => performance.now(
); function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); }
 const now = () => performance.now(); function lerp(a, b, t) { ret

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); function lerp(a, b, t) { re
turn a + (b - a) * t; } function clamp(n, a, b) { return Math.max(
a, Math.min(b, n)); } const now = () => performance.now(); functio
n clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } // compil
ed preview • scanner demo const now = () => performance.now(); con
st SCAN_WIDTH = 8; // compiled preview • scanner demo const MAX_PA
RTICLES = 2500; const SCAN_WIDTH = 8; function lerp(a, b, t) { ret
urn a + (b - a) * t; } const now = () => performance.now(); // com
piled preview • scanner demo function lerp(a, b, t) { return a + (
b - a) * t; } function lerp(a, b, t) { return a + (b - a) * t; } /
/ compiled preview • scanner demo const SCAN_WIDTH = 8; const SCAN
_WIDTH = 8; function clamp(n, a, b) { return Math.max(a, Math.min(
b, n)); } const now = () => performance.now(); // compiled preview
 • scanner demo // compiled preview • scanner demo // compiled pre
view • scanner demo const MAX_PARTICLES = 2500; // compiled previe
w • scanner demo // compiled preview • scanner demo const now = ()

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); function lerp(a, b, t) { re
turn a + (b - a) * t; } const MAX_PARTICLES = 2500; function lerp(
a, b, t) { return a + (b - a) * t; } function lerp(a, b, t) { retu
rn a + (b - a) * t; } // compiled preview • scanner demo const now
 = () => performance.now(); function lerp(a, b, t) { return a + (b
 - a) * t; } const now = () => performance.now(); const SCAN_WIDTH
 = 8; const SCAN_WIDTH = 8; const MAX_PARTICLES = 2500; const now 
= () => performance.now(); function lerp(a, b, t) { return a + (b 
- a) * t; } const now = () => performance.now(); const MAX_PARTICL
ES = 2500; const MAX_PARTICLES = 2500; function lerp(a, b, t) { re
turn a + (b - a) * t; } // compiled preview • scanner demo functio
n lerp(a, b, t) { return a + (b - a) * t; } function clamp(n, a, b
) { return Math.max(a, Math.min(b, n)); } function clamp(n, a, b) 
{ return Math.max(a, Math.min(b, n)); } const SCAN_WIDTH = 8; func
tion clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } // com
piled preview • scanner demo const MAX_PARTICLES = 2500; const MAX

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); function lerp(a, b, t) { re
turn a + (b - a) * t; } const SCAN_WIDTH = 8; const MAX_PARTICLES 
= 2500; const now = () => performance.now(); // compiled preview •
 scanner demo // compiled preview • scanner demo const SCAN_WIDTH 
= 8; function lerp(a, b, t) { return a + (b - a) * t; } // compile
d preview • scanner demo const SCAN_WIDTH = 8; const now = () => p
erformance.now(); const now = () => performance.now(); const SCAN_
WIDTH = 8; const now = () => performance.now(); // compiled previe
w • scanner demo function lerp(a, b, t) { return a + (b - a) * t; 
} const SCAN_WIDTH = 8; // compiled preview • scanner demo const n
ow = () => performance.now(); // compiled preview • scanner demo /
/ compiled preview • scanner demo function clamp(n, a, b) { return
 Math.max(a, Math.min(b, n)); } // compiled preview • scanner demo
 function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } function clamp(n
, a, b) { return Math.max(a, Math.min(b, n)); } const SCAN_WIDTH =

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const now = () => performan
ce.now(); // compiled preview • scanner demo const SCAN_WIDTH = 8;
 const SCAN_WIDTH = 8; const now = () => performance.now(); // com
piled preview • scanner demo const now = () => performance.now(); 
function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } fu
nction lerp(a, b, t) { return a + (b - a) * t; } const SCAN_WIDTH 
= 8; function clamp(n, a, b) { return Math.max(a, Math.min(b, n));
 } const now = () => performance.now(); function lerp(a, b, t) { r
eturn a + (b - a) * t; } // compiled preview • scanner demo functi
on lerp(a, b, t) { return a + (b - a) * t; } const now = () => per
formance.now(); function clamp(n, a, b) { return Math.max(a, Math.
min(b, n)); } const now = () => performance.now(); // compiled pre
view • scanner demo function lerp(a, b, t) { return a + (b - a) * 
t; } function clamp(n, a, b) { return Math.max(a, Math.min(b, n));
 } function lerp(a, b, t) { return a + (b - a) * t; } function cla
mp(n, a, b) { return Math.max(a, Math.min(b, n)); } const SCAN_WID

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const now = () => performan
ce.now(); const now = () => performance.now(); // compiled preview
 • scanner demo const MAX_PARTICLES = 2500; const now = () => perf
ormance.now(); // compiled preview • scanner demo const MAX_PARTIC
LES = 2500; function clamp(n, a, b) { return Math.max(a, Math.min(
b, n)); } function clamp(n, a, b) { return Math.max(a, Math.min(b,
 n)); } const SCAN_WIDTH = 8; // compiled preview • scanner demo c
onst now = () => performance.now(); const MAX_PARTICLES = 2500; co
nst SCAN_WIDTH = 8; const MAX_PARTICLES = 2500; const SCAN_WIDTH =
 8; // compiled preview • scanner demo function lerp(a, b, t) { re
turn a + (b - a) * t; } const SCAN_WIDTH = 8; const SCAN_WIDTH = 8
; // compiled preview • scanner demo const now = () => performance
.now(); const SCAN_WIDTH = 8; const now = () => performance.now();
 const MAX_PARTICLES = 2500; const SCAN_WIDTH = 8; function clamp(
n, a, b) { return Math.max(a, Math.min(b, n)); } const MAX_PARTICL
ES = 2500; function lerp(a, b, t) { return a + (b - a) * t; } func

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const now = () => performan
ce.now(); function lerp(a, b, t) { return a + (b - a) * t; } const
 now = () => performance.now(); function clamp(n, a, b) { return M
ath.max(a, Math.min(b, n)); } const now = () => performance.now();
 const SCAN_WIDTH = 8; const now = () => performance.now(); const 
MAX_PARTICLES = 2500; const MAX_PARTICLES = 2500; const SCAN_WIDTH
 = 8; function lerp(a, b, t) { return a + (b - a) * t; } const now
 = () => performance.now(); const now = () => performance.now(); c
onst SCAN_WIDTH = 8; const SCAN_WIDTH = 8; function clamp(n, a, b)
 { return Math.max(a, Math.min(b, n)); } function clamp(n, a, b) {
 return Math.max(a, Math.min(b, n)); } function clamp(n, a, b) { r
eturn Math.max(a, Math.min(b, n)); } const MAX_PARTICLES = 2500; c
onst now = () => performance.now(); function clamp(n, a, b) { retu
rn Math.max(a, Math.min(b, n)); } // compiled preview • scanner de
mo function lerp(a, b, t) { return a + (b - a) * t; } const MAX_PA
RTICLES = 2500; function lerp(a, b, t) { return a + (b - a) * t; }

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const now = () => performan
ce.now(); function clamp(n, a, b) { return Math.max(a, Math.min(b,
 n)); } function clamp(n, a, b) { return Math.max(a, Math.min(b, n
)); } function lerp(a, b, t) { return a + (b - a) * t; } function 
lerp(a, b, t) { return a + (b - a) * t; } const SCAN_WIDTH = 8; co
nst MAX_PARTICLES = 2500; const SCAN_WIDTH = 8; const SCAN_WIDTH =
 8; const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; const now = () => 
performance.now(); function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } const MAX_PARTICLES = 2500; const now = () => per
formance.now(); const now = () => performance.now(); const now = (
) => performance.now(); const MAX_PARTICLES = 2500; function clamp
(n, a, b) { return Math.max(a, Math.min(b, n)); } const MAX_PARTIC
LES = 2500; // compiled preview • scanner demo const SCAN_WIDTH = 
8; const SCAN_WIDTH = 8; // compiled preview • scanner demo // com
piled preview • scanner demo function lerp(a, b, t) { return a + (
b - a) * t; } const now = () => performance.now(); function clamp(

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); // compiled preview • scann
er demo const MAX_PARTICLES = 2500; const MAX_PARTICLES = 2500; //
 compiled preview • scanner demo function lerp(a, b, t) { return a
 + (b - a) * t; } const SCAN_WIDTH = 8; const now = () => performa
nce.now(); // compiled preview • scanner demo // compiled preview 
• scanner demo const SCAN_WIDTH = 8; const now = () => performance
.now(); const now = () => performance.now(); // compiled preview •
 scanner demo function clamp(n, a, b) { return Math.max(a, Math.mi
n(b, n)); } function clamp(n, a, b) { return Math.max(a, Math.min(
b, n)); } const SCAN_WIDTH = 8; const MAX_PARTICLES = 2500; const 
SCAN_WIDTH = 8; function lerp(a, b, t) { return a + (b - a) * t; }
 // compiled preview • scanner demo const MAX_PARTICLES = 2500; co
nst MAX_PARTICLES = 2500; function lerp(a, b, t) { return a + (b -
 a) * t; } function clamp(n, a, b) { return Math.max(a, Math.min(b
, n)); } const MAX_PARTICLES = 2500; // compiled preview • scanner
 demo // compiled preview • scanner demo const SCAN_WIDTH = 8; con

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); // compiled preview • scann
er demo const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; const SCAN_WID
TH = 8; function lerp(a, b, t) { return a + (b - a) * t; } const M
AX_PARTICLES = 2500; const MAX_PARTICLES = 2500; const now = () =>
 performance.now(); const now = () => performance.now(); // compil
ed preview • scanner demo const MAX_PARTICLES = 2500; const now = 
() => performance.now(); function lerp(a, b, t) { return a + (b - 
a) * t; } function clamp(n, a, b) { return Math.max(a, Math.min(b,
 n)); } const SCAN_WIDTH = 8; const MAX_PARTICLES = 2500; const no
w = () => performance.now(); // compiled preview • scanner demo co
nst now = () => performance.now(); function clamp(n, a, b) { retur
n Math.max(a, Math.min(b, n)); } const now = () => performance.now
(); function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); 
} const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; function lerp(a, b, 
t) { return a + (b - a) * t; } const SCAN_WIDTH = 8; const SCAN_WI
DTH = 8; function lerp(a, b, t) { return a + (b - a) * t; } // com

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); // compiled preview • scann
er demo // compiled preview • scanner demo // compiled preview • s
canner demo const MAX_PARTICLES = 2500; function clamp(n, a, b) { 
return Math.max(a, Math.min(b, n)); } const MAX_PARTICLES = 2500; 
// compiled preview • scanner demo function lerp(a, b, t) { return
 a + (b - a) * t; } function clamp(n, a, b) { return Math.max(a, M
ath.min(b, n)); } // compiled preview • scanner demo // compiled p
review • scanner demo // compiled preview • scanner demo const SCA
N_WIDTH = 8; function lerp(a, b, t) { return a + (b - a) * t; } co
nst now = () => performance.now(); function lerp(a, b, t) { return
 a + (b - a) * t; } const SCAN_WIDTH = 8; // compiled preview • sc
anner demo const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; const MAX_P
ARTICLES = 2500; function lerp(a, b, t) { return a + (b - a) * t; 
} function lerp(a, b, t) { return a + (b - a) * t; } function lerp
(a, b, t) { return a + (b - a) * t; } // compiled preview • scanne
r demo function clamp(n, a, b) { return Math.max(a, Math.min(b, n)

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); // compiled preview • scann
er demo const now = () => performance.now(); const now = () => per
formance.now(); function lerp(a, b, t) { return a + (b - a) * t; }
 function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } fun
ction clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } funct
ion lerp(a, b, t) { return a + (b - a) * t; } const MAX_PARTICLES 
= 2500; // compiled preview • scanner demo function clamp(n, a, b)
 { return Math.max(a, Math.min(b, n)); } // compiled preview • sca
nner demo const now = () => performance.now(); const now = () => p
erformance.now(); function lerp(a, b, t) { return a + (b - a) * t;
 } // compiled preview • scanner demo function lerp(a, b, t) { ret
urn a + (b - a) * t; } const now = () => performance.now(); const 
MAX_PARTICLES = 2500; function lerp(a, b, t) { return a + (b - a) 
* t; } const now = () => performance.now(); const now = () => perf
ormance.now(); const MAX_PARTICLES = 2500; const MAX_PARTICLES = 2

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const SCAN_WIDTH = 8; funct
ion lerp(a, b, t) { return a + (b - a) * t; } function clamp(n, a,
 b) { return Math.max(a, Math.min(b, n)); } const now = () => perf
ormance.now(); function clamp(n, a, b) { return Math.max(a, Math.m
in(b, n)); } function clamp(n, a, b) { return Math.max(a, Math.min
(b, n)); } // compiled preview • scanner demo function clamp(n, a,
 b) { return Math.max(a, Math.min(b, n)); } const SCAN_WIDTH = 8; 
// compiled preview • scanner demo const SCAN_WIDTH = 8; // compil
ed preview • scanner demo const MAX_PARTICLES = 2500; const now = 
() => performance.now(); const MAX_PARTICLES = 2500; const MAX_PAR
TICLES = 2500; const SCAN_WIDTH = 8; function lerp(a, b, t) { retu
rn a + (b - a) * t; } function clamp(n, a, b) { return Math.max(a,
 Math.min(b, n)); } const MAX_PARTICLES = 2500; const MAX_PARTICLE
S = 2500; // compiled preview • scanner demo const now = () => per
formance.now(); const now = () => performance.now(); function lerp
(a, b, t) { return a + (b - a) * t; } // compiled preview • scanne

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const SCAN_WIDTH = 8; funct
ion clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } const M
AX_PARTICLES = 2500; // compiled preview • scanner demo const MAX_
PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Mat
h.min(b, n)); } function clamp(n, a, b) { return Math.max(a, Math.
min(b, n)); } const MAX_PARTICLES = 2500; // compiled preview • sc
anner demo // compiled preview • scanner demo function lerp(a, b, 
t) { return a + (b - a) * t; } // compiled preview • scanner demo 
const now = () => performance.now(); // compiled preview • scanner
 demo // compiled preview • scanner demo function lerp(a, b, t) { 
return a + (b - a) * t; } function clamp(n, a, b) { return Math.ma
x(a, Math.min(b, n)); } function clamp(n, a, b) { return Math.max(
a, Math.min(b, n)); } function lerp(a, b, t) { return a + (b - a) 
* t; } const now = () => performance.now(); const now = () => perf
ormance.now(); const MAX_PARTICLES = 2500; const MAX_PARTICLES = 2
500; function clamp(n, a, b) { return Math.max(a, Math.min(b, n));

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const SCAN_WIDTH = 8; const
 MAX_PARTICLES = 2500; const SCAN_WIDTH = 8; const SCAN_WIDTH = 8;
 const MAX_PARTICLES = 2500; function lerp(a, b, t) { return a + (
b - a) * t; } // compiled preview • scanner demo const SCAN_WIDTH 
= 8; const now = () => performance.now(); // compiled preview • sc
anner demo const MAX_PARTICLES = 2500; // compiled preview • scann
er demo function clamp(n, a, b) { return Math.max(a, Math.min(b, n
)); } const SCAN_WIDTH = 8; function lerp(a, b, t) { return a + (b
 - a) * t; } // compiled preview • scanner demo // compiled previe
w • scanner demo const MAX_PARTICLES = 2500; const now = () => per
formance.now(); function clamp(n, a, b) { return Math.max(a, Math.
min(b, n)); } const MAX_PARTICLES = 2500; function clamp(n, a, b) 
{ return Math.max(a, Math.min(b, n)); } const now = () => performa
nce.now(); // compiled preview • scanner demo const MAX_PARTICLES 
= 2500; function clamp(n, a, b) { return Math.max(a, Math.min(b, n
)); } const now = () => performance.now(); const now = () => perfo

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const SCAN_WIDTH = 8; const
 SCAN_WIDTH = 8; // compiled preview • scanner demo function clamp
(n, a, b) { return Math.max(a, Math.min(b, n)); } const MAX_PARTIC
LES = 2500; function lerp(a, b, t) { return a + (b - a) * t; } fun
ction clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } // co
mpiled preview • scanner demo function clamp(n, a, b) { return Mat
h.max(a, Math.min(b, n)); } // compiled preview • scanner demo con
st now = () => performance.now(); // compiled preview • scanner de
mo // compiled preview • scanner demo const SCAN_WIDTH = 8; const 
MAX_PARTICLES = 2500; const SCAN_WIDTH = 8; function clamp(n, a, b
) { return Math.max(a, Math.min(b, n)); } const SCAN_WIDTH = 8; //
 compiled preview • scanner demo // compiled preview • scanner dem
o const now = () => performance.now(); function lerp(a, b, t) { re
turn a + (b - a) * t; } const MAX_PARTICLES = 2500; function lerp(
a, b, t) { return a + (b - a) * t; } function lerp(a, b, t) { retu
rn a + (b - a) * t; } const now = () => performance.now(); // comp

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const SCAN_WIDTH = 8; // co
mpiled preview • scanner demo function lerp(a, b, t) { return a + 
(b - a) * t; } function lerp(a, b, t) { return a + (b - a) * t; } 
const SCAN_WIDTH = 8; const now = () => performance.now(); const S
CAN_WIDTH = 8; const now = () => performance.now(); const MAX_PART
ICLES = 2500; // compiled preview • scanner demo function clamp(n,
 a, b) { return Math.max(a, Math.min(b, n)); } // compiled preview
 • scanner demo function lerp(a, b, t) { return a + (b - a) * t; }
 const MAX_PARTICLES = 2500; const SCAN_WIDTH = 8; function clamp(
n, a, b) { return Math.max(a, Math.min(b, n)); } const now = () =>
 performance.now(); // compiled preview • scanner demo const SCAN_
WIDTH = 8; function lerp(a, b, t) { return a + (b - a) * t; } cons
t MAX_PARTICLES = 2500; const now = () => performance.now(); const
 now = () => performance.now(); const SCAN_WIDTH = 8; // compiled 
preview • scanner demo const SCAN_WIDTH = 8; const SCAN_WIDTH = 8;
 // compiled preview • scanner demo function lerp(a, b, t) { retur

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const MAX_PARTICLES = 2500;
 const now = () => performance.now(); function clamp(n, a, b) { re
turn Math.max(a, Math.min(b, n)); } const now = () => performance.
now(); const SCAN_WIDTH = 8; const now = () => performance.now(); 
function lerp(a, b, t) { return a + (b - a) * t; } const now = () 
=> performance.now(); const SCAN_WIDTH = 8; // compiled preview • 
scanner demo // compiled preview • scanner demo // compiled previe
w • scanner demo const SCAN_WIDTH = 8; function clamp(n, a, b) { r
eturn Math.max(a, Math.min(b, n)); } const now = () => performance
.now(); const now = () => performance.now(); const MAX_PARTICLES =
 2500; // compiled preview • scanner demo const MAX_PARTICLES = 25
00; const SCAN_WIDTH = 8; const now = () => performance.now(); // 
compiled preview • scanner demo const MAX_PARTICLES = 2500; const 
now = () => performance.now(); const MAX_PARTICLES = 2500; const M
AX_PARTICLES = 2500; const MAX_PARTICLES = 2500; function lerp(a, 
b, t) { return a + (b - a) * t; } function clamp(n, a, b) { return

// Code for scanner-reveal/basic

// Code for scanner-reveal/basic

Custom Content

Use React nodes instead of images:

Speed: 120 px/s

Card 1

Custom content example

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const SCAN_WIDTH = 8; funct
ion lerp(a, b, t) { return a + (b - a) * t; } function clamp(n, a,
 b) { return Math.max(a, Math.min(b, n)); } function lerp(a, b, t)
 { return a + (b - a) * t; } function lerp(a, b, t) { return a + (
b - a) * t; } // compiled preview • scanner demo const MAX_PARTICL
ES = 2500; const now = () => performance.now(); const now = () => 
performance.now(); function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } const SCAN_WIDTH = 8; function lerp(a, b, t) { re
turn a + (b - a) * t; } function clamp(n, a, b) { return Math.max(
a, Math.min(b, n)); } const SCAN_WIDTH = 8; function clamp(n, a, b
) { return Math.max(a, Math.min(b, n)); } // compiled preview • sc
anner demo function clamp(n, a, b) { return Math.max(a, Math.min(b
, n)); } // compiled preview • scanner demo const MAX_PARTICLES = 
2500; const MAX_PARTICLES = 2500; function lerp(a, b, t) { return 
a + (b - a) * t; } function lerp(a, b, t) { return a + (b - a) * t
; } const SCAN_WIDTH = 8; const now = () => performance.now(); fun

Card 2

Another custom card

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const SCAN_WIDTH = 8; funct
ion clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } const M
AX_PARTICLES = 2500; const now = () => performance.now(); function
 lerp(a, b, t) { return a + (b - a) * t; } // compiled preview • s
canner demo const now = () => performance.now(); function lerp(a, 
b, t) { return a + (b - a) * t; } function lerp(a, b, t) { return 
a + (b - a) * t; } function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} function lerp(a, b, t) { return a + (b - a) * t; } const SCAN_WI
DTH = 8; const MAX_PARTICLES = 2500; const SCAN_WIDTH = 8; const M
AX_PARTICLES = 2500; // compiled preview • scanner demo // compile
d preview • scanner demo function clamp(n, a, b) { return Math.max
(a, Math.min(b, n)); } const now = () => performance.now(); const 
SCAN_WIDTH = 8; const now = () => performance.now(); function lerp
(a, b, t) { return a + (b - a) * t; } const MAX_PARTICLES = 2500; 
// compiled preview • scanner demo function lerp(a, b, t) { return

Card 3

More custom content

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const SCAN_WIDTH = 8; const
 MAX_PARTICLES = 2500; // compiled preview • scanner demo const SC
AN_WIDTH = 8; function lerp(a, b, t) { return a + (b - a) * t; } c
onst SCAN_WIDTH = 8; const MAX_PARTICLES = 2500; function clamp(n,
 a, b) { return Math.max(a, Math.min(b, n)); } function clamp(n, a
, b) { return Math.max(a, Math.min(b, n)); } function clamp(n, a, 
b) { return Math.max(a, Math.min(b, n)); } const MAX_PARTICLES = 2
500; function lerp(a, b, t) { return a + (b - a) * t; } function l
erp(a, b, t) { return a + (b - a) * t; } function clamp(n, a, b) {
 return Math.max(a, Math.min(b, n)); } const now = () => performan
ce.now(); function lerp(a, b, t) { return a + (b - a) * t; } const
 MAX_PARTICLES = 2500; const now = () => performance.now(); functi
on lerp(a, b, t) { return a + (b - a) * t; } function clamp(n, a, 
b) { return Math.max(a, Math.min(b, n)); } function lerp(a, b, t) 
{ return a + (b - a) * t; } // compiled preview • scanner demo con
st SCAN_WIDTH = 8; // compiled preview • scanner demo const MAX_PA

Card 1

Custom content example

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const SCAN_WIDTH = 8; const
 SCAN_WIDTH = 8; const now = () => performance.now(); const MAX_PA
RTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Math.
min(b, n)); } const SCAN_WIDTH = 8; const now = () => performance.
now(); const MAX_PARTICLES = 2500; const MAX_PARTICLES = 2500; con
st MAX_PARTICLES = 2500; const now = () => performance.now(); func
tion lerp(a, b, t) { return a + (b - a) * t; } const MAX_PARTICLES
 = 2500; function clamp(n, a, b) { return Math.max(a, Math.min(b, 
n)); } function lerp(a, b, t) { return a + (b - a) * t; } // compi
led preview • scanner demo const now = () => performance.now(); fu
nction lerp(a, b, t) { return a + (b - a) * t; } const now = () =>
 performance.now(); // compiled preview • scanner demo const SCAN_
WIDTH = 8; const SCAN_WIDTH = 8; const now = () => performance.now
(); function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); 
} function lerp(a, b, t) { return a + (b - a) * t; } const MAX_PAR
TICLES = 2500; const SCAN_WIDTH = 8; function lerp(a, b, t) { retu

Card 2

Another custom card

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const MAX_PARTICLES = 2500;
 // compiled preview • scanner demo function lerp(a, b, t) { retur
n a + (b - a) * t; } function clamp(n, a, b) { return Math.max(a, 
Math.min(b, n)); } function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } const SCAN_WIDTH = 8; const MAX_PARTICLES = 2500;
 const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; const MAX_PARTICLES =
 2500; function clamp(n, a, b) { return Math.max(a, Math.min(b, n)
); } function lerp(a, b, t) { return a + (b - a) * t; } const now 
= () => performance.now(); function lerp(a, b, t) { return a + (b 
- a) * t; } const MAX_PARTICLES = 2500; const SCAN_WIDTH = 8; cons
t MAX_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(
a, Math.min(b, n)); } // compiled preview • scanner demo function 
lerp(a, b, t) { return a + (b - a) * t; } function lerp(a, b, t) {
 return a + (b - a) * t; } function clamp(n, a, b) { return Math.m
ax(a, Math.min(b, n)); } const MAX_PARTICLES = 2500; const SCAN_WI
DTH = 8; // compiled preview • scanner demo function clamp(n, a, b

Card 3

More custom content

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const MAX_PARTICLES = 2500;
 const now = () => performance.now(); function clamp(n, a, b) { re
turn Math.max(a, Math.min(b, n)); } function lerp(a, b, t) { retur
n a + (b - a) * t; } function clamp(n, a, b) { return Math.max(a, 
Math.min(b, n)); } const MAX_PARTICLES = 2500; // compiled preview
 • scanner demo // compiled preview • scanner demo const now = () 
=> performance.now(); const MAX_PARTICLES = 2500; // compiled prev
iew • scanner demo function lerp(a, b, t) { return a + (b - a) * t
; } function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); 
} const now = () => performance.now(); // compiled preview • scann
er demo function clamp(n, a, b) { return Math.max(a, Math.min(b, n
)); } function lerp(a, b, t) { return a + (b - a) * t; } const MAX
_PARTICLES = 2500; const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; con
st SCAN_WIDTH = 8; function lerp(a, b, t) { return a + (b - a) * t
; } const now = () => performance.now(); function lerp(a, b, t) { 
return a + (b - a) * t; } const MAX_PARTICLES = 2500; const now = 

Card 1

Custom content example

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const MAX_PARTICLES = 2500;
 function lerp(a, b, t) { return a + (b - a) * t; } const SCAN_WID
TH = 8; // compiled preview • scanner demo const MAX_PARTICLES = 2
500; const MAX_PARTICLES = 2500; function clamp(n, a, b) { return 
Math.max(a, Math.min(b, n)); } // compiled preview • scanner demo 
function lerp(a, b, t) { return a + (b - a) * t; } const MAX_PARTI
CLES = 2500; function lerp(a, b, t) { return a + (b - a) * t; } fu
nction lerp(a, b, t) { return a + (b - a) * t; } // compiled previ
ew • scanner demo const now = () => performance.now(); function le
rp(a, b, t) { return a + (b - a) * t; } const now = () => performa
nce.now(); const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; const MAX_P
ARTICLES = 2500; const now = () => performance.now(); function ler
p(a, b, t) { return a + (b - a) * t; } const now = () => performan
ce.now(); const MAX_PARTICLES = 2500; const MAX_PARTICLES = 2500; 
function lerp(a, b, t) { return a + (b - a) * t; } const SCAN_WIDT
H = 8; function lerp(a, b, t) { return a + (b - a) * t; } function

Card 2

Another custom card

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const MAX_PARTICLES = 2500;
 function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } /
/ compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX_
PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Mat
h.min(b, n)); } // compiled preview • scanner demo const now = () 
=> performance.now(); function clamp(n, a, b) { return Math.max(a,
 Math.min(b, n)); } const MAX_PARTICLES = 2500; const SCAN_WIDTH =
 8; function lerp(a, b, t) { return a + (b - a) * t; } function cl
amp(n, a, b) { return Math.max(a, Math.min(b, n)); } // compiled p
review • scanner demo const MAX_PARTICLES = 2500; const SCAN_WIDTH
 = 8; function lerp(a, b, t) { return a + (b - a) * t; } // compil
ed preview • scanner demo function clamp(n, a, b) { return Math.ma
x(a, Math.min(b, n)); } const MAX_PARTICLES = 2500; const SCAN_WID
TH = 8; // compiled preview • scanner demo const now = () => perfo
rmance.now(); const now = () => performance.now(); // compiled pre
view • scanner demo const MAX_PARTICLES = 2500; const now = () => 

Card 3

More custom content

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); function clamp(n, a, b) { r
eturn Math.max(a, Math.min(b, n)); } const MAX_PARTICLES = 2500; c
onst now = () => performance.now(); const MAX_PARTICLES = 2500; co
nst MAX_PARTICLES = 2500; function clamp(n, a, b) { return Math.ma
x(a, Math.min(b, n)); } function clamp(n, a, b) { return Math.max(
a, Math.min(b, n)); } function lerp(a, b, t) { return a + (b - a) 
* t; } const MAX_PARTICLES = 2500; const MAX_PARTICLES = 2500; con
st now = () => performance.now(); function lerp(a, b, t) { return 
a + (b - a) * t; } const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; con
st SCAN_WIDTH = 8; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } // compiled preview • scanner demo // compiled pr
eview • scanner demo function lerp(a, b, t) { return a + (b - a) *
 t; } // compiled preview • scanner demo function clamp(n, a, b) {
 return Math.max(a, Math.min(b, n)); } const SCAN_WIDTH = 8; const
 MAX_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a
, Math.min(b, n)); } const MAX_PARTICLES = 2500; function lerp(a, 

Card 1

Custom content example

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); function clamp(n, a, b) { r
eturn Math.max(a, Math.min(b, n)); } const SCAN_WIDTH = 8; functio
n lerp(a, b, t) { return a + (b - a) * t; } function lerp(a, b, t)
 { return a + (b - a) * t; } const MAX_PARTICLES = 2500; function 
clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } // compiled
 preview • scanner demo function clamp(n, a, b) { return Math.max(
a, Math.min(b, n)); } const SCAN_WIDTH = 8; const MAX_PARTICLES = 
2500; const MAX_PARTICLES = 2500; function lerp(a, b, t) { return 
a + (b - a) * t; } function lerp(a, b, t) { return a + (b - a) * t
; } const SCAN_WIDTH = 8; const now = () => performance.now(); con
st now = () => performance.now(); function clamp(n, a, b) { return
 Math.max(a, Math.min(b, n)); } const now = () => performance.now(
); const now = () => performance.now(); function clamp(n, a, b) { 
return Math.max(a, Math.min(b, n)); } // compiled preview • scanne
r demo const MAX_PARTICLES = 2500; const now = () => performance.n
ow(); // compiled preview • scanner demo function lerp(a, b, t) { 

Card 2

Another custom card

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); function clamp(n, a, b) { r
eturn Math.max(a, Math.min(b, n)); } // compiled preview • scanner
 demo function clamp(n, a, b) { return Math.max(a, Math.min(b, n))
; } const now = () => performance.now(); const SCAN_WIDTH = 8; fun
ction lerp(a, b, t) { return a + (b - a) * t; } function clamp(n, 
a, b) { return Math.max(a, Math.min(b, n)); } const MAX_PARTICLES 
= 2500; const now = () => performance.now(); const MAX_PARTICLES =
 2500; // compiled preview • scanner demo function lerp(a, b, t) {
 return a + (b - a) * t; } const MAX_PARTICLES = 2500; const MAX_P
ARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Math
.min(b, n)); } // compiled preview • scanner demo // compiled prev
iew • scanner demo function lerp(a, b, t) { return a + (b - a) * t
; } // compiled preview • scanner demo const SCAN_WIDTH = 8; funct
ion clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } functio
n clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } function 
clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } function le

Card 3

More custom content

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); function clamp(n, a, b) { r
eturn Math.max(a, Math.min(b, n)); } const now = () => performance
.now(); const SCAN_WIDTH = 8; // compiled preview • scanner demo c
onst SCAN_WIDTH = 8; function lerp(a, b, t) { return a + (b - a) *
 t; } const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; function lerp(a,
 b, t) { return a + (b - a) * t; } const MAX_PARTICLES = 2500; fun
ction clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } const
 now = () => performance.now(); const now = () => performance.now(
); function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); }
 const SCAN_WIDTH = 8; const MAX_PARTICLES = 2500; const MAX_PARTI
CLES = 2500; function clamp(n, a, b) { return Math.max(a, Math.min
(b, n)); } const SCAN_WIDTH = 8; function lerp(a, b, t) { return a
 + (b - a) * t; } // compiled preview • scanner demo function lerp
(a, b, t) { return a + (b - a) * t; } // compiled preview • scanne
r demo const SCAN_WIDTH = 8; const MAX_PARTICLES = 2500; function 
clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } function cl

Card 1

Custom content example

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); function lerp(a, b, t) { re
turn a + (b - a) * t; } function lerp(a, b, t) { return a + (b - a
) * t; } // compiled preview • scanner demo const SCAN_WIDTH = 8; 
const SCAN_WIDTH = 8; function lerp(a, b, t) { return a + (b - a) 
* t; } function lerp(a, b, t) { return a + (b - a) * t; } const SC
AN_WIDTH = 8; function clamp(n, a, b) { return Math.max(a, Math.mi
n(b, n)); } const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; const now 
= () => performance.now(); function clamp(n, a, b) { return Math.m
ax(a, Math.min(b, n)); } function clamp(n, a, b) { return Math.max
(a, Math.min(b, n)); } const now = () => performance.now(); functi
on lerp(a, b, t) { return a + (b - a) * t; } const now = () => per
formance.now(); const MAX_PARTICLES = 2500; const MAX_PARTICLES = 
2500; const MAX_PARTICLES = 2500; function clamp(n, a, b) { return
 Math.max(a, Math.min(b, n)); } const now = () => performance.now(
); function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); }
 const now = () => performance.now(); function lerp(a, b, t) { ret

Card 2

Another custom card

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); function lerp(a, b, t) { re
turn a + (b - a) * t; } function clamp(n, a, b) { return Math.max(
a, Math.min(b, n)); } const now = () => performance.now(); functio
n clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } // compil
ed preview • scanner demo const now = () => performance.now(); con
st SCAN_WIDTH = 8; // compiled preview • scanner demo const MAX_PA
RTICLES = 2500; const SCAN_WIDTH = 8; function lerp(a, b, t) { ret
urn a + (b - a) * t; } const now = () => performance.now(); // com
piled preview • scanner demo function lerp(a, b, t) { return a + (
b - a) * t; } function lerp(a, b, t) { return a + (b - a) * t; } /
/ compiled preview • scanner demo const SCAN_WIDTH = 8; const SCAN
_WIDTH = 8; function clamp(n, a, b) { return Math.max(a, Math.min(
b, n)); } const now = () => performance.now(); // compiled preview
 • scanner demo // compiled preview • scanner demo // compiled pre
view • scanner demo const MAX_PARTICLES = 2500; // compiled previe
w • scanner demo // compiled preview • scanner demo const now = ()

Card 3

More custom content

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); function lerp(a, b, t) { re
turn a + (b - a) * t; } const MAX_PARTICLES = 2500; function lerp(
a, b, t) { return a + (b - a) * t; } function lerp(a, b, t) { retu
rn a + (b - a) * t; } // compiled preview • scanner demo const now
 = () => performance.now(); function lerp(a, b, t) { return a + (b
 - a) * t; } const now = () => performance.now(); const SCAN_WIDTH
 = 8; const SCAN_WIDTH = 8; const MAX_PARTICLES = 2500; const now 
= () => performance.now(); function lerp(a, b, t) { return a + (b 
- a) * t; } const now = () => performance.now(); const MAX_PARTICL
ES = 2500; const MAX_PARTICLES = 2500; function lerp(a, b, t) { re
turn a + (b - a) * t; } // compiled preview • scanner demo functio
n lerp(a, b, t) { return a + (b - a) * t; } function clamp(n, a, b
) { return Math.max(a, Math.min(b, n)); } function clamp(n, a, b) 
{ return Math.max(a, Math.min(b, n)); } const SCAN_WIDTH = 8; func
tion clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } // com
piled preview • scanner demo const MAX_PARTICLES = 2500; const MAX

Card 1

Custom content example

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); function lerp(a, b, t) { re
turn a + (b - a) * t; } const SCAN_WIDTH = 8; const MAX_PARTICLES 
= 2500; const now = () => performance.now(); // compiled preview •
 scanner demo // compiled preview • scanner demo const SCAN_WIDTH 
= 8; function lerp(a, b, t) { return a + (b - a) * t; } // compile
d preview • scanner demo const SCAN_WIDTH = 8; const now = () => p
erformance.now(); const now = () => performance.now(); const SCAN_
WIDTH = 8; const now = () => performance.now(); // compiled previe
w • scanner demo function lerp(a, b, t) { return a + (b - a) * t; 
} const SCAN_WIDTH = 8; // compiled preview • scanner demo const n
ow = () => performance.now(); // compiled preview • scanner demo /
/ compiled preview • scanner demo function clamp(n, a, b) { return
 Math.max(a, Math.min(b, n)); } // compiled preview • scanner demo
 function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } function clamp(n
, a, b) { return Math.max(a, Math.min(b, n)); } const SCAN_WIDTH =

Card 2

Another custom card

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const now = () => performan
ce.now(); // compiled preview • scanner demo const SCAN_WIDTH = 8;
 const SCAN_WIDTH = 8; const now = () => performance.now(); // com
piled preview • scanner demo const now = () => performance.now(); 
function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } fu
nction lerp(a, b, t) { return a + (b - a) * t; } const SCAN_WIDTH 
= 8; function clamp(n, a, b) { return Math.max(a, Math.min(b, n));
 } const now = () => performance.now(); function lerp(a, b, t) { r
eturn a + (b - a) * t; } // compiled preview • scanner demo functi
on lerp(a, b, t) { return a + (b - a) * t; } const now = () => per
formance.now(); function clamp(n, a, b) { return Math.max(a, Math.
min(b, n)); } const now = () => performance.now(); // compiled pre
view • scanner demo function lerp(a, b, t) { return a + (b - a) * 
t; } function clamp(n, a, b) { return Math.max(a, Math.min(b, n));
 } function lerp(a, b, t) { return a + (b - a) * t; } function cla
mp(n, a, b) { return Math.max(a, Math.min(b, n)); } const SCAN_WID

Card 3

More custom content

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const now = () => performan
ce.now(); const now = () => performance.now(); // compiled preview
 • scanner demo const MAX_PARTICLES = 2500; const now = () => perf
ormance.now(); // compiled preview • scanner demo const MAX_PARTIC
LES = 2500; function clamp(n, a, b) { return Math.max(a, Math.min(
b, n)); } function clamp(n, a, b) { return Math.max(a, Math.min(b,
 n)); } const SCAN_WIDTH = 8; // compiled preview • scanner demo c
onst now = () => performance.now(); const MAX_PARTICLES = 2500; co
nst SCAN_WIDTH = 8; const MAX_PARTICLES = 2500; const SCAN_WIDTH =
 8; // compiled preview • scanner demo function lerp(a, b, t) { re
turn a + (b - a) * t; } const SCAN_WIDTH = 8; const SCAN_WIDTH = 8
; // compiled preview • scanner demo const now = () => performance
.now(); const SCAN_WIDTH = 8; const now = () => performance.now();
 const MAX_PARTICLES = 2500; const SCAN_WIDTH = 8; function clamp(
n, a, b) { return Math.max(a, Math.min(b, n)); } const MAX_PARTICL
ES = 2500; function lerp(a, b, t) { return a + (b - a) * t; } func

Card 1

Custom content example

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const now = () => performan
ce.now(); function lerp(a, b, t) { return a + (b - a) * t; } const
 now = () => performance.now(); function clamp(n, a, b) { return M
ath.max(a, Math.min(b, n)); } const now = () => performance.now();
 const SCAN_WIDTH = 8; const now = () => performance.now(); const 
MAX_PARTICLES = 2500; const MAX_PARTICLES = 2500; const SCAN_WIDTH
 = 8; function lerp(a, b, t) { return a + (b - a) * t; } const now
 = () => performance.now(); const now = () => performance.now(); c
onst SCAN_WIDTH = 8; const SCAN_WIDTH = 8; function clamp(n, a, b)
 { return Math.max(a, Math.min(b, n)); } function clamp(n, a, b) {
 return Math.max(a, Math.min(b, n)); } function clamp(n, a, b) { r
eturn Math.max(a, Math.min(b, n)); } const MAX_PARTICLES = 2500; c
onst now = () => performance.now(); function clamp(n, a, b) { retu
rn Math.max(a, Math.min(b, n)); } // compiled preview • scanner de
mo function lerp(a, b, t) { return a + (b - a) * t; } const MAX_PA
RTICLES = 2500; function lerp(a, b, t) { return a + (b - a) * t; }

Card 2

Another custom card

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const now = () => performan
ce.now(); function clamp(n, a, b) { return Math.max(a, Math.min(b,
 n)); } function clamp(n, a, b) { return Math.max(a, Math.min(b, n
)); } function lerp(a, b, t) { return a + (b - a) * t; } function 
lerp(a, b, t) { return a + (b - a) * t; } const SCAN_WIDTH = 8; co
nst MAX_PARTICLES = 2500; const SCAN_WIDTH = 8; const SCAN_WIDTH =
 8; const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; const now = () => 
performance.now(); function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } const MAX_PARTICLES = 2500; const now = () => per
formance.now(); const now = () => performance.now(); const now = (
) => performance.now(); const MAX_PARTICLES = 2500; function clamp
(n, a, b) { return Math.max(a, Math.min(b, n)); } const MAX_PARTIC
LES = 2500; // compiled preview • scanner demo const SCAN_WIDTH = 
8; const SCAN_WIDTH = 8; // compiled preview • scanner demo // com
piled preview • scanner demo function lerp(a, b, t) { return a + (
b - a) * t; } const now = () => performance.now(); function clamp(

Card 3

More custom content

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); // compiled preview • scann
er demo const MAX_PARTICLES = 2500; const MAX_PARTICLES = 2500; //
 compiled preview • scanner demo function lerp(a, b, t) { return a
 + (b - a) * t; } const SCAN_WIDTH = 8; const now = () => performa
nce.now(); // compiled preview • scanner demo // compiled preview 
• scanner demo const SCAN_WIDTH = 8; const now = () => performance
.now(); const now = () => performance.now(); // compiled preview •
 scanner demo function clamp(n, a, b) { return Math.max(a, Math.mi
n(b, n)); } function clamp(n, a, b) { return Math.max(a, Math.min(
b, n)); } const SCAN_WIDTH = 8; const MAX_PARTICLES = 2500; const 
SCAN_WIDTH = 8; function lerp(a, b, t) { return a + (b - a) * t; }
 // compiled preview • scanner demo const MAX_PARTICLES = 2500; co
nst MAX_PARTICLES = 2500; function lerp(a, b, t) { return a + (b -
 a) * t; } function clamp(n, a, b) { return Math.max(a, Math.min(b
, n)); } const MAX_PARTICLES = 2500; // compiled preview • scanner
 demo // compiled preview • scanner demo const SCAN_WIDTH = 8; con

Card 1

Custom content example

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); // compiled preview • scann
er demo const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; const SCAN_WID
TH = 8; function lerp(a, b, t) { return a + (b - a) * t; } const M
AX_PARTICLES = 2500; const MAX_PARTICLES = 2500; const now = () =>
 performance.now(); const now = () => performance.now(); // compil
ed preview • scanner demo const MAX_PARTICLES = 2500; const now = 
() => performance.now(); function lerp(a, b, t) { return a + (b - 
a) * t; } function clamp(n, a, b) { return Math.max(a, Math.min(b,
 n)); } const SCAN_WIDTH = 8; const MAX_PARTICLES = 2500; const no
w = () => performance.now(); // compiled preview • scanner demo co
nst now = () => performance.now(); function clamp(n, a, b) { retur
n Math.max(a, Math.min(b, n)); } const now = () => performance.now
(); function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); 
} const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; function lerp(a, b, 
t) { return a + (b - a) * t; } const SCAN_WIDTH = 8; const SCAN_WI
DTH = 8; function lerp(a, b, t) { return a + (b - a) * t; } // com

Card 2

Another custom card

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); // compiled preview • scann
er demo // compiled preview • scanner demo // compiled preview • s
canner demo const MAX_PARTICLES = 2500; function clamp(n, a, b) { 
return Math.max(a, Math.min(b, n)); } const MAX_PARTICLES = 2500; 
// compiled preview • scanner demo function lerp(a, b, t) { return
 a + (b - a) * t; } function clamp(n, a, b) { return Math.max(a, M
ath.min(b, n)); } // compiled preview • scanner demo // compiled p
review • scanner demo // compiled preview • scanner demo const SCA
N_WIDTH = 8; function lerp(a, b, t) { return a + (b - a) * t; } co
nst now = () => performance.now(); function lerp(a, b, t) { return
 a + (b - a) * t; } const SCAN_WIDTH = 8; // compiled preview • sc
anner demo const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; const MAX_P
ARTICLES = 2500; function lerp(a, b, t) { return a + (b - a) * t; 
} function lerp(a, b, t) { return a + (b - a) * t; } function lerp
(a, b, t) { return a + (b - a) * t; } // compiled preview • scanne
r demo function clamp(n, a, b) { return Math.max(a, Math.min(b, n)

Card 3

More custom content

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); // compiled preview • scann
er demo const now = () => performance.now(); const now = () => per
formance.now(); function lerp(a, b, t) { return a + (b - a) * t; }
 function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } fun
ction clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } funct
ion lerp(a, b, t) { return a + (b - a) * t; } const MAX_PARTICLES 
= 2500; // compiled preview • scanner demo function clamp(n, a, b)
 { return Math.max(a, Math.min(b, n)); } // compiled preview • sca
nner demo const now = () => performance.now(); const now = () => p
erformance.now(); function lerp(a, b, t) { return a + (b - a) * t;
 } // compiled preview • scanner demo function lerp(a, b, t) { ret
urn a + (b - a) * t; } const now = () => performance.now(); const 
MAX_PARTICLES = 2500; function lerp(a, b, t) { return a + (b - a) 
* t; } const now = () => performance.now(); const now = () => perf
ormance.now(); const MAX_PARTICLES = 2500; const MAX_PARTICLES = 2

Card 1

Custom content example

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const SCAN_WIDTH = 8; funct
ion lerp(a, b, t) { return a + (b - a) * t; } function clamp(n, a,
 b) { return Math.max(a, Math.min(b, n)); } const now = () => perf
ormance.now(); function clamp(n, a, b) { return Math.max(a, Math.m
in(b, n)); } function clamp(n, a, b) { return Math.max(a, Math.min
(b, n)); } // compiled preview • scanner demo function clamp(n, a,
 b) { return Math.max(a, Math.min(b, n)); } const SCAN_WIDTH = 8; 
// compiled preview • scanner demo const SCAN_WIDTH = 8; // compil
ed preview • scanner demo const MAX_PARTICLES = 2500; const now = 
() => performance.now(); const MAX_PARTICLES = 2500; const MAX_PAR
TICLES = 2500; const SCAN_WIDTH = 8; function lerp(a, b, t) { retu
rn a + (b - a) * t; } function clamp(n, a, b) { return Math.max(a,
 Math.min(b, n)); } const MAX_PARTICLES = 2500; const MAX_PARTICLE
S = 2500; // compiled preview • scanner demo const now = () => per
formance.now(); const now = () => performance.now(); function lerp
(a, b, t) { return a + (b - a) * t; } // compiled preview • scanne

Card 2

Another custom card

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const SCAN_WIDTH = 8; funct
ion clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } const M
AX_PARTICLES = 2500; // compiled preview • scanner demo const MAX_
PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Mat
h.min(b, n)); } function clamp(n, a, b) { return Math.max(a, Math.
min(b, n)); } const MAX_PARTICLES = 2500; // compiled preview • sc
anner demo // compiled preview • scanner demo function lerp(a, b, 
t) { return a + (b - a) * t; } // compiled preview • scanner demo 
const now = () => performance.now(); // compiled preview • scanner
 demo // compiled preview • scanner demo function lerp(a, b, t) { 
return a + (b - a) * t; } function clamp(n, a, b) { return Math.ma
x(a, Math.min(b, n)); } function clamp(n, a, b) { return Math.max(
a, Math.min(b, n)); } function lerp(a, b, t) { return a + (b - a) 
* t; } const now = () => performance.now(); const now = () => perf
ormance.now(); const MAX_PARTICLES = 2500; const MAX_PARTICLES = 2
500; function clamp(n, a, b) { return Math.max(a, Math.min(b, n));

Card 3

More custom content

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const SCAN_WIDTH = 8; const
 MAX_PARTICLES = 2500; const SCAN_WIDTH = 8; const SCAN_WIDTH = 8;
 const MAX_PARTICLES = 2500; function lerp(a, b, t) { return a + (
b - a) * t; } // compiled preview • scanner demo const SCAN_WIDTH 
= 8; const now = () => performance.now(); // compiled preview • sc
anner demo const MAX_PARTICLES = 2500; // compiled preview • scann
er demo function clamp(n, a, b) { return Math.max(a, Math.min(b, n
)); } const SCAN_WIDTH = 8; function lerp(a, b, t) { return a + (b
 - a) * t; } // compiled preview • scanner demo // compiled previe
w • scanner demo const MAX_PARTICLES = 2500; const now = () => per
formance.now(); function clamp(n, a, b) { return Math.max(a, Math.
min(b, n)); } const MAX_PARTICLES = 2500; function clamp(n, a, b) 
{ return Math.max(a, Math.min(b, n)); } const now = () => performa
nce.now(); // compiled preview • scanner demo const MAX_PARTICLES 
= 2500; function clamp(n, a, b) { return Math.max(a, Math.min(b, n
)); } const now = () => performance.now(); const now = () => perfo

Card 1

Custom content example

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const SCAN_WIDTH = 8; const
 SCAN_WIDTH = 8; // compiled preview • scanner demo function clamp
(n, a, b) { return Math.max(a, Math.min(b, n)); } const MAX_PARTIC
LES = 2500; function lerp(a, b, t) { return a + (b - a) * t; } fun
ction clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } // co
mpiled preview • scanner demo function clamp(n, a, b) { return Mat
h.max(a, Math.min(b, n)); } // compiled preview • scanner demo con
st now = () => performance.now(); // compiled preview • scanner de
mo // compiled preview • scanner demo const SCAN_WIDTH = 8; const 
MAX_PARTICLES = 2500; const SCAN_WIDTH = 8; function clamp(n, a, b
) { return Math.max(a, Math.min(b, n)); } const SCAN_WIDTH = 8; //
 compiled preview • scanner demo // compiled preview • scanner dem
o const now = () => performance.now(); function lerp(a, b, t) { re
turn a + (b - a) * t; } const MAX_PARTICLES = 2500; function lerp(
a, b, t) { return a + (b - a) * t; } function lerp(a, b, t) { retu
rn a + (b - a) * t; } const now = () => performance.now(); // comp

Card 2

Another custom card

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const SCAN_WIDTH = 8; // co
mpiled preview • scanner demo function lerp(a, b, t) { return a + 
(b - a) * t; } function lerp(a, b, t) { return a + (b - a) * t; } 
const SCAN_WIDTH = 8; const now = () => performance.now(); const S
CAN_WIDTH = 8; const now = () => performance.now(); const MAX_PART
ICLES = 2500; // compiled preview • scanner demo function clamp(n,
 a, b) { return Math.max(a, Math.min(b, n)); } // compiled preview
 • scanner demo function lerp(a, b, t) { return a + (b - a) * t; }
 const MAX_PARTICLES = 2500; const SCAN_WIDTH = 8; function clamp(
n, a, b) { return Math.max(a, Math.min(b, n)); } const now = () =>
 performance.now(); // compiled preview • scanner demo const SCAN_
WIDTH = 8; function lerp(a, b, t) { return a + (b - a) * t; } cons
t MAX_PARTICLES = 2500; const now = () => performance.now(); const
 now = () => performance.now(); const SCAN_WIDTH = 8; // compiled 
preview • scanner demo const SCAN_WIDTH = 8; const SCAN_WIDTH = 8;
 // compiled preview • scanner demo function lerp(a, b, t) { retur

Card 3

More custom content

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const MAX_PARTICLES = 2500;
 const now = () => performance.now(); function clamp(n, a, b) { re
turn Math.max(a, Math.min(b, n)); } const now = () => performance.
now(); const SCAN_WIDTH = 8; const now = () => performance.now(); 
function lerp(a, b, t) { return a + (b - a) * t; } const now = () 
=> performance.now(); const SCAN_WIDTH = 8; // compiled preview • 
scanner demo // compiled preview • scanner demo // compiled previe
w • scanner demo const SCAN_WIDTH = 8; function clamp(n, a, b) { r
eturn Math.max(a, Math.min(b, n)); } const now = () => performance
.now(); const now = () => performance.now(); const MAX_PARTICLES =
 2500; // compiled preview • scanner demo const MAX_PARTICLES = 25
00; const SCAN_WIDTH = 8; const now = () => performance.now(); // 
compiled preview • scanner demo const MAX_PARTICLES = 2500; const 
now = () => performance.now(); const MAX_PARTICLES = 2500; const M
AX_PARTICLES = 2500; const MAX_PARTICLES = 2500; function lerp(a, 
b, t) { return a + (b - a) * t; } function clamp(n, a, b) { return

// Code for scanner-reveal/custom-content

// Code for scanner-reveal/custom-content

Minimal Configuration

Minimal setup without controls:

// compiled preview • scanner demo const SCAN_WIDT
H = 8; const MAX_PARTICLES = 2500; function clamp(
n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } 
const now = () => performance.now(); const SCAN_WI
DTH = 8; function lerp(a, b, t) { return a + (b - 
a) * t; } function clamp(n, a, b) { return Math.ma
x(a, Math.min(b, n)); } function lerp(a, b, t) { r
eturn a + (b - a) * t; } function lerp(a, b, t) { 
return a + (b - a) * t; } // compiled preview • sc
anner demo const MAX_PARTICLES = 2500; const now =
 () => performance.now(); const now = () => perfor
mance.now(); function clamp(n, a, b) { return Math
.max(a, Math.min(b, n)); } const SCAN_WIDTH = 8; f
unction lerp(a, b, t) { return a + (b - a) * t; } 

// compiled preview • scanner demo const SCAN_WIDT
H = 8; const MAX_PARTICLES = 2500; function clamp(
n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } 
const now = () => performance.now(); const SCAN_WI
DTH = 8; function clamp(n, a, b) { return Math.max
(a, Math.min(b, n)); } const MAX_PARTICLES = 2500;
 const now = () => performance.now(); function ler
p(a, b, t) { return a + (b - a) * t; } // compiled
 preview • scanner demo const now = () => performa
nce.now(); function lerp(a, b, t) { return a + (b 
- a) * t; } function lerp(a, b, t) { return a + (b
 - a) * t; } function clamp(n, a, b) { return Math
.max(a, Math.min(b, n)); } function lerp(a, b, t) 
{ return a + (b - a) * t; } function lerp(a, b, t)

// compiled preview • scanner demo const SCAN_WIDT
H = 8; const MAX_PARTICLES = 2500; function clamp(
n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } 
const now = () => performance.now(); const SCAN_WI
DTH = 8; const MAX_PARTICLES = 2500; // compiled p
review • scanner demo const SCAN_WIDTH = 8; functi
on lerp(a, b, t) { return a + (b - a) * t; } const
 SCAN_WIDTH = 8; const MAX_PARTICLES = 2500; funct
ion clamp(n, a, b) { return Math.max(a, Math.min(b
, n)); } function clamp(n, a, b) { return Math.max
(a, Math.min(b, n)); } function clamp(n, a, b) { r
eturn Math.max(a, Math.min(b, n)); } const MAX_PAR
TICLES = 2500; function lerp(a, b, t) { return a +
 (b - a) * t; } function lerp(a, b, t) { return a 

// compiled preview • scanner demo const SCAN_WIDT
H = 8; const MAX_PARTICLES = 2500; function clamp(
n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } 
const now = () => performance.now(); const SCAN_WI
DTH = 8; const SCAN_WIDTH = 8; const now = () => p
erformance.now(); const MAX_PARTICLES = 2500; func
tion clamp(n, a, b) { return Math.max(a, Math.min(
b, n)); } const SCAN_WIDTH = 8; const now = () => 
performance.now(); const MAX_PARTICLES = 2500; con
st MAX_PARTICLES = 2500; const MAX_PARTICLES = 250
0; const now = () => performance.now(); function l
erp(a, b, t) { return a + (b - a) * t; } const MAX
_PARTICLES = 2500; function clamp(n, a, b) { retur
n Math.max(a, Math.min(b, n)); } function lerp(a, 

// compiled preview • scanner demo const SCAN_WIDT
H = 8; const MAX_PARTICLES = 2500; function clamp(
n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } 
const now = () => performance.now(); const MAX_PAR
TICLES = 2500; // compiled preview • scanner demo 
function lerp(a, b, t) { return a + (b - a) * t; }
 function clamp(n, a, b) { return Math.max(a, Math
.min(b, n)); } function clamp(n, a, b) { return Ma
th.max(a, Math.min(b, n)); } const SCAN_WIDTH = 8;
 const MAX_PARTICLES = 2500; const SCAN_WIDTH = 8;
 const SCAN_WIDTH = 8; const MAX_PARTICLES = 2500;
 function clamp(n, a, b) { return Math.max(a, Math
.min(b, n)); } function lerp(a, b, t) { return a +
 (b - a) * t; } const now = () => performance.now(

// compiled preview • scanner demo const SCAN_WIDT
H = 8; const MAX_PARTICLES = 2500; function clamp(
n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } 
const now = () => performance.now(); const MAX_PAR
TICLES = 2500; const now = () => performance.now()
; function clamp(n, a, b) { return Math.max(a, Mat
h.min(b, n)); } function lerp(a, b, t) { return a 
+ (b - a) * t; } function clamp(n, a, b) { return 
Math.max(a, Math.min(b, n)); } const MAX_PARTICLES
 = 2500; // compiled preview • scanner demo // com
piled preview • scanner demo const now = () => per
formance.now(); const MAX_PARTICLES = 2500; // com
piled preview • scanner demo function lerp(a, b, t
) { return a + (b - a) * t; } function clamp(n, a,

// compiled preview • scanner demo const SCAN_WIDT
H = 8; const MAX_PARTICLES = 2500; function clamp(
n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } 
const now = () => performance.now(); const MAX_PAR
TICLES = 2500; function lerp(a, b, t) { return a +
 (b - a) * t; } const SCAN_WIDTH = 8; // compiled 
preview • scanner demo const MAX_PARTICLES = 2500;
 const MAX_PARTICLES = 2500; function clamp(n, a, 
b) { return Math.max(a, Math.min(b, n)); } // comp
iled preview • scanner demo function lerp(a, b, t)
 { return a + (b - a) * t; } const MAX_PARTICLES =
 2500; function lerp(a, b, t) { return a + (b - a)
 * t; } function lerp(a, b, t) { return a + (b - a
) * t; } // compiled preview • scanner demo const 

// compiled preview • scanner demo const SCAN_WIDT
H = 8; const MAX_PARTICLES = 2500; function clamp(
n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } 
const now = () => performance.now(); const MAX_PAR
TICLES = 2500; function clamp(n, a, b) { return Ma
th.max(a, Math.min(b, n)); } // compiled preview •
 scanner demo const SCAN_WIDTH = 8; const MAX_PART
ICLES = 2500; function clamp(n, a, b) { return Mat
h.max(a, Math.min(b, n)); } // compiled preview • 
scanner demo const now = () => performance.now(); 
function clamp(n, a, b) { return Math.max(a, Math.
min(b, n)); } const MAX_PARTICLES = 2500; const SC
AN_WIDTH = 8; function lerp(a, b, t) { return a + 
(b - a) * t; } function clamp(n, a, b) { return Ma

// compiled preview • scanner demo const SCAN_WIDT
H = 8; const MAX_PARTICLES = 2500; function clamp(
n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } 
const now = () => performance.now(); function clam
p(n, a, b) { return Math.max(a, Math.min(b, n)); }
 const MAX_PARTICLES = 2500; const now = () => per
formance.now(); const MAX_PARTICLES = 2500; const 
MAX_PARTICLES = 2500; function clamp(n, a, b) { re
turn Math.max(a, Math.min(b, n)); } function clamp
(n, a, b) { return Math.max(a, Math.min(b, n)); } 
function lerp(a, b, t) { return a + (b - a) * t; }
 const MAX_PARTICLES = 2500; const MAX_PARTICLES =
 2500; const now = () => performance.now(); functi
on lerp(a, b, t) { return a + (b - a) * t; } const

// compiled preview • scanner demo const SCAN_WIDT
H = 8; const MAX_PARTICLES = 2500; function clamp(
n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } 
const now = () => performance.now(); function clam
p(n, a, b) { return Math.max(a, Math.min(b, n)); }
 const SCAN_WIDTH = 8; function lerp(a, b, t) { re
turn a + (b - a) * t; } function lerp(a, b, t) { r
eturn a + (b - a) * t; } const MAX_PARTICLES = 250
0; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } // compiled preview • scanner dem
o function clamp(n, a, b) { return Math.max(a, Mat
h.min(b, n)); } const SCAN_WIDTH = 8; const MAX_PA
RTICLES = 2500; const MAX_PARTICLES = 2500; functi
on lerp(a, b, t) { return a + (b - a) * t; } funct

// compiled preview • scanner demo const SCAN_WIDT
H = 8; const MAX_PARTICLES = 2500; function clamp(
n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } 
const now = () => performance.now(); function clam
p(n, a, b) { return Math.max(a, Math.min(b, n)); }
 // compiled preview • scanner demo function clamp
(n, a, b) { return Math.max(a, Math.min(b, n)); } 
const now = () => performance.now(); const SCAN_WI
DTH = 8; function lerp(a, b, t) { return a + (b - 
a) * t; } function clamp(n, a, b) { return Math.ma
x(a, Math.min(b, n)); } const MAX_PARTICLES = 2500
; const now = () => performance.now(); const MAX_P
ARTICLES = 2500; // compiled preview • scanner dem
o function lerp(a, b, t) { return a + (b - a) * t;

// compiled preview • scanner demo const SCAN_WIDT
H = 8; const MAX_PARTICLES = 2500; function clamp(
n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } 
const now = () => performance.now(); function clam
p(n, a, b) { return Math.max(a, Math.min(b, n)); }
 const now = () => performance.now(); const SCAN_W
IDTH = 8; // compiled preview • scanner demo const
 SCAN_WIDTH = 8; function lerp(a, b, t) { return a
 + (b - a) * t; } const SCAN_WIDTH = 8; const SCAN
_WIDTH = 8; function lerp(a, b, t) { return a + (b
 - a) * t; } const MAX_PARTICLES = 2500; function 
clamp(n, a, b) { return Math.max(a, Math.min(b, n)
); } const now = () => performance.now(); const no
w = () => performance.now(); function clamp(n, a, 

// compiled preview • scanner demo const SCAN_WIDT
H = 8; const MAX_PARTICLES = 2500; function clamp(
n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } 
const now = () => performance.now(); function lerp
(a, b, t) { return a + (b - a) * t; } function ler
p(a, b, t) { return a + (b - a) * t; } // compiled
 preview • scanner demo const SCAN_WIDTH = 8; cons
t SCAN_WIDTH = 8; function lerp(a, b, t) { return 
a + (b - a) * t; } function lerp(a, b, t) { return
 a + (b - a) * t; } const SCAN_WIDTH = 8; function
 clamp(n, a, b) { return Math.max(a, Math.min(b, n
)); } const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; 
const now = () => performance.now(); function clam
p(n, a, b) { return Math.max(a, Math.min(b, n)); }

// compiled preview • scanner demo const SCAN_WIDT
H = 8; const MAX_PARTICLES = 2500; function clamp(
n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } 
const now = () => performance.now(); function lerp
(a, b, t) { return a + (b - a) * t; } function cla
mp(n, a, b) { return Math.max(a, Math.min(b, n)); 
} const now = () => performance.now(); function cl
amp(n, a, b) { return Math.max(a, Math.min(b, n));
 } // compiled preview • scanner demo const now = 
() => performance.now(); const SCAN_WIDTH = 8; // 
compiled preview • scanner demo const MAX_PARTICLE
S = 2500; const SCAN_WIDTH = 8; function lerp(a, b
, t) { return a + (b - a) * t; } const now = () =>
 performance.now(); // compiled preview • scanner 

// compiled preview • scanner demo const SCAN_WIDT
H = 8; const MAX_PARTICLES = 2500; function clamp(
n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } 
const now = () => performance.now(); function lerp
(a, b, t) { return a + (b - a) * t; } const MAX_PA
RTICLES = 2500; function lerp(a, b, t) { return a 
+ (b - a) * t; } function lerp(a, b, t) { return a
 + (b - a) * t; } // compiled preview • scanner de
mo const now = () => performance.now(); function l
erp(a, b, t) { return a + (b - a) * t; } const now
 = () => performance.now(); const SCAN_WIDTH = 8; 
const SCAN_WIDTH = 8; const MAX_PARTICLES = 2500; 
const now = () => performance.now(); function lerp
(a, b, t) { return a + (b - a) * t; } const now = 

// compiled preview • scanner demo const SCAN_WIDT
H = 8; const MAX_PARTICLES = 2500; function clamp(
n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } 
const now = () => performance.now(); function lerp
(a, b, t) { return a + (b - a) * t; } const SCAN_W
IDTH = 8; const MAX_PARTICLES = 2500; const now = 
() => performance.now(); // compiled preview • sca
nner demo // compiled preview • scanner demo const
 SCAN_WIDTH = 8; function lerp(a, b, t) { return a
 + (b - a) * t; } // compiled preview • scanner de
mo const SCAN_WIDTH = 8; const now = () => perform
ance.now(); const now = () => performance.now(); c
onst SCAN_WIDTH = 8; const now = () => performance
.now(); // compiled preview • scanner demo functio

// compiled preview • scanner demo const SCAN_WIDT
H = 8; const MAX_PARTICLES = 2500; function clamp(
n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } 
const now = () => performance.now(); const now = (
) => performance.now(); // compiled preview • scan
ner demo const SCAN_WIDTH = 8; const SCAN_WIDTH = 
8; const now = () => performance.now(); // compile
d preview • scanner demo const now = () => perform
ance.now(); function clamp(n, a, b) { return Math.
max(a, Math.min(b, n)); } function lerp(a, b, t) {
 return a + (b - a) * t; } const SCAN_WIDTH = 8; f
unction clamp(n, a, b) { return Math.max(a, Math.m
in(b, n)); } const now = () => performance.now(); 
function lerp(a, b, t) { return a + (b - a) * t; }

// compiled preview • scanner demo const SCAN_WIDT
H = 8; const MAX_PARTICLES = 2500; function clamp(
n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } 
const now = () => performance.now(); const now = (
) => performance.now(); const now = () => performa
nce.now(); // compiled preview • scanner demo cons
t MAX_PARTICLES = 2500; const now = () => performa
nce.now(); // compiled preview • scanner demo cons
t MAX_PARTICLES = 2500; function clamp(n, a, b) { 
return Math.max(a, Math.min(b, n)); } function cla
mp(n, a, b) { return Math.max(a, Math.min(b, n)); 
} const SCAN_WIDTH = 8; // compiled preview • scan
ner demo const now = () => performance.now(); cons
t MAX_PARTICLES = 2500; const SCAN_WIDTH = 8; cons

// compiled preview • scanner demo const SCAN_WIDT
H = 8; const MAX_PARTICLES = 2500; function clamp(
n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } 
const now = () => performance.now(); const now = (
) => performance.now(); function lerp(a, b, t) { r
eturn a + (b - a) * t; } const now = () => perform
ance.now(); function clamp(n, a, b) { return Math.
max(a, Math.min(b, n)); } const now = () => perfor
mance.now(); const SCAN_WIDTH = 8; const now = () 
=> performance.now(); const MAX_PARTICLES = 2500; 
const MAX_PARTICLES = 2500; const SCAN_WIDTH = 8; 
function lerp(a, b, t) { return a + (b - a) * t; }
 const now = () => performance.now(); const now = 
() => performance.now(); const SCAN_WIDTH = 8; con

// compiled preview • scanner demo const SCAN_WIDT
H = 8; const MAX_PARTICLES = 2500; function clamp(
n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } 
const now = () => performance.now(); const now = (
) => performance.now(); function clamp(n, a, b) { 
return Math.max(a, Math.min(b, n)); } function cla
mp(n, a, b) { return Math.max(a, Math.min(b, n)); 
} function lerp(a, b, t) { return a + (b - a) * t;
 } function lerp(a, b, t) { return a + (b - a) * t
; } const SCAN_WIDTH = 8; const MAX_PARTICLES = 25
00; const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; co
nst SCAN_WIDTH = 8; const SCAN_WIDTH = 8; const no
w = () => performance.now(); function clamp(n, a, 
b) { return Math.max(a, Math.min(b, n)); } const M

// Code for scanner-reveal/minimal

// Code for scanner-reveal/minimal

With Callback

Track when items are scanned:

Scanned Items

0 of 20 items scanned

Speed: 120 px/s

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const SCAN_WIDTH = 8; funct
ion lerp(a, b, t) { return a + (b - a) * t; } function clamp(n, a,
 b) { return Math.max(a, Math.min(b, n)); } function lerp(a, b, t)
 { return a + (b - a) * t; } function lerp(a, b, t) { return a + (
b - a) * t; } // compiled preview • scanner demo const MAX_PARTICL
ES = 2500; const now = () => performance.now(); const now = () => 
performance.now(); function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } const SCAN_WIDTH = 8; function lerp(a, b, t) { re
turn a + (b - a) * t; } function clamp(n, a, b) { return Math.max(
a, Math.min(b, n)); } const SCAN_WIDTH = 8; function clamp(n, a, b
) { return Math.max(a, Math.min(b, n)); } // compiled preview • sc
anner demo function clamp(n, a, b) { return Math.max(a, Math.min(b
, n)); } // compiled preview • scanner demo const MAX_PARTICLES = 
2500; const MAX_PARTICLES = 2500; function lerp(a, b, t) { return 
a + (b - a) * t; } function lerp(a, b, t) { return a + (b - a) * t
; } const SCAN_WIDTH = 8; const now = () => performance.now(); fun

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const SCAN_WIDTH = 8; funct
ion clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } const M
AX_PARTICLES = 2500; const now = () => performance.now(); function
 lerp(a, b, t) { return a + (b - a) * t; } // compiled preview • s
canner demo const now = () => performance.now(); function lerp(a, 
b, t) { return a + (b - a) * t; } function lerp(a, b, t) { return 
a + (b - a) * t; } function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} function lerp(a, b, t) { return a + (b - a) * t; } const SCAN_WI
DTH = 8; const MAX_PARTICLES = 2500; const SCAN_WIDTH = 8; const M
AX_PARTICLES = 2500; // compiled preview • scanner demo // compile
d preview • scanner demo function clamp(n, a, b) { return Math.max
(a, Math.min(b, n)); } const now = () => performance.now(); const 
SCAN_WIDTH = 8; const now = () => performance.now(); function lerp
(a, b, t) { return a + (b - a) * t; } const MAX_PARTICLES = 2500; 
// compiled preview • scanner demo function lerp(a, b, t) { return

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const SCAN_WIDTH = 8; const
 MAX_PARTICLES = 2500; // compiled preview • scanner demo const SC
AN_WIDTH = 8; function lerp(a, b, t) { return a + (b - a) * t; } c
onst SCAN_WIDTH = 8; const MAX_PARTICLES = 2500; function clamp(n,
 a, b) { return Math.max(a, Math.min(b, n)); } function clamp(n, a
, b) { return Math.max(a, Math.min(b, n)); } function clamp(n, a, 
b) { return Math.max(a, Math.min(b, n)); } const MAX_PARTICLES = 2
500; function lerp(a, b, t) { return a + (b - a) * t; } function l
erp(a, b, t) { return a + (b - a) * t; } function clamp(n, a, b) {
 return Math.max(a, Math.min(b, n)); } const now = () => performan
ce.now(); function lerp(a, b, t) { return a + (b - a) * t; } const
 MAX_PARTICLES = 2500; const now = () => performance.now(); functi
on lerp(a, b, t) { return a + (b - a) * t; } function clamp(n, a, 
b) { return Math.max(a, Math.min(b, n)); } function lerp(a, b, t) 
{ return a + (b - a) * t; } // compiled preview • scanner demo con
st SCAN_WIDTH = 8; // compiled preview • scanner demo const MAX_PA

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const SCAN_WIDTH = 8; const
 SCAN_WIDTH = 8; const now = () => performance.now(); const MAX_PA
RTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Math.
min(b, n)); } const SCAN_WIDTH = 8; const now = () => performance.
now(); const MAX_PARTICLES = 2500; const MAX_PARTICLES = 2500; con
st MAX_PARTICLES = 2500; const now = () => performance.now(); func
tion lerp(a, b, t) { return a + (b - a) * t; } const MAX_PARTICLES
 = 2500; function clamp(n, a, b) { return Math.max(a, Math.min(b, 
n)); } function lerp(a, b, t) { return a + (b - a) * t; } // compi
led preview • scanner demo const now = () => performance.now(); fu
nction lerp(a, b, t) { return a + (b - a) * t; } const now = () =>
 performance.now(); // compiled preview • scanner demo const SCAN_
WIDTH = 8; const SCAN_WIDTH = 8; const now = () => performance.now
(); function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); 
} function lerp(a, b, t) { return a + (b - a) * t; } const MAX_PAR
TICLES = 2500; const SCAN_WIDTH = 8; function lerp(a, b, t) { retu

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const MAX_PARTICLES = 2500;
 // compiled preview • scanner demo function lerp(a, b, t) { retur
n a + (b - a) * t; } function clamp(n, a, b) { return Math.max(a, 
Math.min(b, n)); } function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } const SCAN_WIDTH = 8; const MAX_PARTICLES = 2500;
 const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; const MAX_PARTICLES =
 2500; function clamp(n, a, b) { return Math.max(a, Math.min(b, n)
); } function lerp(a, b, t) { return a + (b - a) * t; } const now 
= () => performance.now(); function lerp(a, b, t) { return a + (b 
- a) * t; } const MAX_PARTICLES = 2500; const SCAN_WIDTH = 8; cons
t MAX_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(
a, Math.min(b, n)); } // compiled preview • scanner demo function 
lerp(a, b, t) { return a + (b - a) * t; } function lerp(a, b, t) {
 return a + (b - a) * t; } function clamp(n, a, b) { return Math.m
ax(a, Math.min(b, n)); } const MAX_PARTICLES = 2500; const SCAN_WI
DTH = 8; // compiled preview • scanner demo function clamp(n, a, b

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const MAX_PARTICLES = 2500;
 const now = () => performance.now(); function clamp(n, a, b) { re
turn Math.max(a, Math.min(b, n)); } function lerp(a, b, t) { retur
n a + (b - a) * t; } function clamp(n, a, b) { return Math.max(a, 
Math.min(b, n)); } const MAX_PARTICLES = 2500; // compiled preview
 • scanner demo // compiled preview • scanner demo const now = () 
=> performance.now(); const MAX_PARTICLES = 2500; // compiled prev
iew • scanner demo function lerp(a, b, t) { return a + (b - a) * t
; } function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); 
} const now = () => performance.now(); // compiled preview • scann
er demo function clamp(n, a, b) { return Math.max(a, Math.min(b, n
)); } function lerp(a, b, t) { return a + (b - a) * t; } const MAX
_PARTICLES = 2500; const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; con
st SCAN_WIDTH = 8; function lerp(a, b, t) { return a + (b - a) * t
; } const now = () => performance.now(); function lerp(a, b, t) { 
return a + (b - a) * t; } const MAX_PARTICLES = 2500; const now = 

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const MAX_PARTICLES = 2500;
 function lerp(a, b, t) { return a + (b - a) * t; } const SCAN_WID
TH = 8; // compiled preview • scanner demo const MAX_PARTICLES = 2
500; const MAX_PARTICLES = 2500; function clamp(n, a, b) { return 
Math.max(a, Math.min(b, n)); } // compiled preview • scanner demo 
function lerp(a, b, t) { return a + (b - a) * t; } const MAX_PARTI
CLES = 2500; function lerp(a, b, t) { return a + (b - a) * t; } fu
nction lerp(a, b, t) { return a + (b - a) * t; } // compiled previ
ew • scanner demo const now = () => performance.now(); function le
rp(a, b, t) { return a + (b - a) * t; } const now = () => performa
nce.now(); const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; const MAX_P
ARTICLES = 2500; const now = () => performance.now(); function ler
p(a, b, t) { return a + (b - a) * t; } const now = () => performan
ce.now(); const MAX_PARTICLES = 2500; const MAX_PARTICLES = 2500; 
function lerp(a, b, t) { return a + (b - a) * t; } const SCAN_WIDT
H = 8; function lerp(a, b, t) { return a + (b - a) * t; } function

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const MAX_PARTICLES = 2500;
 function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } /
/ compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX_
PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Mat
h.min(b, n)); } // compiled preview • scanner demo const now = () 
=> performance.now(); function clamp(n, a, b) { return Math.max(a,
 Math.min(b, n)); } const MAX_PARTICLES = 2500; const SCAN_WIDTH =
 8; function lerp(a, b, t) { return a + (b - a) * t; } function cl
amp(n, a, b) { return Math.max(a, Math.min(b, n)); } // compiled p
review • scanner demo const MAX_PARTICLES = 2500; const SCAN_WIDTH
 = 8; function lerp(a, b, t) { return a + (b - a) * t; } // compil
ed preview • scanner demo function clamp(n, a, b) { return Math.ma
x(a, Math.min(b, n)); } const MAX_PARTICLES = 2500; const SCAN_WID
TH = 8; // compiled preview • scanner demo const now = () => perfo
rmance.now(); const now = () => performance.now(); // compiled pre
view • scanner demo const MAX_PARTICLES = 2500; const now = () => 

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); function clamp(n, a, b) { r
eturn Math.max(a, Math.min(b, n)); } const MAX_PARTICLES = 2500; c
onst now = () => performance.now(); const MAX_PARTICLES = 2500; co
nst MAX_PARTICLES = 2500; function clamp(n, a, b) { return Math.ma
x(a, Math.min(b, n)); } function clamp(n, a, b) { return Math.max(
a, Math.min(b, n)); } function lerp(a, b, t) { return a + (b - a) 
* t; } const MAX_PARTICLES = 2500; const MAX_PARTICLES = 2500; con
st now = () => performance.now(); function lerp(a, b, t) { return 
a + (b - a) * t; } const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; con
st SCAN_WIDTH = 8; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } // compiled preview • scanner demo // compiled pr
eview • scanner demo function lerp(a, b, t) { return a + (b - a) *
 t; } // compiled preview • scanner demo function clamp(n, a, b) {
 return Math.max(a, Math.min(b, n)); } const SCAN_WIDTH = 8; const
 MAX_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a
, Math.min(b, n)); } const MAX_PARTICLES = 2500; function lerp(a, 

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); function clamp(n, a, b) { r
eturn Math.max(a, Math.min(b, n)); } const SCAN_WIDTH = 8; functio
n lerp(a, b, t) { return a + (b - a) * t; } function lerp(a, b, t)
 { return a + (b - a) * t; } const MAX_PARTICLES = 2500; function 
clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } // compiled
 preview • scanner demo function clamp(n, a, b) { return Math.max(
a, Math.min(b, n)); } const SCAN_WIDTH = 8; const MAX_PARTICLES = 
2500; const MAX_PARTICLES = 2500; function lerp(a, b, t) { return 
a + (b - a) * t; } function lerp(a, b, t) { return a + (b - a) * t
; } const SCAN_WIDTH = 8; const now = () => performance.now(); con
st now = () => performance.now(); function clamp(n, a, b) { return
 Math.max(a, Math.min(b, n)); } const now = () => performance.now(
); const now = () => performance.now(); function clamp(n, a, b) { 
return Math.max(a, Math.min(b, n)); } // compiled preview • scanne
r demo const MAX_PARTICLES = 2500; const now = () => performance.n
ow(); // compiled preview • scanner demo function lerp(a, b, t) { 

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); function clamp(n, a, b) { r
eturn Math.max(a, Math.min(b, n)); } // compiled preview • scanner
 demo function clamp(n, a, b) { return Math.max(a, Math.min(b, n))
; } const now = () => performance.now(); const SCAN_WIDTH = 8; fun
ction lerp(a, b, t) { return a + (b - a) * t; } function clamp(n, 
a, b) { return Math.max(a, Math.min(b, n)); } const MAX_PARTICLES 
= 2500; const now = () => performance.now(); const MAX_PARTICLES =
 2500; // compiled preview • scanner demo function lerp(a, b, t) {
 return a + (b - a) * t; } const MAX_PARTICLES = 2500; const MAX_P
ARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Math
.min(b, n)); } // compiled preview • scanner demo // compiled prev
iew • scanner demo function lerp(a, b, t) { return a + (b - a) * t
; } // compiled preview • scanner demo const SCAN_WIDTH = 8; funct
ion clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } functio
n clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } function 
clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } function le

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); function clamp(n, a, b) { r
eturn Math.max(a, Math.min(b, n)); } const now = () => performance
.now(); const SCAN_WIDTH = 8; // compiled preview • scanner demo c
onst SCAN_WIDTH = 8; function lerp(a, b, t) { return a + (b - a) *
 t; } const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; function lerp(a,
 b, t) { return a + (b - a) * t; } const MAX_PARTICLES = 2500; fun
ction clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } const
 now = () => performance.now(); const now = () => performance.now(
); function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); }
 const SCAN_WIDTH = 8; const MAX_PARTICLES = 2500; const MAX_PARTI
CLES = 2500; function clamp(n, a, b) { return Math.max(a, Math.min
(b, n)); } const SCAN_WIDTH = 8; function lerp(a, b, t) { return a
 + (b - a) * t; } // compiled preview • scanner demo function lerp
(a, b, t) { return a + (b - a) * t; } // compiled preview • scanne
r demo const SCAN_WIDTH = 8; const MAX_PARTICLES = 2500; function 
clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } function cl

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); function lerp(a, b, t) { re
turn a + (b - a) * t; } function lerp(a, b, t) { return a + (b - a
) * t; } // compiled preview • scanner demo const SCAN_WIDTH = 8; 
const SCAN_WIDTH = 8; function lerp(a, b, t) { return a + (b - a) 
* t; } function lerp(a, b, t) { return a + (b - a) * t; } const SC
AN_WIDTH = 8; function clamp(n, a, b) { return Math.max(a, Math.mi
n(b, n)); } const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; const now 
= () => performance.now(); function clamp(n, a, b) { return Math.m
ax(a, Math.min(b, n)); } function clamp(n, a, b) { return Math.max
(a, Math.min(b, n)); } const now = () => performance.now(); functi
on lerp(a, b, t) { return a + (b - a) * t; } const now = () => per
formance.now(); const MAX_PARTICLES = 2500; const MAX_PARTICLES = 
2500; const MAX_PARTICLES = 2500; function clamp(n, a, b) { return
 Math.max(a, Math.min(b, n)); } const now = () => performance.now(
); function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); }
 const now = () => performance.now(); function lerp(a, b, t) { ret

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); function lerp(a, b, t) { re
turn a + (b - a) * t; } function clamp(n, a, b) { return Math.max(
a, Math.min(b, n)); } const now = () => performance.now(); functio
n clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } // compil
ed preview • scanner demo const now = () => performance.now(); con
st SCAN_WIDTH = 8; // compiled preview • scanner demo const MAX_PA
RTICLES = 2500; const SCAN_WIDTH = 8; function lerp(a, b, t) { ret
urn a + (b - a) * t; } const now = () => performance.now(); // com
piled preview • scanner demo function lerp(a, b, t) { return a + (
b - a) * t; } function lerp(a, b, t) { return a + (b - a) * t; } /
/ compiled preview • scanner demo const SCAN_WIDTH = 8; const SCAN
_WIDTH = 8; function clamp(n, a, b) { return Math.max(a, Math.min(
b, n)); } const now = () => performance.now(); // compiled preview
 • scanner demo // compiled preview • scanner demo // compiled pre
view • scanner demo const MAX_PARTICLES = 2500; // compiled previe
w • scanner demo // compiled preview • scanner demo const now = ()

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); function lerp(a, b, t) { re
turn a + (b - a) * t; } const MAX_PARTICLES = 2500; function lerp(
a, b, t) { return a + (b - a) * t; } function lerp(a, b, t) { retu
rn a + (b - a) * t; } // compiled preview • scanner demo const now
 = () => performance.now(); function lerp(a, b, t) { return a + (b
 - a) * t; } const now = () => performance.now(); const SCAN_WIDTH
 = 8; const SCAN_WIDTH = 8; const MAX_PARTICLES = 2500; const now 
= () => performance.now(); function lerp(a, b, t) { return a + (b 
- a) * t; } const now = () => performance.now(); const MAX_PARTICL
ES = 2500; const MAX_PARTICLES = 2500; function lerp(a, b, t) { re
turn a + (b - a) * t; } // compiled preview • scanner demo functio
n lerp(a, b, t) { return a + (b - a) * t; } function clamp(n, a, b
) { return Math.max(a, Math.min(b, n)); } function clamp(n, a, b) 
{ return Math.max(a, Math.min(b, n)); } const SCAN_WIDTH = 8; func
tion clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } // com
piled preview • scanner demo const MAX_PARTICLES = 2500; const MAX

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); function lerp(a, b, t) { re
turn a + (b - a) * t; } const SCAN_WIDTH = 8; const MAX_PARTICLES 
= 2500; const now = () => performance.now(); // compiled preview •
 scanner demo // compiled preview • scanner demo const SCAN_WIDTH 
= 8; function lerp(a, b, t) { return a + (b - a) * t; } // compile
d preview • scanner demo const SCAN_WIDTH = 8; const now = () => p
erformance.now(); const now = () => performance.now(); const SCAN_
WIDTH = 8; const now = () => performance.now(); // compiled previe
w • scanner demo function lerp(a, b, t) { return a + (b - a) * t; 
} const SCAN_WIDTH = 8; // compiled preview • scanner demo const n
ow = () => performance.now(); // compiled preview • scanner demo /
/ compiled preview • scanner demo function clamp(n, a, b) { return
 Math.max(a, Math.min(b, n)); } // compiled preview • scanner demo
 function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } f
unction lerp(a, b, t) { return a + (b - a) * t; } function clamp(n
, a, b) { return Math.max(a, Math.min(b, n)); } const SCAN_WIDTH =

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const now = () => performan
ce.now(); // compiled preview • scanner demo const SCAN_WIDTH = 8;
 const SCAN_WIDTH = 8; const now = () => performance.now(); // com
piled preview • scanner demo const now = () => performance.now(); 
function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); } fu
nction lerp(a, b, t) { return a + (b - a) * t; } const SCAN_WIDTH 
= 8; function clamp(n, a, b) { return Math.max(a, Math.min(b, n));
 } const now = () => performance.now(); function lerp(a, b, t) { r
eturn a + (b - a) * t; } // compiled preview • scanner demo functi
on lerp(a, b, t) { return a + (b - a) * t; } const now = () => per
formance.now(); function clamp(n, a, b) { return Math.max(a, Math.
min(b, n)); } const now = () => performance.now(); // compiled pre
view • scanner demo function lerp(a, b, t) { return a + (b - a) * 
t; } function clamp(n, a, b) { return Math.max(a, Math.min(b, n));
 } function lerp(a, b, t) { return a + (b - a) * t; } function cla
mp(n, a, b) { return Math.max(a, Math.min(b, n)); } const SCAN_WID

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const now = () => performan
ce.now(); const now = () => performance.now(); // compiled preview
 • scanner demo const MAX_PARTICLES = 2500; const now = () => perf
ormance.now(); // compiled preview • scanner demo const MAX_PARTIC
LES = 2500; function clamp(n, a, b) { return Math.max(a, Math.min(
b, n)); } function clamp(n, a, b) { return Math.max(a, Math.min(b,
 n)); } const SCAN_WIDTH = 8; // compiled preview • scanner demo c
onst now = () => performance.now(); const MAX_PARTICLES = 2500; co
nst SCAN_WIDTH = 8; const MAX_PARTICLES = 2500; const SCAN_WIDTH =
 8; // compiled preview • scanner demo function lerp(a, b, t) { re
turn a + (b - a) * t; } const SCAN_WIDTH = 8; const SCAN_WIDTH = 8
; // compiled preview • scanner demo const now = () => performance
.now(); const SCAN_WIDTH = 8; const now = () => performance.now();
 const MAX_PARTICLES = 2500; const SCAN_WIDTH = 8; function clamp(
n, a, b) { return Math.max(a, Math.min(b, n)); } const MAX_PARTICL
ES = 2500; function lerp(a, b, t) { return a + (b - a) * t; } func

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const now = () => performan
ce.now(); function lerp(a, b, t) { return a + (b - a) * t; } const
 now = () => performance.now(); function clamp(n, a, b) { return M
ath.max(a, Math.min(b, n)); } const now = () => performance.now();
 const SCAN_WIDTH = 8; const now = () => performance.now(); const 
MAX_PARTICLES = 2500; const MAX_PARTICLES = 2500; const SCAN_WIDTH
 = 8; function lerp(a, b, t) { return a + (b - a) * t; } const now
 = () => performance.now(); const now = () => performance.now(); c
onst SCAN_WIDTH = 8; const SCAN_WIDTH = 8; function clamp(n, a, b)
 { return Math.max(a, Math.min(b, n)); } function clamp(n, a, b) {
 return Math.max(a, Math.min(b, n)); } function clamp(n, a, b) { r
eturn Math.max(a, Math.min(b, n)); } const MAX_PARTICLES = 2500; c
onst now = () => performance.now(); function clamp(n, a, b) { retu
rn Math.max(a, Math.min(b, n)); } // compiled preview • scanner de
mo function lerp(a, b, t) { return a + (b - a) * t; } const MAX_PA
RTICLES = 2500; function lerp(a, b, t) { return a + (b - a) * t; }

// compiled preview • scanner demo const SCAN_WIDTH = 8; const MAX
_PARTICLES = 2500; function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } function lerp(a, b, t) { return a + (b - a) * t; 
} const now = () => performance.now(); const now = () => performan
ce.now(); function clamp(n, a, b) { return Math.max(a, Math.min(b,
 n)); } function clamp(n, a, b) { return Math.max(a, Math.min(b, n
)); } function lerp(a, b, t) { return a + (b - a) * t; } function 
lerp(a, b, t) { return a + (b - a) * t; } const SCAN_WIDTH = 8; co
nst MAX_PARTICLES = 2500; const SCAN_WIDTH = 8; const SCAN_WIDTH =
 8; const SCAN_WIDTH = 8; const SCAN_WIDTH = 8; const now = () => 
performance.now(); function clamp(n, a, b) { return Math.max(a, Ma
th.min(b, n)); } const MAX_PARTICLES = 2500; const now = () => per
formance.now(); const now = () => performance.now(); const now = (
) => performance.now(); const MAX_PARTICLES = 2500; function clamp
(n, a, b) { return Math.max(a, Math.min(b, n)); } const MAX_PARTIC
LES = 2500; // compiled preview • scanner demo const SCAN_WIDTH = 
8; const SCAN_WIDTH = 8; // compiled preview • scanner demo // com
piled preview • scanner demo function lerp(a, b, t) { return a + (
b - a) * t; } const now = () => performance.now(); function clamp(

// Code for scanner-reveal/with-callback

// Code for scanner-reveal/with-callback

Features

Interactive: Drag to scroll, mouse wheel support
Smooth animations: RequestAnimationFrame-based animation
Particle effects: Dynamic particle system that intensifies during scanning
ASCII art reveal: Automatically generates code-like ASCII art that reveals as cards pass through the scanner
Customizable: Control speed, colors, dimensions, and behavior via props
Responsive: Adapts to window resizing

Notes

The component requires a dark background for optimal visual effect
The scanner line is positioned at the center of the viewport
Cards automatically wrap when reaching the edges
The particle system dynamically adjusts intensity when cards are being scanned

Credits

This component was inspired by the Scanner Reveal animation by @blacklead-studio on CodePen.

Scanner Reveal

Card 1

Card 2

Card 3

Card 1

Card 2

Card 3

Card 1

Card 2

Card 3

Card 1

Card 2

Card 3

Card 1

Card 2

Card 3

Card 1

Card 2

Card 3

Card 1

Card 2

Card 3

Card 1

Card 2

Card 3

Card 1

Card 2

Card 3

Card 1

Card 2

Card 3

Scanned Items

On this page

Card 1

Card 2

Card 3

Card 1

Card 2

Card 3

Card 1

Card 2

Card 3

Card 1

Card 2

Card 3

Card 1

Card 2

Card 3

Card 1

Card 2

Card 3

Card 1

Card 2

Card 3

Card 1

Card 2

Card 3

Card 1

Card 2

Card 3

Card 1

Card 2

Card 3

Scanned Items