@nsaa/core 0.1.0-alpha.1 → 0.1.0-alpha.3

package/dist/sound/lazy-uisfx.d.ts

@@ -0,0 +1,20 @@
+
+import { UisfxPlayerOptions, UisfxSoundPlayer, uisfx_d_exports } from "./uisfx.js";
+type Engine = typeof uisfx_d_exports;
+/**
+ * The recommended sound setup (#144): a `SoundPlayer` that loads the UISFX engine on first use, so
+ * it stays out of the app's first load. The first trusted pointer or key action starts the import
+ * (cues before it finishes are skipped, as they would be before unlocking anyway). If the import
+ * fails, say offline, it stays silent and tries again on the next interaction; a cue never throws.
+ *
+ * Create one per app, at module scope:
+ *
+ * ```tsx
+ * const player = lazyUisfxPlayer();
+ * <SoundProvider player={player}>…</SoundProvider>
+ * ```
+ */
+export declare function lazyUisfxPlayer(options?: UisfxPlayerOptions,
+/** @internal Tests swap the import. */
+importEngine?: () => Promise<Engine>): UisfxSoundPlayer;
+export {};

package/dist/sound/lazy-uisfx.js

@@ -0,0 +1,68 @@
+"use client";
+import { sound } from "../tokens/dist/motion.js";
+// src/sound/lazy-uisfx.ts
+const GESTURES = ["pointerdown", "keydown"];
+/**
+* The recommended sound setup (#144): a `SoundPlayer` that loads the UISFX engine on first use, so
+* it stays out of the app's first load. The first trusted pointer or key action starts the import
+* (cues before it finishes are skipped, as they would be before unlocking anyway). If the import
+* fails, say offline, it stays silent and tries again on the next interaction; a cue never throws.
+*
+* Create one per app, at module scope:
+*
+* ```tsx
+* const player = lazyUisfxPlayer();
+* <SoundProvider player={player}>…</SoundProvider>
+* ```
+*/
+function lazyUisfxPlayer(options = {}, importEngine = () => import("./uisfx.js")) {
+	let engine = null;
+	let loading = false;
+	let pack = options.pack;
+	let gestured = false;
+	const listenOn = options.target ?? (typeof window === "undefined" ? void 0 : window);
+	const stopListening = () => {
+		for (const type of GESTURES) listenOn?.removeEventListener(type, onGesture, true);
+	};
+	const load = () => {
+		if (engine || loading) return;
+		loading = true;
+		importEngine().then(({ createUisfxPlayer }) => {
+			engine = createUisfxPlayer({
+				...options,
+				pack
+			});
+			stopListening();
+			if (gestured) engine.unlock();
+		}).catch(() => {}).finally(() => {
+			loading = false;
+		});
+	};
+	function onGesture(event) {
+		if (!event.isTrusted) return;
+		gestured = true;
+		load();
+	}
+	for (const type of GESTURES) listenOn?.addEventListener(type, onGesture, true);
+	const play = ((cue, playOptions) => {
+		if (engine) return engine(cue, playOptions);
+		load();
+	});
+	play.setPack = (next) => {
+		pack = next;
+		engine?.setPack(next);
+	};
+	play.getPack = () => engine?.getPack() ?? pack ?? sound.feel;
+	play.isUnlocked = () => engine?.isUnlocked() ?? false;
+	play.unlock = () => {
+		gestured = true;
+		if (engine) engine.unlock();
+		else load();
+	};
+	play.destroy = async () => {
+		stopListening();
+		await engine?.destroy();
+	};
+	return play;
+}
+export { lazyUisfxPlayer };

package/dist/sound/sound-map.d.ts

