@assistant-ui/react-markdown 0.2.22 → 0.2.23

package/src/overrides/CodeOverride.tsx

@@ -0,0 +1,91 @@
+import { ComponentPropsWithoutRef, ComponentType, FC, useContext } from "react";
+import { PreContext } from "./PreOverride";
+import {
+  CodeComponent,
+  CodeHeaderProps,
+  PreComponent,
+  SyntaxHighlighterProps,
+} from "./types";
+import { DefaultCodeBlock } from "./CodeBlock";
+import { useCallbackRef } from "@radix-ui/react-use-callback-ref";
+import { withDefaultProps } from "./withDefaults";
+import { DefaultCodeBlockContent } from "./defaultComponents";
+
+const CodeBlockOverride: FC<CodeOverrideProps> = ({
+  components: {
+    Pre,
+    Code,
+    SyntaxHighlighter: FallbackSyntaxHighlighter,
+    CodeHeader: FallbackCodeHeader,
+    by_language = {},
+  },
+  children,
+  ...codeProps
+}) => {
+  const preProps = useContext(PreContext)!;
+  const getPreProps = withDefaultProps<any>(preProps);
+  const WrappedPre: PreComponent = useCallbackRef((props) => (
+    <Pre {...getPreProps(props)} />
+  ));
+
+  const getCodeProps = withDefaultProps<any>(codeProps);
+  const WrappedCode: CodeComponent = useCallbackRef((props) => (
+    <Code {...getCodeProps(props)} />
+  ));
+
+  const language = /language-(\w+)/.exec(codeProps.className || "")?.[1] ?? "";
+
+  // if the code content is not string (due to rehype plugins), return a default code block
+  if (typeof children !== "string") {
+    return (
+      <DefaultCodeBlockContent
+        components={{ Pre: WrappedPre, Code: WrappedCode }}
+        code={children}
+      />
+    );
+  }
+
+  const SyntaxHighlighter: ComponentType<SyntaxHighlighterProps> =
+    by_language[language]?.SyntaxHighlighter ?? FallbackSyntaxHighlighter;
+
+  const CodeHeader: ComponentType<CodeHeaderProps> =
+    by_language[language]?.CodeHeader ?? FallbackCodeHeader;
+
+  return (
+    <DefaultCodeBlock
+      components={{
+        Pre: WrappedPre,
+        Code: WrappedCode,
+        SyntaxHighlighter,
+        CodeHeader,
+      }}
+      language={language || "unknown"}
+      code={children}
+    />
+  );
+};
+
+export type CodeOverrideProps = ComponentPropsWithoutRef<CodeComponent> & {
+  components: {
+    Pre: PreComponent;
+    Code: CodeComponent;
+    CodeHeader: ComponentType<CodeHeaderProps>;
+    SyntaxHighlighter: ComponentType<SyntaxHighlighterProps>;
+    by_language?: Record<
+      string,
+      {
+        CodeHeader?: ComponentType<CodeHeaderProps>;
+        SyntaxHighlighter?: ComponentType<SyntaxHighlighterProps>;
+      }
+    >;
+  };
+};
+
+export const CodeOverride: FC<CodeOverrideProps> = ({
+  components,
+  ...props
+}) => {
+  const preProps = useContext(PreContext);
+  if (!preProps) return <components.Code {...(props as any)} />;
+  return <CodeBlockOverride components={components} {...props} />;
+};

package/src/overrides/PreOverride.tsx

@@ -0,0 +1,15 @@
+import { createContext, ComponentPropsWithoutRef, useContext } from "react";
+import { PreComponent } from "./types";
+
+export const PreContext = createContext<Omit<
+  ComponentPropsWithoutRef<PreComponent>,
+  "children"
+> | null>(null);
+
+export const useIsMarkdownCodeBlock = () => {
+  return useContext(PreContext) !== null;
+};
+
+export const PreOverride: PreComponent = ({ children, ...rest }) => {
+  return <PreContext.Provider value={rest}>{children}</PreContext.Provider>;
+};

package/src/overrides/defaultComponents.tsx

