@datalayer/lexical-loro 0.0.3 → 0.1.0

package/lib/nodes/InlineImageNode/InlineImageNode.d.ts

@@ -0,0 +1,59 @@
+import type { DOMConversionMap, DOMExportOutput, EditorConfig, LexicalEditor, LexicalNode, LexicalUpdateJSON, NodeKey, SerializedEditor, SerializedLexicalNode, Spread } from 'lexical';
+import type { JSX } from 'react';
+import { DecoratorNode } from 'lexical';
+export type Position = 'left' | 'right' | 'full' | undefined;
+export interface InlineImagePayload {
+    altText: string;
+    caption?: LexicalEditor;
+    height?: number;
+    key?: NodeKey;
+    showCaption?: boolean;
+    src: string;
+    width?: number;
+    position?: Position;
+}
+export interface UpdateInlineImagePayload {
+    altText?: string;
+    showCaption?: boolean;
+    position?: Position;
+}
+export type SerializedInlineImageNode = Spread<{
+    altText: string;
+    caption: SerializedEditor;
+    height?: number;
+    showCaption: boolean;
+    src: string;
+    width?: number;
+    position?: Position;
+}, SerializedLexicalNode>;
+export declare class InlineImageNode extends DecoratorNode<JSX.Element> {
+    __src: string;
+    __altText: string;
+    __width: 'inherit' | number;
+    __height: 'inherit' | number;
+    __showCaption: boolean;
+    __caption: LexicalEditor;
+    __position: Position;
+    static getType(): string;
+    static clone(node: InlineImageNode): InlineImageNode;
+    static importJSON(serializedNode: SerializedInlineImageNode): InlineImageNode;
+    updateFromJSON(serializedNode: LexicalUpdateJSON<SerializedInlineImageNode>): this;
+    static importDOM(): DOMConversionMap | null;
+    constructor(src: string, altText: string, position: Position, width?: 'inherit' | number, height?: 'inherit' | number, showCaption?: boolean, caption?: LexicalEditor, key?: NodeKey);
+    exportDOM(): DOMExportOutput;
+    exportJSON(): SerializedInlineImageNode;
+    getSrc(): string;
+    getAltText(): string;
+    setAltText(altText: string): void;
+    setWidthAndHeight(width: 'inherit' | number, height: 'inherit' | number): void;
+    getShowCaption(): boolean;
+    setShowCaption(showCaption: boolean): void;
+    getPosition(): Position;
+    setPosition(position: Position): void;
+    update(payload: UpdateInlineImagePayload): void;
+    createDOM(config: EditorConfig): HTMLElement;
+    updateDOM(prevNode: this, dom: HTMLElement, config: EditorConfig): false;
+    decorate(): JSX.Element;
+}
+export declare function $createInlineImageNode({ altText, position, height, src, width, showCaption, caption, key, }: InlineImagePayload): InlineImageNode;
+export declare function $isInlineImageNode(node: LexicalNode | null | undefined): node is InlineImageNode;

package/lib/nodes/InlineImageNode/InlineImageNode.js

