@fluxdown/react-native-plugins 0.0.0-stage → 0.2.0

package/dist/esm/390~0.js

@@ -0,0 +1,85 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useLatestFn } from "@fluxdown/react-hooks";
+import { useLayoutEffect, useState } from "react";
+import { PixelRatio, Text, View } from "react-native";
+const TextMeasurement = ({ children, length = 1, style, onMeasure })=>{
+    const [layout, setLayout] = useState(null);
+    const [baseline, setBaseline] = useState(null);
+    const [anchoredWidth, setAnchoredWidth] = useState(null);
+    const notify = useLatestFn(onMeasure);
+    const width = ((style.fontSize ?? 16) * PixelRatio.getFontScale() * 2 + Math.abs(style.letterSpacing ?? 0)) * Math.max(length, 1);
+    useLayoutEffect(()=>{
+        if (layout && null !== baseline && null !== anchoredWidth) notify({
+            ...layout,
+            baseline,
+            advance: Math.max(0, anchoredWidth - layout.width)
+        });
+    }, [
+        anchoredWidth,
+        baseline,
+        layout,
+        notify
+    ]);
+    return /*#__PURE__*/ jsxs(View, {
+        pointerEvents: "none",
+        style: {
+            position: 'absolute',
+            left: 0,
+            top: 0,
+            width,
+            flexDirection: 'row',
+            alignItems: 'baseline',
+            opacity: 0
+        },
+        accessibilityElementsHidden: true,
+        importantForAccessibility: "no-hide-descendants",
+        "aria-hidden": true,
+        children: [
+            /*#__PURE__*/ jsx(Text, {
+                selectable: false,
+                style: [
+                    style,
+                    {
+                        flexShrink: 0
+                    }
+                ],
+                onLayout: ({ nativeEvent })=>setLayout(nativeEvent.layout),
+                children: children
+            }),
+            /*#__PURE__*/ jsxs(Text, {
+                selectable: false,
+                style: [
+                    style,
+                    {
+                        position: 'absolute',
+                        left: 0,
+                        top: 0,
+                        flexShrink: 0
+                    }
+                ],
+                onLayout: ({ nativeEvent })=>setAnchoredWidth(nativeEvent.layout.width),
+                children: [
+                    children,
+                    '\u2060',
+                    /*#__PURE__*/ jsx(View, {
+                        style: {
+                            width: 0,
+                            height: 0
+                        }
+                    })
+                ]
+            }),
+            /*#__PURE__*/ jsx(View, {
+                style: {
+                    width: 1,
+                    height: 1
+                },
+                onLayout: ({ nativeEvent })=>{
+                    const { y, height } = nativeEvent.layout;
+                    setBaseline(y + height);
+                }
+            })
+        ]
+    });
+};
+export { TextMeasurement };

package/dist/esm/480~0.js

@@ -0,0 +1,15 @@
+const getNativeProps = (node)=>{
+    const properties = node?.properties ?? {};
+    return {
+        nativeID: 'string' == typeof properties.id ? properties.id : void 0,
+        accessibilityLabel: 'string' == typeof properties.ariaLabel ? properties.ariaLabel : void 0,
+        checked: true === properties.checked
+    };
+};
+const isLastChild = (current, parents)=>{
+    const parent = parents[parents.length - 1];
+    const children = parent?.children.filter((child)=>'text' !== child.type || child.value.trim());
+    return children?.[children.length - 1] === current;
+};
+const isImageOnlyParagraph = (node)=>'element' === node.type && 'tagName' in node && 'p' === node.tagName && node.children.every((child)=>'element' === child.type && 'img' === child.tagName || 'text' === child.type && '' === child.value.trim());
+export { getNativeProps, isImageOnlyParagraph, isLastChild };

package/dist/esm/493~0.js