@@ -0,0 +1,21 @@
+import type { ComponentType, ReactNode } from "react";
+import { PreComponent, CodeComponent, CodeHeaderProps } from "./types";
+
+export const DefaultPre: PreComponent = ({ node, ...rest }) => (
+  <pre {...rest} />
+);
+
+export const DefaultCode: CodeComponent = ({ node, ...rest }) => (
+  <code {...rest} />
+);
+
+export const DefaultCodeBlockContent: ComponentType<{
+  components: { Pre: PreComponent; Code: CodeComponent };
+  code: string | ReactNode | undefined;
+}> = ({ components: { Pre, Code }, code }) => (
+  <Pre>
+    <Code>{code}</Code>
+  </Pre>
+);
+
+export const DefaultCodeHeader: ComponentType<CodeHeaderProps> = () => null;

package/src/overrides/types.ts

@@ -0,0 +1,22 @@
+import { Options } from "react-markdown";
+
+export type PreComponent = NonNullable<
+  NonNullable<Options["components"]>["pre"]
+>;
+export type CodeComponent = NonNullable<
+  NonNullable<Options["components"]>["code"]
+>;
+
+export type CodeHeaderProps = {
+  language: string | undefined;
+  code: string;
+};
+
+export type SyntaxHighlighterProps = {
+  components: {
+    Pre: PreComponent;
+    Code: CodeComponent;
+  };
+  language: string;
+  code: string;
+};

package/src/overrides/withDefaults.tsx

@@ -0,0 +1,14 @@
+import classNames from "classnames";
+
+export const withDefaultProps =
+  <TProps extends { className?: string | undefined }>({
+    className,
+    ...defaultProps
+  }: Partial<TProps>) =>
+  ({ className: classNameProp, ...props }: TProps) => {
+    return {
+      className: classNames(className, classNameProp),
+      ...defaultProps,
+      ...props,
+    } as TProps;
+  };

package/src/primitives/MarkdownText.tsx

@@ -0,0 +1,110 @@
+"use client";
+
+import { INTERNAL, useContentPartText } from "@assistant-ui/react";
+import {
+  ElementRef,
+  ElementType,
+  forwardRef,
+  ForwardRefExoticComponent,
+  RefAttributes,
+  type ComponentPropsWithoutRef,
+  type ComponentType,
+} from "react";
+import ReactMarkdown, { type Options } from "react-markdown";
+import { SyntaxHighlighterProps, CodeHeaderProps } from "../overrides/types";
+import { PreOverride } from "../overrides/PreOverride";
+import {
+  DefaultPre,
+  DefaultCode,
+  DefaultCodeBlockContent,
+  DefaultCodeHeader,
+} from "../overrides/defaultComponents";
+import { useCallbackRef } from "@radix-ui/react-use-callback-ref";
+import { CodeOverride } from "../overrides/CodeOverride";
+import { Primitive } from "@radix-ui/react-primitive";
+import classNames from "classnames";
+
+const { useSmooth } = INTERNAL;
+
+type MarkdownTextPrimitiveElement = ElementRef<typeof Primitive.div>;
+type PrimitiveDivProps = ComponentPropsWithoutRef<typeof Primitive.div>;
+
+export type MarkdownTextPrimitiveProps = Omit<
+  Options,
+  "components" | "children"
+> & {
+  containerProps?: Omit<PrimitiveDivProps, "children" | "asChild">;
+  containerComponent?: ElementType;
+  components?: NonNullable<Options["components"]> & {
+    SyntaxHighlighter?: ComponentType<SyntaxHighlighterProps>;
+    CodeHeader?: ComponentType<CodeHeaderProps>;
+    by_language?: Record<
+      string,
+      {
+        CodeHeader?: ComponentType<CodeHeaderProps>;
+        SyntaxHighlighter?: ComponentType<SyntaxHighlighterProps>;
+      }
+    >;
+  };
+  smooth?: boolean;
+};
+
+export const MarkdownTextPrimitive: ForwardRefExoticComponent<MarkdownTextPrimitiveProps> &
+  RefAttributes<MarkdownTextPrimitiveElement> = forwardRef<
+  MarkdownTextPrimitiveElement,
+  MarkdownTextPrimitiveProps
+>(
+  (
+    {
+      components: userComponents,
+      className,
+      containerProps,
+      containerComponent: Container = "div",
+      ...rest
+    },
+    forwardedRef,
+    smooth = true,
+  ) => {
+    const { text, status } = useSmooth(useContentPartText(), smooth);
+
+    const {
+      pre = DefaultPre,
+      code = DefaultCode,
+      SyntaxHighlighter = DefaultCodeBlockContent,
+      CodeHeader = DefaultCodeHeader,
+      by_language,
+      ...componentsRest
+    } = userComponents ?? {};
+    const components: typeof userComponents = {
+      ...componentsRest,
+      pre: PreOverride,
+      code: useCallbackRef((props) => (
+        <CodeOverride
+          components={{
+            Pre: pre,
+            Code: code,
+            SyntaxHighlighter,
+            CodeHeader,
+            by_language,
+          }}
+          {...props}
+        />
+      )),
+    };
+
+    return (
+      <Container
+        data-status={status.type}
+        {...containerProps}
+        className={classNames(className, containerProps?.className)}
+        ref={forwardedRef}
+      >
+        <ReactMarkdown components={components} {...rest}>
+          {text}
+        </ReactMarkdown>
+      </Container>
+    );
+  },
+);
+
+MarkdownTextPrimitive.displayName = "MarkdownTextPrimitive";

