@prosekit/extensions 0.7.1 → 0.7.3

package/dist/{chunk-2JYT2MT7.js → chunk-OJCMRVEY.js}

@@ -16,24 +16,26 @@ import {
 function defineEnterRule({
   regex,
   handler,
-  stop = !1
+  stop = false
 }) {
-  let rule = new EnterRule(regex, handler, stop);
+  const rule = new EnterRule(regex, handler, stop);
   return defineFacetPayload(enterRule, [rule]);
 }
 function defineTextBlockEnterRule({
   regex,
   type,
   attrs,
-  stop = !0
+  stop = true
 }) {
   return defineEnterRule({
     regex,
     handler: ({ state, from, to, match }) => {
-      let nodeType = getNodeType(state.schema, type), $start = state.doc.resolve(from);
-      if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), nodeType))
+      const nodeType = getNodeType(state.schema, type);
+      const $start = state.doc.resolve(from);
+      if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), nodeType)) {
         return null;
-      let nodeAttrs = maybeRun(attrs, match);
+      }
+      const nodeAttrs = maybeRun(attrs, match);
       return state.tr.delete(from, to).setBlockType(from, from, nodeType, nodeAttrs);
     },
     stop
@@ -45,42 +47,55 @@ var EnterRule = class {
     this.handler = handler;
     this.stop = stop;
   }
