@bysages/solid 0.2.1 → 0.2.3

package/dist/ai-response-B_586r27.mjs

@@ -0,0 +1,139 @@
+import { injectComponentStyle } from "@bysages/core";
+import { mergeProps, spread, template, use } from "solid-js/web";
+import { createEffect, createMemo, onMount, splitProps } from "solid-js";
+import { renderHtml } from "@tanstack/markdown/html";
+//#region src/components/ai-response/code-copy.ts
+/** The two glyphs a copy affordance needs: the stamp and its
+* confirmation. Inline SVG keeps the enhancement framework-agnostic —
+* it lives beside the renderer's generated code HTML. */
+const COPY_CODE_ICON = `<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><rect width="14" height="14" x="8" y="8" rx="2" ry="2"/><path d="M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2"/></svg>`;
+const COPIED_CODE_ICON = `<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M20 6 9 17l-5-5"/></svg>`;
+/** How long the confirmation stays before the stamp returns. */
+const REVERT_MS = 1500;
+/** Make sure every fenced block under `host` carries its copy stamp.
+* The stamp anchors to a wrapper outside the scrolling `pre` — inside,
+* it would fix to the overflow area and travel out of view with the
+* code. The renderer rebuilds the markdown as one HTML string on every
+* stream tick, so this stays idempotent and cheap enough to re-run
+* after each patch. */
+function decorateCodeCopy(host, copyLabel) {
+	for (const pre of host.querySelectorAll("pre")) {
+		let body = pre.parentElement;
+		if (!body || body.getAttribute("data-part") !== "code-body") {
+			body = document.createElement("div");
+			body.setAttribute("data-scope", "ai");
+			body.setAttribute("data-part", "code-body");
+			pre.replaceWith(body);
+			body.appendChild(pre);
+		}
+		let button = body.querySelector("[data-part=\"code-copy\"]");
+		if (!button) {
+			button = document.createElement("button");
+			button.type = "button";
+			button.setAttribute("data-scope", "ai");
+			button.setAttribute("data-part", "code-copy");
+			button.innerHTML = COPY_CODE_ICON;
+			body.appendChild(button);
+		}
+		button.title = copyLabel;
+		button.setAttribute("aria-label", copyLabel);
+	}
+}
+/** The one delegated click for the whole response: copy the block's
+* text and confirm in place, then return the stamp after a beat. */
+async function clickCodeCopy(event, copyLabel, copiedLabel) {
+	const button = event.target?.closest("[data-part=\"code-copy\"]");
+	const pre = button?.closest("[data-part=\"code-body\"]")?.querySelector("pre");
+	if (!button || !pre) return;
+	await navigator.clipboard.writeText(pre.textContent ?? "");
+	button.innerHTML = COPIED_CODE_ICON;
+	button.setAttribute("data-state", "copied");
+	button.title = copiedLabel;
+	button.setAttribute("aria-label", copiedLabel);
+	setTimeout(() => {
+		if (!button.isConnected) return;
+		button.innerHTML = COPY_CODE_ICON;
+		button.removeAttribute("data-state");
+		button.title = copyLabel;
+		button.setAttribute("aria-label", copyLabel);
+	}, REVERT_MS);
+}
+//#endregion
+//#region src/components/ai-response/tables.ts
+/** Wide tables ride a scrolling lane instead of bursting the column.
+* The lane is a plain div: the table-as-scroll-container form is what
+* ate the mouse wheel over plain tables. Idempotent, so it can run
+* after every stream patch. */
+const lanes = /* @__PURE__ */ new Set();
+let laneObserver;
+/** A lane's verdict must follow its box — the panel around it can
+* resize at any moment, so each lane stays observed and re-decided
+* whenever its width changes. */
+function watchLane(lane) {
+	if (lanes.has(lane)) return;
+	lanes.add(lane);
+	laneObserver ??= new ResizeObserver(() => {
+		for (const lane of lanes) {
+			if (!lane.isConnected) {
+				laneObserver.unobserve(lane);
+				lanes.delete(lane);
+				continue;
+			}
+			lane.toggleAttribute("data-scrollable", lane.scrollWidth > lane.clientWidth);
+		}
+	});
+	laneObserver.observe(lane);
+}
+function wrapResponseTables(root) {
+	for (const table of root.querySelectorAll("table")) {
+		if (table.parentElement?.hasAttribute("data-table-scroll")) continue;
+		const lane = document.createElement("div");
+		lane.setAttribute("data-table-scroll", "");
+		table.replaceWith(lane);
+		lane.append(table);
+	}
+	for (const lane of root.querySelectorAll("[data-table-scroll]")) {
+		lane.toggleAttribute("data-scrollable", lane.scrollWidth > lane.clientWidth);
+		watchLane(lane);
+	}
+}
+//#endregion
+//#region src/components/ai-response/index.tsx
+var _tmpl$ = /*#__PURE__*/ template(`<div>`);
+/** Markdown set on the paper. Rendering goes through
+* `@tanstack/markdown`, whose defaults leave raw HTML and executable
+* links inert — streaming-safe by construction. */
+function Response(props) {
+	injectComponentStyle("ai");
+	const [own, rest] = splitProps(props, [
+		"content",
+		"highlighter",
+		"copyLabel",
+		"copiedLabel"
+	]);
+	const html = createMemo(() => renderHtml(own.content, own.highlighter ? { highlighter: own.highlighter } : void 0));
+	let root;
+	onMount(() => createEffect(() => {
+		html();
+		if (root) decorateCodeCopy(root, own.copyLabel ?? "Copy code");
+		if (root) wrapResponseTables(root);
+	}));
+	const onClick = (event) => {
+		clickCodeCopy(event, own.copyLabel ?? "Copy code", own.copiedLabel ?? "Copied");
+	};
+	return (() => {
+		var _el$ = _tmpl$();
+		use((el) => root = el, _el$);
+		spread(_el$, mergeProps(rest, {
+			"data-scope": "ai",
+			"data-part": "response",
+			"onClick": onClick,
+			get innerHTML() {
+				return html();
+			}
+		}), false, false);
+		return _el$;
+	})();
+}
+//#endregion
+export { Response as t };

