@liminis/editor 0.1.0-rc.1

package/dist/app/editor/nodes/C4Component.js

@@ -0,0 +1,284 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * C4Component - React component for rendering and editing C4 architecture diagrams
+ *
+ * Uses the canonical React C4Renderer for diagram display.
+ * Provides editing UI (textarea overlay, click-to-edit) for the Lexical editor.
+ * Supports manual layout mode for drag-and-drop positioning of elements.
+ */
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { mergeRegister } from '@lexical/utils';
+import { $getNodeByKey, $getSelection, $isNodeSelection, COMMAND_PRIORITY_HIGH, KEY_ESCAPE_COMMAND, SELECTION_CHANGE_COMMAND, } from 'lexical';
+import { Move, RotateCcw } from 'lucide-react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { parseC4, validateC4 } from '../c4/parser.js';
+import { layoutC4Diagram } from '../c4/layout.js';
+import { C4Renderer, C4ErrorDisplay } from '../c4/renderer.js';
+import { C4InteractiveRenderer } from '../c4/C4InteractiveRenderer.js';
+import { $isC4Node } from './C4Node.js';
+import { DiagramContextMenu, useDiagramContextMenu } from './DiagramContextMenu.js';
+function C4DiagramDisplay({ code, nodeKey, onDoubleClick, isEditable, }) {
+    const [editor] = useLexicalComposerContext();
+    const containerRef = useRef(null);
+    const [isDarkMode, setIsDarkMode] = useState(false);
+    const [showToolbar, setShowToolbar] = useState(false);
+    const [isEditingLayout, setIsEditingLayout] = useState(false);
+    const contextMenu = useDiagramContextMenu();
+    const previousCodeRef = useRef(code);
+    // Read manual layout from the node
+    const [manualLayout, setManualLayout] = useState(() => {
+        return editor.getEditorState().read(() => {
+            const node = $getNodeByKey(nodeKey);
+            if ($isC4Node(node)) {
+                return node.getManualLayout();
+            }
+            return undefined;
+        });
+    });
+    // Sync manual layout from node when it changes externally (e.g., undo/redo)
+    useEffect(() => {
+        return editor.registerUpdateListener(({ editorState }) => {
+            editorState.read(() => {
+                const node = $getNodeByKey(nodeKey);
+                if ($isC4Node(node)) {
+                    const nodeLayout = node.getManualLayout();
+                    setManualLayout(nodeLayout);
+                }
+            });
+        });
+    }, [editor, nodeKey]);
+    // Detect theme using MutationObserver
+    useEffect(() => {
+        const detectTheme = () => {
+            const isDark = document.documentElement.classList.contains('dark');
+            setIsDarkMode(isDark);
+        };
+        detectTheme();
+        const observer = new MutationObserver(detectTheme);
+        observer.observe(document.documentElement, {
+            attributes: true,
+            attributeFilter: ['class'],
+        });
+        return () => observer.disconnect();
+    }, []);
+    // Parse, validate, and layout the diagram
+    const parseResult = useMemo(() => {
+        const pr = parseC4(code);
+        if (pr.diagram) {
+            const validationErrors = validateC4(pr.diagram);
+            pr.errors.push(...validationErrors);
+        }
+        return pr;
+    }, [code]);
+    const layout = useMemo(() => {
+        if (!parseResult.diagram || parseResult.errors.length > 0)
+            return null;
+        const positions = manualLayout?.positions;
+        return layoutC4Diagram(parseResult.diagram, undefined, positions);
+    }, [parseResult, manualLayout]);
+    // TASK 7: Clear manual layout when DSL code changes (elements added/removed)
+    useEffect(() => {
+        if (manualLayout && code !== previousCodeRef.current && parseResult.diagram) {
+            const newElementIds = new Set(parseResult.diagram.elements.map(e => e.id));
+            const oldElementIds = new Set(Object.keys(manualLayout.positions).filter(id => !id.startsWith('__')));
+            // Check if elements were added or removed
+            const hasChanges = newElementIds.size !== oldElementIds.size ||
+                [...newElementIds].some(id => !oldElementIds.has(id)) ||
+                [...oldElementIds].some(id => !newElementIds.has(id));
+            if (hasChanges) {
+                // Clear manual layout
+                editor.update(() => {
+                    const node = $getNodeByKey(nodeKey);
+                    if ($isC4Node(node)) {
+                        node.setManualLayout(undefined);
+                    }
+                });
+                setIsEditingLayout(false);
+            }
+        }
+        previousCodeRef.current = code;
+    }, [code, manualLayout, parseResult.diagram, editor, nodeKey]);
+    // TASK 6: Handle position changes with Lexical undo integration
+    // The update listener above will sync manualLayout state from the node,
+    // so we only need to write to the Lexical node here.
+    const handlePositionChange = useCallback((newPositions) => {
+        editor.update(() => {
+            const node = $getNodeByKey(nodeKey);
+            if ($isC4Node(node)) {
+                node.setManualLayout({ positions: newPositions });
+            }
+        });
+    }, [editor, nodeKey]);
+    // Handle reset to auto layout
+    const handleResetLayout = useCallback(() => {
+        editor.update(() => {
+            const node = $getNodeByKey(nodeKey);
+            if ($isC4Node(node)) {
+                node.setManualLayout(undefined);
+            }
+        });
+        setManualLayout(undefined);
+        setIsEditingLayout(false);
+    }, [editor, nodeKey]);
+    // Exit edit mode when clicking outside or pressing Escape
+    useEffect(() => {
+        if (!isEditingLayout)
+            return;
+        const handleKeyDown = (e) => {
+            if (e.key === 'Escape') {
+                setIsEditingLayout(false);
+            }
+        };
+        const handleMouseDown = (e) => {
+            const container = containerRef.current;
+            if (!container)
+                return;
+            if (e.target instanceof Node && !container.contains(e.target)) {
+                setIsEditingLayout(false);
+            }
+        };
+        window.addEventListener('keydown', handleKeyDown);
+        document.addEventListener('mousedown', handleMouseDown);
+        return () => {
+            window.removeEventListener('keydown', handleKeyDown);
+            document.removeEventListener('mousedown', handleMouseDown);
+        };
+    }, [isEditingLayout]);
+    if (!layout || !parseResult.diagram) {
+        return _jsx(C4ErrorDisplay, { errors: parseResult.errors, isDarkMode: isDarkMode });
+    }
+    const manualPositions = manualLayout?.positions ?? {};
+    return (_jsxs("div", { ref: containerRef, role: "button", tabIndex: 0, onDoubleClick: isEditingLayout ? undefined : onDoubleClick, onContextMenu: (e) => contextMenu.show(e, containerRef), onKeyDown: (e) => {
+            if (!isEditingLayout && (e.key === 'Enter' || e.key === ' ')) {
+                e.preventDefault();
+                onDoubleClick();
+            }
+        }, onMouseEnter: () => setShowToolbar(true), onMouseLeave: () => setShowToolbar(false), className: "c4-renderer c4-diagram-container", style: {
+            display: 'flex',
+            justifyContent: 'center',
+            padding: '1rem',
+            cursor: isEditingLayout ? 'default' : 'pointer',
+            minHeight: '100px',
+            overflowX: 'auto',
+            position: 'relative',
+        }, children: [isEditable && (showToolbar || isEditingLayout) && (_jsxs("div", { style: {
+                    position: 'absolute',
+                    top: '8px',
+                    right: '8px',
+                    display: 'flex',
+                    gap: '4px',
+                    zIndex: 10,
+                }, children: [_jsx("button", { type: "button", onClick: (e) => {
+                            e.stopPropagation();
+                            setIsEditingLayout(!isEditingLayout);
+                        }, title: isEditingLayout ? 'Exit layout mode' : 'Edit layout', "aria-label": isEditingLayout ? 'Exit layout mode' : 'Edit layout', style: {
+                            width: '28px',
+                            height: '28px',
+                            display: 'flex',
+                            alignItems: 'center',
+                            justifyContent: 'center',
+                            borderRadius: '4px',
+                            border: 'none',
+                            cursor: 'pointer',
+                            backgroundColor: isEditingLayout
+                                ? 'var(--color-primary-100, rgba(59, 130, 246, 0.1))'
+                                : 'var(--color-muted-100, rgba(128, 128, 128, 0.1))',
+                            color: isEditingLayout
+                                ? 'var(--color-primary, #3b82f6)'
+                                : 'var(--color-muted-foreground, #6b7280)',
+                        }, children: _jsx(Move, { size: 16 }) }), manualLayout && (_jsx("button", { type: "button", onClick: (e) => {
+                            e.stopPropagation();
+                            handleResetLayout();
+                        }, title: "Reset to auto layout", "aria-label": "Reset to auto layout", style: {
+                            width: '28px',
+                            height: '28px',
+                            display: 'flex',
+                            alignItems: 'center',
+                            justifyContent: 'center',
+                            borderRadius: '4px',
+                            border: 'none',
+                            cursor: 'pointer',
+                            backgroundColor: 'var(--color-muted-100, rgba(128, 128, 128, 0.1))',
+                            color: 'var(--color-muted-foreground, #6b7280)',
+                        }, children: _jsx(RotateCcw, { size: 16 }) }))] })), isEditingLayout && parseResult.diagram ? (_jsx(C4InteractiveRenderer, { diagram: parseResult.diagram, isDarkMode: isDarkMode, isEditMode: isEditingLayout, manualPositions: manualPositions, onPositionChange: handlePositionChange })) : (_jsx(C4Renderer, { layout: layout, isDarkMode: isDarkMode })), _jsx(DiagramContextMenu, { ...contextMenu.props, onEditText: isEditable ? onDoubleClick : undefined, onEditLayout: isEditable ? () => setIsEditingLayout(prev => !prev) : undefined, onResetLayout: isEditable ? handleResetLayout : undefined, isEditingLayout: isEditingLayout, hasManualLayout: !!manualLayout })] }));
+}
+// =============================================================================
+// C4 EDITOR
+// =============================================================================
+function C4Editor({ code, setCode, onClose, }) {
+    const textareaRef = useRef(null);
+    useEffect(() => {
+        textareaRef.current?.focus();
+    }, []);
+    const handleKeyDown = (e) => {
+        if (e.key === 'Escape') {
+            e.preventDefault();
+            onClose();
+        }
+    };
+    return (_jsxs("div", { className: "c4-editor-container", children: [_jsxs("div", { className: "c4-editor-header", children: [_jsx("span", { className: "c4-editor-label", children: "```c4" }), _jsx("button", { className: "c4-editor-close", onClick: onClose, title: "Close editor (Esc)", children: "\u2715" })] }), _jsx("textarea", { ref: textareaRef, className: "c4-editor-textarea", value: code, onChange: (e) => setCode(e.target.value), onKeyDown: handleKeyDown, placeholder: "Enter C4 diagram code...", spellCheck: false }), _jsx("div", { className: "c4-editor-footer", children: _jsx("span", { className: "c4-editor-label", children: "```" }) })] }));
+}
+export default function C4Component({ code, nodeKey, }) {
+    const [editor] = useLexicalComposerContext();
+    const [isEditable, setIsEditable] = useState(() => editor.isEditable());
+    const [codeValue, setCodeValue] = useState(code);
+    const [showEditor, setShowEditor] = useState(false);
+    // Listen for editable changes
+    useEffect(() => {
+        return editor.registerEditableListener((editable) => {
+            setIsEditable(editable);
+        });
+    }, [editor]);
+    const onHide = useCallback(() => {
+        setShowEditor(false);
+        editor.update(() => {
+            const node = $getNodeByKey(nodeKey);
+            if ($isC4Node(node)) {
+                node.setCode(codeValue);
+            }
+        });
+    }, [editor, codeValue, nodeKey]);
+    useEffect(() => {
+        if (!showEditor && codeValue !== code) {
+            setCodeValue(code);
+        }
+    }, [showEditor, code, codeValue]);
+    useEffect(() => {
+        if (!isEditable) {
+            return;
+        }
+        if (showEditor) {
+            return mergeRegister(editor.registerCommand(SELECTION_CHANGE_COMMAND, () => {
+                // Don't close on selection change while editing
+                return false;
+            }, COMMAND_PRIORITY_HIGH), editor.registerCommand(KEY_ESCAPE_COMMAND, () => {
+                if (showEditor) {
+                    onHide();
+                    return true;
+                }
+                return false;
+            }, COMMAND_PRIORITY_HIGH));
+        }
+        else {
+            return editor.registerUpdateListener(({ editorState }) => {
+                const isSelected = editorState.read(() => {
+                    const selection = $getSelection();
+                    return ($isNodeSelection(selection) &&
+                        selection.has(nodeKey) &&
+                        selection.getNodes().length === 1);
+                });
+                if (isSelected) {
+                    setShowEditor(true);
+                }
+            });
+        }
+    }, [editor, nodeKey, onHide, showEditor, isEditable]);
+    if (showEditor && isEditable) {
+        return (_jsx(C4Editor, { code: codeValue, setCode: setCodeValue, onClose: onHide }));
+    }
+    return (_jsx(C4DiagramDisplay, { code: codeValue, nodeKey: nodeKey, isEditable: isEditable, onDoubleClick: () => {
+            if (isEditable) {
+                setShowEditor(true);
+            }
+        } }));
+}