@@ -0,0 +1,72 @@
+
+import "./sound.js";
+import { ReactNode } from "react";
+/**
+ * The one table of interface sounds: component × event → cue (feel layer, §4). Components play
+ * from here, so the map is reviewable in one place. Surfaces that aren't listed (Popover, Tooltip,
+ * Command, menu open and close, Select open, Tabs, Accordion, Collapsible, inputs) are silent: opening a light surface isn't a commit,
+ * and the palette is a 100+/day tool. Nothing plays on hover, load or typing.
+ */
+export declare const SOUND_MAP: {
+  readonly button: {
+    readonly press: "input.press";
+  };
+  readonly checkbox: {
+    readonly on: "input.toggle-on";
+    readonly off: "input.toggle-off";
+  };
+  readonly "radio-group": {
+    readonly change: "selection.select";
+  };
+  readonly switch: {
+    readonly on: "input.toggle-on";
+    readonly off: "input.toggle-off";
+  };
+  readonly slider: {
+    readonly commit: "movement.snap";
+  };
+  readonly "input-otp": {
+    readonly invalid: "feedback.error";
+  };
+  readonly alert: {
+    readonly destructive: "feedback.error";
+    readonly success: "feedback.success";
+    readonly warning: "feedback.warning";
+  };
+  readonly dialog: {
+    readonly open: "navigation.open";
+    readonly close: "navigation.close";
+  };
+  readonly "alert-dialog": {
+    readonly open: "navigation.open";
+    readonly close: "navigation.close";
+  };
+  readonly drawer: {
+    readonly open: "navigation.open";
+    readonly close: "navigation.close";
+    readonly snap: "movement.snap";
+  };
+  readonly select: {
+    readonly choose: "selection.select";
+  };
+  readonly calendar: {
+    readonly select: "selection.select";
+  };
+  readonly combobox: {
+    readonly choose: "selection.select";
+    readonly clear: "input.press";
+    readonly "chip-remove": "input.press";
+  };
+  readonly "dropdown-menu": {
+    readonly check: "selection.select";
+  };
+  readonly "context-menu": {
+    readonly check: "selection.select";
+  };
+  readonly toast: {
+    readonly success: "feedback.success";
+    readonly warning: "feedback.warning";
+    readonly error: "feedback.error";
+  };
+};
+export type SoundComponent = keyof typeof SOUND_MAP;

package/dist/sound/sound-map.js

@@ -0,0 +1,76 @@
+"use client";
+import { useSound } from "./sound.js";
+import { createContext, createElement, useCallback, useContext } from "react";
+// src/sound/sound-map.ts
+/**
+* The one table of interface sounds: component × event → cue (feel layer, §4). Components play
+* from here, so the map is reviewable in one place. Surfaces that aren't listed (Popover, Tooltip,
+* Command, menu open and close, Select open, Tabs, Accordion, Collapsible, inputs) are silent: opening a light surface isn't a commit,
+* and the palette is a 100+/day tool. Nothing plays on hover, load or typing.
+*/
+const SOUND_MAP = {
+	button: { press: "input.press" },
+	checkbox: {
+		on: "input.toggle-on",
+		off: "input.toggle-off"
+	},
+	"radio-group": { change: "selection.select" },
+	switch: {
+		on: "input.toggle-on",
+		off: "input.toggle-off"
+	},
+	slider: { commit: "movement.snap" },
+	"input-otp": { invalid: "feedback.error" },
+	alert: {
+		destructive: "feedback.error",
+		success: "feedback.success",
+		warning: "feedback.warning"
+	},
+	dialog: {
+		open: "navigation.open",
+		close: "navigation.close"
+	},
+	"alert-dialog": {
+		open: "navigation.open",
+		close: "navigation.close"
+	},
+	drawer: {
+		open: "navigation.open",
+		close: "navigation.close",
+		snap: "movement.snap"
+	},
+	select: { choose: "selection.select" },
+	calendar: { select: "selection.select" },
+	combobox: {
+		choose: "selection.select",
+		clear: "input.press",
+		"chip-remove": "input.press"
+	},
+	"dropdown-menu": { check: "selection.select" },
+	"context-menu": { check: "selection.select" },
+	toast: {
+		success: "feedback.success",
+		warning: "feedback.warning",
+		error: "feedback.error"
+	}
+};
+const SilentContext = createContext(false);
+/** Silences the sound map below it (CommandDialog reuses Dialog but stays silent, §4). */
+function SoundSilence({ children }) {
+	return createElement(SilentContext.Provider, { value: true }, children);
+}
+/** Plays a component's mapped cue for an event, through `useSound()` and its safeguards. */
+function useCue(component) {
+	const { play } = useSound();
+	const silent = useContext(SilentContext);
+	return useCallback((event, options) => {
+		if (silent) return;
+		const cue = SOUND_MAP[component][event];
+		if (cue) play(cue, options);
+	}, [
+		component,
+		play,
+		silent
+	]);
+}
+export { SOUND_MAP, SoundSilence, useCue };

package/dist/sound/sound.d.ts

