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

package/dist/esm/plugins/effect-scale.js

@@ -0,0 +1,188 @@
+import { EffectScalePlugin } from "@fluxdown/react-base-plugins/plugins/effect-scale";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Children, Component, Fragment, useId, useMemo } from "react";
+import { Animated, Easing } from "react-native";
+import react_native_svg, { Defs, FeGaussianBlur, Filter, ForeignObject, G } from "react-native-svg";
+import { useAppear } from "../856~0.js";
+import { InlineDrawing } from "../319~0.js";
+import { InheritedText } from "../855~0.js";
+import { pluginExtends, BaseSlotPlugin } from "../992~0.js";
+const EASE_OUT = /*#__PURE__*/ Easing.out(Easing.cubic);
+const STEPS = /*#__PURE__*/ Array.from({
+    length: 11
+}, (_, index)=>index / 10);
+const OPACITY = [
+    0,
+    0.073441,
+    0.238144,
+    0.431649,
+    0.614656,
+    0.765625,
+    0.876096,
+    0.946729,
+    0.984064,
+    0.998001,
+    1
+];
+const BLUR = [
+    1,
+    0.987688,
+    0.951057,
+    0.891007,
+    0.809017,
+    0.707107,
+    0.587785,
+    0.45399,
+    0.309017,
+    0.156434,
+    0
+];
+class Blur extends Component {
+    render() {
+        return /*#__PURE__*/ jsx(FeGaussianBlur, {
+            stdDeviation: this.props.stdDeviation
+        });
+    }
+}
+const AnimatedBlur = /*#__PURE__*/ Animated.createAnimatedComponent(Blur);
+const Drawing = ({ children, layout, progress, opacity, from, radius })=>{
+    const id = useId();
+    const { width, height } = layout;
+    const padding = Math.ceil(3 * radius);
+    const scale = useMemo(()=>progress.interpolate({
+            inputRange: [
+                0,
+                1
+            ],
+            outputRange: [
+                from,
+                1
+            ],
+            easing: EASE_OUT
+        }), [
+        from,
+        progress
+    ]);
+    const deviation = useMemo(()=>Animated.multiply(progress.interpolate({
+            inputRange: STEPS,
+            outputRange: BLUR
+        }), radius), [
+        progress,
+        radius
+    ]);
+    return /*#__PURE__*/ jsx(Animated.View, {
+        style: {
+            position: 'absolute',
+            left: -padding,
+            top: -padding,
+            width: width + 2 * padding,
+            height: height + 2 * padding,
+            opacity
+        },
+        pointerEvents: "none",
+        accessibilityElementsHidden: true,
+        importantForAccessibility: "no-hide-descendants",
+        "aria-hidden": true,
+        children: /*#__PURE__*/ jsxs(react_native_svg, {
+            width: width + 2 * padding,
+            height: height + 2 * padding,
+            children: [
+                /*#__PURE__*/ jsx(Defs, {
+                    children: /*#__PURE__*/ jsx(Filter, {
+                        id: id,
+                        filterUnits: "userSpaceOnUse",
+                        x: 0,
+                        y: 0,
+                        width: width + 2 * padding,
+                        height: height + 2 * padding,
+                        children: /*#__PURE__*/ jsx(AnimatedBlur, {
+                            stdDeviation: deviation
+                        })
+                    })
+                }),
+                /*#__PURE__*/ jsx(G, {
+                    filter: `url(#${id})`,
+                    children: /*#__PURE__*/ jsx(ForeignObject, {
+                        x: padding,
+                        y: padding,
+                        width: width + 1,
+                        height: height + 1,
+                        children: /*#__PURE__*/ jsx(Animated.View, {
+                            style: {
+                                width,
+                                height,
+                                transform: [
+                                    {
+                                        scale
+                                    }
+                                ],
+                                transformOrigin: [
+                                    width / 2,
+                                    height,
+                                    0
+                                ]
+                            },
+                            children: children
+                        })
+                    })
+                })
+            ]
+        })
+    });
+};
+const Glyph = ({ children, duration, from, start, blur })=>{
+    const { complete, progress } = useAppear(start, duration);
+    const opacity = useMemo(()=>progress.interpolate({
+            inputRange: STEPS,
+            outputRange: OPACITY
+        }), [
+        progress
+    ]);
+    return /*#__PURE__*/ jsx(InlineDrawing, {
+        active: !complete,
+        renderDrawing: (layout, text, { fontSize = 16 })=>/*#__PURE__*/ jsx(Drawing, {
+                layout: layout,
+                progress: progress,
+                opacity: opacity,
+                from: from,
+                radius: blur * fontSize,
+                children: text
+            }),
+        children: children
+    });
+};
+const ScaleRenderer = (props)=>{
+    const { children } = props;
+    if ('string' != typeof children && 'number' != typeof children) return /*#__PURE__*/ jsx(InheritedText, {
+        children: children
+    });
+    return /*#__PURE__*/ jsx(Glyph, {
+        ...props
+    });
+};
+class EffectScaleSlotPlugin extends BaseSlotPlugin {
+    static key = 'slot-scale';
+    Component = ScaleRenderer;
+    type = 'Scale';
+}
+const ScaleWordRenderer = ({ children })=>/*#__PURE__*/ jsx(InheritedText, {
+        numberOfLines: 1,
+        children: Children.map(children, (child, index)=>/*#__PURE__*/ jsxs(Fragment, {
+                children: [
+                    index > 0 && '\u2060',
+                    child
+                ]
+            }))
+    });
+class EffectScaleWordSlotPlugin extends BaseSlotPlugin {
+    static key = 'slot-scale-word';
+    Component = ScaleWordRenderer;
+    type = 'ScaleWord';
+}
+const effect_scale_EffectScalePlugin = /*#__PURE__*/ pluginExtends(EffectScalePlugin, {
+    slots: [
+        EffectScaleSlotPlugin,
+        EffectScaleWordSlotPlugin
+    ]
+});
+export { EffectScaleSlotPlugin, EffectScaleWordSlotPlugin, ScaleRenderer, ScaleWordRenderer, effect_scale_EffectScalePlugin as EffectScalePlugin };

