@witchcraft/editor 0.0.1

package/dist/runtime/demo/README.md

@@ -0,0 +1 @@
+This is structured like this so we can check the demo is both buildable from nuxt and vite.

package/dist/runtime/demo/main.d.ts

@@ -0,0 +1 @@
+import "./tailwind.css.js";

package/dist/runtime/demo/main.js

@@ -0,0 +1,4 @@
+import "./tailwind.css";
+import { createApp } from "vue";
+import App from "../components/EditorDemoApp.vue";
+createApp(App).mount("#app");

package/dist/runtime/demo/tailwind.css

@@ -0,0 +1 @@
+@import "tailwindcss" source("../");@import "../../../playground/.nuxt/witchcraft-ui.css";@import "../../../playground/.nuxt/witchcraft-editor.css";

package/dist/runtime/env.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="vite/client" />
+/// <reference types="@witchcraft/ui" />

package/dist/runtime/injectionKeys.d.ts

@@ -0,0 +1,6 @@
+import type { useScrollNearContainerEdges } from "@witchcraft/ui/composables/useScrollNearContainerEdges";
+import type { ComputedRef, InjectionKey } from "vue";
+import type { CssVariables } from "./types/index.js.js";
+export declare const editorCssVariablesInjectionKey: InjectionKey<ComputedRef<CssVariables>>;
+export declare const editorScrollInjectionKey: InjectionKey<ReturnType<typeof useScrollNearContainerEdges>>;
+export declare const editorTeleportToInjectionKey: InjectionKey<string>;

package/dist/runtime/injectionKeys.js

@@ -0,0 +1,3 @@
+export const editorCssVariablesInjectionKey = Symbol("editorCssVariablesInjectionKey");
+export const editorScrollInjectionKey = Symbol("editorScrollInjectionKey");
+export const editorTeleportToInjectionKey = Symbol("editorTeleportToInjectionKey");

package/dist/runtime/main.lib.d.ts

@@ -0,0 +1,2 @@
+export * from "./types/index.js.js";
+export { default as Editor } from "./components/Editor.vue.js";

package/dist/runtime/main.lib.js

@@ -0,0 +1,2 @@
+export * from "./types/index.js";
+export { default as Editor } from "./components/Editor.vue";

package/dist/runtime/pm/commands/backspace.d.ts

@@ -0,0 +1,12 @@
+import type { Command } from "@tiptap/core";
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        backspace: {
+            /**
+             * @redirectable
+             */
+            backspace: () => ReturnType;
+        };
+    }
+}
+export declare const backspace: () => () => Command;

package/dist/runtime/pm/commands/backspace.js

@@ -0,0 +1,26 @@
+import { Selection, TextSelection } from "@tiptap/pm/state";
+import { redirectFromEmbedded } from "../features/EmbeddedDocument/utils/redirectFromEmbedded.js";
+export const backspace = () => () => ({ state, tr, commands, dispatch, view }) => {
+  const { from, to, $from } = state.selection.map(tr.doc, tr.mapping);
+  if (from === to) {
+    const redirect = redirectFromEmbedded(view, "backspace", { args: [], view, commands });
+    if (redirect.redirected) {
+      return redirect.result;
+    }
+    if ($from.start() === from) {
+      const endsEqual = $from.end() === $from.start();
+      const newFrom = Selection.findFrom(state.doc.resolve(from - 1), -1, true);
+      if (!newFrom) return false;
+      if (dispatch) {
+        tr.delete(newFrom.from, to + (endsEqual ? 2 : 0));
+        tr.setSelection(new TextSelection(tr.doc.resolve(newFrom.from)));
+      }
+      return true;
+    } else {
+      if (dispatch) tr.delete(from - 1, to);
+      return true;
+    }
+  } else {
+    return commands.deleteSelection();
+  }
+};

package/dist/runtime/pm/commands/changeAttrs.d.ts

