@journ/nude 0.1.0

package/dist/spinner.js

@@ -0,0 +1,23 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/spinner.tsx
+/** Announces itself as "Loading" unless `aria-hidden` says another element already does. */
+const Spinner = ({ "aria-hidden": hidden, ...props }) => /* @__PURE__ */ jsxs("svg", {
+	"data-slot": "spinner",
+	role: hidden ? void 0 : "status",
+	"aria-label": hidden ? void 0 : "Loading",
+	"aria-hidden": hidden,
+	viewBox: "0 0 24 24",
+	fill: "none",
+	stroke: "currentColor",
+	strokeWidth: 3,
+	strokeLinecap: "round",
+	...props,
+	children: [/* @__PURE__ */ jsx("circle", {
+		cx: "12",
+		cy: "12",
+		r: "9",
+		opacity: .2
+	}), /* @__PURE__ */ jsx("path", { d: "M21 12a9 9 0 0 0-9-9" })]
+});
+//#endregion
+export { Spinner };

package/dist/stack-parts.d.ts

@@ -0,0 +1,22 @@
+import { ComponentPropsWithRef } from "react";
+//#region src/stack-parts.d.ts
+type RootProps = Omit<ComponentPropsWithRef<'div'>, 'defaultValue'> & {
+  defaultValue: string;
+  onValueChange?: (value: string) => void;
+};
+/**
+ * Activating an item moves it to the end of the stack (the front) and the
+ * 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'> & {
+  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;
+/** Inert and hidden while its item is not the active one. */
+declare const Content: (props: ComponentPropsWithRef<'div'>) => import("react").JSX.Element;
+//#endregion
+export { Content, Item, type ItemProps, Root, type RootProps, Trigger };

package/dist/stack-parts.js

@@ -0,0 +1,125 @@
+"use client";
+import { useCallback, useLayoutEffect, useRef, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+import { createRequiredContext, prefersReducedMotion } from "@journ/lift";
+import { animate } from "animejs";
+//#region src/stack-parts.tsx
+const [StackContext, useStack] = createRequiredContext("Stack.Root");
+const [ItemContext, useItemValue] = createRequiredContext("Stack.Item");
+/**
+* Activating an item moves it to the end of the stack (the front) and the
+* remaining items keep their relative order. Positions are animated with a FLIP
+* transition so every item glides to its new place.
+*/
+const Root = ({ defaultValue, onValueChange, ...props }) => {
+	const [history, setHistory] = useState([defaultValue]);
+	const elements = useRef(/* @__PURE__ */ new Map());
+	const firstRects = useRef(null);
+	const active = history[history.length - 1] ?? defaultValue;
+	const register = useCallback((value, element) => {
+		if (element) elements.current.set(value, element);
+		else elements.current.delete(value);
+	}, []);
+	const activate = useCallback((value) => {
+		if (value === active) return;
+		firstRects.current = new Map([...elements.current].map(([key, element]) => [key, element.getBoundingClientRect().top]));
+		setHistory((current) => [...current.filter((entry) => entry !== value), value]);
+		onValueChange?.(value);
+	}, [active, onValueChange]);
+	useLayoutEffect(() => {
+		const first = firstRects.current;
+		firstRects.current = null;
+		if (!first || prefersReducedMotion()) return;
+		for (const [value, element] of elements.current) {
+			const previous = first.get(value);
+			if (previous === void 0) continue;
+			const delta = previous - element.getBoundingClientRect().top;
+			if (delta !== 0) animate(element, {
+				translateY: [delta, 0],
+				duration: 300,
+				ease: "outExpo"
+			});
+		}
+	}, [history]);
+	return /* @__PURE__ */ jsx(StackContext, {
+		value: {
+			active,
+			history,
+			activate,
+			register
+		},
+		children: /* @__PURE__ */ jsx("div", {
+			"data-slot": "stack",
+			...props
+		})
+	});
+};
+/** Sets `order` and `z-index` inline, so the stack only reorders inside a flex or grid root. */
+const Item = ({ value, style, ...props }) => {
+	const { active, history, register } = useStack();
+	const position = history.indexOf(value) + 1;
+	const itemStyle = {
+		...style,
+		order: position,
+		zIndex: position
+	};
+	return /* @__PURE__ */ jsx(ItemContext, {
+		value,
+		children: /* @__PURE__ */ jsx("div", {
+			"data-slot": "stack-item",
+			"data-value": value,
+			"data-active": active === value,
+			ref: (element) => {
+				register(value, element);
+				return () => register(value, null);
+			},
+			...props,
+			style: itemStyle
+		})
+	});
+};
+const Trigger = ({ onClick, ...props }) => {
+	const { active, activate } = useStack();
+	const value = useItemValue();
+	return /* @__PURE__ */ jsx("button", {
+		type: "button",
+		"data-slot": "stack-trigger",
+		"aria-expanded": active === value,
+		...props,
+		onClick: (event) => {
+			onClick?.(event);
+			activate(value);
+		}
+	});
+};
+/** Inert and hidden while its item is not the active one. */
+const Content = (props) => {
+	const { active } = useStack();
+	const isActive = active === useItemValue();
+	const element = useRef(null);
+	const mounted = useRef(false);
+	useLayoutEffect(() => {
+		if (!mounted.current) {
+			mounted.current = true;
+			return;
+		}
+		if (!isActive || !element.current || prefersReducedMotion()) return;
+		animate(element.current, {
+			opacity: [0, 1],
+			translateY: [12, 0],
+			duration: 250,
+			delay: 100,
+			ease: "outExpo"
+		});
+	}, [isActive]);
+	return /* @__PURE__ */ jsx("div", {
+		ref: element,
+		"data-slot": "stack-content",
+		"data-active": isActive,
+		inert: !isActive,
+		hidden: !isActive,
+		...props
+	});
+};
+//#endregion
+export { Content, Item, Root, Trigger };

package/dist/stack.d.ts

@@ -0,0 +1,10 @@
+import { Content, Item, Root, Trigger } from "./stack-parts.js";
+//#region src/stack.d.ts
+declare const Stack: {
+  Root: typeof Root;
+  Item: typeof Item;
+  Trigger: typeof Trigger;
+  Content: typeof Content;
+};
+//#endregion
+export { Stack };

package/dist/stack.js

@@ -0,0 +1,10 @@
+import { Content, Item, Root, Trigger } from "./stack-parts.js";
+//#region src/stack.tsx
+const Stack = {
+	Root,
+	Item,
+	Trigger,
+	Content
+};
+//#endregion
+export { Stack };

package/dist/stat.d.ts

@@ -0,0 +1,9 @@
+//#region src/stat.d.ts
+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;
+};
+//#endregion
+export { Stat };

