matrix-design-system 1.0.0

package/dist/atoms/effects/plain-image/plain-image.mjs

@@ -0,0 +1,140 @@
+"use client";
+import { usePlainImageStore } from "./use-plain-image-store.mjs";
+import { c } from "react/compiler-runtime";
+import { jsx } from "react/jsx-runtime";
+//#region src/atoms/effects/plain-image/plain-image.tsx
+/**
+* `next/image`'s `fill` positions the image to cover its ancestor but sets no `object-fit`, leaving
+* that to the caller's class. Setting one here as an inline style would silently beat that class.
+*/
+const fillStyle = {
+	position: "absolute",
+	height: "100%",
+	width: "100%",
+	inset: 0
+};
+/**
+* Resolves what to paint behind a loading image. `next/image` treats a `data:` placeholder as the
+* image to show directly, and `"blur"` as an instruction to use `blurDataURL`.
+*/
+const placeholderSource = (placeholder, blurDataURL) => {
+	if (!placeholder || placeholder === "empty") return;
+	return placeholder === "blur" ? blurDataURL : placeholder;
+};
+/**
+* The framework-free default: a real `<img>`. It reproduces the `next/image` behaviours design-system
+* layouts depend on — `fill` positioning, a placeholder painted behind the image until it loads, and
+* lazy loading unless the caller marks the image as priority. Optimisation-only props are
+* destructured away instead of spread onto the DOM, where React would warn about them.
+*/
+const PlainImage = (t0) => {
+	const $ = c(30);
+	let alt;
+	let blurDataURL;
+	let fill;
+	let loading;
+	let onLoad;
+	let placeholder;
+	let priority;
+	let rest;
+	let src;
+	let style;
+	if ($[0] !== t0) {
+		const { src: t1, alt: t2, fill: t3, placeholder: t4, blurDataURL: t5, style: t6, loading: t7, priority: t8, onLoad: t9, quality: _quality, ...t10 } = t0;
+		src = t1;
+		alt = t2;
+		fill = t3;
+		placeholder = t4;
+		blurDataURL = t5;
+		style = t6;
+		loading = t7;
+		priority = t8;
+		onLoad = t9;
+		rest = t10;
+		$[0] = t0;
+		$[1] = alt;
+		$[2] = blurDataURL;
+		$[3] = fill;
+		$[4] = loading;
+		$[5] = onLoad;
+		$[6] = placeholder;
+		$[7] = priority;
+		$[8] = rest;
+		$[9] = src;
+		$[10] = style;
+	} else {
+		alt = $[1];
+		blurDataURL = $[2];
+		fill = $[3];
+		loading = $[4];
+		onLoad = $[5];
+		placeholder = $[6];
+		priority = $[7];
+		rest = $[8];
+		src = $[9];
+		style = $[10];
+	}
+	const { state, effects } = usePlainImageStore(onLoad);
+	const { loaded } = state;
+	const { setImage, handleLoad } = effects;
+	const resolvedSrc = typeof src === "string" ? src : src.src;
+	let t1;
+	if ($[11] !== blurDataURL || $[12] !== loaded || $[13] !== placeholder) {
+		t1 = loaded ? void 0 : placeholderSource(placeholder, blurDataURL);
+		$[11] = blurDataURL;
+		$[12] = loaded;
+		$[13] = placeholder;
+		$[14] = t1;
+	} else t1 = $[14];
+	const background = t1;
+	const t2 = loading ?? (priority ? "eager" : "lazy");
+	const t3 = priority ? "high" : void 0;
+	const t4 = fill ? fillStyle : void 0;
+	let t5;
+	if ($[15] !== background) {
+		t5 = background ? {
+			backgroundImage: `url(${background})`,
+			backgroundSize: "cover",
+			backgroundPosition: "center"
+		} : void 0;
+		$[15] = background;
+		$[16] = t5;
+	} else t5 = $[16];
+	let t6;
+	if ($[17] !== style || $[18] !== t4 || $[19] !== t5) {
+		t6 = {
+			...t4,
+			...t5,
+			...style
+		};
+		$[17] = style;
+		$[18] = t4;
+		$[19] = t5;
+		$[20] = t6;
+	} else t6 = $[20];
+	let t7;
+	if ($[21] !== alt || $[22] !== handleLoad || $[23] !== resolvedSrc || $[24] !== rest || $[25] !== setImage || $[26] !== t2 || $[27] !== t3 || $[28] !== t6) {
+		t7 = /* @__PURE__ */ jsx("img", {
+			ref: setImage,
+			src: resolvedSrc,
+			alt,
+			loading: t2,
+			fetchPriority: t3,
+			onLoad: handleLoad,
+			style: t6,
+			...rest
+		});
+		$[21] = alt;
+		$[22] = handleLoad;
+		$[23] = resolvedSrc;
+		$[24] = rest;
+		$[25] = setImage;
+		$[26] = t2;
+		$[27] = t3;
+		$[28] = t6;
+		$[29] = t7;
+	} else t7 = $[29];
+	return t7;
+};
+//#endregion
+export { PlainImage };

