weasel-icons 0.17.0 → 0.18.0

package/README.md

@@ -8,6 +8,10 @@ Version `0.10.0` contains 874 icons, adding 200 across documents, collaboration,
 
 Version `0.7.0` contained 469 icons; `0.6.0` contained 265 icons.
 
+## Version 0.18.0
+
+Adds 50 icons across technology and security, climate and energy, life sciences, history, and space exploration. The collection now contains 1,136 icons. Each addition includes three typed states, optional ongoing motion, matching editable CLI source and related search terms. Existing icon artwork, public states, shared runtime and the customization skill are unchanged.
+
 ## Version 0.17.0
 
 Adds 32 icons for agent workflows, tool calls, approvals, retrieval, knowledge graphs, attention, transformer computation and token sampling. The collection now contains 1,086 icons. All new icons include three typed states, optional ongoing motion, accent colours, matching editable CLI source and related search terms. Existing icon artwork, public states, shared runtime and the customization skill are unchanged.

package/dist/icons/air-quality/air-quality-icon.d.ts

@@ -0,0 +1,5 @@
+import type { StatefulIconProps } from "../../shared/icon-types.js";
+import { type AirQualityState } from "./air-quality-rig.js";
+export { airQualityStates, type AirQualityState } from "./air-quality-rig.js";
+export type AirQualityIconProps = StatefulIconProps<AirQualityState>;
+export declare const AirQualityIcon: import("react").NamedExoticComponent<AirQualityIconProps>;

package/dist/icons/air-quality/air-quality-icon.js

@@ -0,0 +1,9 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { memo } from 'react';
+import { ArticulatedIcon } from "../../shared/articulated-icon.js";
+import { airQualityArt, airQualityStates } from "./air-quality-rig.js";
+export { airQualityStates } from "./air-quality-rig.js";
+export const AirQualityIcon = memo(function AirQualityIcon(props) {
+    return _jsx(ArticulatedIcon, { art: airQualityArt, states: airQualityStates, ...props });
+});

package/dist/icons/air-quality/air-quality-rig.d.ts

@@ -0,0 +1,37 @@
+import type { PartGesture } from "../../shared/articulation.js";
+/**
+ * Air over a city skyline, with an index column beside it. Fine particles (PM2.5) drift in as
+ * pollution builds: one in good air, three at moderate, six when unhealthy. The index column
+ * fills in step with the particle count, so the reading and the cause are shown together.
+ */
+export declare const airQualityStates: readonly ["good", "moderate", "unhealthy"];
+export type AirQualityState = (typeof airQualityStates)[number];
+export declare const airQualityArt: {
+    name: string;
+    parts: ({
+        name: string;
+        paths: string[];
+        fillOnly: "ink";
+        pivot: readonly [8 | 4.2 | 4.4 | 13.6 | 12.8 | 9.2, 4.2 | 4.4 | 10.6 | 9.4 | 12.6 | 7.4];
+        poses: {}[];
+        gestures: (PartGesture | null)[];
+    } | {
+        name: string;
+        paths: string[];
+        poses: {}[];
+        pathOffsets?: undefined;
+        fillOnly?: undefined;
+        accent?: undefined;
+        gestures?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        pathOffsets: number[][];
+        fillOnly: "ink";
+        accent: true;
+        poses: {
+            flex: number;
+        }[];
+        gestures: (PartGesture | null)[];
+    })[];
+};

package/dist/icons/air-quality/air-quality-rig.js