package/dist/stat.js

@@ -0,0 +1,10 @@
+import { part } from "./lib/part.js";
+//#region src/stat.tsx
+const Stat = {
+	Root: part("div", "stat"),
+	Label: part("p", "stat-label"),
+	Value: part("p", "stat-value"),
+	Hint: part("p", "stat-hint")
+};
+//#endregion
+export { Stat };

package/dist/step-button.d.ts

@@ -0,0 +1,11 @@
+import { IconButtonProps } from "./icon-button.js";
+//#region src/step-button.d.ts
+type StepButtonProps = Omit<IconButtonProps, 'onClick'> & {
+  /** Runs after the caller's own `onClick`. */
+  onStep: () => void;
+  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;
+//#endregion
+export { StepButton, type StepButtonProps };

package/dist/step-button.js

@@ -0,0 +1,13 @@
+import { IconButton } from "./icon-button.js";
+import { jsx } from "react/jsx-runtime";
+//#region src/step-button.tsx
+/** The icon button behind every previous, next, minus and plus control. */
+const StepButton = ({ onStep, onClick, ...props }) => /* @__PURE__ */ jsx(IconButton, {
+	...props,
+	onClick: (event) => {
+		onClick?.(event);
+		onStep();
+	}
+});
+//#endregion
+export { StepButton };

package/dist/stepper-parts.d.ts

@@ -0,0 +1,19 @@
+import { ComponentPropsWithRef } from "react";
+//#region src/stepper-parts.d.ts
+type StepStatus = 'complete' | 'current' | 'upcoming';
+declare const useStepperItem: any;
+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'> & {
+  step: number;
+};
+declare const Item: ({ step, ...props }: ItemProps) => import("react").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;
+//#endregion
+export { Description, Indicator, Item, Label, Root, type StepStatus, useStepperItem };

package/dist/stepper-parts.js

@@ -0,0 +1,44 @@
+"use client";
+import { part } from "./lib/part.js";
+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 Root = ({ value, ...props }) => /* @__PURE__ */ jsx(StepperContext, {
+	value: { value },
+	children: /* @__PURE__ */ jsx("ol", {
+		"data-slot": "stepper",
+		...props
+	})
+});
+const Item = ({ step, ...props }) => {
+	const context = useStepper();
+	const status = step < context.value ? "complete" : step === context.value ? "current" : "upcoming";
+	return /* @__PURE__ */ jsx(ItemContext, {
+		value: {
+			step,
+			status
+		},
+		children: /* @__PURE__ */ jsx("li", {
+			"data-slot": "stepper-item",
+			"data-status": status,
+			"aria-current": status === "current" ? "step" : void 0,
+			...props
+		})
+	});
+};
+/** Shows the step number unless children are given. */
+const Indicator = ({ children, ...props }) => {
+	const { step } = useStepperItem();
+	return /* @__PURE__ */ jsx("span", {
+		"data-slot": "stepper-indicator",
+		"aria-hidden": true,
+		...props,
+		children: children ?? step
+	});
+};
+const Label = part("span", "stepper-label");
+const Description = part("span", "stepper-description");
+//#endregion
+export { Description, Indicator, Item, Label, Root, useStepperItem };

