@parallelworks/ui 0.18.0 → 0.19.1

package/dist/ai/strings.js

@@ -0,0 +1,175 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+//#region src/ai/strings.tsx
+var defaultChatStrings = {
+	modal: {
+		cancel: "Cancel",
+		save: "Save",
+		loading: "Loading…"
+	},
+	shareConversation: {
+		title: "Share Conversation",
+		loadError: "Failed to load sharing settings",
+		saveSuccess: "Sharing settings saved",
+		orgAccess: "Organization Access",
+		orgCanView: "Anyone in the organization can view",
+		allowCollaboration: "Allow collaboration (edit messages)",
+		groupAccess: "Group Access",
+		noGroups: "No groups have access yet",
+		viewOnly: "View only",
+		canCollaborate: "Can collaborate",
+		remove: "Remove",
+		addGroups: "Add groups…",
+		info: /* @__PURE__ */ jsxs(Fragment, { children: [
+			/* @__PURE__ */ jsx("strong", { children: "View" }),
+			" permission allows reading the conversation.",
+			/* @__PURE__ */ jsx("br", {}),
+			/* @__PURE__ */ jsx("strong", { children: "Collaborate" }),
+			" permission allows adding messages."
+		] }),
+		shareButton: "Share conversation"
+	},
+	blockedGroup: {
+		title: "Billing group \"{group}\" is over its allocation",
+		message: "It has reached its allocation limit. Messages to this provider are paused until your administrator increases the allocation."
+	},
+	queue: { remove: "Remove queued message" },
+	activity: {
+		tokens: (input, output) => `↑${input} ↓${output} tokens`,
+		stop: "Stop"
+	},
+	emptyState: {
+		greeting: null,
+		modernSubtitle: "Pick a starter below or type a question to your selected model.",
+		noProvidersTitle: "No AI providers configured",
+		noProvidersBody: "To start chatting, add an AI provider.",
+		addProvider: "Add a provider",
+		sessionUnreachableTitle: (session) => /* @__PURE__ */ jsxs(Fragment, { children: [
+			"Session “",
+			session,
+			"” is not reachable"
+		] }),
+		sessionUnreachableBody: "The session may be offline or still starting up. You can select a different model to continue.",
+		retry: "Retry"
+	},
+	input: {
+		placeholder: "Ask anything",
+		placeholderLoading: "Loading models...",
+		placeholderNoProviders: "Add an AI provider to start chatting",
+		attachFiles: "Attach files",
+		stopGenerating: "Stop generating (Escape)",
+		sendMessage: "Send message (Enter)",
+		filesAttached: (count) => `${count} file${count > 1 ? "s" : ""} attached`
+	},
+	thinking: {
+		label: "Thinking",
+		ellipsis: "Thinking...",
+		thoughtFor: (duration) => `Thought for ${duration}`,
+		activity: "Activity"
+	},
+	thread: { viewOnly: "You have view only access" },
+	sidebar: {
+		groupToday: "Today",
+		groupYesterday: "Yesterday",
+		groupThisWeek: "This Week",
+		groupThisMonth: "This Month",
+		groupOlder: "Older",
+		untitled: "Untitled",
+		rename: "Rename",
+		share: "Share",
+		delete: "Delete",
+		sharedWithYou: "Shared with you",
+		moreOptions: "More options",
+		openSidebar: "Open sidebar",
+		closeSidebar: "Close sidebar",
+		newChat: "New chat",
+		attachments: "Attachments",
+		connectTools: "Connect Tools",
+		manageProviders: "Manage Providers",
+		noConversations: "No conversations yet",
+		deleteTitle: "Delete Conversation",
+		deleteBody: "Are you sure you want to delete this conversation? This action cannot be undone.",
+		deleteAction: "Delete",
+		renameTitle: "Rename Conversation",
+		renameAction: "Rename",
+		renameLabel: "Conversation title",
+		renamePlaceholder: "Enter a new title"
+	},
+	attachmentUpload: {
+		fileTooLarge: (maxSize) => `File too large. Maximum size is ${maxSize}`,
+		maxFilesAllowed: (max) => `Maximum ${max} files allowed`,
+		remove: "Remove",
+		dropFilesHere: "Drop files here",
+		addFiles: "Add files (drag or click)"
+	},
+	attachmentManager: {
+		title: "Attachments",
+		empty: "No attachments yet",
+		download: "Download",
+		delete: "Delete",
+		loadMore: "Load more",
+		loading: "Loading..."
+	},
+	branch: {
+		previous: "Previous branch",
+		next: "Next branch"
+	},
+	chrome: {
+		searchPlaceholder: "Search conversations",
+		searchLabel: "Search conversations (⌘/Ctrl+Shift+F)",
+		noMatches: "No conversations match your search",
+		download: "Download",
+		exportError: "Failed to export conversation",
+		jumpToLatest: "Jump to latest"
+	},
+	messageMeta: {
+		stopped: "Stopped",
+		showMore: "Show more",
+		showLess: "Show less",
+		tokens: (total) => `${total.toLocaleString()} tokens`,
+		tokensBreakdown: (prompt, completion) => `${prompt.toLocaleString()} in · ${completion.toLocaleString()} out`,
+		copy: "Copy message",
+		edit: "Edit message",
+		regenerate: "Regenerate response",
+		retry: "Retry",
+		editPlaceholder: "Edit your message...",
+		cancel: "Cancel",
+		send: "Send"
+	},
+	permissions: {
+		choose: "Choose what the agent may do",
+		readOnly: "Read only",
+		acceptEdits: "Accept edits",
+		bypassPermissions: "Bypass permissions",
+		plan: "Plan",
+		readOnlyHint: "The workspace can be read but not changed.",
+		acceptEditsHint: "File edits are applied without asking. The workspace can be changed without your review.",
+		bypassPermissionsHint: "Every action is taken without asking, including commands that change the system.",
+		planHint: "The workspace is left unchanged while a plan is drafted."
+	},
+	agentTranscript: {
+		showMore: "Show more",
+		showLess: "Show less",
+		running: "Running…",
+		done: "Done",
+		failed: "Failed",
+		interrupted: "Interrupted",
+		noOutput: "(no output)",
+		diffTruncated: "Diff truncated",
+		moreLines: "+{count} more lines",
+		allowOnce: "Yes, allow this command",
+		allowDirectory: "Yes, and allow this directory for the session",
+		deny: "No, deny this command",
+		denyWithFeedback: "No, and provide feedback to the agent",
+		feedbackPlaceholder: "Tell the agent what to do instead…",
+		send: "Send",
+		answered: "Answered",
+		writeOwnAnswer: "Write my own answer…",
+		subagent: "Task",
+		tasks: "Tasks",
+		planPending: "Plan awaiting approval in the terminal",
+		approvalPending: "Waiting for an answer in the terminal",
+		approvalOptions: "Offered choices"
+	}
+};
+//#endregion
+export { defaultChatStrings };