package/dist/atoms/effects/plain-image/use-plain-image-store.mjs

@@ -0,0 +1,62 @@
+"use client";
+import { c } from "react/compiler-runtime";
+import { useState } from "react";
+//#region src/atoms/effects/plain-image/use-plain-image-store.ts
+/**
+* Tracks whether the image has painted, so the placeholder behind it can be dropped once it has —
+* `next/image` does the same.
+*
+* The `complete` check in the ref callback matters for server-rendered markup: an image the browser
+* already has cached can finish loading before React attaches its handlers, and the `load` event
+* would then never reach us, leaving the placeholder showing through a transparent PNG forever.
+*/
+const usePlainImageStore = (onLoad) => {
+	const $ = c(10);
+	const [loaded, setLoaded] = useState(false);
+	let t0;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t0 = (image) => {
+			if (image?.complete) setLoaded(true);
+		};
+		$[0] = t0;
+	} else t0 = $[0];
+	const setImage = t0;
+	let t1;
+	if ($[1] !== onLoad) {
+		t1 = (event) => {
+			setLoaded(true);
+			onLoad?.(event);
+		};
+		$[1] = onLoad;
+		$[2] = t1;
+	} else t1 = $[2];
+	const handleLoad = t1;
+	let t2;
+	if ($[3] !== loaded) {
+		t2 = { loaded };
+		$[3] = loaded;
+		$[4] = t2;
+	} else t2 = $[4];
+	let t3;
+	if ($[5] !== handleLoad) {
+		t3 = {
+			setImage,
+			handleLoad
+		};
+		$[5] = handleLoad;
+		$[6] = t3;
+	} else t3 = $[6];
+	let t4;
+	if ($[7] !== t2 || $[8] !== t3) {
+		t4 = {
+			state: t2,
+			effects: t3
+		};
+		$[7] = t2;
+		$[8] = t3;
+		$[9] = t4;
+	} else t4 = $[9];
+	return t4;
+};
+//#endregion
+export { usePlainImageStore };

package/dist/atoms/icons/chat-icon/chat-icon.d.mts

@@ -0,0 +1,4 @@
+//#region src/atoms/icons/chat-icon/chat-icon.d.ts
+declare const ChatIcon: () => import("react/jsx-runtime").JSX.Element;
+//#endregion
+export { ChatIcon };

package/dist/atoms/icons/chat-icon/chat-icon.mjs

@@ -0,0 +1,13 @@
+import { RoundedIcon } from "../rounded-icon/rounded-icon.mjs";
+import { jsx } from "react/jsx-runtime";
+import { BiChat } from "react-icons/bi";
+//#region src/atoms/icons/chat-icon/chat-icon.tsx
+const ChatIcon = () => /* @__PURE__ */ jsx(RoundedIcon, {
+	className: "animate-pulse flex items-center justify-center text-text-above-primary",
+	children: /* @__PURE__ */ jsx(BiChat, {
+		className: "size-5 md:size-7",
+		"aria-hidden": "true"
+	})
+});
+//#endregion
+export { ChatIcon };

package/dist/atoms/icons/copy-icon/copy-icon.d.mts

@@ -0,0 +1,6 @@
+//#region src/atoms/icons/copy-icon/copy-icon.d.ts
+declare const CopyIcon: () => import("react/jsx-runtime").JSX.Element;
+declare const CopiedIcon: () => import("react/jsx-runtime").JSX.Element;
+declare const CopyErrorIcon: () => import("react/jsx-runtime").JSX.Element;
+//#endregion
+export { CopiedIcon, CopyErrorIcon, CopyIcon };

package/dist/atoms/icons/copy-icon/copy-icon.mjs

