@blocklet/editor-lite 2.6.0

package/lib/main/nodes/YouTubeNode.js

@@ -0,0 +1,94 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { BlockWithAlignableContents } from '@lexical/react/LexicalBlockWithAlignableContents';
+import { DecoratorBlockNode } from '@lexical/react/LexicalDecoratorBlockNode';
+function YouTubeComponent({ className, format, nodeKey, videoID }) {
+    return (_jsx(BlockWithAlignableContents, { className: className, format: format, nodeKey: nodeKey, children: _jsx("iframe", { 
+            // width="560"
+            // height="315"
+            src: `https://www.youtube.com/embed/${videoID}`, frameBorder: "0", allow: "accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture", allowFullScreen: true, title: "YouTube video", style: { width: '100%', maxWidth: '560px', aspectRatio: 16 / 9 } }) }));
+}
+function convertYoutubeElement(domNode) {
+    const videoID = domNode.getAttribute('data-lexical-youtube');
+    if (videoID) {
+        const node = $createYouTubeNode(videoID);
+        return { node };
+    }
+    return null;
+}
+export class YouTubeNode extends DecoratorBlockNode {
+    __id;
+    static getType() {
+        return 'youtube';
+    }
+    static clone(node) {
+        return new YouTubeNode(node.__id, node.__format, node.__key);
+    }
+    static importJSON(serializedNode) {
+        const node = $createYouTubeNode(serializedNode.videoID);
+        node.setFormat(serializedNode.format);
+        return node;
+    }
+    exportJSON() {
+        return {
+            ...super.exportJSON(),
+            type: 'youtube',
+            version: 1,
+            videoID: this.__id,
+        };
+    }
+    constructor(id, format, key) {
+        super(format, key);
+        this.__id = id;
+    }
+    exportDOM() {
+        const element = document.createElement('iframe');
+        element.setAttribute('data-lexical-youtube', this.__id);
+        element.setAttribute('width', '560');
+        element.setAttribute('height', '315');
+        element.setAttribute('src', `https://www.youtube.com/embed/${this.__id}`);
+        element.setAttribute('frameborder', '0');
+        element.setAttribute('allow', 'accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture');
+        element.setAttribute('allowfullscreen', 'true');
+        element.setAttribute('title', 'YouTube video');
+        return { element };
+    }
+    static importDOM() {
+        return {
+            iframe: (domNode) => {
+                if (!domNode.hasAttribute('data-lexical-youtube')) {
+                    return null;
+                }
+                return {
+                    conversion: convertYoutubeElement,
+                    priority: 1,
+                };
+            },
+        };
+    }
+    updateDOM() {
+        return false;
+    }
+    getId() {
+        return this.__id;
+    }
+    getTextContent(_includeInert, _includeDirectionless) {
+        return `https://www.youtube.com/watch?v=${this.__id}`;
+    }
+    decorate(_editor, config) {
+        const embedBlockTheme = config.theme.embedBlock || {};
+        const className = {
+            base: embedBlockTheme.base || '',
+            focus: embedBlockTheme.focus || '',
+        };
+        return (_jsx(YouTubeComponent, { className: className, format: this.__format, nodeKey: this.getKey(), videoID: this.__id }));
+    }
+    isInline() {
+        return false;
+    }
+}
+export function $createYouTubeNode(videoID) {
+    return new YouTubeNode(videoID);
+}
+export function $isYouTubeNode(node) {
+    return node instanceof YouTubeNode;
+}