@@ -0,0 +1,38 @@
+
+import { sound } from "../tokens/dist/motion.js";
+import { ReactNode } from "react";
+/** Cue names come from the tokens (`sound.cue` in packages/tokens/src/effects.json). */
+export type SoundCue = keyof typeof sound.cue;
+/**
+ * Plays a cue. App-supplied, so the library makes no network calls and the sound engine
+ * (UISFX or anything else) stays swappable. `asset` is the engine's cue name from the tokens.
+ */
+export type SoundPlayer = (cue: SoundCue, options: {
+  asset: string;
+  volume: number;
+}) => void | (() => void);
+export interface PlayOptions {
+  /** Give way to any other cue played during the same event (a Button press under a Dialog close). */
+  yield?: boolean | undefined;
+}
+export interface SoundProviderProps {
+  children: ReactNode;
+  /** Plays cues. Without one every cue is silent (the current stub behaviour). */
+  player?: SoundPlayer | undefined;
+  /** Apps can turn the default off (decision #30). */
+  enabled?: boolean | undefined;
+  volume?: number | undefined;
+}
+/** Global sound settings: one remembered mute for the whole app. */
+export declare function SoundProvider({ children, player, enabled, volume }: SoundProviderProps): import("react").JSX.Element;
+/**
+ * Plays interface sounds with manners: only from a user action (call `play` in an event handler),
+ * never when muted, turned off, or when the user asks for reduced motion; repeats are throttled.
+ */
+export declare function useSound(): {
+  play: (cue: SoundCue, options?: PlayOptions) => void;
+  loop: (cue: SoundCue) => (() => void);
+  muted: boolean;
+  setMuted: (muted: boolean) => void;
+  enabled: boolean;
+};

package/dist/sound/sound.js

@@ -0,0 +1,136 @@
+"use client";
+import { sound } from "../tokens/dist/motion.js";
+import { jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useMemo, useRef, useState } from "react";
+import { useReducedMotionConfig } from "motion/react";
+// src/sound/sound.tsx
+/** One moment per player (per SoundProvider), outside React state: one cue per moment (#71). */
+const moments = /* @__PURE__ */ new WeakMap();
+function momentOf(player) {
+	let moment = moments.get(player);
+	if (!moment) {
+		moment = {
+			lastAt: 0,
+			pending: null
+		};
+		moments.set(player, moment);
+	}
+	return moment;
+}
+const MUTE_KEY = "nsaa-sound-muted";
+function readMuted() {
+	try {
+		return localStorage.getItem(MUTE_KEY) === "true";
+	} catch {
+		return false;
+	}
+}
+function writeMuted(muted) {
+	try {
+		localStorage.setItem(MUTE_KEY, String(muted));
+	} catch {}
+}
+const SoundContext = createContext(null);
+/** The app's own switch on <html data-motion> (feel.css reads it too): "reduce" silences sound,
+* "full" overrides the OS setting. */
+function htmlMotion() {
+	return typeof document === "undefined" ? void 0 : document.documentElement.dataset.motion;
+}
+/** Global sound settings: one remembered mute for the whole app. */
+function SoundProvider({ children, player, enabled = sound.enabled, volume = sound.volume }) {
+	const [muted, setMutedState] = useState(readMuted);
+	const setMuted = useCallback((next) => {
+		setMutedState(next);
+		writeMuted(next);
+	}, []);
+	const value = useMemo(() => ({
+		enabled,
+		volume,
+		muted,
+		setMuted,
+		player
+	}), [
+		enabled,
+		volume,
+		muted,
+		setMuted,
+		player
+	]);
+	return /* @__PURE__ */ jsx(SoundContext.Provider, {
+		value,
+		children
+	});
+}
+/**
+* Plays interface sounds with manners: only from a user action (call `play` in an event handler),
+* never when muted, turned off, or when the user asks for reduced motion; repeats are throttled.
+*/
+function useSound() {
+	const context = useContext(SoundContext);
+	const reducedMotion = useReducedMotionConfig() ?? false;
+	const enabled = context?.enabled ?? sound.enabled;
+	const muted = context?.muted ?? false;
+	const player = context?.player;
+	const volume = context?.volume ?? sound.volume;
+	const last = useRef(null);
+	return {
+		play: useCallback((cue, options) => {
+			if (!enabled || muted || !player) return;
+			const html = htmlMotion();
+			if (html === "reduce" || reducedMotion && html !== "full") return;
+			const moment = momentOf(player);
+			const fire = () => {
+				const now = Date.now();
+				if (last.current?.cue === cue && now - last.current.at < 80) return;
+				last.current = {
+					cue,
+					at: now
+				};
+				moment.lastAt = now;
+				player(cue, {
+					asset: sound.cue[cue],
+					volume
+				});
+			};
+			if (!options?.yield) {
+				if (moment.pending) clearTimeout(moment.pending);
+				moment.pending = null;
+				fire();
+				return;
+			}
+			const scheduledAt = Date.now();
+			if (moment.pending) clearTimeout(moment.pending);
+			moment.pending = setTimeout(() => {
+				moment.pending = null;
+				if (scheduledAt - moment.lastAt < 100) return;
+				fire();
+			}, 0);
+		}, [
+			enabled,
+			muted,
+			reducedMotion,
+			player,
+			volume
+		]),
+		loop: useCallback((cue) => {
+			if (!enabled || muted || !player) return () => {};
+			const html = htmlMotion();
+			if (html === "reduce" || reducedMotion && html !== "full") return () => {};
+			const stop = player(cue, {
+				asset: sound.cue[cue],
+				volume
+			});
+			return typeof stop === "function" ? stop : () => {};
+		}, [
+			enabled,
+			muted,
+			reducedMotion,
+			player,
+			volume
+		]),
+		muted,
+		setMuted: context?.setMuted ?? writeMuted,
+		enabled
+	};
+}
+export { SoundProvider, useSound };

