lazycodex-ai 5.1.48 → 5.1.54

package/packages/shared-skills/skills/frontend/scripts/detect/rules/decoration/support/borders.ts

@@ -0,0 +1,150 @@
+import { ancestors, parentOf, shortSnippet, styleOf } from "../../../core/page"
+import { parseColor } from "../../../core/color"
+import { parseShadow } from "../../../core/shadow"
+import type { ElementSnapshot, PageSnapshot } from "../../../types"
+import type { PageHit } from "../../../rule"
+import { borderAccent, borderSafe, chroma, context, length, radii, roundedAway, selected, sides, visible } from "./appearance"
+
+export function borderHits(s: PageSnapshot, e: ElementSnapshot, rule: string): PageHit[] {
+	if (
+		!visible(s, e) ||
+		borderSafe.has(e.tag) ||
+		e.rect.width < 20 ||
+		e.rect.height < 20 ||
+		context(
+			s,
+			e,
+			(a) =>
+				["status", "alert", "alertdialog", "log"].includes(a.attributes["role"] ?? "") ||
+				["polite", "assertive"].includes(a.attributes["aria-live"] ?? ""),
+		)
+	)
+		return []
+	const rs = radii(e),
+		min = Math.min(e.rect.width, e.rect.height)
+	if (Math.max(e.rect.width, e.rect.height) <= min * 1.1 && rs.every((r) => r >= min / 2 - 0.5)) return []
+	const widths = sides.map((side) => length(styleOf(e, "border-" + side + "-width")))
+	return sides.flatMap((side, i) => {
+		const w = widths[i] ?? 0,
+			other = Math.max(...widths.filter((_, j) => i !== j))
+		if (w < 2 || !(other <= 1 || w >= other * 2) || !borderAccent(styleOf(e, "border-" + side + "-color"))) return []
+		const lateral = i === 1 || i === 3
+		const id = lateral ? "side-tab" : (rs[0] ?? 0) > 0 ? "border-accent-on-rounded" : "side-tab"
+		if (
+			id !== rule ||
+			(lateral && !roundedAway(e, i)) ||
+			(!lateral && (rs[0] ?? 0) === 0 && (w < 3 || w > 12 || !roundedAway(e, i) || context(s, e, selected)))
+		)
+			return []
+		return [{ element: e, message: "Accent border on the " + side + " edge (" + w + "px)", snippet: shortSnippet(e) }]
+	})
+}
+
+export function stripeHit(s: PageSnapshot, e: ElementSnapshot): PageHit[] {
+	if (!visible(s, e) || e.rect.width <= 40 || e.rect.height < 16) return []
+	const hosts = [e, ...ancestors(s, e)]
+	if (hosts.some((a) => ["nav", "blockquote", "pre"].includes(a.tag))) return []
+	const rowNode = (a: ElementSnapshot): boolean =>
+		["tr", "td", "th"].includes(a.tag) ||
+		["row", "cell", "gridcell", "rowheader"].includes(a.attributes["role"] ?? "") ||
+		/(?:^|[\s_-])(?:row|cell)(?:$|[\s_-])/.test(a.attributes["class"] ?? "")
+	const row = rowNode(e) && !(!["tr", "td", "th"].includes(e.tag) && !e.attributes["role"] && radii(e).some((r) => r > 0))
+	const rowHosts = row ? hosts.filter(rowNode) : [e]
+	if (rowHosts.some(selected) || (!row && (borderSafe.has(e.tag) || context(s, e, selected)))) return []
+	const status = rowHosts.some(
+		(a) =>
+			a.attributes["data-state"] !== undefined ||
+			a.attributes["data-status"] !== undefined ||
+			a.attributes["aria-invalid"] === "true" ||
+			/(?:is-|has-|--)[a-z]/.test(a.attributes["class"] ?? ""),
+	)
+	const bg = parseColor(styleOf(e, "background-color"))
+	const bare = (bg === null || bg.a < 0.1) && ["none", ""].includes(styleOf(e, "background-image"))
+	const shadows = parseShadow(styleOf(e, "box-shadow"))
+	const inset = shadows.length === 1 ? shadows[0] : undefined
+	if (
+		inset?.inset &&
+		inset.blur === 0 &&
+		inset.spread === 0 &&
+		chroma("rgb(" + inset.color.r + " " + inset.color.g + " " + inset.color.b + " / " + inset.color.a + ")")
+	) {
+		const axis = inset.x !== 0 && inset.y === 0 ? (inset.x > 0 ? 3 : 1) : inset.y !== 0 && inset.x === 0 ? (inset.y > 0 ? 0 : 2) : -1
+		const w = Math.max(Math.abs(inset.x), Math.abs(inset.y))
+		if (axis >= 0 && (row ? (axis === 1 || axis === 3) && w >= 2 && w <= 6 && (status || bare) : w >= 3 && w <= 12 && roundedAway(e, axis)))
+			return [{ element: e, message: "Inset accent stripe (" + w + "px)", snippet: shortSnippet(e) }]
+	}
+	if (row && (status || bare)) {
+		const drawn = sides.map(
+			(side) =>
+				length(styleOf(e, "border-" + side + "-width")) > 0 && !["none", "hidden", ""].includes(styleOf(e, "border-" + side + "-style")),
+		)
+		for (const i of [3, 1]) {
+			const side = sides[i] ?? "left",
+				w = length(styleOf(e, "border-" + side + "-width"))
+			if (drawn[0] && drawn[2]) continue
+			if (drawn[i] && w >= 2 && w <= 6 && chroma(styleOf(e, "border-" + side + "-color")) && (status || drawn.filter(Boolean).length === 1))
+				return [{ element: e, message: "Row accent border (" + w + "px)", snippet: shortSnippet(e) }]
+		}
+	}
+	if (!row && !borderSafe.has(e.tag)) {
+		const stripes = [e.before, e.after].flatMap((p) =>
+			p ? [{ style: p.style, width: length(p.style["width"] ?? ""), height: length(p.style["height"] ?? "") }] : [],
+		)
+		for (const p of stripes) {
+			if (
+				!["absolute", "fixed"].includes(p.style["position"] ?? "") ||
+				!chroma(p.style["background-color"] ?? "") ||
+				p.style["display"] === "none" ||
+				Number(p.style["opacity"] ?? 1) <= 0.01
+			)
+				continue
+			const hugs = (side: string): boolean => Math.abs(length(p.style[side] ?? "")) <= 2
+			const axis =
+				p.width >= 2 && p.width <= 12 && p.height >= Math.max(e.rect.height - 44, e.rect.height / 2)
+					? hugs("left")
+						? 3
+						: hugs("right")
+							? 1
+							: -1
+					: p.height >= 3 && p.height <= 12 && p.width >= Math.max(e.rect.width - 44, e.rect.width / 2)
+						? hugs("top")
+							? 0
+							: hugs("bottom")
+								? 2
+								: -1
+						: -1
+			if (axis >= 0 && roundedAway(e, axis)) return [{ element: e, message: "Positioned accent stripe", snippet: shortSnippet(e) }]
+		}
+	}
+	return []
+}
+
+export function childStripeHit(s: PageSnapshot, e: ElementSnapshot): PageHit[] {
+	if (!["div", "span"].includes(e.tag) || e.children.length > 0 || e.text.trim() !== "" || !visible(s, e)) return []
+	const p = parentOf(s, e)
+	if (!p || ["body", "html", "h1", "h2", "h3", "h4", "h5", "h6"].includes(p.tag) || p.rect.width < 40 || p.rect.height < 20) return []
+	if (
+		context(
+			s,
+			e,
+			(a) =>
+				["nav", "blockquote", "pre", "table", "button", "a", "select", "progress", "meter"].includes(a.tag) ||
+				["progressbar", "slider", "scrollbar", "separator", "tablist", "status", "alert"].includes(a.attributes["role"] ?? "") ||
+				selected(a),
+		)
+	)
+		return []
+	const { width: w, height: h, x } = e.rect,
+		host = p.rect
+	const side = Math.abs(x - host.x) <= 3 ? 3 : Math.abs(host.x + host.width - x - w) <= 3 ? 1 : -1
+	if (
+		side < 0 ||
+		w < 2 ||
+		w > 12 ||
+		h < Math.max(host.height - 44, host.height * 0.5) ||
+		!roundedAway(p, side) ||
+		!chroma(styleOf(e, "background-color"))
+	)
+		return []
+	return [{ element: e, message: w + "px accent stripe child", snippet: shortSnippet(e) }]
+}

