@witchcraft/editor 0.0.1

package/src/runtime/pm/features/Menus/Menus.ts

@@ -0,0 +1,195 @@
+import { type Command, Extension } from "@tiptap/core"
+import { type EditorState, Plugin, type PluginKey } from "@tiptap/pm/state"
+
+import { type Menu, menusPluginKey, type OpenMenuInfo } from "./types.js"
+
+import { createStateOnlyPluginObjApply } from "../../utils/createStateOnlyPluginObjApply.js"
+
+declare module "@tiptap/core" {
+
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	interface Commands<ReturnType> {
+		menus: {
+			/** Can be used to close the open menu. Use force to close pinned menus. */
+			closeOtherMenus: (forceUnpin?: boolean) => ReturnType
+			/** This will temporarily open and "pin" the menu, disabling the auto-prioritizing, until it's closed with `force: true`. */
+			pinOpenMenu: (options: Pick<OpenMenuInfo, "name">) => ReturnType
+			/**
+			 * Register a menu to be hnadled by the Menus extension.
+			 *
+			 * The ideal place to register them is usually in the onCreate hook of the extension. Do not do it from addProseMirrorPlugins as this will cause the menus to be registered more times than they should be.
+			 *
+			 * To be technical, this happens because the DocumentApi creates a state using a copy of the editor's plugins from the extension manager. The problem is not the copy but that the plugin property is actually a getter that calls `addProseMirrorPlugins` so the functon must not have side-effects.
+			 */
+			registerMenu: <TPluginKey extends PluginKey<any>>(menu: Menu<TPluginKey>) => ReturnType
+			/**
+			 * Since most mark menus don't have a close command, this is can be used to temporarily disable them.
+			 *
+			 * This should not be used to more permanantly turn off mark menus, as internally this is used to temporarily disable AND enable them. All optional mark menus have options to disable them.
+			 */
+			disableMarkMenus: () => ReturnType
+			/**
+			 * Enables showing of mark menus again.
+			 */
+			enableMarkMenus: () => ReturnType
+
+		}
+	}
+}
+
+/**
+ * Helps coordinate the display of different menus, never allowing more than one to be opened, sorting by priority, and autoclosing others. \*.
+ *
+ * If this extension is available, extensions with menus will register themselves, some with a higher priority than others.
+ *
+ * On each transaction, the extension will check in order of priority if any of the registered menus should be opened and save which menu that is to it's `menusPluginKey`, closing other open menus.
+ *
+ * The MarkMenuManager component is used in the editor wrapper to easily display "mark" menus  with the help of this extension. If it is not used, they won't show since they must be added manually. The commponent reads the saved state and if the menu is a mark menu and a renderer has been provided for it using the `menusInjectionKey`, it renders the menu. The editor wrapper provides the `menus` option which takes care of providing the menus.
+ *
+ * \* Note that menus may choose to not implement or not provide a close command. In cases like "mark" menus this is fine if using the MarkMenuManager since it will only ever display one menu, but can otherwise break the intended purpose of the extension.
+ */
+
+// eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-empty-object-type
+export const Menus = Extension.create<{}, { menus: Menu[] }>({
+	name: "menus",
+	addStorage() {
+		return {
+			menus: []
+		}
+	},
+	addCommands() {
+		return {
+			enableMarkMenus: (): Command => ({ tr, dispatch }) => {
+				if (dispatch) {
+					tr.setMeta(menusPluginKey, {
+						canShow: true
+					})
+				}
+				return true
+			},
+			disableMarkMenus: (): Command => ({ tr, dispatch }) => {
+				if (dispatch) {
+					tr.setMeta(menusPluginKey, {
+						canShow: false
+					})
+				}
+				return true
+			},
+
+			registerMenu: <TPluginKey extends PluginKey<any>>(menu: Menu<TPluginKey>): Command => () => {
+				const menus = this.storage.menus
+				const existingIndex = menus.findIndex(m => m.name === menu.name)
+				if (existingIndex >= 0) {
+					// eslint-disable-next-line no-console
+					console.warn("Menu already registered, replacing.", {
+						existing: menus[existingIndex],
+						new: menu
+					})
+					menus.splice(existingIndex, 1, menu)
+				}
+				menus.push(menu)
+				menus.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0))
+				return true
+			},
+			unregisterMenu: (menu: Menu): Command => ({ tr }) => {
+				const menus = this.storage.menus
+				const index = menus.indexOf(menu)
+				if (index !== -1) {
+					menus.splice(index, 1)
+					tr.setMeta(menusPluginKey, { menus })
+					return true
+				}
+				return false
+			},
+			pinOpenMenu: (options: Pick<OpenMenuInfo, "name">): Command => ({ dispatch, tr, commands }) => {
+				const menus = this.storage.menus
+				const menu = menus.find(m => m.name === options.name)
+				if (!menu) {
+					// eslint-disable-next-line no-console
+					console.warn("Menu to open not found.", options)
+					return false
+				}
+				commands.closeOtherMenus(true)
+				if (dispatch) {
+					tr.setMeta(menusPluginKey, {
+						state: true,
+						pin: true,
+						menu
+					})
+				}
+				return true
+			},
+			closeOtherMenus: (forceUnpin: boolean = false): Command => ({ dispatch, tr, state, commands }) => {
+				const other = menusPluginKey.getState(state)
+				if (other?.pin && !forceUnpin) return false
+				const otherMenu = other?.menu
+				if (otherMenu?.closeCommand) {
+					commands[otherMenu.closeCommand]()
+					if (dispatch) {
+						tr.setMeta(menusPluginKey, {
+							state: false,
+							menu: undefined
+						})
+					}
+					return true
+				}
+				return false
+			}
+		}
+	},
+	addProseMirrorPlugins() {
+		const self = this
+		return [
+			new Plugin({
+				key: menusPluginKey,
+				state: {
+					init() {
+						return {
+							state: false,
+							pin: false,
+							canShow: true
+						}
+					},
+					apply: createStateOnlyPluginObjApply(menusPluginKey)
+				},
+				appendTransaction(trs, oldState, newState) {
+					const menuWasSetByTrs = trs.some(tr => tr.getMeta(menusPluginKey))
+					if (menuWasSetByTrs) return undefined
+					const menus = self.storage.menus
+					const activeMenu = getActiveMenu(menus, newState)
+					const value = menusPluginKey.getState(newState)
+					const valueWas = menusPluginKey.getState(oldState)
+					if (valueWas?.pin) { return undefined }
+					if (value?.state !== !!activeMenu || value?.menu?.name !== activeMenu?.name) {
+						return newState.tr.setMeta(menusPluginKey, {
+							state: !!activeMenu,
+							menu: activeMenu
+								? {
+										name: activeMenu.name,
+										type: activeMenu.type,
+										closeCommand: activeMenu.closeCommand
+									}
+								: undefined
+						})
+					}
+					return undefined
+				}
+			})
+		]
+	}
+})
+
+function getActiveMenu(menus: Menu[] | undefined, state: EditorState): Menu | undefined {
+	if (!menus) return undefined
+	for (const menu of menus) {
+		const menuState = menu.pluginKey.getState(state)
+		if (menuState === undefined) {
+			// eslint-disable-next-line no-console
+			console.warn("Menu plugin state is undefined. Did you register a plugin with this key?", menu.pluginKey, menu.name)
+		}
+		if (menu.canShow(state, menuState)) {
+			return menu
+		}
+	}
+	return undefined
+}