@@ -0,0 +1,17 @@
+import { jsx } from "react/jsx-runtime";
+import { MdCheck, MdContentCopy, MdErrorOutline } from "react-icons/md";
+//#region src/atoms/icons/copy-icon/copy-icon.tsx
+const CopyIcon = () => /* @__PURE__ */ jsx(MdContentCopy, {
+	className: "size-4",
+	title: "Copy code"
+});
+const CopiedIcon = () => /* @__PURE__ */ jsx(MdCheck, {
+	className: "size-4",
+	title: "Copied!"
+});
+const CopyErrorIcon = () => /* @__PURE__ */ jsx(MdErrorOutline, {
+	className: "size-4",
+	title: "Copy failed"
+});
+//#endregion
+export { CopiedIcon, CopyErrorIcon, CopyIcon };

package/dist/atoms/icons/rounded-icon/index.d.mts

@@ -0,0 +1,2 @@
+import { RoundedIcon } from "./rounded-icon.mjs";
+export { RoundedIcon };

package/dist/atoms/icons/rounded-icon/rounded-icon.d.mts

@@ -0,0 +1,8 @@
+import { FC, PropsWithChildren } from "react";
+//#region src/atoms/icons/rounded-icon/rounded-icon.d.ts
+interface RoundedIconProps extends PropsWithChildren {
+  className?: string;
+}
+declare const RoundedIcon: FC<RoundedIconProps>;
+//#endregion
+export { RoundedIcon };

package/dist/atoms/icons/rounded-icon/rounded-icon.mjs

@@ -0,0 +1,8 @@
+import { jsx } from "react/jsx-runtime";
+//#region src/atoms/icons/rounded-icon/rounded-icon.tsx
+const RoundedIcon = ({ children, className }) => /* @__PURE__ */ jsx("div", {
+	className: `bg-accent flex h-[40px] w-[40px] cursor-pointer items-center justify-center rounded-full transition-all duration-300 hover:scale-125 md:h-[50px] md:w-[50px] ${className}`,
+	children
+});
+//#endregion
+export { RoundedIcon };

package/dist/atoms/links/anchor-link/anchor-link.d.mts

@@ -0,0 +1,31 @@
+import { AnchorHTMLAttributes, FC, ReactNode } from "react";
+//#region src/atoms/links/anchor-link/anchor-link.d.ts
+/**
+ * How a link decides when to prefetch its destination. This is a hint the design system passes to
+ * whatever link implementation the consumer injects — a router that cannot prefetch ignores it.
+ *
+ * - `"viewport"`: prefetch once the link scrolls into the viewport.
+ * - `"hover"`: prefetch only once the pointer or focus reaches the link. Reserved for link-dense
+ *   surfaces (archives, tag listings) where prefetching everything visible is disproportionate to
+ *   the odds any one link gets clicked.
+ * - `"never"`: no prefetching at all.
+ */
+type PrefetchStrategy = "viewport" | "hover" | "never";
+interface LinkComponentProps extends Omit<AnchorHTMLAttributes<HTMLAnchorElement>, "href"> {
+  href: string;
+  children?: ReactNode;
+  prefetch?: PrefetchStrategy;
+}
+/**
+ * What the design system needs from a link renderer. Consumers inject a router-aware implementation
+ * (`next/link`, a framework `<Link>`, and so on); without one, links fall back to {@link AnchorLink}.
+ */
+type LinkComponent = FC<LinkComponentProps>;
+/**
+ * The framework-free default: a real `<a>`, which navigates correctly everywhere but without
+ * client-side routing. `prefetch` is destructured away rather than spread, since it is not a DOM
+ * attribute and React would warn about it.
+ */
+declare const AnchorLink: LinkComponent;
+//#endregion
+export { AnchorLink, LinkComponent, LinkComponentProps, PrefetchStrategy };

package/dist/atoms/links/anchor-link/anchor-link.mjs

@@ -0,0 +1,14 @@
+import { jsx } from "react/jsx-runtime";
+//#region src/atoms/links/anchor-link/anchor-link.tsx
+/**
+* The framework-free default: a real `<a>`, which navigates correctly everywhere but without
+* client-side routing. `prefetch` is destructured away rather than spread, since it is not a DOM
+* attribute and React would warn about it.
+*/
+const AnchorLink = ({ href, children, prefetch: _prefetch, ...rest }) => /* @__PURE__ */ jsx("a", {
+	href,
+	...rest,
+	children
+});
+//#endregion
+export { AnchorLink };