package/src/styles/tailwindcss/markdown.css

@@ -0,0 +1,106 @@
+/* running indicator */
+:where(.aui-md-running):empty::after,
+:where(.aui-md-running) > :where(:not(ol):not(ul):not(pre)):last-child::after,
+:where(.aui-md-running) > pre:last-child code::after,
+:where(.aui-md-running)
+  > :where(:is(ol, ul):last-child)
+  > :where(li:last-child:not(:has(* > li)))::after,
+:where(.aui-md-running)
+  > :where(:is(ol, ul):last-child)
+  > :where(li:last-child)
+  > :where(:is(ol, ul):last-child)
+  > :where(li:last-child:not(:has(* > li)))::after,
+:where(.aui-md-running)
+  > :where(:is(ol, ul):last-child)
+  > :where(li:last-child)
+  > :where(:is(ol, ul):last-child)
+  > :where(li:last-child)
+  > :where(:is(ol, ul):last-child)
+  > :where(li:last-child)::after {
+  @apply animate-pulse font-sans content-['\25CF'] ltr:ml-1 rtl:mr-1;
+}
+
+/* typography */
+.aui-md-h1 {
+  @apply mb-8 scroll-m-20 text-4xl font-extrabold tracking-tight last:mb-0;
+}
+
+.aui-md-h2 {
+  @apply mb-4 mt-8 scroll-m-20 text-3xl font-semibold tracking-tight first:mt-0 last:mb-0;
+}
+
+.aui-md-h3 {
+  @apply mb-4 mt-6 scroll-m-20 text-2xl font-semibold tracking-tight first:mt-0 last:mb-0;
+}
+
+.aui-md-h4 {
+  @apply mb-4 mt-6 scroll-m-20 text-xl font-semibold tracking-tight first:mt-0 last:mb-0;
+}
+
+.aui-md-h5 {
+  @apply my-4 text-lg font-semibold first:mt-0 last:mb-0;
+}
+
+.aui-md-h6 {
+  @apply my-4 font-semibold first:mt-0 last:mb-0;
+}
+
+.aui-md-p {
+  @apply mb-5 mt-5 leading-7 first:mt-0 last:mb-0;
+}
+
+.aui-md-a {
+  @apply text-aui-primary font-medium underline underline-offset-4;
+}
+
+.aui-md-blockquote {
+  @apply border-l-2 pl-6 italic;
+}
+
+.aui-md-ul {
+  @apply my-5 ml-6 list-disc [&>li]:mt-2;
+}
+
+.aui-md-ol {
+  @apply my-5 ml-6 list-decimal [&>li]:mt-2;
+}
+
+.aui-md-hr {
+  @apply my-5 border-b;
+}
+
+.aui-md-table {
+  @apply my-5 w-full border-separate border-spacing-0 overflow-y-auto;
+}
+
+.aui-md-th {
+  @apply bg-aui-muted px-4 py-2 text-left font-bold first:rounded-tl-lg last:rounded-tr-lg [&[align=center]]:text-center [&[align=right]]:text-right;
+}
+
+.aui-md-td {
+  @apply border-b border-l px-4 py-2 text-left last:border-r [&[align=center]]:text-center [&[align=right]]:text-right;
+}
+
+.aui-md-tr {
+  @apply m-0 border-b p-0 first:border-t [&:last-child>td:first-child]:rounded-bl-lg [&:last-child>td:last-child]:rounded-br-lg;
+}
+
+.aui-md-sup {
+  @apply [&>a]:text-xs [&>a]:no-underline;
+}
+
+.aui-md-pre {
+  @apply overflow-x-auto rounded-b-lg bg-black p-4 text-white;
+}
+
+.aui-md-inline-code {
+  @apply bg-aui-muted rounded border font-semibold;
+}
+
+.aui-code-header-root {
+  @apply flex items-center justify-between gap-4 rounded-t-lg bg-zinc-900 px-4 py-2 text-sm font-semibold text-white;
+}
+
+.aui-code-header-language {
+  @apply lowercase [&>span]:text-xs;
+}

