anbeime/skill / skills/hairline/hairline
hairline
Flagged一句话生成跟随鼠标的交互式等轴测线框图(单文件、零依赖、双击即开),或把已有 SVG/Logo 重建为可交互线框。
apps/site/public/skill/hairline-firecrawl-reader.html
View on GitHub<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Hairline figure</title>
<link rel="icon" href="data:,">
<style>
:root { color-scheme: light; --ground: #ffffff; --ink: #232327; --muted: #6f6f78; --line: #e0e0e4; }
@media (prefers-color-scheme: dark) {
:root:not([data-theme="light"]) { color-scheme: dark; --ground: #08090a; --ink: #d0d6e0; --muted: #8a8c95; --line: #29292d; }
}
:root[data-theme="dark"] { color-scheme: dark; --ground: #08090a; --ink: #d0d6e0; --muted: #8a8c95; --line: #29292d; }
:root[data-theme="light"] { color-scheme: light; }
* { box-sizing: border-box; }
body {
margin: 0; min-height: 100vh; display: grid; place-items: center; padding: 24px 16px;
background: var(--ground); color: var(--ink);
font: 13px/1.5 ui-sans-serif, system-ui, -apple-system, "Segoe UI", sans-serif; -webkit-font-smoothing: antialiased;
}
main { width: 100%; max-width: 640px; }
.plate { position: relative; border: 1px solid var(--line); border-radius: 14px; overflow: hidden; }
.tag, .label, output, button { font: 11px/1 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; letter-spacing: 0.02em; }
.tag { position: absolute; top: 12px; z-index: 1; color: var(--muted); pointer-events: none; }
#name { left: 14px; }
#read { right: 14px; color: var(--ink); font-variant-numeric: tabular-nums; }
.controls { display: flex; flex-wrap: wrap; align-items: center; gap: 4px 12px; margin-top: 14px; }
.label { color: var(--muted); }
input[type="range"] {
flex: 1 1 96px; min-width: 0; height: 32px; margin: 0; background: transparent; cursor: pointer;
-webkit-appearance: none; appearance: none;
}
input[type="range"]::-webkit-slider-runnable-track { height: 1px; background: var(--muted); }
input[type="range"]::-webkit-slider-thumb {
-webkit-appearance: none; width: 13px; height: 13px; margin-top: -6px; border-radius: 50%;
border: 1px solid var(--ink); background: var(--ground);
}
input[type="range"]::-moz-range-track { height: 1px; background: var(--muted); }
input[type="range"]::-moz-range-thumb { width: 11px; height: 11px; border-radius: 50%; border: 1px solid var(--ink); background: var(--ground); }
input[type="range"]:focus-visible, button:focus-visible { outline: 1.5px solid var(--ink); outline-offset: 2px; }
output { min-width: 4ch; text-align: right; font-variant-numeric: tabular-nums; }
button {
height: 32px; padding: 0 12px; border: 1px solid var(--line); border-radius: 8px;
background: transparent; color: var(--ink); cursor: pointer;
}
#play[aria-pressed="true"] { background: var(--ink); color: var(--ground); border-color: var(--ink); }
#means { margin: 14px 0 0; text-wrap: pretty; }
#rules { margin: 6px 0 0; line-height: 1.6; }
#error { margin: 12px 0 0; padding-left: 10px; border-left: 1px solid var(--ink); }
</style>
</head>
<body>
<main>
<div class="plate">
<span class="tag" id="name"></span>
<span class="tag" id="read"></span>
<div id="stage"></div>
</div>
<div class="controls">
<label class="label" for="intensity">intensity</label>
<input id="intensity" type="range" min="0" max="1" step="0.01" value="0.5">
<output id="value" for="intensity"></output>
<span class="label">theme</span>
<button id="theme" type="button" aria-label="Switch between the light and the dark theme"></button>
<span class="label">play</span>
<button id="play" type="button" aria-pressed="false">play</button>
</div>
<p id="means"></p>
<p id="rules" class="label"></p>
<p id="error" role="alert" hidden></p>
</main>
<script id="hl-kernel">
/* hairline kernel sha256:346b48bdef2cdfafd5343eba01494255cf75f9c078e6fcd1aafc62bab62980a1 */
/*
* HL: everything a figure may call. Read this index; the code under it is the
* package's src/core, unchanged, and a figure should not need to read it.
*
* Every figure is drawn in a 400 × 320 viewBox. World space is x/y on the
* ground and z up. Plates are filled with the ground colour and painted back
* to front, so a nearer one covers a farther one: append in that order. At
* the default camera, Cam(45, 0.5, S), +x runs down to the right and +y down
* to the left, so the corner with the largest x and y is nearest the viewer:
* append by ascending x + y, from the far corner (smallest x and y) to it.
*
* Camera
* Cam(azDeg, k, S) a camera: azimuth in degrees, k = sin(elevation) (0.5 is the 2:1 view), S = scale
* fit(C, points, cx, cy) centres the box of [x, y, z] points on (cx, cy); call it once, before proj
* it only centres, it never scales: choose S by trying values, with the most extreme pose in points.
* The six figures use S 1.42 to 2.12; the boxes they fit come out 230 to 310 wide and 180 to 245 tall
* proj(C) returns P(x, y, z), which gives [sx, sy]
* unproj(C, sx, sy, z) the world [x, y] under a screen point, on the plane at height z
* facing(C) returns front(sample): whether a ring sample faces the camera
* Rounded solids
* rrect(u0, v0, u1, v1, r, n) a rounded rectangle, as a ring of samples {u, v, nu, nv}
* circ(R, n) a circle, as a ring
* rings(x0, y0, x1, y1, r, b) [ring, inner]: a rounded footprint and its crease ring, inset by b
* r, the corner radius, is cut to half the shorter side. b, the crease's inset in world units
* (0.6 to 2.2 in the figures), must stay under half the shorter side or the crease turns inside out
* prism(P, front, ring, inner, z0, z1) {sil, crease}: a solid standing from z0 to z1, as two path strings
* ringAt(P, ring, z) the ring's points, projected at height z
* run(ring, keep) the one cyclic run of samples that pass keep
* hull(points) the convex hull of screen points
* extremes(P, ring) [left, right, nearest] samples: where dashed drops fall from
* fillet(points, radii, n) rounds every vertex of a closed polygon; returns the new points
* radii is an array, one radius per vertex, each cut to half its shorter edge; a single number gives NaN.
* n is the steps round each corner, default 4: each vertex becomes n + 1 points
* ghost(P, front, ring, z0, depth) a reflection's path {d, y0, y1}; reflect() draws it for you
* Paths and numbers
* poly(points) a closed path string
* open(points) an open polyline string
* seg(a, b) one segment between two screen points [sx, sy], as its own subpath; project world points with P first
* clamp(v, a, b)
* lerp(a, b, t)
* rad(deg)
* r2(n) two decimals
* The continuous clock: one spring per moving number
* spring(x, opts) at rest on x; write .t to retarget; opts {k, c, m, eps}, default k 100, c 18, m 1
* stepS(sp, dt) advances by dt seconds; returns whether it is still moving
* The discrete clock: a 700ms tween on (.32, .72, 0, 1)
* tween(v, dur) at rest on v; dur defaults to 700 (ms)
* tset(tw, to, now, delay) retargets from where it is, after delay ms: the stagger
* the same target again does nothing, so calling it on every pointer move is safe
* tval(tw, now) its value at now
* tdone(tw, now) whether it has landed
* bezier(x1, y1, x2, y2) a CSS cubic-bezier, as a function of progress
* EASE_LIFT the lift curve itself
* reducedMotion() true when the reader asked for less motion; springs and tweens already land at once
* setReducedMotion(on) the loop's business, not a figure's
* Drawing
* mk(tag, attrs, parent) one svg element: the only way a figure makes a node
* solid(parent) {g, sil, cr}: a group holding a silhouette path and a crease path
* put(solid, paths) writes prism()'s {sil, crease} into solid()'s {sil, cr}: sil into sil, crease into cr
* flatDot(parent, C, r, cls) a dot lying on the ground plane; cls is "dot", "dot m" or "dot off"
* place(el, point) moves a dot or a circle to [sx, sy]
* reflect(svg, parent, P, front, ring, z0, depth) a fading mirror under a solid
* fade(svg, y0, y1, a0) a vertical fade, as a mask; returns the value for a mask attribute
* Life
* register(stage, tick) joins the one frame loop; tick(dt in seconds, now in ms) returns true to ask for another frame; gives {wake, unregister}
* pointer(stage, handlers) {move(point), down(point), leave()}, points in viewBox units; returns its disposer
* disposer() {add, on, dispose}: collects tear-down, so destroy is bag.dispose
* The bench's business, not a figure's
* css(lightDark)
* inject(root)
* tour(stage, stops, onStop) an unseen pointer that walks the stops, [x, y] in viewBox units or null to leave, and gives way to a real one; onStop(i) on each arrival; returns {stop}
* LAP the default stops: a diamond around the centre, then a leave
*
* Classes, on path, polygon, ellipse and line. They are the whole palette; a
* figure sets no colour, width or fill of its own.
* (none) filled with the ground colour, medium stroke
* sil the silhouette's stroke hi the bright stroke: the only highlight
* lo the dim stroke nf no fill fo fill only, no stroke
* dash a dashed guide
* dot a bright dot dot m a medium dot dot off a dim dot
*/
var HL = (() => {
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// packages/hairline/src/core/kernel.ts
var kernel_exports = {};
__export(kernel_exports, {
Cam: () => Cam,
EASE_LIFT: () => EASE_LIFT,
LAP: () => LAP,
bezier: () => bezier,
circ: () => circ,
clamp: () => clamp,
css: () => css,
disposer: () => disposer,
extremes: () => extremes,
facing: () => facing,
fade: () => fade,
fillet: () => fillet,
fit: () => fit,
flatDot: () => flatDot,
ghost: () => ghost,
hull: () => hull,
inject: () => inject,
lerp: () => lerp,
mk: () => mk,
open: () => open,
place: () => place,
pointer: () => pointer,
poly: () => poly,
prism: () => prism,
proj: () => proj,
put: () => put,
r2: () => r2,
rad: () => rad,
reducedMotion: () => reducedMotion,
reflect: () => reflect,
register: () => register,
ringAt: () => ringAt,
rings: () => rings,
rrect: () => rrect,
run: () => run,
seg: () => seg,
setReducedMotion: () => setReducedMotion,
solid: () => solid,
spring: () => spring,
stepS: () => stepS,
tdone: () => tdone,
tour: () => tour,
tset: () => tset,
tval: () => tval,
tween: () => tween,
unproj: () => unproj
});
// packages/hairline/src/core/iso.ts
var clamp = (v, a, b) => Math.max(a, Math.min(b, v));
var lerp = (a, b, t) => a + (b - a) * t;
var rad = (d) => d * Math.PI / 180;
var r2 = (n) => Math.round(n * 100) / 100;
var poly = (pts) => "M" + pts.map((p) => r2(p[0]) + " " + r2(p[1])).join("L") + "Z";
var seg = (a, b) => `M${r2(a[0])} ${r2(a[1])}L${r2(b[0])} ${r2(b[1])}`;
var open = (pts) => pts.length < 2 ? "" : "M" + pts.map((p) => r2(p[0]) + " " + r2(p[1])).join("L");
var Cam = (azDeg, k, S) => ({ az: rad(azDeg), k, S, ox: 0, oy: 0 });
function proj(C) {
const c = Math.cos(C.az), s = Math.sin(C.az), zf = Math.sqrt(1 - C.k * C.k);
return (x, y, z) => {
const X = x * c - y * s, Y = x * s + y * c;
return [C.ox + C.S * X, C.oy + C.S * (Y * C.k - z * zf)];
};
}
function unproj(C, sx, sy, z) {
const c = Math.cos(C.az), s = Math.sin(C.az), zf = Math.sqrt(1 - C.k * C.k);
const X = (sx - C.ox) / C.S, Y = ((sy - C.oy) / C.S + z * zf) / C.k;
return [X * c + Y * s, -X * s + Y * c];
}
function fit(C, pts, cx, cy) {
C.ox = 0;
C.oy = 0;
const P = proj(C);
let a = 1e9, b = -1e9, c = 1e9, d = -1e9;
for (const p of pts) {
const q = P(p[0], p[1], p[2]);
a = Math.min(a, q[0]);
b = Math.max(b, q[0]);
c = Math.min(c, q[1]);
d = Math.max(d, q[1]);
}
C.ox = cx - (a + b) / 2;
C.oy = cy - (c + d) / 2;
}
function rrect(u0, v0, u1, v1, r, n = 4) {
r = Math.max(0, Math.min(r, (u1 - u0) / 2, (v1 - v0) / 2));
const out = [];
for (const [cu, cv, a0] of [[u1 - r, v1 - r, 0], [u0 + r, v1 - r, 90], [u0 + r, v0 + r, 180], [u1 - r, v0 + r, 270]])
for (let k = 0; k <= n; k++) {
const a = rad(a0 + 90 * k / n), ca = Math.cos(a), sa = Math.sin(a);
out.push({ u: cu + r * ca, v: cv + r * sa, nu: ca, nv: sa });
}
return out;
}
function circ(R, n = 96) {
const out = [];
for (let k = 0; k < n; k++) {
const a = k / n * Math.PI * 2, ca = Math.cos(a), sa = Math.sin(a);
out.push({ u: R * ca, v: R * sa, nu: ca, nv: sa });
}
return out;
}
function hull(input) {
const pts = input.slice().sort((a, b) => a[0] - b[0] || a[1] - b[1]);
const x = (o, a, b) => (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
const lo = [], up = [];
for (const p of pts) {
while (lo.length > 1 && x(lo[lo.length - 2], lo[lo.length - 1], p) <= 0) lo.pop();
lo.push(p);
}
for (let i = pts.length - 1; i >= 0; i--) {
const p = pts[i];
while (up.length > 1 && x(up[up.length - 2], up[up.length - 1], p) <= 0) up.pop();
up.push(p);
}
lo.pop();
up.pop();
return lo.concat(up);
}
var ringAt = (P, ring, z) => ring.map((q) => P(q.u, q.v, z));
var facing = (C) => {
const s = Math.sin(C.az), c = Math.cos(C.az);
return (q) => q.nu * s + q.nv * c >= -1e-6;
};
function run(ring, keep) {
const n = ring.length;
let s = -1;
for (let i = 0; i < n; i++) if (keep(ring[i]) && !keep(ring[(i + n - 1) % n])) {
s = i;
break;
}
if (s < 0) return keep(ring[0]) ? ring.slice() : [];
const out = [];
for (let k = 0; k < n && keep(ring[(s + k) % n]); k++) out.push(ring[(s + k) % n]);
return out;
}
function prism(P, front, ring, inner, z0, z1) {
return {
sil: poly(hull(ringAt(P, ring, z1).concat(ringAt(P, ring, z0)))),
crease: inner ? open(ringAt(P, run(inner, front), z1)) : ""
};
}
var rings = (x0, y0, x1, y1, r, b) => [
rrect(x0, y0, x1, y1, r),
rrect(x0 + b, y0 + b, x1 - b, y1 - b, Math.max(0.3, r - b))
];
function extremes(P, ring) {
const pr = ring.map((q) => P(q.u, q.v, 0));
let a = 0, b = 0, c = 0;
pr.forEach((p, k) => {
if (p[0] < pr[a][0]) a = k;
if (p[0] > pr[b][0]) b = k;
if (p[1] > pr[c][1]) c = k;
});
return [ring[a], ring[b], ring[c]];
}
function fillet(pts, rs, n = 4) {
const m = pts.length, out = [];
for (let i = 0; i < m; i++) {
const a = pts[(i + m - 1) % m], p = pts[i], b = pts[(i + 1) % m];
const la = Math.hypot(a[0] - p[0], a[1] - p[1]), lb = Math.hypot(b[0] - p[0], b[1] - p[1]);
const t = Math.min(rs[i], la / 2, lb / 2);
const p1 = [p[0] + (a[0] - p[0]) / la * t, p[1] + (a[1] - p[1]) / la * t];
const p2 = [p[0] + (b[0] - p[0]) / lb * t, p[1] + (b[1] - p[1]) / lb * t];
for (let k = 0; k <= n; k++) {
const s = k / n, w = 1 - s;
out.push([w * w * p1[0] + 2 * w * s * p[0] + s * s * p2[0], w * w * p1[1] + 2 * w * s * p[1] + s * s * p2[1]]);
}
}
return out;
}
function ghost(P, front, ring, z0, depth) {
const f = run(ring, front), lowP = ringAt(P, f, z0 - depth);
return {
d: open(lowP) + [f[0], f[f.length - 1]].map((q) => seg(P(q.u, q.v, z0), P(q.u, q.v, z0 - depth))).join(""),
y0: Math.min(...ringAt(P, f, z0).map((p) => p[1])),
y1: Math.max(...lowP.map((p) => p[1])) + 2
};
}
// packages/hairline/src/core/motion.ts
var reduced = false;
var setReducedMotion = (on) => {
reduced = on;
};
var reducedMotion = () => reduced;
function spring(x, o = {}) {
return { x, v: 0, t: x, k: o.k ?? 100, c: o.c ?? 18, m: o.m ?? 1, eps: o.eps ?? 0.01 };
}
function stepS(sp, dt) {
if (reduced) {
sp.x = sp.t;
sp.v = 0;
return false;
}
const n = Math.max(1, Math.ceil(dt * 240)), h = dt / n;
for (let i = 0; i < n; i++) {
const a = (-sp.k * (sp.x - sp.t) - sp.c * sp.v) / sp.m;
sp.v += a * h;
sp.x += sp.v * h;
}
if (Math.abs(sp.x - sp.t) < sp.eps && Math.abs(sp.v) < sp.eps * 10) {
sp.x = sp.t;
sp.v = 0;
return false;
}
return true;
}
function bezier(x1, y1, x2, y2) {
const cx = 3 * x1, bx = 3 * (x2 - x1) - cx, ax = 1 - cx - bx;
const cy = 3 * y1, by = 3 * (y2 - y1) - cy, ay = 1 - cy - by;
const X = (u) => ((ax * u + bx) * u + cx) * u;
const Y = (u) => ((ay * u + by) * u + cy) * u;
const dX = (u) => (3 * ax * u + 2 * bx) * u + cx;
return (t) => {
if (t <= 0) return 0;
if (t >= 1) return 1;
let u = t;
for (let i = 0; i < 8; i++) {
const e = X(u) - t;
if (Math.abs(e) < 1e-5) break;
const d = dX(u);
if (Math.abs(d) < 1e-6) break;
u -= e / d;
}
if (!(u >= 0 && u <= 1) || Math.abs(X(u) - t) > 1e-4) {
let lo = 0, hi = 1;
u = t;
for (let i = 0; i < 24; i++) {
if (X(u) < t) lo = u;
else hi = u;
u = (lo + hi) / 2;
}
}
return Y(u);
};
}
var EASE_LIFT = bezier(0.32, 0.72, 0, 1);
var tween = (v, dur = 700) => ({ from: v, to: v, t0: -1e9, dur });
var tval = (tw, now) => {
const p = clamp((now - tw.t0) / tw.dur, 0, 1);
return tw.from + (tw.to - tw.from) * (reduced ? 1 : EASE_LIFT(p));
};
var tset = (tw, to, now, delay) => {
if (tw.to === to) return;
tw.from = tval(tw, now);
tw.to = to;
tw.t0 = now + delay;
};
var tdone = (tw, now) => reduced || now >= tw.t0 + tw.dur;
// packages/hairline/src/core/stage.ts
var NS = "http://www.w3.org/2000/svg";
function mk(tag, attrs, parent) {
const e = document.createElementNS(NS, tag);
if (attrs) for (const k in attrs) e.setAttribute(k, String(attrs[k]));
if (parent) parent.appendChild(e);
return e;
}
function solid(parent) {
const g = mk("g", {}, parent);
return { g, sil: mk("path", { class: "sil" }, g), cr: mk("path", { class: "nf lo" }, g) };
}
var put = (el, s) => {
el.sil.setAttribute("d", s.sil);
el.cr.setAttribute("d", s.crease);
};
var flatDot = (parent, C, r, cls) => mk("ellipse", { rx: r2(r * C.S), ry: r2(r * C.S * C.k), class: cls }, parent);
var place = (el, q) => {
el.setAttribute("cx", String(r2(q[0])));
el.setAttribute("cy", String(r2(q[1])));
};
var fid = 0;
function fade(svg, y0, y1, a0 = 0.7) {
const id = "hl-fd" + ++fid, defs = mk("defs", {}, svg);
const lg = mk("linearGradient", { id: id + "g", gradientUnits: "userSpaceOnUse", x1: 0, y1: r2(y0), x2: 0, y2: r2(y1) }, defs);
mk("stop", { offset: 0, "stop-color": "#fff", "stop-opacity": a0 }, lg);
mk("stop", { offset: 1, "stop-color": "#fff", "stop-opacity": 0 }, lg);
const m = mk("mask", { id, maskUnits: "userSpaceOnUse", x: 0, y: 0, width: 400, height: 320 }, defs);
mk("rect", { x: 0, y: 0, width: 400, height: 320, fill: `url(#${id}g)` }, m);
return `url(#${id})`;
}
function reflect(svg, parent, P, front, ring, z0, depth) {
const r = ghost(P, front, ring, z0, depth);
const gh = mk("g", { class: "ghost", mask: fade(svg, r.y0, r.y1) }, parent);
mk("path", { d: r.d }, gh);
}
var boards = [];
var byStage = /* @__PURE__ */ new Map();
var raf = 0;
var last = 0;
var io = null;
var rm = null;
function frame() {
const now = performance.now();
const dt = Math.min(0.05, Math.max(0, (now - last) / 1e3));
last = now;
let any = false;
for (const b of boards.slice()) if (b.vis && b.awake) {
try {
b.awake = !!b.tick(dt, now);
} catch (err) {
b.awake = false;
setTimeout(() => {
throw err;
});
}
any = any || b.awake;
}
raf = any ? requestAnimationFrame(frame) : 0;
}
function wake(b) {
b.awake = true;
if (!raf) {
last = performance.now();
raf = requestAnimationFrame(frame);
}
}
var onMotion = () => {
setReducedMotion(!!rm?.matches);
boards.forEach(wake);
};
function start() {
if (io) return;
io = new IntersectionObserver((es) => {
for (const e of es) {
const set = byStage.get(e.target);
if (!set) continue;
for (const b of set) {
b.vis = e.isIntersecting;
if (b.vis) wake(b);
}
}
}, { rootMargin: "80px" });
rm = matchMedia("(prefers-reduced-motion: reduce)");
setReducedMotion(rm.matches);
rm.addEventListener("change", onMotion);
}
function stop() {
if (raf) cancelAnimationFrame(raf);
raf = 0;
io?.disconnect();
io = null;
rm?.removeEventListener("change", onMotion);
rm = null;
}
function register(stage, tick) {
start();
const b = { stage, tick, vis: false, awake: true };
boards.push(b);
const peers = byStage.get(stage);
if (peers) {
for (const p of peers) b.vis = p.vis;
peers.add(b);
if (b.vis) wake(b);
} else {
byStage.set(stage, /* @__PURE__ */ new Set([b]));
io.observe(stage);
}
tick(0, performance.now());
let gone = false;
return {
wake: () => {
if (!gone) wake(b);
},
unregister: () => {
if (gone) return;
gone = true;
boards = boards.filter((x) => x !== b);
const set = byStage.get(stage);
if (set) {
set.delete(b);
if (!set.size) {
byStage.delete(stage);
io?.unobserve(stage);
}
}
if (!boards.length) stop();
}
};
}
var handlers = /* @__PURE__ */ new WeakMap();
var touring = /* @__PURE__ */ new WeakMap();
function pointer(stage, on) {
handlers.set(stage, on);
let tm = 0;
const pt = (e) => {
const r = stage.getBoundingClientRect();
return [(e.clientX - r.left) / r.width * 400, (e.clientY - r.top) / r.height * 320];
};
const move = (e) => {
clearTimeout(tm);
touring.get(stage)?.hold();
on.move(pt(e), e);
};
const down = (e) => {
clearTimeout(tm);
touring.get(stage)?.hold();
if (e.pointerType !== "mouse") stage.releasePointerCapture?.(e.pointerId);
if (on.down) on.down(pt(e), e);
else on.move(pt(e), e);
};
const leave = (e) => {
clearTimeout(tm);
tm = window.setTimeout(() => {
on.leave(e);
touring.get(stage)?.release();
}, e.pointerType === "mouse" ? 0 : 1400);
};
stage.addEventListener("pointermove", move);
stage.addEventListener("pointerdown", down);
stage.addEventListener("pointerleave", leave);
return () => {
clearTimeout(tm);
if (handlers.get(stage) === on) handlers.delete(stage);
stage.removeEventListener("pointermove", move);
stage.removeEventListener("pointerdown", down);
stage.removeEventListener("pointerleave", leave);
};
}
var LAP = [[128, 150], [200, 118], [272, 150], [200, 206], null];
var TRAVEL = 900;
var DWELL = 1200;
var REST = 1800;
var RESUME = 1200;
var STAGGER = 450;
var GHOST = { pointerType: "ghost" };
var started = 0;
function entry([x, y]) {
const dx = x - 200, dy = y - 160;
if (!dx && !dy) return [200, 320];
const k = Math.min(dx ? (dx > 0 ? 200 : -200) / dx : Infinity, dy ? (dy > 0 ? 160 : -160) / dy : Infinity);
return [200 + dx * k, 160 + dy * k];
}
function tour(stage, stops, onStop) {
let i = 0;
let wait = RESUME + STAGGER * (started++ % 4);
let t = -1;
let at = null;
let origin = [200, 320];
let hand = false, keys = stage.contains(stage.ownerDocument.activeElement);
let gone = false;
const leave = () => {
at = null;
t = -1;
handlers.get(stage)?.leave(GHOST);
};
const tick = (dt) => {
if (hand || keys || !stops.length) return false;
if (reducedMotion()) {
if (at) leave();
return false;
}
if (wait > 0) {
wait -= dt * 1e3;
return true;
}
const stop2 = stops[i];
if (stop2 === null) {
if (at) leave();
onStop?.(i);
i = (i + 1) % stops.length;
wait = REST;
return true;
}
const h = handlers.get(stage);
if (!h) return true;
if (t < 0) {
origin = at ?? entry(stop2);
t = 0;
}
t = Math.min(TRAVEL, t + dt * 1e3);
const k = EASE_LIFT(t / TRAVEL);
at = [origin[0] + (stop2[0] - origin[0]) * k, origin[1] + (stop2[1] - origin[1]) * k];
h.move(at, GHOST);
if (t < TRAVEL) return true;
onStop?.(i);
i = (i + 1) % stops.length;
t = -1;
wait = DWELL;
return true;
};
const take = () => {
at = null;
t = -1;
};
const give = () => {
if (hand || keys) return;
i = 0;
t = -1;
wait = RESUME;
board.wake();
};
const me = {
hold: () => {
hand = true;
take();
},
release: () => {
if (!hand) return;
hand = false;
give();
}
};
const focusIn = () => {
keys = true;
take();
};
const focusOut = (e) => {
if (keys && !stage.contains(e.relatedTarget)) {
keys = false;
give();
}
};
stage.addEventListener("focusin", focusIn);
stage.addEventListener("focusout", focusOut);
touring.set(stage, me);
const board = register(stage, tick);
return {
stop: () => {
if (gone) return;
gone = true;
board.unregister();
stage.removeEventListener("focusin", focusIn);
stage.removeEventListener("focusout", focusOut);
if (touring.get(stage) === me) touring.delete(stage);
if (at) leave();
}
};
}
function disposer() {
let fns = [];
return {
add: (fn) => {
fns.push(fn);
},
on: (target, type, fn, opts) => {
const h = fn;
target.addEventListener(type, h, opts);
fns.push(() => target.removeEventListener(type, h, opts));
},
dispose: () => {
const run2 = fns;
fns = [];
for (let i = run2.length - 1; i >= 0; i--) run2[i]();
}
};
}
// packages/hairline/src/core/styles.ts
var LIGHT = { plate: "#ffffff", hi: "#232327", edge: "#a4a4ac", mid: "#c3c3c9", lo: "#e0e0e4" };
var DARK = { plate: "#08090a", hi: "#d0d6e0", edge: "#5b5d64", mid: "#3e3e44", lo: "#29292d" };
var KEYS = ["plate", "hi", "edge", "mid", "lo"];
var vars = (p) => KEYS.map((k) => `--hl-${k}:var(--hairline-${k},${p[k]});`).join("");
var EASE = "cubic-bezier(0.5,0,0.1,1)";
var SVG = ":where([data-hairline]>svg)";
function css(lightDark) {
const both = Object.fromEntries(KEYS.map((k) => [k, `light-dark(${LIGHT[k]},${DARK[k]})`]));
return [
// the box, and the palette: light unless something below says otherwise
`:where([data-hairline]){display:block;position:relative;aspect-ratio:5/4;touch-action:pan-y;user-select:none;-webkit-user-select:none;--hl-sw:var(--hairline-stroke,0.9);${vars(LIGHT)}}`,
// the page's color-scheme
lightDark ? `:where([data-hairline]){${vars(both)}}` : "",
// an ancestor that says dark
`:where(.dark,[data-theme="dark"]) :where([data-hairline]){${vars(DARK)}}`,
// the figure's own theme option
`:where([data-hairline][data-hairline-theme="light"]){${vars(LIGHT)}}`,
`:where([data-hairline][data-hairline-theme="dark"]){${vars(DARK)}}`,
`:where([data-hairline]:focus-visible){outline:1.5px solid var(--hl-hi);outline-offset:2px}`,
`${SVG}{position:absolute;inset:0;width:100%;height:100%;display:block}`,
// Riffle's live region: read, not seen
`:where([data-hairline]>[data-hairline-live]){position:absolute;width:1px;height:1px;margin:-1px;padding:0;border:0;overflow:hidden;clip-path:inset(50%);white-space:nowrap}`,
// the drawing: plates are filled with the plate colour and painted back to front
`${SVG} :where(path,polygon,ellipse,line){fill:var(--hl-plate);stroke:var(--hl-mid);stroke-width:var(--hl-sw);vector-effect:non-scaling-stroke;stroke-linejoin:round;stroke-linecap:round;transition:stroke 260ms ${EASE}}`,
`${SVG} :where(.nf){fill:none}`,
`${SVG} :where(.fo){stroke:none}`,
`${SVG} :where(.sil){stroke:var(--hl-edge)}`,
`${SVG} :where(.hi){stroke:var(--hl-hi)}`,
`${SVG} :where(.lo){stroke:var(--hl-lo)}`,
`${SVG} :where(.dash){stroke-dasharray:1 3}`,
`${SVG} :where(.dot){stroke:none;fill:var(--hl-hi);transition:fill 260ms ${EASE}}`,
`${SVG} :where(.dot.m){fill:var(--hl-edge)}`,
`${SVG} :where(.dot.off){fill:var(--hl-lo)}`,
`${SVG} :where(.ghost path){fill:none;stroke:var(--hl-mid)}`
].join("");
}
var done = /* @__PURE__ */ new WeakSet();
function inject(root) {
if (done.has(root)) return;
done.add(root);
const doc = root.nodeType === 9 ? root : root.ownerDocument;
const win = doc.defaultView;
const text = css(!!win?.CSS?.supports?.("color", "light-dark(#000,#fff)"));
if (win && "adoptedStyleSheets" in root) {
try {
const sheet = new win.CSSStyleSheet();
sheet.replaceSync(text);
root.adoptedStyleSheets = [...root.adoptedStyleSheets, sheet];
return;
} catch {
}
}
const style = doc.createElement("style");
style.setAttribute("data-hairline-style", "");
style.textContent = text;
(root.nodeType === 9 ? doc.head ?? doc.documentElement : root).appendChild(style);
}
return __toCommonJS(kernel_exports);
})();
/* /hairline kernel */
</script>
<script id="hl-bench">
/*
* The bench: the page a figure is shown on. It makes the host and the svg the
* way the package's mount does, hands them to the figure, and owns everything
* around it: the read-out, the slider, the theme, the line under the stage.
*/
(() => {
const RULES = ["hit", "order", "reach", "accent", "rest", "honesty", "cost", "clock", "radius", "quiet"];
const $ = (id) => document.getElementById(id);
const root = document.documentElement, params = new URLSearchParams(location.search);
/* the theme: the system's until the switch is pressed, then the switch's */
const dark = () => (root.dataset.theme ? root.dataset.theme === "dark" : matchMedia("(prefers-color-scheme: dark)").matches);
const label = () => { $("theme").textContent = dark() ? "dark" : "light"; };
$("theme").addEventListener("click", () => { root.dataset.theme = dark() ? "light" : "dark"; label(); });
/* ?theme=light or ?theme=dark wins over the system's, as pressing the switch does */
if (["light", "dark"].includes(params.get("theme"))) root.dataset.theme = params.get("theme");
label();
/* ?intensity=0 sets the slider before the figure mounts, for a look at either end */
const i = (params.get("intensity") || "").trim();
if (i && Number.isFinite(Number(i))) $("intensity").value = String(Math.min(1, Math.max(0, Number(i))));
/* ?w=240 narrows the page, for a look at the size of a thumbnail */
const w = Number(params.get("w"));
if (w > 0) document.querySelector("main").style.maxWidth = w + "px";
/* a figure that fails says so under the stage, instead of leaving an empty plate */
addEventListener("error", (e) => {
$("error").hidden = false;
$("error").textContent = String((e.error && e.error.message) || e.message);
});
let mounted = false;
window.hairline = (figure) => {
if (mounted) throw new Error("hairline: one figure per page.");
mounted = true;
const stage = $("stage"), slider = $("intensity");
/* intensity to the figure's own number: two straight lines that meet at 0.5, as in the package */
const [lo, mid, hi] = figure.range;
const at = (i) => Math.round((i <= 0.5 ? lo + (i / 0.5) * (mid - lo) : mid + ((i - 0.5) / 0.5) * (hi - mid)) * 1000) / 1000;
HL.inject(document);
stage.setAttribute("data-hairline", figure.name);
stage.setAttribute("role", "img");
stage.setAttribute("aria-label", figure.means);
const svg = HL.mk("svg", { viewBox: "0 0 400 320", "aria-hidden": "true" }, stage);
let text = null;
const read = {
get textContent() { return text; },
set textContent(value) { text = value == null ? "" : String(value); $("read").textContent = text; },
};
document.title = "Hairline · " + figure.name;
$("name").textContent = figure.name;
$("means").textContent = figure.means;
$("rules").textContent = figure.rules.map((n) => String(n).padStart(2, "0") + " " + RULES[n - 1]).join(" · ");
const show = () => { $("value").textContent = String(at(Number(slider.value))); };
show();
const handle = figure.mount({ stage, svg, read }, at(Number(slider.value)));
if (text === null) read.textContent = "rest";
slider.addEventListener("input", () => { show(); handle.set(at(Number(slider.value))); });
window.hairline.figure = handle;
/* play: an unseen pointer walks the figure's tour (or HL.LAP) until a hand arrives; ?play=1 starts it on load */
const play = $("play");
window.hairline.playing = null;
play.addEventListener("click", () => {
const was = play.getAttribute("aria-pressed") === "true";
if (was) { window.hairline.playing.stop(); window.hairline.playing = null; }
else window.hairline.playing = HL.tour(stage, figure.tour || HL.LAP, (i) => { if (window.hairline.onStop) window.hairline.onStop(i); });
play.setAttribute("aria-pressed", String(!was));
});
if (params.get("play") === "1") play.click();
/* ?at=200,160 holds the pointer at a viewBox point, for a picture of the answer without a mouse */
const p = (params.get("at") || "").split(",").map(Number);
if (p.length === 2 && p.every(Number.isFinite)) {
const r = stage.getBoundingClientRect();
stage.dispatchEvent(new PointerEvent("pointermove", {
pointerType: "mouse", pointerId: 1, bubbles: true,
clientX: r.left + (p[0] / 400) * r.width, clientY: r.top + (p[1] / 320) * r.height,
}));
}
};
})();
</script>
<script type="module" id="hl-figure">
/**
* Firecrawl, reader: a browser page stands on the ground, and the flame floats
* in front of it, a reading head over its read-line. The pointer's height over
* the page sets how far down it reads. Each part it passes peels off the face
* like tape, twists flat and settles in order on a sheet that feeds out at the
* page's foot, growing as it fills: the page, read into markdown. The heading
* lands as a thick bar, list items behind a dash, the picture as a strip behind
* a square. Where a part was, a dashed ghost stays. Going back up puts them back.
* At rest the head has read the heading. The slider is how long a part flies, in ms.
*/
const {
Cam, clamp, facing, fit, open, poly, prism, proj, rad, rings, rrect, seg, solid, put,
spring, stepS, tween, tset, tval, tdone, disposer, mk, pointer, register,
} = HL;
const PW = 96, PH = 130, D = 3, T0 = 16, T1 = 126, REST = 30, FS = 2.2, UF = PW - 22, XF = 8;
const DX0 = 18, YL = 20, YR = -40, DT = 2, K = 0.5, N = 10, LAG = 0.55;
/** What the page holds, top to bottom: [kind, u0, u1, t]; kind 0 heading, 1 text, 2 picture, 3 list item. */
const ITEMS = [[0, 8, 62, 24], [1, 8, 88, 35], [1, 8, 84, 42], [1, 8, 58, 49], [2, 8, 52, 69],
[3, 16, 70, 91], [3, 16, 80, 98], [3, 16, 60, 105], [1, 8, 86, 115], [1, 8, 64, 122]];
/** Each kind: half width on the page, half width on the sheet, where on the sheet it starts, its length there (0: as on the page). */
const KIND = [[1.8, 2.1, 14, 0], [0, 0, 14, 0], [12, 1.6, 9, 16], [0, 0, 10, 0]];
/** The flame of the mark, read from its own path (a 20 square, y down), cubics sampled finely. */
const F = (() => {
const d = "M13.7605 6.61389C13.138 6.79867 12.6687 7.21667 12.3251 7.67073C12.2513 7.76819 12.0975 7.69495 12.1268 7.57552C12.7848 4.86978 11.9155 2.6209 9.20582 1.51393C9.06836 1.4576 8.92527 1.58097 8.96132 1.72519C10.1939 6.67417 5.00941 6.25673 5.66459 11.8671C5.67585 11.9634 5.56769 12.0293 5.48882 11.973C5.2432 11.7967 4.96885 11.4288 4.78069 11.1702C4.72548 11.0942 4.60605 11.1156 4.5807 11.2063C4.43085 11.7482 4.35986 12.2586 4.35986 12.7656C4.35986 14.7373 5.37333 16.473 6.90734 17.4791C6.99522 17.5366 7.10789 17.4543 7.07804 17.3535C6.99917 17.0887 6.95466 16.8093 6.95128 16.5203C6.95128 16.3429 6.96255 16.1615 6.99015 15.9925C7.05438 15.5677 7.20197 15.1632 7.44985 14.7948C8.29995 13.5188 10.0041 12.2862 9.73199 10.6125C9.71453 10.5066 9.83959 10.4368 9.91846 10.5094C11.119 11.6063 11.3567 13.0817 11.1595 14.405C11.1426 14.5199 11.2868 14.5813 11.3595 14.4912C11.5432 14.2613 11.7674 14.0596 12.0113 13.9081C12.0722 13.8703 12.1533 13.8991 12.1764 13.9667C12.3121 14.3616 12.5138 14.7323 12.7042 15.1029C12.9318 15.5485 13.0529 16.0573 13.0338 16.5958C13.0242 16.8578 12.9808 17.1113 12.9082 17.3524C12.8772 17.4543 12.9887 17.5394 13.0783 17.4808C14.6134 16.4747 15.6275 14.739 15.6275 12.7662C15.6275 12.0806 15.5075 11.4085 15.2804 10.7787C14.8044 9.45766 13.5966 8.46561 13.9019 6.74403C13.9166 6.66178 13.8405 6.59023 13.7605 6.61389Z";
const tok = d.match(/[A-Za-z]|-?[\d.]+/g), out = [], num = () => parseFloat(tok[i++]);
let i = 0, cmd = "", x = 0, y = 0;
while (i < tok.length && tok[i] !== "Z") {
if (/[A-Za-z]/.test(tok[i])) cmd = tok[i++];
if (cmd === "C") {
const [x1, y1, x2, y2, x3, y3] = Array.from({ length: 6 }, num), b = (a, b, c, e, t) => (1 - t) ** 3 * a + 3 * (1 - t) ** 2 * t * b + 3 * (1 - t) * t * t * c + t ** 3 * e;
for (let k = 1; k <= 12; k++) out.push([b(x, x1, x2, x3, k / 12), b(y, y1, y2, y3, k / 12)]);
[x, y] = [x3, y3];
} else { x = num(); y = num(); out.push([x, y]); }
}
// in its own plane: a across to the right, b down, its foot at b = 8
return out.slice(0, -1).map(([px, py]) => [(px - 10) * FS, (py - 9.5) * FS]);
})();
/**
* A thin slab from two outlines of the same points on screen, its front and its back: the back's outline,
* the walls that face you (those whose outward edge points the way the back is shifted), their turning edges, the front.
*/
function slab(front, back) {
const n = front.length, o = [back[0][0] - front[0][0], back[0][1] - front[0][1]];
const area = front.reduce((a, p, i) => { const q = front[(i + 1) % n]; return a + p[0] * q[1] - q[0] * p[1]; }, 0);
const vis = front.map((p, i) => { const q = front[(i + 1) % n], ex = q[0] - p[0], ey = q[1] - p[1]; return (area > 0 ? ey * o[0] - ex * o[1] : ex * o[1] - ey * o[0]) > 0; });
let walls = "", turns = "";
front.forEach((p, i) => {
const j = (i + 1) % n;
if (vis[i]) walls += poly([p, front[j], back[j], back[i]]);
if (vis[i] !== vis[(i + n - 1) % n]) turns += seg(p, back[i]);
});
return [poly(back), walls, turns, poly(front)];
}
function mount({ stage, svg, read }, value) {
const bag = disposer();
let fly = value;
const C = Cam(45, 0.5, 1.6);
fit(C, [[0, PW / 2, 0], [0, -PW / 2, 0], [-D, PW / 2, PH], [XF, PW / 2 - UF, PH + 24], [100, YL, 0], [100, YR, 0], [DX0, YR, 0]], 200, 162);
const P = proj(C), front = facing(C);
/** A point on the page's face, or a plane x in front of or behind it, from the page's own (u right, t down). */
const W = (u, t, x = 0) => P(x, PW / 2 - u, PH - t);
const ring = (q, x = 0) => q.map((p) => W(p.u, p.v, x));
const g = mk("g", {}, svg);
/** Draws a slab's four strings into four paths under parent; returns them so a moving one can be redrawn. */
const draw = (parent, s, cls = "sil") => {
const els = [mk("path", { class: "sil" }, parent), mk("path", { class: "fo" }, parent), mk("path", { class: "sil nf" }, parent), mk("path", { class: cls }, parent)];
if (s) els.forEach((el, i) => el.setAttribute("d", s[i]));
return els;
};
// the page: a thin standing sheet, its top bar (three dots, the address pill), and the picture's drawing
const edge = rrect(0, 0, PW, PH, 2, 3);
draw(g, slab(ring(edge), ring(edge, -D)));
const dot = (u, t, r) => poly(Array.from({ length: 12 }, (_, k) => W(u + r * Math.cos(rad(k * 30)), t + r * Math.sin(rad(k * 30)))));
mk("path", { class: "nf lo", d: [7, 12, 17].map((u) => dot(u, 7, 1.3)).join("") + poly(ring(rrect(24, 4.5, 88, 9.5, 2.5))) + seg(W(0, 14), W(PW, 14)) }, g);
const art = mk("path", { class: "nf lo", d: open([[11, 78], [21, 67], [27, 72], [36, 62], [49, 78]].map(([u, t]) => W(u, t))) + dot(18, 63, 2.4) }, g);
// where each part was: a dashed ghost on the face, under the part itself
const ghosts = mk("path", { class: "nf lo dash" }, g);
// the read-line across the face, a tick standing at each edge
const line = mk("path", { class: "sil" }, g);
// the sheet at the page's foot, which feeds out as parts land on it
const sheet = solid(g), rowX = ITEMS.map((_, k) => DX0 + 8 + k * 7 + (k ? 3 : 0)), grow = spring(rowX[0] + 7, { k: 40, c: 13 });
let sheetAt = NaN;
// each part: on the page it lies on the face; peeling, its far end leads, twisting flat; landed it lies on the sheet
const strips = mk("g", {}, g);
const items = ITEMS.map(([kind, u0, u1, t], k) => {
const [r0, r1, y0, l1] = KIND[kind];
return { kind, u0, u1, t, r0, r1, x1: rowX[k], y1: YL - y0, len: l1 || (u1 - u0) * K,
el: mk("path", { class: kind === 0 ? "sil" : kind === 2 ? "nf lo" : "lo" }, strips), tw: tween(k === 0 ? 1 : 0, fly), drawn: NaN, read: k === 0 };
});
ghosts.setAttribute("d", items.map((it) => it.r0
? poly([[it.u0, it.t - it.r0], [it.u1, it.t - it.r0], [it.u1, it.t + it.r0], [it.u0, it.t + it.r0]].map(([u, t]) => W(u, t, 0.2)))
: seg(W(it.u0, it.t, 0.2), W(it.u1, it.t, 0.2))).join(""));
/** A point of a part at s along it (0 its near end, 1 its far end), q of the way from the page to the sheet, lifted on the way. */
function at3(it, s, q, dp = 0, ds = 0) {
const p = [0.3, PW / 2 - it.u0 - (it.u1 - it.u0) * s + dp, PH - it.t], w = [it.x1, it.y1 - it.len * s + ds, DT + 0.2];
return p.map((v, i) => v + (w[i] - v) * q + (i === 2 ? 14 * Math.sin(Math.PI * q) : 0));
}
/** Across the part at q: upright on the page, lying on the sheet. */
const across = (q, r) => [r * Math.sin((Math.PI / 2) * q), 0, r * Math.cos((Math.PI / 2) * q)];
const off = (c, h, m = 1) => P(...c.map((v, i) => v + h[i] * m));
function paintItem(it, e) {
if (it.drawn === e) return;
it.drawn = e;
const side = [], back = [];
for (let i = 0; i <= N; i++) {
const s = i / N, q = clamp(e * (1 + LAG) - LAG * (1 - s), 0, 1), c = at3(it, s, q);
const h = across(q, it.r0 + (it.r1 - it.r0) * q + 1.3 * Math.sin(Math.PI * q));
side.push(off(c, h)); back.unshift(off(c, h, -1));
}
let d = poly([...side, ...back]);
const q = clamp(e * (1 + LAG) - LAG, 0, 1);
if (it.kind === 3 || (it.kind === 2 && q > 0)) {
// its mark before it: a list item's bullet that becomes a dash; the picture's square, only once it leaves
const c = at3(it, 0, q, 4, 4.5), h = across(q, 1);
const [ml, mw] = it.kind === 3 ? [0.9 + 0.7 * q, 0.9 - 0.3 * q] : [2.2 * q, 2.2 * q];
d += poly([[1, 1], [-1, 1], [-1, -1], [1, -1]].map(([a, b]) => P(c[0] + h[0] * mw * b, c[1] - ml * a, c[2] + h[2] * mw * b)));
}
it.el.setAttribute("d", d);
}
// the head: the read-line at t down the page, the flame floating in front over its right end
const flame = draw(g, null, "sil hi");
const pos = spring(REST, { k: 30, c: 11 });
let hover = false, drawnT = NaN, count = -1;
function paintHead(t) {
if (t === drawnT) return;
drawnT = t;
line.setAttribute("d", seg(W(-3, t, 0.4), W(PW + 3, t, 0.4)) + seg(W(-3, t - 3, 0.4), W(-3, t + 3, 0.4)) + seg(W(PW + 3, t - 3, 0.4), W(PW + 3, t + 3, 0.4)));
const z = PH - t + 4 + 8 * FS, y = PW / 2 - UF, r = Math.SQRT1_2;
const pts = (n) => F.map(([a, b]) => P(XF + (a + n) * r, y - (a - n) * r, z - b));
slab(pts(1.5), pts(-1.5)).forEach((d, i) => flame[i].setAttribute("d", d));
}
const B = register(stage, (dt, now) => {
let moving = stepS(pos, dt);
paintHead(pos.x);
let n = 0;
items.forEach((it) => {
const r = pos.x >= it.t - 2;
if (r !== it.read) { it.read = r; it.tw.dur = fly; tset(it.tw, r ? 1 : 0, now, 0); }
if (it.read) n++;
paintItem(it, tval(it.tw, now));
if (!tdone(it.tw, now)) moving = true;
});
art.classList.toggle("dash", items[4].read);
grow.t = rowX[Math.max(0, n - 1)] + 7;
if (stepS(grow, dt)) moving = true;
if (grow.x !== sheetAt) { sheetAt = grow.x; put(sheet, prism(P, front, ...rings(DX0, YR, sheetAt, YL, 4, 2), 0, DT)); }
if (n !== count) { count = n; read.textContent = hover ? `${n} lines` : "rest"; }
return moving;
});
bag.add(B.unregister);
/** The pointer, put on the page's plane (x 0), which never moves: its height there is how far down to read. */
const zf = Math.sqrt(1 - C.k * C.k), cs = Math.cos(C.az), sn = Math.sin(C.az);
function aim(p) {
hover = p !== null;
if (hover) { const y = -(p[0] - C.ox) / (C.S * sn), z = (y * cs * C.k - (p[1] - C.oy) / C.S) / zf; pos.t = clamp(PH - z, T0, T1); }
else pos.t = REST;
flame[3].classList.toggle("hi", !hover);
line.classList.toggle("hi", hover);
count = -1;
B.wake();
}
bag.add(pointer(stage, { move: (p) => aim(p), leave: () => aim(null) }));
bag.add(() => svg.replaceChildren());
return {
set: (v) => { fly = v; },
destroy: bag.dispose,
};
}
hairline({
name: "firecrawl-reader",
means: "The flame reads a page: point down the page, and every part it passes peels off and settles, in order, on a sheet of markdown.",
rules: [1, 5, 8, 10],
range: [400, 700, 1000],
tour: [[200, 110], [200, 170], [200, 230], null],
mount,
});
</script>
</body>
</html>
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack." | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |