@mx-space/cli 0.7.8 → 0.9.0

package/dist/LexicalCodeCore.dev-DjSrd4A4.mjs

@@ -0,0 +1,1109 @@
+import { d as getPeerDependencyFromEditor, f as namedSignals, l as effect } from "./LexicalExtension.node-BVlcrgOx.mjs";
+import { $ as $isElementNode, $t as ElementNode, An as KEY_ARROW_UP_COMMAND, Ar as removeClassNamesFromElement, Bn as OUTDENT_CONTENT_COMMAND, Bt as COMMAND_PRIORITY_LOW, D as $getCaretRangeInDirection, Dn as KEY_ARROW_DOWN_COMMAND, E as $getCaretRange, F as $getEditor, In as KEY_TAB_COMMAND, J as $insertNodes, K as $getTextPointCaret, Mr as setDOMStyleFromCSS, Nn as KEY_ENTER_COMMAND, Or as mergeRegister, Rn as MOVE_TO_END, Sr as isHTMLElement, Tt as $setSelectionFromCaretRange, U as $getSelection, W as $getSiblingCaret, _r as isDOMDocumentNode, cr as defineExtension, dt as $isTabNode, er as TextNode, f as $createParagraphNode, ft as $isTextNode, g as $createTabNode, ht as $normalizeCaret, it as $isLineBreakNode, jr as safeCast, l as $create, ln as INSERT_TAB_COMMAND, mr as getTextDirection, n as $applyNodeReplacement, on as INDENT_CONTENT_COMMAND, p as $createPoint, rr as configExtension, st as $isRangeSelection, tr as addClassNamesToElement, u as $createLineBreakNode, x as $generateNodesFromRawText, yr as isDOMTextNode, zn as MOVE_TO_START } from "./Lexical.node-fXM8Jp7p.mjs";
+import { a as CoreImportExtension, g as sel, m as defineOverlayRules, o as DOMImportExtension, p as defineImportRule, s as ImportOverlays } from "./LexicalHtml.node-BvNF96jZ.mjs";
+//#region ../../node_modules/.pnpm/@lexical+code-core@0.45.0/node_modules/@lexical/code-core/dist/LexicalCodeCore.dev.mjs
+/**
+* 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.
+*
+*/
+/**
+* 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.
+*
+*/
+function warnOnlyOnce(message) {
+	{
+		let run = false;
+		return () => {
+			if (!run) console.warn(message);
+			run = true;
+		};
+	}
+}
+/**
+* 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.
+*
+*/
+function formatDevErrorMessage(message) {
+	throw new Error(message);
+}
+function $getLastMatchingCodeNode(anchor, direction) {
+	let matchingNode = anchor;
+	for (let caret = $getSiblingCaret(anchor, direction); caret && ($isCodeHighlightNode(caret.origin) || $isTabNode(caret.origin)); caret = caret.getAdjacentCaret()) matchingNode = caret.origin;
+	return matchingNode;
+}
+function $getFirstCodeNodeOfLine(anchor) {
+	return $getLastMatchingCodeNode(anchor, "previous");
+}
+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.
+*/
+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 $getStartOfCodeInLine(anchor, offset) {
+	let last = null;
+	let lastNonBlank = null;
+	let node = anchor;
+	let nodeOffset = offset;
+	let nodeTextContent = anchor.getTextContent();
+	while (true) {
+		if (nodeOffset === 0) {
+			node = node.getPreviousSibling();
+			if (node === null) break;
+			if (!($isCodeHighlightNode(node) || $isTabNode(node) || $isLineBreakNode(node))) formatDevErrorMessage(`Expected a valid Code Node: CodeHighlightNode, TabNode, LineBreakNode`);
+			if ($isLineBreakNode(node)) {
+				last = {
+					node,
+					offset: 1
+				};
+				break;
+			}
+			nodeOffset = Math.max(0, node.getTextContentSize() - 1);
+			nodeTextContent = node.getTextContent();
+		} else nodeOffset--;
+		const character = nodeTextContent[nodeOffset];
+		if ($isCodeHighlightNode(node) && character !== " ") lastNonBlank = {
+			node,
+			offset: nodeOffset
+		};
+	}
+	if (lastNonBlank !== null) return lastNonBlank;
+	let codeCharacterAtAnchorOffset = null;
+	if (offset < anchor.getTextContentSize()) {
+		if ($isCodeHighlightNode(anchor)) codeCharacterAtAnchorOffset = anchor.getTextContent()[offset];
+	} else {
+		const nextSibling = anchor.getNextSibling();
+		if ($isCodeHighlightNode(nextSibling)) codeCharacterAtAnchorOffset = nextSibling.getTextContent()[0];
+	}
+	if (codeCharacterAtAnchorOffset !== null && codeCharacterAtAnchorOffset !== " ") return last;
+	else {
+		const nextNonBlank = findNextNonBlankInLine(anchor, offset);
+		if (nextNonBlank !== null) return nextNonBlank;
+		else return last;
+	}
+}
+function findNextNonBlankInLine(anchor, offset) {
+	let node = anchor;
+	let nodeOffset = offset;
+	let nodeTextContent = anchor.getTextContent();
+	let nodeTextContentSize = anchor.getTextContentSize();
+	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++;
+		}
+	}
+}
+function $getEndOfCodeInLine(anchor) {
+	const lastNode = $getLastCodeNodeOfLine(anchor);
+	if (!!$isLineBreakNode(lastNode)) formatDevErrorMessage(`Unexpected lineBreakNode in getEndOfCodeInLine`);
+	return lastNode;
+}
+/**
+* Plain split of code text into CodeHighlightNodes (with no highlight
+* type) + LineBreakNodes + TabNodes. Used when the tokenizer opts out
+* of a default language so a previously highlighted block still
+* renders its `\n` / `\t` as real line breaks / tabs, while staying
+* compatible with the indent / shift-lines handlers that only accept
+* CodeHighlightNode + TabNode + LineBreakNode inside a CodeNode.
+*/
+function $plainifyCodeContent(text) {
+	const out = [];
+	text.split("\n").forEach((line, lineIdx) => {
+		if (lineIdx > 0) out.push($createLineBreakNode());
+		line.split("	").forEach((part, partIdx) => {
+			if (partIdx > 0) out.push($createTabNode());
+			if (part.length > 0) out.push($createCodeHighlightNode(part));
+		});
+	});
+	return out;
+}
+/**
+* Strip up to `tabSize` leading spaces from a {@link CodeHighlightNode} that
+* starts a code line, to support outdenting space-indented code lines (e.g.
+* code formatted with prettier). Returns true if any spaces were stripped.
+*
+* Best-effort: a line with fewer than `tabSize` leading spaces has all of
+* them stripped, matching VS Code / IntelliJ behavior.
+*
+* Selection is preserved relative to line content. Anchor/focus offsets
+* pointing into `node` shift left by the number of stripped characters
+* (clamped to 0). The underlying TextNode mutation does not adjust
+* selection offsets that already point into the old text, so we patch
+* them up explicitly.
+*/
+function $outdentLeadingSpaces(node, tabSize, selection) {
+	if (!Number.isInteger(tabSize) || tabSize <= 0) return false;
+	const text = node.getTextContent();
+	const leading = /^ +/.exec(text);
+	if (!leading) return false;
+	const stripCount = Math.min(tabSize, leading[0].length);
+	const lineKey = node.getKey();
+	const oldAnchorOffset = selection.anchor.key === lineKey && selection.anchor.type === "text" ? selection.anchor.offset : null;
+	const oldFocusOffset = selection.focus.key === lineKey && selection.focus.type === "text" ? selection.focus.offset : null;
+	node.spliceText(0, stripCount, "");
+	if (oldAnchorOffset !== null) selection.anchor.set(lineKey, Math.max(0, oldAnchorOffset - stripCount), "text");
+	if (oldFocusOffset !== null) selection.focus.set(lineKey, Math.max(0, oldFocusOffset - stripCount), "text");
+	return true;
+}
+/**
+* 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.
+*
+*/
+const DEFAULT_CODE_LANGUAGE = "javascript";
+/** @internal Configurable through the extensions. */
+const getDefaultCodeLanguage = () => DEFAULT_CODE_LANGUAGE;
+function hasChildDOMNodeTag(node, tagName) {
+	for (const child of node.childNodes) {
+		if (isHTMLElement(child) && child.tagName === tagName) return true;
+		if (hasChildDOMNodeTag(child, tagName)) return true;
+	}
+	return false;
+}
+const LANGUAGE_DATA_ATTRIBUTE$1 = "data-language";
+const HIGHLIGHT_LANGUAGE_DATA_ATTRIBUTE = "data-highlight-language";
+const THEME_DATA_ATTRIBUTE = "data-theme";
+const noExtensionDeprecation = warnOnlyOnce("Using CodeNode without CodeExtension is deprecated");
+/** @noInheritDoc */
+var CodeNode = class CodeNode extends ElementNode {
+	/** @internal */
+	__language;
+	/** @internal */
+	__theme;
+	/** @internal */
+	__isSyntaxHighlightSupported;
+	static getType() {
+		return "code";
+	}
+	static clone(node) {
+		return new CodeNode(node.__language, node.__key);
+	}
+	constructor(language, key) {
+		super(key);
+		this.__language = language || void 0;
+		this.__isSyntaxHighlightSupported = false;
+		this.__theme = void 0;
+	}
+	afterCloneFrom(prevNode) {
+		super.afterCloneFrom(prevNode);
+		this.__language = prevNode.__language;
+		this.__theme = prevNode.__theme;
+		this.__isSyntaxHighlightSupported = prevNode.__isSyntaxHighlightSupported;
+	}
+	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$1, 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) setDOMStyleFromCSS(element.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$1, language);
+		} else if (prevLanguage) dom.removeAttribute(LANGUAGE_DATA_ATTRIBUTE$1);
+		const isSyntaxHighlightSupported = this.__isSyntaxHighlightSupported;
+		if (prevNode.__isSyntaxHighlightSupported && 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 !== prevStyle) setDOMStyleFromCSS(dom.style, style, prevStyle);
+		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$1, 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) setDOMStyleFromCSS(element.style, style);
+		return { element };
+	}
+	static importDOM() {
+		return {
+			code: (node) => {
+				return node.textContent != null && (/\r?\n/.test(node.textContent) || hasChildDOMNodeTag(node, "BR")) ? {
+					conversion: $convertPreElement,
+					priority: 1
+				} : null;
+			},
+			div: () => ({
+				conversion: $convertDivElement,
+				priority: 1
+			}),
+			pre: () => ({
+				conversion: $convertPreElement,
+				priority: 0
+			}),
+			table: (node) => {
+				if (isGitHubCodeTable(node)) return {
+					conversion: $convertTableElement,
+					priority: 3
+				};
+				return null;
+			},
+			td: (node) => {
+				const td = node;
+				const table = td.closest("table");
+				if (isGitHubCodeCell(td) || table && isGitHubCodeTable(table)) return {
+					conversion: convertCodeNoop,
+					priority: 3
+				};
+				return null;
+			},
+			tr: (node) => {
+				const table = node.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 {
+			...super.exportJSON(),
+			language: this.getLanguage(),
+			theme: this.getTheme()
+		};
+	}
+	insertNewAfter(selection, restoreSelection = true) {
+		if (!getPeerDependencyFromEditor($getEditor(), "@lexical/code")) {
+			noExtensionDeprecation();
+			const el = $exitCodeNodeOnEnter(selection);
+			if (el) return el;
+		}
+		const { anchor, focus } = selection;
+		const firstSelectionNode = (anchor.isBefore(focus) ? anchor : focus).getNode();
+		if ($isTextNode(firstSelectionNode)) {
+			let node = $getFirstCodeNodeOfLine(firstSelectionNode);
+			const insertNodes = [];
+			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();
+		this.getChildren().forEach((child) => paragraph.append(child));
+		this.replace(paragraph);
+		return true;
+	}
+	setLanguage(language) {
+		const writable = this.getWritable();
+		writable.__language = language || void 0;
+		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 || void 0;
+		return writable;
+	}
+	getTheme() {
+		return this.getLatest().__theme;
+	}
+};
+function $createCodeNode(language, theme) {
+	return $create(CodeNode).setLanguage(language).setTheme(theme);
+}
+function $isCodeNode(node) {
+	return node instanceof CodeNode;
+}
+function $convertPreElement(domNode) {
+	return { node: $createCodeNode(domNode.getAttribute(LANGUAGE_DATA_ATTRIBUTE$1)) };
+}
+function $convertDivElement(domNode) {
+	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");
+}
+function $exitCodeNodeOnEnter(selection) {
+	const { anchor } = selection;
+	if (selection.isCollapsed() && anchor.type === "element") {
+		const codeNode = anchor.getNode();
+		if ($isCodeNode(codeNode)) {
+			const childrenSize = codeNode.getChildrenSize();
+			if (childrenSize >= 2 && anchor.offset === childrenSize) {
+				const lastChild = codeNode.getLastChild();
+				if ($isLineBreakNode(lastChild) && $isLineBreakNode(lastChild.getPreviousSibling())) {
+					const newElement = $createParagraphNode();
+					codeNode.splice(childrenSize - 2, 2, []).insertAfter(newElement, false);
+					newElement.select();
+					return newElement;
+				}
+			}
+		}
+	}
+	return null;
+}
+/**
+* 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.
+*
+*/
+/** @noInheritDoc */
+var CodeHighlightNode = class CodeHighlightNode extends TextNode {
+	/** @internal */
+	__highlightType;
+	constructor(text = "", highlightType, key) {
+		super(text, key);
+		this.__highlightType = highlightType;
+	}
+	static getType() {
+		return "code-highlight";
+	}
+	static clone(node) {
+		return new CodeHighlightNode(node.__text, node.__highlightType || void 0, node.__key);
+	}
+	afterCloneFrom(prevNode) {
+		super.afterCloneFrom(prevNode);
+		this.__highlightType = prevNode.__highlightType;
+	}
+	getHighlightType() {
+		return this.getLatest().__highlightType;
+	}
+	setHighlightType(highlightType) {
+		const self = this.getWritable();
+		self.__highlightType = highlightType || void 0;
+		return self;
+	}
+	canHaveFormat() {
+		return false;
+	}
+	createDOM(config) {
+		const element = super.createDOM(config);
+		addClassNamesToElement(element, getHighlightThemeClass(config.theme, this.__highlightType));
+		return element;
+	}
+	updateDOM(prevNode, dom, config) {
+		const update = super.updateDOM(prevNode, dom, config);
+		const prevClassName = getHighlightThemeClass(config.theme, prevNode.__highlightType);
+		const nextClassName = getHighlightThemeClass(config.theme, this.__highlightType);
+		if (prevClassName !== nextClassName) {
+			if (prevClassName) removeClassNamesFromElement(dom, prevClassName);
+			if (nextClassName) addClassNamesToElement(dom, nextClassName);
+		}
+		return update;
+	}
+	static importJSON(serializedNode) {
+		return $createCodeHighlightNode().updateFromJSON(serializedNode);
+	}
+	updateFromJSON(serializedNode) {
+		return super.updateFromJSON(serializedNode).setHighlightType(serializedNode.highlightType);
+	}
+	exportJSON() {
+		return {
+			...super.exportJSON(),
+			highlightType: this.getHighlightType()
+		};
+	}
+	setFormat(format) {
+		return this;
+	}
+	isParentRequired() {
+		return true;
+	}
+	createParentElementNode() {
+		return $createCodeNode();
+	}
+};
+function getHighlightThemeClass(theme, highlightType) {
+	return highlightType && theme && theme.codeHighlight && theme.codeHighlight[highlightType];
+}
+function $createCodeHighlightNode(text = "", highlightType) {
+	return $applyNodeReplacement(new CodeHighlightNode(text, highlightType));
+}
+function $isCodeHighlightNode(node) {
+	return node instanceof CodeHighlightNode;
+}
+/**
+* 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.
+*
+*/
+/**
+* Add code blocks to the editor (syntax highlighting provided separately)
+*/
+const CodeExtension = defineExtension({
+	name: "@lexical/code",
+	nodes: () => [CodeNode, CodeHighlightNode],
+	register(editor) {
+		return editor.registerCommand(KEY_ENTER_COMMAND, (event) => {
+			const selection = $getSelection();
+			if ($isRangeSelection(selection) && $exitCodeNodeOnEnter(selection)) {
+				event.preventDefault();
+				return true;
+			}
+			return false;
+		}, COMMAND_PRIORITY_LOW);
+	}
+});
+/**
+* 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.
+*
+*/
+const LANGUAGE_DATA_ATTRIBUTE = "data-language";
+/**
+* True for elements whose `font-family` mentions `monospace` — the
+* heuristic the legacy `<div>` rule uses to spot copy-pasted code blocks
+* (e.g. Google Docs serializes a code block as a styled `<div>`).
+*/
+function isMonospaceElement(el) {
+	return el.style.fontFamily.match("monospace") !== null;
+}
+function isMonospaceDescendant(node) {
+	let parent = node.parentElement;
+	while (parent !== null) {
+		if (isMonospaceElement(parent)) return true;
+		parent = parent.parentElement;
+	}
+	return false;
+}
+/**
+* Overlay rules active only while {@link GitHubCodeTableRule} is
+* processing its children. Inside the code-table subtree, every `<tr>`
+* and `<td>` unwraps unconditionally — they never become table-row /
+* table-cell nodes (even when `@lexical/table` registers its rules for
+* those tags). Outside the subtree, this overlay isn't installed, so
+* the cost of these rules is never paid against unrelated `<tr>` /
+* `<td>` pastes.
+*/
+const GitHubCodeTableOverlayRules = defineOverlayRules([defineImportRule({
+	$import: (ctx, el) => ctx.$importChildren(el),
+	match: sel.tag("tr", "td"),
+	name: "@lexical/code/github-code-table/unwrap"
+})]);
+const PreRule = defineImportRule({
+	$import: (ctx, el) => [$createCodeNode(el.getAttribute(LANGUAGE_DATA_ATTRIBUTE)).splice(0, 0, ctx.$importChildren(el))],
+	match: sel.tag("pre"),
+	name: "@lexical/code/pre"
+});
+/**
+* Multi-line `<code>` (containing newlines or `<br>`) is treated as a
+* block code element — mirrors the legacy behavior. Single-line `<code>`
+* defers to the inline-format rule from `CoreImportExtension` so it
+* becomes a TextNode with IS_CODE.
+*/
+const MultilineCodeRule = defineImportRule({
+	$import: (ctx, el, $next) => {
+		const text = el.textContent || "";
+		if (!(/\r?\n/.test(text) || el.querySelector("br") !== null)) return $next();
+		return [$createCodeNode(el.getAttribute(LANGUAGE_DATA_ATTRIBUTE)).splice(0, 0, ctx.$importChildren(el))];
+	},
+	match: sel.tag("code"),
+	name: "@lexical/code/code-multiline"
+});
+/**
+* True for elements carrying BOTH `font-family: …monospace…` and
+* `white-space: pre*` inline — the shape VS Code uses for every line
+* of a copied code block (on every per-line `<div>` on Safari, on
+* the single outer wrapper on Chrome).
+*/
+function isMonospacePreElement(el) {
+	if (!isHTMLElement(el)) return false;
+	const ff = el.style.fontFamily;
+	const ws = el.style.whiteSpace;
+	return typeof ff === "string" && /monospace/i.test(ff) && typeof ws === "string" && ws.startsWith("pre");
+}
+/**
+* Split a monospace-pre wrapper element into logical code lines:
+* `<div>` children contribute their text content as one line,
+* `<br>` children contribute an empty line, inline children (spans
+* and bare text) accumulate into the current line until the next
+* block child.
+*
+* Returns `null` if `el` has no block children (i.e. it's a leaf
+* line, not a wrapper) so the caller can leave it to the
+* sibling-run pass.
+*/
+function splitMonospaceWrapperLines(el) {
+	let hasBlockChild = false;
+	const lines = [];
+	let acc = "";
+	let hasAcc = false;
+	const flush = () => {
+		if (hasAcc) {
+			lines.push(acc);
+			acc = "";
+			hasAcc = false;
+		}
+	};
+	for (const child of Array.from(el.childNodes)) if (isHTMLElement(child)) if (child.tagName === "DIV") {
+		flush();
+		lines.push(child.textContent || "");
+		hasBlockChild = true;
+	} else if (child.tagName === "BR") {
+		flush();
+		lines.push("");
+		hasBlockChild = true;
+	} else {
+		acc += child.textContent || "";
+		hasAcc = true;
+	}
+	else if (isDOMTextNode(child)) {
+		const t = child.textContent || "";
+		if (t.length > 0) {
+			acc += t;
+			hasAcc = true;
+		}
+	}
+	flush();
+	return hasBlockChild ? lines : null;
+}
+/**
+* Returns `true` if `root` contains the structural signature of a
+* VS Code code-block paste:
+*
+*  - a monospace+pre `<div>` wrapper with at least one block (`<div>` /
+*    `<br>`) child — the Chrome shape, or
+*  - two or more consecutive monospace+pre siblings — the Safari shape.
+*
+* Walked once in preprocess; the matching overlay is only installed
+* when this returns `true` so an unrelated paste doesn't pay for the
+* detection or rule cost.
+*/
+function looksLikeVscodePaste(root) {
+	for (const child of Array.from(root.children)) {
+		if (isHTMLElement(child) && isMonospacePreElement(child)) {
+			if (splitMonospaceWrapperLines(child) !== null) return true;
+			const next = child.nextElementSibling;
+			if (next && isMonospacePreElement(next)) return true;
+			continue;
+		}
+		if (looksLikeVscodePaste(child)) return true;
+	}
+	return false;
+}
+const VscodeCodePasteOverlay = defineOverlayRules([defineImportRule({
+	$import: (_ctx, el, $next) => {
+		if (!isMonospacePreElement(el) || isMonospaceDescendant(el)) return $next();
+		const lines = splitMonospaceWrapperLines(el);
+		if (lines === null || lines.length === 0) return $next();
+		return [$createCodeNode().splice(0, 0, $generateNodesFromRawText(lines.join("\n")))];
+	},
+	match: sel.tag("div"),
+	name: "@lexical/code/vscode-wrapper"
+}), defineImportRule({
+	$import: (_ctx, el, $next) => {
+		if (!isMonospacePreElement(el) || isMonospaceDescendant(el)) return $next();
+		const prev = el.previousElementSibling;
+		if (prev && isMonospacePreElement(prev)) return [];
+		const lines = [];
+		let cur = el;
+		while (cur && isMonospacePreElement(cur)) {
+			lines.push(cur.tagName === "BR" ? "" : cur.textContent || "");
+			cur = cur.nextElementSibling;
+		}
+		if (lines.length < 2) return $next();
+		return [$createCodeNode().splice(0, 0, $generateNodesFromRawText(lines.join("\n")))];
+	},
+	match: sel.tag("div", "br"),
+	name: "@lexical/code/vscode-line-run"
+})]);
+/**
+* VS Code → browser code-block pastes ship the block as either:
+*
+*  - **Chrome**: one outer
+*    `<div style="font-family: …monospace…; white-space: pre">…</div>`
+*    wrapping per-line `<div>`s and `<br>`s.
+*  - **Safari**: a flat run of sibling
+*    `<div style="…monospace…; white-space: pre">…</div>` and
+*    `<br style="…monospace…; …">` elements with no wrapping
+*    monospace ancestor (the styles are duplicated onto every
+*    element).
+*
+* The legacy `<div>` rule (and {@link DivRule}) produces one CodeNode
+* per `<div>` on Safari and concatenates inner divs without
+* separating `\n`s on Chrome. This preprocess scans once for the
+* structural signature and, only when it matches, pushes
+* {@link VscodeCodePasteOverlay} onto {@link ImportOverlays} so the
+* VS Code-specific rules participate in the walk. Pastes from other
+* sources pay only the detection cost.
+*
+* @experimental
+*/
+const $installVscodeCodePasteOverlay = (dom, ctx, $next) => {
+	if (looksLikeVscodePaste(isDOMDocumentNode(dom) ? dom.body : dom)) ctx.session.update(ImportOverlays, (prev) => [...prev, VscodeCodePasteOverlay]);
+	$next();
+};
+/**
+* A `<div style="font-family: …monospace…">` (Google-Docs-style code
+* block) creates a CodeNode. Descendant elements inside a monospace
+* wrapper just unwrap so their text content flows into the surrounding
+* CodeNode.
+*/
+const DivRule = defineImportRule({
+	$import: (ctx, el, $next) => {
+		if (isMonospaceElement(el)) return [$createCodeNode().splice(0, 0, ctx.$importChildren(el))];
+		if (isMonospaceDescendant(el)) return ctx.$importChildren(el);
+		return $next();
+	},
+	match: sel.tag("div"),
+	name: "@lexical/code/div"
+});
+/**
+* Import rules for {@link CodeNode}.
+*
+* Specific class-restricted rules (GitHub raw-file-view detectors) are
+* registered before the generic `<table>` / `<tr>` / `<td>` rules so
+* they win dispatch.
+*
+* @experimental
+*/
+const CodeImportRules = [
+	defineImportRule({
+		$import: (ctx, el) => [$createCodeNode().splice(0, 0, ctx.$importChildren(el, { rules: GitHubCodeTableOverlayRules }))],
+		match: sel.tag("table").classAll("js-file-line-container"),
+		name: "@lexical/code/github-code-table"
+	}),
+	defineImportRule({
+		$import: (ctx, el) => ctx.$importChildren(el),
+		match: sel.tag("td").classAll("js-file-line"),
+		name: "@lexical/code/github-code-cell-by-class"
+	}),
+	MultilineCodeRule,
+	PreRule,
+	DivRule
+];
+/**
+* Bundles {@link CodeImportRules} (plus {@link CoreImportExtension}) into
+* a single dependency. The legacy {@link CodeNode.importDOM} continues to
+* work in parallel; depend on this extension to opt into the new
+* pipeline.
+*
+* @experimental
+*/
+const CodeImportExtension = defineExtension({
+	dependencies: [
+		CoreImportExtension,
+		CodeExtension,
+		configExtension(DOMImportExtension, {
+			preprocess: [$installVscodeCodePasteOverlay],
+			rules: CodeImportRules
+		})
+	],
+	name: "@lexical/code/Import"
+});
+function $isSelectionInCode(selection) {
+	if (!$isRangeSelection(selection)) return false;
+	const anchorNode = selection.anchor.getNode();
+	const maybeAnchorCodeNode = $isCodeNode(anchorNode) ? anchorNode : anchorNode.getParent();
+	const focusNode = selection.focus.getNode();
+	const maybeFocusCodeNode = $isCodeNode(focusNode) ? focusNode : focusNode.getParent();
+	return $isCodeNode(maybeAnchorCodeNode) && maybeAnchorCodeNode.is(maybeFocusCodeNode);
+}
+/**
+* Returns an Array of code lines
+* Take the sequence of LineBreakNode | TabNode | CodeHighlightNode forming
+* the selection and split it by LineBreakNode.
+* If the selection ends at the start of the last line, it is considered empty.
+* Empty lines are discarded.
+*/
+function $getCodeLines(selection) {
+	const nodes = selection.getNodes();
+	const lines = [];
+	if (nodes.length === 1 && $isCodeNode(nodes[0])) return lines;
+	let lastLine = [];
+	for (let i = 0; i < nodes.length; i++) {
+		const node = nodes[i];
+		if (!($isCodeHighlightNode(node) || $isTabNode(node) || $isLineBreakNode(node))) formatDevErrorMessage(`Expected selection to be inside CodeBlock and consisting of CodeHighlightNode, TabNode and LineBreakNode`);
+		if ($isLineBreakNode(node)) {
+			if (lastLine.length > 0) {
+				lines.push(lastLine);
+				lastLine = [];
+			}
+		} else lastLine.push(node);
+	}
+	if (lastLine.length > 0) {
+		const selectionEnd = selection.isBackward() ? selection.anchor : selection.focus;
+		const lastPoint = $createPoint(lastLine[0].getKey(), 0, "text");
+		if (!selectionEnd.is(lastPoint)) lines.push(lastLine);
+	}
+	return lines;
+}
+function $handleTab(shiftKey) {
+	const selection = $getSelection();
+	if (!$isRangeSelection(selection) || !$isSelectionInCode(selection)) return null;
+	const indentOrOutdent = !shiftKey ? INDENT_CONTENT_COMMAND : OUTDENT_CONTENT_COMMAND;
+	const tabOrOutdent = !shiftKey ? INSERT_TAB_COMMAND : OUTDENT_CONTENT_COMMAND;
+	const anchor = selection.anchor;
+	const focus = selection.focus;
+	if (anchor.is(focus)) return tabOrOutdent;
+	const codeLines = $getCodeLines(selection);
+	if (codeLines.length !== 1) return indentOrOutdent;
+	const codeLine = codeLines[0];
+	if (!(codeLine.length !== 0)) formatDevErrorMessage(`$getCodeLines only extracts non-empty lines`);
+	let selectionFirst;
+	let selectionLast;
+	if (selection.isBackward()) {
+		selectionFirst = focus;
+		selectionLast = anchor;
+	} else {
+		selectionFirst = anchor;
+		selectionLast = focus;
+	}
+	const firstOfLine = $getFirstCodeNodeOfLine(codeLine[0]);
+	const lastOfLine = $getLastCodeNodeOfLine(codeLine[0]);
+	const anchorOfLine = $createPoint(firstOfLine.getKey(), 0, "text");
+	const focusOfLine = $createPoint(lastOfLine.getKey(), lastOfLine.getTextContentSize(), "text");
+	if (selectionFirst.isBefore(anchorOfLine)) return indentOrOutdent;
+	if (focusOfLine.isBefore(selectionLast)) return indentOrOutdent;
+	if (anchorOfLine.isBefore(selectionFirst) || selectionLast.isBefore(focusOfLine)) return tabOrOutdent;
+	return indentOrOutdent;
+}
+function $handleMultilineIndent(type, tabSize) {
+	const selection = $getSelection();
+	if (!$isRangeSelection(selection) || !$isSelectionInCode(selection)) return false;
+	const codeLines = $getCodeLines(selection);
+	const codeLinesLength = codeLines.length;
+	if (codeLinesLength === 0 && selection.isCollapsed()) {
+		if (type === INDENT_CONTENT_COMMAND) selection.insertNodes([$createTabNode()]);
+		return true;
+	}
+	if (codeLinesLength === 0 && type === INDENT_CONTENT_COMMAND && selection.getTextContent() === "\n") {
+		const tabNode = $createTabNode();
+		const lineBreakNode = $createLineBreakNode();
+		const direction = selection.isBackward() ? "previous" : "next";
+		selection.insertNodes([tabNode, lineBreakNode]);
+		$setSelectionFromCaretRange($getCaretRangeInDirection($getCaretRange($getTextPointCaret(tabNode, "next", 0), $normalizeCaret($getSiblingCaret(lineBreakNode, "next"))), direction));
+		return true;
+	}
+	for (let i = 0; i < codeLinesLength; i++) {
+		const line = codeLines[i];
+		if (line.length > 0) {
+			let firstOfLine = line[0];
+			if (i === 0) firstOfLine = $getFirstCodeNodeOfLine(firstOfLine);
+			if (type === INDENT_CONTENT_COMMAND) {
+				const tabNode = $createTabNode();
+				firstOfLine.insertBefore(tabNode);
+				if (i === 0) {
+					const anchorKey = selection.isBackward() ? "focus" : "anchor";
+					const anchorLine = $createPoint(firstOfLine.getKey(), 0, "text");
+					if (selection[anchorKey].is(anchorLine)) selection[anchorKey].set(tabNode.getKey(), 0, "text");
+				}
+			} else if ($isTabNode(firstOfLine)) firstOfLine.remove();
+			else if (tabSize !== void 0 && $isCodeHighlightNode(firstOfLine)) $outdentLeadingSpaces(firstOfLine, tabSize, selection);
+		}
+	}
+	return true;
+}
+function $handleShiftLines(type, event) {
+	const selection = $getSelection();
+	if (!$isRangeSelection(selection)) return false;
+	const { anchor, focus } = selection;
+	const anchorOffset = anchor.offset;
+	const focusOffset = focus.offset;
+	const anchorNode = anchor.getNode();
+	const focusNode = focus.getNode();
+	const arrowIsUp = type === KEY_ARROW_UP_COMMAND;
+	if (!$isSelectionInCode(selection) || !($isCodeHighlightNode(anchorNode) || $isTabNode(anchorNode)) || !($isCodeHighlightNode(focusNode) || $isTabNode(focusNode))) return false;
+	if (!event.altKey) {
+		if (selection.isCollapsed()) {
+			const codeNode = anchorNode.getParentOrThrow();
+			if (arrowIsUp && anchorOffset === 0 && anchorNode.getPreviousSibling() === null) {
+				if (codeNode.getPreviousSibling() === null) {
+					codeNode.selectPrevious();
+					event.preventDefault();
+					return true;
+				}
+			} else if (!arrowIsUp && anchorOffset === anchorNode.getTextContentSize() && anchorNode.getNextSibling() === null) {
+				if (codeNode.getNextSibling() === null) {
+					codeNode.selectNext();
+					event.preventDefault();
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+	let start;
+	let end;
+	if (anchorNode.isBefore(focusNode)) {
+		start = $getFirstCodeNodeOfLine(anchorNode);
+		end = $getLastCodeNodeOfLine(focusNode);
+	} else {
+		start = $getFirstCodeNodeOfLine(focusNode);
+		end = $getLastCodeNodeOfLine(anchorNode);
+	}
+	if (start == null || end == null) return false;
+	const range = start.getNodesBetween(end);
+	for (let i = 0; i < range.length; i++) {
+		const node = range[i];
+		if (!$isCodeHighlightNode(node) && !$isTabNode(node) && !$isLineBreakNode(node)) return false;
+	}
+	event.preventDefault();
+	event.stopPropagation();
+	const linebreak = arrowIsUp ? start.getPreviousSibling() : end.getNextSibling();
+	if (!$isLineBreakNode(linebreak)) return true;
+	const sibling = arrowIsUp ? linebreak.getPreviousSibling() : linebreak.getNextSibling();
+	if (sibling == null) return true;
+	const maybeInsertionPoint = $isCodeHighlightNode(sibling) || $isTabNode(sibling) || $isLineBreakNode(sibling) ? arrowIsUp ? $getFirstCodeNodeOfLine(sibling) : $getLastCodeNodeOfLine(sibling) : null;
+	let insertionPoint = maybeInsertionPoint != null ? maybeInsertionPoint : sibling;
+	linebreak.remove();
+	range.forEach((node) => node.remove());
+	if (type === KEY_ARROW_UP_COMMAND) {
+		range.forEach((node) => insertionPoint.insertBefore(node));
+		insertionPoint.insertBefore(linebreak);
+	} else {
+		insertionPoint.insertAfter(linebreak);
+		insertionPoint = linebreak;
+		range.forEach((node) => {
+			insertionPoint.insertAfter(node);
+			insertionPoint = node;
+		});
+	}
+	selection.setTextNodeRange(anchorNode, anchorOffset, focusNode, focusOffset);
+	return true;
+}
+function $handleMoveTo(type, event) {
+	const selection = $getSelection();
+	if (!$isRangeSelection(selection)) return false;
+	const { anchor, focus } = selection;
+	const anchorNode = anchor.getNode();
+	const focusNode = focus.getNode();
+	const isMoveToStart = type === MOVE_TO_START;
+	if (!$isSelectionInCode(selection) || !($isCodeHighlightNode(anchorNode) || $isTabNode(anchorNode)) || !($isCodeHighlightNode(focusNode) || $isTabNode(focusNode))) return false;
+	const focusLineNode = focusNode;
+	const moveToStart = $getCodeLineDirection(focusLineNode) === "rtl" ? !isMoveToStart : isMoveToStart;
+	const originalAnchorKey = anchor.key;
+	const originalAnchorOffset = anchor.offset;
+	const originalAnchorType = anchor.type;
+	if (moveToStart) {
+		const start = $getStartOfCodeInLine(focusLineNode, focus.offset);
+		if (start !== null) {
+			const { node, offset } = start;
+			if ($isLineBreakNode(node)) node.selectNext(0, 0);
+			else selection.setTextNodeRange(node, offset, node, offset);
+		} else focusLineNode.getParentOrThrow().selectStart();
+	} else $getEndOfCodeInLine(focusLineNode).select();
+	if (event.shiftKey) selection.anchor.set(originalAnchorKey, originalAnchorOffset, originalAnchorType);
+	event.preventDefault();
+	event.stopPropagation();
+	return true;
+}
+/**
+* @internal
+* Register the keyboard and command handlers that drive code-block
+* indentation: Tab / Shift+Tab, INDENT/OUTDENT_CONTENT_COMMAND,
+* INSERT_TAB_COMMAND, alt+arrow line shifting, and Home/End movement.
+*
+* Both `@lexical/code-shiki` and `@lexical/code-prism` use this via
+* {@link CodeIndentExtension}; callers using `registerCodeHighlighting`
+* will implicitly call this with tabSize of `undefined`.
+*
+* @param editor The editor to register on.
+* @param tabSize When set, OUTDENT_CONTENT_COMMAND (Shift+Tab) also strips
+*   up to that many leading spaces from a code line. See
+*   {@link $outdentLeadingSpaces}.
+*/
+function registerCodeIndentation(editor, tabSize) {
+	return mergeRegister(editor.registerCommand(KEY_TAB_COMMAND, (event) => {
+		const command = $handleTab(event.shiftKey);
+		if (command === null) return false;
+		event.preventDefault();
+		editor.dispatchCommand(command, void 0);
+		return true;
+	}, COMMAND_PRIORITY_LOW), editor.registerCommand(INSERT_TAB_COMMAND, () => {
+		if (!$isSelectionInCode($getSelection())) return false;
+		$insertNodes([$createTabNode()]);
+		return true;
+	}, COMMAND_PRIORITY_LOW), editor.registerCommand(INDENT_CONTENT_COMMAND, () => $handleMultilineIndent(INDENT_CONTENT_COMMAND), COMMAND_PRIORITY_LOW), editor.registerCommand(OUTDENT_CONTENT_COMMAND, () => $handleMultilineIndent(OUTDENT_CONTENT_COMMAND, tabSize), COMMAND_PRIORITY_LOW), editor.registerCommand(KEY_ARROW_UP_COMMAND, (event) => {
+		const selection = $getSelection();
+		if (!$isRangeSelection(selection)) return false;
+		const { anchor } = selection;
+		const anchorNode = anchor.getNode();
+		if (!$isSelectionInCode(selection)) return false;
+		if (selection.isCollapsed() && anchor.offset === 0 && anchorNode.getPreviousSibling() === null && $isCodeNode(anchorNode.getParentOrThrow())) {
+			event.preventDefault();
+			return true;
+		}
+		return $handleShiftLines(KEY_ARROW_UP_COMMAND, event);
+	}, COMMAND_PRIORITY_LOW), editor.registerCommand(KEY_ARROW_DOWN_COMMAND, (event) => {
+		const selection = $getSelection();
+		if (!$isRangeSelection(selection)) return false;
+		const { anchor } = selection;
+		const anchorNode = anchor.getNode();
+		if (!$isSelectionInCode(selection)) return false;
+		if (selection.isCollapsed() && anchor.offset === anchorNode.getTextContentSize() && anchorNode.getNextSibling() === null && $isCodeNode(anchorNode.getParentOrThrow())) {
+			event.preventDefault();
+			return true;
+		}
+		return $handleShiftLines(KEY_ARROW_DOWN_COMMAND, event);
+	}, COMMAND_PRIORITY_LOW), editor.registerCommand(MOVE_TO_START, (event) => $handleMoveTo(MOVE_TO_START, event), COMMAND_PRIORITY_LOW), editor.registerCommand(MOVE_TO_END, (event) => $handleMoveTo(MOVE_TO_END, event), COMMAND_PRIORITY_LOW));
+}
+/**
+* Adds keyboard-driven indentation to code blocks (Tab / Shift+Tab,
+* alt+arrow line shifts, Home/End within a line). Both
+* {@link "@lexical/code-shiki".CodeShikiExtension} and
+* {@link "@lexical/code-prism".CodePrismExtension} declare this as a
+* dependency, so it is activated automatically alongside either
+* highlighter.
+*
+* Code blocks without syntax highlighting can use this extension on its
+* own.
+*/
+const CodeIndentExtension = defineExtension({
+	build: (editor, config) => namedSignals(config),
+	config: safeCast({
+		disabled: false,
+		tabSize: void 0
+	}),
+	dependencies: [CodeExtension],
+	name: "@lexical/code-indent",
+	register: (editor, config, state) => {
+		const stores = state.getOutput();
+		return effect(() => {
+			if (stores.disabled.value) return;
+			return registerCodeIndentation(editor, stores.tabSize.value);
+		});
+	}
+});
+//#endregion
+export { $createCodeHighlightNode, $createCodeNode, $getCodeLineDirection, $getEndOfCodeInLine, $getFirstCodeNodeOfLine, $getLastCodeNodeOfLine, $getStartOfCodeInLine, $isCodeHighlightNode, $isCodeNode, $outdentLeadingSpaces, $plainifyCodeContent, CodeExtension, CodeHighlightNode, CodeImportExtension, CodeImportRules, CodeIndentExtension, CodeNode, DEFAULT_CODE_LANGUAGE, getDefaultCodeLanguage, registerCodeIndentation };