package/dist/esm/plugins/effect-shad/index.d.ts

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

package/dist/esm/plugins/effect-shad/slot/effect-shad/index.d.ts

@@ -0,0 +1,14 @@
+import type { IPluggableConfig } from '@fluxdown/types';
+import { BaseSlotPlugin } from '../../../../base/index.js';
+import { ShadRenderer } from './renderer/index.js';
+export * from './renderer/index.js';
+declare global {
+    interface SlotConfigs {
+        'slot-shad': IPluggableConfig<void>;
+    }
+}
+export declare class EffectShadSlotPlugin extends BaseSlotPlugin<'Shad'> {
+    static readonly key = "slot-shad";
+    readonly Component: typeof ShadRenderer;
+    readonly type = "Shad";
+}

package/dist/esm/plugins/effect-shad/slot/effect-shad/renderer/components/content/index.d.ts

@@ -0,0 +1,2 @@
+import type { ShadProps } from '../../../../../../../base/index.js';
+export declare const ShadContent: ({ leading, active, offset, }: Pick<ShadProps, 'leading' | 'active' | 'offset'>) => import("react").JSX.Element;

package/dist/esm/plugins/effect-shad/slot/effect-shad/renderer/index.d.ts

@@ -0,0 +1,2 @@
+import type { ShadProps } from '../../../../../base/index.js';
+export declare const ShadRenderer: ({ active, isActive, leading, offset }: ShadProps) => import("react").JSX.Element;

package/dist/esm/plugins/effect-shad/slot/effect-shad/renderer/utils.d.ts

