@prosekit/extensions 0.7.2 → 0.7.3

package/dist/_tsup-dts-rollup.d.ts

@@ -835,8 +835,8 @@ export declare function defineTestExtension(): Extension<{
         removeMark: [options: RemoveMarkOptions];
         unsetBlockType: [options?: UnsetBlockTypeOptions | undefined];
         unsetMark: [options?: UnsetMarkOptions | undefined];
-        undo: [];
-        redo: [];
+        readonly undo: [];
+        readonly redo: [];
         toggleBold: [];
         toggleCode: [];
         setHeading: [attrs?: HeadingAttrs | undefined];
@@ -1330,8 +1330,8 @@ export declare function setupTest(): {
             removeMark: [options: RemoveMarkOptions];
             unsetBlockType: [options?: UnsetBlockTypeOptions | undefined];
             unsetMark: [options?: UnsetMarkOptions | undefined];
-            undo: [];
-            redo: [];
+            readonly undo: [];
+            readonly redo: [];
             toggleBold: [];
             toggleCode: [];
             setHeading: [attrs?: HeadingAttrs | undefined];

package/dist/chunk-GPSAJOJA.js

@@ -0,0 +1,188 @@
+// src/mark-rule/extension.ts
+import {
+  defineFacet,
+  defineFacetPayload,
+  pluginFacet
+} from "@prosekit/core";
+import {
+  PluginKey,
+  ProseMirrorPlugin
+} from "@prosekit/pm/state";
+
+// src/mark-rule/apply.ts
+import {
+  OBJECT_REPLACEMENT_CHARACTER,
+  getMarkType,
+  maybeRun
+} from "@prosekit/core";
+import "@prosekit/pm/model";
+import "@prosekit/pm/state";
+
+// src/mark-rule/range.ts
+import "@prosekit/pm/state";
+function getSpanTextRanges($from, $to) {
+  const nodeRange = $from.blockRange($to);
+  if (!nodeRange) {
+    return [];
+  }
+  const stack = [];
+  let start = nodeRange.start;
+  for (let i = nodeRange.startIndex; i < nodeRange.endIndex; i++) {
+    const child = nodeRange.parent.child(i);
+    stack.push([start, child]);
+    start += child.nodeSize;
+  }
+  const ranges = [];
+  while (stack.length > 0) {
+    const [start2, node] = stack.pop();
+    if (node.type.spec.code) {
+      continue;
+    }
+    if (node.type.isTextblock) {
+      ranges.push([start2 + 1, start2 + 1 + node.content.size]);
+      continue;
+    }
+    node.forEach((child, offset) => {
+      stack.push([start2 + offset + 1, child]);
+    });
+  }
+  return ranges;
+}
+function getInlineTextRange($from, $to) {
+  return [$from.start(), $to.end()];
+}
+function getTextRanges(doc, from, to) {
+  const $from = doc.resolve(from);
+  const $to = doc.resolve(to);
+  if ($from.sameParent($to) && $from.parent.isTextblock) {
+    return [getInlineTextRange($from, $to)];
+  } else {
+    const nodeRange = $from.blockRange($to);
+    if (!nodeRange) {
+      return [];
+    }
+    return getSpanTextRanges($from, $to);
+  }
+}
+function getMapRange(transactions, oldState, newState) {
+  let lo = oldState.selection.from;
+  let hi = oldState.selection.to;
+  for (const tr of transactions) {
+    for (const map of tr.mapping.maps) {
+      lo = map.map(lo);
+      hi = map.map(hi);
+      map.forEach((_oldStart, _oldEnd, newStart, newEnd) => {
+        lo = Math.min(lo, hi, newStart);
+        hi = Math.max(lo, hi, newEnd);
+      });
+    }
+  }
+  lo = Math.min(lo, hi, newState.selection.from);
+  hi = Math.min(lo, hi, newState.selection.to);
+  return [lo, hi];
+}
+function getCheckRanges(transactions, oldState, newState) {
+  const [from, to] = getMapRange(transactions, oldState, newState);
+  return getTextRanges(newState.doc, from, to);
+}
+
+// src/mark-rule/apply.ts
+function getExpectedMarkings(rules, doc, from, to) {
+  const text = doc.textBetween(from, to, null, OBJECT_REPLACEMENT_CHARACTER);
+  const ranges = [];
+  for (const rule of rules) {
+    rule.regex.lastIndex = 0;
+    const matches = text.matchAll(rule.regex);
+    const markType = getMarkType(doc.type.schema, rule.type);
+    for (const match of matches) {
+      const index = match.index;
+      if (index == null) continue;
+      const attrs = maybeRun(rule.attrs, match);
+      const mark = markType.create(attrs);
+      ranges.push([from + index, from + index + match[0].length, mark]);
+    }
+  }
+  ranges.sort((a, b) => a[0] - b[0] || b[1] - a[1]);
+  const result = [];
+  let freeIndex = 0;
+  for (const range of ranges) {
+    if (range[0] >= freeIndex) {
+      result.push(range);
+      freeIndex = range[1];
+    }
+  }
+  return result;
+}
+function getReceivedMarkings(rules, doc, from, to) {
+  const result = [];
+  const schema = doc.type.schema;
+  const markTypes = rules.map((rule) => getMarkType(schema, rule.type));
+  doc.nodesBetween(from, to, (node, pos) => {
+    if (!node.isInline) {
+      return;
+    }
+    for (const markType of markTypes) {
+      const mark = node.marks.find((mark2) => mark2.type === markType);
+      if (mark) {
+        result.push([pos, pos + node.nodeSize, mark]);
+      }
+    }
+  });
+  return result;
+}
+function markRangeEquals(a, b) {
+  return a[0] === b[0] && a[1] === b[1] && a[2].eq(b[2]);
+}
+function markRangeDiffs(a, b) {
+  return a.filter((x) => !b.some((y) => markRangeEquals(x, y)));
+}
+function applyMarkRules(rules, transactions, oldState, newState) {
+  if (transactions.length === 0 || transactions.every((tr2) => !tr2.docChanged)) {
+    return null;
+  }
+  const ranges = getCheckRanges(transactions, oldState, newState);
+  const toRemove = [];
+  const toCreate = [];
+  for (const [from, to] of ranges) {
+    const expected = getExpectedMarkings(rules, newState.doc, from, to);
+    const received = getReceivedMarkings(rules, newState.doc, from, to);
+    toRemove.push(...markRangeDiffs(received, expected));
+    toCreate.push(...markRangeDiffs(expected, received));
+  }
+  if (toCreate.length === 0 && toRemove.length === 0) {
+    return null;
+  }
+  const tr = newState.tr;
+  for (const [from, to, mark] of toRemove) {
+    tr.removeMark(from, to, mark);
+  }
+  for (const [from, to, mark] of toCreate) {
+    tr.addMark(from, to, mark);
+  }
+  return tr;
+}
+
+// src/mark-rule/extension.ts
+function defineMarkRule(options) {
+  return defineFacetPayload(markRuleFacet, [options]);
+}
+var markRuleFacet = defineFacet({
+  reduce: () => {
+    let rules = [];
+    const plugin = new ProseMirrorPlugin({
+      key: new PluginKey("prosekit-mark-rule"),
+      appendTransaction: (transactions, oldState, newState) => {
+        return applyMarkRules(rules, transactions, oldState, newState);
+      }
+    });
+    return function reducer(input) {
+      rules = input;
+      return plugin;
+    };
+  },
+  parent: pluginFacet
+});
+
+export {
+  defineMarkRule
+};

package/dist/{chunk-PYT3MOTF.js → chunk-LVMTQOWG.js}

@@ -24,20 +24,35 @@ function createMarkInputRule({
   type,
   attrs = null
 }) {
-  return new InputRule(regex, (state, match, start, end) => {
+  const rule = new InputRule(regex, (state, match, start, end) => {
     var _a;
-    let { tr, schema } = state, [fullText, markText] = match;
-    if (!markText)
+    const { tr, schema } = state;
+    const [fullText, markText] = match;
+    if (!markText) {
       return null;
-    let markStart = start + fullText.indexOf(markText), markEnd = markStart + markText.length;
-    if (!(start <= markStart && markStart < markEnd && markEnd <= end))
+    }
+    const markStart = start + fullText.indexOf(markText);
+    const markEnd = markStart + markText.length;
+    if (!(start <= markStart && markStart < markEnd && markEnd <= end)) {
       return null;
-    let markType = getMarkType(schema, type), mark = markType.create(maybeRun(attrs, match));
-    if (!isMarkAbsent(tr.doc, markStart, markEnd, markType, attrs))
+    }
+    const markType = getMarkType(schema, type);
+    const mark = markType.create(maybeRun(attrs, match));
+    if (!isMarkAbsent(tr.doc, markStart, markEnd, markType, attrs)) {
       return null;
-    let initialStoredMarks = (_a = tr.storedMarks) != null ? _a : [];
-    return tr.addMark(markStart, markEnd, mark), markEnd < end && tr.delete(markEnd, end), start < markStart && tr.delete(start, markStart), tr.setStoredMarks(initialStoredMarks), tr;
+    }
+    const initialStoredMarks = (_a = tr.storedMarks) != null ? _a : [];
+    tr.addMark(markStart, markEnd, mark);
+    if (markEnd < end) {
+      tr.delete(markEnd, end);
+    }
+    if (start < markStart) {
+      tr.delete(start, markStart);
+    }
+    tr.setStoredMarks(initialStoredMarks);
+    return tr;
   });
+  return rule;
 }
 function defineMarkInputRule(options) {
   return defineInputRule(createMarkInputRule(options));
@@ -49,7 +64,7 @@ function defineTextBlockInputRule({
 }) {
   return defineFacetPayload(inputRuleFacet, [
     ({ schema }) => {
-      let nodeType = getNodeType(schema, type);
+      const nodeType = getNodeType(schema, type);
       return textblockTypeInputRule(regex, nodeType, attrs);
     }
   ]);
@@ -62,15 +77,17 @@ function defineWrappingInputRule({
 }) {
   return defineFacetPayload(inputRuleFacet, [
     ({ schema }) => {
-      let nodeType = getNodeType(schema, type);
+      const nodeType = getNodeType(schema, type);
       return wrappingInputRule(regex, nodeType, attrs, join);
     }
   ]);
 }
 var inputRuleFacet = defineFacet({
-  reducer: (inputs) => (context) => {
-    let rules = inputs.flatMap((callback) => callback(context));
-    return [inputRules({ rules })];
+  reducer: (inputs) => {
+    return (context) => {
+      const rules = inputs.flatMap((callback) => callback(context));
+      return [inputRules({ rules })];
+    };
   },
   parent: pluginFacet
 });

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

@@ -2,6 +2,7 @@
 .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() {