package/dist/stepper.d.ts

@@ -0,0 +1,11 @@
+import { Indicator, Item, 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;
+};
+//#endregion
+export { Stepper };

package/dist/stepper.js

@@ -0,0 +1,11 @@
+import { Description, Indicator, Item, Label, Root } from "./stepper-parts.js";
+//#region src/stepper.tsx
+const Stepper = {
+	Root,
+	Item,
+	Indicator,
+	Label,
+	Description
+};
+//#endregion
+export { Stepper };

package/dist/switch-parts.d.ts

@@ -0,0 +1,6 @@
+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;
+//#endregion
+export { Root, Thumb };

package/dist/switch-parts.js

@@ -0,0 +1,8 @@
+"use client";
+import { part } from "./lib/part.js";
+import * as RadixSwitch from "@radix-ui/react-switch";
+//#region src/switch-parts.tsx
+const Root = part(RadixSwitch.Root, "switch");
+const Thumb = part(RadixSwitch.Thumb, "switch-thumb");
+//#endregion
+export { Root, Thumb };

package/dist/switch.d.ts

@@ -0,0 +1,7 @@
+//#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;
+};
+//#endregion
+export { Switch };

package/dist/switch.js

@@ -0,0 +1,8 @@
+import { Root, Thumb } from "./switch-parts.js";
+//#region src/switch.tsx
+const Switch = {
+	Root,
+	Thumb
+};
+//#endregion
+export { Switch };

package/dist/table.d.ts

@@ -0,0 +1,12 @@
+//#region src/table.d.ts
+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;
+};
+//#endregion
+export { Table };

package/dist/table.js

@@ -0,0 +1,13 @@
+import { part } from "./lib/part.js";
+//#region src/table.tsx
+const Table = {
+	Root: part("table", "table"),
+	Caption: part("caption", "table-caption"),
+	Head: part("thead", "table-head"),
+	Body: part("tbody", "table-body"),
+	Row: part("tr", "table-row"),
+	Header: part("th", "table-header"),
+	Cell: part("td", "table-cell")
+};
+//#endregion
+export { Table };

package/dist/tabs-parts.d.ts

@@ -0,0 +1,8 @@
+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;
+//#endregion
+export { Content, List, Root, Trigger };

package/dist/tabs-parts.js

@@ -0,0 +1,10 @@
+"use client";
+import { part } from "./lib/part.js";
+import * as RadixTabs from "@radix-ui/react-tabs";
+//#region src/tabs-parts.tsx
+const Root = part(RadixTabs.Root, "tabs");
+const List = part(RadixTabs.List, "tabs-list");
+const Trigger = part(RadixTabs.Trigger, "tabs-trigger");
+const Content = part(RadixTabs.Content, "tabs-content");
+//#endregion
+export { Content, List, Root, Trigger };

package/dist/tabs.d.ts

@@ -0,0 +1,9 @@
+//#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;
+};
+//#endregion
+export { Tabs };

package/dist/tabs.js

@@ -0,0 +1,10 @@
+import { Content, List, Root, Trigger } from "./tabs-parts.js";
+//#region src/tabs.tsx
+const Tabs = {
+	Root,
+	List,
+	Trigger,
+	Content
+};
+//#endregion
+export { Tabs };

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