@@ -0,0 +1,9 @@
+import type { Command } from "@tiptap/core";
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        changeAttrs: {
+            changeAttrs: (nodeType: string | undefined, attrs: Record<string, unknown>) => ReturnType;
+        };
+    }
+}
+export declare const changeAttrs: () => (nodeType: string | undefined, attrs: Record<string, unknown>) => Command;

package/dist/runtime/pm/commands/changeAttrs.js

@@ -0,0 +1,15 @@
+import { nodesBetween } from "../utils/nodesBetween.js";
+export const changeAttrs = () => (nodeType, attrs) => ({ state, tr, dispatch }) => {
+  let changed = false;
+  nodesBetween(tr.doc, state.selection.map(tr.doc, tr.mapping), (node, pos) => {
+    if (node?.type?.name === nodeType) {
+      changed = true;
+      if (dispatch) {
+        tr.setNodeMarkup(pos, void 0, attrs);
+      }
+    }
+    return true;
+  });
+  if (!changed) return false;
+  return true;
+};

package/dist/runtime/pm/commands/deleteSelection.d.ts

@@ -0,0 +1,9 @@
+import type { Command } from "@tiptap/core";
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        deleteSelection: {
+            deleteSelection: () => ReturnType;
+        };
+    }
+}
+export declare const deleteSelection: () => () => Command;

package/dist/runtime/pm/commands/deleteSelection.js

@@ -0,0 +1,8 @@
+export const deleteSelection = () => () => ({ state, tr, dispatch }) => {
+  const { from, to } = state.selection.map(tr.doc, tr.mapping);
+  if (from !== to) {
+    if (dispatch) tr.delete(from, to);
+    return true;
+  }
+  return false;
+};

package/dist/runtime/pm/commands/enter.d.ts

@@ -0,0 +1,14 @@
+import type { Command } from "@tiptap/core";
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        customEnter: {
+            /**
+             * Overrides tiptap's enter command.
+             *
+             * @redirectable
+             */
+            enter: (pos?: number) => ReturnType;
+        };
+    }
+}
+export declare const enter: () => (pos?: number) => Command;

package/dist/runtime/pm/commands/enter.js

@@ -0,0 +1,9 @@
+export const enter = () => (pos) => ({ commands }) => commands.first(({ commands: commands2 }) => [
+  // incase the command isn't registered
+  () => commands2?.blockquoteEnter(pos),
+  // incase the command isn't registered
+  () => commands2?.codeBlockEnterOrSplit(pos),
+  () => commands2?.tableEnter(pos),
+  () => commands2.splitItem(pos),
+  () => commands2.insertBreak(pos)
+]);

package/dist/runtime/pm/commands/insertBreak.d.ts

@@ -0,0 +1,9 @@
+import { type Command } from "@tiptap/core";
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        insertBreak: {
+            insertBreak: (pos?: number) => ReturnType;
+        };
+    }
+}
+export declare const insertBreak: (codeBlockType?: string, disallowedTypesOrNames?: string[]) => (pos?: number) => Command;

package/dist/runtime/pm/commands/insertBreak.js

@@ -0,0 +1,22 @@
+import { getNodeType } from "@tiptap/core";
+import { TextSelection } from "@tiptap/pm/state";
+export const insertBreak = (codeBlockType = "codeBlock", disallowedTypesOrNames = ["blockquote"]) => (pos) => ({ state, commands, tr, dispatch }) => {
+  const { $from, $to } = state.selection.map(tr.doc, tr.mapping);
+  if ($from.parent.type.name === codeBlockType || $to.parent.type.name === codeBlockType) {
+    return commands.codeBlockEnterOrSplit(pos);
+  }
+  const disallowedTypes = disallowedTypesOrNames.map((type) => getNodeType(type, state.schema));
+  if (disallowedTypes.some((type) => $from.node(-1)?.type === type || $to.node(-1)?.type === type)) {
+    return false;
+  }
+  if (dispatch) {
+    if (pos !== void 0) {
+      tr.setSelection(TextSelection.create(tr.doc, pos));
+    }
+    commands.setHardBreak();
+    if (pos !== void 0) {
+      tr.setSelection(TextSelection.create(tr.doc, tr.mapping.map(pos)));
+    }
+  }
+  return true;
+};