package/dist/ai/types.d.ts

@@ -0,0 +1,236 @@
+export interface ChatUser {
+    id: string;
+    username: string;
+    name?: string;
+    avatarUrl?: string;
+}
+export interface AttachmentRef {
+    id: string;
+    filename: string;
+    contentType: string;
+    size: number;
+    uploadedAt: string;
+    conversationId?: string;
+    messageId?: string;
+}
+export interface FunctionCall {
+    name: string;
+    arguments: string;
+}
+export interface ToolCall {
+    function: FunctionCall;
+    id?: string;
+    index?: number;
+    type?: string;
+}
+export interface ToolCallDelta {
+    index?: number;
+    id?: string;
+    type?: string;
+    function?: {
+        name?: string;
+        arguments?: string;
+    };
+}
+export interface TokenUsage {
+    prompt_tokens?: number;
+    completion_tokens?: number;
+    total_tokens?: number;
+}
+export type ToolCallStatus = 'running' | 'ok' | 'error';
+export interface TextPart {
+    kind: 'text';
+    text: string;
+}
+export interface ReasoningPart {
+    kind: 'reasoning';
+    text: string;
+    durationMs?: number;
+}
+export interface ToolCallPart {
+    kind: 'tool_call';
+    id: string;
+    name: string;
+    args: string;
+    status: ToolCallStatus;
+    result?: string;
+    startLine?: number;
+}
+export type SubagentStatus = 'running' | 'done' | 'failed';
+export interface SubagentPart {
+    kind: 'subagent';
+    id: string;
+    status: SubagentStatus;
+    agentType?: string;
+    color?: string;
+    background?: boolean;
+    description?: string;
+    actions?: string[];
+    summary?: string;
+    report?: string;
+}
+export interface ApprovalOption {
+    label: string;
+    description?: string;
+}
+export type ApprovalAnswerValue = {
+    kind: 'confirm';
+    allowed: boolean;
+    allowDir?: boolean;
+    denyMessage?: string;
+} | {
+    kind: 'ask';
+    text: string;
+    chat?: boolean;
+};
+export interface ApprovalPart {
+    kind: 'approval';
+    id: string;
+    approvalKind: 'confirm' | 'ask' | 'plan';
+    toolName?: string;
+    command?: string;
+    reason?: string;
+    agent?: string;
+    mode?: string;
+    question?: string;
+    header?: string;
+    multiSelect?: boolean;
+    options?: ApprovalOption[];
+    plan?: string;
+    canAllowDirectory?: boolean;
+    resolved?: boolean;
+    answer?: string;
+}
+export interface NoticePart {
+    kind: 'notice' | 'warning' | 'error';
+    text: string;
+    detail?: string;
+}
+export type TodoStatus = 'pending' | 'in_progress' | 'completed';
+export interface TodoItem {
+    content: string;
+    status: TodoStatus;
+    activeForm?: string;
+}
+export interface TodoSnapshotPart {
+    kind: 'todo_snapshot';
+    todos: TodoItem[];
+}
+export type MessagePart = TextPart | ReasoningPart | ToolCallPart | SubagentPart | ApprovalPart | NoticePart | TodoSnapshotPart;
+export type MessagePartKind = MessagePart['kind'];
+export type PseudoUserKind = 'command-input' | 'shell-input' | 'compaction';
+export interface ChatMessage {
+    id: string;
+    role: string;
+    content?: string | null | undefined;
+    parentId?: string | null | undefined;
+    model?: string | null | undefined;
+    providerId?: string | null | undefined;
+    reasoning?: string | undefined;
+    reasoningDuration?: number | undefined;
+    responsesOutput?: unknown[] | null | undefined;
+    stopped?: boolean | undefined;
+    timestamp?: string | undefined;
+    tokensUsed?: TokenUsage | undefined;
+    toolCallId?: string | undefined;
+    toolCalls?: ToolCall[] | null | undefined;
+    attachments?: AttachmentRef[] | null | undefined;
+    author?: ChatUser | undefined;
+    conversationId?: string | undefined;
+    error?: string | null | undefined;
+    parts?: MessagePart[] | null | undefined;
+    pseudo?: PseudoUserKind | null | undefined;
+}
+export interface Conversation {
+    id: string;
+    messages: ChatMessage[];
+    title?: string | null;
+    activeBranchId?: string | null;
+    branches?: string[] | null;
+    canCollaborate?: boolean;
+    createdAt?: string;
+    isOwner?: boolean;
+    updatedAt?: string | null;
+}
+export interface ConversationSummary {
+    id: string;
+    canCollaborate: boolean;
+    createdAt: string;
+    isOwner: boolean;
+    messageCount: number;
+    activeBranchId?: string;
+    preview?: string;
+    title?: string;
+    updatedAt?: string;
+}
+export interface ChatModel {
+    id: string;
+    object: string;
+    created: number;
+    owned_by: string;
+    tool_calling_mode: 'native' | 'emulated' | 'none';
+    name?: string;
+    provider?: string;
+    provider_name?: string;
+    provider_owner?: string;
+    provider_type?: string;
+    context_window?: number;
+    input_rate?: number;
+    output_rate?: number;
+    reasoning_efforts?: string[] | null;
+    supports_responses?: boolean;
+    supports_usage?: boolean;
+    usage_not_supported?: boolean;
+}
+export interface UnreachableSession {
+    name: string;
+    owner: string;
+}
+export type CspKind = 'openai' | 'anthropic' | 'google' | 'azure' | 'aws' | 'other';
+export interface ProviderInfo {
+    id: string;
+    name: string;
+    displayName?: string;
+    user: string;
+    cspKind: CspKind;
+    platformLabel?: string;
+    status: string;
+    group?: string;
+    groupBlocked?: boolean;
+}
+export interface Allocation {
+    name: string;
+    total: number;
+    used?: number;
+}
+export interface ChatNavigation {
+    toConversation(id: string): void;
+    toNewChat(): void;
+    toAttachments(): void;
+}
+export interface ChatNotify {
+    success(message: string): void;
+    error(message: string): void;
+    info(message: string): void;
+}
+export type SharePermissionLevel = 'view' | 'collaborate';
+export interface SharePermission {
+    id?: string;
+    team?: string | null;
+    teamName?: string | null;
+    permission: SharePermissionLevel;
+    entireOrganization: boolean;
+}
+export interface ShareGroup {
+    id: string;
+    name: string;
+}
+export type ChatLinkTarget = {
+    kind: 'conversation';
+    id: string;
+} | {
+    kind: 'attachments';
+} | {
+    kind: 'external';
+    href: string;
+};