package/dist/chevron-GWEoEYdO.mjs

@@ -0,0 +1,9 @@
+import { template } from "solid-js/web";
+//#region src/components/ai/chevron.tsx
+var _tmpl$ = /*#__PURE__*/ template(`<svg viewBox="0 0 16 16"fill=none aria-hidden=true><path d="M6 4l4 4-4 4"stroke=currentColor stroke-width=1.5 stroke-linecap=round stroke-linejoin=round>`);
+/** The folding chevron the shared indicator turns. */
+function chevron() {
+	return _tmpl$();
+}
+//#endregion
+export { chevron as t };

package/dist/components/accordion/index.d.mts

@@ -0,0 +1,7 @@
+import { Accordion as Accordion$1 } from "@ark-ui/solid/accordion";
+//#region src/components/accordion/index.d.ts
+/** Ark's Accordion, dressed in the paper-and-ink system: a ruled sheet
+ * folded by quiet rows, unfolding with a spring-chevoned dissolve. The
+ * API is Ark's own — Root, Item, ItemTrigger, ItemContent, ItemIndicator. */
+export declare const Accordion: typeof Accordion$1;
+//#endregion

package/dist/components/accordion/index.mjs

@@ -0,0 +1,10 @@
+import { injectComponentStyle } from "@bysages/core";
+import { Accordion as Accordion$1 } from "@ark-ui/solid/accordion";
+//#region src/components/accordion/index.ts
+/** Ark's Accordion, dressed in the paper-and-ink system: a ruled sheet
+* folded by quiet rows, unfolding with a spring-chevoned dissolve. The
+* API is Ark's own — Root, Item, ItemTrigger, ItemContent, ItemIndicator. */
+const Accordion = Accordion$1;
+injectComponentStyle("accordion");
+//#endregion
+export { Accordion };

package/dist/components/affix/index.d.mts