package/dist/app/editor/nodes/C4Node.d.ts

@@ -0,0 +1,32 @@
+/**
+ * C4Node - Renders C4 architecture diagrams
+ * Uses DecoratorNode pattern similar to MermaidNode
+ */
+import { DecoratorNode, DOMConversionMap, DOMExportOutput, LexicalNode, NodeKey, SerializedLexicalNode, Spread } from 'lexical';
+import type { ManualLayout } from '../c4/types.js';
+export type SerializedC4Node = Spread<{
+    code: string;
+    manualLayout?: ManualLayout;
+}, SerializedLexicalNode>;
+export declare class C4Node extends DecoratorNode<JSX.Element> {
+    __code: string;
+    __manualLayout: ManualLayout | undefined;
+    static getType(): string;
+    static clone(node: C4Node): C4Node;
+    constructor(code: string, manualLayout?: ManualLayout, key?: NodeKey);
+    static importJSON(serializedNode: SerializedC4Node): C4Node;
+    exportJSON(): SerializedC4Node;
+    createDOM(): HTMLElement;
+    exportDOM(): DOMExportOutput;
+    static importDOM(): DOMConversionMap | null;
+    updateDOM(): boolean;
+    isInline(): boolean;
+    getTextContent(): string;
+    getCode(): string;
+    setCode(code: string): void;
+    getManualLayout(): ManualLayout | undefined;
+    setManualLayout(layout: ManualLayout | undefined): void;
+    decorate(): JSX.Element;
+}
+export declare function $createC4Node(code?: string, manualLayout?: ManualLayout): C4Node;
+export declare function $isC4Node(node: LexicalNode | null | undefined): node is C4Node;