package/dist/ai/ui/Avatar.d.ts

@@ -0,0 +1,8 @@
+interface AvatarProps {
+    src?: string | undefined;
+    name?: string;
+    size?: 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+    className?: string;
+}
+export declare function Avatar({ src, name, size, className }: AvatarProps): import("react").JSX.Element;
+export {};

package/dist/ai/ui/Avatar.js

@@ -0,0 +1,35 @@
+import cx from "classnames";
+import { useMemo, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/ai/ui/Avatar.tsx
+var sizeClasses = {
+	sm: "w-6 h-6 text-xs",
+	md: "w-8 h-8 text-sm",
+	lg: "w-10 h-10 text-base",
+	xl: "w-12 h-12 text-lg",
+	"2xl": "w-16 h-16 text-xl"
+};
+function Avatar({ src, name, size = "md", className }) {
+	const [erroredUrl, setErroredUrl] = useState(null);
+	const errored = erroredUrl !== null && erroredUrl === src;
+	const initials = useMemo(() => {
+		if (!name) return "?";
+		const parts = name.split(/[\s.]+/).filter(Boolean);
+		if (parts.length >= 2) return (parts[0][0] + parts[parts.length - 1][0]).toUpperCase();
+		return parts[0]?.[0]?.toUpperCase() || "?";
+	}, [name]);
+	return /* @__PURE__ */ jsx("div", {
+		className: cx("relative inline-flex", className),
+		children: !src || errored ? /* @__PURE__ */ jsx("div", {
+			className: cx("rounded-full flex items-center justify-center font-medium", "bg-(--theme-element,#3b82f6) text-(--theme-element-text,#ffffff)", sizeClasses[size]),
+			children: initials
+		}) : /* @__PURE__ */ jsx("img", {
+			src,
+			alt: name || "User avatar",
+			onError: () => setErroredUrl(src),
+			className: cx("rounded-full object-cover", sizeClasses[size])
+		})
+	});
+}
+//#endregion
+export { Avatar };

package/dist/ai/ui/Dropdown.d.ts

@@ -0,0 +1,31 @@
+import { type ReactNode } from 'react';
+export interface DropdownOption {
+    label: string;
+    value: string;
+    /** A second line under the label, for choices that need explaining. */
+    description?: string;
+    /** Rendered as a plain option; the trailing checkmark and bold never apply. */
+    muted?: boolean;
+}
+interface DropdownProps {
+    options: DropdownOption[];
+    value: string;
+    onChange: (value: string) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    /** 'bare' drops the input background and text colour, for a trigger that
+     *  reads as a chip or as toolbar text. */
+    variant?: 'default' | 'bare';
+    /** Leading content in the trigger, before the label. */
+    icon?: ReactNode;
+    /** Shown in the trigger instead of the selected option's label. */
+    valueLabel?: string;
+    ariaLabel?: string;
+    /** Tooltip on the closed trigger. */
+    hint?: string;
+    wrapperClassName?: string;
+    textBoxClassName?: string;
+    listClassName?: string;
+}
+export default function Dropdown({ options, value, onChange, placeholder, disabled, variant, icon, valueLabel, ariaLabel, hint, wrapperClassName, textBoxClassName, listClassName, }: DropdownProps): import("react").JSX.Element;
+export {};

package/dist/ai/ui/Dropdown.js

@@ -0,0 +1,110 @@
+import { ChevronDownIcon } from "../../icons.js";
+import { TOOLTIP_ID } from "../../components/Tooltip.js";
+import cx from "classnames";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { createPortal } from "react-dom";
+//#region src/ai/ui/Dropdown.tsx
+/** Matches the list's max-h-60, so the flip decision matches what renders. */
+var MAX_LIST_HEIGHT_PX = 240;
+function Dropdown({ options, value, onChange, placeholder = "", disabled = false, variant = "default", icon, valueLabel, ariaLabel, hint, wrapperClassName, textBoxClassName, listClassName }) {
+	const [open, setOpen] = useState(false);
+	const wrapperRef = useRef(null);
+	const listRef = useRef(null);
+	const [position, setPosition] = useState({
+		top: 0,
+		bottom: 0,
+		left: 0,
+		width: 0,
+		flipped: false
+	});
+	const updatePosition = useCallback(() => {
+		const rect = wrapperRef.current?.getBoundingClientRect();
+		if (!rect) return;
+		const below = window.innerHeight - rect.bottom;
+		const flipped = below < MAX_LIST_HEIGHT_PX && rect.top > below;
+		setPosition({
+			top: rect.bottom + 4,
+			bottom: window.innerHeight - rect.top + 4,
+			left: rect.left,
+			width: rect.width,
+			flipped
+		});
+	}, []);
+	useEffect(() => {
+		if (!open) return;
+		updatePosition();
+		const onPointerDown = (e) => {
+			const target = e.target;
+			if (!wrapperRef.current?.contains(target) && !listRef.current?.contains(target)) setOpen(false);
+		};
+		const onKey = (e) => {
+			if (e.key === "Escape") setOpen(false);
+		};
+		window.addEventListener("mousedown", onPointerDown);
+		window.addEventListener("keydown", onKey);
+		window.addEventListener("scroll", updatePosition, true);
+		window.addEventListener("resize", updatePosition);
+		return () => {
+			window.removeEventListener("mousedown", onPointerDown);
+			window.removeEventListener("keydown", onKey);
+			window.removeEventListener("scroll", updatePosition, true);
+			window.removeEventListener("resize", updatePosition);
+		};
+	}, [open, updatePosition]);
+	const selected = options.find((o) => o.value === value);
+	const shown = valueLabel ?? selected?.label;
+	const tooltip = hint && !open ? {
+		"data-tooltip-id": TOOLTIP_ID,
+		"data-tooltip-content": hint
+	} : {};
+	return /* @__PURE__ */ jsxs("div", {
+		ref: wrapperRef,
+		className: cx("relative", wrapperClassName),
+		children: [/* @__PURE__ */ jsxs("button", {
+			type: "button",
+			disabled,
+			onClick: () => setOpen((o) => !o),
+			"aria-haspopup": "listbox",
+			"aria-expanded": open,
+			"aria-label": ariaLabel,
+			...tooltip,
+			className: cx("flex items-center justify-between gap-2 cursor-pointer", variant === "default" && "bg-(--theme-input-bg,#f9fafb) text-(--theme-input,#000000)", "disabled:opacity-50 disabled:cursor-not-allowed", textBoxClassName || "text-sm border border-(--theme-border,#d1d5db) rounded px-2 py-1.5 w-full"),
+			children: [
+				icon,
+				/* @__PURE__ */ jsx("span", {
+					className: cx("truncate", !shown && "text-(--theme-muted-text-color,#6c757d)"),
+					children: shown || placeholder
+				}),
+				/* @__PURE__ */ jsx(ChevronDownIcon, { className: "h-3 w-3 shrink-0 opacity-60" })
+			]
+		}), open && createPortal(/* @__PURE__ */ jsx("ul", {
+			ref: listRef,
+			style: {
+				position: "fixed",
+				...position.flipped ? { bottom: position.bottom } : { top: position.top },
+				left: position.left,
+				minWidth: position.width,
+				zIndex: 300
+			},
+			className: cx("max-h-60 overflow-auto rounded-md border border-(--theme-border,#e5e7eb) bg-(--theme-panel-bg,#ffffff) py-1 shadow-lg", listClassName),
+			children: options.map((option) => /* @__PURE__ */ jsx("li", { children: /* @__PURE__ */ jsxs("button", {
+				type: "button",
+				onClick: () => {
+					onChange(option.value);
+					setOpen(false);
+				},
+				className: cx("w-full cursor-pointer px-3 py-1.5 text-left text-sm hover:bg-(--theme-hover,#f3f4f6)", option.muted ? "text-(--theme-muted-text-color,#6c757d)" : "text-(--theme-panel,#000000)", option.value === value && !option.muted && "font-semibold"),
+				children: [/* @__PURE__ */ jsx("span", {
+					className: "block truncate",
+					children: option.label
+				}), option.description && /* @__PURE__ */ jsx("span", {
+					className: "mt-0.5 block text-xs font-normal leading-snug text-(--theme-muted-text-color,#6c757d)",
+					children: option.description
+				})]
+			}) }, option.value))
+		}), document.body)]
+	});
+}
+//#endregion
+export { Dropdown as default };

package/dist/ai/ui/Markdown.d.ts

@@ -0,0 +1,8 @@
+import { type ControlsConfig } from 'streamdown';
+interface MarkdownProps {
+    children: string;
+    isStreaming?: boolean;
+    controls?: ControlsConfig;
+}
+export default function Markdown({ children, isStreaming, controls }: MarkdownProps): import("react").JSX.Element;
+export {};

package/dist/ai/ui/Markdown.js

@@ -0,0 +1,79 @@
+import { useChatConfig } from "../core/config.js";
+import { rehypeCodeBreaks } from "./codeBreaks.js";
+import cx from "classnames";
+import { useEffect, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+import { code } from "@streamdown/code";
+import { math } from "@streamdown/math";
+import { Streamdown, defaultRehypePlugins } from "streamdown";
+//#region src/ai/ui/Markdown.tsx
+function schemeIsDark() {
+	if (typeof document === "undefined") return false;
+	const scheme = getComputedStyle(document.documentElement).colorScheme;
+	if (scheme.includes("dark") !== scheme.includes("light")) return scheme.includes("dark");
+	return typeof window.matchMedia === "function" && window.matchMedia("(prefers-color-scheme: dark)").matches;
+}
+var basePlugins = {
+	code,
+	math
+};
+var pluginsWithMermaid;
+var mermaidLoad;
+function loadMermaid() {
+	mermaidLoad ??= import("@streamdown/mermaid").then(({ createMermaidPlugin }) => {
+		const base = createMermaidPlugin();
+		pluginsWithMermaid = {
+			...basePlugins,
+			mermaid: {
+				...base,
+				getMermaid: (config) => base.getMermaid({
+					theme: schemeIsDark() ? "dark" : "neutral",
+					...config
+				})
+			}
+		};
+	});
+	return mermaidLoad;
+}
+var shikiTheme = ["github-light", "github-dark"];
+var rehypePlugins = [...Object.values(defaultRehypePlugins), rehypeCodeBreaks];
+function Markdown({ children, isStreaming, controls }) {
+	const { markdownComponents } = useChatConfig();
+	const needsMermaid = !!children && children.includes("```mermaid");
+	const [, setMermaidReady] = useState(() => !!pluginsWithMermaid);
+	useEffect(() => {
+		if (!needsMermaid || pluginsWithMermaid) return;
+		let live = true;
+		loadMermaid().then(() => {
+			if (live) setMermaidReady(true);
+		});
+		return () => {
+			live = false;
+		};
+	}, [needsMermaid]);
+	const plugins = needsMermaid && pluginsWithMermaid ? pluginsWithMermaid : basePlugins;
+	return /* @__PURE__ */ jsx("div", {
+		className: "markdown whitespace-normal text-start w-full",
+		children: /* @__PURE__ */ jsx(Streamdown, {
+			mode: isStreaming ? "streaming" : "static",
+			...isStreaming === void 0 ? {} : { isAnimating: isStreaming },
+			...isStreaming ? { caret: "block" } : {},
+			...controls === void 0 ? {} : { controls },
+			plugins,
+			rehypePlugins,
+			shikiTheme,
+			components: {
+				a: ({ node, ...props }) => /* @__PURE__ */ jsx("a", {
+					...props,
+					className: cx("link wrap-break-word", props.className),
+					target: "_blank",
+					rel: "noopener noreferrer"
+				}),
+				...markdownComponents
+			},
+			children: children || ""
+		})
+	});
+}
+//#endregion
+export { Markdown as default };