@prosekit/extensions 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 ocavue
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/list/style.css

@@ -0,0 +1,84 @@
+/* ../../node_modules/.pnpm/prosemirror-flat-list@0.3.14/node_modules/prosemirror-flat-list/dist/style.css */
+.prosemirror-flat-list {
+  padding: 0;
+  margin-top: 0;
+  margin-bottom: 0;
+  margin-left: 32px;
+  margin-bottom: 0;
+  position: relative;
+  display: list-item;
+  list-style: none;
+}
+.prosemirror-flat-list.ProseMirror-selectednode {
+  outline: none;
+}
+.prosemirror-flat-list.ProseMirror-selectednode:after {
+  content: "";
+  position: absolute;
+  left: -32px;
+  right: -2px;
+  top: -2px;
+  bottom: -2px;
+  border: 2px solid #8cf;
+  pointer-events: none;
+}
+.prosemirror-flat-list[data-list-kind=bullet] {
+  list-style: disc;
+}
+.prosemirror-flat-list[data-list-kind=ordered]::before {
+  position: absolute;
+  right: 100%;
+  font-variant-numeric: tabular-nums;
+  content: counter(prosemirror-flat-list-counter, decimal) ". ";
+}
+@supports (-moz-appearance: none) {
+  .prosemirror-flat-list[data-list-kind=ordered] {
+    contain: style;
+    counter-increment: prosemirror-flat-list-counter;
+  }
+}
+@supports not (-moz-appearance: none) {
+  .prosemirror-flat-list[data-list-kind=ordered] {
+    counter-reset: prosemirror-flat-list-counter;
+    counter-increment: prosemirror-flat-list-counter;
+  }
+  .prosemirror-flat-list[data-list-kind=ordered] + .prosemirror-flat-list[data-list-kind=ordered] {
+    counter-reset: none;
+  }
+}
+.prosemirror-flat-list[data-list-kind=task] > .list-marker {
+  position: absolute;
+  right: 100%;
+  text-align: center;
+  width: 1.5em;
+  width: 1lh;
+}
+.prosemirror-flat-list[data-list-kind=task] > .list-marker,
+.prosemirror-flat-list[data-list-kind=task] > .list-marker * {
+  cursor: pointer;
+}
+.prosemirror-flat-list[data-list-kind=toggle] > .list-marker {
+  position: absolute;
+  right: 100%;
+  text-align: center;
+  width: 1.5em;
+  width: 1lh;
+}
+.prosemirror-flat-list[data-list-kind=toggle] > .list-marker::before {
+  content: "\23f7";
+}
+.prosemirror-flat-list[data-list-kind=toggle][data-list-collapsable][data-list-collapsed] > .list-marker::before {
+  content: "\23f5";
+}
+.prosemirror-flat-list[data-list-kind=toggle][data-list-collapsable] > .list-marker {
+  cursor: pointer;
+}
+.prosemirror-flat-list[data-list-kind=toggle]:not([data-list-collapsable]) > .list-marker {
+  opacity: 40%;
+  pointer-events: none;
+}
+.prosemirror-flat-list[data-list-kind=toggle][data-list-collapsable][data-list-collapsed] > .list-content > *:nth-child(n + 2) {
+  display: none;
+}
+
+/* src/list/style.css */

package/dist/placeholder/style.css

@@ -0,0 +1,8 @@
+/* src/placeholder/style.css */
+.prosekit-placeholder::before {
+  position: absolute;
+  opacity: 30%;
+  pointer-events: none;
+  height: 0;
+  content: attr(data-placeholder);
+}

package/dist/prosekit-extensions-blockquote.d.ts

@@ -0,0 +1,11 @@
+import * as _prosekit_core from '@prosekit/core';
+
+declare function addBlockquoteSpec(): _prosekit_core.Extension<{
+    NODES: "blockquote";
+}>;
+/** @public */
+declare function addBlockquote(): _prosekit_core.Extension<{
+    NODES: "blockquote";
+}>;
+
+export { addBlockquote, addBlockquoteSpec };

package/dist/prosekit-extensions-blockquote.js