@@ -0,0 +1,30 @@
+import { ChipTagProps as TagProps$1 } from "./chip.js";
+import { Composer } from "./composer.js";
+import { ComponentPropsWithRef, ElementType, ReactNode } from "react";
+//#region src/tag-input-parts.d.ts
+declare const useTagInput: any;
+type RootProps = Omit<ComponentPropsWithRef<'div'>, 'defaultValue' | 'onChange'> & {
+  value?: string[];
+  defaultValue?: string[];
+  onValueChange?: (tags: string[]) => void;
+  /** Return false to refuse a tag, e.g. an invalid email. The text stays so it can be fixed. */
+  validate?: (tag: string) => boolean;
+  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;
+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 & {
+  value: string;
+};
+declare const Tag: ({ value, components, ...props }: TagProps) => import("react").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;
+//#endregion
+export { Field, Root, type RootProps, Tag, type TagProps, Tags, useTagInput };

package/dist/tag-input-parts.js

@@ -0,0 +1,99 @@
+"use client";
+import { Chip } from "./chip.js";
+import { Composer } from "./composer.js";
+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 none = [];
+/** Tags are trimmed, unique (ignoring case) and never empty. */
+const Root = ({ value, defaultValue = none, onValueChange, validate, children, ...props }) => {
+	const [stored, setStored] = useControllableState(value, defaultValue, onValueChange);
+	const tags = stored ?? none;
+	const [text, setText] = useState("");
+	const [invalid, setInvalid] = useState(false);
+	const add = (...incoming) => {
+		const next = [...tags];
+		let refused = false;
+		for (const raw of incoming) {
+			const tag = raw.trim();
+			if (!tag || next.some((existing) => existing.toLowerCase() === tag.toLowerCase())) continue;
+			if (validate && !validate(tag)) {
+				refused = true;
+				continue;
+			}
+			next.push(tag);
+		}
+		setInvalid(refused);
+		if (next.length !== tags.length) setStored(next);
+		if (!refused) setText("");
+	};
+	return /* @__PURE__ */ jsx(TagInputContext, {
+		value: {
+			tags,
+			text,
+			invalid,
+			setText: (next) => (setInvalid(false), setText(next)),
+			add,
+			remove: (tag) => setStored(tags.filter((existing) => existing !== tag)),
+			removeLast: () => tags.length > 0 && setStored(tags.slice(0, -1))
+		},
+		children: /* @__PURE__ */ jsx(Composer.Root, {
+			"data-slot": "tag-input",
+			...props,
+			children
+		})
+	});
+};
+const Tag = ({ value, components, ...props }) => {
+	const { remove } = useTagInput();
+	const ChipTag = components?.Tag ?? Chip.Tag;
+	return /* @__PURE__ */ jsx(ChipTag, {
+		"data-slot": "tag-input-tag",
+		removeLabel: `Remove ${value}`,
+		onRemove: () => remove(value),
+		...props,
+		children: value
+	});
+};
+/** One `Tag` per value. Use `useTagInput` and `Tag` yourself for a custom list. */
+const Tags = ({ components }) => {
+	const { tags } = useTagInput();
+	return tags.map((tag) => /* @__PURE__ */ jsx(Tag, {
+		value: tag,
+		components
+	}, tag));
+};
+const Field = ({ onKeyDown, onBlur, onPaste, ...props }) => {
+	const { text, invalid, setText, add, removeLast } = useTagInput();
+	return /* @__PURE__ */ jsx(Composer.Input, {
+		"data-slot": "tag-input-field",
+		"aria-invalid": invalid || void 0,
+		...props,
+		value: text,
+		onChange: (event) => setText(event.target.value),
+		onKeyDown: (event) => {
+			onKeyDown?.(event);
+			if (event.key === "Enter" || event.key === ",") {
+				event.preventDefault();
+				add(text);
+			}
+			if (event.key === "Backspace" && text === "") removeLast();
+		},
+		onBlur: (event) => {
+			onBlur?.(event);
+			add(text);
+		},
+		onPaste: (event) => {
+			onPaste?.(event);
+			const pasted = event.clipboardData.getData("text");
+			if (/[,\n;]/.test(pasted)) {
+				event.preventDefault();
+				add(...pasted.split(/[,\n;]+/));
+			}
+		}
+	});
+};
+//#endregion
+export { Field, Root, Tag, Tags, useTagInput };

package/dist/tag-input.d.ts

@@ -0,0 +1,10 @@
+import { Field, Root, RootProps, Tag, Tags, useTagInput } from "./tag-input-parts.js";
+//#region src/tag-input.d.ts
+declare const TagInput: {
+  Root: typeof Root;
+  Tags: typeof Tags;
+  Tag: typeof Tag;
+  Field: typeof Field;
+};
+//#endregion
+export { TagInput, type RootProps as TagInputProps, useTagInput };

package/dist/tag-input.js

@@ -0,0 +1,10 @@
+import { Field, Root, Tag, Tags, useTagInput } from "./tag-input-parts.js";
+//#region src/tag-input.tsx
+const TagInput = {
+	Root,
+	Tags,
+	Tag,
+	Field
+};
+//#endregion
+export { TagInput, useTagInput };

package/dist/text-morph.d.ts

@@ -0,0 +1,17 @@
+import { ComponentPropsWithRef, ElementType } from "react";
+//#region src/text-morph.d.ts
+type TextMorphProps = Omit<ComponentPropsWithRef<'span'>, 'children'> & {
+  children: string;
+  as?: ElementType;
+  classNames?: {
+    label?: string;
+    char?: string;
+  };
+};
+/**
+ * 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;
+//#endregion
+export { TextMorph, type TextMorphProps };