package/dist/runtime/pm/features/Base/Base.d.ts

@@ -0,0 +1,4 @@
+import { Extension } from "@tiptap/core";
+import type { BaseExtensionOptions } from "./types.js.js";
+/** Adds some basic commands and plugins to the editor. */
+export declare const Base: Extension<BaseExtensionOptions, any>;

package/dist/runtime/pm/features/Base/Base.js

@@ -0,0 +1,32 @@
+import { Extension } from "@tiptap/core";
+import { deleteNodes } from "./commands/deleteNodes.js";
+import { setCursorVisible } from "./commands/setCursorVisible.js";
+import { debugSelectionPlugin } from "./plugins/debugSelectionPlugin.js";
+import { isCursorVisiblePlugin } from "./plugins/isCursorVisiblePlugin.js";
+import { isUsingTouchPlugin } from "./plugins/isUsingTouchPlugin.js";
+import { unfocusedSelectionIndicatorPlugin } from "./plugins/unfocusedSelectionIndicatorPlugin.js";
+import { backspace } from "../../commands/backspace.js";
+import { changeAttrs } from "../../commands/changeAttrs.js";
+import { enter } from "../../commands/enter.js";
+import { insertBreak } from "../../commands/insertBreak.js";
+export const Base = Extension.create({
+  name: "Base",
+  addProseMirrorPlugins() {
+    return [
+      debugSelectionPlugin(this.editor),
+      unfocusedSelectionIndicatorPlugin(),
+      isUsingTouchPlugin(),
+      isCursorVisiblePlugin()
+    ];
+  },
+  addCommands() {
+    return {
+      enter: enter(),
+      deleteNodes: deleteNodes(),
+      insertBreak: insertBreak("codeBlock"),
+      backspace: backspace(),
+      changeAttrs: changeAttrs(),
+      setCursorVisible: setCursorVisible()
+    };
+  }
+});

package/dist/runtime/pm/features/Base/commands/deleteNodes.d.ts

@@ -0,0 +1,10 @@
+import { type Command } from "@tiptap/core";
+import type { NodeType } from "@tiptap/pm/model";
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        deleteNodes: {
+            deleteNodes: (type: NodeType | string, pos?: number | undefined) => ReturnType;
+        };
+    }
+}
+export declare const deleteNodes: () => (type: NodeType | string, pos?: number | undefined) => Command;

package/dist/runtime/pm/features/Base/commands/deleteNodes.js

@@ -0,0 +1,29 @@
+import { getNodeType } from "@tiptap/core";
+import { TextSelection } from "@tiptap/pm/state";
+import { findUpwards } from "../../../utils/findUpwards.js";
+export const deleteNodes = () => (type, pos) => ({ state, tr, dispatch }) => {
+  const nodeType = getNodeType(type, state.schema);
+  if (pos !== void 0) {
+    const $pos = tr.doc.resolve(pos);
+    const $wantedPos = findUpwards(tr.doc, pos, ($pos2) => $pos2.node().type === nodeType).$pos;
+    if (!$wantedPos) return false;
+    const depth = $wantedPos.depth - ($wantedPos.node(-1).childCount === 1 ? 1 : 0);
+    if (dispatch) {
+      const beforePos = $pos.before(depth);
+      tr.delete(beforePos, $pos.after(depth));
+    }
+  } else {
+    const { $from, $to, from } = state.selection.map(tr.doc, tr.mapping);
+    const $wantedFrom = findUpwards(tr.doc, from, ($pos) => $pos.node().type === nodeType).$pos;
+    const $wantedTo = findUpwards(tr.doc, from, ($pos) => $pos.node().type === nodeType).$pos;
+    if (!$wantedFrom || !$wantedTo) return false;
+    const startDepth = $wantedFrom.depth - ($wantedFrom?.node(-1).childCount === 1 ? 1 : 0);
+    const endDepth = $wantedTo.depth - ($wantedTo?.node(-1).childCount === 1 ? 1 : 0);
+    if (dispatch) {
+      tr.delete($from.before(startDepth), $to.after(endDepth));
+      const newCursor = tr.mapping.map(from) - 1;
+      tr.setSelection(TextSelection.near(tr.doc.resolve(newCursor), -1));
+    }
+  }
+  return true;
+};