@@ -0,0 +1,162 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { addClassNamesToElement, removeClassNamesFromElement, } from '@lexical/utils';
+import { $applyNodeReplacement, createEditor, DecoratorNode, isHTMLElement, } from 'lexical';
+import * as React from 'react';
+const InlineImageComponent = React.lazy(() => import('./InlineImageComponent'));
+function $convertInlineImageElement(domNode) {
+    if (isHTMLElement(domNode) && domNode.nodeName === 'IMG') {
+        const { alt: altText, src, width, height } = domNode;
+        const node = $createInlineImageNode({ altText, height, src, width });
+        return { node };
+    }
+    return null;
+}
+function getPositionClass(position) {
+    return typeof position === 'string' ? `position-${position}` : undefined;
+}
+export class InlineImageNode extends DecoratorNode {
+    __src;
+    __altText;
+    __width;
+    __height;
+    __showCaption;
+    __caption;
+    __position;
+    static getType() {
+        return 'inline-image';
+    }
+    static clone(node) {
+        return new InlineImageNode(node.__src, node.__altText, node.__position, node.__width, node.__height, node.__showCaption, node.__caption, node.__key);
+    }
+    static importJSON(serializedNode) {
+        const { altText, height, width, src, showCaption, position } = serializedNode;
+        return $createInlineImageNode({
+            altText,
+            height,
+            position,
+            showCaption,
+            src,
+            width,
+        }).updateFromJSON(serializedNode);
+    }
+    updateFromJSON(serializedNode) {
+        const { caption } = serializedNode;
+        const node = super.updateFromJSON(serializedNode);
+        const nestedEditor = node.__caption;
+        const editorState = nestedEditor.parseEditorState(caption.editorState);
+        if (!editorState.isEmpty()) {
+            nestedEditor.setEditorState(editorState);
+        }
+        return node;
+    }
+    static importDOM() {
+        return {
+            img: (node) => ({
+                conversion: $convertInlineImageElement,
+                priority: 0,
+            }),
+        };
+    }
+    constructor(src, altText, position, width, height, showCaption, caption, key) {
+        super(key);
+        this.__src = src;
+        this.__altText = altText;
+        this.__width = width || 'inherit';
+        this.__height = height || 'inherit';
+        this.__showCaption = showCaption || false;
+        this.__caption = caption || createEditor();
+        this.__position = position;
+    }
+    exportDOM() {
+        const element = document.createElement('img');
+        element.setAttribute('src', this.__src);
+        element.setAttribute('alt', this.__altText);
+        element.setAttribute('width', this.__width.toString());
+        element.setAttribute('height', this.__height.toString());
+        return { element };
+    }
+    exportJSON() {
+        return {
+            ...super.exportJSON(),
+            altText: this.getAltText(),
+            caption: this.__caption.toJSON(),
+            height: this.__height === 'inherit' ? 0 : this.__height,
+            position: this.__position,
+            showCaption: this.__showCaption,
+            src: this.getSrc(),
+            width: this.__width === 'inherit' ? 0 : this.__width,
+        };
+    }
+    getSrc() {
+        return this.__src;
+    }
+    getAltText() {
+        return this.__altText;
+    }
+    setAltText(altText) {
+        const writable = this.getWritable();
+        writable.__altText = altText;
+    }
+    setWidthAndHeight(width, height) {
+        const writable = this.getWritable();
+        writable.__width = width;
+        writable.__height = height;
+    }
+    getShowCaption() {
+        return this.__showCaption;
+    }
+    setShowCaption(showCaption) {
+        const writable = this.getWritable();
+        writable.__showCaption = showCaption;
+    }
+    getPosition() {
+        return this.__position;
+    }
+    setPosition(position) {
+        const writable = this.getWritable();
+        writable.__position = position;
+    }
+    update(payload) {
+        const writable = this.getWritable();
+        const { altText, showCaption, position } = payload;
+        if (altText !== undefined) {
+            writable.__altText = altText;
+        }
+        if (showCaption !== undefined) {
+            writable.__showCaption = showCaption;
+        }
+        if (position !== undefined) {
+            writable.__position = position;
+        }
+    }
+    // View
+    createDOM(config) {
+        const span = document.createElement('span');
+        for (const cls of [
+            config.theme.inlineImage,
+            getPositionClass(this.__position),
+        ]) {
+            if (cls) {
+                addClassNamesToElement(span, cls);
+            }
+        }
+        return span;
+    }
+    updateDOM(prevNode, dom, config) {
+        const position = this.__position;
+        if (position !== prevNode.__position) {
+            removeClassNamesFromElement(dom, getPositionClass(prevNode.__position));
+            addClassNamesToElement(dom, getPositionClass(position));
+        }
+        return false;
+    }
+    decorate() {
+        return (_jsx(InlineImageComponent, { src: this.__src, altText: this.__altText, width: this.__width, height: this.__height, nodeKey: this.getKey(), showCaption: this.__showCaption, caption: this.__caption, position: this.__position }));
+    }
+}
+export function $createInlineImageNode({ altText, position, height, src, width, showCaption, caption, key, }) {
+    return $applyNodeReplacement(new InlineImageNode(src, altText, position, width, height, showCaption, caption, key));
+}
+export function $isInlineImageNode(node) {
+    return node instanceof InlineImageNode;
+}

package/lib/nodes/KeywordNode.d.ts