@@ -0,0 +1,20 @@
+import { JSX } from "solid-js";
+//#region src/components/affix/index.d.ts
+export interface AffixProps extends JSX.HTMLAttributes<HTMLDivElement> {
+  /** Where the content pins when it reaches the top of the scrolling
+   * ancestor — the height of any fixed header it must clear. */
+  offsetTop?: string;
+  /** Where it pins from the bottom instead, for footers and action bars. */
+  offsetBottom?: string;
+}
+/**
+ * A nail: the wrapped content travels with the page until it reaches its
+ * offset, then stays put while the page moves on. The semantics are
+ * plain `position: sticky` — pinning is relative to the nearest
+ * *scrolling* ancestor, so the element works inside a scrollable panel
+ * exactly as it does on the page itself, and a parent with
+ * `overflow: hidden` clips the pin. Both offsets may be given: the
+ * content then holds its place inside that band.
+ */
+export declare function Affix(props: AffixProps): JSX.Element;
+//#endregion

package/dist/components/affix/index.mjs

@@ -0,0 +1,35 @@
+import { injectComponentStyle } from "@bysages/core";
+import { mergeProps, spread, template } from "solid-js/web";
+import { splitProps } from "solid-js";
+//#region src/components/affix/index.tsx
+var _tmpl$ = /*#__PURE__*/ template(`<div>`);
+/**
+* A nail: the wrapped content travels with the page until it reaches its
+* offset, then stays put while the page moves on. The semantics are
+* plain `position: sticky` — pinning is relative to the nearest
+* *scrolling* ancestor, so the element works inside a scrollable panel
+* exactly as it does on the page itself, and a parent with
+* `overflow: hidden` clips the pin. Both offsets may be given: the
+* content then holds its place inside that band.
+*/
+function Affix(props) {
+	injectComponentStyle("affix");
+	const [own, rest] = splitProps(props, ["offsetTop", "offsetBottom"]);
+	return (() => {
+		var _el$ = _tmpl$();
+		spread(_el$, mergeProps(rest, {
+			get style() {
+				return {
+					...rest.style,
+					top: own.offsetTop ?? "0px",
+					bottom: own.offsetBottom ?? "0px"
+				};
+			},
+			"data-scope": "affix",
+			"data-part": "root"
+		}), false, false);
+		return _el$;
+	})();
+}
+//#endregion
+export { Affix };

package/dist/components/ai/index.d.mts

@@ -0,0 +1,2 @@
+import { a as AiLoader, c as ReasoningUIPart, d as StepStartUIPart, f as TextUIPart, h as UIMessagePart, i as AiConversation, l as SourceDocumentUIPart, m as UIMessage, n as AiActions, o as DataUIPart, p as ToolUIPart, r as AiContent, s as FileUIPart, t as Ai, u as SourceUrlUIPart } from "../../index-B4XS2n2y.mjs";
+export { Ai, AiActions, AiContent, AiConversation, AiLoader, type DataUIPart, type FileUIPart, type ReasoningUIPart, type SourceDocumentUIPart, type SourceUrlUIPart, type StepStartUIPart, type TextUIPart, type ToolUIPart, type UIMessage, type UIMessagePart };

package/dist/components/ai/index.mjs

