@cgi-learning-hub/ui 1.14.0 → 1.15.0

package/dist/tiptap/index.es.js

@@ -0,0 +1,2843 @@
+import { H as IconButton, It as Tooltip, Lt as Typography, Nt as ToggleButton, W as InputBase, Zt as DeleteRounded_default, et as Menu, hn as clsx, j as Divider, ln as SvgIcon_default, mt as Stack, ot as Popover, tt as MenuItem, u as Badge } from "../src-jE7nLe9k.js";
+import { Fragment, forwardRef, useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { styled } from "@mui/material/styles";
+import { createSvgIcon } from "@mui/material/utils";
+import { AllSelection, NodeSelection, TextSelection } from "@tiptap/pm/state";
+import { useCurrentEditor, useEditorState } from "@tiptap/react";
+import "@tiptap/pm/tables";
+//#region src/tiptap/components/icons/text-snippet-icon.tsx
+var TextSnippetIcon = createSvgIcon(/* @__PURE__ */ jsx("path", { d: "M14.17,5L19,9.83V19H5V5L14.17,5L14.17,5 M14.17,3H5C3.9,3,3,3.9,3,5v14c0,1.1,0.9,2,2,2h14c1.1,0,2-0.9,2-2V9.83 c0-0.53-0.21-1.04-0.59-1.41l-4.83-4.83C15.21,3.21,14.7,3,14.17,3L14.17,3z M7,15h10v2H7V15z M7,11h10v2H7V11z M7,7h7v2H7V7z" }), "TextSnippet");
+//#endregion
+//#region src/tiptap/hooks/use-tiptap-editor.ts
+function getActivePageEditor(editor) {
+	const pages = editor.storage.pages;
+	if (!pages || !("activeEditor" in pages)) return null;
+	return pages.activeEditor ?? null;
+}
+function useTiptapEditor(providedEditor) {
+	const { editor: coreEditor } = useCurrentEditor();
+	const mainEditor = providedEditor ?? coreEditor;
+	const [storageEditor, setStorageEditor] = useState(null);
+	useEffect(() => {
+		if (!mainEditor) {
+			setStorageEditor(null);
+			return;
+		}
+		const updateHandler = () => setStorageEditor(getActivePageEditor(mainEditor));
+		updateHandler();
+		mainEditor.on("update", updateHandler);
+		mainEditor.on("selectionUpdate", updateHandler);
+		return () => {
+			mainEditor.off("update", updateHandler);
+			mainEditor.off("selectionUpdate", updateHandler);
+		};
+	}, [mainEditor]);
+	useEffect(() => {
+		if (!storageEditor) return;
+		const handleDestroy = () => setStorageEditor(null);
+		storageEditor.on("destroy", handleDestroy);
+		return () => {
+			storageEditor.off("destroy", handleDestroy);
+		};
+	}, [storageEditor]);
+	return useEditorState({
+		editor: storageEditor ?? mainEditor,
+		selector(context) {
+			if (!context.editor) return {
+				editor: null,
+				editorState: void 0,
+				canCommand: void 0
+			};
+			return {
+				editor: context.editor,
+				editorState: context.editor.state,
+				canCommand: context.editor.can
+			};
+		}
+	}) ?? { editor: null };
+}
+//#endregion
+//#region src/tiptap/lib/tiptap-utils.ts
+var MAC_SYMBOLS = {
+	mod: "⌘",
+	command: "⌘",
+	meta: "⌘",
+	ctrl: "⌃",
+	control: "⌃",
+	alt: "⌥",
+	option: "⌥",
+	shift: "⇧",
+	backspace: "Del",
+	delete: "⌦",
+	enter: "⏎",
+	escape: "⎋",
+	capslock: "⇪"
+};
+function cn(...inputs) {
+	return clsx(inputs);
+}
+/**
+* Determines if the current platform is macOS
+* @returns boolean indicating if the current platform is Mac
+*/
+function isMac() {
+	return typeof navigator !== "undefined" && navigator.platform.toLowerCase().includes("mac");
+}
+/**
+* Formats a shortcut key based on the platform (Mac or non-Mac)
+* @param key - The key to format (e.g., "ctrl", "alt", "shift")
+* @param isMac - Boolean indicating if the platform is Mac
+* @param capitalize - Whether to capitalize the key (default: true)
+* @returns Formatted shortcut key symbol
+*/
+var formatShortcutKey = (key, isMac, capitalize = true) => {
+	if (isMac) return MAC_SYMBOLS[key.toLowerCase()] || (capitalize ? key.toUpperCase() : key);
+	return capitalize ? key.charAt(0).toUpperCase() + key.slice(1) : key;
+};
+/**
+* Parses a shortcut key string into an array of formatted key symbols
+* @param shortcutKeys - The string of shortcut keys (e.g., "ctrl-alt-shift")
+* @param delimiter - The delimiter used to split the keys (default: "-")
+* @param capitalize - Whether to capitalize the keys (default: true)
+* @returns Array of formatted shortcut key symbols
+*/
+var parseShortcutKeys = (props) => {
+	const { shortcutKeys, delimiter = "+", capitalize = true } = props;
+	if (!shortcutKeys) return [];
+	return shortcutKeys.split(delimiter).map((key) => key.trim()).map((key) => formatShortcutKey(key, isMac(), capitalize));
+};
+/**
+* Checks if a mark exists in the editor schema
+* @param markName - The name of the mark to check
+* @param editor - The editor instance
+* @returns boolean indicating if the mark exists in the schema
+*/
+var isMarkInSchema = (markName, editor) => {
+	if (!editor?.schema) return false;
+	return editor.schema.spec.marks.get(markName) !== void 0;
+};
+/**
+* Checks if a node exists in the editor schema
+* @param nodeName - The name of the node to check
+* @param editor - The editor instance
+* @returns boolean indicating if the node exists in the schema
+*/
+var isNodeInSchema = (nodeName, editor) => {
+	if (!editor?.schema) return false;
+	return editor.schema.spec.nodes.get(nodeName) !== void 0;
+};
+/**
+* Checks if a value is a valid number (not null, undefined, or NaN)
+* @param value - The value to check
+* @returns boolean indicating if the value is a valid number
+*/
+function isValidPosition(pos) {
+	return typeof pos === "number" && pos >= 0;
+}
+/**
+* Checks if one or more extensions are registered in the Tiptap editor.
+* @param editor - The Tiptap editor instance
+* @param extensionNames - A single extension name or an array of names to check
+* @returns True if at least one of the extensions is available, false otherwise
+*/
+var warnedMissingExtensions = /* @__PURE__ */ new Set();
+function isExtensionAvailable(editor, extensionNames) {
+	if (!editor || editor.isDestroyed) return false;
+	const names = Array.isArray(extensionNames) ? extensionNames : [extensionNames];
+	const extensions = editor.extensionManager?.extensions;
+	if (!extensions) return false;
+	const found = names.some((name) => extensions.some((ext) => ext.name === name));
+	if (!found) {
+		const key = names.join(", ");
+		if (!warnedMissingExtensions.has(key)) {
+			warnedMissingExtensions.add(key);
+			console.warn(`None of the extensions [${key}] were found in the editor schema. Ensure they are included in the editor configuration.`);
+		}
+	}
+	return found;
+}
+/**
+* Finds a node at the specified position with error handling
+* @param editor The Tiptap editor instance
+* @param position The position in the document to find the node
+* @returns The node at the specified position, or null if not found
+*/
+function findNodeAtPosition(editor, position) {
+	try {
+		const node = editor.state.doc.nodeAt(position);
+		if (!node) {
+			console.warn(`No node found at position ${position}`);
+			return null;
+		}
+		return node;
+	} catch (error) {
+		console.error(`Error getting node at position ${position}:`, error);
+		return null;
+	}
+}
+/**
+* Finds the position and instance of a node in the document
+* @param props Object containing editor, node (optional), and nodePos (optional)
+* @param props.editor The Tiptap editor instance
+* @param props.node The node to find (optional if nodePos is provided)
+* @param props.nodePos The position of the node to find (optional if node is provided)
+* @returns An object with the position and node, or null if not found
+*/
+function findNodePosition(props) {
+	const { editor, node, nodePos } = props;
+	if (!editor || !editor.state?.doc) return null;
+	const hasValidNode = node !== void 0 && node !== null;
+	const hasValidPos = isValidPosition(nodePos);
+	if (!hasValidNode && !hasValidPos) return null;
+	if (hasValidNode) {
+		let foundPos = -1;
+		let foundNode = null;
+		editor.state.doc.descendants((currentNode, pos) => {
+			if (currentNode === node) {
+				foundPos = pos;
+				foundNode = currentNode;
+				return false;
+			}
+			return true;
+		});
+		if (foundPos !== -1 && foundNode !== null) return {
+			pos: foundPos,
+			node: foundNode
+		};
+	}
+	if (hasValidPos) {
+		const nodeAtPos = findNodeAtPosition(editor, nodePos);
+		if (nodeAtPos) return {
+			pos: nodePos,
+			node: nodeAtPos
+		};
+	}
+	return null;
+}
+/**
+* Determines whether the current selection contains a node whose type matches
+* any of the provided node type names.
+* @param editor Tiptap editor instance
+* @param nodeTypeNames List of node type names to match against
+* @param checkAncestorNodes Whether to check ancestor node types up the depth chain
+*/
+function isNodeTypeSelected(editor, nodeTypeNames = [], checkAncestorNodes = false) {
+	if (!editor || !editor.state.selection) return false;
+	const { selection } = editor.state;
+	if (selection.empty) return false;
+	if (selection instanceof NodeSelection) {
+		const selectedNode = selection.node;
+		return selectedNode ? nodeTypeNames.includes(selectedNode.type.name) : false;
+	}
+	if (checkAncestorNodes) {
+		const { $from } = selection;
+		for (let depth = $from.depth; depth > 0; depth--) {
+			const ancestorNode = $from.node(depth);
+			if (nodeTypeNames.includes(ancestorNode.type.name)) return true;
+		}
+	}
+	return false;
+}
+/**
+* Check whether the current selection is fully within nodes
+* whose type names are in the provided `types` list.
+*
+* - NodeSelection → checks the selected node.
+* - Text/AllSelection → ensures all textblocks within [from, to) are allowed.
+*/
+function selectionWithinConvertibleTypes(editor, types = []) {
+	if (!editor || types.length === 0) return false;
+	const { state } = editor;
+	const { selection } = state;
+	const allowed = new Set(types);
+	if (selection instanceof NodeSelection) {
+		const nodeType = selection.node?.type?.name;
+		return !!nodeType && allowed.has(nodeType);
+	}
+	if (selection instanceof TextSelection || selection instanceof AllSelection) {
+		let valid = true;
+		state.doc.nodesBetween(selection.from, selection.to, (node) => {
+			if (node.isTextblock && !allowed.has(node.type.name)) {
+				valid = false;
+				return false;
+			}
+			return valid;
+		});
+		return valid;
+	}
+	return false;
+}
+var ATTR_WHITESPACE = /[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g;
+function isAllowedUri(uri, protocols) {
+	const allowedProtocols = [
+		"http",
+		"https",
+		"ftp",
+		"ftps",
+		"mailto",
+		"tel",
+		"callto",
+		"sms",
+		"cid",
+		"xmpp"
+	];
+	if (protocols) protocols.forEach((protocol) => {
+		const nextProtocol = typeof protocol === "string" ? protocol : protocol.scheme;
+		if (nextProtocol) allowedProtocols.push(nextProtocol);
+	});
+	return !uri || uri.replace(ATTR_WHITESPACE, "").match(new RegExp(`^(?:(?:${allowedProtocols.join("|")}):|[^a-z]|[a-z0-9+.\-]+(?:[^a-z+.\-:]|$))`, "i"));
+}
+function sanitizeUrl(inputUrl, baseUrl, protocols) {
+	try {
+		const url = new URL(inputUrl, baseUrl);
+		if (isAllowedUri(url.href, protocols)) return url.href;
+	} catch {}
+	return "#";
+}
+function getSelectedBlockNodes(editor) {
+	const { doc } = editor.state;
+	const { from, to } = editor.state.selection;
+	const blocks = [];
+	const seen = /* @__PURE__ */ new Set();
+	doc.nodesBetween(from, to, (node, pos) => {
+		if (!node.isBlock) return;
+		if (!seen.has(pos)) {
+			seen.add(pos);
+			blocks.push(node);
+		}
+		return false;
+	});
+	return blocks;
+}
+//#endregion
+//#region src/tiptap/components/ui/blockquote-button/use-blockquote.ts
+var BLOCKQUOTE_SHORTCUT_KEY = "mod+shift+b";
+/**
+* Checks if blockquote can be toggled in the current editor state
+*/
+function canToggleBlockquote(editor, turnInto = true) {
+	if (!editor || !editor.isEditable) return false;
+	if (!isNodeInSchema("blockquote", editor) || isNodeTypeSelected(editor, ["image"])) return false;
+	if (!turnInto) return editor.can().toggleWrap("blockquote");
+	if (!selectionWithinConvertibleTypes(editor, [
+		"paragraph",
+		"heading",
+		"bulletList",
+		"orderedList",
+		"taskList",
+		"blockquote",
+		"codeBlock"
+	])) return false;
+	return editor.can().toggleWrap("blockquote") || editor.can().clearNodes();
+}
+/**
+* Toggles blockquote formatting for a specific node or the current selection
+*/
+function toggleBlockquote(editor) {
+	if (!editor || !editor.isEditable) return false;
+	if (!canToggleBlockquote(editor)) return false;
+	try {
+		const view = editor.view;
+		let state = view.state;
+		let tr = state.tr;
+		const blocks = getSelectedBlockNodes(editor);
+		const isPossibleToTurnInto = selectionWithinConvertibleTypes(editor, [
+			"paragraph",
+			"heading",
+			"bulletList",
+			"orderedList",
+			"taskList",
+			"blockquote",
+			"codeBlock"
+		]) && blocks.length === 1;
+		if ((state.selection.empty || state.selection instanceof TextSelection) && isPossibleToTurnInto) {
+			const pos = findNodePosition({
+				editor,
+				node: state.selection.$anchor.node(1)
+			})?.pos;
+			if (!isValidPosition(pos)) return false;
+			tr = tr.setSelection(NodeSelection.create(state.doc, pos));
+			view.dispatch(tr);
+			state = view.state;
+		}
+		const selection = state.selection;
+		let chain = editor.chain().focus();
+		if (selection instanceof NodeSelection) {
+			const firstChild = selection.node.firstChild?.firstChild;
+			const lastChild = selection.node.lastChild?.lastChild;
+			const from = firstChild ? selection.from + firstChild.nodeSize : selection.from + 1;
+			const to = lastChild ? selection.to - lastChild.nodeSize : selection.to - 1;
+			const resolvedFrom = state.doc.resolve(from);
+			const resolvedTo = state.doc.resolve(to);
+			chain = chain.setTextSelection(TextSelection.between(resolvedFrom, resolvedTo)).clearNodes();
+		}
+		(editor.isActive("blockquote") ? chain.lift("blockquote") : chain.wrapIn("blockquote")).run();
+		editor.chain().focus().selectTextblockEnd().run();
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Determines if the blockquote button should be shown
+*/
+function shouldShowButton$5(props) {
+	const { editor, hideWhenUnavailable } = props;
+	if (!editor) return false;
+	if (!hideWhenUnavailable) return true;
+	if (!editor.isEditable) return false;
+	if (!isNodeInSchema("blockquote", editor)) return false;
+	if (!editor.isActive("code")) return canToggleBlockquote(editor);
+	return true;
+}
+/**
+* Custom hook that provides blockquote functionality for Tiptap editor
+*
+* @example
+* ```tsx
+* // Simple usage - no params needed
+* function MySimpleBlockquoteButton() {
+*   const { isVisible, handleToggle, isActive } = useBlockquote()
+*
+*   if (!isVisible) return null
+*
+*   return <button onClick={handleToggle}>Blockquote</button>
+* }
+*
+* // Advanced usage with configuration
+* function MyAdvancedBlockquoteButton() {
+*   const { isVisible, handleToggle, label, isActive } = useBlockquote({
+*     editor: myEditor,
+*     hideWhenUnavailable: true,
+*     onToggled: () => console.log('Blockquote toggled!')
+*   })
+*
+*   if (!isVisible) return null
+*
+*   return (
+*     <MyButton
+*       onClick={handleToggle}
+*       aria-label={label}
+*       aria-pressed={isActive}
+*     >
+*       Toggle Blockquote
+*     </MyButton>
+*   )
+* }
+* ```
+*/
+function useBlockquote(config) {
+	const { editor: providedEditor, hideWhenUnavailable = false, onToggled } = config || {};
+	const { editor } = useTiptapEditor(providedEditor);
+	const [isVisible, setIsVisible] = useState(true);
+	const canToggle = canToggleBlockquote(editor);
+	const isActive = editor?.isActive("blockquote") || false;
+	useEffect(() => {
+		if (!editor) return;
+		const handleSelectionUpdate = () => {
+			setIsVisible(shouldShowButton$5({
+				editor,
+				hideWhenUnavailable
+			}));
+		};
+		handleSelectionUpdate();
+		editor.on("selectionUpdate", handleSelectionUpdate);
+		return () => {
+			editor.off("selectionUpdate", handleSelectionUpdate);
+		};
+	}, [editor, hideWhenUnavailable]);
+	return {
+		isVisible,
+		isActive,
+		handleToggle: useCallback(() => {
+			if (!editor) return false;
+			const success = toggleBlockquote(editor);
+			if (success) onToggled?.();
+			return success;
+		}, [editor, onToggled]),
+		canToggle,
+		label: "Citation en bloc",
+		shortcutKeys: BLOCKQUOTE_SHORTCUT_KEY,
+		Icon: TextSnippetIcon
+	};
+}
+//#endregion
+//#region src/tiptap/components/ui-primitive/button/button.tsx
+var ShortcutDisplay = ({ shortcuts }) => {
+	if (shortcuts.length === 0) return null;
+	return /* @__PURE__ */ jsx("div", { children: shortcuts.map((key, index) => /* @__PURE__ */ jsxs(Fragment, { children: [index > 0 && /* @__PURE__ */ jsx("kbd", { children: "+" }), /* @__PURE__ */ jsx("kbd", { children: key })] }, index)) });
+};
+var Button = forwardRef(({ className, children, tooltip, showTooltip = true, shortcutKeys, ...props }, ref) => {
+	const shortcuts = useMemo(() => parseShortcutKeys({ shortcutKeys }), [shortcutKeys]);
+	if (!tooltip || !showTooltip) return /* @__PURE__ */ jsx(ToggleButton, {
+		size: "small",
+		color: "primary",
+		ref,
+		sx: {
+			border: "none",
+			"&:disabled": { border: "none" }
+		},
+		...props,
+		children
+	});
+	return /* @__PURE__ */ jsx(Tooltip, {
+		enterDelay: 200,
+		title: /* @__PURE__ */ jsxs(Fragment$1, { children: [tooltip, /* @__PURE__ */ jsx(ShortcutDisplay, { shortcuts })] }),
+		slotProps: { popper: { modifiers: [{
+			name: "offset",
+			options: { offset: [0, -8] }
+		}] } },
+		children: /* @__PURE__ */ jsx(ToggleButton, {
+			size: "small",
+			color: "primary",
+			ref,
+			sx: {
+				border: "none",
+				"&:disabled": { border: "none" }
+			},
+			...props,
+			children
+		})
+	});
+});
+Button.displayName = "Button";
+//#endregion
+//#region src/tiptap/components/ui/blockquote-button/blockquote-button.tsx
+function BlockquoteShortcutBadge({ shortcutKeys = BLOCKQUOTE_SHORTCUT_KEY }) {
+	return /* @__PURE__ */ jsx(Badge, { children: parseShortcutKeys({ shortcutKeys }) });
+}
+/**
+* Button component for toggling blockquote in a Tiptap editor.
+*
+* For custom button implementations, use the `useBlockquote` hook instead.
+*/
+var BlockquoteButton = forwardRef(({ editor: providedEditor, text, hideWhenUnavailable = false, onToggled, showShortcut = false, onClick, children, ...buttonProps }, ref) => {
+	const { editor } = useTiptapEditor(providedEditor);
+	const { isVisible, canToggle, isActive, handleToggle, label, shortcutKeys, Icon } = useBlockquote({
+		editor,
+		hideWhenUnavailable,
+		onToggled
+	});
+	const handleClick = useCallback((event) => {
+		onClick?.(event, !isActive);
+		if (event.defaultPrevented) return;
+		handleToggle();
+	}, [handleToggle, onClick]);
+	if (!isVisible) return null;
+	return /* @__PURE__ */ jsx(Button, {
+		value: "blockquote",
+		type: "button",
+		selected: isActive,
+		role: "button",
+		tabIndex: -1,
+		disabled: !canToggle,
+		"data-disabled": !canToggle,
+		"aria-label": label,
+		tooltip: label,
+		onClick: handleClick,
+		...buttonProps,
+		ref,
+		children: children ?? /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			/* @__PURE__ */ jsx(Icon, { fontSize: "small" }),
+			text && /* @__PURE__ */ jsx("span", {
+				className: "tiptap-button-text",
+				children: text
+			}),
+			showShortcut && /* @__PURE__ */ jsx(BlockquoteShortcutBadge, { shortcutKeys })
+		] })
+	});
+});
+BlockquoteButton.displayName = "BlockquoteButton";
+//#endregion
+//#region src/tiptap/components/icons/integration-instructions-icon.tsx
+var IntegrationInstructionIcon = createSvgIcon(/* @__PURE__ */ jsxs("g", { children: [
+	/* @__PURE__ */ jsx("rect", {
+		fill: "none",
+		height: "24",
+		width: "24"
+	}),
+	/* @__PURE__ */ jsx("circle", {
+		cx: "12",
+		cy: "3.5",
+		fill: "none",
+		r: ".75"
+	}),
+	/* @__PURE__ */ jsx("circle", {
+		cx: "12",
+		cy: "3.5",
+		fill: "none",
+		r: ".75"
+	}),
+	/* @__PURE__ */ jsx("polygon", {
+		fill: "none",
+		points: "5,15 5,16 5,19 19,19 19,16 19,15 19,5 5,5"
+	}),
+	/* @__PURE__ */ jsxs("g", { children: [
+		/* @__PURE__ */ jsx("polygon", { points: "11,14.17 8.83,12 11,9.83 9.59,8.41 6,12 9.59,15.59" }),
+		/* @__PURE__ */ jsx("polygon", { points: "14.41,15.59 18,12 14.41,8.41 13,9.83 15.17,12 13,14.17" }),
+		/* @__PURE__ */ jsx("path", { d: "M19,3h-4.18C14.4,1.84,13.3,1,12,1S9.6,1.84,9.18,3H5C4.86,3,4.73,3.01,4.6,3.04C4.21,3.12,3.86,3.32,3.59,3.59 c-0.18,0.18-0.33,0.4-0.43,0.64C3.06,4.46,3,4.72,3,5v10v1v3c0,0.27,0.06,0.54,0.16,0.78c0.1,0.24,0.25,0.45,0.43,0.64 c0.27,0.27,0.62,0.47,1.01,0.55C4.73,20.99,4.86,21,5,21h14c1.1,0,2-0.9,2-2v-3v-1V5C21,3.9,20.1,3,19,3z M12,2.75 c0.41,0,0.75,0.34,0.75,0.75S12.41,4.25,12,4.25s-0.75-0.34-0.75-0.75S11.59,2.75,12,2.75z M19,15v1v3H5v-3v-1V5h14V15z" })
+	] })
+] }), "IntegrationInstruction");
+//#endregion
+//#region src/tiptap/components/ui/code-block-button/use-code-block.ts
+var CODE_BLOCK_SHORTCUT_KEY = "mod+alt+c";
+/**
+* Checks if code block can be toggled in the current editor state
+*/
+function canToggle$1(editor, turnInto = true) {
+	if (!editor || !editor.isEditable) return false;
+	if (!isNodeInSchema("codeBlock", editor) || isNodeTypeSelected(editor, ["image"])) return false;
+	if (!turnInto) return editor.can().toggleNode("codeBlock", "paragraph");
+	if (!selectionWithinConvertibleTypes(editor, [
+		"paragraph",
+		"heading",
+		"bulletList",
+		"orderedList",
+		"taskList",
+		"blockquote",
+		"codeBlock"
+	])) return false;
+	return editor.can().toggleNode("codeBlock", "paragraph") || editor.can().clearNodes();
+}
+/**
+* Toggles code block in the editor
+*/
+function toggleCodeBlock(editor) {
+	if (!editor || !editor.isEditable) return false;
+	if (!canToggle$1(editor)) return false;
+	try {
+		const view = editor.view;
+		let state = view.state;
+		let tr = state.tr;
+		const blocks = getSelectedBlockNodes(editor);
+		const isPossibleToTurnInto = selectionWithinConvertibleTypes(editor, [
+			"paragraph",
+			"heading",
+			"bulletList",
+			"orderedList",
+			"taskList",
+			"blockquote",
+			"codeBlock"
+		]) && blocks.length === 1;
+		if ((state.selection.empty || state.selection instanceof TextSelection) && isPossibleToTurnInto) {
+			const pos = findNodePosition({
+				editor,
+				node: state.selection.$anchor.node(1)
+			})?.pos;
+			if (!isValidPosition(pos)) return false;
+			tr = tr.setSelection(NodeSelection.create(state.doc, pos));
+			view.dispatch(tr);
+			state = view.state;
+		}
+		const selection = state.selection;
+		let chain = editor.chain().focus();
+		if (selection instanceof NodeSelection) {
+			const firstChild = selection.node.firstChild?.firstChild;
+			const lastChild = selection.node.lastChild?.lastChild;
+			const from = firstChild ? selection.from + firstChild.nodeSize : selection.from + 1;
+			const to = lastChild ? selection.to - lastChild.nodeSize : selection.to - 1;
+			const resolvedFrom = state.doc.resolve(from);
+			const resolvedTo = state.doc.resolve(to);
+			chain = chain.setTextSelection(TextSelection.between(resolvedFrom, resolvedTo)).clearNodes();
+		}
+		(editor.isActive("codeBlock") ? chain.setNode("paragraph") : chain.toggleNode("codeBlock", "paragraph")).run();
+		editor.chain().focus().selectTextblockEnd().run();
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Determines if the code block button should be shown
+*/
+function shouldShowButton$4(props) {
+	const { editor, hideWhenUnavailable } = props;
+	if (!editor) return false;
+	if (!hideWhenUnavailable) return true;
+	if (!editor.isEditable) return false;
+	if (!isNodeInSchema("codeBlock", editor)) return false;
+	if (!editor.isActive("code")) return canToggle$1(editor);
+	return true;
+}
+/**
+* Custom hook that provides code block functionality for Tiptap editor
+*
+* @example
+* ```tsx
+* // Simple usage - no params needed
+* function MySimpleCodeBlockButton() {
+*   const { isVisible, isActive, handleToggle } = useCodeBlock()
+*
+*   if (!isVisible) return null
+*
+*   return (
+*     <button
+*       onClick={handleToggle}
+*       aria-pressed={isActive}
+*     >
+*       Code Block
+*     </button>
+*   )
+* }
+*
+* // Advanced usage with configuration
+* function MyAdvancedCodeBlockButton() {
+*   const { isVisible, isActive, handleToggle, label } = useCodeBlock({
+*     editor: myEditor,
+*     hideWhenUnavailable: true,
+*     onToggled: (isActive) => console.log('Code block toggled:', isActive)
+*   })
+*
+*   if (!isVisible) return null
+*
+*   return (
+*     <MyButton
+*       onClick={handleToggle}
+*       aria-label={label}
+*       aria-pressed={isActive}
+*     >
+*       Toggle Code Block
+*     </MyButton>
+*   )
+* }
+* ```
+*/
+function useCodeBlock(config) {
+	const { editor: providedEditor, hideWhenUnavailable = false, onToggled } = config || {};
+	const { editor } = useTiptapEditor(providedEditor);
+	const [isVisible, setIsVisible] = useState(true);
+	const canToggleState = canToggle$1(editor);
+	const isActive = editor?.isActive("codeBlock") || false;
+	useEffect(() => {
+		if (!editor) return;
+		const handleSelectionUpdate = () => {
+			setIsVisible(shouldShowButton$4({
+				editor,
+				hideWhenUnavailable
+			}));
+		};
+		handleSelectionUpdate();
+		editor.on("selectionUpdate", handleSelectionUpdate);
+		return () => {
+			editor.off("selectionUpdate", handleSelectionUpdate);
+		};
+	}, [editor, hideWhenUnavailable]);
+	return {
+		isVisible,
+		isActive,
+		handleToggle: useCallback(() => {
+			if (!editor) return false;
+			const success = toggleCodeBlock(editor);
+			if (success) onToggled?.();
+			return success;
+		}, [editor, onToggled]),
+		canToggle: canToggleState,
+		label: "Bloc de code",
+		shortcutKeys: CODE_BLOCK_SHORTCUT_KEY,
+		Icon: IntegrationInstructionIcon
+	};
+}
+//#endregion
+//#region src/tiptap/components/ui/code-block-button/code-block-button.tsx
+function CodeBlockShortcutBadge({ shortcutKeys = CODE_BLOCK_SHORTCUT_KEY }) {
+	return /* @__PURE__ */ jsx(Badge, { children: parseShortcutKeys({ shortcutKeys }) });
+}
+/**
+* Button component for toggling code block in a Tiptap editor.
+*
+* For custom button implementations, use the `useCodeBlock` hook instead.
+*/
+var CodeBlockButton = forwardRef(({ editor: providedEditor, text, hideWhenUnavailable = false, onToggled, showShortcut = false, onClick, children, ...buttonProps }, ref) => {
+	const { editor } = useTiptapEditor(providedEditor);
+	const { isVisible, canToggle, isActive, handleToggle, label, shortcutKeys, Icon } = useCodeBlock({
+		editor,
+		hideWhenUnavailable,
+		onToggled
+	});
+	const handleClick = useCallback((event) => {
+		onClick?.(event, !isActive);
+		if (event.defaultPrevented) return;
+		handleToggle();
+	}, [handleToggle, onClick]);
+	if (!isVisible) return null;
+	return /* @__PURE__ */ jsx(Button, {
+		value: "codeBlock",
+		type: "button",
+		selected: isActive,
+		role: "button",
+		disabled: !canToggle,
+		"data-disabled": !canToggle,
+		tabIndex: -1,
+		"aria-label": label,
+		tooltip: label,
+		onClick: handleClick,
+		...buttonProps,
+		ref,
+		children: children ?? /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			/* @__PURE__ */ jsx(Icon, { fontSize: "small" }),
+			text && /* @__PURE__ */ jsx("span", {
+				className: "tiptap-button-text",
+				children: text
+			}),
+			showShortcut && /* @__PURE__ */ jsx(CodeBlockShortcutBadge, { shortcutKeys })
+		] })
+	});
+});
+CodeBlockButton.displayName = "CodeBlockButton";
+//#endregion
+//#region ../../node_modules/.pnpm/@mui+icons-material@9.4.0_@mui+material@9.4.0_@emotion+react@11.14.0_@types+react@19.2._02cb1dd638d2ccdea7d16c50ea4ea174/node_modules/@mui/icons-material/ExpandMoreRounded.mjs
+var ExpandMoreRounded_default = SvgIcon_default(/*#__PURE__*/ jsx("path", { d: "M15.88 9.29 12 13.17 8.12 9.29a.996.996 0 0 0-1.41 0c-.39.39-.39 1.02 0 1.41l4.59 4.59c.39.39 1.02.39 1.41 0l4.59-4.59c.39-.39.39-1.02 0-1.41-.39-.38-1.03-.39-1.42 0" }), "ExpandMoreRounded");
+//#endregion
+//#region src/tiptap/components/icons/heading-five-icon.tsx
+var HeadingFiveIcon = createSvgIcon(/* @__PURE__ */ jsxs("g", { children: [/* @__PURE__ */ jsx("path", {
+	d: "M5 6C5 5.44772 4.55228 5 4 5C3.44772 5 3 5.44772 3 6V18C3 18.5523 3.44772 19 4 19C4.55228 19 5 18.5523 5 18V13H11V18C11 18.5523 11.4477 19 12 19C12.5523 19 13 18.5523 13 18V6C13 5.44772 12.5523 5 12 5C11.4477 5 11 5.44772 11 6V11H5V6Z",
+	fill: "currentColor"
+}), /* @__PURE__ */ jsx("path", {
+	d: "M16 10C16 9.44772 16.4477 9 17 9H21C21.5523 9 22 9.44772 22 10C22 10.5523 21.5523 11 21 11H18V12H18.3C20.2754 12 22 13.4739 22 15.5C22 17.5261 20.2754 19 18.3 19C17.6457 19 17.0925 18.8643 16.5528 18.5944C16.0588 18.3474 15.8586 17.7468 16.1055 17.2528C16.3525 16.7588 16.9532 16.5586 17.4472 16.8056C17.7074 16.9357 17.9542 17 18.3 17C19.3246 17 20 16.2739 20 15.5C20 14.7261 19.3246 14 18.3 14H17C16.4477 14 16 13.5523 16 13L16 12.9928V10Z",
+	fill: "currentColor"
+})] }), "HeadingFiveIcon");
+//#endregion
+//#region src/tiptap/components/icons/heading-four-icon.tsx
+var HeadingFourIcon = createSvgIcon(/* @__PURE__ */ jsxs("g", { children: [/* @__PURE__ */ jsx("path", {
+	d: "M4 5C4.55228 5 5 5.44772 5 6V11H11V6C11 5.44772 11.4477 5 12 5C12.5523 5 13 5.44772 13 6V18C13 18.5523 12.5523 19 12 19C11.4477 19 11 18.5523 11 18V13H5V18C5 18.5523 4.55228 19 4 19C3.44772 19 3 18.5523 3 18V6C3 5.44772 3.44772 5 4 5Z",
+	fill: "currentColor"
+}), /* @__PURE__ */ jsx("path", {
+	d: "M17 9C17.5523 9 18 9.44772 18 10V13H20V10C20 9.44772 20.4477 9 21 9C21.5523 9 22 9.44772 22 10V18C22 18.5523 21.5523 19 21 19C20.4477 19 20 18.5523 20 18V15H17C16.4477 15 16 14.5523 16 14V10C16 9.44772 16.4477 9 17 9Z",
+	fill: "currentColor"
+})] }), "HeadingFour");
+//#endregion
+//#region src/tiptap/components/icons/heading-one-icon.tsx
+var HeadingOneIcon = createSvgIcon(/* @__PURE__ */ jsxs("g", { children: [/* @__PURE__ */ jsx("path", {
+	d: "M5 6C5 5.44772 4.55228 5 4 5C3.44772 5 3 5.44772 3 6V18C3 18.5523 3.44772 19 4 19C4.55228 19 5 18.5523 5 18V13H11V18C11 18.5523 11.4477 19 12 19C12.5523 19 13 18.5523 13 18V6C13 5.44772 12.5523 5 12 5C11.4477 5 11 5.44772 11 6V11H5V6Z",
+	fill: "currentColor"
+}), /* @__PURE__ */ jsx("path", {
+	d: "M21.0001 10C21.0001 9.63121 20.7971 9.29235 20.472 9.11833C20.1468 8.94431 19.7523 8.96338 19.4454 9.16795L16.4454 11.168C15.9859 11.4743 15.8617 12.0952 16.1681 12.5547C16.4744 13.0142 17.0953 13.1384 17.5548 12.8321L19.0001 11.8685V18C19.0001 18.5523 19.4478 19 20.0001 19C20.5524 19 21.0001 18.5523 21.0001 18V10Z",
+	fill: "currentColor"
+})] }), "HeadingOne");
+//#endregion
+//#region src/tiptap/components/icons/heading-six-icon.tsx
+var HeadingSixIcon = createSvgIcon(/* @__PURE__ */ jsxs("g", { children: [/* @__PURE__ */ jsx("path", {
+	d: "M5 6C5 5.44772 4.55228 5 4 5C3.44772 5 3 5.44772 3 6V18C3 18.5523 3.44772 19 4 19C4.55228 19 5 18.5523 5 18V13H11V18C11 18.5523 11.4477 19 12 19C12.5523 19 13 18.5523 13 18V6C13 5.44772 12.5523 5 12 5C11.4477 5 11 5.44772 11 6V11H5V6Z",
+	fill: "currentColor"
+}), /* @__PURE__ */ jsx("path", {
+	fillRule: "evenodd",
+	clipRule: "evenodd",
+	d: "M20.7071 9.29289C21.0976 9.68342 21.0976 10.3166 20.7071 10.7071C19.8392 11.575 19.2179 12.2949 18.7889 13.0073C18.8587 13.0025 18.929 13 19 13C20.6569 13 22 14.3431 22 16C22 17.6569 20.6569 19 19 19C17.3431 19 16 17.6569 16 16C16 14.6007 16.2837 13.4368 16.8676 12.3419C17.4384 11.2717 18.2728 10.3129 19.2929 9.29289C19.6834 8.90237 20.3166 8.90237 20.7071 9.29289ZM19 17C18.4477 17 18 16.5523 18 16C18 15.4477 18.4477 15 19 15C19.5523 15 20 15.4477 20 16C20 16.5523 19.5523 17 19 17Z",
+	fill: "currentColor"
+})] }), "HeadingSix");
+//#endregion
+//#region src/tiptap/components/icons/heading-three-icon.tsx
+var HeadingThreeIcon = createSvgIcon(/* @__PURE__ */ jsxs("g", { children: [
+	/* @__PURE__ */ jsx("path", {
+		d: "M4 5C4.55228 5 5 5.44772 5 6V11H11V6C11 5.44772 11.4477 5 12 5C12.5523 5 13 5.44772 13 6V18C13 18.5523 12.5523 19 12 19C11.4477 19 11 18.5523 11 18V13H5V18C5 18.5523 4.55228 19 4 19C3.44772 19 3 18.5523 3 18V6C3 5.44772 3.44772 5 4 5Z",
+		fill: "currentColor"
+	}),
+	/* @__PURE__ */ jsx("path", {
+		fillRule: "evenodd",
+		clipRule: "evenodd",
+		d: "M19.4608 11.2169C19.1135 11.0531 18.5876 11.0204 18.0069 11.3619C17.5309 11.642 16.918 11.4831 16.638 11.007C16.358 10.531 16.5169 9.91809 16.9929 9.63807C18.1123 8.97962 19.3364 8.94691 20.314 9.40808C21.2839 9.86558 21.9999 10.818 21.9999 12C21.9999 12.7957 21.6838 13.5587 21.1212 14.1213C20.5586 14.6839 19.7956 15 18.9999 15C18.4476 15 17.9999 14.5523 17.9999 14C17.9999 13.4477 18.4476 13 18.9999 13C19.2651 13 19.5195 12.8947 19.707 12.7071C19.8946 12.5196 19.9999 12.2652 19.9999 12C19.9999 11.6821 19.8159 11.3844 19.4608 11.2169Z",
+		fill: "currentColor"
+	}),
+	/* @__PURE__ */ jsx("path", {
+		fillRule: "evenodd",
+		clipRule: "evenodd",
+		d: "M18.0001 14C18.0001 13.4477 18.4478 13 19.0001 13C19.7957 13 20.5588 13.3161 21.1214 13.8787C21.684 14.4413 22.0001 15.2043 22.0001 16C22.0001 17.2853 21.2767 18.3971 20.1604 18.8994C19.0257 19.41 17.642 19.2315 16.4001 18.3C15.9582 17.9686 15.8687 17.3418 16.2001 16.9C16.5314 16.4582 17.1582 16.3686 17.6001 16.7C18.3581 17.2685 18.9744 17.24 19.3397 17.0756C19.7234 16.9029 20.0001 16.5147 20.0001 16C20.0001 15.7348 19.8947 15.4804 19.7072 15.2929C19.5196 15.1054 19.2653 15 19.0001 15C18.4478 15 18.0001 14.5523 18.0001 14Z",
+		fill: "currentColor"
+	})
+] }), "HeadingThree");
+//#endregion
+//#region src/tiptap/components/ui/heading-menu-item/use-heading.ts
+var headingIcons = {
+	1: HeadingOneIcon,
+	2: createSvgIcon(/* @__PURE__ */ jsxs("g", { children: [/* @__PURE__ */ jsx("path", {
+		d: "M5 6C5 5.44772 4.55228 5 4 5C3.44772 5 3 5.44772 3 6V18C3 18.5523 3.44772 19 4 19C4.55228 19 5 18.5523 5 18V13H11V18C11 18.5523 11.4477 19 12 19C12.5523 19 13 18.5523 13 18V6C13 5.44772 12.5523 5 12 5C11.4477 5 11 5.44772 11 6V11H5V6Z",
+		fill: "currentColor"
+	}), /* @__PURE__ */ jsx("path", {
+		d: "M22.0001 12C22.0001 10.7611 21.1663 9.79297 20.0663 9.42632C18.9547 9.05578 17.6171 9.28724 16.4001 10.2C15.9582 10.5314 15.8687 11.1582 16.2001 11.6C16.5314 12.0418 17.1582 12.1314 17.6001 11.8C18.383 11.2128 19.0455 11.1942 19.4338 11.3237C19.8339 11.457 20.0001 11.7389 20.0001 12C20.0001 12.4839 19.8554 12.7379 19.6537 12.9481C19.4275 13.1837 19.1378 13.363 18.7055 13.6307C18.6313 13.6767 18.553 13.7252 18.4701 13.777C17.9572 14.0975 17.3128 14.5261 16.8163 15.2087C16.3007 15.9177 16.0001 16.8183 16.0001 18C16.0001 18.5523 16.4478 19 17.0001 19H21.0001C21.5523 19 22.0001 18.5523 22.0001 18C22.0001 17.4477 21.5523 17 21.0001 17H18.131C18.21 16.742 18.3176 16.5448 18.4338 16.385C18.6873 16.0364 19.0429 15.7775 19.5301 15.473C19.5898 15.4357 19.6536 15.3966 19.7205 15.3556C20.139 15.0992 20.6783 14.7687 21.0964 14.3332C21.6447 13.7621 22.0001 13.0161 22.0001 12Z",
+		fill: "currentColor"
+	})] }), "HeadingTwo"),
+	3: HeadingThreeIcon,
+	4: HeadingFourIcon,
+	5: HeadingFiveIcon,
+	6: HeadingSixIcon
+};
+var HEADING_SHORTCUT_KEYS = {
+	1: "ctrl+alt+1",
+	2: "ctrl+alt+2",
+	3: "ctrl+alt+3",
+	4: "ctrl+alt+4",
+	5: "ctrl+alt+5",
+	6: "ctrl+alt+6"
+};
+/**
+* Checks if heading can be toggled in the current editor state
+*/
+function canToggle(editor, level, turnInto = true) {
+	if (!editor || !editor.isEditable) return false;
+	if (!isNodeInSchema("heading", editor) || isNodeTypeSelected(editor, ["image"])) return false;
+	if (!turnInto) return level ? editor.can().setNode("heading", { level }) : editor.can().setNode("heading");
+	if (!selectionWithinConvertibleTypes(editor, [
+		"paragraph",
+		"heading",
+		"bulletList",
+		"orderedList",
+		"taskList",
+		"blockquote",
+		"codeBlock"
+	])) return false;
+	return level ? editor.can().setNode("heading", { level }) || editor.can().clearNodes() : editor.can().setNode("heading") || editor.can().clearNodes();
+}
+/**
+* Checks if heading is currently active
+*/
+function isHeadingActive(editor, level) {
+	if (!editor || !editor.isEditable) return false;
+	if (Array.isArray(level)) return level.some((l) => editor.isActive("heading", { level: l }));
+	return level ? editor.isActive("heading", { level }) : editor.isActive("heading");
+}
+/**
+* Toggles heading in the editor
+*/
+function toggleHeading(editor, level) {
+	if (!editor || !editor.isEditable) return false;
+	const levels = Array.isArray(level) ? level : [level];
+	const toggleLevel = levels.find((l) => canToggle(editor, l));
+	if (!toggleLevel) return false;
+	try {
+		const view = editor.view;
+		let state = view.state;
+		let tr = state.tr;
+		const blocks = getSelectedBlockNodes(editor);
+		const isPossibleToTurnInto = selectionWithinConvertibleTypes(editor, [
+			"paragraph",
+			"heading",
+			"bulletList",
+			"orderedList",
+			"taskList",
+			"blockquote",
+			"codeBlock"
+		]) && blocks.length === 1;
+		if ((state.selection.empty || state.selection instanceof TextSelection) && isPossibleToTurnInto) {
+			const pos = findNodePosition({
+				editor,
+				node: state.selection.$anchor.node(1)
+			})?.pos;
+			if (!isValidPosition(pos)) return false;
+			tr = tr.setSelection(NodeSelection.create(state.doc, pos));
+			view.dispatch(tr);
+			state = view.state;
+		}
+		const selection = state.selection;
+		let chain = editor.chain().focus();
+		if (selection instanceof NodeSelection) {
+			const firstChild = selection.node.firstChild?.firstChild;
+			const lastChild = selection.node.lastChild?.lastChild;
+			const from = firstChild ? selection.from + firstChild.nodeSize : selection.from + 1;
+			const to = lastChild ? selection.to - lastChild.nodeSize : selection.to - 1;
+			const resolvedFrom = state.doc.resolve(from);
+			const resolvedTo = state.doc.resolve(to);
+			chain = chain.setTextSelection(TextSelection.between(resolvedFrom, resolvedTo)).clearNodes();
+		}
+		(levels.some((l) => editor.isActive("heading", { level: l })) ? chain.setNode("paragraph") : chain.setNode("heading", { level: toggleLevel })).run();
+		editor.chain().focus().selectTextblockEnd().run();
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Determines if the heading menu item should be shown
+*/
+function shouldShowItem(props) {
+	const { editor, level, hideWhenUnavailable } = props;
+	if (!editor) return false;
+	if (!hideWhenUnavailable) return true;
+	if (!editor.isEditable) return false;
+	if (!isNodeInSchema("heading", editor)) return false;
+	if (!editor.isActive("code")) {
+		if (Array.isArray(level)) return level.some((l) => canToggle(editor, l));
+		return canToggle(editor, level);
+	}
+	return true;
+}
+/**
+* Custom hook that provides heading functionality for Tiptap editor
+*
+* @example
+* ```tsx
+* // Simple usage
+* function MySimpleHeadingItem() {
+*   const { isVisible, isActive, handleToggle, Icon } = useHeading({ level: 1 })
+*
+*   if (!isVisible) return null
+*
+*   return (
+*     <button
+*       onClick={handleToggle}
+*       aria-pressed={isActive}
+*     >
+*       <Icon />
+*       Heading 1
+*     </button>
+*   )
+* }
+*
+* // Advanced usage with configuration
+* function MyAdvancedHeadingItem() {
+*   const { isVisible, isActive, handleToggle, label, Icon } = useHeading({
+*     level: 2,
+*     editor: myEditor,
+*     hideWhenUnavailable: true,
+*     onToggled: (isActive) => console.log('Heading toggled:', isActive)
+*   })
+*
+*   if (!isVisible) return null
+*
+*   return (
+*     <MyButton
+*       onClick={handleToggle}
+*       aria-label={label}
+*       aria-pressed={isActive}
+*     >
+*       <Icon />
+*       Toggle Heading 2
+*     </MyButton>
+*   )
+* }
+* ```
+*/
+function useHeading(config) {
+	const { editor: providedEditor, level, hideWhenUnavailable = false, onToggled } = config;
+	const { editor } = useTiptapEditor(providedEditor);
+	const [isVisible, setIsVisible] = useState(true);
+	const canToggleState = canToggle(editor, level);
+	const isActive = isHeadingActive(editor, level);
+	useEffect(() => {
+		if (!editor) return;
+		const handleSelectionUpdate = () => {
+			setIsVisible(shouldShowItem({
+				editor,
+				level,
+				hideWhenUnavailable
+			}));
+		};
+		handleSelectionUpdate();
+		editor.on("selectionUpdate", handleSelectionUpdate);
+		return () => {
+			editor.off("selectionUpdate", handleSelectionUpdate);
+		};
+	}, [
+		editor,
+		level,
+		hideWhenUnavailable
+	]);
+	return {
+		isVisible,
+		isActive,
+		handleToggle: useCallback(() => {
+			if (!editor) return false;
+			const success = toggleHeading(editor, level);
+			if (success) onToggled?.();
+			return success;
+		}, [
+			editor,
+			level,
+			onToggled
+		]),
+		canToggle: canToggleState,
+		label: `Titre ${level}`,
+		shortcutKeys: HEADING_SHORTCUT_KEYS[level],
+		Icon: headingIcons[level]
+	};
+}
+//#endregion
+//#region src/tiptap/components/ui/heading-menu-item/heading-menu-item.tsx
+function HeadingShortcutBadge({ level, shortcutKeys = HEADING_SHORTCUT_KEYS[level] }) {
+	return /* @__PURE__ */ jsx(Badge, { children: parseShortcutKeys({ shortcutKeys }) });
+}
+/**
+* Menu item component for toggling heading in a Tiptap editor.
+*
+* For custom menu item implementations, use the `useHeading` hook instead.
+*/
+var HeadingMenuItem = forwardRef(({ editor: providedEditor, level, text, hideWhenUnavailable = false, onToggled, showShortcut = false, onClick, children, ...menuItemProps }, ref) => {
+	const { editor } = useTiptapEditor(providedEditor);
+	const { isVisible, canToggle, isActive, handleToggle, label, Icon, shortcutKeys } = useHeading({
+		editor,
+		level,
+		hideWhenUnavailable,
+		onToggled
+	});
+	const handleClick = useCallback((event) => {
+		onClick?.(event);
+		if (event.defaultPrevented) return;
+		handleToggle();
+	}, [handleToggle, onClick]);
+	if (!isVisible) return null;
+	return /* @__PURE__ */ jsx(MenuItem, {
+		component: "li",
+		role: "button",
+		tabIndex: -1,
+		disabled: !canToggle,
+		"data-disabled": !canToggle,
+		"aria-label": label,
+		"aria-pressed": isActive,
+		tooltip: label,
+		selected: isActive,
+		onClick: handleClick,
+		...menuItemProps,
+		ref,
+		children: children ?? /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			/* @__PURE__ */ jsx(Icon, { fontSize: "small" }),
+			text && /* @__PURE__ */ jsx(Typography, {
+				component: "span",
+				variant: "body2",
+				sx: { ml: 1 },
+				children: label
+			}),
+			showShortcut && /* @__PURE__ */ jsx(HeadingShortcutBadge, {
+				level,
+				shortcutKeys
+			})
+		] })
+	});
+});
+HeadingMenuItem.displayName = "HeadingMenuItem";
+//#endregion
+//#region src/tiptap/components/icons/heading-icon.tsx
+var HeadingIcon = createSvgIcon(/* @__PURE__ */ jsx("path", {
+	d: "M6 3C6.55228 3 7 3.44772 7 4V11H17V4C17 3.44772 17.4477 3 18 3C18.5523 3 19 3.44772 19 4V20C19 20.5523 18.5523 21 18 21C17.4477 21 17 20.5523 17 20V13H7V20C7 20.5523 6.55228 21 6 21C5.44772 21 5 20.5523 5 20V4C5 3.44772 5.44772 3 6 3Z",
+	fill: "currentColor"
+}), "Heading");
+//#endregion
+//#region src/tiptap/components/ui/heading-menu/use-heading-menu.ts
+/**
+* Gets the currently active heading level from the available levels
+*/
+function getActiveHeadingLevel(editor, levels = [
+	1,
+	2,
+	3,
+	4,
+	5,
+	6
+]) {
+	if (!editor || !editor.isEditable) return void 0;
+	return levels.find((level) => isHeadingActive(editor, level));
+}
+/**
+* Custom hook that provides heading menu functionality for Tiptap editor
+*
+* @example
+* ```tsx
+* // Simple usage
+* function MyHeading() {
+*   const {
+*     isVisible,
+*     activeLevel,
+*     isAnyHeadingActive,
+*     canToggle,
+*     levels,
+*   } = useHeadingMenu()
+*
+*   if (!isVisible) return null
+*
+*   return (
+*     <Menu>
+*       // content
+*     </Menu>
+*   )
+* }
+*
+* // Advanced usage with configuration
+* function MyAdvancedHeading() {
+*   const {
+*     isVisible,
+*     activeLevel,
+*   } = useHeadingMenu({
+*     editor: myEditor,
+*     levels: [1, 2, 3],
+*     hideWhenUnavailable: true,
+*   })
+*
+*   // component implementation
+* }
+* ```
+*/
+function useHeadingMenu(config) {
+	const { editor: providedEditor, levels = [
+		1,
+		2,
+		3,
+		4,
+		5,
+		6
+	], hideWhenUnavailable = false } = config || {};
+	const { editor } = useTiptapEditor(providedEditor);
+	const [isVisible, setIsVisible] = useState(true);
+	const activeLevel = getActiveHeadingLevel(editor, levels);
+	const isActive = isHeadingActive(editor);
+	const canToggleState = canToggle(editor);
+	useEffect(() => {
+		if (!editor) return;
+		const handleSelectionUpdate = () => {
+			setIsVisible(shouldShowItem({
+				editor,
+				hideWhenUnavailable,
+				level: levels
+			}));
+		};
+		handleSelectionUpdate();
+		editor.on("selectionUpdate", handleSelectionUpdate);
+		return () => {
+			editor.off("selectionUpdate", handleSelectionUpdate);
+		};
+	}, [
+		editor,
+		hideWhenUnavailable,
+		levels
+	]);
+	return {
+		isVisible,
+		activeLevel,
+		isActive,
+		canToggle: canToggleState,
+		levels,
+		label: "Titre",
+		Icon: activeLevel ? headingIcons[activeLevel] : HeadingIcon
+	};
+}
+//#endregion
+//#region src/tiptap/components/ui/heading-menu/heading-menu.tsx
+/**
+* Menu component for selecting heading levels in a Tiptap editor.
+*
+* For custom menu implementations, use the `useHeadingMenu` hook instead.
+*/
+var HeadingMenu = forwardRef(({ editor: providedEditor, levels = [
+	1,
+	2,
+	3,
+	4,
+	5,
+	6
+], hideWhenUnavailable = false, onOpenChange, children, modal = true, ...buttonProps }, ref) => {
+	const { editor } = useTiptapEditor(providedEditor);
+	const [anchorEl, setAnchorEl] = useState(null);
+	const open = Boolean(anchorEl);
+	const { isVisible, isActive, canToggle, Icon, label } = useHeadingMenu({
+		editor,
+		levels,
+		hideWhenUnavailable
+	});
+	const handleClick = (event) => {
+		setAnchorEl(event.currentTarget);
+	};
+	const handleClose = useCallback(() => {
+		if (!editor || !canToggle) return;
+		setAnchorEl(null);
+		onOpenChange?.(false);
+	}, [
+		canToggle,
+		editor,
+		onOpenChange
+	]);
+	if (!isVisible) return null;
+	return /* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx(Button, {
+		id: "heading-button",
+		value: "heading",
+		type: "button",
+		selected: isActive || open,
+		role: "button",
+		tabIndex: -1,
+		disabled: !canToggle,
+		"data-disabled": !canToggle,
+		"aria-haspopup": "listbox",
+		"aria-controls": "heading-menu",
+		"aria-label": "Format text as heading",
+		"aria-expanded": open,
+		tooltip: label,
+		onClick: handleClick,
+		...buttonProps,
+		ref,
+		children: children ? children : /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(Icon, { fontSize: "small" }), /* @__PURE__ */ jsx(ExpandMoreRounded_default, { sx: { fontSize: "0.75rem" } })] })
+	}), /* @__PURE__ */ jsx(Menu, {
+		id: "heading-menu",
+		anchorEl,
+		open,
+		onClose: handleClose,
+		slotProps: { list: {
+			"aria-labelledby": "heading-button",
+			role: "listbox"
+		} },
+		children: levels.map((level) => /* @__PURE__ */ jsx(HeadingMenuItem, {
+			editor,
+			level,
+			text: `Heading ${level}`,
+			onClick: handleClose
+		}, `heading-${level}`))
+	})] });
+});
+HeadingMenu.displayName = "HeadingMenu";
+//#endregion
+//#region ../../node_modules/.pnpm/@mui+icons-material@9.4.0_@mui+material@9.4.0_@emotion+react@11.14.0_@types+react@19.2._02cb1dd638d2ccdea7d16c50ea4ea174/node_modules/@mui/icons-material/KeyboardReturnRounded.mjs
+var KeyboardReturnRounded_default = SvgIcon_default(/*#__PURE__*/ jsx("path", { d: "M19 8v3H5.83l2.88-2.88c.39-.39.39-1.02 0-1.41a.996.996 0 0 0-1.41 0L2.71 11.3c-.39.39-.39 1.02 0 1.41L7.3 17.3c.39.39 1.02.39 1.41 0s.39-1.02 0-1.41L5.83 13H20c.55 0 1-.45 1-1V8c0-.55-.45-1-1-1s-1 .45-1 1" }), "KeyboardReturnRounded");
+//#endregion
+//#region ../../node_modules/.pnpm/@mui+icons-material@9.4.0_@mui+material@9.4.0_@emotion+react@11.14.0_@types+react@19.2._02cb1dd638d2ccdea7d16c50ea4ea174/node_modules/@mui/icons-material/LinkRounded.mjs
+var LinkRounded_default = SvgIcon_default(/*#__PURE__*/ jsx("path", { d: "M17 7h-3c-.55 0-1 .45-1 1s.45 1 1 1h3c1.65 0 3 1.35 3 3s-1.35 3-3 3h-3c-.55 0-1 .45-1 1s.45 1 1 1h3c2.76 0 5-2.24 5-5s-2.24-5-5-5m-9 5c0 .55.45 1 1 1h6c.55 0 1-.45 1-1s-.45-1-1-1H9c-.55 0-1 .45-1 1m2 3H7c-1.65 0-3-1.35-3-3s1.35-3 3-3h3c.55 0 1-.45 1-1s-.45-1-1-1H7c-2.76 0-5 2.24-5 5s2.24 5 5 5h3c.55 0 1-.45 1-1s-.45-1-1-1" }), "LinkRounded");
+//#endregion
+//#region ../../node_modules/.pnpm/@mui+icons-material@9.4.0_@mui+material@9.4.0_@emotion+react@11.14.0_@types+react@19.2._02cb1dd638d2ccdea7d16c50ea4ea174/node_modules/@mui/icons-material/OpenInNewRounded.mjs
+var OpenInNewRounded_default = SvgIcon_default(/*#__PURE__*/ jsx("path", { d: "M18 19H6c-.55 0-1-.45-1-1V6c0-.55.45-1 1-1h5c.55 0 1-.45 1-1s-.45-1-1-1H5c-1.11 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2v-6c0-.55-.45-1-1-1s-1 .45-1 1v5c0 .55-.45 1-1 1M14 4c0 .55.45 1 1 1h2.59l-9.13 9.13c-.39.39-.39 1.02 0 1.41s1.02.39 1.41 0L19 6.41V9c0 .55.45 1 1 1s1-.45 1-1V4c0-.55-.45-1-1-1h-5c-.55 0-1 .45-1 1" }), "OpenInNewRounded");
+//#endregion
+//#region src/tiptap/components/ui/link-popover/use-link-popover.ts
+/**
+* Checks if a link can be set in the current editor state
+*/
+function canSetLink(editor) {
+	if (!editor || !editor.isEditable) return false;
+	if (isNodeTypeSelected(editor, ["image"], true)) return false;
+	try {
+		return editor.can().setMark("link");
+	} catch {
+		return false;
+	}
+}
+/**
+* Checks if a link is currently active in the editor
+*/
+function isLinkActive(editor) {
+	if (!editor || !editor.isEditable) return false;
+	return editor.isActive("link");
+}
+/**
+* Determines if the link button should be shown
+*/
+function shouldShowLinkButton(props) {
+	const { editor, hideWhenUnavailable } = props;
+	if (!editor || !editor.isEditable) return false;
+	const linkInSchema = isMarkInSchema("link", editor);
+	if (!hideWhenUnavailable) return true;
+	if (!linkInSchema) return false;
+	if (!editor.isActive("code")) return canSetLink(editor);
+	return true;
+}
+/**
+* Custom hook for handling link operations in a Tiptap editor
+*/
+function useLinkHandler(props) {
+	const { editor, onSetLink } = props;
+	const [url, setUrl] = useState(null);
+	useEffect(() => {
+		if (!editor) return;
+		const { href } = editor.getAttributes("link");
+		if (isLinkActive(editor) && url === null) setUrl(href || "");
+	}, [editor, url]);
+	useEffect(() => {
+		if (!editor) return;
+		const updateLinkState = () => {
+			const { href } = editor.getAttributes("link");
+			setUrl(href || "");
+		};
+		editor.on("selectionUpdate", updateLinkState);
+		return () => {
+			editor.off("selectionUpdate", updateLinkState);
+		};
+	}, [editor]);
+	const setLink = useCallback(() => {
+		if (!url || !editor) return;
+		const { selection } = editor.state;
+		const isEmpty = selection.empty;
+		let chain = editor.chain().focus();
+		chain = chain.extendMarkRange("link").setLink({ href: url });
+		if (isEmpty) chain = chain.insertContent({
+			type: "text",
+			text: url
+		});
+		chain.run();
+		setUrl(null);
+		onSetLink?.();
+	}, [
+		editor,
+		onSetLink,
+		url
+	]);
+	const removeLink = useCallback(() => {
+		if (!editor) return;
+		editor.chain().focus().extendMarkRange("link").unsetLink().setMeta("preventAutolink", true).run();
+		setUrl("");
+	}, [editor]);
+	const openLink = useCallback((target = "_blank", features = "noopener,noreferrer") => {
+		if (!url) return;
+		const safeUrl = sanitizeUrl(url, window.location.href);
+		if (safeUrl !== "#") window.open(safeUrl, target, features);
+	}, [url]);
+	return {
+		url: url || "",
+		setUrl,
+		setLink,
+		removeLink,
+		openLink
+	};
+}
+/**
+* Custom hook for link popover state management
+*/
+function useLinkState(props) {
+	const { editor, hideWhenUnavailable = false } = props;
+	const canSet = canSetLink(editor);
+	const isActive = isLinkActive(editor);
+	const [isVisible, setIsVisible] = useState(true);
+	useEffect(() => {
+		if (!editor) return;
+		const handleSelectionUpdate = () => {
+			setIsVisible(shouldShowLinkButton({
+				editor,
+				hideWhenUnavailable
+			}));
+		};
+		handleSelectionUpdate();
+		editor.on("selectionUpdate", handleSelectionUpdate);
+		return () => {
+			editor.off("selectionUpdate", handleSelectionUpdate);
+		};
+	}, [editor, hideWhenUnavailable]);
+	return {
+		isVisible,
+		canSet,
+		isActive
+	};
+}
+/**
+* Main hook that provides link popover functionality for Tiptap editor
+*
+* @example
+* ```tsx
+* // Simple usage
+* function MyLinkButton() {
+*   const { isVisible, canSet, isActive, Icon, label } = useLinkPopover()
+*
+*   if (!isVisible) return null
+*
+*   return <button disabled={!canSet}>Link</button>
+* }
+*
+* // Advanced usage with configuration
+* function MyAdvancedLinkButton() {
+*   const { isVisible, canSet, isActive, Icon, label } = useLinkPopover({
+*     editor: myEditor,
+*     hideWhenUnavailable: true,
+*     onSetLink: () => console.log('Link set!')
+*   })
+*
+*   if (!isVisible) return null
+*
+*   return (
+*     <MyButton
+*       disabled={!canSet}
+*       aria-label={label}
+*       aria-pressed={isActive}
+*     >
+*       <Icon />
+*       {label}
+*     </MyButton>
+*   )
+* }
+* ```
+*/
+function useLinkPopover(config) {
+	const { editor: providedEditor, hideWhenUnavailable = false, onSetLink } = config || {};
+	const { editor } = useTiptapEditor(providedEditor);
+	const { isVisible, canSet, isActive } = useLinkState({
+		editor,
+		hideWhenUnavailable
+	});
+	return {
+		isVisible,
+		canSet,
+		isActive,
+		label: "Lien",
+		Icon: LinkRounded_default,
+		...useLinkHandler({
+			editor,
+			onSetLink
+		})
+	};
+}
+//#endregion
+//#region src/tiptap/components/ui/link-popover/link-popover.tsx
+/**
+* Link button component for triggering the link popover
+*/
+var LinkButton = forwardRef(({ className, children, ...props }, ref) => {
+	return /* @__PURE__ */ jsx(Button, {
+		type: "button",
+		className,
+		role: "button",
+		tabIndex: -1,
+		ref,
+		...props,
+		children: children || /* @__PURE__ */ jsx(LinkRounded_default, { fontSize: "small" })
+	});
+});
+LinkButton.displayName = "LinkButton";
+var StyledIconButton = styled(IconButton)(({ theme }) => ({
+	borderRadius: theme.shape.borderRadius,
+	"& .MuiTouchRipple-root .MuiTouchRipple-child": { borderRadius: theme.shape.borderRadius }
+}));
+/**
+* Main content component for the link popover
+*/
+var LinkMain = ({ url, setUrl, setLink, removeLink, openLink, isActive }) => {
+	const handleKeyDown = (event) => {
+		if (event.key === "Enter") {
+			event.preventDefault();
+			setLink();
+		}
+	};
+	return /* @__PURE__ */ jsxs(Stack, {
+		direction: "row",
+		spacing: .5,
+		sx: {
+			alignItems: "center",
+			p: 1
+		},
+		children: [
+			/* @__PURE__ */ jsx(InputBase, {
+				type: "url",
+				placeholder: "Coller un lien...",
+				value: url,
+				onChange: (e) => setUrl(e.target.value),
+				onKeyDown: handleKeyDown,
+				autoFocus: true,
+				autoComplete: "off",
+				autoCorrect: "off",
+				autoCapitalize: "off",
+				sx: {
+					padding: ".25rem .625rem",
+					fontSize: "0.875rem",
+					minWidth: "12rem"
+				}
+			}),
+			/* @__PURE__ */ jsx(StyledIconButton, {
+				size: "small",
+				type: "button",
+				onClick: setLink,
+				title: "Appliquer le lien",
+				disabled: !url && !isActive,
+				children: /* @__PURE__ */ jsx(KeyboardReturnRounded_default, { fontSize: "small" })
+			}),
+			/* @__PURE__ */ jsx(Divider, {
+				orientation: "vertical",
+				flexItem: true,
+				sx: { my: .5 }
+			}),
+			/* @__PURE__ */ jsx(StyledIconButton, {
+				size: "small",
+				type: "button",
+				onClick: openLink,
+				title: "Ouvrir dans une nouvelle fenêtre",
+				disabled: !url && !isActive,
+				children: /* @__PURE__ */ jsx(OpenInNewRounded_default, { fontSize: "small" })
+			}),
+			/* @__PURE__ */ jsx(StyledIconButton, {
+				size: "small",
+				type: "button",
+				onClick: removeLink,
+				title: "Supprimer le lien",
+				disabled: !url && !isActive,
+				children: /* @__PURE__ */ jsx(DeleteRounded_default, { fontSize: "small" })
+			})
+		]
+	});
+};
+/**
+* Link popover component for Tiptap editors.
+*
+* For custom popover implementations, use the `useLinkPopover` hook instead.
+*/
+var LinkPopover = forwardRef(({ editor: providedEditor, hideWhenUnavailable = false, onSetLink, onOpenChange, autoOpenOnLinkActive = true, onClick, children, ...buttonProps }, ref) => {
+	const { editor } = useTiptapEditor(providedEditor);
+	const [anchorEl, setAnchorEl] = useState(null);
+	const internalRef = useRef(null);
+	const justSubmittedRef = useRef(false);
+	const { isVisible, canSet, isActive, url, setUrl, setLink, removeLink, openLink, label, Icon } = useLinkPopover({
+		editor,
+		hideWhenUnavailable,
+		onSetLink
+	});
+	const setRefs = useCallback((node) => {
+		internalRef.current = node;
+		if (typeof ref === "function") ref(node);
+		else if (ref) ref.current = node;
+	}, [ref]);
+	const handleClose = useCallback(() => {
+		setAnchorEl(null);
+		onOpenChange?.(false);
+	}, [onOpenChange]);
+	const handleSetLink = useCallback(() => {
+		justSubmittedRef.current = true;
+		setLink();
+		setAnchorEl(null);
+		queueMicrotask(() => {
+			justSubmittedRef.current = false;
+		});
+	}, [setLink]);
+	const handleClick = useCallback((event) => {
+		onClick?.(event, !isActive);
+		if (event.defaultPrevented) return;
+		setAnchorEl(event.currentTarget);
+	}, [onClick, anchorEl]);
+	useEffect(() => {
+		if (autoOpenOnLinkActive && isActive && !justSubmittedRef.current) setAnchorEl(internalRef.current);
+	}, [autoOpenOnLinkActive, isActive]);
+	if (!isVisible) return null;
+	const open = Boolean(anchorEl);
+	return /* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx(LinkButton, {
+		value: "link",
+		disabled: !canSet,
+		selected: isActive || open,
+		"data-disabled": !canSet,
+		"aria-label": label,
+		tooltip: label,
+		onClick: handleClick,
+		...buttonProps,
+		ref: setRefs,
+		children: children ?? /* @__PURE__ */ jsx(Icon, { fontSize: "small" })
+	}), /* @__PURE__ */ jsx(Popover, {
+		open,
+		anchorEl,
+		onClose: handleClose,
+		anchorOrigin: {
+			vertical: "bottom",
+			horizontal: "center"
+		},
+		transformOrigin: {
+			vertical: -4,
+			horizontal: "center"
+		},
+		children: /* @__PURE__ */ jsx(LinkMain, {
+			url,
+			setUrl,
+			setLink: handleSetLink,
+			removeLink,
+			openLink,
+			isActive
+		})
+	})] });
+});
+LinkPopover.displayName = "LinkPopover";
+//#endregion
+//#region src/tiptap/components/ui/list-button/use-list.ts
+var listIcons = {
+	bulletList: SvgIcon_default(/*#__PURE__*/ jsx("path", { d: "M4 10.5c-.83 0-1.5.67-1.5 1.5s.67 1.5 1.5 1.5 1.5-.67 1.5-1.5-.67-1.5-1.5-1.5m0-6c-.83 0-1.5.67-1.5 1.5S3.17 7.5 4 7.5 5.5 6.83 5.5 6 4.83 4.5 4 4.5m0 12c-.83 0-1.5.68-1.5 1.5s.68 1.5 1.5 1.5 1.5-.68 1.5-1.5-.67-1.5-1.5-1.5M8 19h12c.55 0 1-.45 1-1s-.45-1-1-1H8c-.55 0-1 .45-1 1s.45 1 1 1m0-6h12c.55 0 1-.45 1-1s-.45-1-1-1H8c-.55 0-1 .45-1 1s.45 1 1 1M7 6c0 .55.45 1 1 1h12c.55 0 1-.45 1-1s-.45-1-1-1H8c-.55 0-1 .45-1 1" }), "FormatListBulletedRounded"),
+	orderedList: SvgIcon_default(/*#__PURE__*/ jsx("path", { d: "M8 7h12c.55 0 1-.45 1-1s-.45-1-1-1H8c-.55 0-1 .45-1 1s.45 1 1 1m12 10H8c-.55 0-1 .45-1 1s.45 1 1 1h12c.55 0 1-.45 1-1s-.45-1-1-1m0-6H8c-.55 0-1 .45-1 1s.45 1 1 1h12c.55 0 1-.45 1-1s-.45-1-1-1M4.5 16h-2c-.28 0-.5.22-.5.5s.22.5.5.5H4v.5h-.5c-.28 0-.5.22-.5.5s.22.5.5.5H4v.5H2.5c-.28 0-.5.22-.5.5s.22.5.5.5h2c.28 0 .5-.22.5-.5v-3c0-.28-.22-.5-.5-.5m-2-11H3v2.5c0 .28.22.5.5.5s.5-.22.5-.5v-3c0-.28-.22-.5-.5-.5h-1c-.28 0-.5.22-.5.5s.22.5.5.5m2 5h-2c-.28 0-.5.22-.5.5s.22.5.5.5h1.3l-1.68 1.96c-.08.09-.12.21-.12.32v.22c0 .28.22.5.5.5h2c.28 0 .5-.22.5-.5s-.22-.5-.5-.5H3.2l1.68-1.96c.08-.09.12-.21.12-.32v-.22c0-.28-.22-.5-.5-.5" }), "FormatListNumberedRounded"),
+	taskList: createSvgIcon(/* @__PURE__ */ jsxs("g", { children: [
+		/* @__PURE__ */ jsx("path", {
+			fillRule: "evenodd",
+			clipRule: "evenodd",
+			d: "M2 6C2 4.89543 2.89543 4 4 4H8C9.10457 4 10 4.89543 10 6V10C10 11.1046 9.10457 12 8 12H4C2.89543 12 2 11.1046 2 10V6ZM8 6H4V10H8V6Z",
+			fill: "currentColor"
+		}),
+		/* @__PURE__ */ jsx("path", {
+			fillRule: "evenodd",
+			clipRule: "evenodd",
+			d: "M9.70711 14.2929C10.0976 14.6834 10.0976 15.3166 9.70711 15.7071L5.70711 19.7071C5.31658 20.0976 4.68342 20.0976 4.29289 19.7071L2.29289 17.7071C1.90237 17.3166 1.90237 16.6834 2.29289 16.2929C2.68342 15.9024 3.31658 15.9024 3.70711 16.2929L5 17.5858L8.29289 14.2929C8.68342 13.9024 9.31658 13.9024 9.70711 14.2929Z",
+			fill: "currentColor"
+		}),
+		/* @__PURE__ */ jsx("path", {
+			fillRule: "evenodd",
+			clipRule: "evenodd",
+			d: "M12 6C12 5.44772 12.4477 5 13 5H21C21.5523 5 22 5.44772 22 6C22 6.55228 21.5523 7 21 7H13C12.4477 7 12 6.55228 12 6Z",
+			fill: "currentColor"
+		}),
+		/* @__PURE__ */ jsx("path", {
+			fillRule: "evenodd",
+			clipRule: "evenodd",
+			d: "M12 12C12 11.4477 12.4477 11 13 11H21C21.5523 11 22 11.4477 22 12C22 12.5523 21.5523 13 21 13H13C12.4477 13 12 12.5523 12 12Z",
+			fill: "currentColor"
+		}),
+		/* @__PURE__ */ jsx("path", {
+			fillRule: "evenodd",
+			clipRule: "evenodd",
+			d: "M12 18C12 17.4477 12.4477 17 13 17H21C21.5523 17 22 17.4477 22 18C22 18.5523 21.5523 19 21 19H13C12.4477 19 12 18.5523 12 18Z",
+			fill: "currentColor"
+		})
+	] }), "ListTodo")
+};
+var listLabels = {
+	bulletList: "Liste à puces",
+	orderedList: "Liste numérotée",
+	taskList: "Liste de tâches"
+};
+var LIST_SHORTCUT_KEYS = {
+	bulletList: "mod+shift+8",
+	orderedList: "mod+shift+7",
+	taskList: "mod+shift+9"
+};
+/**
+* Checks if a list can be toggled in the current editor state
+*/
+function canToggleList(editor, type, turnInto = true) {
+	if (!editor || !editor.isEditable) return false;
+	if (!isNodeInSchema(type, editor) || isNodeTypeSelected(editor, ["image"])) return false;
+	if (!turnInto) switch (type) {
+		case "bulletList": return editor.can().toggleBulletList();
+		case "orderedList": return editor.can().toggleOrderedList();
+		case "taskList": return editor.can().toggleList("taskList", "taskItem");
+		default: return false;
+	}
+	if (!selectionWithinConvertibleTypes(editor, [
+		"paragraph",
+		"heading",
+		"bulletList",
+		"orderedList",
+		"taskList",
+		"blockquote",
+		"codeBlock"
+	])) return false;
+	switch (type) {
+		case "bulletList": return editor.can().toggleBulletList() || editor.can().clearNodes();
+		case "orderedList": return editor.can().toggleOrderedList() || editor.can().clearNodes();
+		case "taskList": return editor.can().toggleList("taskList", "taskItem") || editor.can().clearNodes();
+		default: return false;
+	}
+}
+/**
+* Checks if list is currently active
+*/
+function isListActive(editor, type) {
+	if (!editor || !editor.isEditable) return false;
+	switch (type) {
+		case "bulletList": return editor.isActive("bulletList");
+		case "orderedList": return editor.isActive("orderedList");
+		case "taskList": return editor.isActive("taskList");
+		default: return false;
+	}
+}
+/**
+* Toggles list in the editor
+*/
+function toggleList(editor, type) {
+	if (!editor || !editor.isEditable) return false;
+	if (!canToggleList(editor, type)) return false;
+	try {
+		const view = editor.view;
+		let state = view.state;
+		let tr = state.tr;
+		const blocks = getSelectedBlockNodes(editor);
+		const isPossibleToTurnInto = selectionWithinConvertibleTypes(editor, [
+			"paragraph",
+			"heading",
+			"bulletList",
+			"orderedList",
+			"taskList",
+			"blockquote",
+			"codeBlock"
+		]) && blocks.length === 1;
+		if ((state.selection.empty || state.selection instanceof TextSelection) && isPossibleToTurnInto) {
+			const pos = findNodePosition({
+				editor,
+				node: state.selection.$anchor.node(1)
+			})?.pos;
+			if (!isValidPosition(pos)) return false;
+			tr = tr.setSelection(NodeSelection.create(state.doc, pos));
+			view.dispatch(tr);
+			state = view.state;
+		}
+		const selection = state.selection;
+		let chain = editor.chain().focus();
+		if (selection instanceof NodeSelection) {
+			const firstChild = selection.node.firstChild?.firstChild;
+			const lastChild = selection.node.lastChild?.lastChild;
+			const from = firstChild ? selection.from + firstChild.nodeSize : selection.from + 1;
+			const to = lastChild ? selection.to - lastChild.nodeSize : selection.to - 1;
+			const resolvedFrom = state.doc.resolve(from);
+			const resolvedTo = state.doc.resolve(to);
+			chain = chain.setTextSelection(TextSelection.between(resolvedFrom, resolvedTo)).clearNodes();
+		}
+		if (editor.isActive(type)) chain.liftListItem("listItem").lift("bulletList").lift("orderedList").run();
+		else {
+			const toggle = {
+				bulletList: () => chain.toggleBulletList(),
+				orderedList: () => chain.toggleOrderedList(),
+				taskList: () => chain.toggleList("taskList", "taskItem")
+			}[type];
+			if (!toggle) return false;
+			toggle().run();
+		}
+		editor.chain().focus().selectTextblockEnd().run();
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Determines if the list button should be shown
+*/
+function shouldShowButton$3(props) {
+	const { editor, type, hideWhenUnavailable } = props;
+	if (!editor) return false;
+	if (!hideWhenUnavailable) return true;
+	if (!editor.isEditable) return false;
+	if (!isNodeInSchema(type, editor)) return false;
+	if (!editor.isActive("code")) return canToggleList(editor, type);
+	return true;
+}
+/**
+* Custom hook that provides list functionality for Tiptap editor
+*
+* @example
+* ```tsx
+* // Simple usage
+* function MySimpleListButton() {
+*   const { isVisible, handleToggle, isActive } = useList({ type: "bulletList" })
+*
+*   if (!isVisible) return null
+*
+*   return <button onClick={handleToggle}>Bullet List</button>
+* }
+*
+* // Advanced usage with configuration
+* function MyAdvancedListButton() {
+*   const { isVisible, handleToggle, label, isActive } = useList({
+*     type: "orderedList",
+*     editor: myEditor,
+*     hideWhenUnavailable: true,
+*     onToggled: () => console.log('List toggled!')
+*   })
+*
+*   if (!isVisible) return null
+*
+*   return (
+*     <MyButton
+*       onClick={handleToggle}
+*       aria-label={label}
+*       aria-pressed={isActive}
+*     >
+*       Toggle List
+*     </MyButton>
+*   )
+* }
+* ```
+*/
+function useList(config) {
+	const { editor: providedEditor, type, hideWhenUnavailable = false, onToggled } = config;
+	const { editor } = useTiptapEditor(providedEditor);
+	const [isVisible, setIsVisible] = useState(true);
+	const canToggle = canToggleList(editor, type);
+	const isActive = isListActive(editor, type);
+	useEffect(() => {
+		if (!editor) return;
+		const handleSelectionUpdate = () => {
+			setIsVisible(shouldShowButton$3({
+				editor,
+				type,
+				hideWhenUnavailable
+			}));
+		};
+		handleSelectionUpdate();
+		editor.on("selectionUpdate", handleSelectionUpdate);
+		return () => {
+			editor.off("selectionUpdate", handleSelectionUpdate);
+		};
+	}, [
+		editor,
+		type,
+		hideWhenUnavailable
+	]);
+	return {
+		isVisible,
+		isActive,
+		handleToggle: useCallback(() => {
+			if (!editor) return false;
+			const success = toggleList(editor, type);
+			if (success) onToggled?.();
+			return success;
+		}, [
+			editor,
+			type,
+			onToggled
+		]),
+		canToggle,
+		label: listLabels[type],
+		shortcutKeys: LIST_SHORTCUT_KEYS[type],
+		Icon: listIcons[type]
+	};
+}
+//#endregion
+//#region src/tiptap/components/ui/list-button/list-button.tsx
+function ListShortcutBadge({ type, shortcutKeys = LIST_SHORTCUT_KEYS[type] }) {
+	return /* @__PURE__ */ jsx(Badge, { children: parseShortcutKeys({ shortcutKeys }) });
+}
+/**
+* Button component for toggling lists in a Tiptap editor.
+*
+* For custom button implementations, use the `useList` hook instead.
+*/
+var ListButton = forwardRef(({ editor: providedEditor, type, text, hideWhenUnavailable = false, onToggled, showShortcut = false, onClick, children, ...buttonProps }, ref) => {
+	const { editor } = useTiptapEditor(providedEditor);
+	const { isVisible, canToggle, isActive, handleToggle, label, shortcutKeys, Icon } = useList({
+		editor,
+		type,
+		hideWhenUnavailable,
+		onToggled
+	});
+	const handleClick = useCallback((event) => {
+		onClick?.(event, !isActive);
+		if (event.defaultPrevented) return;
+		handleToggle();
+	}, [handleToggle, onClick]);
+	if (!isVisible) return null;
+	return /* @__PURE__ */ jsx(Button, {
+		value: type,
+		type: "button",
+		selected: isActive,
+		role: "button",
+		tabIndex: -1,
+		disabled: !canToggle,
+		"data-disabled": !canToggle,
+		"aria-label": label,
+		tooltip: label,
+		onClick: handleClick,
+		...buttonProps,
+		ref,
+		children: children ?? /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			/* @__PURE__ */ jsx(Icon, { fontSize: "small" }),
+			text && /* @__PURE__ */ jsx("span", {
+				className: "tiptap-button-text",
+				children: text
+			}),
+			showShortcut && /* @__PURE__ */ jsx(ListShortcutBadge, {
+				type,
+				shortcutKeys
+			})
+		] })
+	});
+});
+ListButton.displayName = "ListButton";
+//#endregion
+//#region ../../node_modules/.pnpm/@mui+icons-material@9.4.0_@mui+material@9.4.0_@emotion+react@11.14.0_@types+react@19.2._02cb1dd638d2ccdea7d16c50ea4ea174/node_modules/@mui/icons-material/CodeRounded.mjs
+var CodeRounded_default = SvgIcon_default(/*#__PURE__*/ jsx("path", { d: "M8.7 15.9 4.8 12l3.9-3.9c.39-.39.39-1.01 0-1.4a.984.984 0 0 0-1.4 0l-4.59 4.59c-.39.39-.39 1.02 0 1.41l4.59 4.6c.39.39 1.01.39 1.4 0s.39-1.01 0-1.4m6.6 0 3.9-3.9-3.9-3.9a.984.984 0 0 1 0-1.4c.39-.39 1.01-.39 1.4 0l4.59 4.59c.39.39.39 1.02 0 1.41l-4.59 4.6c-.39.39-1.01.39-1.4 0a.984.984 0 0 1 0-1.4" }), "CodeRounded");
+//#endregion
+//#region ../../node_modules/.pnpm/@mui+icons-material@9.4.0_@mui+material@9.4.0_@emotion+react@11.14.0_@types+react@19.2._02cb1dd638d2ccdea7d16c50ea4ea174/node_modules/@mui/icons-material/FormatBoldRounded.mjs
+var FormatBoldRounded_default = SvgIcon_default(/*#__PURE__*/ jsx("path", { d: "M15.6 10.79c.97-.67 1.65-1.77 1.65-2.79 0-2.26-1.75-4-4-4H8c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h5.78c2.07 0 3.96-1.69 3.97-3.77.01-1.53-.85-2.84-2.15-3.44M10 6.5h3c.83 0 1.5.67 1.5 1.5s-.67 1.5-1.5 1.5h-3zm3.5 9H10v-3h3.5c.83 0 1.5.67 1.5 1.5s-.67 1.5-1.5 1.5" }), "FormatBoldRounded");
+//#endregion
+//#region ../../node_modules/.pnpm/@mui+icons-material@9.4.0_@mui+material@9.4.0_@emotion+react@11.14.0_@types+react@19.2._02cb1dd638d2ccdea7d16c50ea4ea174/node_modules/@mui/icons-material/FormatItalicRounded.mjs
+var FormatItalicRounded_default = SvgIcon_default(/*#__PURE__*/ jsx("path", { d: "M10 5.5c0 .83.67 1.5 1.5 1.5h.71l-3.42 8H7.5c-.83 0-1.5.67-1.5 1.5S6.67 18 7.5 18h5c.83 0 1.5-.67 1.5-1.5s-.67-1.5-1.5-1.5h-.71l3.42-8h1.29c.83 0 1.5-.67 1.5-1.5S17.33 4 16.5 4h-5c-.83 0-1.5.67-1.5 1.5" }), "FormatItalicRounded");
+//#endregion
+//#region ../../node_modules/.pnpm/@mui+icons-material@9.4.0_@mui+material@9.4.0_@emotion+react@11.14.0_@types+react@19.2._02cb1dd638d2ccdea7d16c50ea4ea174/node_modules/@mui/icons-material/FormatUnderlinedRounded.mjs
+var FormatUnderlinedRounded_default = SvgIcon_default(/*#__PURE__*/ jsx("path", { d: "M12.79 16.95c3.03-.39 5.21-3.11 5.21-6.16V4.25C18 3.56 17.44 3 16.75 3s-1.25.56-1.25 1.25v6.65c0 1.67-1.13 3.19-2.77 3.52-2.25.47-4.23-1.25-4.23-3.42V4.25C8.5 3.56 7.94 3 7.25 3S6 3.56 6 4.25V11c0 3.57 3.13 6.42 6.79 5.95M5 20c0 .55.45 1 1 1h12c.55 0 1-.45 1-1s-.45-1-1-1H6c-.55 0-1 .45-1 1" }), "FormatUnderlinedRounded");
+//#endregion
+//#region ../../node_modules/.pnpm/@mui+icons-material@9.4.0_@mui+material@9.4.0_@emotion+react@11.14.0_@types+react@19.2._02cb1dd638d2ccdea7d16c50ea4ea174/node_modules/@mui/icons-material/StrikethroughSRounded.mjs
+var StrikethroughSRounded_default = SvgIcon_default(/*#__PURE__*/ jsx("path", { d: "M14.59 7.52c0-.31-.05-.59-.15-.85-.09-.27-.24-.49-.44-.68s-.45-.33-.75-.44c-.3-.1-.66-.16-1.06-.16-.39 0-.74.04-1.03.13s-.53.21-.72.36c-.19.16-.34.34-.44.55q-.15.315-.15.66c0 .48.25.88.74 1.21.38.25.77.48 1.41.7H7.39c-.05-.08-.11-.17-.15-.25-.26-.48-.39-1.03-.39-1.67 0-.61.13-1.16.4-1.67q.39-.75 1.11-1.29c.48-.35 1.05-.63 1.7-.83.66-.19 1.39-.29 2.18-.29.81 0 1.54.11 2.21.34.66.22 1.23.54 1.69.94.47.4.83.88 1.08 1.43s.38 1.15.38 1.81zM20 10H4c-.55 0-1 .45-1 1s.45 1 1 1h8.62c.18.07.4.14.55.2q.555.255.87.51c.315.255.35.36.43.57.07.2.11.43.11.69 0 .23-.05.45-.14.66-.09.2-.23.38-.42.53s-.42.26-.71.35c-.29.08-.63.13-1.01.13-.43 0-.83-.04-1.18-.13s-.66-.23-.91-.42-.45-.44-.59-.75-.25-.76-.25-1.21H6.4c0 .55.08 1.13.24 1.58s.37.85.65 1.21c.28.35.6.66.98.92.37.26.78.48 1.22.65q.66.255 1.38.39c.48.08.96.13 1.44.13.8 0 1.53-.09 2.18-.28s1.21-.45 1.67-.79.82-.77 1.07-1.27.38-1.07.38-1.71c0-.6-.1-1.14-.31-1.61-.05-.11-.11-.23-.17-.33H20c.55 0 1-.45 1-1V11c0-.55-.45-1-1-1" }), "StrikethroughSRounded");
+//#endregion
+//#region ../../node_modules/.pnpm/@mui+icons-material@9.4.0_@mui+material@9.4.0_@emotion+react@11.14.0_@types+react@19.2._02cb1dd638d2ccdea7d16c50ea4ea174/node_modules/@mui/icons-material/SubscriptRounded.mjs
+var SubscriptRounded_default = SvgIcon_default(/*#__PURE__*/ jsx("path", { d: "M10.52 10.73 7.3 5.72C6.82 4.97 7.35 4 8.23 4c.39 0 .74.2.95.53l2.76 4.46h.12l2.74-4.45c.21-.34.57-.54.96-.54.88 0 1.42.98.94 1.72l-3.23 5 3.55 5.55c.48.75-.06 1.73-.94 1.73-.38 0-.74-.2-.95-.52l-3.07-4.89h-.12l-3.07 4.89c-.2.32-.56.52-.95.52-.88 0-1.42-.97-.94-1.72zM23 19.5c0-.28-.22-.5-.5-.5H20v-1h2c.55 0 1-.45 1-1v-1c0-.55-.45-1-1-1h-2.5c-.28 0-.5.22-.5.5s.22.5.5.5H22v1h-2c-.55 0-1 .45-1 1v1c0 .55.45 1 1 1h2.5c.28 0 .5-.22.5-.5" }), "SubscriptRounded");
+//#endregion
+//#region src/tiptap/components/ui/mark-button/use-mark.ts
+var markIcons = {
+	bold: FormatBoldRounded_default,
+	italic: FormatItalicRounded_default,
+	underline: FormatUnderlinedRounded_default,
+	strike: StrikethroughSRounded_default,
+	code: CodeRounded_default,
+	superscript: SvgIcon_default(/*#__PURE__*/ jsx("path", { d: "M10.51 12.73 7.3 7.72C6.82 6.97 7.35 6 8.23 6c.39 0 .74.2.95.53l2.76 4.46h.12l2.74-4.45c.2-.34.56-.54.95-.54.88 0 1.42.98.94 1.72l-3.23 5 3.55 5.55c.49.75-.05 1.73-.93 1.73-.38 0-.74-.2-.95-.52l-3.07-4.89h-.12l-3.07 4.89c-.21.32-.56.52-.95.52-.88 0-1.42-.97-.94-1.72zM23 8.5c0-.28-.22-.5-.5-.5H20V7h2c.55 0 1-.45 1-1V5c0-.55-.45-1-1-1h-2.5c-.28 0-.5.22-.5.5s.22.5.5.5H22v1h-2c-.55 0-1 .45-1 1v1c0 .55.45 1 1 1h2.5c.28 0 .5-.22.5-.5" }), "SuperscriptRounded"),
+	subscript: SubscriptRounded_default
+};
+var MARK_SHORTCUT_KEYS = {
+	bold: "mod+b",
+	italic: "mod+i",
+	underline: "mod+u",
+	strike: "mod+shift+s",
+	code: "mod+e",
+	superscript: "mod+.",
+	subscript: "mod+,"
+};
+/**
+* Checks if a mark can be toggled in the current editor state
+*/
+function canToggleMark(editor, type) {
+	if (!editor || !editor.isEditable) return false;
+	if (!isMarkInSchema(type, editor) || isNodeTypeSelected(editor, ["image"])) return false;
+	return editor.can().toggleMark(type);
+}
+/**
+* Checks if a mark is currently active
+*/
+function isMarkActive(editor, type) {
+	if (!editor || !editor.isEditable) return false;
+	return editor.isActive(type);
+}
+/**
+* Toggles a mark in the editor
+*/
+function toggleMark(editor, type) {
+	if (!editor || !editor.isEditable) return false;
+	if (!canToggleMark(editor, type)) return false;
+	return editor.chain().focus().toggleMark(type).run();
+}
+/**
+* Determines if the mark button should be shown
+*/
+function shouldShowButton$2(props) {
+	const { editor, type, hideWhenUnavailable } = props;
+	if (!editor) return false;
+	if (!hideWhenUnavailable) return true;
+	if (!editor.isEditable) return false;
+	if (!isMarkInSchema(type, editor)) return false;
+	if (!editor.isActive("code")) return canToggleMark(editor, type);
+	return true;
+}
+/**
+* Gets the formatted mark name
+*/
+function getFormattedMarkName(type) {
+	switch (type) {
+		case "bold": return "Gras";
+		case "italic": return "Italique";
+		case "strike": return "Barré";
+		case "code": return "Code";
+		case "underline": return "Souligné";
+		case "superscript": return "Exposant";
+		case "subscript": return "Indice";
+	}
+}
+/**
+* Custom hook that provides mark functionality for Tiptap editor
+*
+* @example
+* ```tsx
+* // Simple usage
+* function MySimpleBoldButton() {
+*   const { isVisible, handleMark } = useMark({ type: "bold" })
+*
+*   if (!isVisible) return null
+*
+*   return <button onClick={handleMark}>Bold</button>
+* }
+*
+* // Advanced usage with configuration
+* function MyAdvancedItalicButton() {
+*   const { isVisible, handleMark, label, isActive } = useMark({
+*     editor: myEditor,
+*     type: "italic",
+*     hideWhenUnavailable: true,
+*     onToggled: () => console.log('Mark toggled!')
+*   })
+*
+*   if (!isVisible) return null
+*
+*   return (
+*     <MyButton
+*       onClick={handleMark}
+*       aria-pressed={isActive}
+*       aria-label={label}
+*     >
+*       Italic
+*     </MyButton>
+*   )
+* }
+* ```
+*/
+function useMark(config) {
+	const { editor: providedEditor, type, hideWhenUnavailable = false, onToggled } = config;
+	const { editor } = useTiptapEditor(providedEditor);
+	const [isVisible, setIsVisible] = useState(true);
+	const canToggle = canToggleMark(editor, type);
+	const isActive = isMarkActive(editor, type);
+	useEffect(() => {
+		if (!editor) return;
+		const handleSelectionUpdate = () => {
+			setIsVisible(shouldShowButton$2({
+				editor,
+				type,
+				hideWhenUnavailable
+			}));
+		};
+		handleSelectionUpdate();
+		editor.on("selectionUpdate", handleSelectionUpdate);
+		return () => {
+			editor.off("selectionUpdate", handleSelectionUpdate);
+		};
+	}, [
+		editor,
+		type,
+		hideWhenUnavailable
+	]);
+	return {
+		isVisible,
+		isActive,
+		handleMark: useCallback(() => {
+			if (!editor) return false;
+			const success = toggleMark(editor, type);
+			if (success) onToggled?.();
+			return success;
+		}, [
+			editor,
+			type,
+			onToggled
+		]),
+		canToggle,
+		label: getFormattedMarkName(type),
+		shortcutKeys: MARK_SHORTCUT_KEYS[type],
+		Icon: markIcons[type]
+	};
+}
+//#endregion
+//#region src/tiptap/components/ui/mark-button/mark-button.tsx
+function MarkShortcutBadge({ type, shortcutKeys = MARK_SHORTCUT_KEYS[type] }) {
+	return /* @__PURE__ */ jsx(Badge, { children: parseShortcutKeys({ shortcutKeys }) });
+}
+/**
+* Button component for toggling marks in a Tiptap editor.
+*
+* For custom button implementations, use the `useMark` hook instead.
+*/
+var MarkButton = forwardRef(({ editor: providedEditor, type, text, hideWhenUnavailable = false, onToggled, showShortcut = false, onClick, children, ...buttonProps }, ref) => {
+	const { editor } = useTiptapEditor(providedEditor);
+	const { isVisible, handleMark, label, canToggle, isActive, Icon, shortcutKeys } = useMark({
+		editor,
+		type,
+		hideWhenUnavailable,
+		onToggled
+	});
+	const handleClick = useCallback((event) => {
+		onClick?.(event, !isActive);
+		if (event.defaultPrevented) return;
+		handleMark();
+	}, [handleMark, onClick]);
+	if (!isVisible) return null;
+	return /* @__PURE__ */ jsx(Button, {
+		value: type,
+		type: "button",
+		disabled: !canToggle,
+		selected: isActive,
+		"data-disabled": !canToggle,
+		role: "button",
+		tabIndex: -1,
+		"aria-label": label,
+		tooltip: label,
+		onClick: handleClick,
+		...buttonProps,
+		ref,
+		children: children ?? /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			/* @__PURE__ */ jsx(Icon, { fontSize: "small" }),
+			text && /* @__PURE__ */ jsx("span", {
+				className: "tiptap-button-text",
+				children: text
+			}),
+			showShortcut && /* @__PURE__ */ jsx(MarkShortcutBadge, {
+				type,
+				shortcutKeys
+			})
+		] })
+	});
+});
+MarkButton.displayName = "MarkButton";
+//#endregion
+//#region ../../node_modules/.pnpm/@mui+icons-material@9.4.0_@mui+material@9.4.0_@emotion+react@11.14.0_@types+react@19.2._02cb1dd638d2ccdea7d16c50ea4ea174/node_modules/@mui/icons-material/FormatAlignCenterRounded.mjs
+var FormatAlignCenterRounded_default = SvgIcon_default(/*#__PURE__*/ jsx("path", { d: "M7 16c0 .55.45 1 1 1h8c.55 0 1-.45 1-1s-.45-1-1-1H8c-.55 0-1 .45-1 1m-3 5h16c.55 0 1-.45 1-1s-.45-1-1-1H4c-.55 0-1 .45-1 1s.45 1 1 1m0-8h16c.55 0 1-.45 1-1s-.45-1-1-1H4c-.55 0-1 .45-1 1s.45 1 1 1m3-5c0 .55.45 1 1 1h8c.55 0 1-.45 1-1s-.45-1-1-1H8c-.55 0-1 .45-1 1M3 4c0 .55.45 1 1 1h16c.55 0 1-.45 1-1s-.45-1-1-1H4c-.55 0-1 .45-1 1" }), "FormatAlignCenterRounded");
+//#endregion
+//#region ../../node_modules/.pnpm/@mui+icons-material@9.4.0_@mui+material@9.4.0_@emotion+react@11.14.0_@types+react@19.2._02cb1dd638d2ccdea7d16c50ea4ea174/node_modules/@mui/icons-material/FormatAlignJustifyRounded.mjs
+var FormatAlignJustifyRounded_default = SvgIcon_default(/*#__PURE__*/ jsx("path", { d: "M4 21h16c.55 0 1-.45 1-1s-.45-1-1-1H4c-.55 0-1 .45-1 1s.45 1 1 1m0-4h16c.55 0 1-.45 1-1s-.45-1-1-1H4c-.55 0-1 .45-1 1s.45 1 1 1m0-4h16c.55 0 1-.45 1-1s-.45-1-1-1H4c-.55 0-1 .45-1 1s.45 1 1 1m0-4h16c.55 0 1-.45 1-1s-.45-1-1-1H4c-.55 0-1 .45-1 1s.45 1 1 1M3 4c0 .55.45 1 1 1h16c.55 0 1-.45 1-1s-.45-1-1-1H4c-.55 0-1 .45-1 1" }), "FormatAlignJustifyRounded");
+//#endregion
+//#region ../../node_modules/.pnpm/@mui+icons-material@9.4.0_@mui+material@9.4.0_@emotion+react@11.14.0_@types+react@19.2._02cb1dd638d2ccdea7d16c50ea4ea174/node_modules/@mui/icons-material/FormatAlignLeftRounded.mjs
+var FormatAlignLeftRounded_default = SvgIcon_default(/*#__PURE__*/ jsx("path", { d: "M14 15H4c-.55 0-1 .45-1 1s.45 1 1 1h10c.55 0 1-.45 1-1s-.45-1-1-1m0-8H4c-.55 0-1 .45-1 1s.45 1 1 1h10c.55 0 1-.45 1-1s-.45-1-1-1M4 13h16c.55 0 1-.45 1-1s-.45-1-1-1H4c-.55 0-1 .45-1 1s.45 1 1 1m0 8h16c.55 0 1-.45 1-1s-.45-1-1-1H4c-.55 0-1 .45-1 1s.45 1 1 1M3 4c0 .55.45 1 1 1h16c.55 0 1-.45 1-1s-.45-1-1-1H4c-.55 0-1 .45-1 1" }), "FormatAlignLeftRounded");
+//#endregion
+//#region ../../node_modules/.pnpm/@mui+icons-material@9.4.0_@mui+material@9.4.0_@emotion+react@11.14.0_@types+react@19.2._02cb1dd638d2ccdea7d16c50ea4ea174/node_modules/@mui/icons-material/FormatAlignRightRounded.mjs
+var FormatAlignRightRounded_default = SvgIcon_default(/*#__PURE__*/ jsx("path", { d: "M4 21h16c.55 0 1-.45 1-1s-.45-1-1-1H4c-.55 0-1 .45-1 1s.45 1 1 1m6-4h10c.55 0 1-.45 1-1s-.45-1-1-1H10c-.55 0-1 .45-1 1s.45 1 1 1m-6-4h16c.55 0 1-.45 1-1s-.45-1-1-1H4c-.55 0-1 .45-1 1s.45 1 1 1m6-4h10c.55 0 1-.45 1-1s-.45-1-1-1H10c-.55 0-1 .45-1 1s.45 1 1 1M3 4c0 .55.45 1 1 1h16c.55 0 1-.45 1-1s-.45-1-1-1H4c-.55 0-1 .45-1 1" }), "FormatAlignRightRounded");
+//#endregion
+//#region src/tiptap/components/ui/text-align-button/use-text-align.ts
+var TEXT_ALIGN_SHORTCUT_KEYS = {
+	left: "mod+shift+l",
+	center: "mod+shift+e",
+	right: "mod+shift+r",
+	justify: "mod+shift+j"
+};
+var textAlignIcons = {
+	left: FormatAlignLeftRounded_default,
+	center: FormatAlignCenterRounded_default,
+	right: FormatAlignRightRounded_default,
+	justify: FormatAlignJustifyRounded_default
+};
+var textAlignLabels = {
+	left: "Aligner à gauche",
+	center: "Aligner au centre",
+	right: "Aligner à droite",
+	justify: "Justifier"
+};
+/**
+* Checks if text alignment can be performed in the current editor state
+*/
+function canSetTextAlign(editor, align) {
+	if (!editor || editor.isDestroyed || !editor.isEditable) return false;
+	if (!isExtensionAvailable(editor, "textAlign") || isNodeTypeSelected(editor, ["image", "horizontalRule"])) return false;
+	try {
+		return editor.can().setTextAlign(align);
+	} catch {
+		return false;
+	}
+}
+function hasSetTextAlign(commands) {
+	return "setTextAlign" in commands;
+}
+/**
+* Checks if the text alignment is currently active
+*/
+function isTextAlignActive(editor, align) {
+	if (!editor || !editor.isEditable) return false;
+	return editor.isActive({ textAlign: align });
+}
+/**
+* Sets text alignment in the editor
+*/
+function setTextAlign(editor, align) {
+	if (!editor || editor.isDestroyed || !editor.isEditable) return false;
+	if (!canSetTextAlign(editor, align)) return false;
+	try {
+		const chain = editor.chain().focus();
+		if (hasSetTextAlign(chain)) return chain.setTextAlign(align).run();
+	} catch {
+		return false;
+	}
+	return false;
+}
+/**
+* Determines if the text align button should be shown
+*/
+function shouldShowButton$1(props) {
+	const { editor, hideWhenUnavailable, align } = props;
+	if (!editor) return false;
+	if (!hideWhenUnavailable) return true;
+	if (!editor.isEditable) return false;
+	if (!isExtensionAvailable(editor, "textAlign")) return false;
+	if (!editor.isActive("code")) return canSetTextAlign(editor, align);
+	return true;
+}
+/**
+* Custom hook that provides text align functionality for Tiptap editor
+*
+* @example
+* ```tsx
+* // Simple usage
+* function MySimpleAlignButton() {
+*   const { isVisible, handleTextAlign } = useTextAlign({ align: "center" })
+*
+*   if (!isVisible) return null
+*
+*   return <button onClick={handleTextAlign}>Align Center</button>
+* }
+*
+* // Advanced usage with configuration
+* function MyAdvancedAlignButton() {
+*   const { isVisible, handleTextAlign, label, isActive } = useTextAlign({
+*     editor: myEditor,
+*     align: "right",
+*     hideWhenUnavailable: true,
+*     onAligned: () => console.log('Text aligned!')
+*   })
+*
+*   if (!isVisible) return null
+*
+*   return (
+*     <MyButton
+*       onClick={handleTextAlign}
+*       aria-pressed={isActive}
+*       aria-label={label}
+*     >
+*       Align Right
+*     </MyButton>
+*   )
+* }
+* ```
+*/
+function useTextAlign(config) {
+	const { editor: providedEditor, align, hideWhenUnavailable = false, onAligned } = config;
+	const { editor } = useTiptapEditor(providedEditor);
+	const [isVisible, setIsVisible] = useState(true);
+	const canAlign = canSetTextAlign(editor, align);
+	const isActive = isTextAlignActive(editor, align);
+	useEffect(() => {
+		if (!editor) return;
+		const handleSelectionUpdate = () => {
+			setIsVisible(shouldShowButton$1({
+				editor,
+				align,
+				hideWhenUnavailable
+			}));
+		};
+		handleSelectionUpdate();
+		editor.on("selectionUpdate", handleSelectionUpdate);
+		return () => {
+			editor.off("selectionUpdate", handleSelectionUpdate);
+		};
+	}, [
+		editor,
+		hideWhenUnavailable,
+		align
+	]);
+	return {
+		isVisible,
+		isActive,
+		handleTextAlign: useCallback(() => {
+			if (!editor) return false;
+			const success = setTextAlign(editor, align);
+			if (success) onAligned?.();
+			return success;
+		}, [
+			editor,
+			align,
+			onAligned
+		]),
+		canAlign,
+		label: textAlignLabels[align],
+		shortcutKeys: TEXT_ALIGN_SHORTCUT_KEYS[align],
+		Icon: textAlignIcons[align]
+	};
+}
+//#endregion
+//#region src/tiptap/components/ui/text-align-button/text-align-button.tsx
+function TextAlignShortcutBadge({ align, shortcutKeys = TEXT_ALIGN_SHORTCUT_KEYS[align] }) {
+	return /* @__PURE__ */ jsx(Badge, { children: parseShortcutKeys({ shortcutKeys }) });
+}
+/**
+* Button component for setting text alignment in a Tiptap editor.
+*
+* For custom button implementations, use the `useTextAlign` hook instead.
+*/
+var TextAlignButton = forwardRef(({ editor: providedEditor, align, text, hideWhenUnavailable = false, onAligned, showShortcut = false, onClick, icon: CustomIcon, children, ...buttonProps }, ref) => {
+	const { editor } = useTiptapEditor(providedEditor);
+	const { isVisible, handleTextAlign, label, canAlign, isActive, Icon, shortcutKeys } = useTextAlign({
+		editor,
+		align,
+		hideWhenUnavailable,
+		onAligned
+	});
+	const handleClick = useCallback((event) => {
+		onClick?.(event, !isActive);
+		if (event.defaultPrevented) return;
+		handleTextAlign();
+	}, [handleTextAlign, onClick]);
+	if (!isVisible) return null;
+	const RenderIcon = CustomIcon ?? Icon;
+	return /* @__PURE__ */ jsx(Button, {
+		value: align,
+		type: "button",
+		disabled: !canAlign,
+		selected: isActive,
+		"data-disabled": !canAlign,
+		role: "button",
+		tabIndex: -1,
+		"aria-label": label,
+		tooltip: label,
+		onClick: handleClick,
+		...buttonProps,
+		ref,
+		children: children ?? /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			/* @__PURE__ */ jsx(RenderIcon, { fontSize: "small" }),
+			text && /* @__PURE__ */ jsx("span", {
+				className: "tiptap-button-text",
+				children: text
+			}),
+			showShortcut && /* @__PURE__ */ jsx(TextAlignShortcutBadge, {
+				align,
+				shortcutKeys
+			})
+		] })
+	});
+});
+TextAlignButton.displayName = "TextAlignButton";
+//#endregion
+//#region ../../node_modules/.pnpm/@mui+icons-material@9.4.0_@mui+material@9.4.0_@emotion+react@11.14.0_@types+react@19.2._02cb1dd638d2ccdea7d16c50ea4ea174/node_modules/@mui/icons-material/RedoRounded.mjs
+var RedoRounded_default = SvgIcon_default(/*#__PURE__*/ jsx("path", { d: "M18.4 10.6C16.55 8.99 14.15 8 11.5 8c-4.16 0-7.74 2.42-9.44 5.93-.32.67.04 1.47.75 1.71.59.2 1.23-.08 1.5-.64 1.3-2.66 4.03-4.5 7.19-4.5 1.95 0 3.73.72 5.12 1.88l-1.91 1.91c-.63.63-.19 1.71.7 1.71H21c.55 0 1-.45 1-1V9.41c0-.89-1.08-1.34-1.71-.71z" }), "RedoRounded");
+//#endregion
+//#region ../../node_modules/.pnpm/@mui+icons-material@9.4.0_@mui+material@9.4.0_@emotion+react@11.14.0_@types+react@19.2._02cb1dd638d2ccdea7d16c50ea4ea174/node_modules/@mui/icons-material/UndoRounded.mjs
+var UndoRounded_default = SvgIcon_default(/*#__PURE__*/ jsx("path", { d: "M12.5 8c-2.65 0-5.05.99-6.9 2.6L3.71 8.71C3.08 8.08 2 8.52 2 9.41V15c0 .55.45 1 1 1h5.59c.89 0 1.34-1.08.71-1.71l-1.91-1.91c1.39-1.16 3.16-1.88 5.12-1.88 3.16 0 5.89 1.84 7.19 4.5.27.56.91.84 1.5.64.71-.23 1.07-1.04.75-1.72C20.23 10.42 16.65 8 12.5 8" }), "UndoRounded");
+//#endregion
+//#region src/tiptap/components/ui/undo-redo-button/use-undo-redo.ts
+var UNDO_REDO_SHORTCUT_KEYS = {
+	undo: "mod+z",
+	redo: "mod+shift+z"
+};
+var historyActionLabels = {
+	undo: "Annuler",
+	redo: "Rétablir"
+};
+var historyIcons = {
+	undo: UndoRounded_default,
+	redo: RedoRounded_default
+};
+/**
+* Checks if a history action can be executed
+*/
+function canExecuteUndoRedoAction(editor, action) {
+	if (!editor || editor.isDestroyed || !editor.isEditable) return false;
+	try {
+		if (isNodeTypeSelected(editor, ["image"])) return false;
+		const commands = editor.can();
+		const command = action === "undo" ? commands.undo : commands.redo;
+		return typeof command === "function" ? command() : false;
+	} catch {
+		return false;
+	}
+}
+/**
+* Executes a history action on the editor
+*/
+function executeUndoRedoAction(editor, action) {
+	if (!editor || editor.isDestroyed || !editor.isEditable) return false;
+	if (!canExecuteUndoRedoAction(editor, action)) return false;
+	try {
+		const chain = editor.chain().focus();
+		return action === "undo" ? chain.undo().run() : chain.redo().run();
+	} catch {
+		return false;
+	}
+}
+/**
+* Determines if the history button should be shown
+*/
+function shouldShowButton(props) {
+	const { editor, hideWhenUnavailable, action } = props;
+	if (!editor) return false;
+	if (!hideWhenUnavailable) return true;
+	if (!editor.isEditable) return false;
+	if (!editor.isActive("code")) return canExecuteUndoRedoAction(editor, action);
+	return true;
+}
+/**
+* Custom hook that provides history functionality for Tiptap editor
+*
+* @example
+* ```tsx
+* // Simple usage
+* function MySimpleUndoButton() {
+*   const { isVisible, handleAction } = useHistory({ action: "undo" })
+*
+*   if (!isVisible) return null
+*
+*   return <button onClick={handleAction}>Undo</button>
+* }
+*
+* // Advanced usage with configuration
+* function MyAdvancedRedoButton() {
+*   const { isVisible, handleAction, label } = useHistory({
+*     editor: myEditor,
+*     action: "redo",
+*     hideWhenUnavailable: true,
+*     onExecuted: () => console.log('Action executed!')
+*   })
+*
+*   if (!isVisible) return null
+*
+*   return (
+*     <MyButton
+*       onClick={handleAction}
+*       aria-label={label}
+*     >
+*       Redo
+*     </MyButton>
+*   )
+* }
+* ```
+*/
+function useUndoRedo(config) {
+	const { editor: providedEditor, action, hideWhenUnavailable = false, onExecuted } = config;
+	const { editor } = useTiptapEditor(providedEditor);
+	const [isVisible, setIsVisible] = useState(true);
+	const canExecute = canExecuteUndoRedoAction(editor, action);
+	useEffect(() => {
+		if (!editor) return;
+		const handleUpdate = () => {
+			setIsVisible(shouldShowButton({
+				editor,
+				hideWhenUnavailable,
+				action
+			}));
+		};
+		handleUpdate();
+		editor.on("transaction", handleUpdate);
+		return () => {
+			editor.off("transaction", handleUpdate);
+		};
+	}, [
+		editor,
+		hideWhenUnavailable,
+		action
+	]);
+	return {
+		isVisible,
+		handleAction: useCallback(() => {
+			if (!editor) return false;
+			const success = executeUndoRedoAction(editor, action);
+			if (success) onExecuted?.();
+			return success;
+		}, [
+			editor,
+			action,
+			onExecuted
+		]),
+		canExecute,
+		label: historyActionLabels[action],
+		shortcutKeys: UNDO_REDO_SHORTCUT_KEYS[action],
+		Icon: historyIcons[action]
+	};
+}
+//#endregion
+//#region src/tiptap/components/ui/undo-redo-button/undo-redo-button.tsx
+function HistoryShortcutBadge({ action, shortcutKeys = UNDO_REDO_SHORTCUT_KEYS[action] }) {
+	return /* @__PURE__ */ jsx(Badge, { children: parseShortcutKeys({ shortcutKeys }) });
+}
+/**
+* Button component for triggering undo/redo actions in a Tiptap editor.
+*
+* For custom button implementations, use the `useHistory` hook instead.
+*/
+var UndoRedoButton = forwardRef(({ editor: providedEditor, action, text, hideWhenUnavailable = false, onExecuted, showShortcut = false, onClick, children, ...buttonProps }, ref) => {
+	const { editor } = useTiptapEditor(providedEditor);
+	const { isVisible, handleAction, label, canExecute, Icon, shortcutKeys } = useUndoRedo({
+		editor,
+		action,
+		hideWhenUnavailable,
+		onExecuted
+	});
+	const handleClick = useCallback((event) => {
+		onClick?.(event, true);
+		if (event.defaultPrevented) return;
+		handleAction();
+	}, [handleAction, onClick]);
+	if (!isVisible) return null;
+	return /* @__PURE__ */ jsx(Button, {
+		value: action,
+		type: "button",
+		disabled: !canExecute,
+		"data-disabled": !canExecute,
+		role: "button",
+		tabIndex: -1,
+		"aria-label": label,
+		tooltip: label,
+		onClick: handleClick,
+		...buttonProps,
+		ref,
+		children: children ?? /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			/* @__PURE__ */ jsx(Icon, { fontSize: "small" }),
+			text && /* @__PURE__ */ jsx("span", {
+				className: "tiptap-button-text",
+				children: text
+			}),
+			showShortcut && /* @__PURE__ */ jsx(HistoryShortcutBadge, {
+				action,
+				shortcutKeys
+			})
+		] })
+	});
+});
+UndoRedoButton.displayName = "UndoRedoButton";
+//#endregion
+//#region src/tiptap/hooks/use-composed-ref.ts
+var updateRef = (ref, value) => {
+	if (typeof ref === "function") ref(value);
+	else if (ref && typeof ref === "object" && "current" in ref) {
+		const mutableRef = ref;
+		mutableRef.current = value;
+	}
+};
+var useComposedRef = (libRef, userRef) => {
+	const prevUserRef = useRef(null);
+	return useCallback((instance) => {
+		if (libRef && "current" in libRef) {
+			const mutableLibRef = libRef;
+			mutableLibRef.current = instance;
+		}
+		if (prevUserRef.current) updateRef(prevUserRef.current, null);
+		prevUserRef.current = userRef;
+		if (userRef) updateRef(userRef, instance);
+	}, [libRef, userRef]);
+};
+//#endregion
+//#region src/tiptap/hooks/use-menu-navigation.ts
+/**
+* Hook that implements keyboard navigation for dropdown menus and command palettes.
+*
+* Handles arrow keys, tab, home/end, enter for selection, and escape to close.
+* Works with both Tiptap editors and regular DOM elements.
+*
+* @param options - Configuration options for the menu navigation
+* @returns Object containing the selected index and a setter function
+*/
+function useMenuNavigation({ editor, containerRef, query, items, onSelect, onClose, orientation = "vertical", autoSelectFirstItem = true, loopOnTab = true }) {
+	const [selectedIndex, setSelectedIndex] = useState(autoSelectFirstItem ? 0 : -1);
+	useEffect(() => {
+		const handleKeyboardNavigation = (event) => {
+			if (!items.length) return false;
+			const moveNext = () => setSelectedIndex((currentIndex) => {
+				if (currentIndex === -1) return 0;
+				return (currentIndex + 1) % items.length;
+			});
+			const movePrev = () => setSelectedIndex((currentIndex) => {
+				if (currentIndex === -1) return items.length - 1;
+				return (currentIndex - 1 + items.length) % items.length;
+			});
+			switch (event.key) {
+				case "ArrowUp":
+					if (orientation === "horizontal") return false;
+					event.preventDefault();
+					movePrev();
+					return true;
+				case "ArrowDown":
+					if (orientation === "horizontal") return false;
+					event.preventDefault();
+					moveNext();
+					return true;
+				case "ArrowLeft":
+					if (orientation === "vertical") return false;
+					event.preventDefault();
+					movePrev();
+					return true;
+				case "ArrowRight":
+					if (orientation === "vertical") return false;
+					event.preventDefault();
+					moveNext();
+					return true;
+				case "Tab":
+					if (!loopOnTab) return false;
+					event.preventDefault();
+					if (event.shiftKey) movePrev();
+					else moveNext();
+					return true;
+				case "Home":
+					event.preventDefault();
+					setSelectedIndex(0);
+					return true;
+				case "End":
+					event.preventDefault();
+					setSelectedIndex(items.length - 1);
+					return true;
+				case "Enter":
+					if (event.isComposing) return false;
+					event.preventDefault();
+					if (selectedIndex !== -1 && items[selectedIndex]) onSelect?.(items[selectedIndex]);
+					return true;
+				case "Escape":
+					if (!onClose) return false;
+					event.preventDefault();
+					onClose?.();
+					return true;
+				default: return false;
+			}
+		};
+		let targetElement = null;
+		if (editor) targetElement = editor.view.dom;
+		else if (containerRef?.current) targetElement = containerRef.current;
+		if (targetElement) {
+			targetElement.addEventListener("keydown", handleKeyboardNavigation, true);
+			return () => {
+				targetElement?.removeEventListener("keydown", handleKeyboardNavigation, true);
+			};
+		}
+	}, [
+		editor,
+		containerRef,
+		items,
+		selectedIndex,
+		onSelect,
+		onClose,
+		orientation,
+		loopOnTab
+	]);
+	useEffect(() => {
+		if (query) setSelectedIndex(autoSelectFirstItem ? 0 : -1);
+	}, [query, autoSelectFirstItem]);
+	return {
+		selectedIndex: items.length ? selectedIndex : void 0,
+		setSelectedIndex
+	};
+}
+//#endregion
+//#region src/tiptap/components/ui-primitive/toolbar/toolbar.tsx
+var useToolbarNavigation = (toolbarRef) => {
+	const [items, setItems] = useState([]);
+	const initialContainerTabIndexRef = useRef(void 0);
+	const collectItems = useCallback(() => {
+		if (!toolbarRef.current) return [];
+		return Array.from(toolbarRef.current.querySelectorAll("button:not([disabled]), [role=\"button\"]:not([disabled]), [tabindex=\"0\"]:not([disabled])"));
+	}, [toolbarRef]);
+	useEffect(() => {
+		const toolbar = toolbarRef.current;
+		if (!toolbar) return;
+		if (initialContainerTabIndexRef.current === void 0) initialContainerTabIndexRef.current = toolbar.hasAttribute("tabindex") && toolbar.tabIndex >= 0 ? toolbar.tabIndex : null;
+		const updateItems = () => setItems(collectItems());
+		updateItems();
+		const observer = new MutationObserver(updateItems);
+		observer.observe(toolbar, {
+			childList: true,
+			subtree: true,
+			attributes: true,
+			attributeFilter: ["disabled"]
+		});
+		return () => observer.disconnect();
+	}, [collectItems, toolbarRef]);
+	const { selectedIndex, setSelectedIndex } = useMenuNavigation({
+		containerRef: toolbarRef,
+		items,
+		orientation: "horizontal",
+		onSelect: (el) => el.click(),
+		autoSelectFirstItem: false,
+		loopOnTab: false
+	});
+	useEffect(() => {
+		const toolbar = toolbarRef.current;
+		if (!toolbar) return;
+		const handleFocus = (e) => {
+			const target = e.target;
+			if (toolbar.contains(target)) {
+				target.setAttribute("data-focus-visible", "true");
+				const itemIndex = items.indexOf(target);
+				if (itemIndex >= 0) setSelectedIndex(itemIndex);
+			}
+		};
+		const handleBlur = (e) => {
+			const target = e.target;
+			if (toolbar.contains(target)) target.removeAttribute("data-focus-visible");
+			const nextTarget = e.relatedTarget;
+			const NodeConstructor = toolbar.ownerDocument.defaultView?.Node;
+			if ((!nextTarget || !NodeConstructor || !(nextTarget instanceof NodeConstructor) || !toolbar.contains(nextTarget)) && initialContainerTabIndexRef.current != null) queueMicrotask(() => {
+				if (toolbar.isConnected && !toolbar.contains(toolbar.ownerDocument.activeElement)) {
+					toolbar.tabIndex = initialContainerTabIndexRef.current;
+					setSelectedIndex(-1);
+				}
+			});
+		};
+		toolbar.addEventListener("focus", handleFocus, true);
+		toolbar.addEventListener("blur", handleBlur, true);
+		return () => {
+			toolbar.removeEventListener("focus", handleFocus, true);
+			toolbar.removeEventListener("blur", handleBlur, true);
+		};
+	}, [
+		items,
+		setSelectedIndex,
+		toolbarRef
+	]);
+	useEffect(() => {
+		if (!items.length) return;
+		const toolbar = toolbarRef.current;
+		if (!toolbar) return;
+		const activeEl = toolbar.ownerDocument.activeElement;
+		if (activeEl && !toolbar.contains(activeEl)) return;
+		const initialContainerTabIndex = initialContainerTabIndexRef.current;
+		const currentIndex = selectedIndex ?? -1;
+		if (initialContainerTabIndex != null) {
+			items.forEach((item) => {
+				item.tabIndex = -1;
+			});
+			if (currentIndex >= 0 && items[currentIndex]) {
+				toolbar.tabIndex = -1;
+				items[currentIndex].focus();
+			} else toolbar.tabIndex = initialContainerTabIndex;
+			return;
+		}
+		const existingTabStop = items.findIndex((item) => item.tabIndex === 0);
+		const activeIndex = currentIndex >= 0 && items[currentIndex] ? currentIndex : existingTabStop >= 0 ? existingTabStop : 0;
+		items.forEach((item, index) => {
+			item.tabIndex = index === activeIndex ? 0 : -1;
+		});
+		if (currentIndex >= 0) items[activeIndex]?.focus();
+	}, [
+		selectedIndex,
+		items,
+		toolbarRef
+	]);
+};
+var Toolbar = forwardRef(({ children, className, variant = "fixed", ...props }, ref) => {
+	const toolbarRef = useRef(null);
+	const composedRef = useComposedRef(toolbarRef, ref);
+	useToolbarNavigation(toolbarRef);
+	return /* @__PURE__ */ jsx("div", {
+		ref: composedRef,
+		role: "toolbar",
+		"aria-label": "toolbar",
+		"data-variant": variant,
+		className: cn("tiptap-toolbar", className),
+		...props,
+		children
+	});
+});
+Toolbar.displayName = "Toolbar";
+var ToolbarGroup = forwardRef(({ children, className, ...props }, ref) => /* @__PURE__ */ jsx("div", {
+	ref,
+	role: "group",
+	className: cn("tiptap-toolbar-group", className),
+	...props,
+	children
+}));
+ToolbarGroup.displayName = "ToolbarGroup";
+var ToolbarSeparator = () => /* @__PURE__ */ jsx(Divider, {
+	orientation: "vertical",
+	flexItem: true,
+	sx: { my: 1 }
+});
+ToolbarSeparator.displayName = "ToolbarSeparator";
+//#endregion
+//#region src/tiptap/components/ui-primitive/formatting-controls/formatting-controls.tsx
+var FormattingControls = ({ editor }) => {
+	const hasSuperscriptSubscript = editor.extensionManager.extensions.map((e) => e.name).some((name) => name === "subscript" || name === "superscript");
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [
+		/* @__PURE__ */ jsxs(ToolbarGroup, { children: [/* @__PURE__ */ jsx(UndoRedoButton, { action: "undo" }), /* @__PURE__ */ jsx(UndoRedoButton, { action: "redo" })] }),
+		/* @__PURE__ */ jsx(ToolbarSeparator, {}),
+		/* @__PURE__ */ jsxs(ToolbarGroup, { children: [
+			/* @__PURE__ */ jsx(HeadingMenu, {
+				modal: false,
+				levels: [
+					1,
+					2,
+					3,
+					4
+				]
+			}),
+			/* @__PURE__ */ jsx(ListButton, { type: "bulletList" }),
+			/* @__PURE__ */ jsx(ListButton, { type: "orderedList" }),
+			/* @__PURE__ */ jsx(BlockquoteButton, {}),
+			/* @__PURE__ */ jsx(CodeBlockButton, {})
+		] }),
+		/* @__PURE__ */ jsx(ToolbarSeparator, {}),
+		/* @__PURE__ */ jsxs(ToolbarGroup, { children: [
+			/* @__PURE__ */ jsx(MarkButton, { type: "bold" }),
+			/* @__PURE__ */ jsx(MarkButton, { type: "italic" }),
+			/* @__PURE__ */ jsx(MarkButton, { type: "strike" }),
+			/* @__PURE__ */ jsx(MarkButton, { type: "code" }),
+			/* @__PURE__ */ jsx(MarkButton, { type: "underline" }),
+			/* @__PURE__ */ jsx(LinkPopover, {})
+		] }),
+		hasSuperscriptSubscript ? /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(ToolbarSeparator, {}), /* @__PURE__ */ jsxs(ToolbarGroup, { children: [/* @__PURE__ */ jsx(MarkButton, { type: "superscript" }), /* @__PURE__ */ jsx(MarkButton, { type: "subscript" })] })] }) : null,
+		/* @__PURE__ */ jsx(ToolbarSeparator, {}),
+		/* @__PURE__ */ jsxs(ToolbarGroup, { children: [
+			/* @__PURE__ */ jsx(TextAlignButton, { align: "left" }),
+			/* @__PURE__ */ jsx(TextAlignButton, { align: "center" }),
+			/* @__PURE__ */ jsx(TextAlignButton, { align: "right" }),
+			/* @__PURE__ */ jsx(TextAlignButton, { align: "justify" })
+		] })
+	] });
+};
+FormattingControls.displayName = "FormattingControls";
+//#endregion
+//#region src/tiptap/components/ui-primitive/spacer/spacer.tsx
+function Spacer({ orientation = "horizontal", size, style = {}, ...props }) {
+	const computedStyle = {
+		...style,
+		...orientation === "horizontal" && !size && { flex: 1 },
+		...size && {
+			width: orientation === "vertical" ? "1px" : size,
+			height: orientation === "horizontal" ? "1px" : size
+		}
+	};
+	return /* @__PURE__ */ jsx("div", {
+		...props,
+		style: computedStyle
+	});
+}
+//#endregion
+export { FormattingControls, Spacer, Toolbar, ToolbarGroup, ToolbarSeparator };
+
+//# sourceMappingURL=index.es.js.map