@juspay/svelte-ui-components 4.33.2 → 4.33.3

package/dist/ThinkingOrb/orb/modes/form.js

@@ -11,7 +11,7 @@
  * split keeps "the shape's own motion" and "the camera's fixed angle on it"
  * from tangling together in the per-dot math.
  */
-import { easeInOutCubic, hashUnit, modeSizing, project, rotateX, rotateY, rotateZ } from '../space';
+import { easeInOutCubic, hashUnit, modeSizing, project, rotateX, rotateY, rotateZ, sampleSphere } from '../space';
 const TWO_PI = Math.PI * 2;
 /** The shared "reads as a form inside a square" contract: radius as a share of `size`. */
 const FORM_RADIUS_RATIO = 0.4;
@@ -45,7 +45,11 @@ const EMPTY_STROKES = [];
 // --- composing ---------------------------------------------------------
 /** Dots along each thread at 64px; `countAlongPath` keeps their spacing as the canvas shrinks. */
 const RIBBON_PER_THREAD_BASE = 36;
-const RIBBON_BASE_DOT_RADIUS = 2.2;
+/** Reference parity (BZ-6466 follow-up): upstream thinking-orbs' `ribbon` mode resolves to a
+ * ~0.9-1.1px base dot radius at 64px (its BASE_PROFILES rBase 1.1, x0.85 for this preset's `size`
+ * multiplier). This used to carry 2.2px, exactly the radius that fused composing's dots into a
+ * solid corrugated band instead of the reference's fine, individually-visible beads. */
+const RIBBON_BASE_DOT_RADIUS = 1.2;
 /** Fewer, narrower threads than a full band: at 7 threads across 0.4 rad the 64px ribbon covered
  * most of the sphere and read as a filled ball rather than a strip of cloth. */
 const RIBBON_THREADS = { 64: 5, 32: 4, 20: 3 };
@@ -68,6 +72,16 @@ const RIBBON_CAMERA_TILT = 0.45;
  * combined ink/alpha/radius fade would collapse an edge row to a speck. */
 const RIBBON_EDGE_ALPHA_FLOOR = 0.5;
 const RIBBON_EDGE_INK_LIFT = 0.22;
+/** Reference parity (BZ-6466 follow-up): upstream's `ribbon` mode fills the sphere behind the band
+ * with a faint, fully static "ghost" texture (150 dots at 64px, this preset's `spin: 0` freezing
+ * even the shared camera precession that would otherwise turn it). Ours had no such backing layer,
+ * so the ribbon read as a thin strip floating in empty space rather than cloth wrapped on a solid
+ * form -- the ribbon's own turn was the only motion on screen, with nothing to anchor it against. */
+const RIBBON_GHOST_BASE_COUNT = 110;
+const RIBBON_GHOST_RADIUS_PX = 0.5;
+const RIBBON_GHOST_INK = 0.3;
+const RIBBON_GHOST_ALPHA_BASE = 0.16;
+const RIBBON_GHOST_ALPHA_DEPTH = 0.22;
 /**
  * A ribbon of dots looped once around the sphere on its own tilted great
  * circle -- distinct from the spin axis -- rippling along its length like a
@@ -80,7 +94,20 @@ export const composing = (t, ctx) => {
     const threads = RIBBON_THREADS[ctx.size];
     const perThread = sizing.countAlongPath(RIBBON_PER_THREAD_BASE);
     const total = threads * perThread;
-    const dots = [];
+    const ghostCount = Math.max(20, sizing.count(RIBBON_GHOST_BASE_COUNT));
+    const dots = Array.from({ length: ghostCount }, (_unused, i) => {
+        const point = sampleSphere(i, ghostCount, worldRadius);
+        const tilted = rotateX(point, RIBBON_CAMERA_TILT);
+        const projected = project(tilted, originPx, worldRadius);
+        return {
+            x: projected.x,
+            y: projected.y,
+            depth: projected.depth,
+            radius: sizing.radius(RIBBON_GHOST_RADIUS_PX),
+            ink: RIBBON_GHOST_INK,
+            alpha: clamp01(RIBBON_GHOST_ALPHA_BASE + RIBBON_GHOST_ALPHA_DEPTH * projected.depth)
+        };
+    });
     for (let index = 0; index < total; index += 1) {
         const thread = index % threads;
         const step = Math.floor(index / threads);

package/dist/ThinkingOrb/orb/modes/network.d.ts

@@ -6,7 +6,11 @@
  * projection setup below.
  */
 import type { ModeFn } from '../types';
+import type { ModeSizing } from '../space';
 /** A few nodes on a sphere; lines to near neighbours carry small travelling pulses. */
 export declare const connecting: ModeFn;
+/** Exported so tests that index `weaving`'s strand dots can reproduce and slice off this count,
+ * rather than duplicating the formula as a hardcoded literal. */
+export declare const weavingGhostCount: (sizing: ModeSizing) => number;
 /** Three closed strands wrapped around a sphere, crossing over and under each other as they turn. */
 export declare const weaving: ModeFn;

package/dist/ThinkingOrb/orb/modes/network.js

@@ -144,6 +144,21 @@ const STRAND_DOT_SIZE_FACTOR = { 64: 1, 32: 0.85, 20: 0.7 };
 const STRAND_DEPTH_INK = 0.45;
 /** A slight per-strand shade; the paths and their over/under crossings are what separate them. */
 const STRAND_SHADE_STEP = 0.1;