@@ -0,0 +1,79 @@
+import { jsx } from "react/jsx-runtime";
+import { Fragment } from "react";
+import { useTheme } from "./121~0.js";
+import { InheritedText } from "./855~0.js";
+const BLOCK_TAG_NAMES = [
+    'address',
+    'article',
+    'aside',
+    'blockquote',
+    'dd',
+    'details',
+    'div',
+    'dl',
+    'dt',
+    'fieldset',
+    'figcaption',
+    'figure',
+    'footer',
+    'form',
+    'h1',
+    'h2',
+    'h3',
+    'h4',
+    'h5',
+    'h6',
+    'header',
+    'hr',
+    'li',
+    'main',
+    'nav',
+    'ol',
+    'p',
+    'pre',
+    'section',
+    'summary',
+    'table',
+    'ul'
+];
+const InlineRenderer = ({ children })=>{
+    const { tokens } = useTheme();
+    return /*#__PURE__*/ jsx(InheritedText, {
+        style: {
+            color: tokens.colors.fg,
+            fontFamily: tokens.typography.fontSans,
+            fontSize: tokens.typography.fontSize.md,
+            lineHeight: tokens.typography.fontSize.md * tokens.typography.lineHeight.md
+        },
+        children: children
+    });
+};
+const renderNativeChildren = (nodes, render)=>{
+    const children = [];
+    let inline = [];
+    const flush = ()=>{
+        if (inline.length > 0) {
+            children.push(/*#__PURE__*/ jsx(InlineRenderer, {
+                children: inline
+            }, `inline:${children.length}`));
+            inline = [];
+        }
+    };
+    nodes.forEach((node, index)=>{
+        const isBlock = 'element' === node.type && BLOCK_TAG_NAMES.includes(node.tagName);
+        if (isBlock) {
+            flush();
+            children.push(/*#__PURE__*/ jsx(Fragment, {
+                children: render(node)
+            }, index));
+            return;
+        }
+        if (0 === inline.length && 'text' === node.type && '' === node.value.trim()) return;
+        inline.push(/*#__PURE__*/ jsx(Fragment, {
+            children: render(node)
+        }, index));
+    });
+    flush();
+    return children;
+};
+export { BLOCK_TAG_NAMES, InlineRenderer, renderNativeChildren };

package/dist/esm/855~0.js

@@ -0,0 +1,53 @@
+import { jsx } from "react/jsx-runtime";
+import { useMemoValue } from "@fluxdown/react-hooks";
+import { isEqual, pickBy } from "lodash-es";
+import { StyleSheet, Text } from "react-native";
+import { createContext, useContext, useMemo } from "react";
+import { useTheme } from "./121~0.js";
+const TextContext = /*#__PURE__*/ createContext(null);
+const TextProvider = TextContext.Provider;
+const useTextStyle = ()=>{
+    const inherited = useContext(TextContext);
+    const { tokens } = useTheme();
+    return useMemo(()=>inherited ?? {
+            color: tokens.colors.fg,
+            fontFamily: tokens.typography.fontSans,
+            fontSize: tokens.typography.fontSize.md,
+            lineHeight: tokens.typography.fontSize.md * tokens.typography.lineHeight.md
+        }, [
+        inherited,
+        tokens
+    ]);
+};
+const TEXT_KEYS = [
+    'color',
+    'fontFamily',
+    'fontSize',
+    'fontStyle',
+    'fontWeight',
+    'fontVariant',
+    'letterSpacing',
+    'lineHeight',
+    'textDecorationColor',
+    'textDecorationLine',
+    'textDecorationStyle',
+    'textTransform',
+    'writingDirection'
+];
+const InheritedText = ({ children, style, textBreakStrategy = 'simple', ...props })=>{
+    const inherited = useTextStyle();
+    const value = useMemoValue({
+        ...inherited,
+        ...pickBy(StyleSheet.flatten(style), (item, key)=>void 0 !== item && TEXT_KEYS.includes(key))
+    }, isEqual);
+    return /*#__PURE__*/ jsx(TextProvider, {
+        value: value,
+        children: /*#__PURE__*/ jsx(Text, {
+            ...props,
+            style: style,
+            textBreakStrategy: textBreakStrategy,
+            children: 'function' == typeof children ? children(value) : children
+        })
+    });
+};
+export { InheritedText };

package/dist/esm/856~0.js

