@scottjgilbert/lexical-blog-editor 0.1.4 → 1.0.0-beta.2

package/build/nodes/CodeNode/CodeNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CodeNode.d.ts","sourceRoot":"","sources":["../../../src/nodes/CodeNode/CodeNode.tsx"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,KAAK,EACV,gBAAgB,EAEhB,eAAe,EACf,YAAY,EACZ,aAAa,EACb,WAAW,EACX,iBAAiB,EACjB,OAAO,EACP,aAAa,EACb,cAAc,EACd,qBAAqB,EACrB,MAAM,EACN,OAAO,EACR,MAAM,SAAS,CAAC;AAGjB,OAAO,EAOL,WAAW,EACZ,MAAM,SAAS,CAAC;AAQjB,MAAM,MAAM,kBAAkB,GAAG,MAAM,CACrC;IACE,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACpC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC5B,EACD,qBAAqB,CACtB,CAAC;AAEF,eAAO,MAAM,qBAAqB,eAAe,CAAC;AAClD,eAAO,MAAM,sBAAsB,QAAO,MAA+B,CAAC;AAgB1E,oBAAoB;AACpB,qBAAa,QAAS,SAAQ,WAAW;IACvC,gBAAgB;IAChB,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACtC,gBAAgB;IAChB,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,gBAAgB;IAChB,4BAA4B,EAAE,OAAO,CAAC;IAEtC,MAAM,CAAC,OAAO,IAAI,MAAM;IAIxB,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,QAAQ,GAAG,QAAQ;gBAI1B,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAAE,GAAG,CAAC,EAAE,OAAO;IAO/D,cAAc,CAAC,QAAQ,EAAE,IAAI,GAAG,IAAI;IAQpC,SAAS,CAAC,MAAM,EAAE,YAAY,GAAG,WAAW;IAuB5C,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,GAAG,OAAO;IAoD1E,SAAS,CAAC,MAAM,EAAE,aAAa,GAAG,eAAe;IAyBjD,MAAM,CAAC,SAAS,IAAI,gBAAgB,GAAG,IAAI;IAmE3C,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,kBAAkB,GAAG,QAAQ;IAI/D,cAAc,CAAC,cAAc,EAAE,iBAAiB,CAAC,kBAAkB,CAAC,GAAG,IAAI;IAO3E,UAAU,IAAI,kBAAkB;IAShC,cAAc,CACZ,SAAS,EAAE,cAAc,EACzB,gBAAgB,UAAO,GACtB,IAAI,GAAG,aAAa,GAAG,iBAAiB,GAAG,OAAO;IA4ErD,SAAS,IAAI,KAAK;IAIlB,eAAe,IAAI,OAAO;IAQ1B,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI;IAMtD,WAAW,IAAI,MAAM,GAAG,IAAI,GAAG,SAAS;IAIxC,6BAA6B,CAAC,WAAW,EAAE,OAAO,GAAG,IAAI;IAMzD,6BAA6B,IAAI,OAAO;IAIxC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI;IAMhD,QAAQ,IAAI,MAAM,GAAG,SAAS;CAG/B;AAED,wBAAgB,eAAe,CAC7B,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACpC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAChC,QAAQ,CAEV;AAED,wBAAgB,WAAW,CACzB,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GACnC,IAAI,IAAI,QAAQ,CAElB"}

package/build/nodes/CodeNode/CodeNode.js