package/src/runtime/pm/features/Menus/components/MarkMenuManager.vue

@@ -0,0 +1,203 @@
+<template>
+<!-- @vue-expect-error -->
+<WPopup
+	:model-value="!!activeMarkMenu"
+	:preferred-horizontal="['center-most']"
+	:preferred-vertical="['top-most']"
+	:modify-position="modifyPopupToMenuBounds"
+	:use-backdrop="false"
+	class="[&>div]:transition-[left,top] duration-30"
+	ref="popupComponent"
+>
+	<template #popup="{ extractEl }">
+		<div
+			tabindex="0"
+			class="p-2"
+			:ref="_ => { extractEl(_); menuEl = _ as HTMLElement }"
+			@keydown.esc="close"
+		>
+			<component
+				v-if="menuRenderer?.component"
+				:editor="editor"
+				:is="menuRenderer.component"
+				ref="component"
+				v-bind="menuRenderer?.props?.(editor as any) ?? { editor }"
+				@close="close"
+				@copy="copy"
+			/>
+		</div>
+	</template>
+</WPopup>
+</template>
+
+<script setup lang="ts">
+import type { Editor } from "@tiptap/vue-3"
+import WPopup from "@witchcraft/ui/components/LibPopup"
+import { copy } from "@witchcraft/ui/helpers/copy"
+import type { IPopupReference, PopupPositionModifier, SimpleDOMRect } from "@witchcraft/ui/types"
+import {
+	computed,
+	inject,
+	nextTick,
+	ref,
+	useTemplateRef,
+	watch,
+	watchEffect
+} from "vue"
+
+import { findUpwards } from "../../../utils/findUpwards.js"
+import { type MenuRenderInfo, menusInjectionKey, menusPluginKey } from "../types.js"
+
+const props = withDefaults(defineProps<{
+	editor: Editor
+}>(), {
+})
+const menus = inject(menusInjectionKey, ref({} as Record<string, MenuRenderInfo>))
+
+const activeMarkMenu = ref<string | undefined>()
+const menuRenderer = computed(() => {
+	if (!activeMarkMenu.value) return undefined
+	const menuCompInfo = menus?.value?.[activeMarkMenu.value]
+	return menuCompInfo
+})
+
+const popupComponent = useTemplateRef("popupComponent")
+const menuEl = ref<HTMLElement | null>(null)
+const virtualEditorEl = ref<IPopupReference | null>(null)
+const virtualCursorEl = ref<IPopupReference | null>(null)
+
+function virtualCursorGetBoundingClientRect(): SimpleDOMRect {
+	const opts = menuRenderer.value?.popupOptions
+	const selection = props.editor.state.selection
+	const doc = props.editor.state.doc
+	const $fromItem = findUpwards(doc, selection.from, $pos => $pos.node().type.name === "item")?.$pos
+
+	const end = props.editor.view.coordsAtPos(selection.to)
+	const start = props.editor.view.coordsAtPos(selection.from)
+	// attempt to pin to the top of the item if it's close enough
+	const itemStart = props.editor.view.coordsAtPos($fromItem?.pos ?? selection.from)
+	const pinToItemDistance = typeof opts?.pinToItemDistance === "function"
+		? opts?.pinToItemDistance(props.editor.state as any)
+		: opts?.pinToItemDistance ?? 0
+	// absolute just in case, doubts it's possible
+	const itemStartIsShortDistance = Math.abs(start.top - itemStart.top) < pinToItemDistance
+
+	const leftMost = Math.min(start.left, end.left)
+	const rightMost = Math.max(start.right, end.right)
+	const topMost = Math.min(start.top, end.top, itemStartIsShortDistance ? itemStart.top : Infinity)
+	const bottomMost = Math.max(start.bottom, end.bottom)
+	return {
+		x: leftMost,
+		y: topMost,
+		top: topMost,
+		bottom: bottomMost,
+		left: leftMost,
+		right: rightMost,
+		width: rightMost - leftMost,
+		height: bottomMost - topMost
+	}
+}
+
+function virtualEditorGetBoundingClientRect(): SimpleDOMRect {
+	// constrain it horizontally to the editor
+	// but not vertically
+	// this is so we can later modify the position when we know the height of the menu
+	// so at most it's allowed to be one menu height above the editor unless it hit the window already (which is handled here)
+	// it being below shouldn't be a problem since we're using top-most positioning
+	// it's guarded against below anyways
+	const editorRect = props.editor.view.dom.getBoundingClientRect()
+	const bodyRect = document.body.getBoundingClientRect()
+	return {
+		x: editorRect.x,
+		left: editorRect.left,
+		right: editorRect.right,
+		width: editorRect.width,
+
+		y: 0,
+		top: 0,
+		bottom: bodyRect.bottom,
+		height: bodyRect.height
+	}
+}
+
+const modifyPopupToMenuBounds: PopupPositionModifier = (pos, reference, popup, _bg, space) => {
+	const editorRect = props.editor.view.dom.closest(".editor-wrapper")?.getBoundingClientRect()
+	if (!editorRect) {
+		throw new Error("MarkMenuManager: The wrapping scrollable editor component must have the `editor-wrapper` class for mark menus to work as they need to know the position of the scrollable wrapper.")
+	}
+	const yMin = Math.max(editorRect.top - popup.height, 0)
+	if (pos.y < yMin) pos.y = yMin
+
+	// under no circumstances should	the menu be over the cursor
+	// the popup menu algorithm doesn't allow for not covering the reference element
+	// so we manually stick it above/below
+	if (reference && pos.y + popup.height > reference.top) {
+		pos.y = space.bottom > space.top
+			? reference.bottom
+			: reference.top - popup.height
+	}
+	return pos
+}
+
+function close(e?: Event): void {
+	e?.preventDefault()
+	props.editor.commands.closeOtherMenus()
+}
+
+function documentRefocusBlur(e: Event) {
+	document.removeEventListener("focus", documentRefocusBlur)
+	checkMenuBlur(e)
+}
+function checkMenuBlur(e: Event) {
+	if ("relatedTarget" in e) {
+		// allow window to lose focus and menu to stay open if it was focused
+		// only blur if when we focus back we're outside the menu
+		if (e.relatedTarget === null) {
+			document.addEventListener("focus", documentRefocusBlur)
+		} else if (!menuEl.value?.contains(e.relatedTarget as Node)) {
+			close(e)
+		}
+	}
+}
+
+watchEffect(() => {
+	if (activeMarkMenu.value) {
+		document.addEventListener("click", checkMenuBlur)
+		virtualCursorEl.value = { getBoundingClientRect: virtualCursorGetBoundingClientRect }
+		popupComponent.value?.setReference(virtualCursorEl.value)
+		virtualEditorEl.value = { getBoundingClientRect: virtualEditorGetBoundingClientRect }
+		popupComponent.value?.setBackground(virtualEditorEl.value)
+	} else {
+		document.removeEventListener("click", checkMenuBlur)
+		virtualCursorEl.value = null
+		popupComponent.value?.setReference(virtualCursorEl.value!)
+		virtualEditorEl.value = null
+		popupComponent.value?.setBackground(virtualEditorEl.value)
+	}
+})
+const recompute = () => {
+	nextTick(() => {
+		popupComponent.value?.recompute()
+	})
+}
+function updateState() {
+	const state = menusPluginKey.getState(props.editor.state)
+	if (state?.menu?.type === "mark" && state.canShow) {
+		activeMarkMenu.value = state?.menu?.name
+		recompute()
+	} else {
+		activeMarkMenu.value = undefined
+	}
+}
+
+// mmm feels weird when moving upwards
+// const debouncedRecompute = throttle(recompute, 1000, { leading: true, trailing: true })
+// menu is mounted once then hidden so we have to listen directly
+// also tiptap's shouldShow does not work well
+// hooking into transactions directly to avoid issues
+watch(() => props.editor, (newVal, oldVal) => {
+	oldVal.off("transaction", updateState)
+	newVal.on("transaction", updateState)
+})
+props.editor.on("transaction", updateState)
+</script>