@@ -0,0 +1,33 @@
+import { useStatic } from "@fluxdown/react-hooks";
+import { useLayoutEffect, useState } from "react";
+import { Animated, Easing } from "react-native";
+const getProgress = (start, duration)=>start < 0 || duration <= 0 ? 1 : Math.min(1, Math.max(0, performance.now() - start) / duration);
+const useAppear = (start, duration)=>{
+    const progress = useStatic(()=>new Animated.Value(getProgress(start, duration)));
+    const [complete, setComplete] = useState(()=>getProgress(start, duration) >= 1);
+    useLayoutEffect(()=>{
+        const current = getProgress(start, duration);
+        const remaining = duration * (1 - current);
+        progress.setValue(current);
+        setComplete(current >= 1);
+        if (0 === remaining) return;
+        const animation = Animated.timing(progress, {
+            toValue: 1,
+            duration: remaining,
+            easing: Easing.linear,
+            useNativeDriver: false,
+            isInteraction: false
+        });
+        animation.start(({ finished })=>finished && setComplete(true));
+        return ()=>animation.stop();
+    }, [
+        duration,
+        progress,
+        start
+    ]);
+    return {
+        complete,
+        progress
+    };
+};
+export { useAppear };

package/dist/esm/992~0.js

@@ -0,0 +1 @@
+export { BaseReactRenderPlugin, BaseSlotPlugin, createTypeOfSlot, isHastElement, pluginExtends } from "@fluxdown/react-base-plugins/base";

package/dist/esm/base/animation/hooks.d.ts

@@ -0,0 +1,5 @@
+import { Animated } from 'react-native';
+export declare const useAppear: (start: number, duration: number) => {
+    complete: boolean;
+    progress: Animated.Value;
+};

package/dist/esm/base/animation/index.d.ts

@@ -0,0 +1,3 @@
+export * from './hooks.js';
+export * from './inline.js';
+export * from './measurement.js';

package/dist/esm/base/animation/inline.d.ts

@@ -0,0 +1,10 @@
+import type { ReactNode } from 'react';
+import type { LayoutRectangle, TextStyle } from 'react-native';
+export type InlineDrawingProps = {
+    children?: ReactNode;
+    active: boolean;
+    length?: number;
+    onMeasure?: (layout: LayoutRectangle) => void;
+    renderDrawing: (layout: LayoutRectangle, text: ReactNode, style: TextStyle) => ReactNode;
+};
+export declare const InlineDrawing: ({ children, active, length, renderDrawing, onMeasure, }: InlineDrawingProps) => import("react").JSX.Element;

package/dist/esm/base/animation/measurement.d.ts

@@ -0,0 +1,13 @@
+import type { ReactNode } from 'react';
+import type { LayoutRectangle, TextStyle } from 'react-native';
+export type TextMeasurementValue = LayoutRectangle & {
+    baseline: number;
+    advance: number;
+};
+export type TextMeasurementProps = {
+    children?: ReactNode;
+    length?: number;
+    style: TextStyle;
+    onMeasure: (value: TextMeasurementValue) => void;
+};
+export declare const TextMeasurement: ({ children, length, style, onMeasure, }: TextMeasurementProps) => import("react").JSX.Element;

package/dist/esm/base/components/index.d.ts

@@ -0,0 +1 @@
+export * from './inherited-text/index.js';

package/dist/esm/base/components/inherited-text/hooks.d.ts

@@ -0,0 +1,3 @@
+import type { TextStyle } from 'react-native';
+export declare const TextProvider: import("react").Provider<TextStyle | null>;
+export declare const useTextStyle: () => TextStyle;

package/dist/esm/base/components/inherited-text/index.d.ts

@@ -0,0 +1,6 @@
+import type { ReactNode } from 'react';
+import type { TextProps, TextStyle } from 'react-native';
+export type InheritedTextProps = Omit<TextProps, 'children'> & {
+    children?: ReactNode | ((style: TextStyle) => ReactNode);
+};
+export declare const InheritedText: ({ children, style, textBreakStrategy, ...props }: InheritedTextProps) => import("react").JSX.Element;

package/dist/esm/base/index.d.ts

@@ -0,0 +1,6 @@
+export * from '@fluxdown/react-base-plugins/base';
+export * from './animation/index.js';
+export * from './components/index.js';
+export * from './render/index.js';
+export * from './slot/index.js';
+export * from './theme/index.js';

package/dist/esm/base/render/children.d.ts

@@ -0,0 +1,7 @@
+import type { ElementContent } from 'hast';
+import type { ReactNode } from 'react';
+export declare const BLOCK_TAG_NAMES: string[];
+export declare const InlineRenderer: ({ children }: {
+    children?: ReactNode;
+}) => import("react").JSX.Element;
+export declare const renderNativeChildren: (nodes: ElementContent[], render: (node: ElementContent) => ReactNode) => ReactNode[];