+/** Reference parity (BZ-6466 follow-up): upstream's `braid` mode fills the sphere behind the
+ * strands with a faint, static-in-object-space "ghost" texture (150 dots at 64px) that shares the
+ * strands' own turn, so the strands read as plaiting round a solid ball rather than floating loops
+ * in empty space. Ours had no such backing layer. Always appended after every strand's dots, so
+ * code and tests that index `dots` by strand can slice it off by a known, reproducible count. */
+const STRAND_GHOST_BASE_COUNT = 110;
+const STRAND_GHOST_RADIUS_PX = 0.5;
+const STRAND_GHOST_INK = 0.3;
+/** With STRAND_GHOST_INK 0.3, `inkAlpha` = (1-ink)*alpha = 0.7*alpha, so this needs to clear
+ * 0.1/0.7 for the "nothing paints below 10% opacity" contract even on a ghost dot's far side. */
+const STRAND_GHOST_ALPHA_BASE = 0.16;
+const STRAND_GHOST_ALPHA_DEPTH = 0.22;
+/** Exported so tests that index `weaving`'s strand dots can reproduce and slice off this count,
+ * rather than duplicating the formula as a hardcoded literal. */
+export const weavingGhostCount = (sizing) => Math.max(20, sizing.count(STRAND_GHOST_BASE_COUNT));
 const strandBaseAngle = (strand) => (strand / STRAND_COUNT) * Math.PI * 2;
 /**
  * The `pointIndex`-th of `pointsPerStrand` points around closed `strand`: a
@@ -192,5 +207,22 @@ export const weaving = (t, ctx) => {
             alpha: 0.6 + depth * 0.35
         };
     }));
-    return { dots, strokes };
+    // Shares the strands' own spin+tilt (not their per-strand inclination/phase, which is strand
+    // geometry, not camera) so the backdrop turns together with what it is behind.
+    const ghostCount = weavingGhostCount(sizing);
+    const ghosts = Array.from({ length: ghostCount }, (_unused, i) => {
+        const point = sampleSphere(i, ghostCount, sphereRadius);
+        const spun = rotateY(point, t * STRAND_ROTATE_SPEED);
+        const tilted = rotateX(spun, STRAND_TILT);
+        const projected = project(tilted, originPx, sphereRadius);
+        return {
+            x: projected.x,
+            y: projected.y,
+            depth: projected.depth,
+            radius: sizing.radius(STRAND_GHOST_RADIUS_PX),
+            ink: STRAND_GHOST_INK,
+            alpha: clamp01(STRAND_GHOST_ALPHA_BASE + STRAND_GHOST_ALPHA_DEPTH * projected.depth)
+        };
+    });
+    return { dots: [...dots, ...ghosts], strokes };
 };

package/dist/ThinkingOrb/orb/modes/sphere.js

@@ -44,19 +44,33 @@ const toStroke = (from, to, width, ink, alpha) => ({
 /** Particles travel in short trailing arcs ("trains") rather than scattering
  * independently around their orbit -- a lone random phase per particle reads
  * as noise once density thins the count out at 32/20px, while a handful of
- * particles held close together always reads as motion along a path. */
-const WORKING_TRAIN_BASE_COUNT = 22;
+ * particles held close together always reads as motion along a path.
+ *
+ * Reference parity (BZ-6466 follow-up): the upstream thinking-orbs `orbits`
+ * mode this was ported from draws 12 orbits x 3 particles = 36 marks at
+ * 64px, radius ~1.2px, and reads as a sparse field of distinct particles.
+ * The previous tuning here (22 trains x 5-long, radius 2.2px = 110 marks)
+ * packed 3x the marks at ~1.7x the radius into the same arcs, so consecutive
+ * dots overlapped their own diameter and the whole thing fused into a
+ * blurred scribble instead of scattered points. */
+const WORKING_TRAIN_BASE_COUNT = 12;
 /** Keeps at least this many short arcs on screen at 64px (32/20px use WORKING_SMALL_LAYOUT). The
  * area scaler alone already clears it at the default density; it only bites when density is low. */
 const WORKING_MIN_TRAINS_64 = 3;
-const WORKING_TRAIN_LENGTH = 5;
+const WORKING_TRAIN_LENGTH = 3;
 /** How far apart, in radians, a train's particles trail behind its lead --
  * wide enough to read as a short curved arc, short enough to stay a cluster
  * rather than smearing back into the full-orbit scatter this replaces. */
 const WORKING_TRAIN_ARC_SPAN = 0.5;
-/** At 1.6, with a +/-25% jitter, 20px dots came out 0.6-1px across and the arcs blurred into a
- * smudge; this and the narrower jitter below keep a train a visible stroke at every size. */
-const WORKING_BASE_RADIUS_PX = 2.2;
+/** Reference's `orbits` mode draws particles at ~1.2px on a 64px canvas but scales them back UP
+ * at smaller sizes (2.4x at 20px) rather than shrinking further, so they stay legible once there's
+ * less room for arc spacing to keep them apart. `sizing.radius`'s sub-linear shrink-with-a-floor
+ * goes the other way, so the two sizes need their own base rather than one shared constant. */
+const WORKING_BASE_RADIUS_PX = 1.3;
+/** 32/20px (WORKING_SMALL_LAYOUT): kept at this mode's original, pre-reference-parity radius --
+ * these sizes weren't the fused-blur regression 64px was, and shrinking to match 64px's new,
+ * smaller radius here would drop dots below a legible stroke width. */
+const WORKING_SMALL_BASE_RADIUS_PX = 2.2;
 const WORKING_ORBIT_COUNT = 6;
 const WORKING_ANGULAR_SPEED = 1.1;
 /** How far an orbit's `weight` can push its dots' ink away from the shared
@@ -68,6 +82,17 @@ const WORKING_ORBIT_ALPHA_FLOOR = 0.65;
 /** A train's trailing-most particle never fades past this floor, so the arc's
  * tail stays legible instead of thinning away to nothing. */
 const WORKING_TRAIL_ALPHA_FLOOR = 0.35;