@@ -0,0 +1,92 @@
+/**
+ * Air over a city skyline, with an index column beside it. Fine particles (PM2.5) drift in as
+ * pollution builds: one in good air, three at moderate, six when unhealthy. The index column
+ * fills in step with the particle count, so the reading and the cause are shown together.
+ */
+export const airQualityStates = ['good', 'moderate', 'unhealthy'];
+const circle = (cx, cy, r) => `M${cx - r} ${cy}a${r} ${r} 0 1 0 ${2 * r} 0a${r} ${r} 0 1 0 ${-2 * r} 0Z`;
+/** Particle positions, all at least ~4.4 apart; the order is the order they arrive in. */
+const particles = [
+    [9.2, 4.2],
+    [4.4, 7.4],
+    [12.8, 9.4],
+    [13.6, 4.4],
+    [8, 10.6],
+    [4.2, 12.6],
+];
+/** The state in which each particle first appears. */
+const arrives = [0, 1, 1, 2, 2, 2];
+const levelTop = [17.4, 12.4, 5.6];
+const level = (top) => `M18.4 ${top}H20.2V20.4H18.4Z`;
+const STEP = levelTop[1] - levelTop[2];
+const ease = (flex) => ({
+    duration: 1.6,
+    repeatAfter: 1.6,
+    loop: false,
+    frames: [{ at: 0, flex }, { at: 0.2, flex }, { at: 1 }],
+});
+/** Particles hang in the air and wander slowly; each has its own phase and path. */
+const drift = (i) => {
+    const dx = i % 2 ? 0.6 : -0.6;
+    const dy = i % 3 ? -0.5 : 0.5;
+    const shift = (i * 0.11) % 0.3;
+    return {
+        duration: 3.6,
+        repeatAfter: 3.6,
+        interpolation: 'continuous',
+        frames: [
+            { at: 0 },
+            { at: 0.25 + shift * 0.5, x: dx, y: dy * 0.4 },
+            { at: 0.6 + shift * 0.5, x: dx * 0.3, y: dy },
+            { at: 1 },
+        ],
+    };
+};
+/** Blown in from the left on arrival. */
+const blowIn = {
+    duration: 1.4,
+    repeatAfter: 1.4,
+    loop: false,
+    frames: [{ at: 0, x: -3, opacity: -1 }, { at: 0.2, x: -3, opacity: -1 }, { at: 1 }],
+};
+const particle = (i) => {
+    const [cx, cy] = particles[i];
+    const hidden = { scaleX: 0, scaleY: 0, opacity: 0 };
+    return {
+        name: `particle-${i + 1}`,
+        paths: [circle(cx, cy, 1.3)],
+        fillOnly: 'ink',
+        pivot: [cx, cy],
+        poses: airQualityStates.map((_, s) => (s >= arrives[i] ? {} : hidden)),
+        gestures: airQualityStates.map((_, s) => s < arrives[i] || s === 0 ? null : s === arrives[i] ? blowIn : drift(i)),
+    };
+};
+export const airQualityArt = {
+    name: 'air-quality',
+    parts: [
+        {
+            name: 'skyline',
+            paths: ['M2.6 21.2H14.6V15H11.6V17.4H9V13.6H5.8V16.6H2.6Z'],
+            poses: [{}, {}, {}],
+        },
+        {
+            // The index reading: fills with the concentration. flex = distance below full.
+            name: 'index-level',
+            paths: [level(levelTop[2])],
+            pathOffsets: [[0, 1, 0, 0, 0]],
+            fillOnly: 'ink',
+            accent: true,
+            poses: levelTop.map((top) => ({ flex: +(top - levelTop[2]).toFixed(2) })),
+            // Offsets point the same way from either neighbour, so the level never reverses.
+            gestures: [ease(-STEP), null, ease(STEP)],
+        },
+        {
+            name: 'index-column',
+            paths: [
+                'M19.3 3A1.7 1.7 0 0 1 21 4.7V19.5A1.7 1.7 0 0 1 17.6 19.5V4.7A1.7 1.7 0 0 1 19.3 3Z',
+            ],
+            poses: [{}, {}, {}],
+        },
+        ...particles.map((_, i) => particle(i)),
+    ],
+};

package/dist/icons/astrolabe/astrolabe-icon.d.ts

@@ -0,0 +1,5 @@
+import type { StatefulIconProps } from "../../shared/icon-types.js";
+import { type AstrolabeState } from "./astrolabe-rig.js";
+export { astrolabeStates, type AstrolabeState } from "./astrolabe-rig.js";
+export type AstrolabeIconProps = StatefulIconProps<AstrolabeState>;
+export declare const AstrolabeIcon: import("react").NamedExoticComponent<AstrolabeIconProps>;