package/src/tailwindcss/index.ts

@@ -0,0 +1,8 @@
+import plugin from "tailwindcss/plugin.js";
+import markdownCSS from "../../generated/markdown.css.json";
+
+const auiPlugin = plugin.withOptions<{}>(() => ({ addComponents }) => {
+  addComponents(markdownCSS);
+});
+
+export default auiPlugin;

package/src/ui/code-header.tsx

@@ -0,0 +1,32 @@
+import { FC } from "react";
+import { CheckIcon, CopyIcon } from "lucide-react";
+import { INTERNAL, useThreadConfig } from "@assistant-ui/react";
+
+import { CodeHeaderProps } from "../overrides/types";
+import { useCopyToClipboard } from "./useCopyToClipboard";
+
+const { TooltipIconButton } = INTERNAL;
+
+export const CodeHeader: FC<CodeHeaderProps> = ({ language, code }) => {
+  const {
+    strings: {
+      code: { header: { copy: { tooltip = "Copy" } = {} } = {} } = {},
+    } = {},
+  } = useThreadConfig();
+
+  const { isCopied, copyToClipboard } = useCopyToClipboard();
+  const onCopy = () => {
+    if (!code || isCopied) return;
+    copyToClipboard(code);
+  };
+
+  return (
+    <div className="aui-code-header-root">
+      <span className="aui-code-header-language">{language}</span>
+      <TooltipIconButton tooltip={tooltip} onClick={onCopy}>
+        {!isCopied && <CopyIcon />}
+        {isCopied && <CheckIcon />}
+      </TooltipIconButton>
+    </div>
+  );
+};

package/src/ui/markdown-text.tsx

@@ -0,0 +1,114 @@
+import { FC, memo } from "react";
+import { CodeHeader } from "./code-header";
+import classNames from "classnames";
+import {
+  MarkdownTextPrimitive,
+  MarkdownTextPrimitiveProps,
+} from "../primitives/MarkdownText";
+import { INTERNAL } from "@assistant-ui/react";
+import { useIsMarkdownCodeBlock } from "../overrides/PreOverride";
+
+const { withSmoothContextProvider, useSmoothStatus } = INTERNAL;
+
+export type MakeMarkdownTextProps = MarkdownTextPrimitiveProps;
+
+const defaultComponents: MakeMarkdownTextProps["components"] = {
+  h1: ({ node, className, ...props }) => (
+    <h1 className={classNames("aui-md-h1", className)} {...props} />
+  ),
+  h2: ({ node, className, ...props }) => (
+    <h2 className={classNames("aui-md-h2", className)} {...props} />
+  ),
+  h3: ({ node, className, ...props }) => (
+    <h3 className={classNames("aui-md-h3", className)} {...props} />
+  ),
+  h4: ({ node, className, ...props }) => (
+    <h4 className={classNames("aui-md-h4", className)} {...props} />
+  ),
+  h5: ({ node, className, ...props }) => (
+    <h5 className={classNames("aui-md-h5", className)} {...props} />
+  ),
+  h6: ({ node, className, ...props }) => (
+    <h6 className={classNames("aui-md-h6", className)} {...props} />
+  ),
+  p: ({ node, className, ...props }) => (
+    <p className={classNames("aui-md-p", className)} {...props} />
+  ),
+  a: ({ node, className, ...props }) => (
+    <a className={classNames("aui-md-a", className)} {...props} />
+  ),
+  blockquote: ({ node, className, ...props }) => (
+    <blockquote
+      className={classNames("aui-md-blockquote", className)}
+      {...props}
+    />
+  ),
+  ul: ({ node, className, ...props }) => (
+    <ul className={classNames("aui-md-ul", className)} {...props} />
+  ),
+  ol: ({ node, className, ...props }) => (
+    <ol className={classNames("aui-md-ol", className)} {...props} />
+  ),
+  hr: ({ node, className, ...props }) => (
+    <hr className={classNames("aui-md-hr", className)} {...props} />
+  ),
+  table: ({ node, className, ...props }) => (
+    <table className={classNames("aui-md-table", className)} {...props} />
+  ),
+  th: ({ node, className, ...props }) => (
+    <th className={classNames("aui-md-th", className)} {...props} />
+  ),
+  td: ({ node, className, ...props }) => (
+    <td className={classNames("aui-md-td", className)} {...props} />
+  ),
+  tr: ({ node, className, ...props }) => (
+    <tr className={classNames("aui-md-tr", className)} {...props} />
+  ),
+  sup: ({ node, className, ...props }) => (
+    <sup className={classNames("aui-md-sup", className)} {...props} />
+  ),
+  pre: ({ node, className, ...props }) => (
+    <pre className={classNames("aui-md-pre", className)} {...props} />
+  ),
+  code: ({ node, className, ...props }) => {
+    const isCodeBlock = useIsMarkdownCodeBlock();
+    return (
+      <code
+        className={classNames(!isCodeBlock && "aui-md-inline-code", className)}
+        {...props}
+      />
+    );
+  },
+  CodeHeader,
+};
+
+export const makeMarkdownText = ({
+  className,
+  components: userComponents,
+  ...rest
+}: MakeMarkdownTextProps = {}) => {
+  const components = {
+    ...defaultComponents,
+    ...Object.fromEntries(
+      // ignore undefined values, so undefined values do not override default components
+      Object.entries(userComponents ?? {}).filter(([_, v]) => v !== undefined),
+    ),
+  };
+
+  const MarkdownTextImpl: FC = () => {
+    const status = useSmoothStatus();
+    return (
+      <MarkdownTextPrimitive
+        components={components}
+        {...rest}
+        className={classNames(
+          status.type === "running" && "aui-md-running",
+          className,
+        )}
+      />
+    );
+  };
+  MarkdownTextImpl.displayName = "MarkdownText";
+
+  return memo(withSmoothContextProvider(MarkdownTextImpl), () => true);
+};

