@lemoncat7/dsh-theme-xiaohei 0.3.0-alpha.22 → 0.3.1

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

@@ -0,0 +1,63 @@
+/** Demi-ecart des yeux sur la sphere, en degres (separation totale ~31deg). */
+export declare const EYE_SPLIT = 15.46;
+/** Taille de l'oeil au repos, en unites de rayon de boule. */
+export declare const EYE_W = 0.186;
+export declare const EYE_H = 0.412;
+/** Orientation de tete au repos, ajustee sur les frames de reference. */
+export declare const REST_GAZE: HeadGaze;
+export interface EyePose {
+    x: number;
+    y: number;
+    /** matrice tangente 2x2 : [a b c d] au sens SVG matrix(a,b,c,d,e,f) */
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    /** composante z de la normale : > 0 = face visible */
+    depth: number;
+}
+export interface HeadGaze {
+    /** lacet, degres, positif = regarde a droite */
+    yaw: number;
+    /** tangage, degres, positif = regarde en haut */
+    pitch: number;
+    /** roulis, degres, inclinaison de la tete */
+    roll: number;
+}
+/**
+ * Repere de la tete puis des deux yeux.
+ * Repere ecran : x a droite, y vers le bas, z vers le spectateur.
+ * L'indice 0 est l'oeil interieur, l'indice 1 l'oeil exterieur.
+ */
+export declare function eyePoses(gaze: HeadGaze, scale: number, split?: number): [EyePose, EyePose];
+/**
+ * Vie au repos : derive lente du regard, saccades, clignements.
+ *
+ * Fonction pure du temps (aucun etat interne), donc pause, reprise et saut a
+ * une date arbitraire donnent toujours la meme image. Les valeurs sont des
+ * ECARTS a ajouter a la pose de l'etat courant.
+ */
+export interface Liveliness {
+    dYaw: number;
+    dPitch: number;
+    dRoll: number;
+    /** 1 = oeil ouvert, 0 = ferme (ecrasement vertical en repere ecran) */
+    lid: number;
+    driftX: number;
+    driftY: number;
+    breath: number;
+}
+export interface LivelinessOptions {
+    wander?: number;
+    blink?: boolean;
+    float?: boolean;
+}
+export declare function liveliness(t: number, opt?: LivelinessOptions): Liveliness;
+/**
+ * Le clignement est un ecrasement VERTICAL en repere ecran autour du centre de
+ * l'oeil (mesure : la largeur de bbox est conservee, la hauteur tombe a ~0.35),
+ * pas un retrecissement le long de l'axe incline de la gelule. On le compose
+ * donc apres la matrice tangente, en n'affectant que les sorties en y.
+ */
+export declare function blinkScale(lid: number): number;
+//# sourceMappingURL=face.d.ts.map

package/lib/vendor/bloub/face.js

