eddyter 1.3.30

package/dist/nodes/ChartNode.d.ts

@@ -0,0 +1,41 @@
+import { DecoratorNode, DOMConversionMap, DOMExportOutput, LexicalNode, NodeKey, SerializedLexicalNode, Spread } from '../../node_modules/lexical';
+import * as React from 'react';
+export interface ChartMetadata {
+    type: 'bar' | 'horizontal-bar' | 'line' | 'pie' | 'donut';
+    values: number[];
+    labels?: string[];
+    title?: string;
+    colors?: string[];
+}
+export interface ChartPayload {
+    html: string;
+    metadata?: ChartMetadata;
+    key?: NodeKey;
+}
+export type SerializedChartNode = Spread<{
+    html: string;
+    metadata?: ChartMetadata;
+}, SerializedLexicalNode>;
+export declare class ChartNode extends DecoratorNode<React.ReactElement> {
+    __html: string;
+    __metadata?: ChartMetadata;
+    static getType(): string;
+    static clone(node: ChartNode): ChartNode;
+    constructor(html: string, metadata?: ChartMetadata, key?: NodeKey);
+    createDOM(): HTMLElement;
+    updateDOM(): false;
+    static importJSON(serializedNode: SerializedChartNode): ChartNode;
+    exportJSON(): SerializedChartNode;
+    exportDOM(): DOMExportOutput;
+    static importDOM(): DOMConversionMap | null;
+    decorate(): React.ReactElement;
+    isInline(): boolean;
+    isTopLevel(): boolean;
+    getHTML(): string;
+    setHTML(html: string): void;
+    getMetadata(): ChartMetadata | undefined;
+    setMetadata(metadata: ChartMetadata): void;
+    updateChart(html: string, metadata: ChartMetadata): void;
+}
+export declare function $createChartNode(html: string, metadata?: ChartMetadata): ChartNode;
+export declare function $isChartNode(node: LexicalNode | null | undefined): node is ChartNode;

package/dist/nodes/CommentNode.d.ts

@@ -0,0 +1,34 @@
+import { DOMConversionMap, DOMExportOutput, EditorConfig, LexicalNode, NodeKey, SerializedLexicalNode, Spread, DecoratorNode } from '../../node_modules/lexical';
+export interface CommentPayload {
+    text: string;
+    author?: string;
+    timestamp?: number;
+    key?: NodeKey;
+}
+export type SerializedCommentNode = Spread<{
+    text: string;
+    author: string;
+    timestamp: number;
+}, SerializedLexicalNode>;
+export declare class CommentNode extends DecoratorNode<JSX.Element> {
+    __text: string;
+    __author: string;
+    __timestamp: number;
+    static getType(): string;
+    static clone(node: CommentNode): CommentNode;
+    static importJSON(serializedNode: SerializedCommentNode): CommentNode;
+    exportDOM(): DOMExportOutput;
+    static importDOM(): DOMConversionMap | null;
+    constructor(text: string, author?: string, timestamp?: number, key?: NodeKey);
+    exportJSON(): SerializedCommentNode;
+    setText(text: string): void;
+    setAuthor(author: string): void;
+    createDOM(config: EditorConfig): HTMLElement;
+    updateDOM(): false;
+    getText(): string;
+    getAuthor(): string;
+    getTimestamp(): number;
+    decorate(): JSX.Element;
+}
+export declare function $createCommentNode({ text, author, timestamp, key, }: CommentPayload): CommentNode;
+export declare function $isCommentNode(node: LexicalNode | null | undefined): node is CommentNode;

package/dist/nodes/CommentedTextNode.d.ts