@@ -0,0 +1,69 @@
+import { Action } from "../ai-action/index.mjs";
+import { AiMessage as Message } from "../ai-message/index.mjs";
+import { AiPromptInput as PromptInput } from "../ai-prompt-input/index.mjs";
+import { AiReasoning as Reasoning } from "../ai-reasoning/index.mjs";
+import { t as Response } from "../../ai-response-B_586r27.mjs";
+import { AiSource as Source, AiSources as Sources } from "../ai-source/index.mjs";
+import { AiSuggestion as Suggestion } from "../ai-suggestion/index.mjs";
+import { AiTool as Tool } from "../ai-tool/index.mjs";
+import { injectComponentStyle } from "@bysages/core";
+import { mergeProps, spread, template } from "solid-js/web";
+//#region src/components/ai/index.tsx
+var _tmpl$ = /*#__PURE__*/ template(`<div>`);
+/** A conversation column: Root is the log, Message carries a role, and
+* the speaking parts — Response, Reasoning, Tool, Sources — part the
+* stream. The interactive folds are the shared Collapsible wearing a
+* `data-ai` marker, so the machine work is never ours. Parts stay
+* agnostic of any client; consumers map their message format (e.g. the
+* `UIMessage` parts re-exported here) onto these primitives. */
+function part(name, extra = {}) {
+	function Component(props) {
+		return (() => {
+			var _el$ = _tmpl$();
+			spread(_el$, mergeProps(extra, props, {
+				"data-scope": "ai",
+				get ["data-part"]() {
+					return name.toLowerCase();
+				}
+			}), false, false);
+			return _el$;
+		})();
+	}
+	return Component;
+}
+/** The log itself: the column every stroke lands in, a landmark to
+* screen readers. */
+const AiConversation = part("Conversation", {
+	role: "log",
+	"aria-label": "Conversation"
+});
+/** The bubble's inner measure — content that belongs to neither side
+* specifically. */
+const AiContent = part("Content");
+/** The quiet row under a message — copy, retry, feedback. */
+const AiActions = part("Actions");
+/** The while-it-works whisper for the in-flight turns. */
+const AiLoader = part("Loader", {
+	role: "status",
+	"aria-label": "Loading"
+});
+/** The whole family under one handle — `Ai.Conversation`,
+* `Ai.MessageContent`, and the rest. */
+const Ai = Object.assign(AiConversation, {
+	Conversation: AiConversation,
+	MessageContent: AiContent,
+	Actions: AiActions,
+	Loader: AiLoader,
+	Message,
+	Response,
+	Reasoning,
+	Tool,
+	Sources,
+	Source,
+	Action,
+	Suggestion,
+	PromptInput
+});
+injectComponentStyle("ai");
+//#endregion
+export { Ai, AiActions, AiContent, AiConversation, AiLoader };

package/dist/components/ai-action/index.d.mts

@@ -0,0 +1,13 @@
+import { JSX } from "solid-js";
+//#region src/components/ai-action/index.d.ts
+export interface ActionProps extends JSX.HTMLAttributes<HTMLButtonElement> {
+  /** What the button does, spoken to assistive tech and shown as
+   * the hover title — copy, retry, thumbs. */
+  label: string;
+}
+/** A quiet icon button — copy, retry, thumbs. The label names it to
+ * assistive tech and as the hover title. The control itself is the
+ * shared Button in its ghost register. */
+export declare function Action(props: ActionProps): JSX.Element;
+//#endregion
+export { Action as AiAction };

package/dist/components/ai-action/index.mjs

@@ -0,0 +1,27 @@
+import { Button } from "../button/index.mjs";
+import { injectComponentStyle } from "@bysages/core";
+import { createComponent, mergeProps } from "solid-js/web";
+import { splitProps } from "solid-js";
+//#region src/components/ai-action/index.tsx
+/** A quiet icon button — copy, retry, thumbs. The label names it to
+* assistive tech and as the hover title. The control itself is the
+* shared Button in its ghost register. */
+function Action(props) {
+	injectComponentStyle("ai");
+	const [own, rest] = splitProps(props, ["label", "children"]);
+	return createComponent(Button, mergeProps({
+		variant: "ghost",
+		size: "sm",
+		square: true,
+		get ["aria-label"]() {
+			return own.label;
+		},
+		get title() {
+			return own.label;
+		}
+	}, rest, { get children() {
+		return own.children;
+	} }));
+}
+//#endregion
+export { Action, Action as AiAction };

package/dist/components/ai-attachments/index.d.mts

@@ -0,0 +1,20 @@
+import { JSX } from "solid-js";
+//#region src/components/ai-attachments/index.d.ts
+export type AttachmentStatus = "uploading" | "ready" | "error";
+export interface AttachmentProps extends JSX.HTMLAttributes<HTMLSpanElement> {
+  /** The file's name — it picks the glyph by extension. */
+  name: string;
+  /** The file's size in bytes, when known — rendered human. */
+  size?: number;
+  /** The upload's state on the wire. */
+  status?: AttachmentStatus;
+  onRemove?: () => void;
+}
+/** One file riding the prompt: its glyph by extension, its name and
+ * human size, and a quiet way to take it back off. Uploading reads as
+ * a dashed ghost, error as danger ink. */
+export declare function Attachment(props: AttachmentProps): JSX.Element;
+/** The row the files ride in — a wrapping line of chips. */
+export declare function Attachments(props: JSX.HTMLAttributes<HTMLSpanElement>): JSX.Element;
+//#endregion
+export { Attachment as AiAttachment, Attachments as AiAttachments };

package/dist/components/ai-attachments/index.mjs