@@ -0,0 +1,22 @@
+import type { ReactNode } from 'react';
+export declare const getText: (children: ReactNode) => string;
+export declare const sliceText: (children: ReactNode, start: number, end: number, keepOpaque?: boolean) => ReactNode;
+export type ShadToken = {
+    key: string;
+    text: string;
+    children: ReactNode;
+    prefix: ReactNode;
+    prefixText: string;
+};
+export declare const getShadTokens: (leading: ReactNode, active: ReactNode, position?: number) => {
+    leading: ReactNode;
+    tokens: ShadToken[];
+};
+export type TokenMeasurement = {
+    prefix?: number;
+    width?: number;
+};
+export declare const getGradient: (tokens: ShadToken[], measurements: Record<string, TokenMeasurement>, key: string) => {
+    start: number;
+    width: number;
+} | null;

package/dist/esm/plugins/effect-shad/slot/index.d.ts

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

package/dist/esm/plugins/effect-shad.js

@@ -0,0 +1,271 @@
+import { EffectShadPlugin } from "@fluxdown/react-base-plugins/plugins/effect-shad";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Text, View } from "react-native";
+import { getTextUnits, getTextWords } from "@fluxdown/hast";
+import { useLatestFn } from "@fluxdown/react-hooks";
+import { pick } from "lodash-es";
+import { Children, cloneElement, isValidElement, useId, useMemo, useState } from "react";
+import react_native_svg, { Defs, ForeignObject, G, LinearGradient, Mask, Rect, Stop } from "react-native-svg";
+import { InlineDrawing } from "../319~0.js";
+import { InheritedText } from "../855~0.js";
+import { pluginExtends, BaseSlotPlugin } from "../992~0.js";
+const mapText = (children, map, opaque = (node)=>node)=>Children.map(children, (child)=>{
+        if ('string' == typeof child || 'number' == typeof child) return map(String(child));
+        if (/*#__PURE__*/ isValidElement(child) && Children.toArray(child.props.children).length > 0) {
+            const children = mapText(child.props.children, map, opaque);
+            return Children.count(children) > 0 ? /*#__PURE__*/ cloneElement(child, void 0, children) : null;
+        }
+        return opaque(child);
+    });
+const getText = (children)=>{
+    let value = '';
+    mapText(children, (text)=>{
+        value += text;
+        return text;
+    });
+    return value;
+};
+const sliceText = (children, start, end, keepOpaque = false)=>{
+    let offset = 0;
+    return mapText(children, (text)=>{
+        const from = Math.max(0, start - offset);
+        const to = Math.min(text.length, end - offset);
+        offset += text.length;
+        return from < to ? text.slice(from, to) : null;
+    }, (node)=>keepOpaque ? node : null);
+};
+const getShadTokens = (leading, active, position = 0)=>{
+    const children = [
+        leading,
+        active
+    ];
+    const prefix = getText(leading).length;
+    const text = getText(children);
+    let offset = 0;
+    let settled = prefix;
+    const tokens = [];
+    for (const word of getTextWords(text)){
+        const start = offset;
+        const key = /^\s+$/.test(word) ? `space-${position}` : `word-${position}`;
+        offset += word.length;
+        position += [
+            ...getTextUnits(word)
+        ].length;
+        if (offset <= prefix) continue;
+        if (0 === tokens.length) settled = start;
+        const prefixEnd = Math.max(start, Math.min(prefix, offset));
+        tokens.push({
+            key,
+            text: word,
+            children: sliceText(children, start, offset),
+            prefix: sliceText(children, start, prefixEnd),
+            prefixText: text.slice(start, prefixEnd)
+        });
+    }
+    return {
+        leading: sliceText(children, 0, settled, true),
+        tokens
+    };
+};
+const getGradient = (tokens, measurements, key)=>{
+    let width = 0;
+    let offset = 0;
+    let current;
+    for (const token of tokens){
+        const measured = measurements[token.key];
+        const prefix = token.prefixText.length > 0 ? measured?.prefix : 0;
+        if (measured?.width === void 0 || void 0 === prefix) continue;
+        const measurement = {
+            width: measured.width,
+            prefix
+        };
+        if (token.key === key) current = measurement;
+        else if (!current) offset += measurement.width - measurement.prefix;
+        width += measurement.width - measurement.prefix;
+    }
+    return current ? {
+        start: current.prefix - offset,
+        width
+    } : null;
+};
+const Token = ({ token, gradient, color, onMeasure })=>{
+    const id = useId();
+    if (/^\s+$/.test(token.text)) return /*#__PURE__*/ jsx(InlineDrawing, {
+        active: false,
+        length: [
+            ...getTextUnits(token.text)
+        ].length,
+        onMeasure: ({ width })=>onMeasure({
+                width
+            }),
+        renderDrawing: ()=>null,
+        children: token.children
+    });
+    return /*#__PURE__*/ jsx(InlineDrawing, {
+        active: true,
+        length: [
+            ...getTextUnits(token.text)
+        ].length,
+        onMeasure: ({ width })=>onMeasure({
+                width
+            }),
+        renderDrawing: ({ width: measured, height }, text, style)=>{
+            const drawingWidth = measured + 1;
+            const drawingHeight = height + 1;
+            return /*#__PURE__*/ jsxs(View, {
+                pointerEvents: "none",
+                style: {
+                    position: 'absolute',
+                    left: 0,
+                    top: 0,
+                    width: measured,
+                    height
+                },
+                accessibilityElementsHidden: true,
+                importantForAccessibility: "no-hide-descendants",
+                "aria-hidden": true,
+                children: [
+                    /*#__PURE__*/ jsx(Text, {
+                        selectable: false,
+                        style: [
+                            style,
+                            {
+                                position: 'absolute',
+                                opacity: 0
+                            }
+                        ],
+                        onLayout: ({ nativeEvent })=>onMeasure({
+                                prefix: nativeEvent.layout.width
+                            }),
+                        children: token.prefixText.length > 0 ? token.prefix : '\u2060'
+                    }),
+                    gradient && /*#__PURE__*/ jsxs(react_native_svg, {
+                        width: drawingWidth,
+                        height: drawingHeight,
+                        pointerEvents: "none",
+                        children: [
+                            /*#__PURE__*/ jsxs(Defs, {
+                                children: [
+                                    /*#__PURE__*/ jsxs(LinearGradient, {
+                                        id: `${id}-gradient`,
+                                        gradientUnits: "userSpaceOnUse",
+                                        x1: gradient.start,
+                                        x2: gradient.start + gradient.width,
+                                        y1: 0,
+                                        y2: 0,
+                                        children: [
+                                            /*#__PURE__*/ jsx(Stop, {
+                                                offset: "0",
+                                                stopColor: "white"
+                                            }),
+                                            /*#__PURE__*/ jsx(Stop, {
+                                                offset: "1",
+                                                stopColor: "white",
+                                                stopOpacity: "0"
+                                            })
+                                        ]
+                                    }),
+                                    /*#__PURE__*/ jsx(Mask, {
+                                        id: id,
+                                        maskType: "alpha",
+                                        maskUnits: "userSpaceOnUse",
+                                        x: 0,
+                                        y: 0,
+                                        width: drawingWidth,
+                                        height: drawingHeight,
+                                        children: /*#__PURE__*/ jsx(Rect, {
+                                            width: drawingWidth,
+                                            height: drawingHeight,
+                                            fill: `url(#${id}-gradient)`
+                                        })
+                                    })
+                                ]
+                            }),
+                            /*#__PURE__*/ jsx(G, {
+                                mask: `url(#${id})`,
+                                children: /*#__PURE__*/ jsx(ForeignObject, {
+                                    width: drawingWidth,
+                                    height: drawingHeight,
+                                    children: text
+                                })
+                            })
+                        ]
+                    })
+                ]
+            });
+        },
+        children: !gradient && token.prefixText.length > 0 ? /*#__PURE__*/ jsxs(Fragment, {
+            children: [
+                /*#__PURE__*/ jsx(Text, {
+                    style: {
+                        color
+                    },
+                    children: token.prefix
+                }),
+                sliceText(token.children, token.prefixText.length, token.text.length)
+            ]
+        }) : token.children
+    });
+};
+const ShadContent = ({ leading, active, offset = 0 })=>{
+    const content = useMemo(()=>getShadTokens(leading, active, offset), [
+        active,
+        leading,
+        offset
+    ]);
+    const [measurements, setMeasurements] = useState({});
+    const onMeasure = useLatestFn((key, value)=>{
+        const keys = content.tokens.map((token)=>token.key);
+        if (!keys.includes(key)) return;
+        setMeasurements((previous)=>{
+            const next = pick(previous, keys);
+            const current = next[key];
+            const measurement = {
+                ...current,
+                ...value
+            };
+            if (current?.width === measurement.width && current?.prefix === measurement.prefix && Object.keys(next).length === Object.keys(previous).length) return previous;
+            return {
+                ...next,
+                [key]: measurement
+            };
+        });
+    });
+    return /*#__PURE__*/ jsx(InheritedText, {
+        children: ({ color = 'black' })=>/*#__PURE__*/ jsxs(Fragment, {
+                children: [
+                    content.leading,
+                    content.tokens.map((token)=>/*#__PURE__*/ jsx(Token, {
+                            token: token,
+                            color: color,
+                            gradient: getGradient(content.tokens, measurements, token.key),
+                            onMeasure: (value)=>onMeasure(token.key, value)
+                        }, token.key))
+                ]
+            })
+    });
+};
+const ShadRenderer = ({ active, isActive, leading, offset })=>{
+    if (isActive) return /*#__PURE__*/ jsx(ShadContent, {
+        leading: leading,
+        active: active,
+        offset: offset
+    });
+    return /*#__PURE__*/ jsxs(Text, {
+        children: [
+            leading,
+            active
+        ]
+    });
+};
+class EffectShadSlotPlugin extends BaseSlotPlugin {
+    static key = 'slot-shad';
+    Component = ShadRenderer;
+    type = 'Shad';
+}
+const effect_shad_EffectShadPlugin = /*#__PURE__*/ pluginExtends(EffectShadPlugin, {
+    slots: [
+        EffectShadSlotPlugin
+    ]
+});
+export { EffectShadSlotPlugin, ShadRenderer, effect_shad_EffectShadPlugin as EffectShadPlugin };