package/dist/icons/astrolabe/astrolabe-icon.js

@@ -0,0 +1,9 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { memo } from 'react';
+import { ArticulatedIcon } from "../../shared/articulated-icon.js";
+import { astrolabeArt, astrolabeStates } from "./astrolabe-rig.js";
+export { astrolabeStates } from "./astrolabe-rig.js";
+export const AstrolabeIcon = memo(function AstrolabeIcon(props) {
+    return _jsx(ArticulatedIcon, { art: astrolabeArt, states: astrolabeStates, ...props });
+});

package/dist/icons/astrolabe/astrolabe-rig.d.ts

@@ -0,0 +1,140 @@
+/**
+ * A planispheric astrolabe hung from its suspension ring and throne. The rete (the pierced
+ * star map: an off-centre ecliptic ring with flame-shaped star pointers) lies over the plate;
+ * the alidade, a pointed full-diameter sighting rule, turns on the central pin. Sighting,
+ * the alidade is turned onto a star in the sky; reckoning, the rete is turned until that
+ * star's pointer lies under the alidade, which sets the sky model and reads the time.
+ */
+export declare const astrolabeStates: readonly ["hanging", "sighting", "reckoned"];
+export type AstrolabeState = (typeof astrolabeStates)[number];
+export declare const astrolabeArt: {
+    name: string;
+    parts: ({
+        name: string;
+        paths: string[];
+        poses: {}[];
+        fillOnly?: undefined;
+        detail?: undefined;
+        pivot?: undefined;
+        gestures?: undefined;
+        accent?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        fillOnly: "ink";
+        poses: {}[];
+        detail?: undefined;
+        pivot?: undefined;
+        gestures?: undefined;
+        accent?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        detail: true;
+        pivot: readonly [number, number];
+        poses: ({
+            angle?: undefined;
+        } | {
+            angle: number;
+        })[];
+        gestures: ({
+            duration: number;
+            repeatAfter: number;
+            loop: boolean;
+            frames: ({
+                at: number;
+                angle: number;
+            } | {
+                at: number;
+                angle?: undefined;
+            })[];
+        } | null)[];
+        fillOnly?: undefined;
+        accent?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        fillOnly: "ink";
+        pivot: readonly [number, number];
+        poses: ({
+            angle?: undefined;
+        } | {
+            angle: number;
+        })[];
+        gestures: ({
+            duration: number;
+            repeatAfter: number;
+            loop: boolean;
+            frames: ({
+                at: number;
+                angle: number;
+            } | {
+                at: number;
+                angle?: undefined;
+            })[];
+        } | null)[];
+        detail?: undefined;
+        accent?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        fillOnly: "ink";
+        accent: true;
+        pivot: readonly [number, number];
+        poses: ({
+            angle?: undefined;
+        } | {
+            angle: number;
+        })[];
+        gestures: ({
+            duration: number;
+            repeatAfter: number;
+            loop: boolean;
+            frames: ({
+                at: number;
+                angle: number;
+            } | {
+                at: number;
+                angle?: undefined;
+            })[];
+        } | null)[];
+        detail?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        fillOnly: "ink";
+        pivot: readonly [number, number];
+        poses: ({
+            angle?: undefined;
+        } | {
+            angle: number;
+        })[];
+        detail?: undefined;
+        gestures?: undefined;
+        accent?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        fillOnly: "surface";
+        poses: {}[];
+        detail?: undefined;
+        pivot?: undefined;
+        gestures?: undefined;
+        accent?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        fillOnly: "ink";
+        accent: true;
+        pivot: [number, number];
+        poses: ({
+            scaleX: number;
+            scaleY: number;
+        } | {
+            scaleX?: undefined;
+            scaleY?: undefined;
+        })[];
+        detail?: undefined;
+        gestures?: undefined;
+    })[];
+};

package/dist/icons/astrolabe/astrolabe-rig.js