+/** Reference parity (BZ-6466 follow-up): upstream's `orbits` mode traces each orbit's full circle
+ * as a faint, static "ghost" ring of many dots (40 per orbit at 64px) UNDER the few bright
+ * travelling particles -- about 13x as many ghost dots as particles, so the ring lattice anchors
+ * the silhouette and the particles read as a sparkle on top of it. Ours had no such layer: every
+ * visible dot was one of the sweeping particles, so with only 6-22 of them the whole silhouette
+ * reshaped every frame instead of holding a roughly stable shape -- the actual "fluidity" gap a
+ * static/moving frame comparison alone doesn't show. */
+const WORKING_GHOST_DOTS_PER_ORBIT = 40;
+const WORKING_GHOST_RADIUS_PX = 0.7;
+const WORKING_GHOST_INK = 0.4;
+const WORKING_GHOST_ALPHA = 0.5;
 /** Every particle's own orbital plane, radius, pace and shading weight, keyed by its orbit. */
 const workingOrbit = (orbit) => {
     const seed = orbit * 31 + 7;
@@ -84,8 +109,10 @@ const workingOrbit = (orbit) => {
  * the view axis (like an atom symbol) and give each train a long arc, so every train draws a
  * visible curve and the separate orbits stay readable. */
 const WORKING_SMALL_LAYOUT = {
-    32: { orbits: 4, trainLength: 6, arcSpan: 1 },
-    20: { orbits: 3, trainLength: 7, arcSpan: 1.25 }
+    // Shorter trains than before (was 6/7): at the smaller shared radius above, a longer train's
+    // dots sat closer together than their own diameter and fused the same way 64px did.
+    32: { orbits: 4, trainLength: 4, arcSpan: 0.75 },
+    20: { orbits: 3, trainLength: 4, arcSpan: 0.9 }
 };
 /** How far each small-size orbit tips out of edge-on. Its projection is an ellipse sin(tilt) as
  * tall as it is wide; near 1 rad every orbit projects to nearly the same circle and rolling it
@@ -147,10 +174,32 @@ export const working = (t, ctx) => {
                 (orbit.weight - 0.5) * WORKING_ORBIT_INK_SPREAD;
             const alpha = (WORKING_TRAIL_ALPHA_FLOOR + (1 - WORKING_TRAIL_ALPHA_FLOOR) * trail) *
                 (WORKING_ORBIT_ALPHA_FLOOR + (1 - WORKING_ORBIT_ALPHA_FLOOR) * orbit.weight);
-            const radius = sizing.radius(WORKING_BASE_RADIUS_PX) * (0.9 + 0.25 * hashUnit(seed + 3));
+            const radiusBase = small ? WORKING_SMALL_BASE_RADIUS_PX : WORKING_BASE_RADIUS_PX;
+            const radius = sizing.radius(radiusBase) * (0.9 + 0.25 * hashUnit(seed + 3));
             dots.push(toDot(projected, radius, ink, alpha));
         }
     }
+    // 64px only: 32/20px already anchor their orbits with the faint stroke path below, drawn for
+    // every size in WORKING_SMALL_LAYOUT.
+    if (!small) {
+        const ghostDotsPerOrbit = Math.max(8, sizing.countAlongPath(WORKING_GHOST_DOTS_PER_ORBIT));
+        for (let orbitIndex = 0; orbitIndex < WORKING_ORBIT_COUNT; orbitIndex += 1) {
+            const orbit = workingOrbit(orbitIndex);
+            const orbitRadius = worldRadius * orbit.orbitRadiusFactor;
+            for (let k = 0; k < ghostDotsPerOrbit; k += 1) {
+                const angle = (k / ghostDotsPerOrbit) * TWO_PI;
+                const planar = {
+                    x: Math.cos(angle) * orbitRadius,
+                    y: 0,
+                    z: Math.sin(angle) * orbitRadius
+                };
+                const tilted = rotateX(planar, orbit.tilt);
+                const point = rotateZ(tilted, orbit.roll);
+                const projected = project(point, origin, worldRadius);
+                dots.push(toDot(projected, sizing.radius(WORKING_GHOST_RADIUS_PX), WORKING_GHOST_INK, WORKING_GHOST_ALPHA * (0.4 + 0.6 * projected.depth)));
+            }
+        }
+    }
     const paths = small
         ? Array.from({ length: small.orbits }, (_unused, orbitIndex) => {
             const orbit = workingSmallOrbit(orbitIndex, small.orbits);
@@ -236,10 +285,16 @@ export const searching = (t, ctx) => {
 };
 // ---------------------------------------------------------------------------
 // solving -- tiers that snap a quarter turn out of alignment, hold scrambled,
-// then resolve back, on a loop. Landmark dots and fixed seam rings make the
-// misalignment legible: an otherwise-uniform, evenly-sampled dot texture
-// looks identical under any rotation about the spin axis, so turning a
-// "band" of it invisibly wouldn't read as scrambling at all.
+// then resolve back, on a loop. Each tier's own texture dots rotate with it
+// (reference parity, BZ-6466 follow-up: matching upstream thinking-orbs'
+// `rubik`, which reads solved-vs-scrambled off this same per-band rotation
+// alone), so the misalignment shows as a visible discontinuity in the dot
+// pattern itself; oversized landmark dots add a brighter set of accent
+// points per tier. An earlier tuning also drew fixed seam rings and
+// per-landmark meridian strokes to make the misalignment legible, but next
+// to the reference that wireframe read as a busy skeleton the upstream
+// version doesn't have, so it's gone -- the texture's own rotation already
+// carries the same information.
 // ---------------------------------------------------------------------------
 const SOLVING_BASE_COUNT = 130;
 const SOLVING_BASE_RADIUS_PX = 1.5;
@@ -260,23 +315,6 @@ const SOLVING_LANDMARK_PHASE = hashUnit(5) * TWO_PI;
 const SOLVING_LANDMARK_RADIUS_PX = 3.1;
 const SOLVING_LANDMARK_INK_BOOST = 0.45;
 const SOLVING_LANDMARK_ALPHA = 0.9;
-/** Each landmark also draws a short meridian stroke spanning its tier. Solved, the strokes of all
- * tiers join into three unbroken vertical lines; a turned tier's strokes jump sideways and break
- * the lines into a visible staircase. Held scrambled, loose landmark dots alone still formed tidy
- * columns of their own and read as just another solved pose. */
-const SOLVING_MERIDIAN_POINTS_PER_TIER = 3;
-const SOLVING_MERIDIAN_WIDTH_PX = 1.6;
-const SOLVING_MERIDIAN_INK_BOOST = 0.35;
-const SOLVING_MERIDIAN_ALPHA = 0.85;
-/** The meridians stop this far short of the poles, where all three would otherwise converge. */
-const SOLVING_MERIDIAN_Y_LIMIT = 0.9;
-/** A static ring of short strokes at each cut between tiers, unaffected by
- * any turn, so the "cut into bands" structure reads even while the puzzle
- * sits solved and nothing is moving. */
-const SOLVING_SEAM_SEGMENTS = 12;
-const SOLVING_SEAM_STROKE_RADIUS = 1.05;
-const SOLVING_SEAM_INK = 0.15;
-const SOLVING_SEAM_ALPHA = 0.5;
 const solvingTurnStart = (tier) => tier * SOLVING_TURN_GAP;
 const solvingTurnEnd = (tier) => solvingTurnStart(tier) + SOLVING_TURN_DURATION;
 const SOLVING_HOLD_START = solvingTurnEnd(SOLVING_TIER_COUNT - 1) + SOLVING_HOLD_GAP;
@@ -310,8 +348,6 @@ const solvingTierOf = (yUnit) => clamp(Math.floor(((1 - yUnit) / 2) * SOLVING_TI
 const solvingTierDirection = (tier) => (hashUnit(tier * 53 + 21) < 0.5 ? -1 : 1);
 /** The y-unit (-1..1) at the centre of a tier's latitude band. */
 const solvingTierCenterYUnit = (tier) => 1 - (2 * tier + 1) / SOLVING_TIER_COUNT;
-/** The y-unit (-1..1) of the fixed cut between one tier and the next. */
-const solvingSeamYUnit = (seam) => 1 - (2 * (seam + 1)) / SOLVING_TIER_COUNT;
 const solvingTurnAngle = (tier, cyclePos) => solvingTierTurn(tier, cyclePos) * solvingTierDirection(tier) * (Math.PI / 2);
 export const solving = (t, ctx) => {
     const sizing = modeSizing(ctx.size, ctx.density, ctx.dotScale);
@@ -349,47 +385,7 @@ export const solving = (t, ctx) => {
         const ink = shadeByDepth(projected.depth) - SOLVING_LANDMARK_INK_BOOST;
         return toDot(projected, sizing.radius(SOLVING_LANDMARK_RADIUS_PX), ink, SOLVING_LANDMARK_ALPHA);
     });
-    const seamWidth = sizing.radius(SOLVING_SEAM_STROKE_RADIUS);
-    const seams = Array.from({ length: SOLVING_TIER_COUNT - 1 }, (_unused, seam) => {
-        const yUnit = solvingSeamYUnit(seam);
-        const y = yUnit * worldRadius;
-        const ringRadius = Math.sqrt(Math.max(0, 1 - yUnit * yUnit)) * worldRadius;
-        const ringPoints = Array.from({ length: SOLVING_SEAM_SEGMENTS + 1 }, (_unusedPoint, j) => {
-            const angle = (j / SOLVING_SEAM_SEGMENTS) * TWO_PI;
-            const point = {
-                x: Math.cos(angle) * ringRadius,
-                y,
-                z: Math.sin(angle) * ringRadius
-            };
-            return project(rotateX(point, SOLVING_TILT), origin, worldRadius);
-        });
-        return Array.from({ length: SOLVING_SEAM_SEGMENTS }, (_unusedSegment, j) => toStroke(ringPoints[j], ringPoints[j + 1], seamWidth, SOLVING_SEAM_INK, SOLVING_SEAM_ALPHA));
-    }).flat();
-    const meridianWidth = sizing.radius(SOLVING_MERIDIAN_WIDTH_PX);
-    const meridians = Array.from({ length: SOLVING_TIER_COUNT * SOLVING_LANDMARKS_PER_TIER }, (_unused, i) => {
-        const tier = Math.floor(i / SOLVING_LANDMARKS_PER_TIER);
-        const slot = i % SOLVING_LANDMARKS_PER_TIER;
-        const longitude = SOLVING_LANDMARK_PHASE + (slot / SOLVING_LANDMARKS_PER_TIER) * TWO_PI;
-        const topYUnit = Math.min(SOLVING_MERIDIAN_Y_LIMIT, 1 - (2 * tier) / SOLVING_TIER_COUNT);
-        const bottomYUnit = Math.max(-SOLVING_MERIDIAN_Y_LIMIT, 1 - (2 * (tier + 1)) / SOLVING_TIER_COUNT);
-        const points = Array.from({ length: SOLVING_MERIDIAN_POINTS_PER_TIER }, (_unusedPoint, j) => {
-            const yUnit = topYUnit + ((bottomYUnit - topYUnit) * j) / (SOLVING_MERIDIAN_POINTS_PER_TIER - 1);
-            const ringRadius = Math.sqrt(Math.max(0, 1 - yUnit * yUnit)) * worldRadius;
-            const base = {
-                x: Math.cos(longitude) * ringRadius,
-                y: yUnit * worldRadius,
-                z: Math.sin(longitude) * ringRadius
-            };
-            const turned = rotateY(base, solvingTurnAngle(tier, cyclePos));
-            return project(rotateX(turned, SOLVING_TILT), origin, worldRadius);
-        });
-        return points.slice(1).map((to, j) => {
-            const from = points[j];
-            const depth = (from.depth + to.depth) / 2;
-            return toStroke(from, to, meridianWidth, shadeByDepth(depth) - SOLVING_MERIDIAN_INK_BOOST, SOLVING_MERIDIAN_ALPHA);
-        });
-    }).flat();
-    return { dots: [...texture, ...landmarks], strokes: [...seams, ...meridians] };
+    return { dots: [...texture, ...landmarks], strokes: [] };
 };
 // ---------------------------------------------------------------------------
 // listening -- stacked horizontal rings with a wave rolling through them

package/dist-wc/index.js

@@ -24079,7 +24079,7 @@ var clamp01$5 = (e) => Math.max(0, Math.min(1, e)), rotateX = (e, t) => {
 	width: n,
 	ink: clamp01$2(i),
 	alpha: clamp01$2(a)
-}), WORKING_TRAIN_BASE_COUNT = 22, WORKING_MIN_TRAINS_64 = 3, WORKING_TRAIN_LENGTH = 5, WORKING_TRAIN_ARC_SPAN = .5, WORKING_BASE_RADIUS_PX = 2.2, WORKING_ORBIT_COUNT = 6, WORKING_ANGULAR_SPEED = 1.1, WORKING_ORBIT_INK_SPREAD = .3, WORKING_ORBIT_ALPHA_FLOOR = .65, WORKING_TRAIL_ALPHA_FLOOR = .35, workingOrbit = (e) => {
+}), WORKING_TRAIN_BASE_COUNT = 12, WORKING_MIN_TRAINS_64 = 3, WORKING_TRAIN_LENGTH = 3, WORKING_TRAIN_ARC_SPAN = .5, WORKING_BASE_RADIUS_PX = 1.3, WORKING_SMALL_BASE_RADIUS_PX = 2.2, WORKING_ORBIT_COUNT = 6, WORKING_ANGULAR_SPEED = 1.1, WORKING_ORBIT_INK_SPREAD = .3, WORKING_ORBIT_ALPHA_FLOOR = .65, WORKING_TRAIL_ALPHA_FLOOR = .35, WORKING_GHOST_DOTS_PER_ORBIT = 40, WORKING_GHOST_RADIUS_PX = .7, WORKING_GHOST_INK = .4, WORKING_GHOST_ALPHA = .5, workingOrbit = (e) => {
 	let t = e * 31 + 7;
 	return {
 		tilt: (hashUnit(t) - .5) * Math.PI,
@@ -24091,13 +24091,13 @@ var clamp01$5 = (e) => Math.max(0, Math.min(1, e)), rotateX = (e, t) => {
 }, WORKING_SMALL_LAYOUT = {
 	32: {
 		orbits: 4,
-		trainLength: 6,
-		arcSpan: 1
+		trainLength: 4,
+		arcSpan: .75
 	},
 	20: {
 		orbits: 3,
-		trainLength: 7,
-		arcSpan: 1.25
+		trainLength: 4,
+		arcSpan: .9
 	}
 }, WORKING_SMALL_ORBIT_TILT = .5, WORKING_PATH_SEGMENTS = 24, WORKING_PATH_WIDTH_PX = .8, WORKING_PATH_INK = .5, WORKING_PATH_ALPHA = .45, WORKING_SMALL_ORBIT_RADIUS = .85, WORKING_SMALL_SPEEDS = [
 	.8,
@@ -24115,12 +24115,26 @@ var clamp01$5 = (e) => Math.max(0, Math.min(1, e)), rotateX = (e, t) => {
 	for (let t = 0; t < c; t += 1) {
 		let c = o ? workingSmallOrbit(t % o.orbits, o.orbits) : workingOrbit(t % WORKING_ORBIT_COUNT), p = (o ? Math.floor(t / o.orbits) / s * TWO_PI$1 + t % o.orbits * .9 : hashUnit(t * 5 + 1) * TWO_PI$1) + e * WORKING_ANGULAR_SPEED * c.speedFactor, h = a * c.orbitRadiusFactor;
 		for (let e = 0; e < l; e += 1) {
-			let o = p - e * u, s = project(rotateZ(rotateX({
-				x: Math.cos(o) * h,
+			let s = p - e * u, S = project(rotateZ(rotateX({
+				x: Math.cos(s) * h,
 				y: 0,
-				z: Math.sin(o) * h
-			}, c.tilt), c.roll), i, a), S = t * 13 + e * 7 + 2, C = 1 - e / (l - 1), k = shadeByDepth(s.depth) + (hashUnit(S) - .5) * .08 - (c.weight - .5) * WORKING_ORBIT_INK_SPREAD, R = (WORKING_TRAIL_ALPHA_FLOOR + (1 - WORKING_TRAIL_ALPHA_FLOOR) * C) * (WORKING_ORBIT_ALPHA_FLOOR + (1 - WORKING_ORBIT_ALPHA_FLOOR) * c.weight), te = n.radius(WORKING_BASE_RADIUS_PX) * (.9 + .25 * hashUnit(S + 3));
-			f.push(toDot(s, te, k, R));
+				z: Math.sin(s) * h
+			}, c.tilt), c.roll), i, a), C = t * 13 + e * 7 + 2, k = 1 - e / (l - 1), R = shadeByDepth(S.depth) + (hashUnit(C) - .5) * .08 - (c.weight - .5) * WORKING_ORBIT_INK_SPREAD, te = (WORKING_TRAIL_ALPHA_FLOOR + (1 - WORKING_TRAIL_ALPHA_FLOOR) * k) * (WORKING_ORBIT_ALPHA_FLOOR + (1 - WORKING_ORBIT_ALPHA_FLOOR) * c.weight), ne = o ? WORKING_SMALL_BASE_RADIUS_PX : WORKING_BASE_RADIUS_PX, re = n.radius(ne) * (.9 + .25 * hashUnit(C + 3));
+			f.push(toDot(S, re, R, te));
+		}
+	}
+	if (!o) {
+		let e = Math.max(8, n.countAlongPath(WORKING_GHOST_DOTS_PER_ORBIT));
+		for (let t = 0; t < WORKING_ORBIT_COUNT; t += 1) {
+			let o = workingOrbit(t), s = a * o.orbitRadiusFactor;
+			for (let t = 0; t < e; t += 1) {
+				let c = t / e * TWO_PI$1, l = project(rotateZ(rotateX({
+					x: Math.cos(c) * s,
+					y: 0,
+					z: Math.sin(c) * s
+				}, o.tilt), o.roll), i, a);
+				f.push(toDot(l, n.radius(WORKING_GHOST_RADIUS_PX), WORKING_GHOST_INK, WORKING_GHOST_ALPHA * (.4 + .6 * l.depth)));
+			}
 		}
 	}
 	return {
@@ -24156,10 +24170,10 @@ var clamp01$5 = (e) => Math.max(0, Math.min(1, e)), rotateX = (e, t) => {
 		dots: c,
 		strokes: Array.from({ length: SEARCHING_ARC_SEGMENTS }, (e, t) => toStroke(l[t], l[t + 1], u, SEARCHING_ARC_INK, SEARCHING_ARC_ALPHA))
 	};
-}, SOLVING_BASE_COUNT = 130, SOLVING_BASE_RADIUS_PX = 1.5, SOLVING_TIER_COUNT = 4, SOLVING_TURN_DURATION = .16, SOLVING_TURN_GAP = .3, SOLVING_HOLD_GAP = .55, SOLVING_TILT = -.5, SOLVING_LANDMARKS_PER_TIER = 3, SOLVING_LANDMARK_PHASE = hashUnit(5) * TWO_PI$1, SOLVING_LANDMARK_RADIUS_PX = 3.1, SOLVING_LANDMARK_INK_BOOST = .45, SOLVING_LANDMARK_ALPHA = .9, SOLVING_MERIDIAN_POINTS_PER_TIER = 3, SOLVING_MERIDIAN_WIDTH_PX = 1.6, SOLVING_MERIDIAN_INK_BOOST = .35, SOLVING_MERIDIAN_ALPHA = .85, SOLVING_MERIDIAN_Y_LIMIT = .9, SOLVING_SEAM_SEGMENTS = 12, SOLVING_SEAM_STROKE_RADIUS = 1.05, SOLVING_SEAM_INK = .15, SOLVING_SEAM_ALPHA = .5, solvingTurnStart = (e) => e * SOLVING_TURN_GAP, solvingTurnEnd = (e) => solvingTurnStart(e) + SOLVING_TURN_DURATION, SOLVING_HOLD_START = solvingTurnEnd(SOLVING_TIER_COUNT - 1) + SOLVING_HOLD_GAP, solvingReturnStart = (e) => SOLVING_HOLD_START + (SOLVING_TIER_COUNT - 1 - e) * SOLVING_TURN_GAP, solvingReturnEnd = (e) => solvingReturnStart(e) + SOLVING_TURN_DURATION, SOLVING_CYCLE = solvingReturnEnd(0) + SOLVING_HOLD_GAP, solvingTierTurn = (e, t) => {
+}, SOLVING_BASE_COUNT = 130, SOLVING_BASE_RADIUS_PX = 1.5, SOLVING_TIER_COUNT = 4, SOLVING_TURN_DURATION = .16, SOLVING_TURN_GAP = .3, SOLVING_HOLD_GAP = .55, SOLVING_TILT = -.5, SOLVING_LANDMARKS_PER_TIER = 3, SOLVING_LANDMARK_PHASE = hashUnit(5) * TWO_PI$1, SOLVING_LANDMARK_RADIUS_PX = 3.1, SOLVING_LANDMARK_INK_BOOST = .45, SOLVING_LANDMARK_ALPHA = .9, solvingTurnStart = (e) => e * SOLVING_TURN_GAP, solvingTurnEnd = (e) => solvingTurnStart(e) + SOLVING_TURN_DURATION, SOLVING_HOLD_START = solvingTurnEnd(SOLVING_TIER_COUNT - 1) + SOLVING_HOLD_GAP, solvingReturnStart = (e) => SOLVING_HOLD_START + (SOLVING_TIER_COUNT - 1 - e) * SOLVING_TURN_GAP, solvingReturnEnd = (e) => solvingReturnStart(e) + SOLVING_TURN_DURATION, SOLVING_CYCLE = solvingReturnEnd(0) + SOLVING_HOLD_GAP, solvingTierTurn = (e, t) => {
 	let n = solvingTurnStart(e), i = solvingTurnEnd(e), a = solvingReturnStart(e), o = solvingReturnEnd(e);
 	return t <= n ? 0 : t < i ? easeOutCubic((t - n) / SOLVING_TURN_DURATION) : t < a ? 1 : t < o ? 1 - easeInOutCubic((t - a) / SOLVING_TURN_DURATION) : 0;
-}, solvingTierOf = (e) => clamp$1(Math.floor((1 - e) / 2 * SOLVING_TIER_COUNT), 0, SOLVING_TIER_COUNT - 1), solvingTierDirection = (e) => hashUnit(e * 53 + 21) < .5 ? -1 : 1, solvingTierCenterYUnit = (e) => 1 - (2 * e + 1) / SOLVING_TIER_COUNT, solvingSeamYUnit = (e) => 1 - 2 * (e + 1) / SOLVING_TIER_COUNT, solvingTurnAngle = (e, t) => solvingTierTurn(e, t) * solvingTierDirection(e) * (Math.PI / 2), solving = (e, t) => {
+}, solvingTierOf = (e) => clamp$1(Math.floor((1 - e) / 2 * SOLVING_TIER_COUNT), 0, SOLVING_TIER_COUNT - 1), solvingTierDirection = (e) => hashUnit(e * 53 + 21) < .5 ? -1 : 1, solvingTierCenterYUnit = (e) => 1 - (2 * e + 1) / SOLVING_TIER_COUNT, solvingTurnAngle = (e, t) => solvingTierTurn(e, t) * solvingTierDirection(e) * (Math.PI / 2), solving = (e, t) => {
 	let n = modeSizing(t.size, t.density, t.dotScale), i = originOf(t), a = worldRadiusOf(t), o = n.count(SOLVING_BASE_COUNT), s = e - SOLVING_CYCLE * Math.floor(e / SOLVING_CYCLE), c = Array.from({ length: o }, (e, t) => {
 		let c = sampleSphere(t, o, a), l = project(rotateX(rotateY(c, solvingTurnAngle(solvingTierOf(a > 0 ? c.y / a : 0), s)), SOLVING_TILT), i, a), u = shadeByDepth(l.depth), f = .55 + .3 * hashUnit(t * 3 + 9);
 		return toDot(l, n.radius(SOLVING_BASE_RADIUS_PX), u, f);
@@ -24170,33 +24184,10 @@ var clamp01$5 = (e) => Math.max(0, Math.min(1, e)), rotateX = (e, t) => {
 			z: Math.sin(p) * f
 		}, solvingTurnAngle(o, s)), SOLVING_TILT), i, a), S = shadeByDepth(h.depth) - SOLVING_LANDMARK_INK_BOOST;
 		return toDot(h, n.radius(SOLVING_LANDMARK_RADIUS_PX), S, SOLVING_LANDMARK_ALPHA);
-	}), u = n.radius(SOLVING_SEAM_STROKE_RADIUS), f = Array.from({ length: SOLVING_TIER_COUNT - 1 }, (e, t) => {
-		let n = solvingSeamYUnit(t), o = n * a, s = Math.sqrt(Math.max(0, 1 - n * n)) * a, c = Array.from({ length: 13 }, (e, t) => {
-			let n = t / SOLVING_SEAM_SEGMENTS * TWO_PI$1;
-			return project(rotateX({
-				x: Math.cos(n) * s,
-				y: o,
-				z: Math.sin(n) * s
-			}, SOLVING_TILT), i, a);
-		});
-		return Array.from({ length: SOLVING_SEAM_SEGMENTS }, (e, t) => toStroke(c[t], c[t + 1], u, SOLVING_SEAM_INK, SOLVING_SEAM_ALPHA));
-	}).flat(), p = n.radius(SOLVING_MERIDIAN_WIDTH_PX), h = Array.from({ length: SOLVING_TIER_COUNT * SOLVING_LANDMARKS_PER_TIER }, (e, t) => {
-		let n = Math.floor(t / SOLVING_LANDMARKS_PER_TIER), o = SOLVING_LANDMARK_PHASE + t % SOLVING_LANDMARKS_PER_TIER / SOLVING_LANDMARKS_PER_TIER * TWO_PI$1, c = Math.min(SOLVING_MERIDIAN_Y_LIMIT, 1 - 2 * n / SOLVING_TIER_COUNT), l = Math.max(-.9, 1 - 2 * (n + 1) / SOLVING_TIER_COUNT), u = Array.from({ length: SOLVING_MERIDIAN_POINTS_PER_TIER }, (e, t) => {
-			let u = c + (l - c) * t / (SOLVING_MERIDIAN_POINTS_PER_TIER - 1), f = Math.sqrt(Math.max(0, 1 - u * u)) * a;
-			return project(rotateX(rotateY({
-				x: Math.cos(o) * f,
-				y: u * a,
-				z: Math.sin(o) * f
-			}, solvingTurnAngle(n, s)), SOLVING_TILT), i, a);
-		});
-		return u.slice(1).map((e, t) => {
-			let n = u[t];
-			return toStroke(n, e, p, shadeByDepth((n.depth + e.depth) / 2) - SOLVING_MERIDIAN_INK_BOOST, SOLVING_MERIDIAN_ALPHA);
-		});
-	}).flat();
+	});
 	return {
 		dots: [...c, ...l],
-		strokes: [...f, ...h]
+		strokes: []
 	};
 }, LISTENING_RING_COUNT = {
 	64: 5,
@@ -24279,7 +24270,7 @@ var clamp01$5 = (e) => Math.max(0, Math.min(1, e)), rotateX = (e, t) => {
 	64: 1,
 	32: .85,
 	20: .7
-}, STRAND_DEPTH_INK = .45, STRAND_SHADE_STEP = .1, strandBaseAngle = (e) => e / STRAND_COUNT * Math.PI * 2, strandPoint = (e, t, n, i, a) => {
+}, STRAND_DEPTH_INK = .45, STRAND_SHADE_STEP = .1, STRAND_GHOST_BASE_COUNT = 110, STRAND_GHOST_RADIUS_PX = .5, STRAND_GHOST_INK = .3, STRAND_GHOST_ALPHA_BASE = .16, STRAND_GHOST_ALPHA_DEPTH = .22, weavingGhostCount = (e) => Math.max(20, e.count(STRAND_GHOST_BASE_COUNT)), strandBaseAngle = (e) => e / STRAND_COUNT * Math.PI * 2, strandPoint = (e, t, n, i, a) => {
 	let o = t / (n - 1) * Math.PI * 2, s = STRAND_WAVE_AMPLITUDE * Math.sin(o * STRAND_WAVE_COUNT + a * STRAND_WAVE_SPEED + strandBaseAngle(e));
 	return rotateX(rotateY(rotateX({
 		x: i * Math.cos(s) * Math.cos(o),
@@ -24287,29 +24278,39 @@ var clamp01$5 = (e) => Math.max(0, Math.min(1, e)), rotateX = (e, t) => {
 		z: i * Math.cos(s) * Math.sin(o)
 	}, STRAND_INCLINATION), strandBaseAngle(e) + a * STRAND_ROTATE_SPEED), STRAND_TILT);
 }, weaving = (e, t) => {
-	let { sizing: n, originPx: i, sphereRadius: a } = sphereGeometry(t), o = Math.max(MIN_STRAND_POINTS, n.countAlongPath(STRAND_POINTS_BASE_COUNT)), s = Array.from({ length: STRAND_COUNT }, (t, n) => Array.from({ length: o }, (t, s) => project(strandPoint(n, s, o, a, e), i, a)));
+	let { sizing: n, originPx: i, sphereRadius: a } = sphereGeometry(t), o = Math.max(MIN_STRAND_POINTS, n.countAlongPath(STRAND_POINTS_BASE_COUNT)), s = Array.from({ length: STRAND_COUNT }, (t, n) => Array.from({ length: o }, (t, s) => project(strandPoint(n, s, o, a, e), i, a))), c = s.flatMap((e, i) => e.map((e) => ({
+		x: e.x,
+		y: e.y,
+		depth: e.depth,
+		radius: n.radius(STRAND_DOT_BASE_RADIUS) * STRAND_DOT_SIZE_FACTOR[t.size],
+		ink: clamp01$1((1 - e.depth) * STRAND_DEPTH_INK + i * STRAND_SHADE_STEP),
+		alpha: .55 + e.depth * .4
+	}))), l = s.flatMap((e, i) => e.slice(1).map((a, o) => {
+		let s = e[o], c = (s.depth + a.depth) / 2;
+		return {
+			x1: s.x,
+			y1: s.y,
+			x2: a.x,
+			y2: a.y,
+			depth: c,
+			width: n.radius(STRAND_STROKE_BASE_WIDTH) * STRAND_STROKE_SIZE_FACTOR[t.size],
+			ink: clamp01$1((1 - c) * STRAND_DEPTH_INK + i * STRAND_SHADE_STEP),
+			alpha: .6 + c * .35
+		};
+	})), u = weavingGhostCount(n), f = Array.from({ length: u }, (t, o) => {
+		let s = project(rotateX(rotateY(sampleSphere(o, u, a), e * STRAND_ROTATE_SPEED), STRAND_TILT), i, a);
+		return {
+			x: s.x,
+			y: s.y,
+			depth: s.depth,
+			radius: n.radius(STRAND_GHOST_RADIUS_PX),
+			ink: STRAND_GHOST_INK,
+			alpha: clamp01$1(STRAND_GHOST_ALPHA_BASE + STRAND_GHOST_ALPHA_DEPTH * s.depth)
+		};
+	});
 	return {
-		dots: s.flatMap((e, i) => e.map((e) => ({
-			x: e.x,
-			y: e.y,
-			depth: e.depth,
-			radius: n.radius(STRAND_DOT_BASE_RADIUS) * STRAND_DOT_SIZE_FACTOR[t.size],
-			ink: clamp01$1((1 - e.depth) * STRAND_DEPTH_INK + i * STRAND_SHADE_STEP),
-			alpha: .55 + e.depth * .4
-		}))),
-		strokes: s.flatMap((e, i) => e.slice(1).map((a, o) => {
-			let s = e[o], c = (s.depth + a.depth) / 2;
-			return {
-				x1: s.x,
-				y1: s.y,
-				x2: a.x,
-				y2: a.y,
-				depth: c,
-				width: n.radius(STRAND_STROKE_BASE_WIDTH) * STRAND_STROKE_SIZE_FACTOR[t.size],
-				ink: clamp01$1((1 - c) * STRAND_DEPTH_INK + i * STRAND_SHADE_STEP),
-				alpha: .6 + c * .35
-			};
-		}))
+		dots: [...c, ...f],
+		strokes: l
 	};
 }, TWO_PI = Math.PI * 2, FORM_RADIUS_RATIO = .4, clamp01 = (e) => Math.max(0, Math.min(1, e)), FAR_INK = .6, depthToInk = (e) => clamp01((1 - e) * FAR_INK), depthToAlpha = (e) => clamp01(.5 + e * .5), depthToRadiusFactor = (e) => .7 + e * .3, dotFrom = (e, t, n, i) => ({
 	x: e.x,
@@ -24318,26 +24319,36 @@ var clamp01$5 = (e) => Math.max(0, Math.min(1, e)), rotateX = (e, t) => {
 	radius: n.radius(t) * depthToRadiusFactor(e.depth) * i,
 	ink: depthToInk(e.depth),
 	alpha: depthToAlpha(e.depth)
-}), place = (e, t, n, i, a, o, s, c) => dotFrom(project(rotateX(rotateY(e, t), n), i, a), o, s, c), EMPTY_STROKES = [], RIBBON_PER_THREAD_BASE = 36, RIBBON_BASE_DOT_RADIUS = 2.2, RIBBON_THREADS = {
+}), place = (e, t, n, i, a, o, s, c) => dotFrom(project(rotateX(rotateY(e, t), n), i, a), o, s, c), EMPTY_STROKES = [], RIBBON_PER_THREAD_BASE = 36, RIBBON_BASE_DOT_RADIUS = 1.2, RIBBON_THREADS = {
 	64: 5,
 	32: 4,
 	20: 3
-}, RIBBON_HALF_WIDTH = .3, RIBBON_AXIS_TILT = .68, RIBBON_RIPPLE_WAVES = 3, RIBBON_RIPPLE_SPEED = 1.15, RIBBON_RIPPLE_AMPLITUDE = .18, RIBBON_THREAD_JITTER = .1, RIBBON_SPIN_SPEED = .48, RIBBON_CAMERA_TILT = .45, RIBBON_EDGE_ALPHA_FLOOR = .5, RIBBON_EDGE_INK_LIFT = .22, composing = (e, t) => {
-	let n = modeSizing(t.size, t.density, t.dotScale), i = t.size * FORM_RADIUS_RATIO, a = t.size / 2, o = RIBBON_THREADS[t.size], s = n.countAlongPath(RIBBON_PER_THREAD_BASE), c = o * s, l = [];
+}, RIBBON_HALF_WIDTH = .3, RIBBON_AXIS_TILT = .68, RIBBON_RIPPLE_WAVES = 3, RIBBON_RIPPLE_SPEED = 1.15, RIBBON_RIPPLE_AMPLITUDE = .18, RIBBON_THREAD_JITTER = .1, RIBBON_SPIN_SPEED = .48, RIBBON_CAMERA_TILT = .45, RIBBON_EDGE_ALPHA_FLOOR = .5, RIBBON_EDGE_INK_LIFT = .22, RIBBON_GHOST_BASE_COUNT = 110, RIBBON_GHOST_RADIUS_PX = .5, RIBBON_GHOST_INK = .3, RIBBON_GHOST_ALPHA_BASE = .16, RIBBON_GHOST_ALPHA_DEPTH = .22, composing = (e, t) => {
+	let n = modeSizing(t.size, t.density, t.dotScale), i = t.size * FORM_RADIUS_RATIO, a = t.size / 2, o = RIBBON_THREADS[t.size], s = n.countAlongPath(RIBBON_PER_THREAD_BASE), c = o * s, l = Math.max(20, n.count(RIBBON_GHOST_BASE_COUNT)), u = Array.from({ length: l }, (e, t) => {
+		let o = project(rotateX(sampleSphere(t, l, i), RIBBON_CAMERA_TILT), a, i);
+		return {
+			x: o.x,
+			y: o.y,
+			depth: o.depth,
+			radius: n.radius(RIBBON_GHOST_RADIUS_PX),
+			ink: RIBBON_GHOST_INK,
+			alpha: clamp01(RIBBON_GHOST_ALPHA_BASE + RIBBON_GHOST_ALPHA_DEPTH * o.depth)
+		};
+	});
 	for (let t = 0; t < c; t += 1) {
-		let c = t % o, u = Math.floor(t / o), f = o > 1 ? c / (o - 1) * 2 - 1 : 0, p = u / s * TWO_PI, h = Math.sin(p * RIBBON_RIPPLE_WAVES + e * RIBBON_RIPPLE_SPEED) * RIBBON_RIPPLE_AMPLITUDE, S = f * RIBBON_HALF_WIDTH + h, C = rotateZ({
+		let c = t % o, l = Math.floor(t / o), f = o > 1 ? c / (o - 1) * 2 - 1 : 0, p = l / s * TWO_PI, h = Math.sin(p * RIBBON_RIPPLE_WAVES + e * RIBBON_RIPPLE_SPEED) * RIBBON_RIPPLE_AMPLITUDE, S = f * RIBBON_HALF_WIDTH + h, C = rotateZ({
 			x: Math.cos(S) * Math.cos(p) * i,
 			y: Math.sin(S) * i,
 			z: Math.cos(S) * Math.sin(p) * i
 		}, RIBBON_AXIS_TILT), k = 1 - RIBBON_THREAD_JITTER / 2 + hashUnit(t * 7 + 1) * RIBBON_THREAD_JITTER, R = place(C, e * RIBBON_SPIN_SPEED, RIBBON_CAMERA_TILT, a, i, RIBBON_BASE_DOT_RADIUS, n, k), te = Math.abs(f);
-		l.push({
+		u.push({
 			...R,
 			ink: clamp01(R.ink + te * RIBBON_EDGE_INK_LIFT),
 			alpha: clamp01(R.alpha * (1 - te * (1 - RIBBON_EDGE_ALPHA_FLOOR)))
 		});
 	}
 	return {
-		dots: l,
+		dots: u,
 		strokes: EMPTY_STROKES
 	};
 }, BREATHING_BASE_COUNT = 32, BREATHING_BASE_DOT_RADIUS = 1.7, BREATHING_WORLD_RADIUS_RATIO = .34, BREATHING_AMPLITUDE = .09, BREATHING_SPEED = .55, BREATHING_SHAPE_HARMONIC = 5, BREATHING_SHAPE_SPEED = .22, BREATHING_SHAPE_AMPLITUDE = .035, BREATHING_SPIN_SPEED = .12, BREATHING_TILT = .62, breathing = (e, t) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/svelte-ui-components",
-  "version": "4.33.2",
+  "version": "4.33.3",
   "description": "A themeable Svelte 5 UI component library with CSS custom property driven styling",
   "keywords": [
     "svelte",