-}, enterRule = defineFacet({
+};
+var enterRule = defineFacet({
   reduce: () => {
-    let rules = [], handler = keydownHandler({ Enter: (state, dispatch, view) => view ? execRules(view, rules, dispatch) : !1 }), plugin = new ProseMirrorPlugin({
+    let rules = [];
+    const command = (state, dispatch, view) => {
+      if (!view) return false;
+      return execRules(view, rules, dispatch);
+    };
+    const handler = keydownHandler({ Enter: command });
+    const plugin = new ProseMirrorPlugin({
       key: new PluginKey("prosekit-enter-rule"),
       props: { handleKeyDown: handler }
     });
-    return function(inputs) {
-      return rules = inputs, plugin;
+    return function reducer(inputs) {
+      rules = inputs;
+      return plugin;
     };
   },
   parent: pluginFacet
 });
 function execRules(view, rules, dispatch) {
-  if (view.composing) return !1;
-  let state = view.state, selection = state.selection;
-  if (!isTextSelection(selection)) return !1;
-  let $cursor = selection.$cursor;
-  if (!$cursor || $cursor.parent.type.spec.code) return !1;
-  let textBefore = $cursor.parent.textBetween(
+  if (view.composing) return false;
+  const state = view.state;
+  const selection = state.selection;
+  if (!isTextSelection(selection)) return false;
+  const $cursor = selection.$cursor;
+  if (!$cursor || $cursor.parent.type.spec.code) return false;
+  const textBefore = $cursor.parent.textBetween(
     Math.max(0, $cursor.parentOffset - MAX_MATCH),
     $cursor.parentOffset,
     null,
     OBJECT_REPLACEMENT_CHARACTER
   );
-  for (let rule of rules) {
+  for (const rule of rules) {
     rule.regex.lastIndex = 0;
-    let match = rule.regex.exec(textBefore), tr = match && rule.handler({
+    const match = rule.regex.exec(textBefore);
+    const tr = match && rule.handler({
       state,
       from: $cursor.pos - match[0].length,
       to: $cursor.pos,
       match
     });
-    if (tr && (dispatch == null || dispatch(tr), rule.stop))
-      return !0;
+    if (!tr) continue;
+    dispatch == null ? void 0 : dispatch(tr);
+    if (rule.stop) {
+      return true;
+    }
   }
-  return !1;
+  return false;
 }
 var MAX_MATCH = 200;
 

package/dist/list/style.css

@@ -1,7 +1,8 @@
-/* ../../node_modules/.pnpm/prosemirror-flat-list@0.5.1/node_modules/prosemirror-flat-list/dist/style.css */
+/* ../../node_modules/.pnpm/prosemirror-flat-list@0.5.2/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;
@@ -14,7 +15,10 @@
 .prosemirror-flat-list.ProseMirror-selectednode:after {
   content: "";
   position: absolute;
-  inset: -2px -2px -2px -32px;
+  left: -32px;
+  right: -2px;
+  top: -2px;
+  bottom: -2px;
   border: 2px solid #8cf;
   pointer-events: none;
 }
@@ -27,7 +31,7 @@
 .prosemirror-flat-list[data-list-kind=ordered] > * {
   contain: style;
 }
-.prosemirror-flat-list[data-list-kind=ordered]:before {
+.prosemirror-flat-list[data-list-kind=ordered]::before {
   position: absolute;
   right: 100%;
   font-variant-numeric: tabular-nums;
@@ -65,10 +69,10 @@
   width: 1.5em;
   width: 1lh;
 }
-.prosemirror-flat-list[data-list-kind=toggle] > .list-marker:before {
+.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 {
+.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 {

package/dist/placeholder/style.css

@@ -1,5 +1,5 @@
 /* src/placeholder/style.css */
-.prosekit-placeholder:before {
+.prosekit-placeholder::before {
   position: absolute;
   opacity: 30%;
   pointer-events: none;

package/dist/prosekit-extensions-autocomplete.js

@@ -17,9 +17,11 @@ function defaultCanMatch({ 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 !0;
+  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");
 }
 function getPluginState(state) {
@@ -42,39 +44,55 @@ function createAutocompletePlugin({
   return new Plugin({
     key: pluginKey,
     state: {
-      init: () => ({ active: !1, ignore: null, matching: null }),
+      init: () => {
+        return { active: false, ignore: null, matching: null };
+      },
       apply: (tr, prevValue, oldState, newState) => {
         var _a;
-        let meta = getTrMeta(tr);
-        if (!tr.docChanged && oldState.selection.eq(newState.selection) && !meta)
+        const meta = getTrMeta(tr);
+        if (!tr.docChanged && oldState.selection.eq(newState.selection) && !meta) {
           return prevValue;
-        if (meta)
+        }
+        if (meta) {
           return meta;
-        let nextValue = calcPluginState(newState, getRules());
-        return nextValue.active && prevValue.ignore != null && ((_a = nextValue.matching) == null ? void 0 : _a.from) === prevValue.ignore ? prevValue : nextValue;
+        }
+        const nextValue = calcPluginState(newState, getRules());
+        if (nextValue.active && prevValue.ignore != null && ((_a = nextValue.matching) == null ? void 0 : _a.from) === prevValue.ignore) {
+          return prevValue;
+        }
+        return nextValue;
       }
     },
     view: () => ({
       update: (view, prevState) => {
         var _a, _b, _c;
-        let prevValue = getPluginState(prevState), currValue = getPluginState(view.state);
-        if (prevValue != null && prevValue.active && prevValue.matching && prevValue.matching.rule !== ((_a = currValue == null ? void 0 : currValue.matching) == null ? void 0 : _a.rule) && ((_c = (_b = prevValue.matching.rule).onLeave) == null || _c.call(_b)), currValue != null && currValue.active && currValue.matching && currValue.matching.from !== currValue.ignore) {
-          let { from, to, match, rule } = currValue.matching, textContent = view.state.doc.textBetween(
+        const prevValue = getPluginState(prevState);
+        const currValue = getPluginState(view.state);
+        if ((prevValue == null ? void 0 : prevValue.active) && prevValue.matching && prevValue.matching.rule !== ((_a = currValue == null ? void 0 : currValue.matching) == null ? void 0 : _a.rule)) {
+          (_c = (_b = prevValue.matching.rule).onLeave) == null ? void 0 : _c.call(_b);
+        }
+        if ((currValue == null ? void 0 : currValue.active) && currValue.matching && currValue.matching.from !== currValue.ignore) {
+          const { from, to, match, rule } = currValue.matching;
+          const textContent = view.state.doc.textBetween(
             from,
             to,
             null,
             OBJECT_REPLACEMENT_CHARACTER
-          ), deleteMatch = () => {
-            view.state.doc.textBetween(
+          );
+          const deleteMatch = () => {
+            if (view.state.doc.textBetween(
               from,
               to,
               null,
               OBJECT_REPLACEMENT_CHARACTER
-            ) === textContent && view.dispatch(view.state.tr.delete(from, to));
-          }, ignoreMatch = () => {
+            ) === textContent) {
+              view.dispatch(view.state.tr.delete(from, to));
+            }
+          };
+          const ignoreMatch = () => {
             view.dispatch(
               setTrMeta(view.state.tr, {
-                active: !1,
+                active: false,
                 ignore: from,
                 matching: null
               })
@@ -93,9 +111,10 @@ function createAutocompletePlugin({
     }),
     props: {
       decorations: (state) => {
-        let pluginState = getPluginState(state);
-        if (pluginState != null && pluginState.active && pluginState.matching) {
-          let { from, to } = pluginState.matching, deco = Decoration.inline(from, to, {
+        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]);
@@ -107,22 +126,26 @@ function createAutocompletePlugin({
 }
 var MAX_MATCH = 200;
 function calcPluginState(state, rules) {
-  let $pos = state.selection.$from, parentOffset = $pos.parentOffset, textBefore = $pos.parent.textBetween(
+  const $pos = state.selection.$from;
+  const parentOffset = $pos.parentOffset;
+  const textBefore = $pos.parent.textBetween(
     Math.max(0, parentOffset - MAX_MATCH),
     parentOffset,
     null,
     OBJECT_REPLACEMENT_CHARACTER
   );
-  for (let rule of rules) {
-    if (!rule.canMatch({ state }))
+  for (const rule of rules) {
+    if (!rule.canMatch({ state })) {
       continue;
+    }
     rule.regex.lastIndex = 0;
-    let match = rule.regex.exec(textBefore);
-    if (!match)
+    const match = rule.regex.exec(textBefore);
+    if (!match) {
       continue;
-    let from = $pos.pos - textBefore.length + match.index;
+    }
+    const from = $pos.pos - textBefore.length + match.index;
     return {
-      active: !0,
+      active: true,
       ignore: null,
       matching: {
         rule,
@@ -132,14 +155,17 @@ function calcPluginState(state, rules) {
       }
     };
   }
-  return { active: !1, ignore: null, matching: null };
+  return { active: false, ignore: null, matching: null };
 }
 
 // src/autocomplete/rule.ts
 var AutocompleteRule = class {
   constructor(options) {
     var _a;
-    this.regex = options.regex, this.onMatch = options.onEnter, this.onLeave = options.onLeave, this.canMatch = (_a = options.canMatch) != null ? _a : defaultCanMatch;
+    this.regex = options.regex;
+    this.onMatch = options.onEnter;
+    this.onLeave = options.onLeave;
+    this.canMatch = (_a = options.canMatch) != null ? _a : defaultCanMatch;
   }
 };
 
@@ -149,13 +175,16 @@ function defineAutocomplete(rule) {
 }
 var autocompleteFacet = defineFacet({
   reduce: () => {
-    let rules = [], plugin = createAutocompletePlugin({ getRules: () => rules });
-    return function(inputs) {
-      return rules = inputs, plugin;
+    let rules = [];
+    const getRules = () => rules;
+    const plugin = createAutocompletePlugin({ getRules });
+    return function reducer(inputs) {
+      rules = inputs;
+      return plugin;
     };
   },
   parent: pluginFacet,
-  singleton: !0
+  singleton: true
 });
 export {
   AutocompleteRule,

package/dist/prosekit-extensions-blockquote.js

@@ -1,6 +1,6 @@
 import {
   defineWrappingInputRule
-} from "./chunk-PYT3MOTF.js";
+} from "./chunk-LVMTQOWG.js";
 
 // src/blockquote/index.ts
 import { defineNodeSpec, union } from "@prosekit/core";
@@ -9,7 +9,7 @@ function defineBlockquoteSpec() {
     name: "blockquote",
     content: "block+",
     group: "block",
-    defining: !0,
+    defining: true,
     parseDOM: [{ tag: "blockquote" }],
     toDOM() {
       return ["blockquote", 0];

package/dist/prosekit-extensions-bold.js

@@ -1,6 +1,6 @@
 import {
   defineMarkInputRule
-} from "./chunk-PYT3MOTF.js";
+} from "./chunk-LVMTQOWG.js";
 
 // src/bold/index.ts
 import {
@@ -21,12 +21,16 @@ function defineBoldSpec() {
       // tags with a font-weight normal.
       {
         tag: "b",
-        getAttrs: (node) => typeof node != "string" && node.style.fontWeight !== "normal" && null
+        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) => typeof value == "string" && /^(bold(er)?|[5-9]\d{2,})$/.test(value) && null
+        getAttrs: (value) => {
+          return typeof value === "string" && /^(bold(er)?|[5-9]\d{2,})$/.test(value) && null;
+        }
       }
     ],
     toDOM() {

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

@@ -1,9 +1,9 @@
 import {
   defineTextBlockEnterRule
-} from "./chunk-2JYT2MT7.js";
+} from "./chunk-OJCMRVEY.js";
 import {
   defineTextBlockInputRule
-} from "./chunk-PYT3MOTF.js";
+} from "./chunk-LVMTQOWG.js";
 
 // src/code-block/code-block.ts
 import { union } from "@prosekit/core";
@@ -18,10 +18,18 @@ import {
 } from "@prosekit/core";
 function defineCodeBlockCommands() {
   return defineCommands({
-    setCodeBlock: (attrs) => setBlockType({ type: "codeBlock", attrs }),
-    insertCodeBlock: (attrs) => insertNode({ type: "codeBlock", attrs }),
-    toggleCodeBlock: (attrs) => toggleNode({ type: "codeBlock", attrs }),
-    setCodeBlockAttrs: (attrs) => setNodeAttrs({ type: "codeBlock", attrs })
+    setCodeBlock: (attrs) => {
+      return setBlockType({ type: "codeBlock", attrs });
+    },
+    insertCodeBlock: (attrs) => {
+      return insertNode({ type: "codeBlock", attrs });
+    },
+    toggleCodeBlock: (attrs) => {
+      return toggleNode({ type: "codeBlock", attrs });
+    },
+    setCodeBlockAttrs: (attrs) => {
+      return setNodeAttrs({ type: "codeBlock", attrs });
+    }
   });
 }
 
@@ -53,24 +61,32 @@ function defineCodeBlockKeymap() {
   });
 }
 var existCodeBlock = (state, dispatch) => {
-  if (!state.selection.empty)
-    return !1;
-  let { $head } = state.selection, parent = $head.parent;
-  if (parent.isTextblock && parent.type.spec.code && $head.parentOffset === parent.content.size && parent.textContent.endsWith(`
-
-`)) {
-    let grandParent = $head.node(-1), insertIndex = $head.indexAfter(-1), type = defaultBlockAt(grandParent.contentMatchAt(insertIndex));
-    if (!type || !grandParent.canReplaceWith(insertIndex, insertIndex, type))
-      return !1;
+  if (!state.selection.empty) {
+    return false;
+  }
+  const { $head } = state.selection;
+  const parent = $head.parent;
+  if (parent.isTextblock && parent.type.spec.code && $head.parentOffset === parent.content.size && parent.textContent.endsWith("\n\n")) {
+    const grandParent = $head.node(-1);
+    const insertIndex = $head.indexAfter(-1);
+    const type = defaultBlockAt(grandParent.contentMatchAt(insertIndex));
+    if (!type || !grandParent.canReplaceWith(insertIndex, insertIndex, type)) {
+      return false;
+    }
     if (dispatch) {
-      let { tr } = state;
+      const { tr } = state;
       tr.delete($head.pos - 2, $head.pos);
-      let pos = tr.selection.$head.after(), node = type.createAndFill();
-      node && (tr.replaceWith(pos, pos, node), tr.setSelection(TextSelection.near(tr.doc.resolve(pos), 1)), dispatch(tr.scrollIntoView()));
+      const pos = tr.selection.$head.after();
+      const node = type.createAndFill();
+      if (node) {
+        tr.replaceWith(pos, pos, node);
+        tr.setSelection(TextSelection.near(tr.doc.resolve(pos), 1));
+        dispatch(tr.scrollIntoView());
+      }
     }
-    return !0;
+    return true;
   }
-  return !1;
+  return false;
 };
 
 // src/code-block/code-block-spec.ts
@@ -80,8 +96,8 @@ function defineCodeBlockSpec() {
     name: "codeBlock",
     content: "text*",
     group: "block",
-    code: !0,
-    defining: !0,
+    code: true,
+    defining: true,
     marks: "",
     attrs: { language: { default: "" } },
     parseDOM: [
@@ -94,7 +110,8 @@ function defineCodeBlockSpec() {
       }
     ],
     toDOM(node) {
-      return ["pre", { "data-language": node.attrs.language }, ["code", 0]];
+      const attrs = node.attrs;
+      return ["pre", { "data-language": attrs.language }, ["code", 0]];
     }
   });
 }
@@ -125,44 +142,63 @@ function defineCodeBlockHighlight({
 import { createParser } from "prosemirror-highlight/shiki";
 
 // src/code-block/shiki-highlighter.ts
-var highlighter, loadedLangs = /* @__PURE__ */ new Set(), loadedThemes = /* @__PURE__ */ new Set();
+var highlighter;
+var loadedLangs = /* @__PURE__ */ new Set();
+var loadedThemes = /* @__PURE__ */ new Set();
 async function createHighlighter(options) {
-  let { getSingletonHighlighter } = await import("./shiki-import-UFUFVKJ2.js");
-  highlighter || (highlighter = await getSingletonHighlighter(options));
+  const { getSingletonHighlighter } = await import("./shiki-import-UFUFVKJ2.js");
+  if (!highlighter) {
+    highlighter = await getSingletonHighlighter(options);
+  }
 }
 async function loadLanguages(langs) {
-  for (let lang of langs) {
+  for (const lang of langs) {
     if (!highlighter) break;
-    await highlighter.loadLanguage(lang), loadedLangs.add(lang);
+    await highlighter.loadLanguage(lang);
+    loadedLangs.add(lang);
   }
 }
 async function loadThemes(themes) {
-  for (let theme of themes) {
+  for (const theme of themes) {
     if (!highlighter) break;
-    await highlighter.loadTheme(theme), loadedThemes.add(theme);
+    await highlighter.loadTheme(theme);
+    loadedThemes.add(theme);
   }
 }
 function prepareHighlighter(options) {
-  if (!highlighter)
+  if (!highlighter) {
     return { promise: createHighlighter(options) };
-  let langs = options.langs.filter((lang) => !loadedLangs.has(lang));
-  if (langs.length > 0)
+  }
+  const langs = options.langs.filter((lang) => !loadedLangs.has(lang));
+  if (langs.length > 0) {
     return { promise: loadLanguages(langs) };
-  let themes = options.themes.filter((theme) => !loadedThemes.has(theme));
-  return themes.length > 0 ? { promise: loadThemes(themes) } : { highlighter };
+  }
+  const themes = options.themes.filter((theme) => !loadedThemes.has(theme));
+  if (themes.length > 0) {
+    return { promise: loadThemes(themes) };
+  }
+  return { highlighter };
 }
 
 // src/code-block/shiki-parser.ts
 function createLazyParser(highlighterOptions) {
   let parser;
-  return prepareHighlighter(highlighterOptions), function(options) {
-    let language = options.language || "", { highlighter: highlighter2, promise } = prepareHighlighter({
+  prepareHighlighter(highlighterOptions);
+  return function lazyParser(options) {
+    const language = options.language || "";
+    const { highlighter: highlighter2, promise } = prepareHighlighter({
       langs: [language],
       themes: highlighterOptions.themes
     });
-    return highlighter2 ? (parser || (parser = createParser(highlighter2, {
-      theme: highlighterOptions.themes[0]
-    })), parser(options)) : promise;
+    if (!highlighter2) {
+      return promise;
+    }
+    if (!parser) {
+      parser = createParser(highlighter2, {
+        theme: highlighterOptions.themes[0]
+      });
+    }
+    return parser(options);
   };
 }
 
@@ -172,7 +208,7 @@ function defineCodeBlockShiki({
   langs = ["text"],
   langAlias = {}
 } = {}) {
-  let parser = createLazyParser({ themes, langs, langAlias });
+  const parser = createLazyParser({ themes, langs, langAlias });
   return defineCodeBlockHighlight({ parser });
 }
 

package/dist/prosekit-extensions-code.js

@@ -1,6 +1,6 @@
 import {
   defineMarkInputRule
-} from "./chunk-PYT3MOTF.js";
+} from "./chunk-LVMTQOWG.js";
 
 // src/code/index.ts
 import {