package/dist/app/editor/nodes/C4Node.js

@@ -0,0 +1,112 @@
+/* eslint-disable react-refresh/only-export-components */
+/**
+ * C4Node - Renders C4 architecture diagrams
+ * Uses DecoratorNode pattern similar to MermaidNode
+ */
+import { DecoratorNode, $applyNodeReplacement, } from 'lexical';
+import { createElement, lazy, Suspense } from 'react';
+const C4Component = lazy(() => import('./C4Component.js'));
+function $convertC4Element(domNode) {
+    const code = domNode.getAttribute('data-lexical-c4');
+    if (code) {
+        // Decode from base64
+        const decodedCode = atob(code);
+        const node = $createC4Node(decodedCode);
+        return { node };
+    }
+    return null;
+}
+export class C4Node extends DecoratorNode {
+    __code;
+    __manualLayout;
+    static getType() {
+        return 'c4';
+    }
+    static clone(node) {
+        const layout = node.__manualLayout
+            ? { positions: { ...node.__manualLayout.positions } }
+            : undefined;
+        return new C4Node(node.__code, layout, node.__key);
+    }
+    constructor(code, manualLayout, key) {
+        super(key);
+        this.__code = code;
+        this.__manualLayout = manualLayout;
+    }
+    static importJSON(serializedNode) {
+        return $createC4Node(serializedNode.code, serializedNode.manualLayout);
+    }
+    exportJSON() {
+        const json = {
+            type: 'c4',
+            version: 1,
+            code: this.getCode(),
+        };
+        if (this.__manualLayout) {
+            json.manualLayout = this.__manualLayout;
+        }
+        return json;
+    }
+    createDOM() {
+        const element = document.createElement('div');
+        element.className = 'editor-c4';
+        return element;
+    }
+    exportDOM() {
+        const element = document.createElement('div');
+        // Encode as base64 to avoid issues with special characters
+        element.setAttribute('data-lexical-c4', btoa(this.__code));
+        element.className = 'c4-export';
+        element.textContent = this.__code;
+        return { element };
+    }
+    static importDOM() {
+        return {
+            div: (domNode) => {
+                if (!domNode.hasAttribute('data-lexical-c4')) {
+                    return null;
+                }
+                return {
+                    conversion: $convertC4Element,
+                    priority: 2,
+                };
+            },
+        };
+    }
+    updateDOM() {
+        return false;
+    }
+    isInline() {
+        return false;
+    }
+    getTextContent() {
+        return this.__code;
+    }
+    getCode() {
+        return this.__code;
+    }
+    setCode(code) {
+        const writable = this.getWritable();
+        writable.__code = code;
+    }
+    getManualLayout() {
+        return this.__manualLayout;
+    }
+    setManualLayout(layout) {
+        const writable = this.getWritable();
+        writable.__manualLayout = layout;
+    }
+    decorate() {
+        return createElement(Suspense, { fallback: createElement('div', { className: 'c4-loading' }, 'Loading diagram...') }, createElement(C4Component, {
+            code: this.__code,
+            nodeKey: this.__key,
+        }));
+    }
+}
+export function $createC4Node(code = '', manualLayout) {
+    const c4Node = new C4Node(code, manualLayout);
+    return $applyNodeReplacement(c4Node);
+}
+export function $isC4Node(node) {
+    return node instanceof C4Node;
+}