@@ -0,0 +1,14 @@
+import type { EditorConfig, LexicalNode, SerializedTextNode } from 'lexical';
+import { TextNode } from 'lexical';
+export type SerializedKeywordNode = SerializedTextNode;
+export declare class KeywordNode extends TextNode {
+    static getType(): string;
+    static clone(node: KeywordNode): KeywordNode;
+    static importJSON(serializedNode: SerializedKeywordNode): KeywordNode;
+    createDOM(config: EditorConfig): HTMLElement;
+    canInsertTextBefore(): boolean;
+    canInsertTextAfter(): boolean;
+    isTextEntity(): true;
+}
+export declare function $createKeywordNode(keyword?: string): KeywordNode;
+export declare function $isKeywordNode(node: LexicalNode | null | undefined): boolean;

package/lib/nodes/KeywordNode.js

@@ -0,0 +1,33 @@
+import { $applyNodeReplacement, TextNode } from 'lexical';
+export class KeywordNode extends TextNode {
+    static getType() {
+        return 'keyword';
+    }
+    static clone(node) {
+        return new KeywordNode(node.__text, node.__key);
+    }
+    static importJSON(serializedNode) {
+        return $createKeywordNode().updateFromJSON(serializedNode);
+    }
+    createDOM(config) {
+        const dom = super.createDOM(config);
+        dom.style.cursor = 'default';
+        dom.className = 'keyword';
+        return dom;
+    }
+    canInsertTextBefore() {
+        return false;
+    }
+    canInsertTextAfter() {
+        return false;
+    }
+    isTextEntity() {
+        return true;
+    }
+}
+export function $createKeywordNode(keyword = '') {
+    return $applyNodeReplacement(new KeywordNode(keyword));
+}
+export function $isKeywordNode(node) {
+    return node instanceof KeywordNode;
+}

package/lib/nodes/LayoutContainerNode.d.ts

@@ -0,0 +1,24 @@
+import type { DOMConversionMap, DOMExportOutput, EditorConfig, LexicalNode, LexicalUpdateJSON, NodeKey, SerializedElementNode, Spread } from 'lexical';
+import { ElementNode } from 'lexical';
+export type SerializedLayoutContainerNode = Spread<{
+    templateColumns: string;
+}, SerializedElementNode>;
+export declare class LayoutContainerNode extends ElementNode {
+    __templateColumns: string;
+    constructor(templateColumns: string, key?: NodeKey);
+    static getType(): string;
+    static clone(node: LayoutContainerNode): LayoutContainerNode;
+    createDOM(config: EditorConfig): HTMLElement;
+    exportDOM(): DOMExportOutput;
+    updateDOM(prevNode: this, dom: HTMLElement): boolean;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(json: SerializedLayoutContainerNode): LayoutContainerNode;
+    updateFromJSON(serializedNode: LexicalUpdateJSON<SerializedLayoutContainerNode>): this;
+    isShadowRoot(): boolean;
+    canBeEmpty(): boolean;
+    exportJSON(): SerializedLayoutContainerNode;
+    getTemplateColumns(): string;
+    setTemplateColumns(templateColumns: string): this;
+}
+export declare function $createLayoutContainerNode(templateColumns?: string): LayoutContainerNode;
+export declare function $isLayoutContainerNode(node: LexicalNode | null | undefined): node is LayoutContainerNode;

package/lib/nodes/LayoutContainerNode.js

