@assistant-ui/react-markdown 0.2.22 → 0.2.24

package/dist/ui/useCopyToClipboard.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/ui/useCopyToClipboard.tsx"],"sourcesContent":["import { useState } from \"react\";\nimport { UseActionBarCopyProps } from \"@assistant-ui/react\";\n\nexport type useCopyToClipboardProps = UseActionBarCopyProps;\n\nexport const useCopyToClipboard = ({\n  copiedDuration = 3000,\n}: useCopyToClipboardProps = {}) => {\n  const [isCopied, setIsCopied] = useState<boolean>(false);\n\n  const copyToClipboard = (value: string) => {\n    if (!value) return;\n\n    navigator.clipboard.writeText(value).then(() => {\n      setIsCopied(true);\n      setTimeout(() => setIsCopied(false), copiedDuration);\n    });\n  };\n\n  return { isCopied, copyToClipboard };\n};\n"],"mappings":"AAAA,SAAS,gBAAgB;AAKlB,MAAM,qBAAqB,CAAC;AAAA,EACjC,iBAAiB;AACnB,IAA6B,CAAC,MAAM;AAClC,QAAM,CAAC,UAAU,WAAW,IAAI,SAAkB,KAAK;AAEvD,QAAM,kBAAkB,CAAC,UAAkB;AACzC,QAAI,CAAC,MAAO;AAEZ,cAAU,UAAU,UAAU,KAAK,EAAE,KAAK,MAAM;AAC9C,kBAAY,IAAI;AAChB,iBAAW,MAAM,YAAY,KAAK,GAAG,cAAc;AAAA,IACrD,CAAC;AAAA,EACH;AAEA,SAAO,EAAE,UAAU,gBAAgB;AACrC;","names":[]}

package/package.json

@@ -1,27 +1,17 @@
 {
   "name": "@assistant-ui/react-markdown",
-  "version": "0.2.22",
+  "version": "0.2.24",
   "license": "MIT",
   "exports": {
     ".": {
-      "import": {
-        "types": "./dist/index.d.mts",
-        "default": "./dist/index.mjs"
-      },
-      "require": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      }
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
     },
     "./tailwindcss": {
-      "import": {
-        "types": "./dist/tailwindcss/index.d.mts",
-        "default": "./dist/tailwindcss/index.mjs"
-      },
-      "require": {
-        "types": "./dist/tailwindcss/index.d.ts",
-        "default": "./dist/tailwindcss/index.js"
-      }
+      "types": "./dist/tailwindcss/index.d.ts",
+      "import": "./dist/tailwindcss/index.mjs",
+      "require": "./dist/tailwindcss/index.js"
     },
     "./styles/*": {
       "default": "./dist/styles/*"
@@ -33,6 +23,8 @@
   "types": "./dist/index.d.ts",
   "files": [
     "dist",
+    "tailwindcss",
+    "src",
     "README.md"
   ],
   "sideEffects": false,
@@ -44,7 +36,7 @@
     "react-markdown": "^9.0.1"
   },
   "peerDependencies": {
-    "@assistant-ui/react": "^0.5.91",
+    "@assistant-ui/react": "^0.5.93",
     "@types/react": "*",
     "react": "^18 || ^19",
     "tailwindcss": "^3.4.4"
@@ -70,8 +62,9 @@
     "tailwindcss-animate": "^1.0.7",
     "tsup": "8.3.0",
     "tsx": "^4.19.1",
-    "@assistant-ui/tailwindcss-transformer": "0.1.0",
-    "@assistant-ui/tsconfig": "0.0.0"
+    "@assistant-ui/react": "0.5.93",
+    "@assistant-ui/tsconfig": "0.0.0",
+    "@assistant-ui/tailwindcss-transformer": "0.1.0"
   },
   "publishConfig": {
     "access": "public",
@@ -86,6 +79,7 @@
     "url": "https://github.com/Yonom/assistant-ui/issues"
   },
   "scripts": {
-    "build": "tsx scripts/build.mts"
+    "build": "tsx scripts/build.mts && pnpm run build:declarations",
+    "build:declarations": "tsc -p tsconfig.declarations.json"
   }
 }

package/src/index.ts

@@ -0,0 +1,18 @@
+export {
+  MarkdownTextPrimitive,
+  type MarkdownTextPrimitiveProps,
+} from "./primitives/MarkdownText";
+
+export type {
+  CodeHeaderProps,
+  SyntaxHighlighterProps,
+} from "./overrides/types";
+
+export { useIsMarkdownCodeBlock } from "./overrides/PreOverride";
+
+export {
+  makeMarkdownText,
+  type MakeMarkdownTextProps,
+} from "./ui/markdown-text";
+
+export { CodeHeader } from "./ui/code-header";

package/src/overrides/CodeBlock.tsx

@@ -0,0 +1,41 @@
+import { ComponentType, FC, useMemo } from "react";
+
+import {
+  CodeComponent,
+  CodeHeaderProps,
+  PreComponent,
+  SyntaxHighlighterProps,
+} from "./types";
+import { DefaultCodeBlockContent } from "./defaultComponents";
+
+export type CodeBlockProps = {
+  language: string;
+  code: string;
+  components: {
+    Pre: PreComponent;
+    Code: CodeComponent;
+    CodeHeader: ComponentType<CodeHeaderProps>;
+    SyntaxHighlighter: ComponentType<SyntaxHighlighterProps>;
+  };
+};
+
+export const DefaultCodeBlock: FC<CodeBlockProps> = ({
+  components: { Pre, Code, SyntaxHighlighter, CodeHeader },
+  language,
+  code,
+}) => {
+  const components = useMemo(() => ({ Pre, Code }), [Pre, Code]);
+
+  const SH = !!language ? SyntaxHighlighter : DefaultCodeBlockContent;
+
+  return (
+    <>
+      <CodeHeader language={language} code={code} />
+      <SH
+        components={components}
+        language={language ?? "unknown"}
+        code={code}
+      />
+    </>
+  );
+};

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);
+};