@lemoncat7/dsh-theme-xiaohei 0.3.0-alpha.23 → 0.3.2

package/lib/vendor/bloub/math.js

@@ -0,0 +1,36 @@
+// Adapted from bloub, Copyright (c) 2026 Jérémy Perret (MIT).
+// See THIRD_PARTY_NOTICES.md for source revision and local changes.
+export const TAU = Math.PI * 2;
+export const clamp = (v, lo = 0, hi = 1) => (v < lo ? lo : v > hi ? hi : v);
+export const lerp = (a, b, t) => a + (b - a) * t;
+/**
+ * Mesure sur la video : les transitions sont des ease-out exponentiels, sans
+ * depassement du corps. Les seuls effets de ressort sont locaux (le pop de la
+ * pastille de notification, l'ouverture des yeux) et sont ecrits directement
+ * dans l'etat concerne.
+ */
+export const easings = {
+    easeOutCubic: (t) => 1 - (1 - t) ** 3,
+    easeInOutCubic: (t) => (t < 0.5 ? 4 * t ** 3 : 1 - (-2 * t + 2) ** 3 / 2),
+    easeOutQuint: (t) => 1 - (1 - t) ** 5
+};
+/** Bruit 1D periodique : boucle sans couture sur `period`, utile pour la derive du regard. */
+export function loopNoise(t, period, seed = 0) {
+    const p = (t / period) * TAU;
+    return (0.55 * Math.sin(p + seed) +
+        0.3 * Math.sin(2 * p + seed * 1.7 + 1.1) +
+        0.15 * Math.sin(3 * p + seed * 2.3 + 2.4));
+}
+/** PRNG deterministe (mulberry32) : meme sequence a chaque lecture. */
+export function createRng(seed) {
+    let a = seed >>> 0;
+    return () => {
+        a = (a + 0x6d2b79f5) >>> 0;
+        let t = Math.imul(a ^ (a >>> 15), 1 | a);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+/** Arrondi court : divise par ~2 le poids des chaines de path generees a 60 fps. */
+export const r2 = (v) => Math.round(v * 100) / 100;
+//# sourceMappingURL=math.js.map

package/lib/vendor/bloub/profiles.d.ts

@@ -0,0 +1,8 @@
+export declare const PROFILE_SAMPLES = 64;
+export declare const PROFILES: {
+    readonly egg: readonly [0.8369, 0.8424, 0.8497, 0.8585, 0.8674, 0.8775, 0.8878, 0.8983, 0.9089, 0.9185, 0.9288, 0.9374, 0.9445, 0.9504, 0.9543, 0.9559, 0.9555, 0.9519, 0.9466, 0.9389, 0.9302, 0.9193, 0.9085, 0.8969, 0.8852, 0.8734, 0.8625, 0.8513, 0.8411, 0.8325, 0.8243, 0.8179, 0.8137, 0.8112, 0.8102, 0.8128, 0.8178, 0.8262, 0.8374, 0.8518, 0.8702, 0.8922, 0.9169, 0.9446, 0.9741, 1.0023, 1.0267, 1.0433, 1.0481, 1.0393, 1.0216, 0.997, 0.9697, 0.9418, 0.9169, 0.8949, 0.876, 0.8604, 0.849, 0.8394, 0.8337, 0.8314, 0.8305, 0.8326];
+    readonly hexagon: readonly [0.921, 0.9282, 0.9441, 0.9706, 0.9984, 1.0059, 0.9896, 0.9562, 0.929, 0.9124, 0.9047, 0.9058, 0.9157, 0.9349, 0.9642, 0.9873, 0.9882, 0.9665, 0.9336, 0.9105, 0.8968, 0.8918, 0.8955, 0.908, 0.9293, 0.9611, 0.982, 0.9812, 0.959, 0.9282, 0.9089, 0.8978, 0.8964, 0.9026, 0.9189, 0.9439, 0.9778, 0.999, 0.9964, 0.9713, 0.9439, 0.9274, 0.9196, 0.9206, 0.9308, 0.9502, 0.9799, 1.0121, 1.0226, 1.0071, 0.9752, 0.951, 0.9366, 0.9316, 0.9351, 0.9485, 0.9711, 1.0026, 1.0213, 1.0155, 0.9863, 0.9547, 0.9347, 0.9232];
+    readonly triangle: readonly [0.7819, 0.8211, 0.8747, 0.944, 1.0223, 1.096, 1.1401, 1.134, 1.0808, 1.0047, 0.9265, 0.8603, 0.8104, 0.773, 0.745, 0.7273, 0.7151, 0.7118, 0.7148, 0.7245, 0.7427, 0.768, 0.8037, 0.8518, 0.9148, 0.9876, 1.0583, 1.1073, 1.1109, 1.0667, 0.994, 0.9164, 0.8482, 0.7948, 0.7555, 0.7261, 0.7056, 0.6925, 0.6859, 0.6869, 0.6938, 0.7084, 0.7305, 0.7615, 0.804, 0.8595, 0.9311, 1.0092, 1.0791, 1.1171, 1.1054, 1.0501, 0.9779, 0.905, 0.845, 0.799, 0.7656, 0.7413, 0.7258, 0.716, 0.7146, 0.7204, 0.733, 0.7528];
+};
+export type ProfileName = keyof typeof PROFILES;
+//# sourceMappingURL=profiles.d.ts.map

package/lib/vendor/bloub/profiles.js

@@ -0,0 +1,20 @@
+// Adapted from bloub, Copyright (c) 2026 Jérémy Perret (MIT).
+// See THIRD_PARTY_NOTICES.md for source revision and local changes.
+// Profils radiaux r(theta) releves au pixel sur la video de reference.
+// theta = 0 pointe vers la droite et croit dans le sens horaire (y vers le bas).
+// Unite : rayon de la boule au repos = 1.
+//
+// Genere par tools/extract-profiles.py — ne pas editer a la main.
+export const PROFILE_SAMPLES = 64;
+export const PROFILES = {
+    // oeuf : meme hauteur que la boule, retreci en largeur
+    // image 164, empreinte mesuree 1.647 x 2.000
+    egg: [0.8369, 0.8424, 0.8497, 0.8585, 0.8674, 0.8775, 0.8878, 0.8983, 0.9089, 0.9185, 0.9288, 0.9374, 0.9445, 0.9504, 0.9543, 0.9559, 0.9555, 0.9519, 0.9466, 0.9389, 0.9302, 0.9193, 0.9085, 0.8969, 0.8852, 0.8734, 0.8625, 0.8513, 0.8411, 0.8325, 0.8243, 0.8179, 0.8137, 0.8112, 0.8102, 0.8128, 0.8178, 0.8262, 0.8374, 0.8518, 0.8702, 0.8922, 0.9169, 0.9446, 0.9741, 1.0023, 1.0267, 1.0433, 1.0481, 1.0393, 1.0216, 0.9970, 0.9697, 0.9418, 0.9169, 0.8949, 0.8760, 0.8604, 0.8490, 0.8394, 0.8337, 0.8314, 0.8305, 0.8326],
+    // hexagone pointe en haut, coins tres arrondis
+    // image 174, empreinte mesuree 1.826 x 2.011
+    hexagon: [0.9210, 0.9282, 0.9441, 0.9706, 0.9984, 1.0059, 0.9896, 0.9562, 0.9290, 0.9124, 0.9047, 0.9058, 0.9157, 0.9349, 0.9642, 0.9873, 0.9882, 0.9665, 0.9336, 0.9105, 0.8968, 0.8918, 0.8955, 0.9080, 0.9293, 0.9611, 0.9820, 0.9812, 0.9590, 0.9282, 0.9089, 0.8978, 0.8964, 0.9026, 0.9189, 0.9439, 0.9778, 0.9990, 0.9964, 0.9713, 0.9439, 0.9274, 0.9196, 0.9206, 0.9308, 0.9502, 0.9799, 1.0121, 1.0226, 1.0071, 0.9752, 0.9510, 0.9366, 0.9316, 0.9351, 0.9485, 0.9711, 1.0026, 1.0213, 1.0155, 0.9863, 0.9547, 0.9347, 0.9232],
+    // triangle pointe en haut, coins tres arrondis
+    // image 190, empreinte mesuree 1.995 x 1.884
+    triangle: [0.7819, 0.8211, 0.8747, 0.9440, 1.0223, 1.0960, 1.1401, 1.1340, 1.0808, 1.0047, 0.9265, 0.8603, 0.8104, 0.7730, 0.7450, 0.7273, 0.7151, 0.7118, 0.7148, 0.7245, 0.7427, 0.7680, 0.8037, 0.8518, 0.9148, 0.9876, 1.0583, 1.1073, 1.1109, 1.0667, 0.9940, 0.9164, 0.8482, 0.7948, 0.7555, 0.7261, 0.7056, 0.6925, 0.6859, 0.6869, 0.6938, 0.7084, 0.7305, 0.7615, 0.8040, 0.8595, 0.9311, 1.0092, 1.0791, 1.1171, 1.1054, 1.0501, 0.9779, 0.9050, 0.8450, 0.7990, 0.7656, 0.7413, 0.7258, 0.7160, 0.7146, 0.7204, 0.7330, 0.7528],
+};
+//# sourceMappingURL=profiles.js.map

package/lib/vendor/bloub/repere.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Le repere de tout ce que le moteur rend.
+ *
+ * `engine.sample()` sort des coordonnees en unites de viewBox, et ces deux nombres en sont
+ * la definition : sans eux, une sortie du moteur ne veut rien dire. Ils vivaient dans
+ * `BloubBot.vue`, donc hors d'atteinte — un `<script setup>` n'exporte rien — et
+ * `export.ts` en redisait un a la main avec le commentaire qui nommait le probleme.
+ *
+ * Ils sont ici parce que `src/bot/` est ce qui se lit et se consomme du dehors : le
+ * composant Vue est UN client du moteur, pas sa definition.
+ */
+/**
+ * Rayon de la boule au repos, en unites de viewBox. C'est le `scale` que le composant
+ * passe a `BotEngine`.
+ *
+ * Choisi et non mesure : c'est l'unite de travail. Tout le reste du dossier s'exprime en
+ * fractions de ce rayon, ce qui rend les mesures relevees sur la video independantes de la
+ * taille d'affichage.
+ */
+export declare const RAYON = 100;
+/**
+ * Demi-cote du viewBox affiche. La marge au-dela du rayon loge les anneaux.
+ *
+ * Ce n'est pas une valeur libre : les anneaux de l'orbite et le swoosh de la comete montent
+ * a 1,4 fois le rayon, soit 140. Rien ne les borne au runtime — c'est le reglage a la main
+ * des tableaux `RINGS` et `SWOOSH` (`decor.ts`) qui les tient sous 158, et un test le
+ * verrouille.
+ */
+export declare const DEMI_VIEWBOX = 158;
+//# sourceMappingURL=repere.d.ts.map

package/lib/vendor/bloub/repere.js

@@ -0,0 +1,32 @@
+// Adapted from bloub, Copyright (c) 2026 Jérémy Perret (MIT).
+// See THIRD_PARTY_NOTICES.md for source revision and local changes.
+/**
+ * Le repere de tout ce que le moteur rend.
+ *
+ * `engine.sample()` sort des coordonnees en unites de viewBox, et ces deux nombres en sont
+ * la definition : sans eux, une sortie du moteur ne veut rien dire. Ils vivaient dans
+ * `BloubBot.vue`, donc hors d'atteinte — un `<script setup>` n'exporte rien — et
+ * `export.ts` en redisait un a la main avec le commentaire qui nommait le probleme.
+ *
+ * Ils sont ici parce que `src/bot/` est ce qui se lit et se consomme du dehors : le
+ * composant Vue est UN client du moteur, pas sa definition.
+ */
+/**
+ * Rayon de la boule au repos, en unites de viewBox. C'est le `scale` que le composant
+ * passe a `BotEngine`.
+ *
+ * Choisi et non mesure : c'est l'unite de travail. Tout le reste du dossier s'exprime en
+ * fractions de ce rayon, ce qui rend les mesures relevees sur la video independantes de la
+ * taille d'affichage.
+ */
+export const RAYON = 100;
+/**
+ * Demi-cote du viewBox affiche. La marge au-dela du rayon loge les anneaux.
+ *
+ * Ce n'est pas une valeur libre : les anneaux de l'orbite et le swoosh de la comete montent
+ * a 1,4 fois le rayon, soit 140. Rien ne les borne au runtime — c'est le reglage a la main
+ * des tableaux `RINGS` et `SWOOSH` (`decor.ts`) qui les tient sous 158, et un test le
+ * verrouille.
+ */
+export const DEMI_VIEWBOX = 158;
+//# sourceMappingURL=repere.js.map

package/lib/vendor/bloub/shape.d.ts

@@ -0,0 +1,80 @@
+import { type ProfileName } from './profiles.js';
+export interface Point {
+    x: number;
+    y: number;
+}
+/**
+ * Une silhouette = un profil radial r(theta) plus une pose.
+ *
+ * Tout passe par des profils echantillonnes au MEME nombre d'angles : deux
+ * formes quelconques ont donc des points qui se correspondent un a un, et le
+ * morphing se reduit a une interpolation lineaire des rayons. C'est ce qui
+ * rend les transitions propres sans librairie de morphing de path.
+ */
+export interface Silhouette {
+    radii: number[];
+    /** rotation du profil, en radians */
+    rot: number;
+    /** decalage du centre, en unites de rayon de boule */
+    cx: number;
+    cy: number;
+    /** squash & stretch, applique en repere ecran (apres rotation) */
+    sx: number;
+    sy: number;
+}
+export declare function silhouette(name: ProfileName, pose?: Partial<Silhouette>): Silhouette;
+/** Cercle parfait : sert de base neutre (point, bulle, cible de fondu). */
+export declare function circle(radius: number, pose?: Partial<Silhouette>): Silhouette;
+/** Interpolation de deux silhouettes. `out` est reutilise pour eviter d'allouer a 60 fps. */
+export declare function blend(a: Silhouette, b: Silhouette, t: number, out?: Silhouette): Silhouette;
+/** Projette la silhouette en points ecran. `scale` = rayon de la boule en unites de viewBox. */
+export declare function toPoints(s: Silhouette, scale: number, out?: Point[]): Point[];
+/**
+ * Polyligne fermee -> cubiques Catmull-Rom.
+ *
+ * Avec 64 points les tangentes centrees suffisent largement : le contour est
+ * lisse au pixel pres meme affiche en 600 px, et la chaine reste courte.
+ */
+export declare function closedPath(pts: Point[], tension?: number): string;
+/**
+ * Polygone quelconque -> profil radial, par lancer de rayon depuis `center`.
+ *
+ * Sert a fabriquer les formes qui ne s'expriment pas naturellement en r(theta)
+ * (la barre tronconique du "!"). Calcule une seule fois au chargement, jamais
+ * dans la boucle de rendu.
+ */
+export declare function profileFromPolygon(poly: Point[], cx: number, cy: number): number[];
+/** Enveloppe convexe de deux cercles : la barre tronconique du "!" vertical. */
+export declare function hullOfCircles(x1: number, y1: number, r1: number, x2: number, y2: number, r2v: number, steps?: number): Point[];
+/**
+ * Rayon du profil dans une direction quelconque, par interpolation entre les
+ * deux echantillons voisins.
+ *
+ * Sert a recaler ce qui est pose "sur" le corps (les yeux, la pastille de
+ * notification) quand la silhouette n'est plus un cercle : sans ca, un oeil
+ * place a 0.62 rayon sort d'une forme dont le bord est a 0.55 dans cette
+ * direction, et le masque le rogne.
+ */
+export declare function radiusAtAngle(radii: number[], angle: number): number;
+/**
+ * Superellipse : |x/sx|^n + |y/sy|^n = 1.
+ * n = 2 donne une ellipse, n ~ 4 le squircle du personnalisateur.
+ */
+export declare function superellipseProfile(n: number, sx?: number, sy?: number): number[];
+/**
+ * Profil radial de l'UNION de disques : r(theta) = la plus lointaine des
+ * intersections rayon/cercle. Exact tant que l'origine est dans l'union — c'est
+ * ce qui donne les bosses du nuage sans booleen de path.
+ */
+export declare function unionOfCirclesProfile(circles: Array<{
+    x: number;
+    y: number;
+    r: number;
+}>): number[];
+/** Polygone regulier a coins arrondis, inscrit dans `radius`. */
+export declare function regularPolygonProfile(sides: number, radius: number, rc: number, rotationDeg?: number): number[];
+/** Polyligne fermee exacte : garde les segments droits (contrairement a closedPath). */
+export declare function polyPath(pts: Point[], scale?: number): string;
+/** Capsule (stade) centree sur l'origine : la forme exacte des yeux du bot. */
+export declare function capsulePath(w: number, h: number): string;
+//# sourceMappingURL=shape.d.ts.map

package/lib/vendor/bloub/shape.js

@@ -0,0 +1,268 @@
+// Adapted from bloub, Copyright (c) 2026 Jérémy Perret (MIT).
+// See THIRD_PARTY_NOTICES.md for source revision and local changes.
+import { TAU, lerp, r2 } from './math.js';
+import { PROFILES, PROFILE_SAMPLES } from './profiles.js';
+const ANGLES = Array.from({ length: PROFILE_SAMPLES }, (_, i) => (i / PROFILE_SAMPLES) * TAU);
+const COS = ANGLES.map(Math.cos);
+const SIN = ANGLES.map(Math.sin);
+export function silhouette(name, pose = {}) {
+    return {
+        radii: [...PROFILES[name]],
+        rot: 0,
+        cx: 0,
+        cy: 0,
+        sx: 1,
+        sy: 1,
+        ...pose
+    };
+}
+/** Cercle parfait : sert de base neutre (point, bulle, cible de fondu). */
+export function circle(radius, pose = {}) {
+    return {
+        radii: new Array(PROFILE_SAMPLES).fill(radius),
+        rot: 0,
+        cx: 0,
+        cy: 0,
+        sx: 1,
+        sy: 1,
+        ...pose
+    };
+}
+/** Interpolation de deux silhouettes. `out` est reutilise pour eviter d'allouer a 60 fps. */
+export function blend(a, b, t, out) {
+    const dst = out ?? { radii: new Array(PROFILE_SAMPLES), rot: 0, cx: 0, cy: 0, sx: 1, sy: 1 };
+    for (let i = 0; i < PROFILE_SAMPLES; i++) {
+        dst.radii[i] = lerp(a.radii[i] ?? 1, b.radii[i] ?? 1, t);
+    }
+    // Rotation par le chemin le plus court : evite de faire un tour complet
+    // quand on passe par exemple de +170deg a -170deg.
+    let dRot = b.rot - a.rot;
+    while (dRot > Math.PI)
+        dRot -= TAU;
+    while (dRot < -Math.PI)
+        dRot += TAU;
+    dst.rot = a.rot + dRot * t;
+    dst.cx = lerp(a.cx, b.cx, t);
+    dst.cy = lerp(a.cy, b.cy, t);
+    dst.sx = lerp(a.sx, b.sx, t);
+    dst.sy = lerp(a.sy, b.sy, t);
+    return dst;
+}
+/** Projette la silhouette en points ecran. `scale` = rayon de la boule en unites de viewBox. */
+export function toPoints(s, scale, out = []) {
+    const cr = Math.cos(s.rot);
+    const sr = Math.sin(s.rot);
+    for (let i = 0; i < PROFILE_SAMPLES; i++) {
+        const r = s.radii[i] ?? 1;
+        const x = r * (COS[i] ?? 0);
+        const y = r * (SIN[i] ?? 0);
+        // rotation puis squash en repere ecran, puis translation
+        const rx = x * cr - y * sr;
+        const ry = x * sr + y * cr;
+        const p = out[i] ?? { x: 0, y: 0 };
+        p.x = (rx * s.sx + s.cx) * scale;
+        p.y = (ry * s.sy + s.cy) * scale;
+        out[i] = p;
+    }
+    out.length = PROFILE_SAMPLES;
+    return out;
+}
+/**
+ * Polyligne fermee -> cubiques Catmull-Rom.
+ *
+ * Avec 64 points les tangentes centrees suffisent largement : le contour est
+ * lisse au pixel pres meme affiche en 600 px, et la chaine reste courte.
+ */
+export function closedPath(pts, tension = 1 / 6) {
+    const n = pts.length;
+    if (n < 3)
+        return '';
+    const first = pts[0];
+    let d = `M${r2(first.x)} ${r2(first.y)}`;
+    for (let i = 0; i < n; i++) {
+        const p0 = pts[(i - 1 + n) % n];
+        const p1 = pts[i];
+        const p2 = pts[(i + 1) % n];
+        const p3 = pts[(i + 2) % n];
+        const c1x = p1.x + (p2.x - p0.x) * tension;
+        const c1y = p1.y + (p2.y - p0.y) * tension;
+        const c2x = p2.x - (p3.x - p1.x) * tension;
+        const c2y = p2.y - (p3.y - p1.y) * tension;
+        d += `C${r2(c1x)} ${r2(c1y)} ${r2(c2x)} ${r2(c2y)} ${r2(p2.x)} ${r2(p2.y)}`;
+    }
+    return `${d}Z`;
+}
+/**
+ * Polygone quelconque -> profil radial, par lancer de rayon depuis `center`.
+ *
+ * Sert a fabriquer les formes qui ne s'expriment pas naturellement en r(theta)
+ * (la barre tronconique du "!"). Calcule une seule fois au chargement, jamais
+ * dans la boucle de rendu.
+ */
+export function profileFromPolygon(poly, cx, cy) {
+    const radii = new Array(PROFILE_SAMPLES).fill(0);
+    const n = poly.length;
+    for (let k = 0; k < PROFILE_SAMPLES; k++) {
+        const dx = COS[k] ?? 0;
+        const dy = SIN[k] ?? 0;
+        let best = 0;
+        for (let i = 0; i < n; i++) {
+            const a = poly[i];
+            const b = poly[(i + 1) % n];
+            const ex = b.x - a.x;
+            const ey = b.y - a.y;
+            const den = dx * ey - dy * ex;
+            if (Math.abs(den) < 1e-9)
+                continue;
+            const px = a.x - cx;
+            const py = a.y - cy;
+            const t = (px * ey - py * ex) / den; // distance le long du rayon
+            const u = (px * dy - py * dx) / den; // position sur le segment
+            if (t > best && u >= 0 && u <= 1)
+                best = t;
+        }
+        radii[k] = best;
+    }
+    return radii;
+}
+/** Enveloppe convexe de deux cercles : la barre tronconique du "!" vertical. */
+export function hullOfCircles(x1, y1, r1, x2, y2, r2v, steps = 96) {
+    const dx = x2 - x1;
+    const dy = y2 - y1;
+    const dist = Math.hypot(dx, dy) || 1e-6;
+    // angle des tangentes externes communes
+    const base = Math.atan2(dy, dx);
+    const spread = Math.acos(Math.max(-1, Math.min(1, (r1 - r2v) / dist)));
+    const pts = [];
+    // arc du grand cercle
+    for (let i = 0; i <= steps / 2; i++) {
+        const a = base + spread + ((TAU - 2 * spread) * i) / (steps / 2);
+        pts.push({ x: x1 + Math.cos(a) * r1, y: y1 + Math.sin(a) * r1 });
+    }
+    // arc du petit cercle
+    for (let i = 0; i <= steps / 2; i++) {
+        const a = base - spread + ((2 * spread) * i) / (steps / 2);
+        pts.push({ x: x2 + Math.cos(a) * r2v, y: y2 + Math.sin(a) * r2v });
+    }
+    return pts;
+}
+/**
+ * Rayon du profil dans une direction quelconque, par interpolation entre les
+ * deux echantillons voisins.
+ *
+ * Sert a recaler ce qui est pose "sur" le corps (les yeux, la pastille de
+ * notification) quand la silhouette n'est plus un cercle : sans ca, un oeil
+ * place a 0.62 rayon sort d'une forme dont le bord est a 0.55 dans cette
+ * direction, et le masque le rogne.
+ */
+export function radiusAtAngle(radii, angle) {
+    const n = radii.length;
+    const t = ((((angle / TAU) % 1) + 1) % 1) * n;
+    const i = Math.floor(t);
+    return lerp(radii[i % n] ?? 1, radii[(i + 1) % n] ?? 1, t - i);
+}
+/**
+ * Superellipse : |x/sx|^n + |y/sy|^n = 1.
+ * n = 2 donne une ellipse, n ~ 4 le squircle du personnalisateur.
+ */
+export function superellipseProfile(n, sx = 1, sy = 1) {
+    return ANGLES.map((_, i) => {
+        const c = Math.abs((COS[i] ?? 0) / sx) ** n;
+        const s = Math.abs((SIN[i] ?? 0) / sy) ** n;
+        return (c + s) ** (-1 / n);
+    });
+}
+/**
+ * Profil radial de l'UNION de disques : r(theta) = la plus lointaine des
+ * intersections rayon/cercle. Exact tant que l'origine est dans l'union — c'est
+ * ce qui donne les bosses du nuage sans booleen de path.
+ */
+export function unionOfCirclesProfile(circles) {
+    const out = new Array(PROFILE_SAMPLES).fill(0);
+    for (let i = 0; i < PROFILE_SAMPLES; i++) {
+        const dx = COS[i] ?? 0;
+        const dy = SIN[i] ?? 0;
+        let best = 0;
+        for (const c of circles) {
+            const b = dx * c.x + dy * c.y;
+            const disc = b * b - (c.x * c.x + c.y * c.y - c.r * c.r);
+            if (disc < 0)
+                continue;
+            const t = b + Math.sqrt(disc);
+            if (t > best)
+                best = t;
+        }
+        out[i] = best;
+    }
+    return out;
+}
+/**
+ * Polygone a coins arrondis, par somme de Minkowski avec un disque : chaque
+ * arete est poussee de `rc` vers l'exterieur, chaque sommet devient un arc de
+ * rayon `rc`. Les sommets sont donc a poser au rayon voulu MOINS rc.
+ * Attend un polygone en sens horaire (repere ecran, y vers le bas).
+ */
+function roundedPolygon(verts, rc, arcSteps = 10) {
+    const n = verts.length;
+    const out = [];
+    const normal = (a, b) => {
+        const dx = b.x - a.x;
+        const dy = b.y - a.y;
+        const len = Math.hypot(dx, dy) || 1;
+        // sens horaire + y vers le bas : la normale sortante est (dy, -dx)
+        return Math.atan2(-dx / len, dy / len);
+    };
+    for (let i = 0; i < n; i++) {
+        const prev = verts[(i - 1 + n) % n];
+        const cur = verts[i];
+        const next = verts[(i + 1) % n];
+        const a0 = normal(prev, cur);
+        const a1 = normal(cur, next);
+        let d = a1 - a0;
+        while (d > Math.PI)
+            d -= TAU;
+        while (d < -Math.PI)
+            d += TAU;
+        for (let k = 0; k <= arcSteps; k++) {
+            const a = a0 + (d * k) / arcSteps;
+            out.push({ x: cur.x + Math.cos(a) * rc, y: cur.y + Math.sin(a) * rc });
+        }
+    }
+    return out;
+}
+/** Polygone regulier a coins arrondis, inscrit dans `radius`. */
+export function regularPolygonProfile(sides, radius, rc, rotationDeg = 0) {
+    const rot = (rotationDeg * Math.PI) / 180;
+    const verts = Array.from({ length: sides }, (_, i) => {
+        // sens horaire a l'ecran : theta croissant avec y vers le bas
+        const a = rot + (i / sides) * TAU;
+        return { x: Math.cos(a) * (radius - rc), y: Math.sin(a) * (radius - rc) };
+    });
+    return profileFromPolygon(roundedPolygon(verts, rc), 0, 0);
+}
+/** Polyligne fermee exacte : garde les segments droits (contrairement a closedPath). */
+export function polyPath(pts, scale = 1) {
+    if (pts.length < 3)
+        return '';
+    let d = '';
+    for (let i = 0; i < pts.length; i++) {
+        const p = pts[i];
+        d += `${i === 0 ? 'M' : 'L'}${r2(p.x * scale)} ${r2(p.y * scale)}`;
+    }
+    return `${d}Z`;
+}
+/** Capsule (stade) centree sur l'origine : la forme exacte des yeux du bot. */
+export function capsulePath(w, h) {
+    const hw = Math.max(w, 0.01) / 2;
+    const hh = Math.max(h, 0.01) / 2;
+    const r = Math.min(hw, hh);
+    return (`M${r2(-hw)} ${r2(-hh + r)}` +
+        `A${r2(r)} ${r2(r)} 0 0 1 ${r2(-hw + r)} ${r2(-hh)}` +
+        `L${r2(hw - r)} ${r2(-hh)}` +
+        `A${r2(r)} ${r2(r)} 0 0 1 ${r2(hw)} ${r2(-hh + r)}` +
+        `L${r2(hw)} ${r2(hh - r)}` +
+        `A${r2(r)} ${r2(r)} 0 0 1 ${r2(hw - r)} ${r2(hh)}` +
+        `L${r2(-hw + r)} ${r2(hh)}` +
+        `A${r2(r)} ${r2(r)} 0 0 1 ${r2(-hw)} ${r2(hh - r)}Z`);
+}
+//# sourceMappingURL=shape.js.map

package/lib/vendor/bloub/skins.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Formes et couleurs proposees par le personnalisateur du bot.
+ *
+ * A la difference des silhouettes d'animation (`profiles.ts`), celles-ci ne sont
+ * PAS relevees sur la video : elles sont construites analytiquement d'apres la
+ * grille du personnalisateur d'origine. Deux sources distinctes, donc, et c'est
+ * volontaire — les etats animes doivent rester fideles a la video, les formes de
+ * base sont un choix d'utilisateur.
+ */
+/**
+ * Les identifiants sont enumeres plutot que deduits du tableau : c'est ce qui
+ * permet a la couche i18n de verifier A LA COMPILATION que chaque forme a bien
+ * sa traduction dans les trois langues (`t(\`shapes.${id}\`)` ne compile que si
+ * la cle existe). Un `as const` sur le tableau aurait le meme effet mais
+ * rendrait `radii` en lecture seule, alors que le moteur le passe tel quel.
+ */
+export type ShapeId = 'cercle' | 'galet' | 'squircle' | 'capsule' | 'triangle' | 'hexagone' | 'nuage' | 'goutte';
+export interface BotShape {
+    id: ShapeId;
+    radii: number[];
+}
+export declare const SHAPES: BotShape[];
+export declare const SHAPE_BY_ID: Map<string, BotShape>;
+export declare const DEFAULT_SHAPE = "cercle";
+export type ColorId = 'encre' | 'creme' | 'brun' | 'rouge' | 'orange' | 'ambre' | 'vert' | 'turquoise' | 'bleu' | 'violet' | 'rose' | 'gris';
+export interface BotColor {
+    id: ColorId;
+    hex: string;
+}
+/** Palette du personnalisateur d'origine. */
+export declare const COLORS: BotColor[];
+export declare const COLOR_BY_ID: Map<string, BotColor>;
+export declare const DEFAULT_COLOR = "encre";
+/** Melange deux couleurs hex. Sert a la brume de profondeur des particules. */
+export declare function mixHex(from: string, to: string, t: number): string;
+//# sourceMappingURL=skins.d.ts.map

package/lib/vendor/bloub/skins.js

@@ -0,0 +1,74 @@
+// Adapted from bloub, Copyright (c) 2026 Jérémy Perret (MIT).
+// See THIRD_PARTY_NOTICES.md for source revision and local changes.
+import { PROFILE_SAMPLES } from './profiles.js';
+import { hullOfCircles, profileFromPolygon, regularPolygonProfile, superellipseProfile, unionOfCirclesProfile } from './shape.js';
+/** Ramene le rayon maximal a `max` pour que toutes les formes pesent pareil a l'oeil. */
+function normalize(radii, max = 1) {
+    const peak = Math.max(...radii);
+    if (peak <= 0)
+        return radii;
+    const k = max / peak;
+    return radii.map((r) => r * k);
+}
+const ANGLES = Array.from({ length: PROFILE_SAMPLES }, (_, i) => (i / PROFILE_SAMPLES) * Math.PI * 2);
+/** Galet : cercle deforme par deux harmoniques basses, donc irregulier mais lisse. */
+const pebble = normalize(ANGLES.map((a) => 1 + 0.075 * Math.cos(2 * a + 0.5) + 0.035 * Math.cos(3 * a + 2.1)), 1.02);
+/** Nuage : union de bosses, large en bas, deux lobes en haut. */
+const cloud = normalize(unionOfCirclesProfile([
+    { x: -0.44, y: 0.2, r: 0.54 },
+    { x: 0.46, y: 0.2, r: 0.5 },
+    { x: 0.02, y: 0.3, r: 0.6 },
+    { x: -0.24, y: -0.3, r: 0.48 },
+    { x: 0.3, y: -0.24, r: 0.44 }
+]), 1.02);
+/** Goutte : gros disque en bas, pointe effilee en haut. */
+const droplet = normalize(profileFromPolygon(hullOfCircles(0, 0.28, 0.66, 0, -0.96, 0.05), 0, 0), 1.04);
+/** Capsule couchee : enveloppe de deux disques cote a cote. */
+const capsule = profileFromPolygon(hullOfCircles(-0.42, 0, 0.62, 0.42, 0, 0.62), 0, 0);
+export const SHAPES = [
+    { id: 'cercle', radii: new Array(PROFILE_SAMPLES).fill(1) },
+    { id: 'galet', radii: pebble },
+    // 1.15 et pas 1.02 : sur une superellipse le rayon maximal est la diagonale,
+    // donc normaliser dessus donne une forme qui parait plus petite que le cercle.
+    { id: 'squircle', radii: normalize(superellipseProfile(4.2), 1.15) },
+    { id: 'capsule', radii: capsule },
+    // -90deg : un sommet vers le haut de l'ecran (y est oriente vers le bas)
+    { id: 'triangle', radii: regularPolygonProfile(3, 1.12, 0.34, -90) },
+    // 0deg : sommets a gauche et a droite, donc aretes du haut et du bas plates
+    { id: 'hexagone', radii: regularPolygonProfile(6, 1.04, 0.26, 0) },
+    { id: 'nuage', radii: cloud },
+    { id: 'goutte', radii: droplet }
+];
+// Map indexee par `string` et non par `ShapeId` : les appelants interrogent avec
+// une valeur relue du localStorage ou d'une prop, donc non validee.
+export const SHAPE_BY_ID = new Map(SHAPES.map((s) => [s.id, s]));
+export const DEFAULT_SHAPE = 'cercle';
+/** Palette du personnalisateur d'origine. */
+export const COLORS = [
+    { id: 'encre', hex: '#0a0a0c' },
+    { id: 'brun', hex: '#8b5e3c' },
+    { id: 'rouge', hex: '#e8483f' },
+    { id: 'orange', hex: '#f08a24' },
+    { id: 'ambre', hex: '#f0b429' },
+    { id: 'vert', hex: '#3ecf8e' },
+    { id: 'turquoise', hex: '#2fbfa0' },
+    { id: 'bleu', hex: '#3b93f0' },
+    { id: 'violet', hex: '#8b5cf6' },
+    { id: 'rose', hex: '#e152b0' },
+    { id: 'gris', hex: '#a3a3a3' },
+    { id: 'creme', hex: '#f1efe9' }
+];
+export const COLOR_BY_ID = new Map(COLORS.map((c) => [c.id, c]));
+export const DEFAULT_COLOR = 'encre';
+/** Melange deux couleurs hex. Sert a la brume de profondeur des particules. */
+export function mixHex(from, to, t) {
+    const parse = (h) => {
+        const v = parseInt(h.slice(1), 16);
+        return [(v >> 16) & 255, (v >> 8) & 255, v & 255];
+    };
+    const a = parse(from);
+    const b = parse(to);
+    const c = a.map((x, i) => Math.round(x + (b[i] - x) * t));
+    return `#${c.map((x) => x.toString(16).padStart(2, '0')).join('')}`;
+}
+//# sourceMappingURL=skins.js.map