@journ/nude 0.1.1 → 0.1.2

package/dist/sidebar.d.ts

@@ -1,14 +1,24 @@
+import { Styled } from "./styled.js";
 //#region src/sidebar.d.ts
+declare const Layout: Styled<"div">;
+declare const Content: Styled<"main">;
+declare const Root: Styled<"aside">;
+declare const Header: Styled<"div">;
+declare const Body: Styled<"nav">;
+declare const Section: Styled<"div">;
+declare const Heading: Styled<"h3">;
+declare const Item: Styled<"a">;
+declare const Footer: Styled<"div">;
 declare const Sidebar: {
-  Layout: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>) => import("react").ReactNode;
-  Root: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLElement>, HTMLElement>) => import("react").ReactNode;
-  Header: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>) => import("react").ReactNode;
-  Body: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLElement>, HTMLElement>) => import("react").ReactNode;
-  Section: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>) => import("react").ReactNode;
-  Heading: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>) => import("react").ReactNode;
-  Item: (props: import("react").DetailedHTMLProps<import("react").AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>) => import("react").ReactNode;
-  Footer: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>) => import("react").ReactNode;
-  Content: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLElement>, HTMLElement>) => import("react").ReactNode;
+  Layout: typeof Layout;
+  Root: typeof Root;
+  Header: typeof Header;
+  Body: typeof Body;
+  Section: typeof Section;
+  Heading: typeof Heading;
+  Item: typeof Item;
+  Footer: typeof Footer;
+  Content: typeof Content;
 };
 //#endregion
 export { Sidebar };

package/dist/skeleton.d.ts

@@ -1,4 +1,5 @@
+import { Styled } from "./styled.js";
 //#region src/skeleton.d.ts
-declare const Skeleton: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>) => import("react").ReactNode;
+declare const Skeleton: Styled<"div">;
 //#endregion
 export { Skeleton };

package/dist/slider-parts.d.ts

@@ -1,9 +1,10 @@
+import { Styled } from "./styled.js";
 import * as RadixSlider from "@radix-ui/react-slider";
 //#region src/slider-parts.d.ts
-declare const Root: (props: RadixSlider.SliderProps & import("react").RefAttributes<HTMLSpanElement>) => import("react").ReactNode;
-declare const Track: (props: RadixSlider.SliderTrackProps & import("react").RefAttributes<HTMLSpanElement>) => import("react").ReactNode;
-declare const Range: (props: RadixSlider.SliderRangeProps & import("react").RefAttributes<HTMLSpanElement>) => import("react").ReactNode;
+declare const Root: Styled<typeof RadixSlider.Root>;
+declare const Track: Styled<typeof RadixSlider.Track>;
+declare const Range: Styled<typeof RadixSlider.Range>;
 /** Render one thumb per value. */
-declare const Thumb: (props: RadixSlider.SliderThumbProps & import("react").RefAttributes<HTMLSpanElement>) => import("react").ReactNode;
+declare const Thumb: Styled<typeof RadixSlider.Thumb>;
 //#endregion
 export { Range, Root, Thumb, Track };

package/dist/slider.d.ts

@@ -1,9 +1,10 @@
+import { Range, Root, Thumb, Track } from "./slider-parts.js";
 //#region src/slider.d.ts
 declare const Slider: {
-  Root: (props: import("@radix-ui/react-slider").SliderProps & import("react").RefAttributes<HTMLSpanElement>) => import("react").ReactNode;
-  Track: (props: import("@radix-ui/react-slider").SliderTrackProps & import("react").RefAttributes<HTMLSpanElement>) => import("react").ReactNode;
-  Range: (props: import("@radix-ui/react-slider").SliderRangeProps & import("react").RefAttributes<HTMLSpanElement>) => import("react").ReactNode;
-  Thumb: (props: import("@radix-ui/react-slider").SliderThumbProps & import("react").RefAttributes<HTMLSpanElement>) => import("react").ReactNode;
+  Root: typeof Root;
+  Track: typeof Track;
+  Range: typeof Range;
+  Thumb: typeof Thumb;
 };
 //#endregion
 export { Slider };

package/dist/spinner.d.ts