package/src/ui/useCopyToClipboard.tsx

@@ -0,0 +1,21 @@
+import { useState } from "react";
+import { UseActionBarCopyProps } from "@assistant-ui/react";
+
+export type useCopyToClipboardProps = UseActionBarCopyProps;
+
+export const useCopyToClipboard = ({
+  copiedDuration = 3000,
+}: useCopyToClipboardProps = {}) => {
+  const [isCopied, setIsCopied] = useState<boolean>(false);
+
+  const copyToClipboard = (value: string) => {
+    if (!value) return;
+
+    navigator.clipboard.writeText(value).then(() => {
+      setIsCopied(true);
+      setTimeout(() => setIsCopied(false), copiedDuration);
+    });
+  };
+
+  return { isCopied, copyToClipboard };
+};

package/tailwindcss/README.md

@@ -0,0 +1 @@
+This directory exists to support subpath imports for TypeScript projects using --moduleResolution node.

package/tailwindcss/package.json

@@ -0,0 +1,5 @@
+{
+  "main": "../dist/tailwindcss/index.js",
+  "module": "../dist/tailwindcss/index.mjs",
+  "types": "../dist/tailwindcss/index.d.ts"
+}

package/dist/index.d.mts

@@ -1,45 +0,0 @@
-import * as react from 'react';
-import { ElementType, ComponentType, ForwardRefExoticComponent, RefAttributes, ElementRef, ComponentPropsWithoutRef, FC } from 'react';
-import { Options } from 'react-markdown';
-import { Primitive } from '@radix-ui/react-primitive';
-
-type PreComponent = NonNullable<NonNullable<Options["components"]>["pre"]>;
-type CodeComponent = NonNullable<NonNullable<Options["components"]>["code"]>;
-type CodeHeaderProps = {
-    language: string | undefined;
-    code: string;
-};
-type SyntaxHighlighterProps = {
-    components: {
-        Pre: PreComponent;
-        Code: CodeComponent;
-    };
-    language: string;
-    code: string;
-};
-
-type MarkdownTextPrimitiveElement = ElementRef<typeof Primitive.div>;
-type PrimitiveDivProps = ComponentPropsWithoutRef<typeof Primitive.div>;
-type MarkdownTextPrimitiveProps = Omit<Options, "components" | "children"> & {
-    containerProps?: Omit<PrimitiveDivProps, "children" | "asChild">;
-    containerComponent?: ElementType;
-    components?: NonNullable<Options["components"]> & {
-        SyntaxHighlighter?: ComponentType<SyntaxHighlighterProps>;
-        CodeHeader?: ComponentType<CodeHeaderProps>;
-        by_language?: Record<string, {
-            CodeHeader?: ComponentType<CodeHeaderProps>;
-            SyntaxHighlighter?: ComponentType<SyntaxHighlighterProps>;
-        }>;
-    };
-    smooth?: boolean;
-};
-declare const MarkdownTextPrimitive: ForwardRefExoticComponent<MarkdownTextPrimitiveProps> & RefAttributes<MarkdownTextPrimitiveElement>;
-
-declare const useIsMarkdownCodeBlock: () => boolean;
-
-type MakeMarkdownTextProps = MarkdownTextPrimitiveProps;
-declare const makeMarkdownText: ({ className, components: userComponents, ...rest }?: MakeMarkdownTextProps) => react.NamedExoticComponent<{}>;
-
-declare const CodeHeader: FC<CodeHeaderProps>;
-
-export { CodeHeader, type CodeHeaderProps, type MakeMarkdownTextProps, MarkdownTextPrimitive, type MarkdownTextPrimitiveProps, type SyntaxHighlighterProps, makeMarkdownText, useIsMarkdownCodeBlock };