@@ -0,0 +1,367 @@
+/**
+ * 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 { addClassNamesToElement, isHTMLElement } from "@lexical/utils";
+import { $create, $createLineBreakNode, $createParagraphNode, $createTabNode, $isTabNode, $isTextNode, ElementNode, } from "lexical";
+import { $createCodeHighlightNode, $isCodeHighlightNode, } from "./CodeHighlightNode";
+import { $getFirstCodeNodeOfLine } from "./FlatStructureUtils";
+export const DEFAULT_CODE_LANGUAGE = "javascript";
+export const getDefaultCodeLanguage = () => DEFAULT_CODE_LANGUAGE;
+function hasChildDOMNodeTag(node, tagName) {
+    for (const child of node.childNodes) {
+        if (isHTMLElement(child) && child.tagName === tagName) {
+            return true;
+        }
+        hasChildDOMNodeTag(child, tagName);
+    }
+    return false;
+}
+const LANGUAGE_DATA_ATTRIBUTE = "data-language";
+const HIGHLIGHT_LANGUAGE_DATA_ATTRIBUTE = "data-highlight-language";
+const THEME_DATA_ATTRIBUTE = "data-theme";
+/** @noInheritDoc */
+export class CodeNode extends ElementNode {
+    static getType() {
+        return "code";
+    }
+    static clone(node) {
+        return new CodeNode(node.__language, node.__key);
+    }
+    constructor(language, key) {
+        super(key);
+        this.__language = language || undefined;
+        this.__isSyntaxHighlightSupported = false;
+        this.__theme = undefined;
+    }
+    afterCloneFrom(prevNode) {
+        super.afterCloneFrom(prevNode);
+        this.__language = prevNode.__language;
+        this.__theme = prevNode.__theme;
+        this.__isSyntaxHighlightSupported = prevNode.__isSyntaxHighlightSupported;
+    }
+    // View
+    createDOM(config) {
+        const element = document.createElement("code");
+        addClassNamesToElement(element, config.theme.code);
+        element.setAttribute("spellcheck", "false");
+        const language = this.getLanguage();
+        if (language) {
+            element.setAttribute(LANGUAGE_DATA_ATTRIBUTE, language);
+            if (this.getIsSyntaxHighlightSupported()) {
+                element.setAttribute(HIGHLIGHT_LANGUAGE_DATA_ATTRIBUTE, language);
+            }
+        }
+        const theme = this.getTheme();
+        if (theme) {
+            element.setAttribute(THEME_DATA_ATTRIBUTE, theme);
+        }
+        const style = this.getStyle();
+        if (style) {
+            element.setAttribute("style", style);
+        }
+        return element;
+    }
+    updateDOM(prevNode, dom, config) {
+        const language = this.__language;
+        const prevLanguage = prevNode.__language;
+        if (language) {
+            if (language !== prevLanguage) {
+                dom.setAttribute(LANGUAGE_DATA_ATTRIBUTE, language);
+            }
+        }
+        else if (prevLanguage) {
+            dom.removeAttribute(LANGUAGE_DATA_ATTRIBUTE);
+        }
+        const isSyntaxHighlightSupported = this.__isSyntaxHighlightSupported;
+        const prevIsSyntaxHighlightSupported = prevNode.__isSyntaxHighlightSupported;
+        if (prevIsSyntaxHighlightSupported && prevLanguage) {
+            if (isSyntaxHighlightSupported && language) {
+                if (language !== prevLanguage) {
+                    dom.setAttribute(HIGHLIGHT_LANGUAGE_DATA_ATTRIBUTE, language);
+                }
+            }
+            else {
+                dom.removeAttribute(HIGHLIGHT_LANGUAGE_DATA_ATTRIBUTE);
+            }
+        }
+        else if (isSyntaxHighlightSupported && language) {
+            dom.setAttribute(HIGHLIGHT_LANGUAGE_DATA_ATTRIBUTE, language);
+        }
+        const theme = this.__theme;
+        const prevTheme = prevNode.__theme;
+        if (theme) {
+            if (theme !== prevTheme) {
+                dom.setAttribute(THEME_DATA_ATTRIBUTE, theme);
+            }
+        }
+        else if (prevTheme) {
+            dom.removeAttribute(THEME_DATA_ATTRIBUTE);
+        }
+        const style = this.__style;
+        const prevStyle = prevNode.__style;
+        if (style) {
+            if (style !== prevStyle) {
+                dom.setAttribute("style", style);
+            }
+        }
+        else if (prevStyle) {
+            dom.removeAttribute("style");
+        }
+        return false;
+    }
+    exportDOM(editor) {
+        const element = document.createElement("pre");
+        addClassNamesToElement(element, editor._config.theme.code);
+        element.setAttribute("spellcheck", "false");
+        const language = this.getLanguage();
+        if (language) {
+            element.setAttribute(LANGUAGE_DATA_ATTRIBUTE, language);
+            if (this.getIsSyntaxHighlightSupported()) {
+                element.setAttribute(HIGHLIGHT_LANGUAGE_DATA_ATTRIBUTE, language);
+            }
+        }
+        const theme = this.getTheme();
+        if (theme) {
+            element.setAttribute(THEME_DATA_ATTRIBUTE, theme);
+        }
+        const style = this.getStyle();
+        if (style) {
+            element.setAttribute("style", style);
+        }
+        return { element };
+    }
+    static importDOM() {
+        return {
+            // Typically <pre> is used for code blocks, and <code> for inline code styles
+            // but if it's a multi line <code> we'll create a block. Pass through to
+            // inline format handled by TextNode otherwise.
+            code: (node) => {
+                const isMultiLine = node.textContent != null &&
+                    (/\r?\n/.test(node.textContent) || hasChildDOMNodeTag(node, "BR"));
+                return isMultiLine
+                    ? {
+                        conversion: $convertPreElement,
+                        priority: 1,
+                    }
+                    : null;
+            },
+            div: () => ({
+                conversion: $convertDivElement,
+                priority: 1,
+            }),
+            pre: () => ({
+                conversion: $convertPreElement,
+                priority: 0,
+            }),
+            table: (node) => {
+                const table = node;
+                // domNode is a <table> since we matched it by nodeName
+                if (isGitHubCodeTable(table)) {
+                    return {
+                        conversion: $convertTableElement,
+                        priority: 3,
+                    };
+                }
+                return null;
+            },
+            td: (node) => {
+                // element is a <td> since we matched it by nodeName
+                const td = node;
+                const table = td.closest("table");
+                if (isGitHubCodeCell(td) || (table && isGitHubCodeTable(table))) {
+                    // Return a no-op if it's a table cell in a code table, but not a code line.
+                    // Otherwise it'll fall back to the T
+                    return {
+                        conversion: convertCodeNoop,
+                        priority: 3,
+                    };
+                }
+                return null;
+            },
+            tr: (node) => {
+                // element is a <tr> since we matched it by nodeName
+                const tr = node;
+                const table = tr.closest("table");
+                if (table && isGitHubCodeTable(table)) {
+                    return {
+                        conversion: convertCodeNoop,
+                        priority: 3,
+                    };
+                }
+                return null;
+            },
+        };
+    }
+    static importJSON(serializedNode) {
+        return $createCodeNode().updateFromJSON(serializedNode);
+    }
+    updateFromJSON(serializedNode) {
+        return super
+            .updateFromJSON(serializedNode)
+            .setLanguage(serializedNode.language)
+            .setTheme(serializedNode.theme);
+    }
+    exportJSON() {
+        return Object.assign(Object.assign({}, super.exportJSON()), { language: this.getLanguage(), theme: this.getTheme() });
+    }
+    // Mutation
+    insertNewAfter(selection, restoreSelection = true) {
+        const children = this.getChildren();
+        const childrenLength = children.length;
+        if (childrenLength >= 2 &&
+            children[childrenLength - 1].getTextContent() === "\n" &&
+            children[childrenLength - 2].getTextContent() === "\n" &&
+            selection.isCollapsed() &&
+            selection.anchor.key === this.__key &&
+            selection.anchor.offset === childrenLength) {
+            children[childrenLength - 1].remove();
+            children[childrenLength - 2].remove();
+            const newElement = $createParagraphNode();
+            this.insertAfter(newElement, restoreSelection);
+            return newElement;
+        }
+        // If the selection is within the codeblock, find all leading tabs and
+        // spaces of the current line. Create a new line that has all those
+        // tabs and spaces, such that leading indentation is preserved.
+        const { anchor, focus } = selection;
+        const firstPoint = anchor.isBefore(focus) ? anchor : focus;
+        const firstSelectionNode = firstPoint.getNode();
+        if ($isTextNode(firstSelectionNode)) {
+            let node = $getFirstCodeNodeOfLine(firstSelectionNode);
+            const insertNodes = [];
+            // eslint-disable-next-line no-constant-condition
+            while (true) {
+                if ($isTabNode(node)) {
+                    insertNodes.push($createTabNode());
+                    node = node.getNextSibling();
+                }
+                else if ($isCodeHighlightNode(node)) {
+                    let spaces = 0;
+                    const text = node.getTextContent();
+                    const textSize = node.getTextContentSize();
+                    while (spaces < textSize && text[spaces] === " ") {
+                        spaces++;
+                    }
+                    if (spaces !== 0) {
+                        insertNodes.push($createCodeHighlightNode(" ".repeat(spaces)));
+                    }
+                    if (spaces !== textSize) {
+                        break;
+                    }
+                    node = node.getNextSibling();
+                }
+                else {
+                    break;
+                }
+            }
+            const split = firstSelectionNode.splitText(anchor.offset)[0];
+            const x = anchor.offset === 0 ? 0 : 1;
+            const index = split.getIndexWithinParent() + x;
+            const codeNode = firstSelectionNode.getParentOrThrow();
+            const nodesToInsert = [$createLineBreakNode(), ...insertNodes];
+            codeNode.splice(index, 0, nodesToInsert);
+            const last = insertNodes[insertNodes.length - 1];
+            if (last) {
+                last.select();
+            }
+            else if (anchor.offset === 0) {
+                split.selectPrevious();
+            }
+            else {
+                split.getNextSibling().selectNext(0, 0);
+            }
+        }
+        if ($isCodeNode(firstSelectionNode)) {
+            const { offset } = selection.anchor;
+            firstSelectionNode.splice(offset, 0, [$createLineBreakNode()]);
+            firstSelectionNode.select(offset + 1, offset + 1);
+        }
+        return null;
+    }
+    canIndent() {
+        return false;
+    }
+    collapseAtStart() {
+        const paragraph = $createParagraphNode();
+        const children = this.getChildren();
+        children.forEach((child) => paragraph.append(child));
+        this.replace(paragraph);
+        return true;
+    }
+    setLanguage(language) {
+        const writable = this.getWritable();
+        writable.__language = language || undefined;
+        return writable;
+    }
+    getLanguage() {
+        return this.getLatest().__language;
+    }
+    setIsSyntaxHighlightSupported(isSupported) {
+        const writable = this.getWritable();
+        writable.__isSyntaxHighlightSupported = isSupported;
+        return writable;
+    }
+    getIsSyntaxHighlightSupported() {
+        return this.getLatest().__isSyntaxHighlightSupported;
+    }
+    setTheme(theme) {
+        const writable = this.getWritable();
+        writable.__theme = theme || undefined;
+        return writable;
+    }
+    getTheme() {
+        return this.getLatest().__theme;
+    }
+}
+export function $createCodeNode(language, theme) {
+    return $create(CodeNode).setLanguage(language).setTheme(theme);
+}
+export function $isCodeNode(node) {
+    return (node === null || node === void 0 ? void 0 : node.__type) == "code";
+}
+function $convertPreElement(domNode) {
+    const language = domNode.getAttribute(LANGUAGE_DATA_ATTRIBUTE);
+    return { node: $createCodeNode(language) };
+}
+function $convertDivElement(domNode) {
+    // domNode is a <div> since we matched it by nodeName
+    const div = domNode;
+    const isCode = isCodeElement(div);
+    if (!isCode && !isCodeChildElement(div)) {
+        return {
+            node: null,
+        };
+    }
+    return {
+        node: isCode ? $createCodeNode() : null,
+    };
+}
+function $convertTableElement() {
+    return { node: $createCodeNode() };
+}
+function convertCodeNoop() {
+    return { node: null };
+}
+function isCodeElement(div) {
+    return div.style.fontFamily.match("monospace") !== null;
+}
+function isCodeChildElement(node) {
+    let parent = node.parentElement;
+    while (parent !== null) {
+        if (isCodeElement(parent)) {
+            return true;
+        }
+        parent = parent.parentElement;
+    }
+    return false;
+}
+function isGitHubCodeCell(cell) {
+    return cell.classList.contains("js-file-line");
+}
+function isGitHubCodeTable(table) {
+    return table.classList.contains("js-file-line-container");
+}