@@ -0,0 +1,29 @@
+import { DOMConversionMap, DOMExportOutput, EditorConfig, LexicalNode, NodeKey, SerializedTextNode, Spread, TextNode } from '../../node_modules/lexical';
+export type SerializedCommentedTextNode = Spread<{
+    commentId: string;
+    commentText: string;
+    commentAuthor: string;
+    commentTimestamp: number;
+}, SerializedTextNode>;
+export declare class CommentedTextNode extends TextNode {
+    __commentId: string;
+    __commentText: string;
+    __commentAuthor: string;
+    __commentTimestamp: number;
+    static getType(): string;
+    static clone(node: CommentedTextNode): CommentedTextNode;
+    constructor(text: string, commentId: string, commentText: string, commentAuthor: string, commentTimestamp: number, key?: NodeKey);
+    static importJSON(serializedNode: SerializedCommentedTextNode): CommentedTextNode;
+    exportJSON(): SerializedCommentedTextNode;
+    createDOM(config: EditorConfig): HTMLElement;
+    updateDOM(): false;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(): DOMExportOutput;
+    getCommentId(): string;
+    getCommentText(): string;
+    getCommentAuthor(): string;
+    getCommentTimestamp(): number;
+    setCommentText(text: string): void;
+}
+export declare function $createCommentedTextNode(text: string, commentId: string, commentText: string, commentAuthor: string, commentTimestamp: number): CommentedTextNode;
+export declare function $isCommentedTextNode(node: LexicalNode | null | undefined): node is CommentedTextNode;

package/dist/nodes/EmbedNode.d.ts

@@ -0,0 +1,32 @@
+import { DecoratorNode, DOMExportOutput, NodeKey } from '../../node_modules/lexical';
+/**
+ * A custom Lexical node that embeds and renders various types of content
+ * such as videos, PDFs, documents, and other media files.
+ */
+export type DisplayType = "url" | "card" | "embed";
+export type Alignment = "left" | "center" | "right";
+export declare class EmbedNode extends DecoratorNode<JSX.Element> {
+    __url: string;
+    __displayType: DisplayType;
+    __alignment: Alignment;
+    __width: number;
+    __height: number;
+    constructor(url: string, displayType?: DisplayType, alignment?: Alignment, width?: number, height?: number, key?: NodeKey);
+    static getType(): string;
+    static clone(node: EmbedNode): EmbedNode;
+    createDOM(): HTMLElement;
+    updateDOM(): boolean;
+    static importJSON(serializedNode: any): EmbedNode;
+    exportJSON(): any;
+    exportDOM(): DOMExportOutput;
+    getURL(): string;
+    getDisplayType(): DisplayType;
+    getAlignment(): Alignment;
+    setDisplayType(displayType: DisplayType): void;
+    setAlignment(alignment: Alignment): void;
+    getWidth(): number;
+    getHeight(): number;
+    setDimensions(width: number, height: number): void;
+    decorate(): JSX.Element;
+}
+export declare function $createEmbedNode(url: string, displayType?: DisplayType, alignment?: Alignment, width?: number, height?: number): EmbedNode;

package/dist/nodes/FileNode.d.ts

@@ -0,0 +1,32 @@
+import { DecoratorNode, DOMConversionMap, DOMExportOutput, EditorConfig, LexicalNode, NodeKey, SerializedLexicalNode, Spread } from '../../node_modules/lexical';
+export interface FilePayload {
+    src: string;
+    fileName: string;
+    fileSize?: number;
+    key?: NodeKey;
+}
+export type SerializedFileNode = Spread<{
+    src: string;
+    fileName: string;
+    fileSize?: number;
+}, SerializedLexicalNode>;
+export declare class FileNode extends DecoratorNode<JSX.Element> {
+    __src: string;
+    __fileName: string;
+    __fileSize?: number;
+    static getType(): string;
+    static clone(node: FileNode): FileNode;
+    static importJSON(serializedNode: SerializedFileNode): FileNode;
+    exportDOM(): DOMExportOutput;
+    static importDOM(): DOMConversionMap | null;
+    constructor(src: string, fileName: string, fileSize?: number, key?: NodeKey);
+    exportJSON(): SerializedFileNode;
+    createDOM(config: EditorConfig): HTMLElement;
+    updateDOM(): false;
+    getSrc(): string;
+    getFileName(): string;
+    getFileSize(): number | undefined;
+    decorate(): JSX.Element;
+}
+export declare function $createFileNode({ src, fileName, fileSize, key }: FilePayload): FileNode;
+export declare function $isFileNode(node: LexicalNode | null | undefined): node is FileNode;

package/dist/nodes/ImageNode.d.ts