@@ -1,6 +1,6 @@
-import { ComponentPropsWithRef } from "react";
+import { Styled } from "./styled.js";
 //#region src/spinner.d.ts
 /** Announces itself as "Loading" unless `aria-hidden` says another element already does. */
-declare const Spinner: ({ 'aria-hidden': hidden, ...props }: ComponentPropsWithRef<'svg'>) => import("react").JSX.Element;
+declare const Spinner: Styled<"svg">;
 //#endregion
 export { Spinner };

package/dist/stack-parts.d.ts

@@ -1,6 +1,7 @@
-import { ComponentPropsWithRef } from "react";
+import { Styled } from "./styled.js";
+import { ComponentPropsWithRef, JSX } from "react";
 //#region src/stack-parts.d.ts
-type RootProps = Omit<ComponentPropsWithRef<'div'>, 'defaultValue'> & {
+type RootProps = Omit<ComponentPropsWithRef<"div">, "defaultValue"> & {
   defaultValue: string;
   onValueChange?: (value: string) => void;
 };
@@ -9,14 +10,14 @@ type RootProps = Omit<ComponentPropsWithRef<'div'>, 'defaultValue'> & {
  * remaining items keep their relative order. Positions are animated with a FLIP
  * transition so every item glides to its new place.
  */
-declare const Root: ({ defaultValue, onValueChange, ...props }: RootProps) => import("react").JSX.Element;
-type ItemProps = Omit<ComponentPropsWithRef<'div'>, 'ref'> & {
+declare const Root: ({ defaultValue, onValueChange, ...props }: RootProps) => JSX.Element;
+type ItemProps = Omit<ComponentPropsWithRef<"div">, "ref"> & {
   value: string;
 };
 /** Sets `order` and `z-index` inline, so the stack only reorders inside a flex or grid root. */
-declare const Item: ({ value, style, ...props }: ItemProps) => import("react").JSX.Element;
-declare const Trigger: ({ onClick, ...props }: ComponentPropsWithRef<'button'>) => import("react").JSX.Element;
+declare const Item: ({ value, style, ...props }: ItemProps) => JSX.Element;
+declare const Trigger: Styled<"button">;
 /** Inert and hidden while its item is not the active one. */
-declare const Content: (props: ComponentPropsWithRef<'div'>) => import("react").JSX.Element;
+declare const Content: Styled<"div">;
 //#endregion
 export { Content, Item, type ItemProps, Root, type RootProps, Trigger };

package/dist/stat.d.ts

@@ -1,9 +1,14 @@
+import { Styled } from "./styled.js";
 //#region src/stat.d.ts
+declare const Root: Styled<"div">;
+declare const Label: Styled<"p">;
+declare const Value: Styled<"p">;
+declare const Hint: Styled<"p">;
 declare const Stat: {
-  Root: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>) => import("react").ReactNode;
-  Label: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>) => import("react").ReactNode;
-  Value: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>) => import("react").ReactNode;
-  Hint: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>) => import("react").ReactNode;
+  Root: typeof Root;
+  Label: typeof Label;
+  Value: typeof Value;
+  Hint: typeof Hint;
 };
 //#endregion
 export { Stat };

package/dist/step-button.d.ts

@@ -1,11 +1,12 @@
 import { IconButtonProps } from "./icon-button.js";
+import { JSX } from "react";
 //#region src/step-button.d.ts