package/dist/app/editor/nodes/CalloutNode.d.ts

@@ -0,0 +1,23 @@
+import { DOMConversionMap, DOMExportOutput, EditorConfig, ElementNode, LexicalNode, NodeKey, SerializedElementNode, Spread } from 'lexical';
+export type CalloutType = 'note' | 'tip' | 'warning' | 'important' | 'caution';
+export type SerializedCalloutNode = Spread<{
+    calloutType: CalloutType;
+}, SerializedElementNode>;
+export declare class CalloutNode extends ElementNode {
+    __calloutType: CalloutType;
+    static getType(): string;
+    static clone(node: CalloutNode): CalloutNode;
+    constructor(calloutType: CalloutType, key?: NodeKey);
+    getCalloutType(): CalloutType;
+    setCalloutType(calloutType: CalloutType): void;
+    createDOM(config: EditorConfig): HTMLElement;
+    updateDOM(prevNode: CalloutNode, dom: HTMLElement): boolean;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(): DOMExportOutput;
+    static importJSON(serializedNode: SerializedCalloutNode): CalloutNode;
+    exportJSON(): SerializedCalloutNode;
+    canBeEmpty(): boolean;
+    isShadowRoot(): boolean;
+}
+export declare function $createCalloutNode(calloutType: CalloutType, content?: string): CalloutNode;
+export declare function $isCalloutNode(node: LexicalNode | null | undefined): node is CalloutNode;