package/dist/atoms/links/anchor-link/index.d.mts

@@ -0,0 +1,2 @@
+import { AnchorLink, LinkComponent, LinkComponentProps, PrefetchStrategy } from "./anchor-link.mjs";
+export { AnchorLink, type LinkComponent, type LinkComponentProps, type PrefetchStrategy };

package/dist/atoms/links/external-link/external-link.d.mts

@@ -0,0 +1,13 @@
+import { FC, ReactNode } from "react";
+//#region src/atoms/links/external-link/external-link.d.ts
+type ExternalLinkProps = {
+  href: string;
+  target?: string;
+  rel?: string;
+  children?: ReactNode;
+  className?: string;
+  onClick?: () => void;
+};
+declare const ExternalLink: FC<ExternalLinkProps>;
+//#endregion
+export { ExternalLink };

package/dist/atoms/links/external-link/external-link.mjs

@@ -0,0 +1,29 @@
+"use client";
+import { c } from "react/compiler-runtime";
+import { jsx } from "react/jsx-runtime";
+//#region src/atoms/links/external-link/external-link.tsx
+const ExternalLink = (t0) => {
+	const $ = c(7);
+	const { children, href, onClick, target, rel, className } = t0;
+	let t1;
+	if ($[0] !== children || $[1] !== className || $[2] !== href || $[3] !== onClick || $[4] !== rel || $[5] !== target) {
+		t1 = /* @__PURE__ */ jsx("a", {
+			href,
+			onClick,
+			className,
+			target,
+			rel,
+			children
+		});
+		$[0] = children;
+		$[1] = className;
+		$[2] = href;
+		$[3] = onClick;
+		$[4] = rel;
+		$[5] = target;
+		$[6] = t1;
+	} else t1 = $[6];
+	return t1;
+};
+//#endregion
+export { ExternalLink };

package/dist/atoms/links/external-link/index.d.mts

@@ -0,0 +1,2 @@
+import { ExternalLink } from "./external-link.mjs";
+export { ExternalLink };

package/dist/atoms/links/internal-link/index.d.mts

@@ -0,0 +1,2 @@
+import { InternalLink, InternalLinkProps } from "./internal-link.mjs";
+export { InternalLink, type InternalLinkProps };

package/dist/atoms/links/internal-link/internal-link.d.mts

@@ -0,0 +1,15 @@
+import { LinkComponent, PrefetchStrategy } from "../anchor-link/anchor-link.mjs";
+import "../anchor-link/index.mjs";
+import { FC, ReactNode } from "react";
+//#region src/atoms/links/internal-link/internal-link.d.ts
+interface InternalLinkProps {
+  to: string;
+  className?: string;
+  children?: ReactNode;
+  prefetch?: PrefetchStrategy;
+  onClick?: () => void;
+  linkComponent?: LinkComponent;
+}
+declare const InternalLink: FC<InternalLinkProps>;
+//#endregion
+export { InternalLink, InternalLinkProps };

package/dist/atoms/links/internal-link/internal-link.mjs

@@ -0,0 +1,12 @@
+import { AnchorLink } from "../anchor-link/anchor-link.mjs";
+import { jsx } from "react/jsx-runtime";
+//#region src/atoms/links/internal-link/internal-link.tsx
+const InternalLink = ({ children, className, to, onClick, prefetch = "viewport", linkComponent: Link = AnchorLink }) => /* @__PURE__ */ jsx(Link, {
+	className,
+	href: to,
+	prefetch,
+	onClick,
+	children
+});
+//#endregion
+export { InternalLink };

package/dist/atoms/loader/loader/index.d.mts

@@ -0,0 +1,2 @@
+import { Loader } from "./loader.mjs";
+export { Loader };

package/dist/atoms/loader/loader/loader.d.mts

@@ -0,0 +1,10 @@
+import { FC } from "react";
+//#region src/atoms/loader/loader/loader.d.ts
+interface LoaderProps {
+  size?: "sm" | "md" | "lg";
+  className?: string;
+  label?: string;
+}
+declare const Loader: FC<LoaderProps>;
+//#endregion
+export { Loader };

package/dist/atoms/loader/loader/loader.mjs