package/dist/index.d.ts

@@ -1,45 +0,0 @@
-import * as react from 'react';
-import { ElementType, ComponentType, ForwardRefExoticComponent, RefAttributes, ElementRef, ComponentPropsWithoutRef, FC } from 'react';
-import { Options } from 'react-markdown';
-import { Primitive } from '@radix-ui/react-primitive';
-
-type PreComponent = NonNullable<NonNullable<Options["components"]>["pre"]>;
-type CodeComponent = NonNullable<NonNullable<Options["components"]>["code"]>;
-type CodeHeaderProps = {
-    language: string | undefined;
-    code: string;
-};
-type SyntaxHighlighterProps = {
-    components: {
-        Pre: PreComponent;
-        Code: CodeComponent;
-    };
-    language: string;
-    code: string;
-};
-
-type MarkdownTextPrimitiveElement = ElementRef<typeof Primitive.div>;
-type PrimitiveDivProps = ComponentPropsWithoutRef<typeof Primitive.div>;
-type MarkdownTextPrimitiveProps = Omit<Options, "components" | "children"> & {
-    containerProps?: Omit<PrimitiveDivProps, "children" | "asChild">;
-    containerComponent?: ElementType;
-    components?: NonNullable<Options["components"]> & {
-        SyntaxHighlighter?: ComponentType<SyntaxHighlighterProps>;
-        CodeHeader?: ComponentType<CodeHeaderProps>;
-        by_language?: Record<string, {
-            CodeHeader?: ComponentType<CodeHeaderProps>;
-            SyntaxHighlighter?: ComponentType<SyntaxHighlighterProps>;
-        }>;
-    };
-    smooth?: boolean;
-};
-declare const MarkdownTextPrimitive: ForwardRefExoticComponent<MarkdownTextPrimitiveProps> & RefAttributes<MarkdownTextPrimitiveElement>;
-
-declare const useIsMarkdownCodeBlock: () => boolean;
-
-type MakeMarkdownTextProps = MarkdownTextPrimitiveProps;
-declare const makeMarkdownText: ({ className, components: userComponents, ...rest }?: MakeMarkdownTextProps) => react.NamedExoticComponent<{}>;
-
-declare const CodeHeader: FC<CodeHeaderProps>;
-
-export { CodeHeader, type CodeHeaderProps, type MakeMarkdownTextProps, MarkdownTextPrimitive, type MarkdownTextPrimitiveProps, type SyntaxHighlighterProps, makeMarkdownText, useIsMarkdownCodeBlock };

package/dist/tailwindcss/index.d.mts

@@ -1,11 +0,0 @@
-import * as tailwindcss_types_config from 'tailwindcss/types/config';
-
-declare const auiPlugin: {
-    (options: {}): {
-        handler: tailwindcss_types_config.PluginCreator;
-        config?: Partial<tailwindcss_types_config.Config>;
-    };
-    __isOptionsFunction: true;
-};
-
-export { auiPlugin as default };