@@ -0,0 +1,91 @@
+import { addClassNamesToElement } from '@lexical/utils';
+import { ElementNode } from 'lexical';
+function $convertLayoutContainerElement(domNode) {
+    const styleAttributes = window.getComputedStyle(domNode);
+    const templateColumns = styleAttributes.getPropertyValue('grid-template-columns');
+    if (templateColumns) {
+        const node = $createLayoutContainerNode(templateColumns);
+        return { node };
+    }
+    return null;
+}
+export class LayoutContainerNode extends ElementNode {
+    __templateColumns;
+    constructor(templateColumns, key) {
+        super(key);
+        this.__templateColumns = templateColumns;
+    }
+    static getType() {
+        return 'layout-container';
+    }
+    static clone(node) {
+        return new LayoutContainerNode(node.__templateColumns, node.__key);
+    }
+    createDOM(config) {
+        const dom = document.createElement('div');
+        dom.style.gridTemplateColumns = this.__templateColumns;
+        if (typeof config.theme.layoutContainer === 'string') {
+            addClassNamesToElement(dom, config.theme.layoutContainer);
+        }
+        return dom;
+    }
+    exportDOM() {
+        const element = document.createElement('div');
+        element.style.gridTemplateColumns = this.__templateColumns;
+        element.setAttribute('data-lexical-layout-container', 'true');
+        return { element };
+    }
+    updateDOM(prevNode, dom) {
+        if (prevNode.__templateColumns !== this.__templateColumns) {
+            dom.style.gridTemplateColumns = this.__templateColumns;
+        }
+        return false;
+    }
+    static importDOM() {
+        return {
+            div: (domNode) => {
+                if (!domNode.hasAttribute('data-lexical-layout-container')) {
+                    return null;
+                }
+                return {
+                    conversion: $convertLayoutContainerElement,
+                    priority: 2,
+                };
+            },
+        };
+    }
+    static importJSON(json) {
+        return $createLayoutContainerNode().updateFromJSON(json);
+    }
+    updateFromJSON(serializedNode) {
+        return super
+            .updateFromJSON(serializedNode)
+            .setTemplateColumns(serializedNode.templateColumns);
+    }
+    isShadowRoot() {
+        return true;
+    }
+    canBeEmpty() {
+        return false;
+    }
+    exportJSON() {
+        return {
+            ...super.exportJSON(),
+            templateColumns: this.__templateColumns,
+        };
+    }
+    getTemplateColumns() {
+        return this.getLatest().__templateColumns;
+    }
+    setTemplateColumns(templateColumns) {
+        const self = this.getWritable();
+        self.__templateColumns = templateColumns;
+        return self;
+    }
+}
+export function $createLayoutContainerNode(templateColumns = '') {
+    return new LayoutContainerNode(templateColumns);
+}
+export function $isLayoutContainerNode(node) {
+    return node instanceof LayoutContainerNode;
+}

package/lib/nodes/LayoutItemNode.d.ts

@@ -0,0 +1,16 @@
+import type { DOMConversionMap, EditorConfig, LexicalNode, SerializedElementNode } from 'lexical';
+import { ElementNode } from 'lexical';
+export type SerializedLayoutItemNode = SerializedElementNode;
+export declare function $isEmptyLayoutItemNode(node: LexicalNode): boolean;
+export declare class LayoutItemNode extends ElementNode {
+    static getType(): string;
+    static clone(node: LayoutItemNode): LayoutItemNode;
+    createDOM(config: EditorConfig): HTMLElement;
+    updateDOM(): boolean;
+    collapseAtStart(): boolean;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serializedNode: SerializedLayoutItemNode): LayoutItemNode;
+    isShadowRoot(): boolean;
+}
+export declare function $createLayoutItemNode(): LayoutItemNode;
+export declare function $isLayoutItemNode(node: LexicalNode | null | undefined): node is LayoutItemNode;

package/lib/nodes/LayoutItemNode.js

@@ -0,0 +1,65 @@
+import { addClassNamesToElement } from '@lexical/utils';
+import { $isParagraphNode, ElementNode } from 'lexical';
+function $convertLayoutItemElement() {
+    return { node: $createLayoutItemNode() };
+}
+export function $isEmptyLayoutItemNode(node) {
+    if (!$isLayoutItemNode(node) || node.getChildrenSize() !== 1) {
+        return false;
+    }
+    const firstChild = node.getFirstChild();
+    return $isParagraphNode(firstChild) && firstChild.isEmpty();
+}
+export class LayoutItemNode extends ElementNode {
+    static getType() {
+        return 'layout-item';
+    }
+    static clone(node) {
+        return new LayoutItemNode(node.__key);
+    }
+    createDOM(config) {
+        const dom = document.createElement('div');
+        dom.setAttribute('data-lexical-layout-item', 'true');
+        if (typeof config.theme.layoutItem === 'string') {
+            addClassNamesToElement(dom, config.theme.layoutItem);
+        }
+        return dom;
+    }
+    updateDOM() {
+        return false;
+    }
+    collapseAtStart() {
+        const parent = this.getParentOrThrow();
+        if (this.is(parent.getFirstChild()) &&
+            parent.getChildren().every($isEmptyLayoutItemNode)) {
+            parent.remove();
+            return true;
+        }
+        return false;
+    }
+    static importDOM() {
+        return {
+            div: (domNode) => {
+                if (!domNode.hasAttribute('data-lexical-layout-item')) {
+                    return null;
+                }
+                return {
+                    conversion: $convertLayoutItemElement,
+                    priority: 2,
+                };
+            },
+        };
+    }
+    static importJSON(serializedNode) {
+        return $createLayoutItemNode().updateFromJSON(serializedNode);
+    }
+    isShadowRoot() {
+        return true;
+    }
+}
+export function $createLayoutItemNode() {
+    return new LayoutItemNode();
+}
+export function $isLayoutItemNode(node) {
+    return node instanceof LayoutItemNode;
+}