-type StepButtonProps = Omit<IconButtonProps, 'onClick'> & {
+type StepButtonProps = Omit<IconButtonProps, "onClick"> & {
   /** Runs after the caller's own `onClick`. */
   onStep: () => void;
-  onClick?: IconButtonProps['onClick'];
+  onClick?: IconButtonProps["onClick"];
 };
 /** The icon button behind every previous, next, minus and plus control. */
-declare const StepButton: ({ onStep, onClick, ...props }: StepButtonProps) => import("react").JSX.Element;
+declare const StepButton: ({ onStep, onClick, ...props }: StepButtonProps) => JSX.Element;
 //#endregion
 export { StepButton, type StepButtonProps };

package/dist/stepper-parts.d.ts

@@ -1,19 +1,24 @@
-import { ComponentPropsWithRef } from "react";
+import { Styled } from "./styled.js";
+import { ComponentPropsWithRef, JSX } from "react";
 //#region src/stepper-parts.d.ts
-type StepStatus = 'complete' | 'current' | 'upcoming';
-declare const useStepperItem: any;
-type RootProps = ComponentPropsWithRef<'ol'> & {
+type StepStatus = "complete" | "current" | "upcoming";
+type ItemContextValue = {
+  step: number;
+  status: StepStatus;
+};
+declare const useStepperItem: () => ItemContextValue;
+type RootProps = ComponentPropsWithRef<"ol"> & {
   /** The step the user is on, starting at 1. */
   value: number;
 };
-declare const Root: ({ value, ...props }: RootProps) => import("react").JSX.Element;
-type ItemProps = ComponentPropsWithRef<'li'> & {
+declare const Root: ({ value, ...props }: RootProps) => JSX.Element;
+type ItemProps = ComponentPropsWithRef<"li"> & {
   step: number;
 };
-declare const Item: ({ step, ...props }: ItemProps) => import("react").JSX.Element;
+declare const Item: ({ step, ...props }: ItemProps) => JSX.Element;
 /** Shows the step number unless children are given. */
-declare const Indicator: ({ children, ...props }: ComponentPropsWithRef<'span'>) => import("react").JSX.Element;
-declare const Label: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>) => import("react").ReactNode;
-declare const Description: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>) => import("react").ReactNode;
+declare const Indicator: Styled<"span">;
+declare const Label: Styled<"span">;
+declare const Description: Styled<"span">;
 //#endregion
 export { Description, Indicator, Item, Label, Root, type StepStatus, useStepperItem };

package/dist/stepper-parts.js

@@ -4,7 +4,8 @@ import { jsx } from "react/jsx-runtime";
 import { createRequiredContext } from "@journ/lift";
 //#region src/stepper-parts.tsx
 const [StepperContext, useStepper] = createRequiredContext("Stepper.Root");
-const [ItemContext, useStepperItem] = createRequiredContext("Stepper.Item");
+const [ItemContext, useStepperItemContext] = createRequiredContext("Stepper.Item");
+const useStepperItem = useStepperItemContext;
 const Root = ({ value, ...props }) => /* @__PURE__ */ jsx(StepperContext, {
 	value: { value },
 	children: /* @__PURE__ */ jsx("ol", {

package/dist/stepper.d.ts

@@ -1,11 +1,11 @@
-import { Indicator, Item, Root } from "./stepper-parts.js";
+import { Description, Indicator, Item, Label, Root } from "./stepper-parts.js";
 //#region src/stepper.d.ts
 declare const Stepper: {
   Root: typeof Root;
   Item: typeof Item;
   Indicator: typeof Indicator;
-  Label: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>) => import("react").ReactNode;
-  Description: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>) => import("react").ReactNode;
+  Label: typeof Label;
+  Description: typeof Description;
 };
 //#endregion
 export { Stepper };

package/dist/styled.d.ts

@@ -0,0 +1,5 @@
+import { ComponentPropsWithRef, ElementType, JSX } from "react";
+//#region src/styled.d.ts
+type Styled<T extends ElementType> = (props: ComponentPropsWithRef<T>) => JSX.Element;
+//#endregion
+export type { Styled };

package/dist/switch-parts.d.ts

@@ -1,6 +1,7 @@
+import { Styled } from "./styled.js";
 import * as RadixSwitch from "@radix-ui/react-switch";
 //#region src/switch-parts.d.ts
-declare const Root: (props: RadixSwitch.SwitchProps & import("react").RefAttributes<HTMLButtonElement>) => import("react").ReactNode;
-declare const Thumb: (props: RadixSwitch.SwitchThumbProps & import("react").RefAttributes<HTMLSpanElement>) => import("react").ReactNode;
+declare const Root: Styled<typeof RadixSwitch.Root>;
+declare const Thumb: Styled<typeof RadixSwitch.Thumb>;
 //#endregion
 export { Root, Thumb };

package/dist/switch.d.ts

@@ -1,7 +1,8 @@
+import { Root, Thumb } from "./switch-parts.js";
 //#region src/switch.d.ts
 declare const Switch: {
-  Root: (props: import("@radix-ui/react-switch").SwitchProps & import("react").RefAttributes<HTMLButtonElement>) => import("react").ReactNode;
-  Thumb: (props: import("@radix-ui/react-switch").SwitchThumbProps & import("react").RefAttributes<HTMLSpanElement>) => import("react").ReactNode;
+  Root: typeof Root;
+  Thumb: typeof Thumb;
 };
 //#endregion
 export { Switch };

package/dist/table.d.ts

@@ -1,12 +1,20 @@
+import { Styled } from "./styled.js";
 //#region src/table.d.ts
+declare const Root: Styled<"table">;
+declare const Caption: Styled<"caption">;
+declare const Head: Styled<"thead">;
+declare const Body: Styled<"tbody">;
+declare const Row: Styled<"tr">;
+declare const Header: Styled<"th">;
+declare const Cell: Styled<"td">;
 declare const Table: {
-  Root: (props: import("react").DetailedHTMLProps<import("react").TableHTMLAttributes<HTMLTableElement>, HTMLTableElement>) => import("react").ReactNode;
-  Caption: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLElement>, HTMLElement>) => import("react").ReactNode;
-  Head: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>) => import("react").ReactNode;
-  Body: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>) => import("react").ReactNode;
-  Row: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>) => import("react").ReactNode;
-  Header: (props: import("react").DetailedHTMLProps<import("react").ThHTMLAttributes<HTMLTableHeaderCellElement>, HTMLTableHeaderCellElement>) => import("react").ReactNode;
-  Cell: (props: import("react").DetailedHTMLProps<import("react").TdHTMLAttributes<HTMLTableDataCellElement>, HTMLTableDataCellElement>) => import("react").ReactNode;
+  Root: typeof Root;
+  Caption: typeof Caption;
+  Head: typeof Head;
+  Body: typeof Body;
+  Row: typeof Row;
+  Header: typeof Header;
+  Cell: typeof Cell;
 };
 //#endregion
 export { Table };