package/build/nodes/CodeNode/FacadeShiki.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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 { CodeNode } from "./CodeNode";
+import type { LexicalEditor, LexicalNode, NodeKey } from "lexical";
+export declare function isCodeLanguageLoaded(language: string): boolean;
+export declare function loadCodeLanguage(language: string, editor?: LexicalEditor, codeNodeKey?: NodeKey): Promise<void> | undefined;
+export declare function isCodeThemeLoaded(theme: string): boolean;
+export declare function loadCodeTheme(theme: string, editor?: LexicalEditor, codeNodeKey?: NodeKey): Promise<void> | undefined;
+export declare function getCodeLanguageOptions(): [string, string][];
+export declare function getCodeThemeOptions(): [string, string][];
+export declare function normalizeCodeLanguage(language: string): string;
+export declare function $getHighlightNodes(codeNode: CodeNode, language: string): LexicalNode[];
+//# sourceMappingURL=FacadeShiki.d.ts.map

package/build/nodes/CodeNode/FacadeShiki.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FacadeShiki.d.ts","sourceRoot":"","sources":["../../../src/nodes/CodeNode/FacadeShiki.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AA4BnE,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,WAWpD;AAED,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,MAAM,EAChB,MAAM,CAAC,EAAE,aAAa,EACtB,WAAW,CAAC,EAAE,OAAO,6BA8BtB;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,WAS9C;AAED,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,aAAa,EACtB,WAAW,CAAC,EAAE,OAAO,6BAiBtB;AAED,wBAAgB,sBAAsB,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAE3D;AACD,wBAAgB,mBAAmB,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAExD;AAED,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAU9D;AAED,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,QAAQ,EAClB,QAAQ,EAAE,MAAM,GACf,WAAW,EAAE,CAoBf"}