@@ -0,0 +1,65 @@
+import { DOMConversionMap, DOMExportOutput, EditorConfig, LexicalEditor, LexicalNode, NodeKey, SerializedEditor, SerializedLexicalNode, Spread, DecoratorNode } from '../../node_modules/lexical';
+export type ImagePosition = "none" | "left" | "right" | "full" | "inline-left" | "inline-center" | "inline-right";
+export interface ImagePayload {
+    altText: string;
+    caption?: LexicalEditor;
+    height?: number;
+    key?: NodeKey;
+    maxWidth?: number;
+    showCaption?: boolean;
+    src: string;
+    width?: number;
+    captionsEnabled?: boolean;
+    originalPrompt?: string;
+    position?: ImagePosition;
+    linkUrl?: string;
+}
+export type SerializedImageNode = Spread<{
+    altText: string;
+    caption: SerializedEditor;
+    height?: number;
+    maxWidth: number;
+    showCaption: boolean;
+    src: string;
+    width?: number;
+    originalPrompt?: string;
+    position?: ImagePosition;
+    linkUrl?: string;
+}, SerializedLexicalNode>;
+export declare class ImageNode extends DecoratorNode<JSX.Element> {
+    __src: string;
+    __altText: string;
+    __width: "inherit" | number;
+    __height: "inherit" | number;
+    __maxWidth: number;
+    __showCaption: boolean;
+    __caption: LexicalEditor;
+    __captionsEnabled: boolean;
+    __originalPrompt: string;
+    __position: ImagePosition;
+    __linkUrl: string;
+    static getType(): string;
+    static clone(node: ImageNode): ImageNode;
+    static importJSON(serializedNode: SerializedImageNode): ImageNode;
+    exportDOM(): DOMExportOutput;
+    static importDOM(): DOMConversionMap | null;
+    constructor(src: string, altText: string, maxWidth: number, width?: "inherit" | number, height?: "inherit" | number, showCaption?: boolean, caption?: LexicalEditor, captionsEnabled?: boolean, originalPrompt?: string, position?: ImagePosition, linkUrl?: string, key?: NodeKey);
+    exportJSON(): SerializedImageNode;
+    setWidthAndHeight(width: "inherit" | number, height: "inherit" | number): void;
+    setShowCaption(showCaption: boolean): void;
+    private getPositionStyles;
+    createDOM(config: EditorConfig): HTMLElement;
+    updateDOM(prevNode: ImageNode, dom: HTMLElement): boolean;
+    getSrc(): string;
+    setSrc(src: string): void;
+    getAltText(): string;
+    getOriginalPrompt(): string;
+    setOriginalPrompt(prompt: string): void;
+    getPosition(): ImagePosition;
+    setPosition(position: ImagePosition): void;
+    getLinkUrl(): string;
+    setLinkUrl(linkUrl: string): void;
+    decorate(): JSX.Element;
+}
+export declare function $createImageNode({ altText, height, maxWidth, captionsEnabled, src, width, showCaption, caption, key, originalPrompt, position, linkUrl, }: ImagePayload): ImageNode;
+export declare function $isImageNode(node: LexicalNode | null | undefined): node is ImageNode;

package/dist/nodes/MentionNode.d.ts