package/dist/runtime/pm/features/Base/commands/setCursorVisible.d.ts

@@ -0,0 +1,12 @@
+import type { Command } from "@tiptap/core";
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        setCursorVisible: {
+            /**
+             * Set the state of the cursor visibility plugin.
+             */
+            setCursorVisible: (val: boolean) => ReturnType;
+        };
+    }
+}
+export declare const setCursorVisible: () => (val: boolean) => Command;

package/dist/runtime/pm/features/Base/commands/setCursorVisible.js

@@ -0,0 +1,7 @@
+import { isCursorVisiblePluginKey } from "../plugins/isCursorVisiblePlugin.js";
+export const setCursorVisible = () => (val) => ({ tr, dispatch }) => {
+  if (dispatch) {
+    tr.setMeta(isCursorVisiblePluginKey, val);
+  }
+  return true;
+};

package/dist/runtime/pm/features/Base/plugins/debugSelectionPlugin.d.ts

@@ -0,0 +1,9 @@
+import type { Editor } from "@tiptap/core";
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+export declare const debugSelectionPluginKey: PluginKey<any>;
+/**
+ * Sets the window title to the current selection for debugging in development mode (by checking process.env.NODE_ENV).
+ *
+ * For embedded editors, adds the selection as `[from - to]`.
+ */
+export declare const debugSelectionPlugin: (editor: Editor, log?: boolean) => Plugin;

package/dist/runtime/pm/features/Base/plugins/debugSelectionPlugin.js