package/dist/sound/uisfx.d.ts

@@ -0,0 +1,41 @@
+
+import { SoundPlayer } from "./sound.js";
+import { PackName } from "uisfx";
+declare namespace uisfx_d_exports {
+  export { SoundPack, UisfxPlayerOptions, UisfxSoundPlayer, createUisfxPlayer, soundPacks };
+}
+export type SoundPack = PackName;
+/** Every UISFX pack, for pickers. */
+export declare const soundPacks: readonly SoundPack[];
+export interface UisfxPlayerOptions {
+  /** UISFX pack (sound family). Defaults to the `sound.feel` token. */
+  pack?: SoundPack | undefined;
+  /** Where to listen for the first user gesture. Defaults to `window`. */
+  target?: EventTarget | undefined;
+}
+/** A `SoundPlayer` for `SoundProvider`, plus controls for the engine. */
+export interface UisfxSoundPlayer extends SoundPlayer {
+  setPack: (pack: SoundPack) => void;
+  getPack: () => SoundPack;
+  /** True once a trusted pointer or key action has happened (or `unlock` was called from one). */
+  isUnlocked: () => boolean;
+  /** Unlock audio from your own user-gesture handler. Never call it on load. */
+  unlock: () => void;
+  /** Stops sounds, removes listeners and closes the audio context. */
+  destroy: () => Promise<void>;
+}
+/**
+ * Real sound for `SoundProvider`, synthesised live by UISFX (no network, no audio files).
+ * Manners: nothing plays, and no audio context is created, until the first trusted pointer or
+ * key action; mute, volume and reduced motion are handled by `SoundProvider`/`useSound`.
+ *
+ * Create one per app, at module scope (not inside a component, where StrictMode or re-renders
+ * would make extra engines):
+ *
+ * ```tsx
+ * const player = createUisfxPlayer({ pack: "soft" });
+ * <SoundProvider player={player}>…</SoundProvider>
+ * ```
+ */
+export declare function createUisfxPlayer({ pack, target }?: UisfxPlayerOptions): UisfxSoundPlayer;
+export { uisfx_d_exports };

package/dist/sound/uisfx.js