@@ -0,0 +1,117 @@
+/**
+ * A planispheric astrolabe hung from its suspension ring and throne. The rete (the pierced
+ * star map: an off-centre ecliptic ring with flame-shaped star pointers) lies over the plate;
+ * the alidade, a pointed full-diameter sighting rule, turns on the central pin. Sighting,
+ * the alidade is turned onto a star in the sky; reckoning, the rete is turned until that
+ * star's pointer lies under the alidade, which sets the sky model and reads the time.
+ */
+export const astrolabeStates = ['hanging', 'sighting', 'reckoned'];
+const C = [12, 14];
+const R = 7.2;
+const SIGHT = 38; // the star at (19.4, 3.9) lies on this bearing from the pin
+const STAR_AT = -60; // the sighted star's pointer, before the rete is turned
+const TURN = SIGHT - STAR_AT;
+const ECL_DIR = 0; // direction of the ecliptic ring's centre from the pin
+const ECL_D = 1.4;
+const ECL_R = 3.3;
+const n = (v) => +v.toFixed(2);
+const polar = (deg, r) => {
+    const a = (deg * Math.PI) / 180;
+    return `${n(C[0] + r * Math.sin(a))} ${n(C[1] - r * Math.cos(a))}`;
+};
+const circle = (cx, cy, r) => `M${n(cx - r)} ${n(cy)}A${r} ${r} 0 1 1 ${n(cx + r)} ${n(cy)}A${r} ${r} 0 1 1 ${n(cx - r)} ${n(cy)}Z`;
+/** A star pointer: a flame rising from the ecliptic ring toward the rim. */
+const flame = (deg, tip, half) => {
+    const a = ((deg - ECL_DIR) * Math.PI) / 180;
+    const along = Math.cos(a) * ECL_D;
+    const base = along + Math.sqrt(ECL_R * ECL_R - (Math.sin(a) * ECL_D) ** 2) - 0.3;
+    const spread = (half / base) * (180 / Math.PI);
+    return `M${polar(deg - spread, base)}Q${polar(deg - spread * 0.4, (base + tip) / 2)} ${polar(deg, tip)}Q${polar(deg + spread * 0.4, (base + tip) / 2)} ${polar(deg + spread, base)}Z`;
+};
+const a = (ECL_DIR * Math.PI) / 180;
+const ECL_C = [C[0] + ECL_D * Math.sin(a), C[1] - ECL_D * Math.cos(a)];
+/** The alidade drawn upright: a bar with a sighting vane across each end. */
+const alidade = [`M${polar(0, 6.6)}L${polar(90, 1.05)}L${polar(180, 6.6)}L${polar(-90, 1.05)}Z`];
+const turnIn = {
+    duration: 1.8,
+    repeatAfter: 1.8,
+    loop: false,
+    frames: [{ at: 0, angle: -TURN }, { at: 0.12, angle: -TURN }, { at: 1 }],
+};
+const rete = [{}, {}, { angle: TURN }];
+export const astrolabeArt = {
+    name: 'astrolabe',
+    parts: [
+        {
+            // Suspension ring, hung from the shackle at the top of the throne.
+            name: 'ring',
+            paths: [circle(12, 2.35, 1.25)],
+            poses: [{}, {}, {}],
+        },
+        {
+            // The throne: the solid lug rising from the rim.
+            name: 'throne',
+            paths: [
+                'M6.6 9.2C7.4 7.4 9.2 6.4 10.2 5C10.5 4.6 10.6 4.1 10.6 3.6H13.4C13.4 4.1 13.5 4.6 13.8 5C14.8 6.4 16.6 7.4 17.4 9.2Q12 4.4 6.6 9.2Z',
+            ],
+            fillOnly: 'ink',
+            poses: [{}, {}, {}],
+        },
+        {
+            // The mater: the raised rim holding the plate.
+            name: 'mater',
+            paths: [circle(C[0], C[1], R)],
+            poses: [{}, {}, {}],
+        },
+        {
+            // The rete's ecliptic ring, off-centre on the pin.
+            name: 'ecliptic',
+            paths: [circle(ECL_C[0], ECL_C[1], ECL_R)],
+            detail: true,
+            pivot: C,
+            poses: rete,
+            gestures: [null, null, turnIn],
+        },
+        {
+            name: 'pointers',
+            paths: [flame(180, 5.8, 1.05)],
+            fillOnly: 'ink',
+            pivot: C,
+            poses: rete,
+            gestures: [null, null, turnIn],
+        },
+        {
+            // The sighted star's pointer on the rete (accent); it comes to lie under the alidade.
+            name: 'star-pointer',
+            paths: [flame(STAR_AT, 5.8, 1.3)],
+            fillOnly: 'ink',
+            accent: true,
+            pivot: C,
+            poses: rete,
+            gestures: [null, null, turnIn],
+        },
+        {
+            // The alidade: the sighting rule across the face, turning on the pin.
+            name: 'alidade',
+            paths: alidade,
+            fillOnly: 'ink',
+            pivot: C,
+            poses: [{}, { angle: SIGHT }, { angle: SIGHT }],
+        },
+        {
+            name: 'pin',
+            paths: [circle(C[0], C[1], 0.5)],
+            fillOnly: 'surface',
+            poses: [{}, {}, {}],
+        },
+        {
+            // The star in the sky, on the alidade's line of sight.
+            name: 'star',
+            paths: ['M19.4 1.6Q19.8 3.5 21.7 3.9Q19.8 4.3 19.4 6.2Q19 4.3 17.1 3.9Q19 3.5 19.4 1.6Z'],
+            fillOnly: 'ink',
+            accent: true,
+            pivot: [19.4, 3.9],
+            poses: [{ scaleX: 0, scaleY: 0 }, {}, {}],
+        },
+    ],
+};