package/dist/tabs-parts.d.ts

@@ -1,8 +1,9 @@
+import { Styled } from "./styled.js";
 import * as RadixTabs from "@radix-ui/react-tabs";
 //#region src/tabs-parts.d.ts
-declare const Root: (props: RadixTabs.TabsProps & import("react").RefAttributes<HTMLDivElement>) => import("react").ReactNode;
-declare const List: (props: RadixTabs.TabsListProps & import("react").RefAttributes<HTMLDivElement>) => import("react").ReactNode;
-declare const Trigger: (props: RadixTabs.TabsTriggerProps & import("react").RefAttributes<HTMLButtonElement>) => import("react").ReactNode;
-declare const Content: (props: RadixTabs.TabsContentProps & import("react").RefAttributes<HTMLDivElement>) => import("react").ReactNode;
+declare const Root: Styled<typeof RadixTabs.Root>;
+declare const List: Styled<typeof RadixTabs.List>;
+declare const Trigger: Styled<typeof RadixTabs.Trigger>;
+declare const Content: Styled<typeof RadixTabs.Content>;
 //#endregion
 export { Content, List, Root, Trigger };

package/dist/tabs.d.ts

@@ -1,9 +1,10 @@
+import { Content, List, Root, Trigger } from "./tabs-parts.js";
 //#region src/tabs.d.ts
 declare const Tabs: {
-  Root: (props: import("@radix-ui/react-tabs").TabsProps & import("react").RefAttributes<HTMLDivElement>) => import("react").ReactNode;
-  List: (props: import("@radix-ui/react-tabs").TabsListProps & import("react").RefAttributes<HTMLDivElement>) => import("react").ReactNode;
-  Trigger: (props: import("@radix-ui/react-tabs").TabsTriggerProps & import("react").RefAttributes<HTMLButtonElement>) => import("react").ReactNode;
-  Content: (props: import("@radix-ui/react-tabs").TabsContentProps & import("react").RefAttributes<HTMLDivElement>) => import("react").ReactNode;
+  Root: typeof Root;
+  List: typeof List;
+  Trigger: typeof Trigger;
+  Content: typeof Content;
 };
 //#endregion
 export { Tabs };

package/dist/tag-input-parts.d.ts

@@ -1,9 +1,19 @@
+import { Styled } from "./styled.js";
 import { ChipTagProps as TagProps$1 } from "./chip.js";
 import { Composer } from "./composer.js";