package/dist/app/editor/nodes/CalloutNode.js

@@ -0,0 +1,94 @@
+import { $createParagraphNode, $createTextNode, ElementNode, } from 'lexical';
+export class CalloutNode extends ElementNode {
+    __calloutType;
+    static getType() {
+        return 'callout';
+    }
+    static clone(node) {
+        return new CalloutNode(node.__calloutType, node.__key);
+    }
+    constructor(calloutType, key) {
+        super(key);
+        this.__calloutType = calloutType;
+    }
+    getCalloutType() {
+        return this.__calloutType;
+    }
+    setCalloutType(calloutType) {
+        const writable = this.getWritable();
+        writable.__calloutType = calloutType;
+    }
+    createDOM(config) {
+        void config;
+        const element = document.createElement('div');
+        element.className = `callout callout-${this.__calloutType}`;
+        element.setAttribute('data-callout-type', this.__calloutType);
+        return element;
+    }
+    updateDOM(prevNode, dom) {
+        if (prevNode.__calloutType !== this.__calloutType) {
+            dom.className = `callout callout-${this.__calloutType}`;
+            dom.setAttribute('data-callout-type', this.__calloutType);
+        }
+        return false;
+    }
+    static importDOM() {
+        return {
+            div: (domNode) => {
+                if (domNode.classList.contains('callout')) {
+                    return {
+                        conversion: convertCalloutElement,
+                        priority: 1,
+                    };
+                }
+                return null;
+            },
+        };
+    }
+    exportDOM() {
+        const element = document.createElement('div');
+        element.className = `callout callout-${this.__calloutType}`;
+        element.setAttribute('data-callout-type', this.__calloutType);
+        return { element };
+    }
+    static importJSON(serializedNode) {
+        void serializedNode;
+        const node = $createCalloutNode(serializedNode.calloutType);
+        return node;
+    }
+    exportJSON() {
+        return {
+            ...super.exportJSON(),
+            type: 'callout',
+            calloutType: this.__calloutType,
+            version: 1,
+        };
+    }
+    // Allow block-level content inside callouts
+    canBeEmpty() {
+        return false;
+    }
+    isShadowRoot() {
+        return true;
+    }
+}
+function convertCalloutElement(domNode) {
+    const calloutType = (domNode.getAttribute('data-callout-type') || 'note');
+    const node = $createCalloutNode(calloutType);
+    return { node };
+}
+export function $createCalloutNode(calloutType, content) {
+    const node = new CalloutNode(calloutType);
+    // If content is provided, create a paragraph with text inside
+    if (content !== undefined) {
+        const paragraph = $createParagraphNode();
+        if (content) {
+            paragraph.append($createTextNode(content));
+        }
+        node.append(paragraph);
+    }
+    return node;
+}
+export function $isCalloutNode(node) {
+    return node instanceof CalloutNode;
+}