@@ -0,0 +1,23 @@
+// src/blockquote/index.ts
+import { addNodeSpec, defineExtension } from "@prosekit/core";
+function addBlockquoteSpec() {
+  return addNodeSpec({
+    name: "blockquote",
+    spec: {
+      content: "block+",
+      group: "block",
+      defining: true,
+      parseDOM: [{ tag: "blockquote" }],
+      toDOM() {
+        return ["blockquote", 0];
+      }
+    }
+  });
+}
+function addBlockquote() {
+  return defineExtension([addBlockquoteSpec()]);
+}
+export {
+  addBlockquote,
+  addBlockquoteSpec
+};

package/dist/prosekit-extensions-bold.d.ts

@@ -0,0 +1,20 @@
+import * as _prosekit_core from '@prosekit/core';
+
+declare function addBoldSpec(): _prosekit_core.Extension<{
+    MARKS: "bold";
+}>;
+declare function addBoldCommands(): _prosekit_core.Extension<{
+    COMMAND_ARGS: {
+        toggleBold: [];
+    };
+}>;
+declare function addBoldKeymap(): _prosekit_core.Extension<_prosekit_core.ExtensionTyping<string, string, _prosekit_core.CommandArgs>>;
+/** @public */
+declare function addBold(): _prosekit_core.Extension<{
+    MARKS: "bold";
+    COMMAND_ARGS: {
+        toggleBold: [];
+    };
+}>;
+
+export { addBold, addBoldCommands, addBoldKeymap, addBoldSpec };

package/dist/prosekit-extensions-bold.js

@@ -0,0 +1,56 @@
+// src/bold/index.ts
+import {
+  addCommands,
+  addKeymap,
+  addMarkSpec,
+  defineExtension,
+  toggleMark
+} from "@prosekit/core";
+function addBoldSpec() {
+  return addMarkSpec({
+    name: "bold",
+    spec: {
+      parseDOM: [
+        { tag: "strong" },
+        // This works around a Google Docs misbehavior where
+        // pasted content will be inexplicably wrapped in `<b>`
+        // tags with a font-weight normal.
+        {
+          tag: "b",
+          getAttrs: (node) => {
+            return typeof node !== "string" && node.style.fontWeight !== "normal" && null;
+          }
+        },
+        { style: "font-weight=400", clearMark: (m) => m.type.name == "strong" },
+        {
+          style: "font-weight",
+          getAttrs: (value) => {
+            return typeof value === "string" && /^(bold(er)?|[5-9]\d{2,})$/.test(value) && null;
+          }
+        }
+      ],
+      toDOM() {
+        return ["em", 0];
+      }
+    }
+  });
+}
+function addBoldCommands() {
+  return addCommands({
+    toggleBold: () => toggleMark({ type: "bold" })
+  });
+}
+function addBoldKeymap() {
+  return addKeymap({
+    "Mod-b": toggleMark({ type: "bold" })
+  });
+}
+function addBold() {
+  return defineExtension([addBoldSpec(), addBoldCommands(), addBoldKeymap()]);
+}
+export {
+  addBold,
+  addBoldCommands,
+  addBoldKeymap,
+  addBoldSpec
+};

package/dist/prosekit-extensions-code-block.js

@@ -0,0 +1,21 @@
+// src/code-block/index.ts
+import { addNodeSpec, defineExtension } from "@prosekit/core";
+function addHorizontalRuleSpec() {
+  return addNodeSpec({
+    name: "horizontalRule",
+    spec: {
+      group: "block",
+      parseDOM: [{ tag: "hr" }],
+      toDOM() {
+        return ["hr"];
+      }
+    }
+  });
+}
+function addHorizontalRule() {
+  return defineExtension([addHorizontalRuleSpec()]);
+}
+export {
+  addHorizontalRule,
+  addHorizontalRuleSpec
+};

package/dist/prosekit-extensions-code.d.ts

@@ -0,0 +1,16 @@
+import * as _prosekit_core from '@prosekit/core';
+
+/**
+ * @public
+ */
+declare function addCodeSpec(): _prosekit_core.Extension<{
+    MARKS: "code";
+}>;
+/**
+ * @public
+ */
+declare function addCode(): _prosekit_core.Extension<{
+    MARKS: "code";
+}>;
+
+export { addCode, addCodeSpec };

package/dist/prosekit-extensions-code.js