@@ -0,0 +1,75 @@
+import { DOMConversionMap, DOMExportOutput, EditorConfig, LexicalNode, NodeKey, SerializedTextNode, Spread, TextNode } from '../../node_modules/lexical';
+/**
+ * Type definition for a serialized MentionNode.
+ * This extends a standard serialized text node with an additional `mentionName` property.
+ */
+export type SerializedMentionNode = Spread<{
+    mentionName: string;
+}, SerializedTextNode>;
+/**
+ * MentionNode class extends TextNode to represent a mention (e.g., @username).
+ */
+export declare class MentionNode extends TextNode {
+    __mention: string;
+    /**
+     * Returns the type identifier for this node.
+     */
+    static getType(): string;
+    /**
+     * Creates a clone of the MentionNode.
+     */
+    static clone(node: MentionNode): MentionNode;
+    /**
+     * Imports a MentionNode from JSON representation.
+     */
+    static importJSON(serializedNode: SerializedMentionNode): MentionNode;
+    /**
+     * Constructor for MentionNode.
+     * @param mentionName - The name of the mention (e.g., "@john")
+     * @param text - Optional text content (defaults to mention name)
+     * @param key - Optional unique node key
+     */
+    constructor(mentionName: string, text?: string, key?: NodeKey);
+    /**
+     * Serializes the MentionNode into JSON format.
+     */
+    exportJSON(): SerializedMentionNode;
+    /**
+     * Creates a DOM representation of the MentionNode.
+     * This determines how the mention appears in the editor.
+     */
+    createDOM(config: EditorConfig): HTMLElement;
+    /**
+     * Exports the MentionNode as a DOM element (for copying/pasting or saving).
+     */
+    exportDOM(): DOMExportOutput;
+    /**
+     * Defines how to import a MentionNode from a pasted or loaded HTML document.
+     */
+    static importDOM(): DOMConversionMap | null;
+    /**
+     * Indicates that this node represents a text entity, meaning it behaves as a single unit.
+     */
+    isTextEntity(): true;
+    /**
+     * Prevents inserting text before the mention (e.g., avoids breaking the mention).
+     */
+    canInsertTextBefore(): boolean;
+    /**
+     * Prevents inserting text after the mention (e.g., avoids breaking the mention).
+     */
+    canInsertTextAfter(): boolean;
+}
+/**
+ * Helper function to create a new MentionNode.
+ * @param mentionName - The name of the mention (e.g., "@john")
+ * @param textContent - Optional text content (defaults to mention name)
+ * @returns A newly created MentionNode.
+ */
+export declare function $createMentionNode(mentionName: string, textContent?: string): MentionNode;
+/**
+ * Type guard function to check if a node is a MentionNode.
+ * @param node - The node to check.
+ * @returns True if the node is a MentionNode, false otherwise.
+ */
+export declare function $isMentionNode(node: LexicalNode | null | undefined): node is MentionNode;

package/dist/nodes/NotePanelNode.d.ts

@@ -0,0 +1,31 @@
+import { DOMConversionMap, DOMExportOutput, EditorConfig, LexicalNode, NodeKey, SerializedLexicalNode, Spread, DecoratorNode } from '../../node_modules/lexical';
+export type NotePanelType = "info" | "warning" | "error" | "success" | "note";
+export interface NotePanelPayload {
+    type: NotePanelType;
+    title?: string;
+    key?: NodeKey;
+}
+export type SerializedNotePanelNode = Spread<{
+    panelType: NotePanelType;
+    title: string;
+}, SerializedLexicalNode>;
+export declare class NotePanelNode extends DecoratorNode<JSX.Element> {
+    __panelType: NotePanelType;
+    __title: string;
+    static getType(): string;
+    static clone(node: NotePanelNode): NotePanelNode;
+    static importJSON(serializedNode: SerializedNotePanelNode): NotePanelNode;
+    exportDOM(): DOMExportOutput;
+    static importDOM(): DOMConversionMap | null;
+    constructor(type: NotePanelType, title?: string, key?: NodeKey);
+    exportJSON(): SerializedNotePanelNode;
+    setPanelType(type: NotePanelType): void;
+    setTitle(title: string): void;
+    createDOM(config: EditorConfig): HTMLElement;
+    updateDOM(): false;
+    getPanelType(): NotePanelType;
+    getTitle(): string;
+    decorate(): JSX.Element;
+}
+export declare function $createNotePanelNode({ type, title, key, }: NotePanelPayload): NotePanelNode;
+export declare function $isNotePanelNode(node: LexicalNode | null | undefined): node is NotePanelNode;

package/dist/pages/ConfigurableEditor/ConfigurableEditor.d.ts

@@ -0,0 +1,26 @@
+import { default as React } from 'react';
+import { EditorConfigTypes } from '../../types';
+/**
+ * Handles editor state changes, retrieving root and selection.
+ */
+/**
+ * ConfigurableEditor component using Lexical.
+ * Includes plugins for various functionalities such as lists, tables, and formatting.
+ */
+interface CurrentUser {
+    id: string;
+    name: string;
+    email?: string;
+    avatar?: string;
+}
+interface ConfigurableEditorProps {
+    config: EditorConfigTypes;
+    defaultFontFamilies: string[];
+    mentionUserList: string[];
+    currentUser?: CurrentUser | null;
+    initialContent?: string;
+    onChange?: (html: string) => void;
+    apiKey?: string;
+}
+declare const ConfigurableEditor: React.FC<ConfigurableEditorProps>;
+export default ConfigurableEditor;

package/dist/pages/ConfigurableEditor/index.d.ts