package/dist/icons/aurora/aurora-icon.d.ts

@@ -0,0 +1,5 @@
+import type { StatefulIconProps } from "../../shared/icon-types.js";
+import { type AuroraState } from "./aurora-rig.js";
+export { auroraStates, type AuroraState } from "./aurora-rig.js";
+export type AuroraIconProps = StatefulIconProps<AuroraState>;
+export declare const AuroraIcon: import("react").NamedExoticComponent<AuroraIconProps>;

package/dist/icons/aurora/aurora-icon.js

@@ -0,0 +1,9 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { memo } from 'react';
+import { ArticulatedIcon } from "../../shared/articulated-icon.js";
+import { auroraArt, auroraStates } from "./aurora-rig.js";
+export { auroraStates } from "./aurora-rig.js";
+export const AuroraIcon = memo(function AuroraIcon(props) {
+    return _jsx(ArticulatedIcon, { art: auroraArt, states: auroraStates, ...props });
+});

package/dist/icons/aurora/aurora-rig.d.ts

@@ -0,0 +1,64 @@
+/**
+ * An auroral curtain above the curve of the Earth. Solar-wind electrons funnelled down the
+ * magnetic field lines strike the upper atmosphere and make it glow: the curtain has a sharp,
+ * folded lower border and rays that rise along the near-vertical field lines. A quiet arc is a
+ * low, smooth band; as geomagnetic activity rises the border folds and the rays lengthen; in a
+ * storm the curtain towers and pushes further toward the equator (lower in the sky here).
+ */
+export declare const auroraStates: readonly ["quiet", "active", "storm"];
+export type AuroraState = (typeof auroraStates)[number];
+export declare const auroraArt: {
+    name: string;
+    parts: ({
+        name: string;
+        paths: string[];
+        poses: {}[];
+        pathStates?: undefined;
+        pathOffsets?: undefined;
+        fillOnly?: undefined;
+        accent?: undefined;
+        gestures?: undefined;
+    } | {
+        name: string;
+        paths: string[];
+        pathStates: string[][];
+        pathOffsets: number[][];
+        fillOnly: "ink";
+        accent: true;
+        poses: {
+            opacity: number;
+        }[];
+        gestures: ({
+            duration: number;
+            repeatAfter: number;
+            interpolation: "continuous";
+            frames: ({
+                at: number;
+                flex?: undefined;
+            } | {
+                at: number;
+                flex: number;
+            })[];
+        } | null)[];
+    } | {
+        name: string;
+        paths: string[];
+        pathStates: string[][];
+        pathOffsets: number[][];
+        accent: true;
+        poses: {}[];
+        gestures: ({
+            duration: number;
+            repeatAfter: number;
+            interpolation: "continuous";
+            frames: ({
+                at: number;
+                flex?: undefined;
+            } | {
+                at: number;
+                flex: number;
+            })[];
+        } | null)[];
+        fillOnly?: undefined;
+    })[];
+};