@@ -0,0 +1,62 @@
+"use client";
+import { MotionDiv } from "../../animation/motion-div/motion-div.mjs";
+import { c } from "react/compiler-runtime";
+import { jsx } from "react/jsx-runtime";
+//#region src/atoms/loader/loader/loader.tsx
+const sizeClasses = {
+	sm: "h-1.5 w-1.5",
+	md: "h-2.5 w-2.5",
+	lg: "h-3.5 w-3.5"
+};
+const gapClasses = {
+	sm: "gap-1",
+	md: "gap-2",
+	lg: "gap-3"
+};
+const dots = [
+	0,
+	1,
+	2
+];
+const Loader = (t0) => {
+	const $ = c(6);
+	const { size: t1, className, label: t2 } = t0;
+	const size = t1 === void 0 ? "md" : t1;
+	const label = t2 === void 0 ? "Loading" : t2;
+	const t3 = `flex items-center ${gapClasses[size]}${className ? ` ${className}` : ""}`;
+	let t4;
+	if ($[0] !== size) {
+		t4 = dots.map((i) => /* @__PURE__ */ jsx(MotionDiv, {
+			animate: { y: [
+				0,
+				-8,
+				0
+			] },
+			transition: {
+				duration: .6,
+				repeat: Infinity,
+				delay: i * .15,
+				ease: "easeInOut"
+			},
+			className: `${sizeClasses[size]} rounded-full bg-accent`
+		}, i));
+		$[0] = size;
+		$[1] = t4;
+	} else t4 = $[1];
+	let t5;
+	if ($[2] !== label || $[3] !== t3 || $[4] !== t4) {
+		t5 = /* @__PURE__ */ jsx("div", {
+			role: "status",
+			"aria-label": label,
+			className: t3,
+			children: t4
+		});
+		$[2] = label;
+		$[3] = t3;
+		$[4] = t4;
+		$[5] = t5;
+	} else t5 = $[5];
+	return t5;
+};
+//#endregion
+export { Loader };

package/dist/atoms/typography/input-field/index.d.mts

@@ -0,0 +1,2 @@
+import { InputField } from "./input-field.mjs";
+export { InputField };

package/dist/atoms/typography/input-field/input-field.d.mts

@@ -0,0 +1,9 @@
+import { FC, RefObject } from "react";
+//#region src/atoms/typography/input-field/input-field.d.ts
+interface InputFieldProps extends React.InputHTMLAttributes<HTMLInputElement> {
+  className?: string;
+  ref?: RefObject<HTMLInputElement | null>;
+}
+declare const InputField: FC<InputFieldProps>;
+//#endregion
+export { InputField };

package/dist/atoms/typography/input-field/input-field.mjs

@@ -0,0 +1,8 @@
+import { jsx } from "react/jsx-runtime";
+//#region src/atoms/typography/input-field/input-field.tsx
+const InputField = ({ className, ...props }) => /* @__PURE__ */ jsx("input", {
+	className: `glow-container rounded-xl bg-none outline-none text-accent${className ? ` ${className}` : ""}`,
+	...props
+});
+//#endregion
+export { InputField };

package/dist/atoms/typography/label/index.d.mts

@@ -0,0 +1,2 @@
+import { Label, LabelProps } from "./label.mjs";
+export { Label, type LabelProps };

package/dist/atoms/typography/label/label.d.mts

@@ -0,0 +1,9 @@
+import { FC, InputHTMLAttributes, ReactElement } from "react";
+//#region src/atoms/typography/label/label.d.ts
+interface LabelProps extends Omit<InputHTMLAttributes<HTMLLabelElement>, "className"> {
+  value: string;
+  icon?: ReactElement;
+}
+declare const Label: FC<LabelProps>;
+//#endregion
+export { Label, LabelProps };

package/dist/atoms/typography/label/label.mjs

@@ -0,0 +1,11 @@
+import { jsxs } from "react/jsx-runtime";
+//#region src/atoms/typography/label/label.tsx
+const Label = ({ value, icon, ...labelProps }) => {
+	return /* @__PURE__ */ jsxs("label", {
+		htmlFor: labelProps.id,
+		className: "text-matrix-green mb-2 flex items-center gap-2 font-medium",
+		children: [icon, value]
+	});
+};
+//#endregion
+export { Label };

package/dist/atoms/typography/markdown/markdown-plugins.mjs

@@ -0,0 +1,16 @@
+import remarkEmoji from "remark-emoji";
+import remarkGfm from "remark-gfm";
+import remarkMath from "remark-math";
+//#region src/atoms/typography/markdown/markdown-plugins.ts
+/**
+* Shared by the renderer and by the block splitter in use-markdown-store: the splitter must see the
+* same block-level constructs the renderer does, or it cuts a block in half (display math, tables)
+* and the renderer then never matches it.
+*/
+const markdownRemarkPlugins = [
+	remarkGfm,
+	remarkMath,
+	remarkEmoji
+];
+//#endregion
+export { markdownRemarkPlugins };