@@ -0,0 +1,2 @@
+declare const ConfigurableEditorPage: () => import("react/jsx-runtime").JSX.Element;
+export default ConfigurableEditorPage;

package/dist/pages/NotFound.d.ts

@@ -0,0 +1,2 @@
+declare const NotFound: () => import("react/jsx-runtime").JSX.Element;
+export default NotFound;

package/dist/pages/RichTextEditor.d.ts

@@ -0,0 +1,6 @@
+/**
+ * RichTextEditor component using Lexical.
+ * Includes plugins for various functionalities such as lists, tables, and formatting.
+ */
+export declare const RichTextEditor: () => import("react/jsx-runtime").JSX.Element;
+export default RichTextEditor;

package/dist/pages/TextareaEditor.d.ts

@@ -0,0 +1,6 @@
+/**
+ * TextareaEditor component using Lexical.
+ * Includes plugins for various functionalities such as lists, tables, and formatting.
+ */
+export declare const TextareaEditor: () => import("react/jsx-runtime").JSX.Element;
+export default TextareaEditor;

package/dist/pages/styles.d.ts

@@ -0,0 +1,5 @@
+declare const useStyles: () => {
+    contentEditable: string;
+    placeholder: string;
+};
+export default useStyles;

package/dist/pcm-processor.js

@@ -0,0 +1,50 @@
+// pcm-processor.js
+
+class PCMProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    this.audioBuffer = [];
+    this.totalSamples = 0;
+    // Reduced to 1600 samples = 100ms at 16kHz (5x faster, still safe for network transmission)
+    this.targetChunkSize = 1600;
+  }
+
+  process(inputs, outputs, parameters) {
+    const input = inputs[0];
+    if (input.length > 0) {
+      const channelData = input[0]; // Mono channel
+
+      // Convert Float32Array to Int16Array (PCM s16le)
+      const pcmData = new Int16Array(channelData.length);
+      for (let i = 0; i < channelData.length; i++) {
+        let s = Math.max(-1, Math.min(1, channelData[i]));
+        pcmData[i] = s < 0 ? s * 0x8000 : s * 0x7FFF;
+      }
+      
+      // Accumulate audio data
+      this.audioBuffer.push(pcmData);
+      this.totalSamples += pcmData.length;
+      
+      // Send when we have enough data (100ms worth for 5x faster response)
+      if (this.totalSamples >= this.targetChunkSize) {
+        // Combine all accumulated audio data
+        const combinedData = new Int16Array(this.totalSamples);
+        let offset = 0;
+        for (const buffer of this.audioBuffer) {
+          combinedData.set(buffer, offset);
+          offset += buffer.length;
+        }
+        
+        // Send buffer to the main thread (as transferable)
+        this.port.postMessage(combinedData.buffer, [combinedData.buffer]);
+        
+        // Reset for next chunk
+        this.audioBuffer = [];
+        this.totalSamples = 0;
+      }
+    }
+    return true;
+  }
+}
+
+registerProcessor('pcm-processor', PCMProcessor); 

package/dist/plugins/AIChatPlugin.d.ts

@@ -0,0 +1,11 @@
+import { LexicalCommand } from '../../node_modules/lexical';
+type AIProvider = 'chatgpt' | 'claude' | 'grok';
+export declare const TOGGLE_AI_CHAT_COMMAND: LexicalCommand<string | undefined>;
+export declare const SHOW_INLINE_AI_PROMPT_COMMAND: LexicalCommand<{
+    provider?: AIProvider;
+    initialText?: string;
+} | undefined>;
+export default function AIChatPlugin({ apiKey, }: {
+    apiKey?: string;
+}): JSX.Element | null;
+export {};

package/dist/plugins/AndroidKeyboardFixPlugin.d.ts

@@ -0,0 +1,16 @@
+/**
+ * AndroidKeyboardFixPlugin
+ *
+ * This plugin fixes issues with Android virtual keyboards (like Microsoft SwiftKey)
+ * where spaces after words appear and disappear quickly.
+ *
+ * The issue occurs because Android IME keyboards use composition events for
+ * predictive text. When space is pressed:
+ * 1. The keyboard triggers compositionend for the current word
+ * 2. Then sends an insertText event for the space
+ * 3. But there's a race condition where Lexical processes these events
+ *    in a way that the space gets inserted and then removed
+ *
+ * This plugin intercepts composition events and ensures spaces are properly preserved.
+ */
+export default function AndroidKeyboardFixPlugin(): null;