@@ -0,0 +1,98 @@
+import { injectComponentStyle } from "@bysages/core";
+import { delegateEvents, effect, insert, memo, mergeProps, setAttribute, spread, template } from "solid-js/web";
+import { splitProps } from "solid-js";
+//#region src/components/ai-attachments/index.tsx
+var _tmpl$ = /*#__PURE__*/ template(`<svg viewBox="0 0 16 16"aria-hidden=true fill=none stroke=currentColor stroke-width=1.5 stroke-linecap=square><rect x=2.5 y=3.5 width=11 height=9></rect><path d="M2.5 10.5 6 7l3 3 2-1.5 2.5 2"></path><circle cx=6 cy=6 r=0.75 fill=currentColor stroke=none>`);
+var _tmpl$2 = /*#__PURE__*/ template(`<svg viewBox="0 0 16 16"aria-hidden=true fill=none stroke=currentColor stroke-width=1.5 stroke-linecap=square><path d="M4 2.5h5l3 3V13.5H4z"></path><path d="M9 2.5v3h3">`);
+var _tmpl$3 = /*#__PURE__*/ template(`<svg viewBox="0 0 16 16"width=12 height=12 aria-hidden=true fill=none stroke=currentColor stroke-width=1.5 stroke-linecap=square><path d="M4 4l8 8M12 4l-8 8">`);
+var _tmpl$4 = /*#__PURE__*/ template(`<span><span></span><button type=button data-remove>`);
+var _tmpl$5 = /*#__PURE__*/ template(`<span>`);
+function imageGlyph() {
+	return _tmpl$();
+}
+function fileGlyph() {
+	return _tmpl$2();
+}
+function removeGlyph() {
+	return _tmpl$3();
+}
+const IMAGE_EXTS = [
+	"png",
+	"jpg",
+	"jpeg",
+	"gif",
+	"webp",
+	"svg",
+	"avif",
+	"bmp",
+	"ico"
+];
+const isImage = (name) => IMAGE_EXTS.includes(name.split(".").pop()?.toLowerCase() ?? "");
+const humanSize = (bytes) => {
+	if (bytes < 1024) return `${bytes} B`;
+	const units = [
+		"KB",
+		"MB",
+		"GB"
+	];
+	let value = bytes;
+	let unit = -1;
+	do {
+		value /= 1024;
+		unit += 1;
+	} while (value >= 1024 && unit < units.length - 1);
+	return `${value.toFixed(1)} ${units[unit]}`;
+};
+/** One file riding the prompt: its glyph by extension, its name and
+* human size, and a quiet way to take it back off. Uploading reads as
+* a dashed ghost, error as danger ink. */
+function Attachment(props) {
+	injectComponentStyle("ai");
+	const [own, rest] = splitProps(props, [
+		"name",
+		"size",
+		"status",
+		"onRemove"
+	]);
+	return (() => {
+		var _el$4 = _tmpl$4(), _el$5 = _el$4.firstChild, _el$6 = _el$5.nextSibling;
+		spread(_el$4, mergeProps(rest, {
+			"data-scope": "ai",
+			"data-part": "attachment",
+			get ["data-status"]() {
+				return own.status ?? "ready";
+			}
+		}), false, true);
+		insert(_el$4, (() => {
+			var _c$ = memo(() => !!isImage(own.name));
+			return () => _c$() ? imageGlyph() : fileGlyph();
+		})(), _el$5);
+		insert(_el$5, () => own.name);
+		insert(_el$4, (() => {
+			var _c$2 = memo(() => own.size !== void 0);
+			return () => _c$2() ? (() => {
+				var _el$7 = _tmpl$5();
+				insert(_el$7, () => humanSize(own.size));
+				return _el$7;
+			})() : null;
+		})(), _el$6);
+		_el$6.$$click = () => own.onRemove?.();
+		insert(_el$6, removeGlyph);
+		effect(() => setAttribute(_el$6, "aria-label", `Remove ${own.name}`));
+		return _el$4;
+	})();
+}
+/** The row the files ride in — a wrapping line of chips. */
+function Attachments(props) {
+	return (() => {
+		var _el$8 = _tmpl$5();
+		spread(_el$8, mergeProps(props, {
+			"data-scope": "ai",
+			"data-part": "attachments"
+		}), false, false);
+		return _el$8;
+	})();
+}
+delegateEvents(["click"]);
+//#endregion
+export { Attachment as AiAttachment, Attachment, Attachments as AiAttachments, Attachments };