package/src/runtime/pm/features/Menus/types.ts

@@ -0,0 +1,64 @@
+import type { Editor } from "@tiptap/core"
+import { type EditorState, PluginKey } from "@tiptap/pm/state"
+import type { Component, InjectionKey, Ref } from "vue"
+
+export interface MenuCloseCommands {
+}
+/**
+ * Menus describe how to close them again with this key.
+ *
+ * It can be used by other menus to close any open menus before opening itself (see {@link closeOtherMenus}).
+ *
+ * The close command must not need to take any arguments.
+ *
+ * You can extend the `MenuCloseCommands` interface to add more commands.
+ */
+
+export const menusPluginKey = new PluginKey<MenusPluginState>("menus")
+export type MenusPluginState = {
+	state: boolean
+	menu?: OpenMenuInfo
+	pin: boolean
+	canShow: boolean
+}
+
+export interface BaseMenu<
+	T extends PluginKey<any> | undefined = PluginKey<any> | undefined
+> {
+	name: string
+	closeCommand: keyof MenuCloseCommands | undefined
+	type: "context" | "floating" | "mark"
+	pluginKey: T extends PluginKey<any> ? T : never
+	priority?: number
+	canShow: T extends PluginKey<any> ? (state: EditorState, pluginState: ReturnType<T["getState"]>) => boolean : never
+}
+export type OpenMenuInfo = Omit<BaseMenu, "pluginKey" | "canShow">
+export interface ContextMenu<
+	T extends PluginKey<any> | undefined = PluginKey<any> | undefined
+> extends BaseMenu<T> {
+	type: "context"
+}
+export interface FloatingMenu<
+	T extends PluginKey<any> | undefined = PluginKey<any> | undefined
+> extends BaseMenu<T> {
+	type: "floating"
+}
+export interface MarkMenu<
+	T extends PluginKey<any> = PluginKey<any>
+> extends BaseMenu<T> {
+	type: "mark"
+}
+export type Menu<T extends PluginKey<any> = PluginKey<any>> = MarkMenu<T> | FloatingMenu<T> | ContextMenu<T>
+
+export type MenuRenderInfo = {
+	props?: (editor: Editor) => Record<string, any>
+	component: Component
+	popupOptions?: {
+		/**
+		 * Attempts to pin the mark menu to the top of the item if the cursor is this close or less to it. Set to a number greater than zero or return a number greater than 0 to enable it.
+		 */
+		pinToItemDistance?: number | ((state: EditorState) => number)
+	}
+}
+
+export const menusInjectionKey = Symbol("menusInjectionKey") as InjectionKey<(Ref<Record<string, MenuRenderInfo>>)>