package/dist/plugins/AutocompletePlugin.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="react" />
+export interface AutocompleteOption {
+    displayText: string;
+    key: string;
+    queryWordStart: number;
+    queryWordEnd: number;
+    type: "suggestion" | "correction" | "spelling" | "enhancement";
+    confidence?: "high" | "medium" | "low";
+    originalWord?: string;
+}
+interface AutocompletePluginProps {
+    onQueryChange?: (query: string | null) => void;
+    onSelectOption?: (selectedOption: AutocompleteOption, nodeToReplace: any, closeMenu: () => void) => void;
+    minMatchLength?: number;
+    maxSuggestions?: number;
+    apiEndpoint?: string;
+    enableAI?: boolean;
+    debounceDelay?: number;
+}
+export declare const AUTOCOMPLETE_COMMAND: import('../../node_modules/lexical').LexicalCommand<string>;
+export default function AutocompletePlugin({ onQueryChange, onSelectOption, minMatchLength, maxSuggestions, apiEndpoint, enableAI, debounceDelay, }: AutocompletePluginProps): JSX.Element | null;
+export {};

package/dist/plugins/CodeBlockNormalizerPlugin.d.ts

@@ -0,0 +1,8 @@
+/**
+ * CodeBlockNormalizerPlugin
+ *
+ * This plugin normalizes code blocks to fix double line break issues.
+ * It acts as a safety net to remove consecutive LineBreakNodes in code blocks,
+ * ensuring proper line spacing and accurate line numbering in the gutter.
+ */
+export default function CodeBlockNormalizerPlugin(): null;

package/dist/plugins/CodeBlockSelectAllPlugin.d.ts

@@ -0,0 +1,8 @@
+/**
+ * CodeBlockSelectAllPlugin
+ *
+ * This plugin handles Cmd+A (select all) behavior for code blocks.
+ * When the cursor is inside a code block, Cmd+A will select only the
+ * content of that code block instead of the entire editor content.
+ */
+export default function CodeBlockSelectAllPlugin(): null;

package/dist/plugins/CodeHighlightPlugin.d.ts

@@ -0,0 +1,3 @@
+import { FC } from 'react';
+declare const CodeHighlightPlugin: FC;
+export default CodeHighlightPlugin;

package/dist/plugins/CombinedAutocompletGrammarPlugin.d.ts

@@ -0,0 +1,20 @@
+export interface AutocompleteOption {
+    displayText: string;
+    key: string;
+    queryWordStart: number;
+    queryWordEnd: number;
+    type: "suggestion";
+    confidence?: "low";
+}
+interface CombinedPluginProps {
+    onQueryChange?: (query: string | null) => void;
+    onSelectOption?: (selectedOption: AutocompleteOption, nodeToReplace: any, closeMenu: () => void) => void;
+    minMatchLength?: number;
+    maxSuggestions?: number;
+    apiEndpoint?: string;
+    enableAI?: boolean;
+    debounceDelay?: number;
+}
+export declare const AUTOCOMPLETE_COMMAND: import('../../node_modules/lexical').LexicalCommand<string>;
+export default function CombinedAutocompleteGrammarPlugin({ onQueryChange, onSelectOption, minMatchLength, maxSuggestions, apiEndpoint, enableAI, debounceDelay, }: CombinedPluginProps): JSX.Element | null;
+export {};

package/dist/plugins/CommentBubblePlugin.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+declare const CommentBubblePlugin: React.FC;
+export default CommentBubblePlugin;

package/dist/plugins/CommentPlugin.d.ts

@@ -0,0 +1,8 @@
+import { LexicalCommand } from '../../node_modules/lexical';
+import { default as React } from 'react';
+export declare const INSERT_COMMENT_COMMAND: LexicalCommand<{
+    text: string;
+}>;
+export declare const OPEN_COMMENT_MODAL_COMMAND: LexicalCommand<unknown>;
+declare const CommentPlugin: React.FC;
+export default CommentPlugin;

package/dist/plugins/CustomHorizontalRulePlugin/CustomHorizontalRuleNode.d.ts