@@ -0,0 +1,59 @@
+"use client";
+import { sound } from "../tokens/dist/motion.js";
+import { createUISFX, cueNames, getPlaybackMode, packNames } from "uisfx";
+// src/sound/uisfx.ts
+/** Every UISFX pack, for pickers. */
+const soundPacks = packNames;
+const GESTURES = ["pointerdown", "keydown"];
+const CUES = new Set(cueNames);
+function isPack(value) {
+	return packNames.includes(value);
+}
+/**
+* Real sound for `SoundProvider`, synthesised live by UISFX (no network, no audio files).
+* Manners: nothing plays, and no audio context is created, until the first trusted pointer or
+* key action; mute, volume and reduced motion are handled by `SoundProvider`/`useSound`.
+*
+* Create one per app, at module scope (not inside a component, where StrictMode or re-renders
+* would make extra engines):
+*
+* ```tsx
+* const player = createUisfxPlayer({ pack: "soft" });
+* <SoundProvider player={player}>…</SoundProvider>
+* ```
+*/
+function createUisfxPlayer({ pack, target } = {}) {
+	const initialPack = pack ?? (isPack(sound.feel) ? sound.feel : "minimal");
+	const engine = createUISFX({
+		pack: initialPack,
+		volume: sound.volume
+	});
+	const listenOn = target ?? (typeof window === "undefined" ? void 0 : window);
+	let unlocked = false;
+	const unlock = () => {
+		if (unlocked) return;
+		unlocked = true;
+		for (const type of GESTURES) listenOn?.removeEventListener(type, onGesture, true);
+		engine.unlock();
+	};
+	function onGesture(event) {
+		if (event.isTrusted) unlock();
+	}
+	for (const type of GESTURES) listenOn?.addEventListener(type, onGesture, true);
+	const play = ((_cue, { asset, volume }) => {
+		if (!unlocked || !CUES.has(asset)) return;
+		if (engine.getVolume() !== volume) engine.setVolume(volume);
+		const playing = engine.play(asset);
+		if (getPlaybackMode(asset) === "loop") return () => playing?.stop();
+	});
+	play.setPack = (next) => engine.setPack(next);
+	play.getPack = () => engine.getPack();
+	play.isUnlocked = () => unlocked;
+	play.unlock = unlock;
+	play.destroy = async () => {
+		for (const type of GESTURES) listenOn?.removeEventListener(type, onGesture, true);
+		await engine.destroy();
+	};
+	return play;
+}
+export { createUisfxPlayer, soundPacks };

package/dist/sound-uisfx.d.ts

@@ -1,38 +1,3 @@
 
-import { n as SoundPlayer } from "./sound-DiYNAnR_.js";
-import { PackName } from "uisfx";
-type SoundPack = PackName;
-/** Every UISFX pack, for pickers. */
-export declare const soundPacks: readonly SoundPack[];
-interface UisfxPlayerOptions {
-  /** UISFX pack (sound family). Defaults to the `sound.feel` token. */
-  pack?: SoundPack | undefined;
-  /** Where to listen for the first user gesture. Defaults to `window`. */
-  target?: EventTarget | undefined;
-}
-/** A `SoundPlayer` for `SoundProvider`, plus controls for the engine. */
-interface UisfxSoundPlayer extends SoundPlayer {
-  setPack: (pack: SoundPack) => void;
-  getPack: () => SoundPack;
-  /** True once a trusted pointer or key action has happened (or `unlock` was called from one). */
-  isUnlocked: () => boolean;
-  /** Unlock audio from your own user-gesture handler. Never call it on load. */
-  unlock: () => void;
-  /** Stops sounds, removes listeners and closes the audio context. */
-  destroy: () => Promise<void>;
-}
-/**
- * Real sound for `SoundProvider`, synthesised live by UISFX (no network, no audio files).
- * Manners: nothing plays, and no audio context is created, until the first trusted pointer or
- * key action; mute, volume and reduced motion are handled by `SoundProvider`/`useSound`.
- *
- * Create one per app, at module scope (not inside a component, where StrictMode or re-renders
- * would make extra engines):
- *
- * ```tsx
- * const player = createUisfxPlayer({ pack: "soft" });
- * <SoundProvider player={player}>…</SoundProvider>
- * ```
- */
-export declare function createUisfxPlayer({ pack, target }?: UisfxPlayerOptions): UisfxSoundPlayer;
-export type { SoundPack, UisfxPlayerOptions, UisfxSoundPlayer };
+import { SoundPack, UisfxPlayerOptions, UisfxSoundPlayer, createUisfxPlayer, soundPacks } from "./sound/uisfx.js";
+export { type SoundPack, type UisfxPlayerOptions, type UisfxSoundPlayer, createUisfxPlayer, soundPacks };

package/dist/sound-uisfx.js

@@ -1,59 +1,2 @@
 "use client";