package/dist/esm/base/render/hast.d.ts

@@ -0,0 +1,5 @@
+import type { Element, Parent } from 'hast';
+import type { GetPropsFunction } from '../../typings/index.js';
+export declare const getNativeProps: GetPropsFunction;
+export declare const isLastChild: (current: Element | object, parents: Parent[]) => boolean;
+export declare const isImageOnlyParagraph: (node: Parent) => boolean;

package/dist/esm/base/render/index.d.ts

@@ -0,0 +1,2 @@
+export * from './children.js';
+export * from './hast.js';

package/dist/esm/base/slot/index.d.ts

@@ -0,0 +1 @@
+export * from './type.js';

package/dist/esm/base/slot/type.d.ts

@@ -0,0 +1,19 @@
+import type { GestureResponderEvent } from 'react-native';
+export interface ImagePressParams {
+    event: GestureResponderEvent;
+}
+export interface LinkPressParams {
+    event: GestureResponderEvent;
+}
+declare global {
+    interface SlotBaseAttributes {
+        nativeID?: string;
+        accessibilityLabel?: string;
+    }
+    interface ImageSlotAttributes {
+        onPress?: (params: ImagePressParams) => void;
+    }
+    interface LinkSlotAttributes {
+        onPress?: (params: LinkPressParams) => void;
+    }
+}

package/dist/esm/base/theme/index.d.ts

@@ -0,0 +1,5 @@
+import type { Theme, ThemeConfig } from '../../typings/theme.js';
+export * from './presets/index.js';
+export declare const ThemeProvider: import("react").Provider<ThemeConfig>;
+export declare const useTheme: () => ThemeConfig;
+export declare const useThemeConfig: (theme?: Theme) => ThemeConfig;

package/dist/esm/base/theme/presets/base.d.ts

@@ -0,0 +1,2 @@
+import type { ThemeTokens } from '../../../typings/theme.js';
+export declare const BASE_TOKENS: Omit<ThemeTokens, 'colors' | 'syntax'>;

package/dist/esm/base/theme/presets/dark.d.ts

@@ -0,0 +1,2 @@
+import type { ThemeConfig } from '../../../typings/theme.js';
+export declare const DARK_THEME: ThemeConfig;

package/dist/esm/base/theme/presets/index.d.ts

@@ -0,0 +1,2 @@
+export * from './dark.js';
+export * from './light.js';

package/dist/esm/base/theme/presets/light.d.ts

@@ -0,0 +1,2 @@
+import type { ThemeConfig } from '../../../typings/theme.js';
+export declare const LIGHT_THEME: ThemeConfig;

package/dist/esm/base.js

@@ -0,0 +1,8 @@
+export * from "@fluxdown/react-base-plugins/base";
+export { BLOCK_TAG_NAMES, InlineRenderer, renderNativeChildren } from "./493~0.js";
+export { DARK_THEME, LIGHT_THEME, ThemeProvider, useTheme, useThemeConfig } from "./121~0.js";
+export { InheritedText } from "./855~0.js";
+export { InlineDrawing } from "./319~0.js";
+export { TextMeasurement } from "./390~0.js";
+export { getNativeProps, isImageOnlyParagraph, isLastChild } from "./480~0.js";
+export { useAppear } from "./856~0.js";

package/dist/esm/highlight~0.js