@@ -0,0 +1,30 @@
+import { HorizontalRuleNode as BaseHorizontalRuleNode } from '../../../node_modules/@lexical/react/LexicalHorizontalRuleNode';
+import { DOMConversionMap, DOMExportOutput, LexicalCommand, LexicalNode, NodeKey, SerializedLexicalNode, Spread } from '../../../node_modules/lexical';
+export interface CustomHorizontalRulePayload {
+    color?: string;
+    strokeWidth?: number;
+}
+export type SerializedCustomHorizontalRuleNode = Spread<{
+    color?: string;
+    strokeWidth?: number;
+}, SerializedLexicalNode>;
+export declare const INSERT_CUSTOM_HORIZONTAL_RULE_COMMAND: LexicalCommand<CustomHorizontalRulePayload>;
+export declare class CustomHorizontalRuleNode extends BaseHorizontalRuleNode {
+    __color?: string;
+    __strokeWidth?: number;
+    static getType(): string;
+    static clone(node: CustomHorizontalRuleNode): CustomHorizontalRuleNode;
+    constructor(color?: string, strokeWidth?: number, key?: NodeKey);
+    createDOM(): HTMLElement;
+    updateDOM(): boolean;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serializedNode: SerializedCustomHorizontalRuleNode): CustomHorizontalRuleNode;
+    exportDOM(): DOMExportOutput;
+    exportJSON(): SerializedCustomHorizontalRuleNode;
+    getColor(): string | undefined;
+    setColor(color?: string): void;
+    getStrokeWidth(): number | undefined;
+    setStrokeWidth(strokeWidth?: number): void;
+}
+export declare function $createCustomHorizontalRuleNode(color?: string, strokeWidth?: number): CustomHorizontalRuleNode;
+export declare function $isCustomHorizontalRuleNode(node: LexicalNode | null | undefined): node is CustomHorizontalRuleNode;

package/dist/plugins/CustomHorizontalRulePlugin/CustomHorizontalRulePlugin.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const CustomHorizontalRulePlugin: React.FC;
+export default CustomHorizontalRulePlugin;

package/dist/plugins/CustomHorizontalRulePlugin/HorizontalRuleCustomizationDialog.d.ts

@@ -0,0 +1,8 @@
+import { LexicalEditor } from '../../../node_modules/lexical';
+import { default as React } from 'react';
+interface HorizontalRuleCustomizationDialogProps {
+    activeEditor: LexicalEditor;
+    onClose: () => void;
+}
+declare const HorizontalRuleCustomizationDialog: React.FC<HorizontalRuleCustomizationDialogProps>;
+export default HorizontalRuleCustomizationDialog;

package/dist/plugins/CustomHorizontalRulePlugin/index.d.ts

@@ -0,0 +1,3 @@
+export { $createCustomHorizontalRuleNode, $isCustomHorizontalRuleNode, CustomHorizontalRuleNode, type CustomHorizontalRulePayload, INSERT_CUSTOM_HORIZONTAL_RULE_COMMAND, type SerializedCustomHorizontalRuleNode, } from './CustomHorizontalRuleNode';
+export { default as CustomHorizontalRulePlugin } from './CustomHorizontalRulePlugin';
+export { default as HorizontalRuleCustomizationDialog } from './HorizontalRuleCustomizationDialog';

package/dist/plugins/DragDropPastePlugin/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+export default function DragDropPaste(): null;

package/dist/plugins/EmbedPreviewPlugin/FloatingEmbedMenuPlugin.d.ts

@@ -0,0 +1,3 @@
+export default function FloatingEmbedMenuPlugin({ anchorElem, }: {
+    anchorElem?: HTMLElement;
+}): JSX.Element | null;

package/dist/plugins/EmbedPreviewPlugin/index.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+interface EmbedPreviewPluginProps {
+    floatingAnchorElem?: HTMLElement;
+}
+declare const EmbedPreviewPlugin: React.FC<EmbedPreviewPluginProps>;
+export default EmbedPreviewPlugin;

package/dist/plugins/FilePlugin.d.ts

@@ -0,0 +1,8 @@
+import { LexicalCommand } from '../../node_modules/lexical';
+export declare const INSERT_FILE_COMMAND: LexicalCommand<{
+    src: string;
+    linkText: string;
+    fileSize?: number;
+}>;
+declare const FilePlugin: React.FC;
+export default FilePlugin;