package/dist/atoms/typography/markdown/markdown.d.mts

@@ -0,0 +1,7 @@
+//#region src/atoms/typography/markdown/markdown.d.ts
+declare const Markdown: import("react").MemoExoticComponent<({ content, id }: {
+  content: string;
+  id: string;
+}) => import("react/jsx-runtime").JSX.Element[]>;
+//#endregion
+export { Markdown };

package/dist/atoms/typography/markdown/markdown.mjs

@@ -0,0 +1,23 @@
+import { markdownRemarkPlugins } from "./markdown-plugins.mjs";
+import { useMarkdownStore } from "./use-markdown-store.mjs";
+import { memo } from "react";
+import { jsx } from "react/jsx-runtime";
+import ReactMarkdown from "react-markdown";
+import rehypeHighlight from "rehype-highlight";
+import rehypeKatex from "rehype-katex";
+//#region src/atoms/typography/markdown/markdown.tsx
+const MarkdownBlock = memo(({ content }) => /* @__PURE__ */ jsx(ReactMarkdown, {
+	remarkPlugins: markdownRemarkPlugins,
+	rehypePlugins: [rehypeHighlight, rehypeKatex],
+	children: content
+}), (prevProps, nextProps) => prevProps.content === nextProps.content);
+MarkdownBlock.displayName = "MarkdownBlock";
+const MarkdownRenderer = ({ content, id }) => {
+	const { state } = useMarkdownStore(content);
+	const { blocks } = state;
+	return blocks.map((block, index) => /* @__PURE__ */ jsx(MarkdownBlock, { content: block }, `${id}-block_${index}`));
+};
+const Markdown = memo(MarkdownRenderer);
+Markdown.displayName = "Markdown";
+//#endregion
+export { Markdown };

package/dist/atoms/typography/markdown/use-markdown-store.mjs

@@ -0,0 +1,24 @@
+import { markdownRemarkPlugins } from "./markdown-plugins.mjs";
+import { useMemo } from "react";
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+//#region src/atoms/typography/markdown/use-markdown-store.ts
+const parser = unified().use(remarkParse).use(markdownRemarkPlugins);
+/**
+* Splits content into top-level blocks so each memoises independently while a response streams.
+* If any node lacks source offsets the whole content is returned as one block: that loses the
+* memoisation granularity, but never drops content.
+*/
+const topLevelBlocks = (content) => {
+	const blocks = [];
+	for (const { position } of parser.parse(content).children) {
+		if (position?.start.offset === void 0 || position.end.offset === void 0) return [content];
+		blocks.push(content.slice(position.start.offset, position.end.offset));
+	}
+	return blocks;
+};
+const useMarkdownStore = (content) => {
+	return { state: { blocks: useMemo(() => topLevelBlocks(content), [content]) } };
+};
+//#endregion
+export { useMarkdownStore };

package/dist/atoms/typography/terminal-blocks/index.d.mts

@@ -0,0 +1,2 @@
+import { Cursor, ErrorText, QuoteText, SuccessText, TerminalLine, TerminalQuoteLine } from "./terminal-blocks.mjs";
+export { Cursor, ErrorText, QuoteText, SuccessText, TerminalLine, TerminalQuoteLine };

package/dist/atoms/typography/terminal-blocks/terminal-blocks.d.mts

@@ -0,0 +1,13 @@
+import { FC, PropsWithChildren } from "react";
+//#region src/atoms/typography/terminal-blocks/terminal-blocks.d.ts
+type TerminalLineSize = "sm" | "md" | "lg";
+declare const TerminalLine: FC<PropsWithChildren<{
+  size?: TerminalLineSize;
+}>>;
+declare const TerminalQuoteLine: FC<PropsWithChildren>;
+declare const Cursor: FC<PropsWithChildren>;
+declare const ErrorText: FC<PropsWithChildren>;
+declare const SuccessText: FC<PropsWithChildren>;
+declare const QuoteText: FC<PropsWithChildren>;
+//#endregion
+export { Cursor, ErrorText, QuoteText, SuccessText, TerminalLine, TerminalLineSize, TerminalQuoteLine };