@@ -0,0 +1,106 @@
+// Adapted from bloub, Copyright (c) 2026 Jérémy Perret (MIT).
+// See THIRD_PARTY_NOTICES.md for source revision and local changes.
+import { clamp, createRng, loopNoise } from './math.js';
+/** Demi-ecart des yeux sur la sphere, en degres (separation totale ~31deg). */
+export const EYE_SPLIT = 15.46;
+/** Taille de l'oeil au repos, en unites de rayon de boule. */
+export const EYE_W = 0.186;
+export const EYE_H = 0.412;
+/** Orientation de tete au repos, ajustee sur les frames de reference. */
+export const REST_GAZE = { yaw: 28.49, pitch: 28.62, roll: -13 };
+const deg = (d) => (d * Math.PI) / 180;
+/** Fait tourner deux vecteurs d'un repere orthonorme dans leur plan commun. */
+function spin(u, v, angle) {
+    const c = Math.cos(angle);
+    const s = Math.sin(angle);
+    return [
+        [u[0] * c + v[0] * s, u[1] * c + v[1] * s, u[2] * c + v[2] * s],
+        [v[0] * c - u[0] * s, v[1] * c - u[1] * s, v[2] * c - u[2] * s]
+    ];
+}
+/**
+ * Repere de la tete puis des deux yeux.
+ * Repere ecran : x a droite, y vers le bas, z vers le spectateur.
+ * L'indice 0 est l'oeil interieur, l'indice 1 l'oeil exterieur.
+ */
+export function eyePoses(gaze, scale, split = EYE_SPLIT) {
+    let f = [0, 0, 1];
+    let right = [1, 0, 0];
+    let down = [0, 1, 0];
+    [f, right] = spin(f, right, deg(gaze.yaw));
+    [down, f] = spin(down, f, deg(gaze.pitch));
+    [right, down] = spin(right, down, deg(gaze.roll));
+    const build = (side) => {
+        const [ef, er] = spin(f, right, deg(split * side));
+        return {
+            x: ef[0] * scale,
+            y: ef[1] * scale,
+            a: er[0],
+            b: er[1],
+            c: down[0],
+            d: down[1],
+            depth: ef[2]
+        };
+    };
+    return [build(-1), build(1)];
+}
+const BLINK_RNG = createRng(0x5eed);
+/** Calendrier de clignements pre-tire : deterministe et sans etat. */
+const BLINKS = (() => {
+    const out = [];
+    let t = 1.4;
+    while (t < 900) {
+        out.push(t);
+        // 1.9 a 4.6 s entre deux clignements, plus un double clignement parfois
+        t += 1.9 + BLINK_RNG() * 2.7;
+        if (BLINK_RNG() < 0.18) {
+            out.push(t);
+            t += 0.24;
+        }
+    }
+    return out;
+})();
+/** Mesure : 1 a 2 frames a 10 fps. */
+const BLINK_DUR = 0.18;
+function blinkLid(t) {
+    // A desktop companion can remain mounted longer than the 15-minute demo.
+    t = ((t % 900) + 900) % 900;
+    for (let i = 0; i < BLINKS.length; i++) {
+        const start = BLINKS[i];
+        if (t < start)
+            break;
+        const k = (t - start) / BLINK_DUR;
+        if (k >= 0 && k <= 1) {
+            // fermeture rapide, reouverture un peu plus lente
+            return k < 0.45 ? 1 - k / 0.45 : (k - 0.45) / 0.55;
+        }
+    }
+    return 1;
+}
+export function liveliness(t, opt = {}) {
+    const { wander = 1, blink = true, float = true } = opt;
+    // Periodes premieres entre elles : la derive ne se repete jamais a l'oeil.
+    return {
+        dYaw: (loopNoise(t, 11.3, 0.4) * 5.5 + loopNoise(t, 3.7, 2.1) * 1.6) * wander,
+        dPitch: (loopNoise(t, 9.1, 1.3) * 4.2 + loopNoise(t, 4.3, 0.7) * 1.3) * wander,
+        dRoll: loopNoise(t, 13.7, 3.2) * 2.2 * wander,
+        lid: blink ? blinkLid(t) : 1,
+        // Au repos la video est quasiment immobile (centre stable a +-0.003, rayon
+        // constant) : toute la vie passe par le regard et les clignements. On garde
+        // juste de quoi ne pas figer completement l'image.
+        driftX: float ? loopNoise(t, 7.9, 1.9) * 0.006 : 0,
+        driftY: float ? loopNoise(t, 5.3, 0.3) * 0.007 : 0,
+        // La largeur est constante, seule la hauteur respire tres legerement.
+        breath: float ? 1 + Math.sin((t / 3.4) * Math.PI * 2) * 0.005 : 1
+    };
+}
+/**
+ * Le clignement est un ecrasement VERTICAL en repere ecran autour du centre de
+ * l'oeil (mesure : la largeur de bbox est conservee, la hauteur tombe a ~0.35),
+ * pas un retrecissement le long de l'axe incline de la gelule. On le compose
+ * donc apres la matrice tangente, en n'affectant que les sorties en y.
+ */
+export function blinkScale(lid) {
+    return 0.06 + 0.94 * clamp(lid);
+}
+//# sourceMappingURL=face.js.map

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

@@ -0,0 +1,22 @@
+export declare const TAU: number;
+export declare const clamp: (v: number, lo?: number, hi?: number) => number;
+export declare const lerp: (a: number, b: number, t: number) => number;
+export type Easing = (t: number) => number;
+/**
+ * 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 declare const easings: {
+    easeOutCubic: (t: number) => number;
+    easeInOutCubic: (t: number) => number;
+    easeOutQuint: (t: number) => number;
+};
+/** Bruit 1D periodique : boucle sans couture sur `period`, utile pour la derive du regard. */
+export declare function loopNoise(t: number, period: number, seed?: number): number;
+/** PRNG deterministe (mulberry32) : meme sequence a chaque lecture. */
+export declare function createRng(seed: number): () => number;
+/** Arrondi court : divise par ~2 le poids des chaines de path generees a 60 fps. */
+export declare const r2: (v: number) => number;
+//# sourceMappingURL=math.d.ts.map

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