package/build/nodes/CodeNode/FacadeShiki.js

@@ -0,0 +1,159 @@
+/**
+ * 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 { $isCodeNode } from "./CodeNode";
+import { $createCodeHighlightNode } from "./CodeHighlightNode";
+import { createHighlighterCoreSync, getTokenStyleObject, isSpecialLang, isSpecialTheme, stringifyTokenStyle, } from "@shikijs/core";
+import { createJavaScriptRegexEngine } from "@shikijs/engine-javascript";
+import { $createLineBreakNode, $createTabNode, $getNodeByKey } from "lexical";
+import { bundledLanguagesInfo } from "shiki/langs";
+import { bundledThemesInfo } from "shiki/themes";
+const shiki = createHighlighterCoreSync({
+    engine: createJavaScriptRegexEngine(),
+    langs: [],
+    themes: [],
+});
+function getDiffedLanguage(language) {
+    const DIFF_LANGUAGE_REGEX = /^diff-([\w-]+)/i;
+    const diffLanguageMatch = DIFF_LANGUAGE_REGEX.exec(language);
+    return diffLanguageMatch ? diffLanguageMatch[1] : null;
+}
+export function isCodeLanguageLoaded(language) {
+    const diffedLanguage = getDiffedLanguage(language);
+    const langId = diffedLanguage || language;
+    // handle shiki Hard-coded languages ['ansi', '', 'plaintext', 'txt', 'text', 'plain']
+    if (isSpecialLang(langId)) {
+        return true;
+    }
+    // note: getLoadedLanguages() also returns aliases
+    return shiki.getLoadedLanguages().includes(langId);
+}
+export function loadCodeLanguage(language, editor, codeNodeKey) {
+    const diffedLanguage = getDiffedLanguage(language);
+    const langId = diffedLanguage ? diffedLanguage : language;
+    if (!isCodeLanguageLoaded(langId)) {
+        const languageInfo = bundledLanguagesInfo.find((desc) => desc.id === langId || (desc.aliases && desc.aliases.includes(langId)));
+        if (languageInfo) {
+            // in case we arrive here concurrently (not yet loaded language is loaded twice)
+            // shiki's synchronous checks make sure to load it only once
+            return shiki.loadLanguage(languageInfo.import()).then(() => {
+                // here we know that the language is loaded
+                // make sure the code is highlighed with the correct language
+                if (editor && codeNodeKey) {
+                    editor.update(() => {
+                        const codeNode = $getNodeByKey(codeNodeKey);
+                        if ($isCodeNode(codeNode) &&
+                            codeNode.getLanguage() === language &&
+                            !codeNode.getIsSyntaxHighlightSupported()) {
+                            codeNode.setIsSyntaxHighlightSupported(true);
+                        }
+                    });
+                }
+            });
+        }
+    }
+}
+export function isCodeThemeLoaded(theme) {
+    const themeId = theme;
+    // handle shiki special theme ['none']
+    if (isSpecialTheme(themeId)) {
+        return true;
+    }
+    return shiki.getLoadedThemes().includes(themeId);
+}
+export function loadCodeTheme(theme, editor, codeNodeKey) {
+    if (!isCodeThemeLoaded(theme)) {
+        const themeInfo = bundledThemesInfo.find((info) => info.id === theme);
+        if (themeInfo) {
+            return shiki.loadTheme(themeInfo.import()).then(() => {
+                if (editor && codeNodeKey) {
+                    editor.update(() => {
+                        const codeNode = $getNodeByKey(codeNodeKey);
+                        if ($isCodeNode(codeNode)) {
+                            codeNode.markDirty();
+                        }
+                    });
+                }
+            });
+        }
+    }
+}
+export function getCodeLanguageOptions() {
+    return bundledLanguagesInfo.map((i) => [i.id, i.name]);
+}
+export function getCodeThemeOptions() {
+    return bundledThemesInfo.map((i) => [i.id, i.displayName]);
+}
+export function normalizeCodeLanguage(language) {
+    const langId = language;
+    const languageInfo = bundledLanguagesInfo.find((desc) => desc.id === langId || (desc.aliases && desc.aliases.includes(langId)));
+    if (languageInfo) {
+        return languageInfo.id;
+    }
+    return language;
+}
+export function $getHighlightNodes(codeNode, language) {
+    const DIFF_LANGUAGE_REGEX = /^diff-([\w-]+)/i;
+    const diffLanguageMatch = DIFF_LANGUAGE_REGEX.exec(language);
+    const code = codeNode.getTextContent();
+    const tokensResult = shiki.codeToTokens(code, {
+        lang: diffLanguageMatch ? diffLanguageMatch[1] : language,
+        theme: codeNode.getTheme() || "poimandres",
+    });
+    const { tokens, bg, fg } = tokensResult;
+    let style = "";
+    if (bg) {
+        style += `background-color: ${bg};`;
+    }
+    if (fg) {
+        style += `color: ${fg};`;
+    }
+    if (codeNode.getStyle() !== style) {
+        codeNode.setStyle(style);
+    }
+    return mapTokensToLexicalStructure(tokens, !!diffLanguageMatch);
+}
+function mapTokensToLexicalStructure(tokens, diff) {
+    const nodes = [];
+    tokens.forEach((line, idx) => {
+        if (idx) {
+            nodes.push($createLineBreakNode());
+        }
+        line.forEach((token, tidx) => {
+            let text = token.content;
+            // implement diff-xxxx languages
+            if (diff && tidx === 0 && text.length > 0) {
+                const prefixes = ["+", "-", ">", "<", " "];
+                const prefixTypes = [
+                    "inserted",
+                    "deleted",
+                    "inserted",
+                    "deleted",
+                    "unchanged",
+                ];
+                const prefixIndex = prefixes.indexOf(text[0]);
+                if (prefixIndex !== -1) {
+                    nodes.push($createCodeHighlightNode(prefixes[prefixIndex], prefixTypes[prefixIndex]));
+                    text = text.slice(1);
+                }
+            }
+            const parts = text.split("\t");
+            parts.forEach((part, pidx) => {
+                if (pidx) {
+                    nodes.push($createTabNode());
+                }
+                if (part !== "") {
+                    const node = $createCodeHighlightNode(part);
+                    const style = stringifyTokenStyle(token.htmlStyle || getTokenStyleObject(token));
+                    node.setStyle(style);
+                    nodes.push(node);
+                }
+            });
+        });
+    });
+    return nodes;
+}

package/build/nodes/CodeNode/FlatStructureUtils.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 { CodeHighlightNode } from "./CodeHighlightNode";
+import type { LineBreakNode, TabNode } from "lexical";
+export declare function $getFirstCodeNodeOfLine(anchor: CodeHighlightNode | TabNode | LineBreakNode): CodeHighlightNode | TabNode | LineBreakNode;
+export declare function $getLastCodeNodeOfLine(anchor: CodeHighlightNode | TabNode | LineBreakNode): CodeHighlightNode | TabNode | LineBreakNode;
+/**
+ * Determines the visual writing direction of a code line.
+ *
+ * Scans the line segments (CodeHighlightNode/TabNode) from start to end
+ * and returns the first strong direction found ("ltr" or "rtl").
+ * If no strong character is found, falls back to the parent element's
+ * direction. Returns null if indeterminate.
+ */
+export declare function $getCodeLineDirection(anchor: CodeHighlightNode | TabNode | LineBreakNode): "ltr" | "rtl" | null;
+//# sourceMappingURL=FlatStructureUtils.d.ts.map