@@ -0,0 +1,20 @@
+// src/code/index.ts
+import { addMarkSpec, defineExtension } from "@prosekit/core";
+function addCodeSpec() {
+  return addMarkSpec({
+    name: "code",
+    spec: {
+      parseDOM: [{ tag: "code" }],
+      toDOM() {
+        return ["code", 0];
+      }
+    }
+  });
+}
+function addCode() {
+  return defineExtension([addCodeSpec()]);
+}
+export {
+  addCode,
+  addCodeSpec
+};

package/dist/prosekit-extensions-heading.d.ts

@@ -0,0 +1,15 @@
+import * as _prosekit_core from '@prosekit/core';
+
+interface HeadingAttrs {
+    level: number;
+}
+declare function addHeadingSpec(): _prosekit_core.Extension<{
+    NODES: "heading";
+}>;
+declare function addHeadingInputRule(): _prosekit_core.Extension<_prosekit_core.ExtensionTyping<string, string, _prosekit_core.CommandArgs>>;
+/** @public */
+declare function addHeading(): _prosekit_core.Extension<{
+    NODES: "heading";
+}>;
+
+export { HeadingAttrs, addHeading, addHeadingInputRule, addHeadingSpec };

package/dist/prosekit-extensions-heading.js

@@ -0,0 +1,53 @@
+// src/heading/index.ts
+import {
+  addInputRule,
+  addNodeSpec,
+  defineExtension,
+  getNodeType
+} from "@prosekit/core";
+import { textblockTypeInputRule } from "@prosekit/pm/inputrules";
+function addHeadingSpec() {
+  return addNodeSpec({
+    name: "heading",
+    spec: {
+      attrs: { level: { default: 1 } },
+      content: "inline*",
+      group: "block",
+      defining: true,
+      parseDOM: [
+        { tag: "h1", attrs: { level: 1 } },
+        { tag: "h2", attrs: { level: 2 } },
+        { tag: "h3", attrs: { level: 3 } },
+        { tag: "h4", attrs: { level: 4 } },
+        { tag: "h5", attrs: { level: 5 } },
+        { tag: "h6", attrs: { level: 6 } }
+      ],
+      toDOM(node) {
+        return [`h${node.attrs.level}`, 0];
+      }
+    }
+  });
+}
+function addHeadingInputRule() {
+  return addInputRule(({ schema }) => {
+    const nodeSpec = getNodeType(schema, "heading");
+    const inputRule = textblockTypeInputRule(
+      /^(#{1,6})\s/,
+      nodeSpec,
+      (match) => {
+        var _a, _b;
+        const level = (_b = (_a = match[1]) == null ? void 0 : _a.length) != null ? _b : 1;
+        return { level };
+      }
+    );
+    return [inputRule];
+  });
+}
+function addHeading() {
+  return defineExtension([addHeadingSpec(), addHeadingInputRule()]);
+}
+export {
+  addHeading,
+  addHeadingInputRule,
+  addHeadingSpec
+};

package/dist/prosekit-extensions-horizontal-rule.js

@@ -0,0 +1,23 @@
+// src/horizontal-rule/index.ts
+import { addNodeSpec, defineExtension } from "@prosekit/core";
+function addBlockquoteSpec() {
+  return addNodeSpec({
+    name: "blockquote",
+    spec: {
+      content: "block+",
+      group: "block",
+      defining: true,
+      parseDOM: [{ tag: "blockquote" }],
+      toDOM() {
+        return ["blockquote", 0];
+      }
+    }
+  });
+}
+function addBlockquote() {
+  return defineExtension([addBlockquoteSpec()]);
+}
+export {
+  addBlockquote,
+  addBlockquoteSpec
+};

package/dist/prosekit-extensions-italic.d.ts

@@ -0,0 +1,20 @@
+import * as _prosekit_core from '@prosekit/core';
+
+declare function addItalicSpec(): _prosekit_core.Extension<{
+    MARKS: "italic";
+}>;
+declare function addItalicCommands(): _prosekit_core.Extension<{
+    COMMAND_ARGS: {
+        toggleItalic: [];
+    };
+}>;
+declare function addItalicKeymap(): _prosekit_core.Extension<_prosekit_core.ExtensionTyping<string, string, _prosekit_core.CommandArgs>>;
+/** @public */
+declare function addItalic(): _prosekit_core.Extension<{
+    MARKS: "italic";
+    COMMAND_ARGS: {
+        toggleItalic: [];
+    };
+}>;
+
+export { addItalic, addItalicCommands, addItalicKeymap, addItalicSpec };

package/dist/prosekit-extensions-italic.js

@@ -0,0 +1,50 @@
+// src/italic/index.ts
+import {
+  addCommands,
+  addKeymap,
+  addMarkSpec,
+  defineExtension,
+  toggleMark
+} from "@prosekit/core";
+function addItalicSpec() {
+  return addMarkSpec({
+    name: "italic",
+    spec: {
+      parseDOM: [
+        { tag: "i" },
+        { tag: "em" },
+        { style: "font-style=italic" },
+        {
+          style: "font-style=normal",
+          clearMark: (m) => m.type.name === "italic"
+        }
+      ],
+      toDOM() {
+        return ["em", 0];
+      }
+    }
+  });
+}
+function addItalicCommands() {
+  return addCommands({
+    toggleItalic: () => toggleMark({ type: "italic" })
+  });
+}
+function addItalicKeymap() {
+  return addKeymap({
+    "Mod-i": toggleMark({ type: "italic" })
+  });
+}
+function addItalic() {
+  return defineExtension([
+    addItalicSpec(),
+    addItalicCommands(),
+    addItalicKeymap()
+  ]);
+}
+export {
+  addItalic,
+  addItalicCommands,
+  addItalicKeymap,
+  addItalicSpec
+};

package/dist/prosekit-extensions-list.d.ts

@@ -0,0 +1,14 @@
+import * as _prosekit_core from '@prosekit/core';
+
+declare function addListSpec(): _prosekit_core.Extension<{
+    NODES: "list";
+}>;
+declare function addListPlugins(): _prosekit_core.Extension<_prosekit_core.ExtensionTyping<string, string, _prosekit_core.CommandArgs>>;
+declare function addListKeymap(): _prosekit_core.Extension<_prosekit_core.ExtensionTyping<string, string, _prosekit_core.CommandArgs>>;
+declare function addListInputRules(): _prosekit_core.Extension<_prosekit_core.ExtensionTyping<string, string, _prosekit_core.CommandArgs>>;
+/** @public */
+declare function addList(): _prosekit_core.Extension<{
+    NODES: "list";
+}>;
+
+export { addList, addListInputRules, addListKeymap, addListPlugins, addListSpec };

package/dist/prosekit-extensions-list.js

@@ -0,0 +1,41 @@
+// src/list/index.ts
+import {
+  addInputRule,
+  addKeymap,
+  addNodeSpec,
+  addPlugin,
+  defineExtension
+} from "@prosekit/core";
+import {
+  createListPlugins,
+  createListSpec,
+  listInputRules,
+  listKeymap
+} from "prosemirror-flat-list";
+function addListSpec() {
+  return addNodeSpec({ name: "list", spec: createListSpec() });
+}
+function addListPlugins() {
+  return addPlugin({ plugins: ({ schema }) => createListPlugins({ schema }) });
+}
+function addListKeymap() {
+  return addKeymap(listKeymap);
+}
+function addListInputRules() {
+  return addInputRule(() => listInputRules);
+}
+function addList() {
+  return defineExtension([
+    addListSpec(),
+    addListPlugins(),
+    addListKeymap(),
+    addListInputRules()
+  ]);
+}
+export {
+  addList,
+  addListInputRules,
+  addListKeymap,
+  addListPlugins,
+  addListSpec
+};

package/dist/prosekit-extensions-placeholder.d.ts

@@ -0,0 +1,23 @@
+import * as _prosekit_core from '@prosekit/core';
+
+interface PlaceholderOptions {
+    /**
+     * The placeholder text to use.
+     */
+    placeholder: string;
+    /**
+     * By default, the placeholder text will be shown whenever the current text
+     * cursor is in an empty node. If you only want to show the placeholder when
+     * the whole doc is empty, you can set this option to 'doc'.
+     *
+     * @default 'block'
+     */
+    strategy?: 'doc' | 'block';
+}
+/**
+ * Add a placeholder text to the editor when the current block or document is
+ * empty.
+ */
+declare function addPlaceholder(options: PlaceholderOptions): _prosekit_core.Extension<_prosekit_core.ExtensionTyping<string, string, _prosekit_core.CommandArgs>>;
+
+export { PlaceholderOptions, addPlaceholder };

package/dist/prosekit-extensions-placeholder.js

@@ -0,0 +1,47 @@
+// src/placeholder/index.ts
+import { addPlugin } from "@prosekit/core";
+import { Plugin } from "@prosekit/pm/state";
+import { Decoration, DecorationSet } from "@prosekit/pm/view";
+function addPlaceholder(options) {
+  return addPlugin({
+    plugins: [createPlaceholderPlugin(options)]
+  });
+}
+function createPlaceholderPlugin(options) {
+  return new Plugin({
+    props: {
+      decorations: (state) => {
+        if (options.strategy === "doc" && !isDocEmpty(state.doc)) {
+          return null;
+        }
+        const placeholderText = options.placeholder;
+        const deco = createPlaceholderDecoration(state, placeholderText);
+        if (!deco) {
+          return null;
+        }
+        return DecorationSet.create(state.doc, [deco]);
+      }
+    }
+  });
+}
+function isDocEmpty(doc) {
+  var _a;
+  return doc.childCount <= 1 && !((_a = doc.firstChild) == null ? void 0 : _a.content.size);
+}
+function createPlaceholderDecoration(state, placeholderText) {
+  const { selection } = state;
+  if (!selection.empty)
+    return null;
+  const $pos = selection.$anchor;
+  const node = $pos.parent;
+  if (node.content.size > 0)
+    return null;
+  const before = $pos.before();
+  return Decoration.node(before, before + node.nodeSize, {
+    class: "prosekit-placeholder",
+    "data-placeholder": placeholderText
+  });
+}
+export {
+  addPlaceholder
+};

package/dist/prosekit-extensions-suggestion.d.ts

@@ -0,0 +1,37 @@
+import * as _prosekit_core from '@prosekit/core';
+import { EditorState } from '@prosekit/pm/state';
+
+interface PredictionRule {
+    match: RegExp;
+    matchAfter?: RegExp;
+}
+/**
+ * @returns Return a Transaction object if you want to append a transaction to current state (using )
+ */
+type MatchHandler = (options: {
+    rule: PredictionRule;
+    match: RegExpMatchArray;
+    matchAfter: RegExpMatchArray | null;
+    state: EditorState;
+    dismiss: VoidFunction;
+    deleteMatch: VoidFunction;
+}) => void;
+interface SuggestionOptions {
+    rules: PredictionRule[];
+    onMatch: MatchHandler;
+    onDeactivate: VoidFunction;
+    /**
+     * You can pass this function if you want to skip the matching in some cases.
+     * By default, the plugin will only run the matching if the current selection
+     * is empty, and the selection is not inside a
+     * [code](https://prosemirror.net/docs/ref/#model.NodeSpec.code) node nor
+     * inside a mark with the name as `code`.
+     */
+    isValid?: (options: {
+        state: EditorState;
+    }) => boolean;
+}
+
+declare function addSuggestion(options: SuggestionOptions): _prosekit_core.Extension<_prosekit_core.ExtensionTyping<string, string, _prosekit_core.CommandArgs>>;
+
+export { PredictionRule, SuggestionOptions, addSuggestion };

package/dist/prosekit-extensions-suggestion.js

@@ -0,0 +1,159 @@
+// src/suggestion/index.ts
+import { addPlugin } from "@prosekit/core";
+
+// src/suggestion/plugin.ts
+import { ProseKitError } from "@prosekit/core";
+import { Plugin, PluginKey } from "@prosekit/pm/state";
+import { Decoration, DecorationSet } from "@prosekit/pm/view";
+
+// src/suggestion/is-valid.ts
+function defaultIsValid({ state }) {
+  return state.selection.empty && !isInsideCode(state.selection.$from);
+}
+function isInsideCode($pos) {
+  for (let d = $pos.depth; d > 0; d--) {
+    if ($pos.node(d).type.spec.code) {
+      return true;
+    }
+  }
+  return $pos.marks().some((mark) => mark.type.name === "code");
+}
+
+// src/suggestion/plugin.ts
+var pluginKey = new PluginKey("prosemirror-prediction");
+function getPluginState(state) {
+  return pluginKey.getState(state);
+}
+function getTrMeta(tr) {
+  return tr.getMeta(pluginKey);
+}
+function setTrMeta(tr, meta) {
+  return tr.setMeta(pluginKey, meta);
+}
+function createPredictionPlugin(options) {
+  if (options.rules.length === 0) {
+    throw new ProseKitError(
+      "You can't create a prediction plugin without rules"
+    );
+  }
+  const { onMatch, onDeactivate, isValid = defaultIsValid } = options;
+  return new Plugin({
+    key: pluginKey,
+    state: {
+      init: () => {
+        return { active: false, ignore: null, matching: null };
+      },
+      apply: (tr, prevValue, oldState, newState) => {
+        var _a;
+        const meta = getTrMeta(tr);
+        if (!tr.docChanged && oldState.selection.eq(newState.selection) && !meta) {
+          return prevValue;
+        }
+        if (meta) {
+          return meta;
+        }
+        if (!isValid({ state: newState })) {
+          return { active: false, ignore: null, matching: null };
+        }
+        const nextValue = calcPluginState(newState, options.rules);
+        if (nextValue.active && prevValue.ignore != null && ((_a = nextValue.matching) == null ? void 0 : _a.from) === prevValue.ignore) {
+          return prevValue;
+        }
+        return nextValue;
+      }
+    },
+    view: () => ({
+      update: (view, prevState) => {
+        const prevPluginState = getPluginState(prevState);
+        const currPluginState = getPluginState(view.state);
+        if ((currPluginState == null ? void 0 : currPluginState.active) && currPluginState.matching && currPluginState.matching.from !== currPluginState.ignore) {
+          const { from, to } = currPluginState.matching;
+          const dismiss = () => {
+            view.dispatch(
+              setTrMeta(view.state.tr, {
+                active: false,
+                ignore: from,
+                matching: null
+              })
+            );
+          };
+          const textContent = view.state.doc.textBetween(from, to, "\uFFFC");
+          const deleteMatch = () => {
+            if (view.state.doc.textBetween(from, to, "\uFFFC") === textContent) {
+              view.dispatch(view.state.tr.delete(from, to));
+            }
+          };
+          onMatch({
+            rule: currPluginState.matching.rule,
+            match: currPluginState.matching.match,
+            matchAfter: currPluginState.matching.matchAfter,
+            state: view.state,
+            dismiss,
+            deleteMatch
+          });
+        } else if (prevPluginState == null ? void 0 : prevPluginState.active) {
+          onDeactivate();
+        }
+      }
+    }),
+    props: {
+      decorations: (state) => {
+        const pluginState = getPluginState(state);
+        if ((pluginState == null ? void 0 : pluginState.active) && pluginState.matching) {
+          const { from, to } = pluginState.matching;
+          const deco = Decoration.inline(from, to, {
+            class: "prosemirror-prediction-match"
+          });
+          return DecorationSet.create(state.doc, [deco]);
+        }
+        return null;
+      }
+    }
+  });
+}
+function calcPluginState(state, rules) {
+  const { $anchor } = state.selection;
+  const matchAfter = rules.some((rule) => rule.matchAfter);
+  const parentOffset = $anchor.parentOffset;
+  const textBefore = $anchor.parent.textBetween(
+    Math.max(0, parentOffset - MAX_MATCH),
+    parentOffset,
+    null,
+    "\uFFFC"
+  );
+  const textAfter = matchAfter ? $anchor.parent.textBetween(
+    parentOffset,
+    Math.min(parentOffset + MAX_MATCH, $anchor.parent.content.size),
+    null
+  ) : "";
+  for (const rule of rules) {
+    const match = textBefore.match(rule.match);
+    const matchAfter2 = rule.matchAfter ? textAfter.match(rule.matchAfter) : null;
+    if (match && match.index != null) {
+      const from = $anchor.pos - textBefore.length + match.index;
+      const to = $anchor.pos + (matchAfter2 ? matchAfter2[0].length : 0);
+      return {
+        active: true,
+        ignore: null,
+        matching: {
+          rule,
+          from,
+          to,
+          match,
+          matchAfter: matchAfter2
+        }
+      };
+    }
+  }
+  return { active: false };
+}
+var MAX_MATCH = 200;
+
+// src/suggestion/index.ts
+function addSuggestion(options) {
+  const plugin = createPredictionPlugin(options);
+  return addPlugin({ plugins: [plugin] });
+}
+export {
+  addSuggestion
+};

package/dist/prosekit-extensions.d.ts

@@ -0,0 +1,2 @@
+
+export { }

package/package.json

@@ -0,0 +1,99 @@
+{
+  "name": "@prosekit/extensions",
+  "type": "module",
+  "version": "0.0.1",
+  "private": false,
+  "author": {
+    "name": "ocavue",
+    "email": "ocavue@gmail.com"
+  },
+  "license": "MIT",
+  "funding": "https://github.com/sponsors/ocavue",
+  "homepage": "https://github.com/ocavue/prosekit#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ocavue/prosekit.git",
+    "directory": "packages/extensions"
+  },
+  "bugs": {
+    "url": "https://github.com/ocavue/prosekit/issues"
+  },
+  "keywords": [
+    "ProseMirror"
+  ],
+  "sideEffects": false,
+  "main": "./dist/prosekit-extensions.js",
+  "module": "./dist/prosekit-extensions.js",
+  "exports": {
+    ".": {
+      "types": "./dist/prosekit-extensions.d.ts",
+      "import": "./dist/prosekit-extensions.js",
+      "default": "./dist/prosekit-extensions.js"
+    },
+    "./blockquote": {
+      "types": "./dist/prosekit-extensions-blockquote.d.ts",
+      "import": "./dist/prosekit-extensions-blockquote.js",
+      "default": "./dist/prosekit-extensions-blockquote.js"
+    },
+    "./bold": {
+      "types": "./dist/prosekit-extensions-bold.d.ts",
+      "import": "./dist/prosekit-extensions-bold.js",
+      "default": "./dist/prosekit-extensions-bold.js"
+    },
+    "./code": {
+      "types": "./dist/prosekit-extensions-code.d.ts",
+      "import": "./dist/prosekit-extensions-code.js",
+      "default": "./dist/prosekit-extensions-code.js"
+    },
+    "./heading": {
+      "types": "./dist/prosekit-extensions-heading.d.ts",
+      "import": "./dist/prosekit-extensions-heading.js",
+      "default": "./dist/prosekit-extensions-heading.js"
+    },
+    "./italic": {
+      "types": "./dist/prosekit-extensions-italic.d.ts",
+      "import": "./dist/prosekit-extensions-italic.js",
+      "default": "./dist/prosekit-extensions-italic.js"
+    },
+    "./list": {
+      "types": "./dist/prosekit-extensions-list.d.ts",
+      "import": "./dist/prosekit-extensions-list.js",
+      "default": "./dist/prosekit-extensions-list.js"
+    },
+    "./list/style.css": {
+      "default": "./dist/list/style.css"
+    },
+    "./placeholder": {
+      "types": "./dist/prosekit-extensions-placeholder.d.ts",
+      "import": "./dist/prosekit-extensions-placeholder.js",
+      "default": "./dist/prosekit-extensions-placeholder.js"
+    },
+    "./placeholder/style.css": {
+      "default": "./dist/placeholder/style.css"
+    },
+    "./suggestion": {
+      "types": "./dist/prosekit-extensions-suggestion.d.ts",
+      "import": "./dist/prosekit-extensions-suggestion.js",
+      "default": "./dist/prosekit-extensions-suggestion.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@prosekit/core": "^0.0.1",
+    "@prosekit/pm": "^0.0.1",
+    "prosemirror-flat-list": "^0.3.14"
+  },
+  "devDependencies": {
+    "@prosekit/dev": "^0.0.0",
+    "tsup": "^7.1.0",
+    "typescript": "^5.1.6",
+    "vitest": "^0.33.0"
+  },
+  "scripts": {
+    "build:tsup": "tsup",
+    "build:tsc": "tsc -b tsconfig.json"
+  },
+  "types": "./dist/prosekit-extensions.d.ts"
+}

package/src/index.ts

@@ -0,0 +1 @@
+export {}