package/dist/app/editor/nodes/CustomLinkNode.d.ts

@@ -0,0 +1,57 @@
+import { LinkNode, SerializedLinkNode } from '@lexical/link';
+import { DOMConversionMap, EditorConfig, LexicalNode } from 'lexical';
+export type SerializedCustomLinkNode = SerializedLinkNode & {
+    wikiAliasState?: 'empty';
+    wikiLinkOrigin?: true;
+};
+/**
+ * CustomLinkNode - Extends Lexical's LinkNode to prevent VS Code webview link interception
+ *
+ * The standard LinkNode renders `<a href="...">` which VS Code webviews intercept and
+ * open automatically on click. This custom node renders `<a data-href="...">` instead,
+ * allowing us to control navigation via JavaScript (Cmd+click to open).
+ */
+export declare class CustomLinkNode extends LinkNode {
+    /** @internal */
+    __wikiAliasState: 'empty' | null;
+    /**
+     * Whether this link was parsed from genuine `[[target]]` / `[[target|alias]]`
+     * wiki-link syntax, as opposed to a standard `[text](url)` link whose URL
+     * merely looks wiki-link-shaped. Export (`convertLinkNode` in
+     * `lexicalToMdast.ts`) always promotes a node with this flag set back to
+     * wiki-link syntax, regardless of `wikiLinkPromotionMode` — an opted-out
+     * host still must not corrupt a document's existing wiki-links (liminis#951).
+     * @internal
+     */
+    __wikiLinkOrigin: boolean;
+    constructor(url: string, attributes?: {
+        rel?: null | string;
+        target?: null | string;
+        title?: null | string;
+    }, key?: string);
+    static getType(): string;
+    static clone(node: CustomLinkNode): CustomLinkNode;
+    createDOM(config: EditorConfig): HTMLAnchorElement;
+    /**
+     * Check if this link is a wiki-link (internal markdown file)
+     */
+    isWikiLink(): boolean;
+    /**
+     * Check if this link is an external link (http/https/mailto)
+     */
+    isExternalLink(): boolean;
+    updateDOM(prevNode: CustomLinkNode, anchor: HTMLAnchorElement, config: EditorConfig): boolean;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serializedNode: SerializedCustomLinkNode): CustomLinkNode;
+    exportJSON(): SerializedCustomLinkNode;
+    setWikiAliasState(state: 'empty' | null): void;
+    getWikiAliasState(): 'empty' | null;
+    setWikiLinkOrigin(origin: boolean): void;
+    getWikiLinkOrigin(): boolean;
+}
+export declare function $createCustomLinkNode(url: string, attributes?: {
+    rel?: null | string;
+    target?: null | string;
+    title?: null | string;
+}): CustomLinkNode;
+export declare function $isCustomLinkNode(node: LexicalNode | null | undefined): node is CustomLinkNode;