package/src/runtime/pm/features/Menus/utils/isMarkMenu.ts

@@ -0,0 +1,5 @@
+import type { MarkMenu, Menu } from "../types.js"
+
+export function isMarkMenu(menu: Menu): menu is MarkMenu {
+	return menu.type === "mark"
+}

package/src/runtime/pm/features/Tables/commands/tableEnter.ts

@@ -0,0 +1,40 @@
+import { type Command, getNodeType } from "@tiptap/core"
+import type { NodeType } from "@tiptap/pm/model"
+
+declare module "@tiptap/core" {
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	interface Commands<ReturnType> {
+		tableEnter: {
+			/**
+			 * Handles enter in a table. Splits the table at the next row, inserting a default item, or if it can't, after the table. Does not delete the selection as it's just weird since delete in a table just clears them.
+			 *
+			 * @redirectable
+			 */
+			tableEnter: (pos?: number) => ReturnType
+		}
+	}
+}
+
+export const tableEnter = (
+	tableTypesOrNames: (string | NodeType)[] = ["table", "tableRow", "tableCell", "tableHeader"],
+	itemTypeOrName: string | NodeType = "item"
+) => (pos?: number): Command => ({ state, dispatch, tr }) => {
+	const itemType = getNodeType(itemTypeOrName, state.schema)
+	const tableType = tableTypesOrNames.map(name => getNodeType(name, state.schema))
+	const { $from, empty } = state.selection
+	const $pos = pos !== undefined ? tr.doc.resolve(pos) : $from
+	const parent = $pos.node(-1)
+	if (tableType.includes(parent.type)) {
+		const item = itemType.createAndFill()
+		if (!item) return false
+		if (dispatch) {
+			if (pos === undefined && !empty) {
+				// its just weird
+				// tr.delete($from.pos, $to.pos);
+			}
+			tr.insert($from.after(-2), item)
+		}
+		return true
+	}
+	return false
+}