-import { i as sound } from "./motion-NQq2BA78.js";
-import { createUISFX, cueNames, getPlaybackMode, packNames } from "uisfx";
-// src/sound/uisfx.ts
-/** Every UISFX pack, for pickers. */
-const soundPacks = packNames;
-const GESTURES = ["pointerdown", "keydown"];
-const CUES = new Set(cueNames);
-function isPack(value) {
-	return packNames.includes(value);
-}
-/**
-* Real sound for `SoundProvider`, synthesised live by UISFX (no network, no audio files).
-* Manners: nothing plays, and no audio context is created, until the first trusted pointer or
-* key action; mute, volume and reduced motion are handled by `SoundProvider`/`useSound`.
-*
-* Create one per app, at module scope (not inside a component, where StrictMode or re-renders
-* would make extra engines):
-*
-* ```tsx
-* const player = createUisfxPlayer({ pack: "soft" });
-* <SoundProvider player={player}>…</SoundProvider>
-* ```
-*/
-function createUisfxPlayer({ pack, target } = {}) {
-	const initialPack = pack ?? (isPack(sound.feel) ? sound.feel : "minimal");
-	const engine = createUISFX({
-		pack: initialPack,
-		volume: sound.volume
-	});
-	const listenOn = target ?? (typeof window === "undefined" ? void 0 : window);
-	let unlocked = false;
-	const unlock = () => {
-		if (unlocked) return;
-		unlocked = true;
-		for (const type of GESTURES) listenOn?.removeEventListener(type, onGesture, true);
-		engine.unlock();
-	};
-	function onGesture(event) {
-		if (event.isTrusted) unlock();
-	}
-	for (const type of GESTURES) listenOn?.addEventListener(type, onGesture, true);
-	const play = ((_cue, { asset, volume }) => {
-		if (!unlocked || !CUES.has(asset)) return;
-		if (engine.getVolume() !== volume) engine.setVolume(volume);
-		const playing = engine.play(asset);
-		if (getPlaybackMode(asset) === "loop") return () => playing?.stop();
-	});
-	play.setPack = (next) => engine.setPack(next);
-	play.getPack = () => engine.getPack();
-	play.isUnlocked = () => unlocked;
-	play.unlock = unlock;
-	play.destroy = async () => {
-		for (const type of GESTURES) listenOn?.removeEventListener(type, onGesture, true);
-		await engine.destroy();
-	};
-	return play;
-}
-export { createUisfxPlayer, soundPacks };
+export { createUisfxPlayer, soundPacks } from "./sound/uisfx.js";

package/dist/sources/accordion.css

@@ -0,0 +1,3 @@
+/* @nsaa/core: Tailwind sources for accordion (generated). */
+@source "../accordion/accordion.js";
+@source "../lib/cn.js";

package/dist/sources/alert-dialog.css

@@ -0,0 +1,26 @@
+/* @nsaa/core: Tailwind sources for alert-dialog (generated). */
+@source "../alert-dialog/alert-dialog.js";
+@source "../button/button.js";
+@source "../lib/cn.js";
+@source "../lib/control-defaults.js";
+@source "../lib/opener.js";
+@source "../lib/use-press.js";
+@source "../loaders/arc.js";
+@source "../loaders/bouncing-dots.js";
+@source "../loaders/cap.js";
+@source "../loaders/circular-dots.js";
+@source "../loaders/classic.js";
+@source "../loaders/easing.js";
+@source "../loaders/fade.js";
+@source "../loaders/frame.js";
+@source "../loaders/motion.js";
+@source "../loaders/orbit.js";
+@source "../loaders/pulse.js";
+@source "../loaders/ring.js";
+@source "../loaders/wave.js";
+@source "../sound/sound-map.js";
+@source "../sound/sound.js";
+@source "../spinner/loader-provider.js";
+@source "../spinner/registry.js";
+@source "../spinner/spinner.js";
+@source "../tokens/dist/motion.js";

package/dist/sources/alert.css

@@ -0,0 +1,8 @@
+/* @nsaa/core: Tailwind sources for alert (generated). */
+@source "../alert/alert.js";
+@source "../lib/cn.js";
+@source "../lib/input-modality.js";
+@source "../lib/user-action.js";
+@source "../sound/sound-map.js";
+@source "../sound/sound.js";
+@source "../tokens/dist/motion.js";

package/dist/sources/avatar.css

@@ -0,0 +1,3 @@
+/* @nsaa/core: Tailwind sources for avatar (generated). */
+@source "../avatar/avatar.js";
+@source "../lib/cn.js";

package/dist/sources/badge.css

@@ -0,0 +1,3 @@
+/* @nsaa/core: Tailwind sources for badge (generated). */
+@source "../badge/badge.js";
+@source "../lib/cn.js";