-import { ComponentPropsWithRef, ElementType, ReactNode } from "react";
+import { ComponentPropsWithRef, ElementType, JSX, ReactNode } from "react";
 //#region src/tag-input-parts.d.ts
-declare const useTagInput: any;
-type RootProps = Omit<ComponentPropsWithRef<'div'>, 'defaultValue' | 'onChange'> & {
+type TagInputContextValue = {
+  tags: string[];
+  text: string;
+  invalid: boolean;
+  setText: (text: string) => void;
+  add: (...tags: string[]) => void;
+  remove: (tag: string) => void;
+  removeLast: () => void;
+};
+declare const useTagInput: () => TagInputContextValue;
+type RootProps = Omit<ComponentPropsWithRef<"div">, "defaultValue" | "onChange"> & {
   value?: string[];
   defaultValue?: string[];
   onValueChange?: (tags: string[]) => void;
@@ -12,19 +22,19 @@ type RootProps = Omit<ComponentPropsWithRef<'div'>, 'defaultValue' | 'onChange'>
   children?: ReactNode;
 };
 /** Tags are trimmed, unique (ignoring case) and never empty. */
-declare const Root: ({ value, defaultValue, onValueChange, validate, children, ...props }: RootProps) => import("react").JSX.Element;
+declare const Root: ({ value, defaultValue, onValueChange, validate, children, ...props }: RootProps) => JSX.Element;
 type TagComponents = {
   /** The chip rendered per tag. It receives `removeLabel`, `onRemove` and the tag as children. */
   components?: {
     Tag?: ElementType;
   };
 };
-type TagProps = Omit<TagProps$1, 'children' | 'onRemove'> & TagComponents & {
+type TagProps = Omit<TagProps$1, "children" | "onRemove"> & TagComponents & {
   value: string;
 };
-declare const Tag: ({ value, components, ...props }: TagProps) => import("react").JSX.Element;
+declare const Tag: ({ value, components, ...props }: TagProps) => JSX.Element;
 /** One `Tag` per value. Use `useTagInput` and `Tag` yourself for a custom list. */
-declare const Tags: ({ components }: TagComponents) => any;
-declare const Field: ({ onKeyDown, onBlur, onPaste, ...props }: ComponentPropsWithRef<typeof Composer.Input>) => import("react").JSX.Element;
+declare const Tags: ({ components }: TagComponents) => ReactNode;
+declare const Field: Styled<typeof Composer.Input>;
 //#endregion
 export { Field, Root, type RootProps, Tag, type TagProps, Tags, useTagInput };

package/dist/tag-input-parts.js

@@ -5,7 +5,8 @@ import { useState } from "react";
 import { jsx } from "react/jsx-runtime";
 import { createRequiredContext, useControllableState } from "@journ/lift";
 //#region src/tag-input-parts.tsx
-const [TagInputContext, useTagInput] = createRequiredContext("TagInput.Root");
+const [TagInputContext, useTagInputContext] = createRequiredContext("TagInput.Root");
+const useTagInput = useTagInputContext;
 const none = [];
 /** Tags are trimmed, unique (ignoring case) and never empty. */
 const Root = ({ value, defaultValue = none, onValueChange, validate, children, ...props }) => {

package/dist/text-morph.d.ts

@@ -1,6 +1,6 @@
-import { ComponentPropsWithRef, ElementType } from "react";
+import { ComponentPropsWithRef, ElementType, JSX } from "react";
 //#region src/text-morph.d.ts
-type TextMorphProps = Omit<ComponentPropsWithRef<'span'>, 'children'> & {
+type TextMorphProps = Omit<ComponentPropsWithRef<"span">, "children"> & {
   children: string;
   as?: ElementType;
   classNames?: {
@@ -12,6 +12,6 @@ type TextMorphProps = Omit<ComponentPropsWithRef<'span'>, 'children'> & {
  * Plays text one character at a time. When the text changes, only the characters
  * that differ drop in again. Screen readers get the whole string once.
  */
-declare const TextMorph: ({ children: text, as: Component, classNames, style, ...props }: TextMorphProps) => import("react").JSX.Element;
+declare const TextMorph: ({ children: text, as: Component, classNames, style, ...props }: TextMorphProps) => JSX.Element;
 //#endregion
 export { TextMorph, type TextMorphProps };

package/dist/text-shimmer.d.ts

@@ -1,9 +1,9 @@
-import { ComponentPropsWithRef, ElementType } from "react";
+import { ComponentPropsWithRef, ElementType, JSX } from "react";
 //#region src/text-shimmer.d.ts
-type TextShimmerProps = ComponentPropsWithRef<'span'> & {
+type TextShimmerProps = ComponentPropsWithRef<"span"> & {
   /** The element to render, `span` by default. */
   as?: ElementType;
 };
-declare const TextShimmer: ({ as: Component, ...props }: TextShimmerProps) => import("react").JSX.Element;
+declare const TextShimmer: ({ as: Component, ...props }: TextShimmerProps) => JSX.Element;
 //#endregion
 export { TextShimmer, type TextShimmerProps };

package/dist/text.d.ts

@@ -1,4 +1,5 @@
+import { Styled } from "./styled.js";
 //#region src/text.d.ts
-declare const Text: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>) => import("react").ReactNode;
+declare const Text: Styled<"p">;
 //#endregion
 export { Text };

package/dist/textarea.d.ts

@@ -1,4 +1,5 @@
+import { Styled } from "./styled.js";
 //#region src/textarea.d.ts
-declare const Textarea: (props: import("react").DetailedHTMLProps<import("react").TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement>) => import("react").ReactNode;
+declare const Textarea: Styled<"textarea">;
 //#endregion
 export { Textarea };

package/dist/time-range-parts.d.ts

@@ -1,5 +1,5 @@
 import { Input } from "./input.js";
-import { ComponentPropsWithRef, ReactNode } from "react";
+import { ComponentPropsWithRef, JSX, ReactNode } from "react";
 //#region src/time-range-parts.d.ts
 type TimeRangeValue = {
   start: string;
@@ -12,11 +12,11 @@ type RootProps = {
   onValueChange?: (value: TimeRangeValue) => void;
   children?: ReactNode;
 };
-declare const Root: ({ value, defaultValue, onValueChange, children }: RootProps) => import("react").JSX.Element;
-type TimeFieldProps = Omit<ComponentPropsWithRef<typeof Input>, 'type' | 'value'>;
-declare const Start: (props: TimeFieldProps) => import("react").JSX.Element;
-declare const Stop: (props: TimeFieldProps) => import("react").JSX.Element;
+declare const Root: ({ value, defaultValue, onValueChange, children }: RootProps) => JSX.Element;
+type TimeFieldProps = Omit<ComponentPropsWithRef<typeof Input>, "type" | "value">;
+declare const Start: (props: TimeFieldProps) => JSX.Element;
+declare const Stop: (props: TimeFieldProps) => JSX.Element;
 /** The time between start and stop. A stop before the start means the next day. */
-declare const Duration: (props: Omit<ComponentPropsWithRef<'output'>, 'children'>) => import("react").JSX.Element;
+declare const Duration: (props: Omit<ComponentPropsWithRef<"output">, "children">) => JSX.Element;
 //#endregion
 export { Duration, Root, type RootProps, Start, Stop, type TimeRangeValue };

package/dist/toast-parts.d.ts

@@ -1,12 +1,13 @@
-import { ComponentProps } from "react";
+import { Styled } from "./styled.js";
+import { ComponentProps, JSX } from "react";
 import { Toaster, toast } from "sonner";
 //#region src/toast-parts.d.ts
 /** Unstyled: sonner's own look is turned off. Pass `toastOptions.classNames` to style it. */
-declare const Provider: ({ toastOptions, ...props }: ComponentProps<typeof Toaster>) => import("react").JSX.Element;
+declare const Provider: ({ toastOptions, ...props }: ComponentProps<typeof Toaster>) => JSX.Element;
 declare const show: typeof toast;
-declare const Root: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>) => import("react").ReactNode;
-declare const Title: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>) => import("react").ReactNode;
-declare const Description: (props: import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>) => import("react").ReactNode;
-declare const Action: (props: import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>) => import("react").ReactNode;
+declare const Root: Styled<"div">;
+declare const Title: Styled<"p">;
+declare const Description: Styled<"p">;
+declare const Action: Styled<"button">;
 //#endregion
 export { Action, Description, Provider, Root, Title, show };

package/dist/toggle-group-parts.d.ts

@@ -1,6 +1,7 @@
+import { Styled } from "./styled.js";
 import * as RadixToggleGroup from "@radix-ui/react-toggle-group";
 //#region src/toggle-group-parts.d.ts
-declare const Root: (props: (RadixToggleGroup.ToggleGroupMultipleProps | RadixToggleGroup.ToggleGroupSingleProps) & import("react").RefAttributes<HTMLDivElement>) => import("react").ReactNode;
-declare const Item: (props: RadixToggleGroup.ToggleGroupItemProps & import("react").RefAttributes<HTMLButtonElement>) => import("react").ReactNode;
+declare const Root: Styled<typeof RadixToggleGroup.Root>;
+declare const Item: Styled<typeof RadixToggleGroup.Item>;
 //#endregion
 export { Item, Root };

package/dist/toggle-group.d.ts

@@ -1,7 +1,8 @@
+import { Item, Root } from "./toggle-group-parts.js";
 //#region src/toggle-group.d.ts
 declare const ToggleGroup: {
-  Root: (props: (import("@radix-ui/react-toggle-group").ToggleGroupMultipleProps | import("@radix-ui/react-toggle-group").ToggleGroupSingleProps) & import("react").RefAttributes<HTMLDivElement>) => import("react").ReactNode;
-  Item: (props: import("@radix-ui/react-toggle-group").ToggleGroupItemProps & import("react").RefAttributes<HTMLButtonElement>) => import("react").ReactNode;
+  Root: typeof Root;
+  Item: typeof Item;
 };
 //#endregion
 export { ToggleGroup };

package/dist/tooltip-parts.d.ts

@@ -1,10 +1,10 @@
-import { ComponentPropsWithRef } from "react";
+import { Styled } from "./styled.js";
 import * as RadixTooltip from "@radix-ui/react-tooltip";
 //#region src/tooltip-parts.d.ts
-declare const Provider: import("react").FC<RadixTooltip.TooltipProviderProps>;
+declare const Provider: typeof RadixTooltip.Provider;
 /** Includes its own provider so a tooltip works without extra setup. */
-declare const Root: ({ delayDuration, ...props }: ComponentPropsWithRef<typeof RadixTooltip.Root>) => import("react").JSX.Element;
-declare const Trigger: import("react").ForwardRefExoticComponent<RadixTooltip.TooltipTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
-declare const Content: (props: ComponentPropsWithRef<typeof RadixTooltip.Content>) => import("react").JSX.Element;
+declare const Root: Styled<typeof RadixTooltip.Root>;
+declare const Trigger: typeof RadixTooltip.Trigger;
+declare const Content: Styled<typeof RadixTooltip.Content>;
 //#endregion
 export { Content, Provider, Root, Trigger };

package/dist/tooltip.d.ts

@@ -1,9 +1,9 @@
-import { Content, Root } from "./tooltip-parts.js";
+import { Content, Provider, Root, Trigger } from "./tooltip-parts.js";
 //#region src/tooltip.d.ts
 declare const Tooltip: {
-  Provider: import("react").FC<import("@radix-ui/react-tooltip").TooltipProviderProps>;
+  Provider: typeof Provider;
   Root: typeof Root;
-  Trigger: import("react").ForwardRefExoticComponent<import("@radix-ui/react-tooltip").TooltipTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+  Trigger: typeof Trigger;
   Content: typeof Content;
 };
 //#endregion

package/dist/touch-target.d.ts

@@ -1,6 +1,6 @@
-import { ComponentPropsWithRef } from "react";
+import { Styled } from "./styled.js";
 //#region src/touch-target.d.ts
 /** A hit-area element rendered before its children. Style it to grow the touch area without changing layout. */
-declare const TouchTarget: ({ children, ...props }: ComponentPropsWithRef<'span'>) => import("react").JSX.Element;
+declare const TouchTarget: Styled<"span">;
 //#endregion
 export { TouchTarget };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@journ/nude",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Unstyled, accessible React primitives for the web. They own behavior, state, focus and ARIA, and leave every visual decision to you.",
   "license": "MIT",
   "repository": {