@@ -0,0 +1,101 @@
+import { __webpack_require__ } from "./rslib-runtime~0.js";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useMemo } from "react";
+import { Text, View } from "react-native";
+import react_native_code_highlighter from "react-native-code-highlighter";
+import { useTheme } from "./121~0.js";
+var highlight_namespaceObject = {};
+__webpack_require__.r(highlight_namespaceObject);
+__webpack_require__.d(highlight_namespaceObject, {
+    default: ()=>highlight
+});
+const createHighlightStyle = ({ colors, syntax })=>({
+        hljs: {
+            color: colors.fg
+        },
+        'hljs-comment': {
+            color: syntax.comment
+        },
+        'hljs-quote': {
+            color: syntax.comment
+        },
+        'hljs-keyword': {
+            color: syntax.keyword
+        },
+        'hljs-selector-tag': {
+            color: syntax.keyword
+        },
+        'hljs-literal': {
+            color: syntax.keyword
+        },
+        'hljs-string': {
+            color: syntax.string
+        },
+        'hljs-regexp': {
+            color: syntax.string
+        },
+        'hljs-number': {
+            color: syntax.number
+        },
+        'hljs-attr': {
+            color: syntax.variable
+        },
+        'hljs-variable': {
+            color: syntax.variable
+        },
+        'hljs-title': {
+            color: syntax.function
+        },
+        'hljs-built_in': {
+            color: syntax.function
+        },
+        'hljs-symbol': {
+            color: syntax.punctuation
+        },
+        'hljs-addition': {
+            color: syntax.inserted
+        },
+        'hljs-deletion': {
+            color: syntax.deleted
+        },
+        'hljs-emphasis': {
+            fontStyle: 'italic'
+        },
+        'hljs-strong': {
+            fontWeight: 'bold'
+        }
+    });
+const HighlightRenderer = ({ code, language, suffix })=>{
+    const { tokens } = useTheme();
+    const hljsStyle = useMemo(()=>createHighlightStyle(tokens), [
+        tokens
+    ]);
+    return /*#__PURE__*/ jsxs(View, {
+        children: [
+            /*#__PURE__*/ jsx(react_native_code_highlighter, {
+                hljsStyle: hljsStyle,
+                language: language,
+                textStyle: {
+                    fontFamily: tokens.typography.fontMono,
+                    fontSize: tokens.code.fontSize,
+                    lineHeight: tokens.code.fontSize * tokens.code.lineHeight,
+                    minHeight: tokens.code.fontSize * tokens.code.lineHeight,
+                    userSelect: 'text'
+                },
+                scrollViewProps: {
+                    contentContainerStyle: {
+                        minWidth: '100%',
+                        padding: tokens.spacing.lg,
+                        backgroundColor: tokens.colors.surfaceSubtle
+                    }
+                },
+                children: code
+            }),
+            suffix ? /*#__PURE__*/ jsx(Text, {
+                children: suffix
+            }) : null
+        ]
+    });
+};
+const highlight = HighlightRenderer;
+export { highlight_namespaceObject };

package/dist/esm/mermaid~0.js