package/src/runtime/pm/features/Tables/index.ts

@@ -0,0 +1,60 @@
+import {
+	Table as TiptapTable,
+	TableCell as TiptapTableCell,
+	TableHeader as TiptapTableHeader,
+	TableRow as TiptapTableRow
+} from "@tiptap/extension-table"
+
+import { tableEnter } from "./commands/tableEnter.js"
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export const TableRow = TiptapTableRow.extend({
+	// force table rows to contain something, otherwise create and fill won't work as expected
+	content: "(tableCell | tableHeader)+",
+	addKeyboardShortcuts() {
+		return {}
+	}
+})
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export const TableCell = TiptapTableCell.extend({
+	content: "block",
+	addKeyboardShortcuts() {
+		return {}
+	}
+})
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export const TableHeader = TiptapTableHeader.extend({
+	content: "block",
+	addKeyboardShortcuts() {
+		return {}
+	}
+})
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export const Table = TiptapTable.extend({
+	addOptions() {
+		return {
+			...(this as any).parent?.(),
+			resizable: true,
+			lastColumnResizable: false
+		}
+	},
+	addCommands() {
+		return {
+			tableEnter: tableEnter()
+		}
+	},
+	addKeyboardShortcuts() {
+		return {}
+	}
+})
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export const TableExtensions = [Table, TableRow, TableCell, TableHeader]
+
+export type NodeTableName = "table"
+export type NodeTableRowName = "tableRow"
+export type NodeTableCellName = "tableCell"
+export type NodeTableHeaderName = "tableHeader"

package/src/runtime/pm/schema.ts