package/build/nodes/CodeNode/FlatStructureUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlatStructureUtils.d.ts","sourceRoot":"","sources":["../../../src/nodes/CodeNode/FlatStructureUtils.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,KAAK,EAGV,aAAa,EAEb,OAAO,EACR,MAAM,SAAS,CAAC;AA+BjB,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,iBAAiB,GAAG,OAAO,GAAG,aAAa,GAClD,iBAAiB,GAAG,OAAO,GAAG,aAAa,CAE7C;AAED,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,iBAAiB,GAAG,OAAO,GAAG,aAAa,GAClD,iBAAiB,GAAG,OAAO,GAAG,aAAa,CAE7C;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,iBAAiB,GAAG,OAAO,GAAG,aAAa,GAClD,KAAK,GAAG,KAAK,GAAG,IAAI,CA6BtB"}

package/build/nodes/CodeNode/FlatStructureUtils.js

@@ -0,0 +1,85 @@
+/**
+ * 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 { $getAdjacentCaret } from "@lexical/utils";
+import { $getSiblingCaret, $isElementNode, $isLineBreakNode, $isTabNode, getTextDirection, } from "lexical";
+import { $isCodeHighlightNode } from "./CodeHighlightNode";
+function $getLastMatchingCodeNode(anchor, direction) {
+    let matchingNode = anchor;
+    for (let caret = $getSiblingCaret(anchor, direction); caret && ($isCodeHighlightNode(caret.origin) || $isTabNode(caret.origin)); caret = $getAdjacentCaret(caret)) {
+        matchingNode = caret.origin;
+    }
+    return matchingNode;
+}
+export function $getFirstCodeNodeOfLine(anchor) {
+    return $getLastMatchingCodeNode(anchor, "previous");
+}
+export function $getLastCodeNodeOfLine(anchor) {
+    return $getLastMatchingCodeNode(anchor, "next");
+}
+/**
+ * Determines the visual writing direction of a code line.
+ *
+ * Scans the line segments (CodeHighlightNode/TabNode) from start to end
+ * and returns the first strong direction found ("ltr" or "rtl").
+ * If no strong character is found, falls back to the parent element's
+ * direction. Returns null if indeterminate.
+ */
+export function $getCodeLineDirection(anchor) {
+    const start = $getFirstCodeNodeOfLine(anchor);
+    const end = $getLastCodeNodeOfLine(anchor);
+    let node = start;
+    while (node !== null) {
+        if ($isCodeHighlightNode(node)) {
+            const direction = getTextDirection(node.getTextContent());
+            if (direction !== null) {
+                return direction;
+            }
+        }
+        if (node === end) {
+            break;
+        }
+        node = node.getNextSibling();
+    }
+    const parent = start.getParent();
+    if ($isElementNode(parent)) {
+        const parentDirection = parent.getDirection();
+        if (parentDirection === "ltr" || parentDirection === "rtl") {
+            return parentDirection;
+        }
+    }
+    return null;
+}
+function findNextNonBlankInLine(anchor, offset) {
+    let node = anchor;
+    let nodeOffset = offset;
+    let nodeTextContent = anchor.getTextContent();
+    let nodeTextContentSize = anchor.getTextContentSize();
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        if (!$isCodeHighlightNode(node) || nodeOffset === nodeTextContentSize) {
+            node = node.getNextSibling();
+            if (node === null || $isLineBreakNode(node)) {
+                return null;
+            }
+            if ($isCodeHighlightNode(node)) {
+                nodeOffset = 0;
+                nodeTextContent = node.getTextContent();
+                nodeTextContentSize = node.getTextContentSize();
+            }
+        }
+        if ($isCodeHighlightNode(node)) {
+            if (nodeTextContent[nodeOffset] !== " ") {
+                return {
+                    node,
+                    offset: nodeOffset,
+                };
+            }
+            nodeOffset++;
+        }
+    }
+}

package/build/nodes/CodeNode/invariant.d.ts

@@ -0,0 +1,2 @@
+export default function invariant(cond?: boolean, message?: string, ...args: string[]): asserts cond;
+//# sourceMappingURL=invariant.d.ts.map

package/build/nodes/CodeNode/invariant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invariant.d.ts","sourceRoot":"","sources":["../../../src/nodes/CodeNode/invariant.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,IAAI,CAAC,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,MAAM,EAChB,GAAG,IAAI,EAAE,MAAM,EAAE,GAChB,OAAO,CAAC,IAAI,CAQd"}

package/build/nodes/CodeNode/invariant.js

@@ -0,0 +1,6 @@
+export default function invariant(cond, message, ...args) {
+    if (cond) {
+        return;
+    }
+    throw new Error(args.reduce((msg, arg) => msg.replace("%s", String(arg)), message || ""));
+}