@@ -0,0 +1,129 @@
+import { __webpack_require__ } from "./rslib-runtime~0.js";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useEffect, useId, useMemo, useState } from "react";
+import { ScrollView, View } from "react-native";
+import { SvgAst, parse } from "react-native-svg";
+import { createTypeOfSlot } from "./992~0.js";
+import { useTheme } from "./121~0.js";
+var mermaid_namespaceObject = {};
+__webpack_require__.r(mermaid_namespaceObject);
+__webpack_require__.d(mermaid_namespaceObject, {
+    default: ()=>mermaid
+});
+const XML_ENTITIES = {
+    '&': '&',
+    '&lt;': '<',
+    '&gt;': '>',
+    '&quot;': '"',
+    '&apos;': "'"
+};
+const decodeEntities = (value)=>value.replace(/&(amp|lt|gt|quot|apos);/g, (entity)=>XML_ENTITIES[entity]);
+const decodeSvgEntities = (node)=>{
+    node.children = node.children.map((child)=>'string' == typeof child ? decodeEntities(child) : decodeSvgEntities(child));
+    for (const [key, value] of Object.entries(node.props))if ('string' == typeof value) node.props[key] = decodeEntities(value);
+    return node;
+};
+const renderDiagram = async (source, tokens, id)=>{
+    const { estimateText, layoutDiagram, lightTheme, parseDiagramAsync, renderToSvg } = await import("@osuki-dev/skia-diagrams");
+    const parsed = await parseDiagramAsync(source);
+    if ('error' === parsed.kind || 'unsupported' === parsed.kind) return null;
+    const { colors, typography } = tokens;
+    const theme = {
+        ...lightTheme,
+        background: colors.bg,
+        nodeFill: colors.surfaceMuted,
+        nodeStroke: colors.borderEmphasis,
+        nodeText: colors.fg,
+        edgeStroke: colors.fgMuted,
+        edgeText: colors.fg,
+        edgeTextBackground: colors.bg,
+        clusterFill: colors.surfaceSubtle,
+        clusterStroke: colors.border,
+        clusterText: colors.fg,
+        accent: colors.accent,
+        noteFill: colors.surfaceMuted,
+        noteText: colors.fg,
+        fontFamily: typography.fontSans,
+        fontFamilyMono: typography.fontMono,
+        fontSize: typography.fontSize.sm
+    };
+    const scene = layoutDiagram(parsed, estimateText, {
+        ...theme.layout,
+        fontSize: theme.fontSize,
+        radius: theme.radius
+    });
+    const svg = renderToSvg(scene, theme).replaceAll('diagram-gradient-', `${id}-gradient-`);
+    return {
+        svg,
+        width: scene.bounds.width,
+        height: scene.bounds.height,
+        label: scene.accessibilityLabel
+    };
+};
+const CodeHeader = /*#__PURE__*/ createTypeOfSlot('CodeHeader');
+const MermaidRenderer = ({ Raw, ...props })=>{
+    const { code, language, meta, loading, onCopy, showHeader = true, suffix } = props;
+    const { tokens } = useTheme();
+    const id = useId().replaceAll(':', '');
+    const [diagram, setDiagram] = useState(null);
+    const ast = useMemo(()=>diagram ? parse(diagram.svg, decodeSvgEntities) : null, [
+        diagram
+    ]);
+    useEffect(()=>{
+        let active = true;
+        if (code.trim()) renderDiagram(code, tokens, id).then((result)=>{
+            if (active && (result || !loading)) setDiagram(result);
+        }, ()=>{
+            if (active && !loading) setDiagram(null);
+        });
+        else setDiagram(null);
+        return ()=>{
+            active = false;
+        };
+    }, [
+        code,
+        loading,
+        tokens,
+        id
+    ]);
+    if (!diagram) return Raw && /*#__PURE__*/ jsx(Raw, {
+        ...props
+    });
+    return /*#__PURE__*/ jsxs(View, {
+        accessibilityState: {
+            busy: loading
+        },
+        style: {
+            marginVertical: tokens.spacing.lg,
+            borderWidth: 1,
+            borderColor: tokens.colors.border,
+            borderRadius: tokens.radius.md,
+            overflow: 'hidden'
+        },
+        children: [
+            showHeader ? /*#__PURE__*/ jsx(CodeHeader, {
+                code: code,
+                language: language,
+                meta: meta,
+                onCopy: onCopy
+            }) : null,
+            /*#__PURE__*/ jsx(ScrollView, {
+                horizontal: true,
+                contentContainerStyle: {
+                    padding: tokens.spacing.lg
+                },
+                children: /*#__PURE__*/ jsx(SvgAst, {
+                    ast: ast,
+                    override: {
+                        width: diagram.width,
+                        height: diagram.height,
+                        accessibilityLabel: meta || diagram.label
+                    }
+                })
+            }),
+            suffix
+        ]
+    });
+};
+const mermaid = MermaidRenderer;
+export { mermaid_namespaceObject };

package/dist/esm/plugins/blockquote/index.d.ts

@@ -0,0 +1,2 @@
+export * from './slot/index.js';
+export declare const BlockquotePlugin: import("@fluxdown/react-base-plugins/typings").IPluginItem;

package/dist/esm/plugins/blockquote/slot/blockquote/index.d.ts

@@ -0,0 +1,13 @@
+import type { IPluggableConfig } from '@fluxdown/types';
+import { BaseSlotPlugin } from '../../../../base/index.js';
+import { BlockquoteRenderer } from './renderer/index.js';
+declare global {
+    interface SlotConfigs {
+        'slot-blockquote': IPluggableConfig<void>;
+    }
+}
+export declare class BlockquoteSlotPlugin extends BaseSlotPlugin<'Blockquote'> {
+    static readonly key = "slot-blockquote";
+    readonly Component: typeof BlockquoteRenderer;
+    readonly type = "Blockquote";
+}

package/dist/esm/plugins/blockquote/slot/blockquote/renderer/index.d.ts

@@ -0,0 +1,2 @@
+import type { BlockquoteProps } from '../../../../../base/index.js';
+export declare const BlockquoteRenderer: ({ children, nativeID }: BlockquoteProps) => import("react").JSX.Element;

package/dist/esm/plugins/blockquote/slot/index.d.ts

@@ -0,0 +1 @@
+export * from './blockquote/index.js';