@@ -0,0 +1,48 @@
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+import { isEmbeddedBlock } from "../../EmbeddedDocument/utils/isEmbeddedBlock.js";
+const ROOT_SELECTION_REGEX = /([0-9 -]*)(\[|$)/;
+const SUB_SELECTION_REGEX = /(\[[0-9 -]*\])/;
+export const debugSelectionPluginKey = new PluginKey("debugSelection");
+export const debugSelectionPlugin = (editor, log = false) => {
+  let initialized = false;
+  return new Plugin({
+    key: debugSelectionPluginKey,
+    state: {
+      init() {
+      },
+      apply(tr) {
+        if (process.env.NODE_ENV === "production") {
+          return;
+        }
+        const sel = `${tr.selection.from} - ${tr.selection.to}`;
+        if (isEmbeddedBlock(editor.view)) {
+          if (log) {
+            console.log(`embedded selection: ${tr.selection.from} - ${tr.selection.to}`);
+          }
+          const hasEmbeddedSelection = document.title.match(SUB_SELECTION_REGEX);
+          if (hasEmbeddedSelection) {
+            document.title = document.title.replace(
+              SUB_SELECTION_REGEX,
+              `[${sel}]`
+            );
+          } else {
+            document.title = `${document.title} [${sel}]`;
+          }
+        } else {
+          if (log) {
+            console.log(`root selection: ${tr.selection.from} - ${tr.selection.to}`);
+          }
+          if (!initialized) {
+            initialized = true;
+            document.title = sel;
+          } else {
+            document.title = document.title.replace(
+              ROOT_SELECTION_REGEX,
+              `${sel} $2`
+            );
+          }
+        }
+      }
+    }
+  });
+};

package/dist/runtime/pm/features/Base/plugins/isCursorVisiblePlugin.d.ts

@@ -0,0 +1,3 @@
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+export declare const isCursorVisiblePluginKey: PluginKey<boolean>;
+export declare function isCursorVisiblePlugin(): Plugin<boolean>;

package/dist/runtime/pm/features/Base/plugins/isCursorVisiblePlugin.js

@@ -0,0 +1,26 @@
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+import { createStateOnlyPluginApply } from "../../../utils/createStateOnlyPluginApply.js";
+export const isCursorVisiblePluginKey = new PluginKey("isCursorVisiblePlugin");
+export function isCursorVisiblePlugin() {
+  const noClasses = {};
+  const attributes = {
+    class: "[caret-color:transparent]"
+  };
+  return new Plugin({
+    key: isCursorVisiblePluginKey,
+    state: {
+      init() {
+        return true;
+      },
+      apply: createStateOnlyPluginApply(isCursorVisiblePluginKey)
+    },
+    props: {
+      attributes(state) {
+        if (!isCursorVisiblePluginKey.getState(state)) {
+          return attributes;
+        }
+        return noClasses;
+      }
+    }
+  });
+}

package/dist/runtime/pm/features/Base/plugins/isUsingTouchPlugin.d.ts

@@ -0,0 +1,3 @@
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+export declare const isUsingTouchPluginKey: PluginKey<boolean>;
+export declare function isUsingTouchPlugin(): Plugin<boolean>;

package/dist/runtime/pm/features/Base/plugins/isUsingTouchPlugin.js

@@ -0,0 +1,38 @@
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+import { createStateOnlyPluginApply } from "../../../utils/createStateOnlyPluginApply.js";
+export const isUsingTouchPluginKey = new PluginKey("isUsingTouchPlugin");
+export function isUsingTouchPlugin() {
+  const noClasses = {};
+  const attributes = {
+    class: "group using-touch"
+  };
+  return new Plugin({
+    key: isUsingTouchPluginKey,
+    props: {
+      handleDOMEvents: {
+        pointerdown: (view, event) => {
+          const pluginState = isUsingTouchPluginKey.getState(view.state);
+          const isUsingTouch = event.pointerType === "touch";
+          if (pluginState !== isUsingTouch) {
+            const tr = view.state.tr;
+            tr.setMeta(isUsingTouchPluginKey, true);
+            tr.setMeta("addToHistory", false);
+            view.dispatch(tr);
+          }
+        }
+      },
+      attributes: (state) => {
+        if (isUsingTouchPluginKey.getState(state)) {
+          return attributes;
+        }
+        return noClasses;
+      }
+    },
+    state: {
+      init() {
+        return false;
+      },
+      apply: createStateOnlyPluginApply(isUsingTouchPluginKey)
+    }
+  });
+}

package/dist/runtime/pm/features/Base/plugins/selectingIndicator.d.ts

@@ -0,0 +1,5 @@
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+export declare const selectingIndicatorPluginKey: PluginKey<any>;
+export declare function selectingIndicatorPlugin({ className }?: {
+    className?: string;
+}): Plugin;

package/dist/runtime/pm/features/Base/plugins/selectingIndicator.js

@@ -0,0 +1,35 @@
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+export const selectingIndicatorPluginKey = new PluginKey(`selecting-indicator`);
+export function selectingIndicatorPlugin({ className = "selecting" } = {}) {
+  let mightBeDragging = false;
+  let dragging = false;
+  return new Plugin({
+    key: selectingIndicatorPluginKey,
+    props: {
+      handleDOMEvents: {
+        pointerdown() {
+          mightBeDragging = true;
+          return false;
+        },
+        pointerover(view) {
+          if (mightBeDragging) {
+            if (dragging) return false;
+            dragging = true;
+            view.dom.classList.add(className);
+          } else {
+            if (!dragging) return false;
+            dragging = false;
+            view.dom.classList.remove(className);
+          }
+          return false;
+        },
+        pointerup(view) {
+          mightBeDragging = false;
+          dragging = false;
+          view.dom.classList.remove(className);
+          return false;
+        }
+      }
+    }
+  });
+}

package/dist/runtime/pm/features/Base/plugins/unfocusedSelectionIndicatorPlugin.d.ts

@@ -0,0 +1,33 @@
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+export declare const unfocusedSelectionIndicatorKey: PluginKey<any>;
+/**
+ * Shows a fake selection decoration while the editor is unfocused and restores the previous selection\* when the editor gains focus again. It also prevents initial focus in events from changing the selection (when it's a selection and not a single position).
+ *
+ * So if the user focuses on something like the search bar or the devtools panel, focusing back to the editor doesn't change the selection.
+ *
+ * Focusing other elements inside the editor does not count as blurring the editor.
+ *
+ * The plugin will add three classes to the decorations, the main class to all the nodes, then the start and end classes to the start and end nodes respectively. This is so you can style the selection correctly since everything from the start right up to the end will have a little extra padding to the right. Therefore technically the start class is not needed, but it's there if needed.
+ *
+ * Some css like this is needed to make it work. The tailwind classes already include some `pm-unfocused-selection` and `pm-unfocused-selection-end` utility classes that take care of this. They use the css variable `--pmUnfocusedSelectionColor` to set the color. They look like this:
+ *
+ * ```scss
+ * .pm-unfocused-selection {
+ * 	background-color: var(--pmUnfocusedSelectionColor);
+ * 	box-shadow: 5px 0 0 0 var(--pmUnfocusedSelectionColor);
+ * }
+ * .pm-unfocused-selection-end {
+ * 	box-shadow: none;
+ * }
+ * ```
+ * Note regarding styling:
+ *
+ * It does not seem possible to get the real default color of selections so the best alternative is probably to use a custom selection color for the real selection. But just setting the same color to both won't work. The real selection gets some transparency added automatically so they will look different, plus the text changes color to indicate focus (which we wouldn't really want).
+ *
+ * Other Notes:
+ * - Whenever it restores a selection or the editor loses focus it must dispatch a new transaction which will have the "unfocused-selection" meta if you need to filter it.
+ * - If you want to hide the unfocused selection decorations you can set the
+ *   `hide-unfocused-selection` meta on the transaction.
+ * - If you change the selection while the editor is considered unfocused, the saved selection will be changed to the new selection.
+ */
+export declare function unfocusedSelectionIndicatorPlugin({ main: mainClass, start: startClass, end: endClass }?: Partial<Record<"main" | "start" | "end", string>>): Plugin;

package/dist/runtime/pm/features/Base/plugins/unfocusedSelectionIndicatorPlugin.js

@@ -0,0 +1,66 @@
+import { Plugin, PluginKey, TextSelection } from "@tiptap/pm/state";
+import { Decoration, DecorationSet } from "@tiptap/pm/view";
+export const unfocusedSelectionIndicatorKey = new PluginKey("unfocusedSelectionIndicator");
+export function unfocusedSelectionIndicatorPlugin({
+  main: mainClass = "pm-unfocused-selection",
+  start: startClass = `${mainClass}-start`,
+  end: endClass = `${mainClass}-end`
+} = {}) {
+  return new Plugin({
+    key: unfocusedSelectionIndicatorKey,
+    state: {
+      init() {
+        return {
+          decos: DecorationSet.empty,
+          savedSel: void 0
+        };
+      },
+      apply(tr, value, _oldState, newState) {
+        const trValue = tr.getMeta(unfocusedSelectionIndicatorKey);
+        if (!trValue) return value;
+        const newValue = { ...value, ...trValue };
+        if (!newValue.savedSel) {
+          newValue.decos = DecorationSet.empty;
+          return newValue;
+        }
+        const { from, to } = newValue.savedSel;
+        if (newState.selection.from !== from || newState.selection.to !== to) {
+          newValue.savedSel = newState.selection;
+        }
+        const hideUnfocusedSelection = from === to || !!tr.getMeta("hide-unfocused-selection");
+        newValue.decos = hideUnfocusedSelection ? DecorationSet.empty : DecorationSet.create(tr.doc, [
+          Decoration.inline(from, from + 1, { class: `${mainClass} ${startClass}` }),
+          Decoration.inline(from + 1, to - 1, { class: `${mainClass}` }),
+          Decoration.inline(to - 1, to, { class: `${mainClass} ${endClass}` })
+        ]);
+        return newValue;
+      }
+    },
+    props: {
+      decorations(state) {
+        return this.getState(state)?.decos;
+      },
+      handleDOMEvents: {
+        blur(view, e) {
+          if (e.relatedTarget instanceof Node && view.dom.contains(e.relatedTarget)) return;
+          const tr = view.state.tr;
+          if (!view.state.selection.empty) {
+            tr.setMeta("unfocused-selection", true);
+            tr.setMeta(unfocusedSelectionIndicatorKey, { savedSel: view.state.selection });
+          }
+          view.dispatch(tr);
+        },
+        focusin(view) {
+          const savedSel = unfocusedSelectionIndicatorKey.getState(view.state)?.savedSel;
+          if (savedSel) {
+            const tr = view.state.tr;
+            tr.setMeta("unfocused-selection", true);
+            tr.setMeta(unfocusedSelectionIndicatorKey, { savedSel: void 0 });
+            tr.setSelection(TextSelection.create(view.state.doc, savedSel.from, savedSel.to));
+            view.dispatch(tr);
+          }
+        }
+      }
+    }
+  });
+}

package/dist/runtime/pm/features/Base/types.d.ts

@@ -0,0 +1,3 @@
+import type { WithOnTriggerByEmbeddedBlockOptions } from "../EmbeddedDocument/types.js.js";
+export interface BaseExtensionOptions extends WithOnTriggerByEmbeddedBlockOptions {
+}

package/dist/runtime/pm/features/BaseShortcuts/BaseShortcuts.d.ts

@@ -0,0 +1,3 @@
+import { Extension } from "@tiptap/core";
+/** Extension for providing only the most basic shortcuts. */
+export declare const BaseShortcuts: Extension<any, any>;

package/dist/runtime/pm/features/BaseShortcuts/BaseShortcuts.js

@@ -0,0 +1,34 @@
+import { Extension } from "@tiptap/core";
+export const BaseShortcuts = Extension.create({
+  name: "BaseShortcuts",
+  addKeyboardShortcuts() {
+    return {
+      Backspace: () => this.editor.commands.backspace(),
+      [`Ctrl-Backspace`]: () => this.editor.commands.deleteItem(),
+      [`Ctrl-z`]: () => this.editor.commands.undo(),
+      [`Ctrl-Shift-z`]: () => this.editor.commands.redo(),
+      [`Ctrl-y`]: () => this.editor.commands.redo(),
+      [`Ctrl-b`]: () => this.editor.commands.toggleBold(),
+      [`Ctrl-i`]: () => this.editor.commands.toggleItalic(),
+      Enter: () => this.editor.commands.enter(),
+      [`Shift-Enter`]: () => this.editor.commands.first(({ commands }) => [
+        () => commands.blockquoteShiftEnter(),
+        () => commands.insertBreak()
+      ]),
+      [`Ctrl-.`]: () => this.editor.commands.indentItem(),
+      [`Ctrl-,`]: () => this.editor.commands.unindentItem(),
+      [`Ctrl-Space`]: () => {
+        return this.editor.commands.openItemMenu("item");
+      },
+      Escape: () => this.editor.commands.first(({ commands }) => [
+        () => commands.closeLinkMenu(),
+        () => commands.blur()
+      ]),
+      Tab: () => this.editor.commands.codeBlockIndent(),
+      [`Shift-Tab`]: () => this.editor.commands.codeBlockUnindent(),
+      [`Ctrl-k`]: () => this.editor.commands.openLinkMenu(),
+      [`Ctrl-Shift-k`]: () => this.editor.commands.openLinkMenu({ type: "internal" }),
+      [`Ctrl-Alt-k`]: () => this.editor.commands.expandSelectionToLink()
+    };
+  }
+});

package/dist/runtime/pm/features/Blockquote/Blockquote.d.ts

@@ -0,0 +1,5 @@
+import { Node } from "@tiptap/core";
+export declare const Blockquote: Node<import("@tiptap/extension-blockquote", { with: { "resolution-mode": "require" } }).BlockquoteOptions, any>;
+export type NodeBlockquoteName = "blockquote";
+export declare const Cite: Node<any, any>;
+export type NodeCiteName = "cite";