package/dist/icons/aurora/aurora-rig.js

@@ -0,0 +1,102 @@
+/**
+ * An auroral curtain above the curve of the Earth. Solar-wind electrons funnelled down the
+ * magnetic field lines strike the upper atmosphere and make it glow: the curtain has a sharp,
+ * folded lower border and rays that rise along the near-vertical field lines. A quiet arc is a
+ * low, smooth band; as geomagnetic activity rises the border folds and the rays lengthen; in a
+ * storm the curtain towers and pushes further toward the equator (lower in the sky here).
+ */
+export const auroraStates = ['quiet', 'active', 'storm'];
+const n = (v) => +v.toFixed(3);
+// Border anchors; the five rays stand on the inner anchors.
+const XS = [2.6, 4.4, 8.2, 12, 15.8, 19.6, 21.4];
+/** Catmull-Rom segment i of the border, as a cubic Bézier tail (control, control, end). */
+function segment(ys, i) {
+    const p = XS.map((x, k) => [x, ys[k]]);
+    const a = p[Math.max(0, i - 1)], b = p[i], c = p[i + 1], e = p[Math.min(p.length - 1, i + 2)];
+    return (`C${n(b[0] + (c[0] - a[0]) / 6)} ${n(b[1] + (c[1] - a[1]) / 6)} ` +
+        `${n(c[0] - (e[0] - b[0]) / 6)} ${n(c[1] - (e[1] - b[1]) / 6)} ${n(c[0])} ${n(c[1])}`);
+}
+/** Smooth lower border through the anchors, plus the vertical rays standing on it. */
+function curtain(ys, lengths) {
+    let d = `M${n(XS[0])} ${n(ys[0])}`;
+    for (let i = 0; i < XS.length - 1; i++)
+        d += segment(ys, i);
+    const rays = lengths.map((length, i) => {
+        const x = XS[i + 1], y = ys[i + 1];
+        return `M${n(x)} ${n(y)}L${n(x)} ${n(y - length)}`;
+    });
+    return [d, ...rays];
+}
+/** The glowing sheet between the border and the ray tops, from the first ray to the last. */
+function sheet(ys, lengths) {
+    let d = `M${n(XS[1])} ${n(ys[1])}`;
+    for (let i = 1; i < XS.length - 2; i++)
+        d += segment(ys, i);
+    for (let i = lengths.length - 1; i >= 0; i--)
+        d += `L${n(XS[i + 1])} ${n(ys[i + 1] - lengths[i])}`;
+    return [d + 'Z'];
+}
+const NUMBER = /[-+]?(?:\d*\.\d+|\d+\.?\d*)/g;
+const values = (d) => (d.match(NUMBER) ?? []).map(Number);
+/** Flex offsets: the difference between a displaced drawing and the accepted one. */
+const offsets = (base, moved) => base.map((d, i) => values(moved[i]).map((v, k) => n(v - values(d)[k])));
+/** The lower border is a fold wave whose period does not match the ray spacing. */
+// The border's free ends lift slightly toward the sheet, so they never hook downward.
+const wave = (base, amp) => {
+    const ys = XS.map((x) => n(base + amp * Math.sin(((x - 2.6) / 9.4) * 2 * Math.PI)));
+    ys[0] = n(ys[1] - 0.7);
+    ys[ys.length - 1] = n(ys[ys.length - 2] - 0.7);
+    return ys;
+};
+const QUIET_Y = wave(15, 0.35);
+const QUIET_L = [2.2, 3, 3.6, 3, 2.4];
+const ACTIVE_Y = wave(15, 1.5);
+const ACTIVE_L = [5, 7.2, 8.6, 7.6, 5.6];
+const STORM_Y = wave(16, 2);
+const STORM_L = [8.8, 11.4, 12.6, 11.6, 9.4];
+// The folds travel sideways: a quarter-period phase component, added and removed.
+const SWAY = XS.map((x, i) => i === 0 || i === XS.length - 1 ? 0 : n(1.1 * Math.cos(((x - 2.6) / 9.4) * 2 * Math.PI)));
+const shifted = (ys) => ys.map((y, i) => y + SWAY[i]);
+const quietSheet = sheet(QUIET_Y, QUIET_L);
+const activeSheet = sheet(ACTIVE_Y, ACTIVE_L);
+const stormSheet = sheet(STORM_Y, STORM_L);
+const quiet = curtain(QUIET_Y, QUIET_L);
+const active = curtain(ACTIVE_Y, ACTIVE_L);
+const storm = curtain(STORM_Y, STORM_L);
+const ripple = (duration) => ({
+    duration,
+    repeatAfter: duration + 0.8,
+    interpolation: 'continuous',
+    frames: [{ at: 0 }, { at: 0.25, flex: 1 }, { at: 0.75, flex: -1 }, { at: 1 }],
+});
+export const auroraArt = {
+    name: 'aurora',
+    parts: [
+        {
+            // The Earth's curved limb under the polar sky.
+            name: 'limb',
+            paths: ['M2.6 21.6C8 19.9 16 19.9 21.4 21.6'],
+            poses: [{}, {}, {}],
+        },
+        {
+            // Translucent glow of the curtain: excited oxygen fills the sheet between the rays.
+            name: 'glow',
+            paths: quietSheet,
+            pathStates: [quietSheet, activeSheet, stormSheet],
+            pathOffsets: offsets(activeSheet, sheet(shifted(ACTIVE_Y), ACTIVE_L)),
+            fillOnly: 'ink',
+            accent: true,
+            poses: [{ opacity: 0.28 }, { opacity: 0.28 }, { opacity: 0.28 }],
+            gestures: [null, ripple(3.2), ripple(2.6)],
+        },
+        {
+            name: 'curtain',
+            paths: quiet,
+            pathStates: [quiet, active, storm],
+            pathOffsets: offsets(active, curtain(shifted(ACTIVE_Y), ACTIVE_L)),
+            accent: true,
+            poses: [{}, {}, {}],
+            gestures: [null, ripple(3.2), ripple(2.6)],
+        },
+    ],
+};

