@prosekit/extensions 0.5.2 → 0.5.3

package/dist/prosekit-extensions-mention.js

@@ -8,18 +8,18 @@ import {
 function defineMentionSpec() {
   return defineNodeSpec({
     name: "mention",
-    atom: true,
+    atom: !0,
     group: "inline",
     attrs: {
       id: {},
       value: {},
       kind: { default: "" }
     },
-    inline: true,
+    inline: !0,
     leafText: (node) => node.attrs.value.toString(),
     parseDOM: [
       {
-        tag: `span[data-mention]`,
+        tag: "span[data-mention]",
         getAttrs: (dom) => ({
           id: dom.getAttribute("data-id") || "",
           kind: dom.getAttribute("data-mention") || "",
@@ -41,9 +41,7 @@ function defineMentionSpec() {
 }
 function defineMentionCommands() {
   return defineCommands({
-    insertMention: (attrs) => {
-      return insertNode({ type: "mention", attrs });
-    }
+    insertMention: (attrs) => insertNode({ type: "mention", attrs })
   });
 }
 function defineMention() {

package/dist/prosekit-extensions-placeholder.js

@@ -11,35 +11,24 @@ function createPlaceholderPlugin(options) {
     key: new PluginKey("prosekit-placeholder"),
     props: {
       decorations: (state) => {
-        if (options.strategy === "doc" && !isDocEmpty(state.doc)) {
+        if (options.strategy === "doc" && !isDocEmpty(state.doc) || isInCodeBlock(state.selection))
           return null;
-        }
-        if (isInCodeBlock(state.selection)) {
-          return null;
-        }
-        const placeholderText = options.placeholder;
-        const deco = createPlaceholderDecoration(state, placeholderText);
-        if (!deco) {
-          return null;
-        }
-        return DecorationSet.create(state.doc, [deco]);
+        let placeholderText = options.placeholder, deco = createPlaceholderDecoration(state, placeholderText);
+        return deco ? DecorationSet.create(state.doc, [deco]) : null;
       }
     }
   });
 }
 function isDocEmpty(doc) {
   var _a;
-  return doc.childCount <= 1 && !((_a = doc.firstChild) == null ? void 0 : _a.content.size);
+  return doc.childCount <= 1 && !((_a = doc.firstChild) != null && _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();
+  let { selection } = state;
+  if (!selection.empty) return null;
+  let $pos = selection.$anchor, node = $pos.parent;
+  if (node.content.size > 0) return null;
+  let before = $pos.before();
   return Decoration.node(before, before + node.nodeSize, {
     class: "prosekit-placeholder",
     "data-placeholder": placeholderText

package/dist/prosekit-extensions-readonly.js

@@ -7,7 +7,7 @@ function defineReadonly() {
 var plugin = new ProseMirrorPlugin({
   key: new PluginKey("prosekey-readonly"),
   props: {
-    editable: () => false
+    editable: () => !1
   }
 });
 export {

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

@@ -0,0 +1,3 @@
+export { defineSearchQuery } from './_tsup-dts-rollup';
+export { defineSearchCommands } from './_tsup-dts-rollup';
+export { SearchQueryOptions } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-search.js

@@ -0,0 +1,382 @@
+// src/search/index.ts
+import { defineCommands, definePlugin } from "@prosekit/core";
+
+// src/search/prosemirror-search/search.ts
+import {
+  Plugin,
+  PluginKey,
+  TextSelection
+} from "@prosekit/pm/state";
+import { DecorationSet, Decoration } from "@prosekit/pm/view";
+
+// src/search/prosemirror-search/query.ts
+import { Slice, Fragment } from "@prosekit/pm/model";
+import "@prosekit/pm/state";
+var SearchQuery = class {
+  /// Create a query object.
+  constructor(config) {
+    this.search = config.search, this.caseSensitive = !!config.caseSensitive, this.literal = !!config.literal, this.regexp = !!config.regexp, this.replace = config.replace || "", this.valid = !!this.search && !(this.regexp && !validRegExp(this.search)), this.wholeWord = !!config.wholeWord, this.impl = this.valid ? this.regexp ? new RegExpQuery(this) : new StringQuery(this) : nullQuery;
+  }
+  /// Compare this query to another query.
+  eq(other) {
+    return this.search == other.search && this.replace == other.replace && this.caseSensitive == other.caseSensitive && this.regexp == other.regexp && this.wholeWord == other.wholeWord;
+  }
+  /// Find the next occurrence of this query in the given range.
+  findNext(state, from = 0, to = state.doc.content.size) {
+    for (; ; ) {
+      if (from >= to) return null;
+      let result = this.impl.findNext(state, from, to);
+      if (!result || this.checkResult(state, result)) return result;
+      from = result.from + 1;
+    }
+  }
+  /// Find the previous occurrence of this query in the given range.
+  /// Note that, if `to` is given, it should be _less_ than `from`.
+  findPrev(state, from = state.doc.content.size, to = 0) {
+    for (; ; ) {
+      if (from <= to) return null;
+      let result = this.impl.findPrev(state, from, to);
+      if (!result || this.checkResult(state, result)) return result;
+      from = result.to - 1;
+    }
+  }
+  /// @internal
+  checkResult(state, result) {
+    return this.wholeWord ? checkWordBoundary(state, result.from) && checkWordBoundary(state, result.to) : !0;
+  }
+  /// @internal
+  unquote(string) {
+    return this.literal ? string : string.replace(
+      /\\([\\nrt])/g,
+      (_, ch) => ch == "n" ? `
+` : ch == "r" ? "\r" : ch == "t" ? "	" : "\\"
+    );
+  }
+  /// Get a replacement slice for a given search result.
+  getReplacement(state, result) {
+    let marks = state.doc.resolve(result.from).marksAcross(state.doc.resolve(result.to)), text = this.unquote(this.replace), nodes = [], i = 0, { match } = result;
+    if (match) {
+      text = text.replace(
+        /\$([\d$&+])/g,
+        (m, i2) => i2 == "$" ? "$" : i2 == "&" ? match[0] : i2 != "0" && +i2 < match.length ? match[+i2] : m
+      );
+      for (let pos = result.from; ; ) {
+        let obj = text.indexOf("\uFFFC", i);
+        if (obj < 0) break;
+        let found = findLeafBetween(state, pos, result.to);
+        if (!found) break;
+        obj > i && nodes.push(state.schema.text(text.slice(i, obj), marks)), nodes.push(found.node), i = obj + 1, pos = found.pos + 1;
+      }
+    }
+    return i < text.length && nodes.push(state.schema.text(text.slice(i), marks)), new Slice(Fragment.from(nodes), 0, 0);
+  }
+}, nullQuery = new class {
+  findNext() {
+    return null;
+  }
+  findPrev() {
+    return null;
+  }
+}(), StringQuery = class {
+  constructor(query) {
+    this.query = query;
+    let string = query.unquote(query.search);
+    query.caseSensitive || (string = string.toLowerCase()), this.string = string;
+  }
+  findNext(state, from, to) {
+    return scanTextblocks(state.doc, from, to, (node, start) => {
+      let off = Math.max(from, start), content = textContent(node).slice(
+        off - start,
+        Math.min(node.content.size, to - start)
+      ), index = (this.query.caseSensitive ? content : content.toLowerCase()).indexOf(this.string);
+      return index < 0 ? null : {
+        from: off + index,
+        to: off + index + this.string.length,
+        match: null
+      };
+    });
+  }
+  findPrev(state, from, to) {
+    return scanTextblocks(state.doc, from, to, (node, start) => {
+      let off = Math.max(start, to), content = textContent(node).slice(
+        off - start,
+        Math.min(node.content.size, from - start)
+      );
+      this.query.caseSensitive || (content = content.toLowerCase());
+      let index = content.lastIndexOf(this.string);
+      return index < 0 ? null : {
+        from: off + index,
+        to: off + index + this.string.length,
+        match: null
+      };
+    });
+  }
+}, baseFlags = "g" + (/x/.unicode == null ? "" : "u"), RegExpQuery = class {
+  constructor(query) {
+    this.query = query;
+    this.regexp = new RegExp(
+      query.search,
+      baseFlags + (query.caseSensitive ? "" : "i")
+    );
+  }
+  findNext(state, from, to) {
+    return scanTextblocks(state.doc, from, to, (node, start) => {
+      let content = textContent(node).slice(
+        0,
+        Math.min(node.content.size, to - start)
+      );
+      this.regexp.lastIndex = from - start;
+      let match = this.regexp.exec(content);
+      return match ? {
+        from: start + match.index,
+        to: start + match.index + match[0].length,
+        match
+      } : null;
+    });
+  }
+  findPrev(state, from, to) {
+    return scanTextblocks(state.doc, from, to, (node, start) => {
+      let content = textContent(node).slice(
+        0,
+        Math.min(node.content.size, from - start)
+      ), match;
+      for (let off = 0; ; ) {
+        this.regexp.lastIndex = off;
+        let next = this.regexp.exec(content);
+        if (!next) break;
+        match = next, off = next.index + 1;
+      }
+      return match ? {
+        from: start + match.index,
+        to: start + match.index + match[0].length,
+        match
+      } : null;
+    });
+  }
+};
+function validRegExp(source) {
+  try {
+    return new RegExp(source, baseFlags), !0;
+  } catch (e) {
+    return !1;
+  }
+}
+var TextContentCache = /* @__PURE__ */ new WeakMap();
+function textContent(node) {
+  let cached = TextContentCache.get(node);
+  if (cached) return cached;
+  let content = "";
+  for (let i = 0; i < node.childCount; i++) {
+    let child = node.child(i);
+    child.isText ? content += child.text : child.isLeaf ? content += "\uFFFC" : content += " " + textContent(child) + " ";
+  }
+  return TextContentCache.set(node, content), content;
+}
+function scanTextblocks(node, from, to, f, nodeStart = 0) {
+  if (node.inlineContent)
+    return f(node, nodeStart);
+  if (!node.isLeaf)
+    if (from > to)
+      for (let i = node.childCount - 1, pos = nodeStart + node.content.size; i >= 0 && pos > to; i--) {
+        let child = node.child(i);
+        if (pos -= child.nodeSize, pos < from) {
+          let result = scanTextblocks(child, from, to, f, pos + 1);
+          if (result != null) return result;
+        }
+      }
+    else
+      for (let i = 0, pos = nodeStart; i < node.childCount && pos < to; i++) {
+        let child = node.child(i), start = pos;
+        if (pos += child.nodeSize, pos > from) {
+          let result = scanTextblocks(child, from, to, f, start + 1);
+          if (result != null) return result;
+        }
+      }
+  return null;
+}
+function checkWordBoundary(state, pos) {
+  let $pos = state.doc.resolve(pos), before = $pos.nodeBefore, after = $pos.nodeAfter;
+  return !before || !after || !before.isText || !after.isText ? !0 : !/\p{L}$/u.test(before.text) || !/^\p{L}/u.test(after.text);
+}
+function findLeafBetween(state, from, to) {
+  let found = null;
+  return state.doc.nodesBetween(from, to, (node, pos) => {
+    if (found) return !1;
+    node.isLeaf && node.isInline && !node.isText && (found = { node, pos });
+  }), found;
+}
+
+// src/search/prosemirror-search/search.ts
+var SearchState = class {
+  constructor(query, range, deco) {
+    this.query = query;
+    this.range = range;
+    this.deco = deco;
+  }
+};
+function buildMatchDeco(state, query, range) {
+  if (!query.valid) return DecorationSet.empty;
+  let deco = [], sel = state.selection;
+  for (let pos = range ? range.from : 0, end = range ? range.to : state.doc.content.size; ; ) {
+    let next = query.findNext(state, pos, end);
+    if (!next) break;
+    let cls = next.from == sel.from && next.to == sel.to ? "ProseMirror-active-search-match" : "ProseMirror-search-match";
+    deco.push(Decoration.inline(next.from, next.to, { class: cls })), pos = next.to;
+  }
+  return DecorationSet.create(state.doc, deco);
+}
+var searchKey = new PluginKey("search");
+function search(options = {}) {
+  return new Plugin({
+    key: searchKey,
+    state: {
+      init(_config, state) {
+        let query = options.initialQuery || new SearchQuery({ search: "" }), range = options.initialRange || null;
+        return new SearchState(
+          query,
+          range,
+          buildMatchDeco(state, query, range)
+        );
+      },
+      apply(tr, search2, _oldState, state) {
+        let set = tr.getMeta(searchKey);
+        if (set)
+          return new SearchState(
+            set.query,
+            set.range,
+            buildMatchDeco(state, set.query, set.range)
+          );
+        if (tr.docChanged || tr.selectionSet) {
+          let range = search2.range;
+          if (range) {
+            let from = tr.mapping.map(range.from, 1), to = tr.mapping.map(range.to, -1);
+            range = from < to ? { from, to } : null;
+          }
+          search2 = new SearchState(
+            search2.query,
+            range,
+            buildMatchDeco(state, search2.query, range)
+          );
+        }
+        return search2;
+      }
+    },
+    props: {
+      decorations: (state) => searchKey.getState(state).deco
+    }
+  });
+}
+function nextMatch(search2, state, wrap, curFrom, curTo) {
+  let range = search2.range || { from: 0, to: state.doc.content.size }, next = search2.query.findNext(state, Math.max(curTo, range.from), range.to);
+  return !next && wrap && (next = search2.query.findNext(state, range.from, Math.min(curFrom, range.to))), next;
+}
+function prevMatch(search2, state, wrap, curFrom, curTo) {
+  let range = search2.range || { from: 0, to: state.doc.content.size }, prev = search2.query.findPrev(
+    state,
+    Math.min(curFrom, range.to),
+    range.from
+  );
+  return !prev && wrap && (prev = search2.query.findPrev(state, range.to, Math.max(curTo, range.from))), prev;
+}
+function findCommand(wrap, dir) {
+  return (state, dispatch) => {
+    let search2 = searchKey.getState(state);
+    if (!search2 || !search2.query.valid) return !1;
+    let { from, to } = state.selection, next = dir > 0 ? nextMatch(search2, state, wrap, from, to) : prevMatch(search2, state, wrap, from, to);
+    if (!next) return !1;
+    let selection = TextSelection.create(state.doc, next.from, next.to);
+    return dispatch && dispatch(state.tr.setSelection(selection).scrollIntoView()), !0;
+  };
+}
+var findNext = findCommand(!0, 1), findNextNoWrap = findCommand(!1, 1), findPrev = findCommand(!0, -1), findPrevNoWrap = findCommand(!1, -1);
+function replaceCommand(wrap, moveForward) {
+  return (state, dispatch) => {
+    let search2 = searchKey.getState(state);
+    if (!search2 || !search2.query.valid) return !1;
+    let { from } = state.selection, next = nextMatch(search2, state, wrap, from, from);
+    if (!next) return !1;
+    if (!dispatch) return !0;
+    if (state.selection.from == next.from && state.selection.to == next.to) {
+      let tr = state.tr.replace(
+        next.from,
+        next.to,
+        search2.query.getReplacement(state, next)
+      ), after = moveForward && nextMatch(search2, state, wrap, next.from, next.to);
+      after ? tr.setSelection(
+        TextSelection.create(
+          tr.doc,
+          tr.mapping.map(after.from, 1),
+          tr.mapping.map(after.to, -1)
+        )
+      ) : tr.setSelection(
+        TextSelection.create(tr.doc, next.from, tr.mapping.map(next.to, 1))
+      ), dispatch(tr.scrollIntoView());
+    } else if (moveForward)
+      dispatch(
+        state.tr.setSelection(TextSelection.create(state.doc, next.from, next.to)).scrollIntoView()
+      );
+    else
+      return !1;
+    return !0;
+  };
+}
+var replaceNext = replaceCommand(!0, !0), replaceNextNoWrap = replaceCommand(!1, !0), replaceCurrent = replaceCommand(!1, !1), replaceAll = (state, dispatch) => {
+  let search2 = searchKey.getState(state);
+  if (!search2) return !1;
+  let matches = [], range = search2.range || { from: 0, to: state.doc.content.size };
+  for (let pos = range.from; ; ) {
+    let next = search2.query.findNext(state, pos, range.to);
+    if (!next) break;
+    matches.push(next), pos = next.to;
+  }
+  if (dispatch) {
+    let tr = state.tr;
+    for (let i = matches.length - 1; i >= 0; i--) {
+      let match = matches[i];
+      tr.replace(
+        match.from,
+        match.to,
+        search2.query.getReplacement(state, match)
+      );
+    }
+    dispatch(tr);
+  }
+  return !0;
+};
+
+// src/search/index.ts
+function defineSearchQuery(options) {
+  let query = new SearchQuery(options);
+  return definePlugin(search({ initialQuery: query }));
+}
+function scrollActiveIntoView(view) {
+  if (view.isDestroyed) return;
+  let active = view.dom.querySelector(".ProseMirror-active-search-match");
+  active == null || active.scrollIntoView({
+    block: "nearest",
+    inline: "nearest",
+    behavior: "smooth"
+  });
+}
+function withScrollActiveIntoView(command) {
+  return (state, dispatch, view) => {
+    let result = command(state, dispatch, view);
+    return result && dispatch && view && setTimeout(() => scrollActiveIntoView(view), 50), result;
+  };
+}
+function defineSearchCommands() {
+  return defineCommands({
+    findNext: () => withScrollActiveIntoView(findNext),
+    findPrev: () => withScrollActiveIntoView(findPrev),
+    findNextNoWrap: () => withScrollActiveIntoView(findNextNoWrap),
+    findPrevNoWrap: () => withScrollActiveIntoView(findPrevNoWrap),
+    replaceNext: () => withScrollActiveIntoView(replaceNext),
+    replaceNextNoWrap: () => withScrollActiveIntoView(replaceNextNoWrap),
+    replaceCurrent: () => withScrollActiveIntoView(replaceCurrent),
+    replaceAll: () => withScrollActiveIntoView(replaceAll)
+  });
+}
+export {
+  defineSearchCommands,
+  defineSearchQuery
+};

package/dist/prosekit-extensions-strike.js

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

package/dist/prosekit-extensions-table.js

@@ -10,23 +10,13 @@ import {
 } from "@prosekit/core";
 import { TextSelection } from "@prosekit/pm/state";
 function createEmptyTable(schema, row, col, header) {
-  const table = getNodeType(schema, "table");
-  const tableRow = getNodeType(schema, "tableRow");
-  const tableCell = getNodeType(schema, "tableCell");
-  const tableHeaderCell = getNodeType(schema, "tableHeaderCell");
-  const createHeaderRow = () => {
-    return tableRow.createAndFill(
-      null,
-      Array.from({ length: col }, () => tableHeaderCell.createAndFill())
-    );
-  };
-  const createBodyRow = () => {
-    return tableRow.createAndFill(
-      null,
-      Array.from({ length: col }, () => tableCell.createAndFill())
-    );
-  };
-  const rows = [
+  let table = getNodeType(schema, "table"), tableRow = getNodeType(schema, "tableRow"), tableCell = getNodeType(schema, "tableCell"), tableHeaderCell = getNodeType(schema, "tableHeaderCell"), createHeaderRow = () => tableRow.createAndFill(
+    null,
+    Array.from({ length: col }, () => tableHeaderCell.createAndFill())
+  ), createBodyRow = () => tableRow.createAndFill(
+    null,
+    Array.from({ length: col }, () => tableCell.createAndFill())
+  ), rows = [
     ...Array.from({ length: header ? 1 : 0 }, createHeaderRow),
     ...Array.from({ length: header ? row - 1 : row }, createBodyRow)
   ];
@@ -38,41 +28,27 @@ function insertTable({
   header
 }) {
   return (state, dispatch, view) => {
-    const table = createEmptyTable(state.schema, row, col, header);
+    let table = createEmptyTable(state.schema, row, col, header);
     return insertNode({ node: table })(state, dispatch, view);
   };
 }
 var exitTable = (state, dispatch) => {
-  const { $head, $anchor } = state.selection;
-  if (!$head.sameParent($anchor)) {
-    return false;
-  }
-  let tableStart = -1;
-  let tableDepth = -1;
-  for (let depth = $head.depth; depth >= 0; depth--) {
-    const node2 = $head.node(depth);
-    if (node2.type.spec.tableRole === "table") {
-      tableStart = $head.before(depth);
-      tableDepth = depth;
-    }
-  }
-  if (tableStart < 0 || tableDepth <= 0) {
-    return false;
-  }
-  const above = $head.node(tableDepth - 1);
-  const after = $head.indexAfter(tableDepth - 1);
-  const type = defaultBlockAt(above.contentMatchAt(after));
-  const node = type == null ? void 0 : type.createAndFill();
-  if (!type || !node || !above.canReplaceWith(after, after, type)) {
-    return false;
-  }
+  let { $head, $anchor } = state.selection;
+  if (!$head.sameParent($anchor))
+    return !1;
+  let tableStart = -1, tableDepth = -1;
+  for (let depth = $head.depth; depth >= 0; depth--)
+    $head.node(depth).type.spec.tableRole === "table" && (tableStart = $head.before(depth), tableDepth = depth);
+  if (tableStart < 0 || tableDepth <= 0)
+    return !1;
+  let above = $head.node(tableDepth - 1), after = $head.indexAfter(tableDepth - 1), type = defaultBlockAt(above.contentMatchAt(after)), node = type == null ? void 0 : type.createAndFill();
+  if (!type || !node || !above.canReplaceWith(after, after, type))
+    return !1;
   if (dispatch) {
-    const pos = $head.after(tableDepth);
-    const tr = state.tr.replaceWith(pos, pos, node);
-    tr.setSelection(TextSelection.near(tr.doc.resolve(pos), 1));
-    dispatch(tr.scrollIntoView());
+    let pos = $head.after(tableDepth), tr = state.tr.replaceWith(pos, pos, node);
+    tr.setSelection(TextSelection.near(tr.doc.resolve(pos), 1)), dispatch(tr.scrollIntoView());
   }
-  return true;
+  return !0;
 };
 function defineTableCommands() {
   return defineCommands({
@@ -95,15 +71,11 @@ var cellAttrs = {
   colspan: { default: 1 },
   rowspan: { default: 1 },
   colwidth: { default: null }
-};
-var cellContent = "block+";
+}, cellContent = "block+";
 function getCellAttrs(dom) {
-  if (typeof dom === "string") {
+  if (typeof dom == "string")
     return {};
-  }
-  const widthAttr = dom.getAttribute("data-colwidth");
-  const widths = widthAttr && /^\d+(,\d+)*$/.test(widthAttr) ? widthAttr.split(",").map((s) => Number(s)) : null;
-  const colspan = Number(dom.getAttribute("colspan") || 1);
+  let widthAttr = dom.getAttribute("data-colwidth"), widths = widthAttr && /^\d+(,\d+)*$/.test(widthAttr) ? widthAttr.split(",").map((s) => Number(s)) : null, colspan = Number(dom.getAttribute("colspan") || 1);
   return {
     colspan,
     rowspan: Number(dom.getAttribute("rowspan") || 1),
@@ -111,25 +83,15 @@ function getCellAttrs(dom) {
   };
 }
 function setCellAttrs(node) {
-  const pmAttrs = node.attrs;
-  const domAttrs = {};
-  if (pmAttrs.colspan !== 1) {
-    domAttrs.colspan = pmAttrs.colspan;
-  }
-  if (pmAttrs.rowspan !== 1) {
-    domAttrs.rowspan = pmAttrs.rowspan;
-  }
-  if (pmAttrs.colwidth) {
-    domAttrs["data-colwidth"] = pmAttrs.colwidth.join(",");
-  }
-  return domAttrs;
+  let pmAttrs = node.attrs, domAttrs = {};
+  return pmAttrs.colspan !== 1 && (domAttrs.colspan = pmAttrs.colspan), pmAttrs.rowspan !== 1 && (domAttrs.rowspan = pmAttrs.rowspan), pmAttrs.colwidth && (domAttrs["data-colwidth"] = pmAttrs.colwidth.join(",")), domAttrs;
 }
 function defineTableSpec() {
   return defineNodeSpec({
     name: "table",
     tableRole: "table",
     content: "tableRow+",
-    isolating: true,
+    isolating: !0,
     group: "block",
     parseDOM: [{ tag: "table" }],
     toDOM() {
@@ -154,7 +116,7 @@ function defineTableCellSpec() {
     tableRole: "cell",
     content: cellContent,
     attrs: cellAttrs,
-    isolating: true,
+    isolating: !0,
     parseDOM: [{ tag: "td", getAttrs: (dom) => getCellAttrs(dom) }],
     toDOM(node) {
       return ["td", setCellAttrs(node), 0];
@@ -167,7 +129,7 @@ function defineTableHeaderCellSpec() {
     tableRole: "header_cell",
     content: cellContent,
     attrs: cellAttrs,
-    isolating: true,
+    isolating: !0,
     parseDOM: [{ tag: "th", getAttrs: (dom) => getCellAttrs(dom) }],
     toDOM(node) {
       return ["th", setCellAttrs(node), 0];

package/dist/prosekit-extensions-text-align.js

@@ -11,11 +11,9 @@ function defineTextAlignAttr(type, defaultValue) {
     type,
     attr: "textAlign",
     default: defaultValue,
-    splittable: true,
+    splittable: !0,
     toDOM: (value) => value ? ["style", `text-align:${value};`] : null,
-    parseDOM: (node) => {
-      return node.style.getPropertyValue("text-align") || null;
-    }
+    parseDOM: (node) => node.style.getPropertyValue("text-align") || null
   });
 }
 function defineTextAlignAttrs(types, defaultValue) {