package/lib/nodes/MentionNode.d.ts

@@ -0,0 +1,20 @@
+import { type DOMConversionMap, type DOMExportOutput, type EditorConfig, type LexicalNode, type NodeKey, type SerializedTextNode, type Spread, TextNode } from 'lexical';
+export type SerializedMentionNode = Spread<{
+    mentionName: string;
+}, SerializedTextNode>;
+export declare class MentionNode extends TextNode {
+    __mention: string;
+    static getType(): string;
+    static clone(node: MentionNode): MentionNode;
+    static importJSON(serializedNode: SerializedMentionNode): MentionNode;
+    constructor(mentionName: string, text?: string, key?: NodeKey);
+    exportJSON(): SerializedMentionNode;
+    createDOM(config: EditorConfig): HTMLElement;
+    exportDOM(): DOMExportOutput;
+    static importDOM(): DOMConversionMap | null;
+    isTextEntity(): true;
+    canInsertTextBefore(): boolean;
+    canInsertTextAfter(): boolean;
+}
+export declare function $createMentionNode(mentionName: string, textContent?: string): MentionNode;
+export declare function $isMentionNode(node: LexicalNode | null | undefined): node is MentionNode;

package/lib/nodes/MentionNode.js

@@ -0,0 +1,81 @@
+import { $applyNodeReplacement, TextNode, } from 'lexical';
+function $convertMentionElement(domNode) {
+    const textContent = domNode.textContent;
+    const mentionName = domNode.getAttribute('data-lexical-mention-name');
+    if (textContent !== null) {
+        const node = $createMentionNode(typeof mentionName === 'string' ? mentionName : textContent, textContent);
+        return {
+            node,
+        };
+    }
+    return null;
+}
+const mentionStyle = 'background-color: rgba(24, 119, 232, 0.2)';
+export class MentionNode extends TextNode {
+    __mention;
+    static getType() {
+        return 'mention';
+    }
+    static clone(node) {
+        return new MentionNode(node.__mention, node.__text, node.__key);
+    }
+    static importJSON(serializedNode) {
+        return $createMentionNode(serializedNode.mentionName).updateFromJSON(serializedNode);
+    }
+    constructor(mentionName, text, key) {
+        super(text ?? mentionName, key);
+        this.__mention = mentionName;
+    }
+    exportJSON() {
+        return {
+            ...super.exportJSON(),
+            mentionName: this.__mention,
+        };
+    }
+    createDOM(config) {
+        const dom = super.createDOM(config);
+        dom.style.cssText = mentionStyle;
+        dom.className = 'mention';
+        dom.spellcheck = false;
+        return dom;
+    }
+    exportDOM() {
+        const element = document.createElement('span');
+        element.setAttribute('data-lexical-mention', 'true');
+        if (this.__text !== this.__mention) {
+            element.setAttribute('data-lexical-mention-name', this.__mention);
+        }
+        element.textContent = this.__text;
+        return { element };
+    }
+    static importDOM() {
+        return {
+            span: (domNode) => {
+                if (!domNode.hasAttribute('data-lexical-mention')) {
+                    return null;
+                }
+                return {
+                    conversion: $convertMentionElement,
+                    priority: 1,
+                };
+            },
+        };
+    }
+    isTextEntity() {
+        return true;
+    }
+    canInsertTextBefore() {
+        return false;
+    }
+    canInsertTextAfter() {
+        return false;
+    }
+}
+export function $createMentionNode(mentionName, textContent) {
+    const mentionNode = new MentionNode(mentionName, (textContent = mentionName));
+    mentionNode.setMode('segmented').toggleDirectionless();
+    return $applyNodeReplacement(mentionNode);
+}
+export function $isMentionNode(node) {
+    return node instanceof MentionNode;
+}