package/lib/main/plugins/AutoEmbedPlugin/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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.
+ *
+ */
+import { EmbedConfig } from '@lexical/react/LexicalAutoEmbedPlugin';
+import { type JSX } from 'react';
+export interface PlaygroundEmbedConfig extends EmbedConfig {
+    contentName: string;
+    icon?: JSX.Element;
+    exampleUrl: string;
+    keywords: Array<string>;
+    description?: string;
+    skipDefaultEmbedOption?: boolean;
+}
+export declare const YoutubeEmbedConfig: PlaygroundEmbedConfig;
+export declare const TwitterEmbedConfig: PlaygroundEmbedConfig;
+export declare const FigmaEmbedConfig: PlaygroundEmbedConfig;
+export declare const GithubConfig: PlaygroundEmbedConfig;
+export declare const EmbedConfigs: PlaygroundEmbedConfig[];
+export declare function AutoEmbedDialog({ embedConfig, onClose, }: {
+    embedConfig: PlaygroundEmbedConfig;
+    onClose: () => void;
+}): JSX.Element;
+export default function AutoEmbedPlugin(): JSX.Element;

package/lib/main/plugins/AutoEmbedPlugin/index.js

@@ -0,0 +1,353 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * 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.
+ *
+ */
+import { $getSelection, $isRangeSelection, $createTextNode, COMMAND_PRIORITY_EDITOR, KEY_DOWN_COMMAND, } from 'lexical';
+import { AutoEmbedOption, URL_MATCHER, LexicalAutoEmbedPlugin, } from '@lexical/react/LexicalAutoEmbedPlugin';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { useMemo, useState, useEffect, useRef } from 'react';
+import { $getNearestNodeOfType } from '@lexical/utils';
+import { LinkNode, $createLinkNode } from '@lexical/link';
+import compact from 'lodash/compact';
+import { Box } from '@mui/material';
+import useModal from '../../hooks/useModal';
+import Button from '../../ui/Button';
+import { DialogActions } from '../../ui/Dialog';
+import { INSERT_FIGMA_COMMAND } from '../FigmaPlugin';
+import { INSERT_TWEET_COMMAND } from '../TwitterPlugin';
+import { INSERT_YOUTUBE_COMMAND } from '../YouTubePlugin';
+import { createBlockletEmbedOption } from '../../../ext/BlockletEmbedPlugin';
+import { createBookmarkOption } from '../../../ext/BookmarkPlugin';
+import { get as getFromUrlParseCache, wrap } from './urlParseCache';
+import { BilibiliEmbedConfig } from '../../../ext/BilibiliPlugin/config';
+import { createPostLinkAutoEmbedOption } from '../../../ext/PostLinkEmbedPlugin';
+import { $createGithubNode } from '../../../ext/nodes/GithubNode';
+import { $createEmojiNode } from '../../nodes/EmojiNode';
+import { useEditorConfig } from '../../../config';
+import { fetchOpenGraphInfo } from '../../../ext/utils';
+import createPortal from '../../../components/createPortal';
+import { icons } from '../../icons';
+export const YoutubeEmbedConfig = {
+    contentName: 'Youtube Video',
+    exampleUrl: 'https://www.youtube.com/watch?v=jNQXAC9IVRw',
+    // Icon for display.
+    icon: _jsx("i", { className: "iconify", "data-icon": "mdi:youtube" }),
+    insertNode: (editor, result) => {
+        editor.dispatchCommand(INSERT_YOUTUBE_COMMAND, result.id);
+    },
+    keywords: ['youtube', 'video'],
+    // Determine if a given URL is a match and return url data.
+    parseUrl: wrap((url) => {
+        const match = /^.*(youtu\.be\/|v\/|u\/\w\/|embed\/|watch\?v=|&v=)([^#&?]*).*/.exec(url);
+        const id = match ? (match?.[2].length === 11 ? match[2] : null) : null;
+        if (id != null) {
+            return {
+                id,
+                url,
+            };
+        }
+        return null;
+    }, 'youtube-video'),
+    type: 'youtube-video',
+};
+export const TwitterEmbedConfig = {
+    // e.g. Tweet or Google Map.
+    contentName: 'X',
+    exampleUrl: 'https://twitter.com/jack/status/20',
+    // Icon for display.
+    icon: _jsx("i", { className: "iconify", "data-icon": icons.brandX }),
+    // Create the Lexical embed node from the url data.
+    insertNode: (editor, result) => {
+        editor.dispatchCommand(INSERT_TWEET_COMMAND, result.id);
+    },
+    // For extra searching.
+    keywords: ['tweet', 'twitter'],
+    // Determine if a given URL is a match and return url data.
+    parseUrl: wrap((text) => {
+        const match = /^https:\/\/(?:twitter|x)\.com\/(#!\/)?(\w+)\/status(es)*\/(\d+)/.exec(text);
+        if (match != null) {
+            return {
+                id: match[4],
+                url: match[0],
+            };
+        }
+        return null;
+    }, 'tweet'),
+    type: 'tweet',
+};
+export const FigmaEmbedConfig = {
+    contentName: 'Figma',
+    exampleUrl: 'https://www.figma.com/file/LKQ4FJ4bTnCSjedbRpk931/Sample-File',
+    icon: _jsx("i", { className: "iconify", "data-icon": icons.brandFigma }),
+    insertNode: (editor, result) => {
+        editor.dispatchCommand(INSERT_FIGMA_COMMAND, result.id);
+    },
+    keywords: ['figma', 'figma.com', 'mock-up'],
+    // Determine if a given URL is a match and return url data.
+    parseUrl: wrap((text) => {
+        const match = /https:\/\/([\w.-]+\.)?figma.com\/(file|proto)\/([0-9a-zA-Z]{22,128})(?:\/.*)?$/.exec(text);
+        if (match != null) {
+            return {
+                id: match[3],
+                url: match[0],
+            };
+        }
+        return null;
+    }, 'figma'),
+    type: 'figma',
+};
+export const GithubConfig = {
+    contentName: 'GitHub',
+    exampleUrl: 'https://github.com/blocklet/discuss-kit/pull/722',
+    // Icon for display.
+    icon: _jsx("i", { className: "iconify", "data-icon": "tabler:brand-github" }),
+    // Create the Lexical embed node from the url data.
+    insertNode: (editor, result) => { },
+    // For extra searching.
+    keywords: ['github'],
+    // Determine if a given URL is a match and return url data.
+    parseUrl: wrap((text) => {
+        const GITHUB = 'github.com';
+        try {
+            const { origin, pathname } = new URL(text);
+            if (origin.includes(GITHUB)) {
+                const [, , , id] = pathname.split('/').filter(Boolean);
+                return { id, url: text };
+            }
+            return null;
+        }
+        catch (error) {
+            return null;
+        }
+    }, 'github'),
+    skipDefaultEmbedOption: true,
+    type: 'github',
+};
+const LinkFallbackConfig = {
+    contentName: '',
+    exampleUrl: '',
+    insertNode: (editor, result) => { },
+    keywords: [],
+    parseUrl: async (text) => {
+        const prevs = await Promise.all(['github', 'youtube-video', 'tweet', 'figma', 'bilibili-video'].map((type) => getFromUrlParseCache(text, type)));
+        if (prevs.some((v) => v)) {
+            return null;
+        }
+        return { id: text, url: text };
+    },
+    skipDefaultEmbedOption: true,
+    type: 'link-fallback',
+};
+export const EmbedConfigs = [
+    TwitterEmbedConfig,
+    YoutubeEmbedConfig,
+    FigmaEmbedConfig,
+    BilibiliEmbedConfig,
+    GithubConfig,
+    LinkFallbackConfig,
+];
+function AutoEmbedMenuItem({ index, isSelected, onClick, onMouseEnter, option, }) {
+    let className = 'item';
+    if (isSelected) {
+        className += ' selected';
+    }
+    // @ts-ignore
+    if (option.disabled) {
+        className += ' embed-option-disabled';
+    }
+    const handleClick = () => {
+        // @ts-ignore
+        if (!option.disabled) {
+            onClick();
+        }
+    };
+    return (_jsx("li", { tabIndex: -1, className: className, ref: option.setRefElement, role: "option", "aria-selected": isSelected, id: `typeahead-item-${index}`, onMouseEnter: onMouseEnter, onClick: handleClick, children: _jsx("span", { className: "text", children: option.title }) }, option.key));
+}
+function AutoEmbedMenu({ options, selectedItemIndex, onOptionClick, onOptionMouseEnter, }) {
+    return (_jsx("div", { className: "typeahead-popover", children: _jsx("ul", { children: options.map((option, i) => (_jsx(AutoEmbedMenuItem, { index: i, isSelected: selectedItemIndex === i, onClick: () => onOptionClick(option, i), onMouseEnter: () => onOptionMouseEnter(i), option: option }, option.key))) }) }));
+}
+const debounce = (callback, delay) => {
+    let timeoutId;
+    return (text) => {
+        window.clearTimeout(timeoutId);
+        timeoutId = window.setTimeout(() => {
+            callback(text);
+        }, delay);
+    };
+};
+export function AutoEmbedDialog({ embedConfig, onClose, }) {
+    const [text, setText] = useState('');
+    const [editor] = useLexicalComposerContext();
+    const [embedResult, setEmbedResult] = useState(null);
+    const validateText = useMemo(() => debounce((inputText) => {
+        const urlMatch = URL_MATCHER.exec(inputText);
+        if (embedConfig != null && inputText != null && urlMatch != null) {
+            Promise.resolve(embedConfig.parseUrl(inputText)).then((parseResult) => {
+                setEmbedResult(parseResult);
+            });
+        }
+        else if (embedResult != null) {
+            setEmbedResult(null);
+        }
+    }, 200), [embedConfig, embedResult]);
+    const onClick = () => {
+        if (embedResult != null) {
+            embedConfig.insertNode(editor, embedResult);
+            onClose();
+        }
+    };
+    return (_jsxs(Box, { sx: { width: { xs: 300, sm: 400, md: 600 } }, children: [_jsx("div", { className: "Input__wrapper", children: _jsx("input", { type: "text", className: "Input__input", placeholder: embedConfig.exampleUrl, value: text, "data-test-id": `${embedConfig.type}-embed-modal-url`, onChange: (e) => {
+                        const { value } = e.target;
+                        setText(value);
+                        validateText(value);
+                    } }) }), _jsx(DialogActions, { children: _jsx(Button, { disabled: !embedResult, onClick: onClick, "data-test-id": `${embedConfig.type}-embed-modal-submit-btn`, children: "Embed" }) })] }));
+}
+export default function AutoEmbedPlugin() {
+    const [editor] = useLexicalComposerContext();
+    const [modal, showModal] = useModal();
+    const editorConfig = useEditorConfig();
+    const dismissFnRef = useRef(null);
+    const openEmbedModal = (embedConfig) => {
+        showModal(`Embed ${embedConfig.contentName}`, (onClose) => (_jsx(AutoEmbedDialog, { embedConfig: embedConfig, onClose: onClose })));
+    };
+    // Dismiss the menu when moving the cursor
+    // (https://community.arcblock.io/discussions/29f1b7a4-2af6-407f-8653-1267067d8899)
+    useEffect(() => {
+        return editor.registerUpdateListener(() => {
+            dismissFnRef.current?.();
+        });
+    }, [editor]);
+    const getMenuOptions = (activeEmbedConfig, embedFn, dismissFn) => {
+        dismissFnRef.current = dismissFn;
+        return compact([
+            new AutoEmbedOption('Dismiss', {
+                onSelect: dismissFn,
+            }),
+            ...(activeEmbedConfig.skipDefaultEmbedOption !== true
+                ? [
+                    new AutoEmbedOption(`Embed ${activeEmbedConfig.contentName}`, {
+                        onSelect: embedFn,
+                    }),
+                ]
+                : []),
+            createPostLinkAutoEmbedOption(editor, editorConfig),
+            createBlockletEmbedOption(editor, editorConfig),
+            createBookmarkOption(editor, editorConfig),
+            ...(editorConfig.openGraphEndpoint
+                ? [
+                    activeEmbedConfig.type === 'github'
+                        ? new AutoEmbedOption('Create mention', {
+                            onSelect: () => {
+                                editor.update(async () => {
+                                    const selection = $getSelection();
+                                    if ($isRangeSelection(selection)) {
+                                        const anchorNode = selection.anchor.getNode();
+                                        const anchorTopLevelElement = anchorNode.getTopLevelElementOrThrow();
+                                        const linkNode = $getNearestNodeOfType(anchorNode, LinkNode);
+                                        const linkUrl = anchorNode.getTextContent();
+                                        const reg = /^https?:\/\/github.com\//;
+                                        if (linkUrl && reg.test(linkUrl)) {
+                                            anchorNode.replace($createEmojiNode('global-loading', ''));
+                                            if (linkNode) {
+                                                linkNode.append($createEmojiNode('empty-text', ' '));
+                                                linkNode.selectEnd();
+                                            }
+                                            anchorTopLevelElement.selectEnd();
+                                            const openGraphInfo = await fetchOpenGraphInfo(editorConfig.openGraphEndpoint, linkUrl);
+                                            if (openGraphInfo) {
+                                                editor.update(() => {
+                                                    anchorTopLevelElement.selectEnd();
+                                                    let link = null;
+                                                    if (openGraphInfo.url) {
+                                                        link = $createGithubNode({
+                                                            title: openGraphInfo.title,
+                                                            image: openGraphInfo.image || '',
+                                                            link: linkUrl || '',
+                                                        });
+                                                    }
+                                                    else {
+                                                        link = $createLinkNode(linkUrl).append($createTextNode(linkUrl));
+                                                    }
+                                                    if (linkNode) {
+                                                        linkNode.replace(link);
+                                                    }
+                                                    const linkParent = link.getParent();
+                                                    linkParent?.append($createTextNode(' '));
+                                                    linkParent?.selectEnd();
+                                                });
+                                            }
+                                            else {
+                                                editor.update(() => {
+                                                    anchorTopLevelElement.selectEnd();
+                                                    let link = null;
+                                                    link = $createLinkNode(linkUrl).append($createTextNode(linkUrl));
+                                                    if (linkNode) {
+                                                        linkNode.replace(link);
+                                                    }
+                                                    const linkParent = link.getParent();
+                                                    linkParent?.append($createTextNode(' '));
+                                                    linkParent?.selectEnd();
+                                                });
+                                            }
+                                        }
+                                    }
+                                });
+                            },
+                        })
+                        : null,
+                ]
+                : []),
+        ]);
+    };
+    // shortcut: ctrl+z
+    useEffect(() => {
+        let timer = null;
+        return editor.registerCommand(KEY_DOWN_COMMAND, (e) => {
+            if ((e.metaKey || e.ctrlKey) && e.key === 'z') {
+                timer = setTimeout(() => {
+                    const loading = document.querySelector('.global-loading');
+                    if (loading) {
+                        editor.update(() => {
+                            const selection = $getSelection();
+                            if ($isRangeSelection(selection)) {
+                                const anchorNode = selection.anchor.getNode();
+                                const linkNode = $getNearestNodeOfType(anchorNode, LinkNode);
+                                linkNode?.remove();
+                            }
+                        });
+                    }
+                    clearTimeout(timer);
+                }, 0);
+                return false;
+            }
+            return false;
+        }, COMMAND_PRIORITY_EDITOR);
+    }, [editor]);
+    return (_jsxs(_Fragment, { children: [modal, _jsx(LexicalAutoEmbedPlugin, { embedConfigs: EmbedConfigs, onOpenEmbedModalForConfig: openEmbedModal, getMenuOptions: getMenuOptions, menuRenderFn: (anchorElementRef, { selectedIndex, options, selectOptionAndCleanUp, setHighlightedIndex }) => {
+                    return anchorElementRef.current
+                        ? createPortal(_jsx(Box, { className: "typeahead-popover auto-embed-menu", sx: {
+                                marginLeft: `${Math.max(parseFloat(anchorElementRef.current.style.width) - 200, 0)}px`,
+                                width: 200,
+                                border: 1,
+                                borderColor: 'divider',
+                                color: 'text.primary',
+                                bgcolor: 'background.default',
+                                'li.selected': {
+                                    bgcolor: 'action.selected',
+                                },
+                                'li:hover': {
+                                    bgcolor: 'action.hover',
+                                },
+                            }, children: _jsx(AutoEmbedMenu, { options: options, selectedItemIndex: selectedIndex, onOptionClick: (option, index) => {
+                                    setHighlightedIndex(index);
+                                    selectOptionAndCleanUp(option);
+                                }, onOptionMouseEnter: (index) => {
+                                    setHighlightedIndex(index);
+                                } }) }), anchorElementRef.current)
+                        : null;
+                } })] }));
+}

package/lib/main/plugins/AutoEmbedPlugin/urlParseCache.d.ts

@@ -0,0 +1,2 @@
+export declare const get: (url: string, type: string) => import("@lexical/react/LexicalAutoEmbedPlugin").EmbedMatchResult<unknown> | Promise<import("@lexical/react/LexicalAutoEmbedPlugin").EmbedMatchResult<unknown> | null> | null;
+export declare const wrap: <T extends (text: string) => import("@lexical/react/LexicalAutoEmbedPlugin").EmbedMatchResult<unknown> | Promise<import("@lexical/react/LexicalAutoEmbedPlugin").EmbedMatchResult<unknown> | null> | null>(parseUrl: T, type: string) => (url: string) => import("@lexical/react/LexicalAutoEmbedPlugin").EmbedMatchResult<unknown> | Promise<import("@lexical/react/LexicalAutoEmbedPlugin").EmbedMatchResult<unknown> | null> | null;

package/lib/main/plugins/AutoEmbedPlugin/urlParseCache.js

@@ -0,0 +1,14 @@
+const cache = {};
+const getKey = (url, type) => `${url}_${type}`;
+export const get = (url, type) => {
+    return cache[getKey(url, type)];
+};
+export const wrap = (parseUrl, type) => {
+    return (url) => {
+        const key = getKey(url, type);
+        if (!cache[key]) {
+            cache[key] = parseUrl(url);
+        }
+        return cache[key];
+    };
+};

package/lib/main/plugins/AutoLinkPlugin/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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.
+ *
+ */
+import type { JSX } from 'react';
+export default function LexicalAutoLinkPlugin(): JSX.Element;

package/lib/main/plugins/AutoLinkPlugin/index.js

@@ -0,0 +1,39 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * 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.
+ *
+ */
+import { AutoLinkPlugin } from '@lexical/react/LexicalAutoLinkPlugin';
+// `\u00A0-\uD7FF\uE000-\uFFFD`: 支持常用字符集 (#1423)
+const URL_MATCHER = /((https?:\/\/(www\.)?)|(www\.))[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,63}\b([-a-zA-Z0-9\u00A0-\uD7FF\uE000-\uFFFD()@:%_+.~#?&//=]*)/;
+const EMAIL_MATCHER = /(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))/;
+const MATCHERS = [
+    (text) => {
+        const match = URL_MATCHER.exec(text);
+        if (match === null) {
+            return null;
+        }
+        const fullMatch = match[0];
+        return {
+            index: match.index,
+            length: fullMatch.length,
+            text: fullMatch,
+            url: fullMatch.startsWith('http') ? fullMatch : `https://${fullMatch}`,
+        };
+    },
+    (text) => {
+        const match = EMAIL_MATCHER.exec(text);
+        return (match && {
+            index: match.index,
+            length: match[0].length,
+            text: match[0],
+            url: `mailto:${match[0]}`,
+        });
+    },
+];
+export default function LexicalAutoLinkPlugin() {
+    return _jsx(AutoLinkPlugin, { matchers: MATCHERS });
+}

package/lib/main/plugins/ClickableLinkPlugin/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 代码复制自 @lexical/react/LexicalClickableLinkPlugin, 逻辑改动:
+ * - url origin 与 window.location.origin 相同时, 避免 newTab 方式跳转
+ * - 编辑模式下, 避免当前页面直接跳转 (#1575)
+ */
+export default function LexicalClickableLinkPlugin({ newTab }: {
+    newTab?: boolean;
+}): null;