package/dist/icons/brain-computer-interface/brain-computer-interface-icon.d.ts

@@ -0,0 +1,5 @@
+import type { StatefulIconProps } from "../../shared/icon-types.js";
+import { type BrainComputerInterfaceState } from "./brain-computer-interface-rig.js";
+export { brainComputerInterfaceStates, type BrainComputerInterfaceState, } from "./brain-computer-interface-rig.js";
+export type BrainComputerInterfaceIconProps = StatefulIconProps<BrainComputerInterfaceState>;
+export declare const BrainComputerInterfaceIcon: import("react").NamedExoticComponent<BrainComputerInterfaceIconProps>;

package/dist/icons/brain-computer-interface/brain-computer-interface-icon.js

@@ -0,0 +1,9 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { memo } from 'react';
+import { ArticulatedIcon } from "../../shared/articulated-icon.js";
+import { brainComputerInterfaceArt, brainComputerInterfaceStates, } from "./brain-computer-interface-rig.js";
+export { brainComputerInterfaceStates, } from "./brain-computer-interface-rig.js";
+export const BrainComputerInterfaceIcon = memo(function BrainComputerInterfaceIcon(props) {
+    return (_jsx(ArticulatedIcon, { art: brainComputerInterfaceArt, states: brainComputerInterfaceStates, ...props }));
+});