@@ -0,0 +1,128 @@
+import { type EditorOptions, type Extension, getSchema, type Mark, type Node } from "@tiptap/core"
+import { Bold } from "@tiptap/extension-bold"
+import { Code } from "@tiptap/extension-code"
+import { Dropcursor } from "@tiptap/extension-dropcursor"
+import { Gapcursor } from "@tiptap/extension-gapcursor"
+import { Italic } from "@tiptap/extension-italic"
+import { Paragraph } from "@tiptap/extension-paragraph"
+import { Strike } from "@tiptap/extension-strike"
+import { Subscript } from "@tiptap/extension-subscript"
+import { Superscript } from "@tiptap/extension-superscript"
+import { Text } from "@tiptap/extension-text"
+import { Underline } from "@tiptap/extension-underline"
+import type { Schema } from "@tiptap/pm/model"
+
+import { Base } from "./features/Base/Base.js"
+import { Blockquote, Cite, type NodeBlockquoteName, type NodeCiteName } from "./features/Blockquote/Blockquote.js"
+import { Item, type NodeItemName } from "./features/Blocks/Item.js"
+import { List, type NodeListName } from "./features/Blocks/List.js"
+import { CodeBlock, type NodeCodeBlockName } from "./features/CodeBlock/CodeBlock.js"
+import { CommandBar } from "./features/CommandsMenus/CommandBar.js"
+import { Document, type NodeDocumentName } from "./features/Document/Document.js"
+import { EmbeddedDocument, type NodeEmbeddedDocumentName } from "./features/EmbeddedDocument/EmbeddedDocument.js"
+import { HardBreak } from "./features/HardBreak/HardBreak.js"
+import { Heading, type NodeHeadingName } from "./features/Heading/Heading.js"
+import { Highlight, type MarkHighlightName } from "./features/Highlight/Highlight.js"
+import { History } from "./features/History/History.js"
+import { Iframe, type NodeIframeName } from "./features/Iframe/Iframe.js"
+import { Image } from "./features/Image/Image.js"
+import { Link } from "./features/Link/Link.js"
+import { Menus } from "./features/Menus/Menus.js"
+import { type NodeTableCellName, type NodeTableHeaderName, type NodeTableName, type NodeTableRowName, TableExtensions } from "./features/Tables/index.js"
+
+function stripShortcuts<T extends Node | Mark | Extension>(c: T): T {
+	return c.extend({
+		addKeyboardShortcuts() {
+			return {}
+		}
+	}) as any
+}
+
+export const extensions: EditorOptions["extensions"] = [
+	Document,
+	Gapcursor,
+	Dropcursor,
+	// custom
+	stripShortcuts(Paragraph.extend({
+		group: "block"
+	})),
+	CommandBar,
+	Base,
+	List,
+	Item,
+	Heading,
+	CodeBlock,
+	Iframe,
+	EmbeddedDocument,
+	Link, // needs to be before other marks so we don't get link splitting
+	HardBreak,
+	Image,
+	Highlight,
+	...TableExtensions,
+	...[
+
+		// do not use configured extensions here
+		// see https://github.com/ueberdosis/tiptap/issues/4081
+
+		Text,
+		// styling
+		Blockquote,
+		Cite,
+		Code,
+		Italic,
+		Underline,
+		Strike,
+		Subscript,
+		Superscript,
+
+		Bold,
+		// embedding
+		// other
+		History
+	].map(e => stripShortcuts(e)),
+	Menus
+]
+
+// mostly for the test builder, so we can have proper typing
+// though the tests should use the full testExtensions
+type NodeParagraphName = "paragraph"
+type NodeTextName = "text"
+type MarkHardBreakName = "hardBreak"
+type MarkUnderlineName = "underline"
+type MarkStrikeName = "strike"
+type MarkSubscriptName = "subscript"
+type MarkSuperscriptName = "superscript"
+type MarkCodeName = "code"
+type MarkItalicName = "italic"
+type MarkBoldName = "bold"
+type NodeImageName = "image"
+
+const _schema = getSchema(extensions) as Schema<
+	NodeListName
+	| NodeItemName
+	| NodeHeadingName
+	| NodeDocumentName
+	| NodeCodeBlockName
+	| NodeIframeName
+	| NodeEmbeddedDocumentName
+	| NodeParagraphName
+	| NodeTextName
+	| NodeImageName
+	| NodeTableName
+	| NodeTableHeaderName
+	| NodeTableRowName
+	| NodeTableCellName
+	| NodeBlockquoteName
+	| NodeCiteName,
+	| MarkHardBreakName
+	| MarkHighlightName
+	| MarkUnderlineName
+	| MarkStrikeName
+	| MarkSubscriptName
+	| MarkSuperscriptName
+	| MarkCodeName
+	| MarkItalicName
+	| MarkBoldName
+	| MarkHighlightName
+>
+export const schema = _schema