package/dist/esm/plugins/effect-suffix/index.d.ts

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

package/dist/esm/plugins/effect-suffix/slot/effect-suffix/index.d.ts

@@ -0,0 +1,14 @@
+import type { IPluggableConfig } from '@fluxdown/types';
+import { BaseSlotPlugin } from '../../../../base/index.js';
+import { SuffixRenderer } from './renderer/index.js';
+export * from './renderer/index.js';
+declare global {
+    interface SlotConfigs {
+        'slot-suffix': IPluggableConfig<void>;
+    }
+}
+export declare class EffectSuffixSlotPlugin extends BaseSlotPlugin<'Suffix'> {
+    static readonly key = "slot-suffix";
+    readonly Component: typeof SuffixRenderer;
+    readonly type = "Suffix";
+}

package/dist/esm/plugins/effect-suffix/slot/effect-suffix/renderer/consts.d.ts

@@ -0,0 +1 @@
+export declare const EASE_IN_OUT: import("react-native").EasingFunction;

package/dist/esm/plugins/effect-suffix/slot/effect-suffix/renderer/index.d.ts

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

package/dist/esm/plugins/effect-suffix/slot/index.d.ts

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

package/dist/esm/plugins/effect-suffix.js

@@ -0,0 +1,82 @@
+import { EffectSuffixPlugin } from "@fluxdown/react-base-plugins/plugins/effect-suffix";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useStatic } from "@fluxdown/react-hooks";
+import { useLayoutEffect, useState } from "react";
+import { Animated, Easing, Text, View } from "react-native";
+import { InheritedText } from "../855~0.js";
+import { TextMeasurement } from "../390~0.js";
+import { pluginExtends, BaseSlotPlugin } from "../992~0.js";
+const EASE_IN_OUT = /*#__PURE__*/ Easing.bezier(0.42, 0, 0.58, 1);
+const SuffixRenderer = ({ children, type })=>{
+    const opacity = useStatic(()=>new Animated.Value(1));
+    const [baseline, setBaseline] = useState();
+    useLayoutEffect(()=>{
+        const start = performance.now();
+        let frame;
+        const tick = ()=>{
+            const phase = (performance.now() - start) % 1000 / 1000;
+            const value = phase < 1 / 3 ? 1 : phase < 0.5 ? 1 - EASE_IN_OUT((phase - 1 / 3) * 6) : phase < 5 / 6 ? 0 : EASE_IN_OUT((phase - 5 / 6) * 6);
+            opacity.setValue(value);
+            frame = requestAnimationFrame(tick);
+        };
+        tick();
+        return ()=>cancelAnimationFrame(frame);
+    }, [
+        opacity
+    ]);
+    return /*#__PURE__*/ jsx(InheritedText, {
+        children: (style)=>{
+            const { fontSize = 16, lineHeight = 1.65 * fontSize, color = 'black' } = style;
+            const cursor = 'cursor' === type;
+            const height = cursor ? fontSize : 0.624 * fontSize;
+            return /*#__PURE__*/ jsxs(View, {
+                accessibilityElementsHidden: true,
+                importantForAccessibility: "no-hide-descendants",
+                "aria-hidden": true,
+                pointerEvents: "none",
+                style: {
+                    width: 0,
+                    height: 0
+                },
+                children: [
+                    /*#__PURE__*/ jsx(TextMeasurement, {
+                        style: style,
+                        onMeasure: (measurement)=>setBaseline(measurement.baseline),
+                        children: '\u200b'
+                    }),
+                    /*#__PURE__*/ jsx(Animated.View, {
+                        style: {
+                            position: 'absolute',
+                            left: 0.18 * fontSize,
+                            top: -(baseline ?? 0),
+                            opacity: void 0 === baseline ? 0 : opacity
+                        },
+                        children: null != children ? /*#__PURE__*/ jsx(Text, {
+                            style: style,
+                            children: children
+                        }) : /*#__PURE__*/ jsx(View, {
+                            style: {
+                                width: cursor ? 0.39 * lineHeight / 1.65 : height,
+                                height,
+                                marginTop: (lineHeight - height) / 2,
+                                borderRadius: fontSize * (cursor ? 0.06 : 0.312),
+                                backgroundColor: color
+                            }
+                        })
+                    })
+                ]
+            });
+        }
+    });
+};
+class EffectSuffixSlotPlugin extends BaseSlotPlugin {
+    static key = 'slot-suffix';
+    Component = SuffixRenderer;
+    type = 'Suffix';
+}
+const effect_suffix_EffectSuffixPlugin = /*#__PURE__*/ pluginExtends(EffectSuffixPlugin, {
+    slots: [
+        EffectSuffixSlotPlugin
+    ]
+});
+export { EffectSuffixSlotPlugin, SuffixRenderer, effect_suffix_EffectSuffixPlugin as EffectSuffixPlugin };

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

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

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

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

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

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

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

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

package/dist/esm/plugins/emphasis.js

@@ -0,0 +1,21 @@
+import { EmphasisPlugin } from "@fluxdown/react-base-plugins/plugins/emphasis";
+import { jsx } from "react/jsx-runtime";
+import { InheritedText } from "../855~0.js";
+import { pluginExtends, BaseSlotPlugin } from "../992~0.js";
+const EmphasisRenderer = ({ children })=>/*#__PURE__*/ jsx(InheritedText, {
+        style: {
+            fontStyle: 'italic'
+        },
+        children: children
+    });
+class EmphasisSlotPlugin extends BaseSlotPlugin {
+    static key = 'slot-emphasis';
+    Component = EmphasisRenderer;
+    type = 'Emphasis';
+}
+const emphasis_EmphasisPlugin = /*#__PURE__*/ pluginExtends(EmphasisPlugin, {
+    slots: [
+        EmphasisSlotPlugin
+    ]
+});
+export { EmphasisSlotPlugin, emphasis_EmphasisPlugin as EmphasisPlugin };

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

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