package/dist/components/ai-message/index.d.mts

@@ -0,0 +1,13 @@
+import { JSX } from "solid-js";
+//#region src/components/ai-message/index.d.ts
+export type MessageRole = "user" | "assistant" | "system";
+export interface MessageProps extends Omit<JSX.HTMLAttributes<HTMLElement>, "role"> {
+  /** Whose stroke this is — the user's words sit in a recessed
+   * bubble, the assistant speaks flat on the paper. */
+  role?: MessageRole;
+}
+/** Whose stroke this is — the user's words sit in a recessed bubble,
+ * the assistant speaks flat on the paper. */
+export declare function Message(props: MessageProps): JSX.Element;
+//#endregion
+export { Message as AiMessage };

package/dist/components/ai-message/index.mjs

@@ -0,0 +1,24 @@
+import { injectComponentStyle } from "@bysages/core";
+import { mergeProps, spread, template } from "solid-js/web";
+import { splitProps } from "solid-js";
+//#region src/components/ai-message/index.tsx
+var _tmpl$ = /*#__PURE__*/ template(`<article>`);
+/** Whose stroke this is — the user's words sit in a recessed bubble,
+* the assistant speaks flat on the paper. */
+function Message(props) {
+	injectComponentStyle("ai");
+	const [own, rest] = splitProps(props, ["role"]);
+	return (() => {
+		var _el$ = _tmpl$();
+		spread(_el$, mergeProps(rest, {
+			"data-scope": "ai",
+			"data-part": "message",
+			get ["data-role"]() {
+				return own.role ?? "assistant";
+			}
+		}), false, false);
+		return _el$;
+	})();
+}
+//#endregion
+export { Message as AiMessage, Message };

package/dist/components/ai-prompt-input/index.d.mts

@@ -0,0 +1,45 @@
+import { JSX } from "solid-js";
+//#region src/components/ai-prompt-input/index.d.ts
+export interface PromptInputProps extends Omit<JSX.HTMLAttributes<HTMLFormElement>, "onSubmit" | "value"> {
+  /** The draft in the vessel — bind `value`; it clears itself on
+   * a successful submit. */
+  value?: string;
+  onValueChange?: (value: string) => void;
+  onSubmit?: (value: string) => void;
+  onStop?: () => void;
+  /** The quiet invitation before the reader types. */
+  placeholder?: string;
+  /** Still the words on the canvas, but the submit seal does
+   * nothing and Enter stays a line break. */
+  disabled?: boolean;
+  /** The machine is working — the seal becomes a stop seal and
+   * Enter holds its breath. */
+  busy?: boolean;
+  /** Attachments riding above the text. */
+  header?: JSX.Element;
+  /** The tools at the text's left. */
+  leading?: JSX.Element;
+  /** The row at the text's right — the send seal falls there by
+   * default. */
+  trailing?: JSX.Element;
+  /** The tools beneath the text. */
+  footer?: JSX.Element;
+  /** The controls that close the footer row — the seal falls there
+   * when a footer exists. */
+  footerEnd?: JSX.Element;
+}
+/** The prompt vessel: the shared field textarea — self-growing on the
+ * machine's autoresize — with the submit seal riding its last line.
+ * Around the body, the slot props answer the composer's anatomy:
+ * `header` for attachments riding above, `leading` for the tools at
+ * the text's left, `trailing` for the seal itself, `footer` for the
+ * tools beneath, and `footerEnd` for the controls that close the
+ * footer row — the seal falls there by default, so a model picker
+ * dropped in rides the send's shoulder. An empty slot renders no part,
+ * so the bare vessel stays one quiet line. Controlled — bind `value`
+ * and take the text on `onSubmit`. Enter sends; Shift+Enter breaks the
+ * line. While `busy` the seal becomes a stop seal and Enter holds its
+ * breath. */
+export declare function PromptInput(props: PromptInputProps): JSX.Element;
+//#endregion
+export { PromptInput as AiPromptInput };