package/packages/shared-skills/skills/frontend/scripts/detect/rules/decoration/support/clip-geometry.ts

@@ -0,0 +1,151 @@
+import { splitTop } from "./appearance"
+import { arc, cubic, lerp, type Point } from "./curve-samples"
+export function geometricPolygon(body: string): boolean {
+	const points = splitTop(body)
+		.filter((p) => !/^nonzero$|^evenodd$/.test(p))
+		.map((p) => splitTop(p, /\s/))
+	const key = (v: string): string => (/^[-+]?0(?:\.0+)?(?:%|px)?$/.test(v) ? "0" : v.replace(/\s/g, ""))
+	if (
+		points.every((p, i) => {
+			const next = points[(i + 1) % points.length]
+			return p.length === 2 && next !== undefined && (key(p[0] ?? "") === key(next[0] ?? "") || key(p[1] ?? "") === key(next[1] ?? ""))
+		})
+	)
+		return true
+	const numeric = points.map((p) => p.map((v) => (/^[-+]?[\d.]+(?:px|%)?$/.test(v) ? Number.parseFloat(v) : Number.NaN)))
+	if (numeric.some((p) => p.length !== 2 || p.some((n) => !Number.isFinite(n)))) return false
+	const xs = numeric.map((p) => p[0] ?? 0),
+		ys = numeric.map((p) => p[1] ?? 0)
+	const distinct = (vs: readonly number[]): number[] => [...new Set(vs)].sort((a, b) => a - b)
+	const teeth = (along: readonly number[], across: readonly number[]): boolean => {
+		const d = distinct(along),
+			step = (d[1] ?? 0) - (d[0] ?? 0)
+		if (d.length < 3 || step <= 0 || d.slice(1).some((v, i) => Math.abs(v - (d[i] ?? 0) - step) > 0.5)) return false
+		let last: number | null = null,
+			swings = 0
+		for (let i = 0; i < along.length; i++) {
+			const j = (i + 1) % along.length
+			if (Math.abs(Math.abs((along[j] ?? 0) - (along[i] ?? 0)) - step) > 0.5) {
+				last = null
+				continue
+			}
+			const swing = (across[j] ?? 0) - (across[i] ?? 0)
+			if (Math.abs(swing) < 0.01) continue
+			if (last !== null && (Math.sign(last) === Math.sign(swing) || Math.abs(Math.abs(last) - Math.abs(swing)) > 0.5)) return false
+			last = swing
+			swings++
+		}
+		return swings >= 3
+	}
+	return (
+		(distinct(xs).length >= 2 && distinct(xs).length <= 4 && teeth(ys, xs)) ||
+		(distinct(ys).length >= 2 && distinct(ys).length <= 4 && teeth(xs, ys))
+	)
+}
+export function roundedPath(body: string): boolean {
+	const tokens = body.replace(/^["']|["']$/g, "").match(/[A-Za-z]|[-+]?(?:[0-9]+\.?[0-9]*|\.[0-9]+)(?:[eE][-+]?[0-9]+)?/g) ?? []
+	const segments: { a: Point; b: Point; line: boolean }[] = [],
+		points: Point[] = []
+	let at: Point = [0, 0],
+		start: Point = [0, 0],
+		cmd = "",
+		i = 0
+	let lastCubic: Point | null = null,
+		lastQuad: Point | null = null
+	while (i < tokens.length) {
+		const token = tokens[i] ?? ""
+		if (/^[a-z]$/i.test(token)) {
+			cmd = token
+			i++
+			if (cmd.toLowerCase() === "z") {
+				if (at[0] !== start[0] || at[1] !== start[1]) segments.push({ a: at, b: start, line: true })
+				at = start
+				cmd = ""
+			}
+			continue
+		}
+		const upper = cmd.toUpperCase(),
+			arity =
+				upper === "H" || upper === "V"
+					? 1
+					: upper === "C"
+						? 6
+						: upper === "A"
+							? 7
+							: upper === "S" || upper === "Q"
+								? 4
+								: ["M", "L", "T"].includes(upper)
+									? 2
+									: 0
+		if (arity === 0 || i + arity > tokens.length) return false
+		const args = tokens.slice(i, i + arity).map(Number)
+		if (args.some((n) => !Number.isFinite(n))) return false
+		i += arity
+		const rel = cmd !== upper,
+			base: Point = rel ? at : [0, 0]
+		const end: Point =
+			upper === "H"
+				? [base[0] + (args[0] ?? 0), at[1]]
+				: upper === "V"
+					? [at[0], base[1] + (args[0] ?? 0)]
+					: [base[0] + (args[arity - 2] ?? 0), base[1] + (args[arity - 1] ?? 0)]
+		const point = (k: number): Point => [base[0] + (args[k] ?? 0), base[1] + (args[k + 1] ?? 0)]
+		const reflect = (p: Point | null): Point => (p ? [2 * at[0] - p[0], 2 * at[1] - p[1]] : at)
+		let nextCubic: Point | null = null,
+			nextQuad: Point | null = null
+		if (upper === "C" || upper === "S") {
+			const c1 = upper === "C" ? point(0) : reflect(lastCubic),
+				c2 = point(upper === "C" ? 2 : 0)
+			points.push(...cubic(at, c1, c2, end))
+			nextCubic = c2
+		} else if (upper === "Q" || upper === "T") {
+			const c: Point = upper === "Q" ? point(0) : reflect(lastQuad)
+			points.push(...cubic(at, lerp(at, c, 2 / 3), lerp(end, c, 2 / 3), end))
+			nextQuad = c
+		} else if (upper === "A")
+			points.push(...arc(at, args[0] ?? 0, args[1] ?? 0, args[2] ?? 0, (args[3] ?? 0) !== 0, (args[4] ?? 0) !== 0, end))
+		lastCubic = nextCubic
+		lastQuad = nextQuad
+		if (upper === "M") {
+			start = end
+			cmd = rel ? "l" : "L"
+		} else segments.push({ a: at, b: end, line: ["L", "H", "V"].includes(upper) })
+		points.push(end)
+		at = end
+	}
+	const lines = segments.filter((s) => s.line)
+	if (lines.length < 4) return false
+	const xs = points.map((p) => p[0]),
+		ys = points.map((p) => p[1]),
+		minX = Math.min(...xs),
+		maxX = Math.max(...xs),
+		minY = Math.min(...ys),
+		maxY = Math.max(...ys)
+	const tol = Math.max(1, maxX - minX, maxY - minY) * 0.01,
+		near = (a: number, b: number): boolean => Math.abs(a - b) <= tol
+	const edges = (p: Point): number[] =>
+		[near(p[1], minY) ? 0 : -1, near(p[0], maxX) ? 1 : -1, near(p[1], maxY) ? 2 : -1, near(p[0], minX) ? 3 : -1].filter((i) => i >= 0)
+	const reached = new Set<number>()
+	for (const l of lines) {
+		const edge = edges(l.a).find((i) => edges(l.b).includes(i))
+		if (edge === undefined) return false
+		reached.add(edge)
+	}
+	if (reached.size !== 4) return false
+	const first = segments.findIndex((s) => s.line)
+	const run: Point[] = []
+	for (let k = 1; k <= segments.length; k++) {
+		const segment = segments[(first + k) % segments.length]
+		if (!segment) continue
+		const a = run[0],
+			b = run[1]
+		if (segment.line) {
+			if (a && b && !edges(a).some((x) => edges(b).some((y) => x % 2 !== y % 2))) return false
+			run.length = 0
+		} else {
+			run[0] = a ?? segment.a
+			run[1] = segment.b
+		}
+	}
+	return true
+}

package/packages/shared-skills/skills/frontend/scripts/detect/rules/decoration/support/css-candidates.ts

@@ -0,0 +1,66 @@
+import { ancestors, parentOf } from "../../../core/page"
+import { cssBlocks } from "../../../core/source"
+import type { ElementSnapshot, PageSnapshot } from "../../../types"
+
+function compound(e: ElementSnapshot, selector: string): boolean {
+	const tag = /^[a-z][\w-]*|^\*/i.exec(selector)?.[0]
+	if (tag && tag !== "*" && e.tag !== tag.toLowerCase()) return false
+	let rest = selector.slice(tag?.length ?? 0)
+	for (const m of rest.matchAll(/([.#])([\w-]+)|\[([\w-]+)(?:=["']?([^"'\]]*)["']?)?\]/g)) {
+		if (m[1] === "#" && e.attributes["id"] !== m[2]) return false
+		if (m[1] === "." && !(e.attributes["class"] ?? "").split(/\s+/).includes(m[2] ?? "")) return false
+		if (m[3] && (e.attributes[m[3]] === undefined || (m[4] !== undefined && e.attributes[m[3]] !== m[4]))) return false
+	}
+	rest = rest.replace(/([.#])[\w-]+|\[[^\]]+\]/g, "")
+	return rest === ""
+}
+
+export function matchesSelector(s: PageSnapshot, e: ElementSnapshot, selector: string): boolean {
+	const pieces = selector.trim().replace(/\s*>\s*/g, " > ").split(/\s+/)
+	const last = pieces.pop()
+	if (!last || !compound(e, last)) return false
+	let current = e
+	while (pieces.length > 0) {
+		const part = pieces.pop()
+		if (part === ">") {
+			const parent = parentOf(s, current)
+			const wanted = pieces.pop()
+			if (!parent || !wanted || !compound(parent, wanted)) return false
+			current = parent
+		} else {
+			const match = [...ancestors(s, current)].find(a => compound(a, part ?? ""))
+			if (!match) return false
+			current = match
+		}
+	}
+	return true
+}
+
+export function cssCandidates(s: PageSnapshot): ReadonlyMap<string, Readonly<Record<string, string>>> {
+	const merged = new Map<string, Record<string, string>>()
+	for (const css of s.cssText) {
+		let text = css
+		for (const match of css.matchAll(/@media[^{]*prefers-reduced-motion\s*:\s*reduce\s*\)[^{]*\{/g)) {
+			let end = (match.index ?? 0) + match[0].length
+			let depth = 1
+			const start = match.index ?? 0
+			while (end < css.length && depth > 0) {
+				if (css[end] === "{") depth++
+				if (css[end] === "}") depth--
+				end++
+			}
+			text = text.replace(css.slice(start, end), "")
+		}
+		for (const block of cssBlocks(text)) {
+			for (const selector of block.selector.split(",").map(v => v.trim()).filter(v => v !== "" && !v.startsWith("@"))) {
+				const declarations = merged.get(selector) ?? {}
+				for (const entry of block.body.split(";")) {
+					const colon = entry.indexOf(":")
+					if (colon >= 0) declarations[entry.slice(0, colon).trim().toLowerCase()] = entry.slice(colon + 1).trim()
+				}
+				merged.set(selector, declarations)
+			}
+		}
+	}
+	return merged
+}

package/packages/shared-skills/skills/frontend/scripts/detect/rules/decoration/support/curve-samples.ts

@@ -0,0 +1,55 @@
+export type Point = readonly [number, number]
+export const lerp = (a: Point, b: Point, t: number): Point => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t]
+export function cubic(p0: Point, p1: Point, p2: Point, p3: Point): readonly Point[] {
+	return Array.from({ length: 15 }, (_, i) => {
+		const t = (i + 1) / 16,
+			u = 1 - t,
+			a = u * u * u,
+			b = 3 * u * u * t,
+			c = 3 * u * t * t,
+			d = t * t * t
+		return [a * p0[0] + b * p1[0] + c * p2[0] + d * p3[0], a * p0[1] + b * p1[1] + c * p2[1] + d * p3[1]] satisfies Point
+	})
+}
+export function arc(
+	from: Point,
+	rxInput: number,
+	ryInput: number,
+	rotation: number,
+	large: boolean,
+	sweep: boolean,
+	to: Point,
+): readonly Point[] {
+	let rx = Math.abs(rxInput),
+		ry = Math.abs(ryInput)
+	if ((from[0] === to[0] && from[1] === to[1]) || rx === 0 || ry === 0) return []
+	const phi = (rotation * Math.PI) / 180,
+		sin = Math.sin(phi),
+		cos = Math.cos(phi),
+		dx = (from[0] - to[0]) / 2,
+		dy = (from[1] - to[1]) / 2
+	const x1 = cos * dx + sin * dy,
+		y1 = -sin * dx + cos * dy,
+		lambda = (x1 * x1) / (rx * rx) + (y1 * y1) / (ry * ry)
+	if (lambda > 1) {
+		rx *= Math.sqrt(lambda)
+		ry *= Math.sqrt(lambda)
+	}
+	const num = rx * rx * ry * ry - rx * rx * y1 * y1 - ry * ry * x1 * x1,
+		den = rx * rx * y1 * y1 + ry * ry * x1 * x1
+	const coef = (den === 0 ? 0 : Math.sqrt(Math.max(0, num / den))) * (large === sweep ? -1 : 1)
+	const cx1 = (coef * rx * y1) / ry,
+		cy1 = (-coef * ry * x1) / rx,
+		cx = cos * cx1 - sin * cy1 + (from[0] + to[0]) / 2,
+		cy = sin * cx1 + cos * cy1 + (from[1] + to[1]) / 2
+	const theta = Math.atan2((y1 - cy1) / ry, (x1 - cx1) / rx)
+	let delta = Math.atan2((-y1 - cy1) / ry, (-x1 - cx1) / rx) - theta
+	if (sweep && delta < 0) delta += Math.PI * 2
+	else if (!sweep && delta > 0) delta -= Math.PI * 2
+	return Array.from({ length: 15 }, (_, i) => {
+		const t = theta + (delta * (i + 1)) / 16,
+			ex = rx * Math.cos(t),
+			ey = ry * Math.sin(t)
+		return [cos * ex - sin * ey + cx, sin * ex + cos * ey + cy] satisfies Point
+	})
+}

package/packages/shared-skills/skills/frontend/scripts/detect/rules/decoration/support/gradient-pattern.ts

@@ -0,0 +1,40 @@
+import { parseColor } from "../../../core/color"
+import { splitTop } from "./appearance"
+const position = (value: string): number | null => {
+	const token = value
+		.replace(/\s/g, "")
+		.replace(/^(?:calc\()+/, "")
+		.replace(/\)+$/, "")
+	const match = /^([-+]?[\d.]+)(%|deg|grad|turn|px)?$/.exec(token)
+	if (!match) return null
+	const n = Number(match[1])
+	if (n === 0) return 0
+	return match[2] === "%" ? n / 100 : match[2] === "deg" ? n / 360 : match[2] === "grad" ? n / 400 : match[2] === "turn" ? n : null
+}
+export function repeats(value: string): boolean {
+	for (const layer of splitTop(value)) {
+		const m = /^repeating-(linear|radial)-gradient\(([\s\S]*)\)$/i.exec(layer)
+		if (!m) continue
+		const stops = splitTop(m[2] ?? ""),
+			first = splitTop(stops[0] ?? "", /\s/),
+			token = first[0] ?? ""
+		if (token.includes("var(")) return true
+		const start =
+			parseColor(token) !== null ||
+			(/^(?:transparent|currentcolor|[a-z]+)$/i.test(token) && !/^(?:circle|ellipse|to|at|in|closest|farthest)/i.test(token))
+				? 0
+				: 1
+		if (stops.length < start + 2) return true
+		if (m[1]?.toLowerCase() === "radial" && start === 1) {
+			const prelude = (stops[0] ?? "").split(/\bat\b|\bin\b/)[0] ?? ""
+			if (/closest-|farthest-side|[0-9]/.test(prelude)) return true
+		}
+		const a = splitTop(stops[start] ?? "", /\s/),
+			b = splitTop(stops.at(-1) ?? "", /\s/)
+		if (b.length === 1 && b[0]?.includes("var(")) return true
+		const zero = a[1] === undefined || position(a[1]) === 0,
+			full = b.length === 1 || position(b.at(-1) ?? "") === 1
+		if (!(zero && full)) return true
+	}
+	return false
+}

package/packages/shared-skills/skills/frontend/scripts/detect/rules/decoration/support/keyframes.ts

@@ -0,0 +1,134 @@
+import type { ComputedStyle, PageSnapshot } from "../../../types"
+import { splitTop } from "./appearance"
+export type Frame = Readonly<Record<string, string>>
+export type KeyframeStep = { readonly key: string; readonly declarations: Frame }
+export function keyframeSteps(s: PageSnapshot, name: string): readonly KeyframeStep[] | null {
+	const frames: KeyframeStep[] = []
+	let found = false
+	for (const css of s.cssText) {
+		const text = css.replace(/\/\*[\s\S]*?\*\//g, "")
+		for (const m of text.matchAll(/@(?:-webkit-)?keyframes\s+([\w-]+)\s*\{/g)) {
+			if (m[1] !== name) continue
+			found = true
+			let end = (m.index ?? 0) + m[0].length,
+				depth = 1
+			const start = end
+			while (end < text.length && depth > 0) {
+				if (text[end] === "{") depth++
+				if (text[end] === "}") depth--
+				end++
+			}
+			for (const step of text.slice(start, end - 1).matchAll(/([^{}]+)\{([^{}]*)\}/g)) {
+				const entries = (step[2] ?? "").split(";").flatMap((d) => {
+					const i = d.indexOf(":")
+					return i < 0 ? [] : [[d.slice(0, i).trim().toLowerCase(), d.slice(i + 1).trim()]]
+				})
+				frames.push({ key: (step[1] ?? "").trim(), declarations: Object.fromEntries(entries) })
+			}
+		}
+	}
+	return found ? frames : null
+}
+export function keyframes(s: PageSnapshot, name: string): readonly Frame[] | null {
+	return keyframeSteps(s, name)?.map(step => step.declarations) ?? null
+}
+export function infiniteNames(style: ComputedStyle): readonly string[] {
+	const iterations = splitTop(style["animation-iteration-count"] ?? "")
+	return splitTop(style["animation-name"] ?? "").filter((n, i) => n !== "none" && iterations[i % iterations.length] === "infinite")
+}
+export function onlyUnitPulse(frames: readonly Frame[]): boolean {
+	return (
+		frames.length > 0 &&
+		frames.every((f) =>
+			Object.entries(f).every(([p, v]) => {
+				if (p === "opacity") return true
+				if (p === "animation-timing-function") return !/linear\(|var\(/.test(v) && !overshoot(v)
+				if (p !== "scale" && p !== "transform") return false
+				if (v === "none") return true
+				const rest = p === "scale" ? v : v.replace(/scale(?:[XYZ]|3d)?\(([^)]*)\)/gi, "$1")
+				return (
+					/^[\s,0-9.+-]+$/.test(rest) &&
+					rest
+						.split(/[\s,]+/)
+						.filter(Boolean)
+						.every((n) => Number(n) >= 0 && Number(n) <= 1)
+				)
+			}),
+		)
+	)
+}
+export const overshoot = (v: string): boolean =>
+	[...v.matchAll(/cubic-bezier\(\s*([\d.+-]+)\s*,\s*([\d.+-]+)\s*,\s*([\d.+-]+)\s*,\s*([\d.+-]+)\s*\)/g)].some((m) =>
+		[Number(m[2]), Number(m[4])].some((y) => y < -0.1 || y > 1.1),
+	)
+const scalar = (v: string): number | null => (/^[-+]?(?:\d*\.)?\d+(?:px)?$/.test(v) ? Number.parseFloat(v) : null)
+const differs = (a: string | undefined, b: string | undefined): boolean => {
+	if (a === undefined || b === undefined) return false
+	const x = scalar(a),
+		y = scalar(b)
+	return x !== null && y !== null ? Math.abs(x - y) >= 4 : a.replace(/\s/g, "") !== b.replace(/\s/g, "")
+}
+function translation(f: Frame): readonly string[] | null {
+	const t = f["transform"]
+	if (t === undefined && f["translate"] === undefined) return null
+	if (t?.includes("matrix")) return []
+	const axes = ["0", "0", "0"]
+	for (const m of (t ?? "").matchAll(/translate([XYZ]|3d)?\(([^)]*)\)/gi)) {
+		const suffix = m[1]?.toLowerCase(),
+			args = (m[2] ?? "").split(/,\s*/).map((x) => x.trim())
+		if (suffix === "x" || suffix === "y" || suffix === "z") axes[suffix === "x" ? 0 : suffix === "y" ? 1 : 2] = args[0] ?? "0"
+		else
+			args.forEach((v, i) => {
+				axes[i] = v
+			})
+	}
+	if (f["translate"])
+		f["translate"].split(/\s+/).forEach((v, i) => {
+			axes[i] = v
+		})
+	return axes
+}
+export function dotPulse(frames: readonly Frame[]): boolean {
+	const declarations = frames.flatMap((f) => Object.entries(f))
+	const scales = declarations
+		.filter(([p]) => p === "transform")
+		.flatMap(([, v]) => [...v.matchAll(/scale([XY]|3d)?\(/gi)].map((m) => m[1] ?? "both"))
+	const oneAxis =
+		scales.length > 0 &&
+		new Set(scales).size === 1 &&
+		["X", "Y", "x", "y"].includes(scales[0] ?? "") &&
+		!declarations.some(([p]) => p === "scale")
+	const signal = declarations.some(
+		([p, v]) => p === "opacity" || p === "box-shadow" || p === "scale" || (p === "transform" && /scale/i.test(v) && !oneAxis),
+	)
+	if (!signal) return false
+	const translations = frames.map(translation).filter((t): t is readonly string[] => t !== null)
+	for (const a of translations)
+		for (const b of translations)
+			for (let i = 0; i < 3; i++) {
+				const x = a[i] ?? "0",
+					y = b[i] ?? "0"
+				if (!x.includes("%") && !y.includes("%") && differs(x, y)) return false
+			}
+	const sizes = frames.filter((f) => f["height"] !== undefined)
+	if (sizes.some((f) => f["height"] !== sizes[0]?.["height"]) && sizes.every((f) => f["width"] === sizes[0]?.["width"])) return false
+	const pairs = [
+		["left", "right"],
+		["top", "bottom"],
+		["inset-inline-start", "inset-inline-end"],
+		["inset-block-start", "inset-block-end"],
+		["margin-left", "margin-right"],
+		["margin-top", "margin-bottom"],
+		["margin-inline-start", "margin-inline-end"],
+		["margin-block-start", "margin-block-end"],
+	]
+	for (const a of frames)
+		for (const b of frames) {
+			if (differs(a["width"], b["width"]) || differs(a["height"], b["height"])) continue
+			for (const [x = "", y = ""] of pairs) if (differs(a[x], b[x]) !== differs(a[y], b[y])) return false
+		}
+	return true
+}
+export const toggles = (frames: readonly Frame[]): boolean =>
+	frames.some((f) => Number(f["opacity"] ?? 1) <= 0.15 || f["visibility"] === "hidden") &&
+	frames.every((f) => Object.keys(f).every((p) => ["opacity", "visibility", "animation-timing-function"].includes(p)))