package/lib/nodes/PageBreakNode/index.d.ts

@@ -0,0 +1,17 @@
+import type { JSX } from 'react';
+import './index.css';
+import { DecoratorNode, DOMConversionMap, LexicalNode, SerializedLexicalNode } from 'lexical';
+export type SerializedPageBreakNode = SerializedLexicalNode;
+export declare class PageBreakNode extends DecoratorNode<JSX.Element> {
+    static getType(): string;
+    static clone(node: PageBreakNode): PageBreakNode;
+    static importJSON(serializedNode: SerializedPageBreakNode): PageBreakNode;
+    static importDOM(): DOMConversionMap | null;
+    createDOM(): HTMLElement;
+    getTextContent(): string;
+    isInline(): false;
+    updateDOM(): boolean;
+    decorate(): JSX.Element;
+}
+export declare function $createPageBreakNode(): PageBreakNode;
+export declare function $isPageBreakNode(node: LexicalNode | null | undefined): node is PageBreakNode;

package/lib/nodes/PageBreakNode/index.js

@@ -0,0 +1,83 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import './index.css';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { useLexicalNodeSelection } from '@lexical/react/useLexicalNodeSelection';
+import { mergeRegister } from '@lexical/utils';
+import { CLICK_COMMAND, COMMAND_PRIORITY_HIGH, COMMAND_PRIORITY_LOW, DecoratorNode, } from 'lexical';
+import { useEffect } from 'react';
+function PageBreakComponent({ nodeKey }) {
+    const [editor] = useLexicalComposerContext();
+    const [isSelected, setSelected, clearSelection] = useLexicalNodeSelection(nodeKey);
+    useEffect(() => {
+        return mergeRegister(editor.registerCommand(CLICK_COMMAND, (event) => {
+            const pbElem = editor.getElementByKey(nodeKey);
+            if (event.target === pbElem) {
+                if (!event.shiftKey) {
+                    clearSelection();
+                }
+                setSelected(!isSelected);
+                return true;
+            }
+            return false;
+        }, COMMAND_PRIORITY_LOW));
+    }, [clearSelection, editor, isSelected, nodeKey, setSelected]);
+    useEffect(() => {
+        const pbElem = editor.getElementByKey(nodeKey);
+        if (pbElem !== null) {
+            pbElem.className = isSelected ? 'selected' : '';
+        }
+    }, [editor, isSelected, nodeKey]);
+    return null;
+}
+export class PageBreakNode extends DecoratorNode {
+    static getType() {
+        return 'page-break';
+    }
+    static clone(node) {
+        return new PageBreakNode(node.__key);
+    }
+    static importJSON(serializedNode) {
+        return $createPageBreakNode().updateFromJSON(serializedNode);
+    }
+    static importDOM() {
+        return {
+            figure: (domNode) => {
+                const tp = domNode.getAttribute('type');
+                if (tp !== this.getType()) {
+                    return null;
+                }
+                return {
+                    conversion: $convertPageBreakElement,
+                    priority: COMMAND_PRIORITY_HIGH,
+                };
+            },
+        };
+    }
+    createDOM() {
+        const el = document.createElement('figure');
+        el.style.pageBreakAfter = 'always';
+        el.setAttribute('type', this.getType());
+        return el;
+    }
+    getTextContent() {
+        return '\n';
+    }
+    isInline() {
+        return false;
+    }
+    updateDOM() {
+        return false;
+    }
+    decorate() {
+        return _jsx(PageBreakComponent, { nodeKey: this.__key });
+    }
+}
+function $convertPageBreakElement() {
+    return { node: $createPageBreakNode() };
+}
+export function $createPageBreakNode() {
+    return new PageBreakNode();
+}
+export function $isPageBreakNode(node) {
+    return node instanceof PageBreakNode;
+}

package/lib/nodes/PlaygroundNodes.d.ts

@@ -0,0 +1,3 @@
+import type { Klass, LexicalNode } from 'lexical';
+declare const PlaygroundNodes: Array<Klass<LexicalNode>>;
+export default PlaygroundNodes;