@prosekit/extensions 0.11.3 → 0.11.5

package/dist/commit/style.css

@@ -6,3 +6,5 @@
   background-color: #53e54b80;
 }
 
+
+/*# sourceMappingURL=style.css.map*/

package/dist/commit/style.css.map

@@ -0,0 +1 @@
+{"version":3,"file":"style.css","names":[],"sources":["../../src/commit/style.css"],"sourcesContent":[".prosekit-commit-deletion {\n  background-color: #e5534b80;\n  text-decoration: line-through;\n}\n.prosekit-commit-addition {\n  background-color: #53e54b80;\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA"}

package/dist/commit/style.js

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

package/dist/{drop-indicator-B8P652g2.js → drop-indicator-D1eHOhSi.js}

@@ -11,8 +11,7 @@ function getTargetsByView(view) {
 		if (pos >= 0) {
 			let dom = view.nodeDOM(pos);
 			if (dom && isHTMLElement(dom)) {
-				let rect = dom.getBoundingClientRect();
-				let { top, bottom, left: x1, right: x2 } = rect;
+				let { top, bottom, left: x1, right: x2 } = dom.getBoundingClientRect();
 				targets.push([pos, [
 					x1,
 					top,
@@ -61,14 +60,15 @@ function buildGetTarget(view, onDrag) {
 			const p2Distance = pointLineDistance(point, line2);
 			return p1Distance - p2Distance || pos1 - pos2;
 		};
-		const targets = getTargets();
+		let targets = getTargets();
 		targets.sort(compare);
+		targets = targets.slice(0, 8);
 		const target = targets.find((target$1) => onDrag({
 			view,
 			pos: target$1[0],
 			event
 		}) !== false);
-		if (target && isDraggingToItself(view, target[0])) return void 0;
+		if (target && isDraggingToItself(view, target[0])) return;
 		return target;
 	};
 	let prevPoint;
@@ -263,4 +263,5 @@ function defineDropIndicator(options) {
 }
 
 //#endregion
-export { defineDropIndicator };
+export { defineDropIndicator };
+//# sourceMappingURL=drop-indicator-D1eHOhSi.js.map

package/dist/drop-indicator-D1eHOhSi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"drop-indicator-D1eHOhSi.js","names":["stack: StackItem[]","targets: DropTarget[]","prevTargets: DropTarget[]","prevDoc: ProseMirrorNode | undefined","prevRect: DOMRect | undefined","getTargetImpl: GetTarget","target","prevPoint: Point | undefined","prevTarget: DropTarget | undefined","getTargetCached: GetTarget","getTarget: GetTarget | undefined","hideId: ReturnType<typeof setTimeout> | undefined","prevX: number | undefined","prevY: number | undefined","hasDragOverEvent: boolean","showHandler: ShowHandler","hideHandler: VoidFunction","dragHandler: DragEventHandler"],"sources":["../src/drop-indicator/drop-target.ts","../src/drop-indicator/drop-indicator-plugin.ts","../src/drop-indicator/drop-indicator-facet.ts","../src/drop-indicator/drop-indicator.ts"],"sourcesContent":["import { isHTMLElement } from '@ocavue/utils'\nimport { isNodeSelection } from '@prosekit/core'\nimport type { ProseMirrorNode } from '@prosekit/pm/model'\nimport type { EditorView } from '@prosekit/pm/view'\n\nimport type { DragEventHandler } from './types'\n\ntype Point = readonly [x: number, y: number]\n\ntype Line = readonly [x1: number, y1: number, x2: number, y2: number]\n\n/**\n * @internal\n */\ntype DropTarget = readonly [pos: number, line: Line]\n\nfunction getTargetsByView(view: EditorView): DropTarget[] {\n  type StackItem = [pos: number, node: ProseMirrorNode]\n  let stack: StackItem[] = [[-1, view.state.doc]]\n  let targets: DropTarget[] = []\n\n  while (stack.length > 0) {\n    const [pos, node] = stack.pop()!\n    if (pos >= 0) {\n      let dom = view.nodeDOM(pos)\n      if (dom && isHTMLElement(dom)) {\n        let rect = dom.getBoundingClientRect()\n        let { top, bottom, left: x1, right: x2 } = rect\n        targets.push(\n          [pos, [x1, top, x2, top]],\n          [pos + node.nodeSize, [x1, bottom, x2, bottom]],\n        )\n      }\n    }\n    if (node.isBlock && !node.isTextblock) {\n      let childPos = pos + 1\n      for (let child of node.children) {\n        stack.push([childPos, child])\n        childPos += child.nodeSize\n      }\n    }\n  }\n\n  return targets\n}\n\n/**\n * @internal\n */\nexport type GetTarget = (point: Point, event: DragEvent) => DropTarget | undefined\n\n/**\n * @internal\n */\nexport function buildGetTarget(\n  view: EditorView,\n  onDrag: DragEventHandler,\n): GetTarget {\n  let prevTargets: DropTarget[] = []\n  let prevDoc: ProseMirrorNode | undefined\n  let prevRect: DOMRect | undefined\n\n  const getTargets = (): DropTarget[] => {\n    const rect = view.dom.getBoundingClientRect()\n    const doc = view.state.doc\n\n    if (\n      prevTargets && prevDoc && prevRect\n      && rect.width === prevRect.width\n      && rect.height === prevRect.height\n      && rect.x === prevRect.x\n      && rect.y === prevRect.y\n      && prevDoc.eq(doc)\n    ) {\n      return prevTargets\n    }\n\n    prevRect = rect\n    prevDoc = doc\n    prevTargets = getTargetsByView(view)\n    return prevTargets\n  }\n\n  const getTargetImpl: GetTarget = (point, event) => {\n    if (!view.editable || view.isDestroyed) {\n      return\n    }\n\n    const compare = (p1: DropTarget, p2: DropTarget): number => {\n      const [pos1, line1] = p1\n      const [pos2, line2] = p2\n      const p1Distance = pointLineDistance(point, line1)\n      const p2Distance = pointLineDistance(point, line2)\n\n      return (p1Distance - p2Distance) || (pos1 - pos2)\n    }\n\n    let targets = getTargets()\n    targets.sort(compare)\n\n    // Only consider the first few targets for performance reasons.\n    targets = targets.slice(0, 8)\n\n    // Find the closest valid target.\n    const target = targets.find(target => onDrag({ view, pos: target[0], event }) !== false)\n\n    // If the dragging node is already at the target position, we ignore this\n    // target. Notice that we don't pick the second better target here.\n    if (target && isDraggingToItself(view, target[0])) {\n      return undefined\n    }\n\n    return target\n  }\n\n  let prevPoint: Point | undefined\n  let prevTarget: DropTarget | undefined\n\n  const getTargetCached: GetTarget = (point, event) => {\n    if (prevPoint && pointEqual(prevPoint, point)) {\n      return prevTarget\n    }\n\n    prevPoint = point\n    prevTarget = getTargetImpl(point, event)\n    return prevTarget\n  }\n\n  return getTargetCached\n}\n\nfunction pointEqual(a: Point, b: Point) {\n  return a[0] === b[0] && a[1] === b[1]\n}\n\nfunction pointPointDistance(a: Point, b: Point) {\n  // Manhattan distance\n  return Math.abs(a[0] - b[0]) + Math.abs(a[1] - b[1])\n}\n\nfunction pointLineDistance(point: Point, line: Line) {\n  // Notice that we are actually not calculating the distance between the point\n  // and the line. Instead, we are calculating the distance between the point\n  // and the two endpoints of the line.\n  return Math.min(\n    pointPointDistance(point, [line[0], line[1]]),\n    pointPointDistance(point, [line[2], line[3]]),\n  )\n}\n\n/**\n * Whether the dragging node is being dragged to the same position. For example,\n * dragging a list node into a new position that is just below the list node, or\n * dragging a nested quoteblock into itself.\n */\nfunction isDraggingToItself(view: EditorView, pos: number) {\n  const dragging = view.dragging\n  if (!dragging) return\n\n  const { move } = dragging\n  if (!move) return\n\n  const selection = view.state.selection\n  if (!isNodeSelection(selection)) return\n\n  const { from, to } = selection\n  return from <= pos && pos <= to\n}\n","import type { ResolvedPos } from '@prosekit/pm/model'\nimport {\n  NodeSelection,\n  Plugin,\n  PluginKey,\n  TextSelection,\n  type PluginView,\n} from '@prosekit/pm/state'\nimport type { EditorView } from '@prosekit/pm/view'\n\nimport {\n  buildGetTarget,\n  type GetTarget,\n} from './drop-target'\nimport type {\n  DragEventHandler,\n  ShowHandler,\n  ViewDragging,\n} from './types'\n\n/**\n * @internal\n */\ninterface DropIndicatorPluginOptions {\n  onDrag: DragEventHandler\n  onShow: ShowHandler\n  onHide: VoidFunction\n}\n\n/**\n * @internal\n */\nexport function createDropIndicatorPlugin(options: DropIndicatorPluginOptions): Plugin {\n  let getTarget: GetTarget | undefined\n\n  return new Plugin({\n    key: new PluginKey('prosekit-drop-indicator'),\n    view: (view) => {\n      getTarget = buildGetTarget(view, options.onDrag)\n      return createDropIndicatorView(view, getTarget, options)\n    },\n    props: {\n      handleDrop(view, event, slice, move): boolean {\n        if (!getTarget) return false\n\n        const target = getTarget([event.clientX, event.clientY], event)\n\n        if (!target) return false\n\n        event.preventDefault()\n        let insertPos = target[0]\n\n        let tr = view.state.tr\n        if (move) {\n          let { node } = (view.dragging as ViewDragging | null) || {}\n          if (node) node.replace(tr)\n          else tr.deleteSelection()\n        }\n\n        let pos = tr.mapping.map(insertPos)\n        let isNode = slice.openStart == 0 && slice.openEnd == 0 && slice.content.childCount == 1\n        let beforeInsert = tr.doc\n        if (isNode) tr.replaceRangeWith(pos, pos, slice.content.firstChild!)\n        else tr.replaceRange(pos, pos, slice)\n        if (tr.doc.eq(beforeInsert)) {\n          return true\n        }\n\n        let $pos = tr.doc.resolve(pos)\n        if (\n          isNode && NodeSelection.isSelectable(slice.content.firstChild!)\n          && $pos.nodeAfter && $pos.nodeAfter.sameMarkup(slice.content.firstChild!)\n        ) {\n          tr.setSelection(new NodeSelection($pos))\n        } else {\n          let end = tr.mapping.map(insertPos)\n          tr.mapping.maps[tr.mapping.maps.length - 1].forEach((_from, _to, _newFrom, newTo) => end = newTo)\n          tr.setSelection(selectionBetween(view, $pos, tr.doc.resolve(end)))\n        }\n        view.focus()\n        view.dispatch(tr.setMeta('uiEvent', 'drop'))\n        return true\n      },\n    },\n  })\n}\n\nfunction selectionBetween(view: EditorView, $anchor: ResolvedPos, $head: ResolvedPos, bias?: number) {\n  return view.someProp('createSelectionBetween', f => f(view, $anchor, $head))\n    || TextSelection.between($anchor, $head, bias)\n}\n\nfunction createDropIndicatorView(view: EditorView, getTarget: GetTarget, options: DropIndicatorPluginOptions): PluginView {\n  let dom = view.dom\n  let hideId: ReturnType<typeof setTimeout> | undefined\n  let prevX: number | undefined\n  let prevY: number | undefined\n  let hasDragOverEvent: boolean = false\n\n  const scheduleHide = () => {\n    if (hideId) {\n      clearTimeout(hideId)\n    }\n\n    hasDragOverEvent = false\n    hideId = setTimeout(() => {\n      if (hasDragOverEvent) return\n      options.onHide()\n    }, 30)\n  }\n\n  const handleDragOver = (event: DragEvent): void => {\n    hasDragOverEvent = true\n\n    const { clientX, clientY } = event\n    if (prevX === clientX && prevY === clientY) {\n      return\n    }\n    prevX = clientX\n    prevY = clientY\n\n    let target = getTarget([clientX, clientY], event)\n\n    if (!target) {\n      scheduleHide()\n      return\n    } else {\n      const [pos, [x1, y1, x2, y2]] = target\n      const line = { p1: { x: x1, y: y1 }, p2: { x: x2, y: y2 } }\n      options.onShow({ view, pos, line })\n    }\n  }\n\n  dom.addEventListener('dragover', handleDragOver)\n  dom.addEventListener('dragend', scheduleHide)\n  dom.addEventListener('drop', scheduleHide)\n  dom.addEventListener('dragleave', scheduleHide)\n\n  const destroy = () => {\n    dom.removeEventListener('dragover', handleDragOver)\n    dom.removeEventListener('dragend', scheduleHide)\n    dom.removeEventListener('drop', scheduleHide)\n    dom.removeEventListener('dragleave', scheduleHide)\n  }\n\n  return { destroy }\n}\n","import {\n  defineFacet,\n  defineFacetPayload,\n  pluginFacet,\n  type PlainExtension,\n  type PluginPayload,\n} from '@prosekit/core'\n\nimport { createDropIndicatorPlugin } from './drop-indicator-plugin'\nimport type {\n  DragEventHandler,\n  ShowHandler,\n} from './types'\n\n/**\n * @internal\n */\nexport function defineDropIndicatorPayload(\n  payload: DropIndicatorPayload,\n): PlainExtension {\n  return defineFacetPayload(dropIndicatorFacet, [payload]) as PlainExtension\n}\n\n/**\n * @internal\n */\nexport interface DropIndicatorPayload {\n  /**\n   * A callback that is called when the drop indicator should be shown.\n   */\n  onShow?: ShowHandler\n\n  /**\n   * A callback that is called when the drop indicator should be hidden.\n   */\n  onHide?: VoidFunction\n\n  /**\n   * A callback that is called when the `dragover` event is fired. You can\n   * return `false` to disable the current drop point and thus hide the drop\n   * indicator.\n   */\n  onDrag?: DragEventHandler\n}\n\nconst dropIndicatorFacet = defineFacet<DropIndicatorPayload, PluginPayload>({\n  parent: pluginFacet,\n  singleton: true,\n  reducer: (payloads: DropIndicatorPayload[]): PluginPayload => {\n    let showHandlers = payloads.map(p => p.onShow).filter(x => !!x)\n    let hideHandlers = payloads.map(p => p.onHide).filter(x => !!x)\n    let dragHandlers = payloads.map(p => p.onDrag).filter(x => !!x)\n\n    let showHandler: ShowHandler = (options) => {\n      for (let fn of showHandlers) {\n        fn(options)\n      }\n    }\n\n    let hideHandler: VoidFunction = () => {\n      for (let fn of hideHandlers) {\n        fn()\n      }\n    }\n\n    let dragHandler: DragEventHandler = (options): boolean => {\n      for (let fn of dragHandlers) {\n        if (fn(options) === false) return false\n      }\n      return true\n    }\n\n    if (showHandlers.length === 0) {\n      // No `onShow` event handler, so we don't need to create a plugin.\n      return []\n    }\n\n    return createDropIndicatorPlugin({\n      onDrag: dragHandler,\n      onShow: showHandler,\n      onHide: hideHandler,\n    })\n  },\n})\n","import type { PlainExtension } from '@prosekit/core'\n\nimport {\n  defineDropIndicatorPayload,\n  type DropIndicatorPayload,\n} from './drop-indicator-facet'\n\n/**\n * @internal\n */\nexport type DropIndicatorExtension = PlainExtension\n\n/**\n * Defines an extension that controls the behavior of the drop indicator.\n *\n * This extension itself doesn't draw the drop indicator, but it provides the\n * necessary callbacks to do so. You probably don't want to use this extension\n * directly, but rather use the `<DropIndicator>` component.\n *\n * You can add this extension multiple times. If any extension has `onDrag`\n * callback defined, and it returns `false`, then the drop point will be\n * discarded.\n *\n * @public\n */\nexport function defineDropIndicator(\n  options?: DropIndicatorOptions,\n): DropIndicatorExtension {\n  return defineDropIndicatorPayload(options ?? {})\n}\n\n/**\n * Options for {@link defineDropIndicator}.\n *\n * @public\n */\nexport interface DropIndicatorOptions extends DropIndicatorPayload {}\n"],"mappings":"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"}

package/dist/enter-rule-RdhEA900.js

@@ -93,4 +93,5 @@ function execRules(view, rules, dispatch) {
 const MAX_MATCH = 200;
 
 //#endregion
-export { defineEnterRule, defineTextBlockEnterRule };
+export { defineEnterRule, defineTextBlockEnterRule };
+//# sourceMappingURL=enter-rule-RdhEA900.js.map

package/dist/enter-rule-RdhEA900.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enter-rule-RdhEA900.js","names":["rule: EnterRule","regex: RegExp","handler: EnterRuleHandler","stop: boolean","rules: EnterRule[]","command: Command"],"sources":["../src/enter-rule/index.ts"],"sourcesContent":["import {\n  defineFacet,\n  defineFacetPayload,\n  getNodeType,\n  isTextSelection,\n  maybeRun,\n  OBJECT_REPLACEMENT_CHARACTER,\n  pluginFacet,\n  type PlainExtension,\n  type PluginPayload,\n} from '@prosekit/core'\nimport { keydownHandler } from '@prosekit/pm/keymap'\nimport type {\n  Attrs,\n  NodeType,\n} from '@prosekit/pm/model'\nimport {\n  PluginKey,\n  ProseMirrorPlugin,\n  type Command,\n  type EditorState,\n  type Transaction,\n} from '@prosekit/pm/state'\nimport type { EditorView } from '@prosekit/pm/view'\n\n/**\n * @public\n *\n * Options for {@link EnterRuleHandler}.\n */\nexport interface EnterRuleHandlerOptions {\n  /**\n   * The current editor state.\n   */\n  state: EditorState\n\n  /**\n   * The start position of the matched text.\n   */\n  from: number\n\n  /**\n   * The end position of the matched text.\n   */\n  to: number\n\n  /**\n   * The matched result from the regular expression.\n   */\n  match: RegExpExecArray\n}\n\n/**\n * @public\n */\nexport type EnterRuleHandler = (options: EnterRuleHandlerOptions) => Transaction | null\n\n/**\n * Options for {@link defineEnterRule}.\n *\n * @public\n */\nexport type EnterRuleOptions = {\n  /**\n   * The regular expression to match against. It should end with `$`.\n   */\n  regex: RegExp\n\n  /**\n   * A function to be called when an enter rule is triggered.\n   */\n  handler: EnterRuleHandler\n\n  /**\n   * Whether to stop further handlers from being called if this rule is triggered.\n   *\n   * @default false\n   */\n  stop?: boolean\n}\n\n/**\n * Options for {@link defineTextBlockEnterRule}.\n *\n * @public\n */\nexport interface TextBlockEnterRuleOptions {\n  /**\n   * The regular expression to match against. It should end with `$`.\n   */\n  regex: RegExp\n\n  /**\n   * The node type to replace the matched text with.\n   */\n  type: string | NodeType\n\n  /**\n   * Attributes to set on the node. If a function is provided, it will be called\n   * with the matched result from the regular expression.\n   */\n  attrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null)\n\n  /**\n   * Whether to stop further handlers from being called if this rule is triggered.\n   *\n   * @default true\n   */\n  stop?: boolean\n}\n\n/**\n * Defines an enter rule. An enter rule applies when the text directly in front of\n * the cursor matches `regex` and user presses Enter. The `regex` should end\n * with `$`.\n *\n * @param options\n *\n * @public\n */\nexport function defineEnterRule({\n  regex,\n  handler,\n  stop = false,\n}: EnterRuleOptions): PlainExtension {\n  const rule: EnterRule = new EnterRule(regex, handler, stop)\n  return defineFacetPayload(enterRule, [rule]) as PlainExtension\n}\n\n/**\n * Defines an enter rule that replaces the matched text with a block node.\n *\n * See also {@link defineEnterRule}.\n *\n * @param options\n *\n * @public\n */\nexport function defineTextBlockEnterRule({\n  regex,\n  type,\n  attrs,\n  stop = true,\n}: TextBlockEnterRuleOptions): PlainExtension {\n  return defineEnterRule({\n    regex,\n    handler: ({ state, from, to, match }) => {\n      const nodeType = getNodeType(state.schema, type)\n      const $start = state.doc.resolve(from)\n\n      if (\n        !$start\n          .node(-1)\n          .canReplaceWith($start.index(-1), $start.indexAfter(-1), nodeType)\n      ) {\n        return null\n      }\n\n      const nodeAttrs = maybeRun(attrs, match)\n      return state.tr\n        .delete(from, to)\n        .setBlockType(from, from, nodeType, nodeAttrs)\n    },\n    stop,\n  })\n}\n\n/**\n * @internal\n */\nclass EnterRule {\n  constructor(\n    readonly regex: RegExp,\n    readonly handler: EnterRuleHandler,\n    readonly stop: boolean,\n  ) {}\n}\n\nconst enterRule = defineFacet<EnterRule, PluginPayload>({\n  reduce: () => {\n    let rules: EnterRule[] = []\n\n    const command: Command = (state, dispatch, view) => {\n      if (!view) return false\n      return execRules(view, rules, dispatch)\n    }\n    const handler = keydownHandler({ Enter: command })\n    const plugin = new ProseMirrorPlugin({\n      key: new PluginKey('prosekit-enter-rule'),\n      props: { handleKeyDown: handler },\n    })\n\n    return function reducer(inputs) {\n      rules = inputs\n      return plugin\n    }\n  },\n\n  parent: pluginFacet,\n})\n\nfunction execRules(\n  view: EditorView,\n  rules: readonly EnterRule[],\n  dispatch?: (tr: Transaction) => void,\n): boolean {\n  if (view.composing) return false\n  const state = view.state\n  const selection = state.selection\n  if (!isTextSelection(selection)) return false\n  const $cursor = selection.$cursor\n  if (!$cursor || $cursor.parent.type.spec.code) return false\n\n  const textBefore = $cursor.parent.textBetween(\n    Math.max(0, $cursor.parentOffset - MAX_MATCH),\n    $cursor.parentOffset,\n    null,\n    OBJECT_REPLACEMENT_CHARACTER,\n  )\n\n  for (const rule of rules) {\n    rule.regex.lastIndex = 0\n    const match = rule.regex.exec(textBefore)\n    const tr = match\n      && rule.handler({\n        state,\n        from: $cursor.pos - match[0].length,\n        to: $cursor.pos,\n        match,\n      })\n    if (!tr) continue\n    dispatch?.(tr)\n\n    if (rule.stop) {\n      return true\n    }\n  }\n  return false\n}\n\nconst MAX_MATCH = 200\n"],"mappings":";;;;;;;;;;;;;;AAwHA,SAAgB,gBAAgB,EAC9B,OACA,SACA,OAAO,SAC4B;CACnC,MAAMA,OAAkB,IAAI,UAAU,OAAO,SAAS,KAAK;AAC3D,QAAO,mBAAmB,WAAW,CAAC,KAAK,CAAC;;;;;;;;;;;AAY9C,SAAgB,yBAAyB,EACvC,OACA,MACA,OACA,OAAO,QACqC;AAC5C,QAAO,gBAAgB;EACrB;EACA,UAAU,EAAE,OAAO,MAAM,IAAI,YAAY;GACvC,MAAM,WAAW,YAAY,MAAM,QAAQ,KAAK;GAChD,MAAM,SAAS,MAAM,IAAI,QAAQ,KAAK;AAEtC,OACE,CAAC,OACE,KAAK,GAAG,CACR,eAAe,OAAO,MAAM,GAAG,EAAE,OAAO,WAAW,GAAG,EAAE,SAAS,CAEpE,QAAO;GAGT,MAAM,YAAY,SAAS,OAAO,MAAM;AACxC,UAAO,MAAM,GACV,OAAO,MAAM,GAAG,CAChB,aAAa,MAAM,MAAM,UAAU,UAAU;;EAElD;EACD,CAAC;;;;;AAMJ,IAAM,YAAN,MAAgB;CACd,YACE,AAASC,OACT,AAASC,SACT,AAASC,MACT;EAHS;EACA;EACA;;;AAIb,MAAM,YAAY,YAAsC;CACtD,cAAc;EACZ,IAAIC,QAAqB,EAAE;EAE3B,MAAMC,WAAoB,OAAO,UAAU,SAAS;AAClD,OAAI,CAAC,KAAM,QAAO;AAClB,UAAO,UAAU,MAAM,OAAO,SAAS;;EAEzC,MAAM,UAAU,eAAe,EAAE,OAAO,SAAS,CAAC;EAClD,MAAM,SAAS,IAAI,kBAAkB;GACnC,KAAK,IAAI,UAAU,sBAAsB;GACzC,OAAO,EAAE,eAAe,SAAS;GAClC,CAAC;AAEF,SAAO,SAAS,QAAQ,QAAQ;AAC9B,WAAQ;AACR,UAAO;;;CAIX,QAAQ;CACT,CAAC;AAEF,SAAS,UACP,MACA,OACA,UACS;AACT,KAAI,KAAK,UAAW,QAAO;CAC3B,MAAM,QAAQ,KAAK;CACnB,MAAM,YAAY,MAAM;AACxB,KAAI,CAAC,gBAAgB,UAAU,CAAE,QAAO;CACxC,MAAM,UAAU,UAAU;AAC1B,KAAI,CAAC,WAAW,QAAQ,OAAO,KAAK,KAAK,KAAM,QAAO;CAEtD,MAAM,aAAa,QAAQ,OAAO,YAChC,KAAK,IAAI,GAAG,QAAQ,eAAe,UAAU,EAC7C,QAAQ,cACR,MACA,6BACD;AAED,MAAK,MAAM,QAAQ,OAAO;AACxB,OAAK,MAAM,YAAY;EACvB,MAAM,QAAQ,KAAK,MAAM,KAAK,WAAW;EACzC,MAAM,KAAK,SACN,KAAK,QAAQ;GACd;GACA,MAAM,QAAQ,MAAM,MAAM,GAAG;GAC7B,IAAI,QAAQ;GACZ;GACD,CAAC;AACJ,MAAI,CAAC,GAAI;AACT,aAAW,GAAG;AAEd,MAAI,KAAK,KACP,QAAO;;AAGX,QAAO;;AAGT,MAAM,YAAY"}

package/dist/gap-cursor/style.css

@@ -24,3 +24,5 @@
   display: block;
 }
 
+
+/*# sourceMappingURL=style.css.map*/

package/dist/gap-cursor/style.css.map

@@ -0,0 +1 @@
+{"version":3,"file":"style.css","names":[],"sources":["../../src/gap-cursor/style.css"],"sourcesContent":[".ProseMirror-gapcursor {\n  display: none;\n  position: relative;\n  pointer-events: none;\n}\n\n.ProseMirror-gapcursor:after {\n  display: block;\n  position: absolute;\n  top: -2px;\n  width: 20px;\n  border-top: 1px solid currentColor;\n  content: \"\";\n  animation: ProseMirror-cursor-blink 1.1s steps(2, start) infinite;\n}\n\n@keyframes ProseMirror-cursor-blink {\n  to {\n    visibility: hidden;\n  }\n}\n\n.ProseMirror-focused .ProseMirror-gapcursor {\n  display: block;\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA"}

package/dist/gap-cursor/style.js

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

package/dist/{input-rule-Gji4N7Oe.js → input-rule-B17tpW4m.js}

@@ -16,7 +16,7 @@ function defineInputRule(rule) {
 * @internal
 */
 function createMarkInputRule({ regex, type, attrs = null, inCodeMark = false }) {
-	const rule = new InputRule(regex, (state, match, start, end) => {
+	return new InputRule(regex, (state, match, start, end) => {
 		const { tr, schema } = state;
 		const [fullText, markText] = match;
 		if (!markText) return null;
@@ -33,7 +33,6 @@ function createMarkInputRule({ regex, type, attrs = null, inCodeMark = false })
 		tr.setStoredMarks(initialStoredMarks);
 		return tr;
 	}, { inCodeMark });
-	return rule;
 }
 /**
 * Defines an input rule for automatically adding inline marks when a given
@@ -90,4 +89,5 @@ const inputRuleFacet = defineFacet({
 });
 
 //#endregion
-export { createMarkInputRule, defineInputRule, defineMarkInputRule, defineTextBlockInputRule, defineWrappingInputRule };
+export { createMarkInputRule, defineInputRule, defineMarkInputRule, defineTextBlockInputRule, defineWrappingInputRule };
+//# sourceMappingURL=input-rule-B17tpW4m.js.map

package/dist/input-rule-B17tpW4m.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-rule-B17tpW4m.js","names":["rules: InputRule[]"],"sources":["../src/input-rule/index.ts"],"sourcesContent":["import {\n  defineFacet,\n  defineFacetPayload,\n  getMarkType,\n  getNodeType,\n  isMarkAbsent,\n  maybeRun,\n  pluginFacet,\n  type PlainExtension,\n  type PluginPayload,\n} from '@prosekit/core'\nimport {\n  InputRule,\n  inputRules,\n  textblockTypeInputRule,\n  wrappingInputRule,\n} from '@prosekit/pm/inputrules'\nimport type {\n  Attrs,\n  MarkType,\n  NodeType,\n  ProseMirrorNode,\n  Schema,\n} from '@prosekit/pm/model'\nimport type { Plugin } from '@prosekit/pm/state'\n\n/**\n * Defines an input rule extension.\n *\n * @param rule - The ProseMirror input rule to add.\n *\n * @public\n */\nexport function defineInputRule(rule: InputRule): PlainExtension {\n  return defineInputRuleFacetPayload(() => rule)\n}\n\n/**\n * Options for {@link defineMarkInputRule}.\n *\n * @public\n */\nexport interface MarkInputRuleOptions {\n  /**\n   * The regular expression to match against, which should end with `$` and has\n   * exactly one capture group. All other matched text outside the capture group\n   * will be deleted.\n   */\n  regex: RegExp\n\n  /**\n   * The type of mark to set.\n   */\n  type: string | MarkType\n\n  /**\n   * Attributes to set on the mark.\n   */\n  attrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null)\n\n  /**\n   * Whether this rule should fire inside marks marked as [code](https://prosemirror.net/docs/ref/#model.MarkSpec.code).\n   *\n   * @default `false`\n   */\n  inCodeMark?: boolean\n}\n\n/**\n * @internal\n */\nexport function createMarkInputRule({\n  regex,\n  type,\n  attrs = null,\n  inCodeMark = false,\n}: MarkInputRuleOptions): InputRule {\n  const rule = new InputRule(regex, (state, match, start, end) => {\n    const { tr, schema } = state\n    const [fullText, markText] = match\n\n    if (!markText) {\n      return null\n    }\n\n    const markStart = start + fullText.indexOf(markText)\n    const markEnd = markStart + markText.length\n\n    if (!(start <= markStart && markStart < markEnd && markEnd <= end)) {\n      // Incorrect regex.\n      return null\n    }\n\n    const markType = getMarkType(schema, type)\n    const mark = markType.create(maybeRun(attrs, match))\n\n    if (!isMarkAbsent(tr.doc, markStart, markEnd, markType, attrs)) {\n      // The mark is already active.\n      return null\n    }\n\n    const initialStoredMarks = tr.storedMarks ?? []\n\n    tr.addMark(markStart, markEnd, mark)\n\n    if (markEnd < end) {\n      tr.delete(markEnd, end)\n    }\n    if (start < markStart) {\n      tr.delete(start, markStart)\n    }\n\n    // Make sure not to reactivate any marks which had previously been\n    // deactivated. By keeping track of the initial stored marks we are able to\n    // discard any unintended consequences of deleting text and adding it again.\n    tr.setStoredMarks(initialStoredMarks)\n\n    return tr\n  }, { inCodeMark })\n\n  return rule\n}\n\n/**\n * Defines an input rule for automatically adding inline marks when a given\n * pattern is typed.\n *\n * @public\n */\nexport function defineMarkInputRule(\n  options: MarkInputRuleOptions,\n): PlainExtension {\n  return defineInputRule(createMarkInputRule(options))\n}\n\n/**\n * Defines an input rule that changes the type of a textblock when the matched\n * text is typed into it.\n *\n * See also [textblockTypeInputRule](https://prosemirror.net/docs/ref/#inputrules.textblockTypeInputRule)\n *\n * @param options\n *\n * @public\n */\nexport function defineTextBlockInputRule({\n  regex,\n  type,\n  attrs,\n}: {\n  /**\n   * The regular expression to match against, which should end with `$`. It\n   * usually also starts with `^` to that it is only matched at the start of a\n   * textblock.\n   */\n  regex: RegExp\n\n  /**\n   * The node type to replace the matched text with.\n   */\n  type: string | NodeType\n\n  /**\n   * Attributes to set on the node.\n   */\n  attrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null)\n}): PlainExtension {\n  return defineInputRuleFacetPayload(({ schema }): InputRule => {\n    const nodeType = getNodeType(schema, type)\n    return textblockTypeInputRule(regex, nodeType, attrs)\n  })\n}\n\n/**\n * Defines an input rule for automatically wrapping a textblock when a given\n * string is typed.\n *\n * See also [wrappingInputRule](https://prosemirror.net/docs/ref/#inputrules.wrappingInputRule)\n *\n * @param options\n *\n * @public\n */\nexport function defineWrappingInputRule({\n  regex,\n  type,\n  attrs,\n  join,\n}: {\n  /**\n   * The regular expression to match against, which should end with `$`. It\n   * usually also starts with `^` to that it is only matched at the start of a\n   * textblock.\n   */\n  regex: RegExp\n\n  /**\n   * The type of node to wrap in.\n   */\n  type: string | NodeType\n\n  /**\n   * Attributes to set on the node.\n   */\n  attrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null)\n\n  /**\n   * By default, if there's a node with the same type above the newly wrapped\n   * node, the rule will try to\n   * [join](https://prosemirror.net/docs/ref/#transform.Transform.join) those\n   * two nodes. You can pass a join predicate, which takes a regular expression\n   * match and the node before the wrapped node, and can return a boolean to\n   * indicate whether a join should happen.\n   */\n  join?: (match: RegExpMatchArray, node: ProseMirrorNode) => boolean\n}): PlainExtension {\n  return defineInputRuleFacetPayload(({ schema }): InputRule => {\n    const nodeType = getNodeType(schema, type)\n    return wrappingInputRule(regex, nodeType, attrs, join)\n  })\n}\n\nfunction defineInputRuleFacetPayload(input: InputRulePayload): PlainExtension {\n  return defineFacetPayload(inputRuleFacet, [input]) as PlainExtension\n}\n\ntype InputRulePayload = (context: { schema: Schema }) => InputRule\n\nconst inputRuleFacet = defineFacet<InputRulePayload, PluginPayload>({\n  reducer: (inputs: InputRulePayload[]): PluginPayload => {\n    return (context): Plugin[] => {\n      const rules: InputRule[] = inputs.flatMap((callback) => callback(context))\n      return [inputRules({ rules })]\n    }\n  },\n  parent: pluginFacet,\n})\n"],"mappings":";;;;;;;;;;;AAiCA,SAAgB,gBAAgB,MAAiC;AAC/D,QAAO,kCAAkC,KAAK;;;;;AAqChD,SAAgB,oBAAoB,EAClC,OACA,MACA,QAAQ,MACR,aAAa,SACqB;AA4ClC,QA3Ca,IAAI,UAAU,QAAQ,OAAO,OAAO,OAAO,QAAQ;EAC9D,MAAM,EAAE,IAAI,WAAW;EACvB,MAAM,CAAC,UAAU,YAAY;AAE7B,MAAI,CAAC,SACH,QAAO;EAGT,MAAM,YAAY,QAAQ,SAAS,QAAQ,SAAS;EACpD,MAAM,UAAU,YAAY,SAAS;AAErC,MAAI,EAAE,SAAS,aAAa,YAAY,WAAW,WAAW,KAE5D,QAAO;EAGT,MAAM,WAAW,YAAY,QAAQ,KAAK;EAC1C,MAAM,OAAO,SAAS,OAAO,SAAS,OAAO,MAAM,CAAC;AAEpD,MAAI,CAAC,aAAa,GAAG,KAAK,WAAW,SAAS,UAAU,MAAM,CAE5D,QAAO;EAGT,MAAM,qBAAqB,GAAG,eAAe,EAAE;AAE/C,KAAG,QAAQ,WAAW,SAAS,KAAK;AAEpC,MAAI,UAAU,IACZ,IAAG,OAAO,SAAS,IAAI;AAEzB,MAAI,QAAQ,UACV,IAAG,OAAO,OAAO,UAAU;AAM7B,KAAG,eAAe,mBAAmB;AAErC,SAAO;IACN,EAAE,YAAY,CAAC;;;;;;;;AAWpB,SAAgB,oBACd,SACgB;AAChB,QAAO,gBAAgB,oBAAoB,QAAQ,CAAC;;;;;;;;;;;;AAatD,SAAgB,yBAAyB,EACvC,OACA,MACA,SAkBiB;AACjB,QAAO,6BAA6B,EAAE,aAAwB;EAC5D,MAAM,WAAW,YAAY,QAAQ,KAAK;AAC1C,SAAO,uBAAuB,OAAO,UAAU,MAAM;GACrD;;;;;;;;;;;;AAaJ,SAAgB,wBAAwB,EACtC,OACA,MACA,OACA,QA4BiB;AACjB,QAAO,6BAA6B,EAAE,aAAwB;EAC5D,MAAM,WAAW,YAAY,QAAQ,KAAK;AAC1C,SAAO,kBAAkB,OAAO,UAAU,OAAO,KAAK;GACtD;;AAGJ,SAAS,4BAA4B,OAAyC;AAC5E,QAAO,mBAAmB,gBAAgB,CAAC,MAAM,CAAC;;AAKpD,MAAM,iBAAiB,YAA6C;CAClE,UAAU,WAA8C;AACtD,UAAQ,YAAsB;GAC5B,MAAMA,QAAqB,OAAO,SAAS,aAAa,SAAS,QAAQ,CAAC;AAC1E,UAAO,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;;;CAGlC,QAAQ;CACT,CAAC"}

package/dist/list/style.css

@@ -127,3 +127,5 @@
   }
 }
 
+
+/*# sourceMappingURL=style.css.map*/

package/dist/list/style.css.map

@@ -0,0 +1 @@
+{"version":3,"file":"style.css","names":[],"sources":["../../src/list/style.css"],"sourcesContent":[":root {\n  --prosekit-list-bullet-icon: url(\"data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' viewBox='0 0 24 24'%3E%3Ccircle cx='12' cy='12' r='2.5' fill='currentColor'/%3E%3C/svg%3E\");\n  --prosekit-list-toggle-open-icon: url(\"data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' viewBox='0 0 24 24'%3E%3Cpolygon points='8,10 12,14 16,10' fill='currentColor'/%3E%3C/svg%3E\");\n  --prosekit-list-toggle-closed-icon: url(\"data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' viewBox='0 0 24 24'%3E%3Cpolygon points='10,8 14,12 10,16' fill='currentColor'/%3E%3C/svg%3E\");\n}\n\n.prosemirror-flat-list {\n  & {\n    position: relative;\n    margin: 0;\n    padding: 0;\n    list-style: none;\n  }\n\n  & > .list-marker {\n    position: absolute;\n    left: 0;\n    width: 1.5em;\n    width: 1lh;\n    height: 1.5em;\n    height: 1lh;\n    text-align: center;\n  }\n\n  & > .list-content {\n    margin-left: 1.5em;\n    margin-left: 1lh;\n  }\n\n  &[data-list-kind=\"bullet\"] > .list-marker,\n  &[data-list-kind=\"toggle\"] > .list-marker {\n    background-color: currentColor;\n    mask-position: center;\n    mask-repeat: no-repeat;\n    mask-size: contain;\n  }\n\n  &[data-list-kind=\"bullet\"] {\n    & > .list-marker {\n      mask-image: var(--prosekit-list-bullet-icon);\n    }\n  }\n\n  &[data-list-kind=\"toggle\"] {\n    & > .list-marker {\n      mask-image: var(--prosekit-list-toggle-open-icon);\n    }\n\n    &[data-list-collapsable][data-list-collapsed] > .list-marker {\n      mask-image: var(--prosekit-list-toggle-closed-icon);\n    }\n  }\n\n  &[data-list-kind=\"ordered\"] {\n    /*\n      Ensure that the counters in children don't escape, so that the sub lists\n      won't affect the counter of the parent list.\n  \n      See also https://github.com/ocavue/prosemirror-flat-list/issues/23\n      */\n    & > * {\n      contain: style;\n    }\n\n    &::before {\n      position: absolute;\n      right: calc(100% - 1.5em);\n      right: calc(100% - 1lh);\n      content: counter(prosemirror-flat-list-counter, decimal) \". \";\n      font-variant-numeric: tabular-nums;\n    }\n    counter-increment: prosemirror-flat-list-counter;\n\n    /* \n      Reset the counter for the first list node in the sequence.\n      */\n    &:first-child,\n    :not(&) + & {\n      counter-reset: prosemirror-flat-list-counter;\n\n      /* \n        If the first list node has a custom order number, set the counter to that value.\n        */\n      &[data-list-order] {\n        @supports (counter-set: prosemirror-flat-list-counter 1) {\n          counter-set: prosemirror-flat-list-counter var(--prosemirror-flat-list-order);\n        }\n\n        /* \n          Safari older than version 17.2 doesn't support `counter-set` \n          */\n        @supports not (counter-set: prosemirror-flat-list-counter 1) {\n          counter-increment: prosemirror-flat-list-counter var(--prosemirror-flat-list-order);\n        }\n      }\n    }\n  }\n\n  &[data-list-kind=\"task\"] {\n    & > .list-marker {\n      &,\n      & * {\n        /* Make sure that the checkbox is at the center */\n        display: flex;\n        align-items: center;\n        justify-content: center;\n        margin: 0;\n        padding: 0;\n        cursor: pointer;\n      }\n    }\n  }\n\n  &[data-list-kind=\"toggle\"] {\n    &[data-list-collapsable] > .list-marker {\n      cursor: pointer;\n    }\n    &:not([data-list-collapsable]) > .list-marker {\n      opacity: 40%;\n      pointer-events: none;\n    }\n\n    /* If collapsed, hide the second and futher children */\n    &[data-list-collapsable][data-list-collapsed] > .list-content > *:nth-child(n+2) {\n      display: none;\n    }\n  }\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA"}

package/dist/list/style.js

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

package/dist/loro/style.css

@@ -32,3 +32,5 @@
   user-select: none;
 }
 
+
+/*# sourceMappingURL=style.css.map*/

package/dist/loro/style.css.map

@@ -0,0 +1 @@
+{"version":3,"file":"style.css","names":[],"sources":["../../src/loro/style.css"],"sourcesContent":[".ProseMirror-loro-cursor:first-child {\n  margin-top: 16px;\n}\n\n/* This gives the remote user caret. The colors are automatically overwritten */\n.ProseMirror-loro-cursor {\n  position: relative;\n  margin-right: -1px;\n  margin-left: -1px;\n  border-right: 1px solid black;\n  border-left: 1px solid black;\n  border-color: orange;\n  word-break: normal;\n  pointer-events: none;\n}\n\n/* This renders the username above the caret */\n.ProseMirror-loro-cursor > div {\n  position: absolute;\n  top: -1.05em;\n  left: -1px;\n  padding-right: 2px;\n  padding-left: 2px;\n  background-color: rgb(250, 129, 0);\n  color: white;\n  font-style: normal;\n  font-weight: normal;\n  font-size: 13px;\n  line-height: normal;\n  font-family: serif;\n  white-space: nowrap;\n  user-select: none;\n}\n"],"mappings":"AAAA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA"}

package/dist/loro/style.js

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

package/dist/{mark-rule-D7zaa32n.js → mark-rule-BCqIZMDu.js}

@@ -34,8 +34,7 @@ function getTextRanges(doc, from, to) {
 	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 [];
+		if (!$from.blockRange($to)) return [];
 		return getSpanTextRanges($from, $to);
 	}
 }
@@ -157,4 +156,5 @@ const markRuleFacet = defineFacet({
 });
 
 //#endregion
-export { defineMarkRule };
+export { defineMarkRule };
+//# sourceMappingURL=mark-rule-BCqIZMDu.js.map

package/dist/mark-rule-BCqIZMDu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mark-rule-BCqIZMDu.js","names":["stack: Array<[start: number, node: ProseMirrorNode]>","ranges: Array<[number, number]>","start","ranges: MarkRange[]","result: MarkRange[]","mark","tr","toRemove: MarkRange[]","toCreate: MarkRange[]","rules: MarkRuleOptions[]"],"sources":["../src/mark-rule/range.ts","../src/mark-rule/apply.ts","../src/mark-rule/mark-rule.ts"],"sourcesContent":["import type {\n  ProseMirrorNode,\n  ResolvedPos,\n} from '@prosekit/pm/model'\nimport type {\n  EditorState,\n  Transaction,\n} from '@prosekit/pm/state'\nimport type { ProsemirrorNode } from 'prosemirror-flat-list'\n\nfunction getSpanTextRanges($from: ResolvedPos, $to: ResolvedPos) {\n  const nodeRange = $from.blockRange($to)\n  if (!nodeRange) {\n    return []\n  }\n\n  const stack: Array<[start: number, node: ProseMirrorNode]> = []\n  let start = nodeRange.start\n\n  for (let i = nodeRange.startIndex; i < nodeRange.endIndex; i++) {\n    const child = nodeRange.parent.child(i)\n    stack.push([start, child])\n    start += child.nodeSize\n  }\n\n  const ranges: Array<[number, number]> = []\n\n  while (stack.length > 0) {\n    const [start, node] = stack.pop()!\n    if (node.type.spec.code) {\n      continue\n    }\n\n    if (node.type.isTextblock) {\n      ranges.push([start + 1, start + 1 + node.content.size])\n      continue\n    }\n\n    node.forEach((child, offset) => {\n      stack.push([start + offset + 1, child])\n    })\n  }\n\n  return ranges\n}\n\nfunction getInlineTextRange(\n  $from: ResolvedPos,\n  $to: ResolvedPos,\n): [number, number] {\n  return [$from.start(), $to.end()]\n}\n\nfunction getTextRanges(\n  doc: ProsemirrorNode,\n  from: number,\n  to: number,\n): Array<[number, number]> {\n  const $from = doc.resolve(from)\n  const $to = doc.resolve(to)\n\n  if ($from.sameParent($to) && $from.parent.isTextblock) {\n    return [getInlineTextRange($from, $to)]\n  } else {\n    const nodeRange = $from.blockRange($to)\n    if (!nodeRange) {\n      return []\n    }\n\n    return getSpanTextRanges($from, $to)\n  }\n}\n\nfunction getMapRange(\n  transactions: readonly Transaction[],\n  oldState: EditorState,\n  newState: EditorState,\n) {\n  let lo = oldState.selection.from\n  let hi = oldState.selection.to\n\n  for (const tr of transactions) {\n    for (const map of tr.mapping.maps) {\n      lo = map.map(lo)\n      hi = map.map(hi)\n\n      map.forEach((_oldStart, _oldEnd, newStart, newEnd) => {\n        lo = Math.min(lo, hi, newStart)\n        hi = Math.max(lo, hi, newEnd)\n      })\n    }\n  }\n\n  lo = Math.min(lo, hi, newState.selection.from)\n  hi = Math.min(lo, hi, newState.selection.to)\n\n  return [lo, hi] as const\n}\n\nexport function getCheckRanges(\n  transactions: readonly Transaction[],\n  oldState: EditorState,\n  newState: EditorState,\n): Array<[number, number]> {\n  const [from, to] = getMapRange(transactions, oldState, newState)\n  return getTextRanges(newState.doc, from, to)\n}\n","import {\n  getMarkType,\n  maybeRun,\n  OBJECT_REPLACEMENT_CHARACTER,\n} from '@prosekit/core'\nimport type {\n  Mark,\n  ProseMirrorNode,\n} from '@prosekit/pm/model'\nimport type {\n  EditorState,\n  Transaction,\n} from '@prosekit/pm/state'\n\nimport { getCheckRanges } from './range'\nimport type { MarkRuleOptions } from './types'\n\ntype MarkRange = [from: number, to: number, mark: Mark]\n\nfunction getExpectedMarkings(\n  rules: MarkRuleOptions[],\n  doc: ProseMirrorNode,\n  from: number,\n  to: number,\n): MarkRange[] {\n  const text = doc.textBetween(from, to, null, OBJECT_REPLACEMENT_CHARACTER)\n  const ranges: MarkRange[] = []\n\n  for (const rule of rules) {\n    rule.regex.lastIndex = 0\n    const matches = text.matchAll(rule.regex)\n    const markType = getMarkType(doc.type.schema, rule.type)\n\n    for (const match of matches) {\n      const index = match.index\n      if (index == null) continue\n      const attrs = maybeRun(rule.attrs, match)\n      const mark = markType.create(attrs)\n      ranges.push([from + index, from + index + match[0].length, mark])\n    }\n  }\n\n  // Sort by start position. If start positions are equal, the longer match\n  // should be prioritized.\n  ranges.sort((a, b) => a[0] - b[0] || b[1] - a[1])\n\n  // Remove overlapped marks.\n  const result: MarkRange[] = []\n  let freeIndex = 0\n\n  for (const range of ranges) {\n    if (range[0] >= freeIndex) {\n      result.push(range)\n      freeIndex = range[1]\n    }\n  }\n\n  return result\n}\n\nfunction getReceivedMarkings(\n  rules: MarkRuleOptions[],\n  doc: ProseMirrorNode,\n  from: number,\n  to: number,\n): MarkRange[] {\n  const result: MarkRange[] = []\n  const schema = doc.type.schema\n  const markTypes = rules.map((rule) => getMarkType(schema, rule.type))\n\n  doc.nodesBetween(from, to, (node, pos) => {\n    if (!node.isInline) {\n      return\n    }\n\n    for (const markType of markTypes) {\n      const mark = node.marks.find((mark) => mark.type === markType)\n      if (mark) {\n        result.push([pos, pos + node.nodeSize, mark])\n      }\n    }\n  })\n  return result\n}\n\nfunction markRangeEquals(a: MarkRange, b: MarkRange): boolean {\n  return a[0] === b[0] && a[1] === b[1] && a[2].eq(b[2])\n}\n\nfunction markRangeDiffs(a: MarkRange[], b: MarkRange[]): MarkRange[] {\n  return a.filter((x) => !b.some((y) => markRangeEquals(x, y)))\n}\n\nexport function applyMarkRules(\n  rules: MarkRuleOptions[],\n  transactions: readonly Transaction[],\n  oldState: EditorState,\n  newState: EditorState,\n): Transaction | null {\n  if (transactions.length === 0 || transactions.every((tr) => !tr.docChanged)) {\n    return null\n  }\n\n  const ranges = getCheckRanges(transactions, oldState, newState)\n\n  const toRemove: MarkRange[] = []\n  const toCreate: MarkRange[] = []\n\n  for (const [from, to] of ranges) {\n    const expected = getExpectedMarkings(rules, newState.doc, from, to)\n    const received = getReceivedMarkings(rules, newState.doc, from, to)\n\n    toRemove.push(...markRangeDiffs(received, expected))\n    toCreate.push(...markRangeDiffs(expected, received))\n  }\n\n  if (toCreate.length === 0 && toRemove.length === 0) {\n    return null\n  }\n\n  const tr = newState.tr\n  for (const [from, to, mark] of toRemove) {\n    tr.removeMark(from, to, mark)\n  }\n  for (const [from, to, mark] of toCreate) {\n    tr.addMark(from, to, mark)\n  }\n  return tr\n}\n","import {\n  defineFacet,\n  defineFacetPayload,\n  pluginFacet,\n  type PlainExtension,\n  type PluginPayload,\n} from '@prosekit/core'\nimport {\n  PluginKey,\n  ProseMirrorPlugin,\n  type EditorState,\n  type Transaction,\n} from '@prosekit/pm/state'\n\nimport { applyMarkRules } from './apply'\nimport type { MarkRuleOptions } from './types'\n\n/**\n * A mark rule is something that can automatically apply marks to text if it\n * matches a certain pattern, and remove them if it doesn't match anymore.\n */\nexport function defineMarkRule(options: MarkRuleOptions): PlainExtension {\n  return defineFacetPayload(markRuleFacet, [options]) as PlainExtension\n}\n\nconst markRuleFacet = defineFacet<MarkRuleOptions, PluginPayload>({\n  reduce: () => {\n    let rules: MarkRuleOptions[] = []\n\n    const plugin = new ProseMirrorPlugin({\n      key: new PluginKey('prosekit-mark-rule'),\n      appendTransaction: (\n        transactions: readonly Transaction[],\n        oldState: EditorState,\n        newState: EditorState,\n      ) => {\n        return applyMarkRules(rules, transactions, oldState, newState)\n      },\n    })\n\n    return function reducer(input) {\n      rules = input\n      return plugin\n    }\n  },\n\n  parent: pluginFacet,\n})\n"],"mappings":"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"}

package/dist/{paste-rule-Cca3n5TA.js → paste-rule-DIEJKIje.js}

@@ -9,28 +9,17 @@ import { Fragment, Slice } from "@prosekit/pm/model";
 const pasteRuleFacet = defineFacet({
 	reduce: () => {
 		let handlers = [];
-		let isPlainText = false;
-		const transformPasted = (slice, view) => {
+		const transformPasted = (slice, view, plain) => {
 			for (const handler of handlers) slice = handler({
 				slice,
 				view,
-				plain: isPlainText
+				plain
 			});
 			return slice;
 		};
 		const plugin = new ProseMirrorPlugin({
 			key: new PluginKey("prosekit-paste-rule"),
-			props: {
-				transformPasted,
-				transformPastedText: (text, plain) => {
-					isPlainText = plain;
-					return text;
-				},
-				transformPastedHTML(html) {
-					isPlainText = false;
-					return html;
-				}
-			}
+			props: { transformPasted }
 		});
 		return (inputs) => {
 			handlers = [...inputs].reverse();
@@ -170,4 +159,5 @@ function replaceMarkInInlineNode(options, node) {
 }
 
 //#endregion
-export { defineMarkPasteRule, definePasteRule };
+export { defineMarkPasteRule, definePasteRule };
+//# sourceMappingURL=paste-rule-DIEJKIje.js.map

package/dist/paste-rule-DIEJKIje.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paste-rule-DIEJKIje.js","names":["handlers: PasteRulePayload[]","chunks: Array<[string, RegExpExecArray | undefined]>","match: RegExpExecArray | null","children: ProseMirrorNode[]","newChildren: ProseMirrorNode[]","nodes: ProseMirrorNode[]","text"],"sources":["../src/paste-rule/paste-rule-plugin.ts","../src/paste-rule/paste-rule.ts","../src/paste-rule/split-text-by-regex.ts","../src/paste-rule/mark-paste-rule.ts"],"sourcesContent":["import {\n  defineFacet,\n  defineFacetPayload,\n  pluginFacet,\n  type PlainExtension,\n  type PluginPayload,\n} from '@prosekit/core'\nimport type { Slice } from '@prosekit/pm/model'\nimport {\n  PluginKey,\n  ProseMirrorPlugin,\n} from '@prosekit/pm/state'\nimport type { EditorView } from '@prosekit/pm/view'\n\ntype PasteRulePayload = (options: { slice: Slice; view: EditorView; plain: boolean }) => Slice\n\n/**\n * @internal\n */\nconst pasteRuleFacet = defineFacet<PasteRulePayload, PluginPayload>({\n  reduce: () => {\n    let handlers: PasteRulePayload[] = []\n\n    const transformPasted = (slice: Slice, view: EditorView, plain: boolean): Slice => {\n      for (const handler of handlers) {\n        slice = handler({ slice, view, plain })\n      }\n      return slice\n    }\n\n    const plugin = new ProseMirrorPlugin({\n      key: new PluginKey('prosekit-paste-rule'),\n      props: {\n        transformPasted,\n      },\n    })\n\n    return (inputs: PasteRulePayload[]) => {\n      // Last added rule (highest priority) is applied first\n      handlers = [...inputs].reverse()\n      return plugin\n    }\n  },\n  singleton: true,\n  parent: pluginFacet,\n})\n\n/**\n * @internal\n */\nexport function definePasteRulePlugin(payload: PasteRulePayload): PlainExtension {\n  return defineFacetPayload(pasteRuleFacet, [payload]) as PlainExtension\n}\n","import type { PlainExtension } from '@prosekit/core'\nimport type { Slice } from '@prosekit/pm/model'\nimport type { EditorView } from '@prosekit/pm/view'\n\nimport { definePasteRulePlugin } from './paste-rule-plugin'\n\n/**\n * @public\n *\n * Options for {@link PasteRuleHandler}.\n */\nexport interface PasteRuleHandlerOptions {\n  /**\n   * The slice to be pasted.\n   */\n  slice: Slice\n\n  /**\n   * The editor view.\n   */\n  view: EditorView\n\n  /**\n   * Whether the pasted content is treated as plain text. This is true when the\n   * `Shift` key is held when pasting.\n   */\n  plain: boolean\n}\n\n/**\n * @public\n *\n * Can be used to transform pasted or dragged-and-dropped content before it is\n * applied to the document.\n */\nexport type PasteRuleHandler = (options: PasteRuleHandlerOptions) => Slice\n\n/**\n * Options for {@link definePasteRule}.\n *\n * @public\n */\nexport interface PasteRuleOptions {\n  /**\n   * A function to be called when a paste rule is triggered.\n   */\n  handler: PasteRuleHandler\n}\n\n/**\n * Defines a paste rule. This rule allows you to modify pasted or dragged\n * content before it is inserted into the document.\n *\n * @param options\n *\n * @public\n */\nexport function definePasteRule({ handler }: PasteRuleOptions): PlainExtension {\n  return definePasteRulePlugin(handler)\n}\n","/**\n * Splits text into chunks based on regex matches, preserving both matched and unmatched segments.\n * Returns an array of tuples where each tuple contains a text segment and either the match data\n * (for matched segments) or undefined (for unmatched segments).\n */\nexport function splitTextByRegex(\n  text: string,\n  regex: RegExp,\n): Array<[string, RegExpExecArray | undefined]> | undefined {\n  regex.lastIndex = 0\n\n  const chunks: Array<[string, RegExpExecArray | undefined]> = []\n  let lastIndex = 0\n  let match: RegExpExecArray | null\n  let matched = false\n\n  while ((match = regex.exec(text))) {\n    const start = match.index\n    const end = regex.lastIndex\n\n    // Push the unmatched prefix, if any.\n    if (start > lastIndex) {\n      chunks.push([text.slice(lastIndex, start), undefined])\n    }\n\n    // Push the matched segment.\n    chunks.push([text.slice(start, end), match])\n    matched = true\n\n    if (lastIndex === end) {\n      // Safeguard against zero-width matches that would otherwise cause an infinite loop.\n      return\n    }\n    lastIndex = end\n  }\n\n  if (matched && lastIndex < text.length) {\n    chunks.push([text.slice(lastIndex), undefined])\n  }\n\n  regex.lastIndex = 0\n\n  return matched ? chunks : undefined\n}\n","import {\n  getMarkType,\n  type PlainExtension,\n} from '@prosekit/core'\nimport type {\n  Attrs,\n  MarkType,\n  ProseMirrorNode,\n} from '@prosekit/pm/model'\nimport {\n  Fragment,\n  Slice,\n} from '@prosekit/pm/model'\n\nimport { definePasteRule } from './paste-rule'\nimport { splitTextByRegex } from './split-text-by-regex'\n\n/**\n * The options for {@link defineMarkPasteRule}.\n *\n * @public\n */\nexport interface MarkPasteRuleOptions {\n  /**\n   * The regular expression to match against. It must have a `g` flag to match\n   * all instances of the mark.\n   */\n  regex: RegExp\n\n  /**\n   * The mark type to apply to the matched text.\n   */\n  type: string | MarkType\n\n  /**\n   * A function used to compute attributes to set on the mark created by this\n   * rule. When it returns `false`, the rule won't match. When it returns `null`\n   * or `undefined`, that is interpreted as an empty/default set of attributes.\n   * @default null\n   */\n  getAttrs?: (match: RegExpExecArray) => Attrs | null | undefined | false\n\n  /**\n   * Optional function to determine if a text node should be skipped.\n   * Default behavior: skip code nodes and nodes that already have the target mark.\n   */\n  shouldSkip?: (node: ProseMirrorNode) => boolean\n}\n\n/**\n * Defines a paste rule that applies marks based on regex patterns.\n *\n * @public\n */\nexport function defineMarkPasteRule(options: MarkPasteRuleOptions): PlainExtension {\n  return definePasteRule({\n    handler: ({ slice, view, plain }) => {\n      if (plain) {\n        return slice\n      }\n\n      const markType = getMarkType(view.state.schema, options.type)\n\n      return replaceMarkInSlice({\n        markType,\n        regex: options.regex,\n        getAttrs: options.getAttrs,\n        shouldSkip: options.shouldSkip,\n      }, slice)\n    },\n  })\n}\n\ninterface MarkPasteRuleHandlerOptions {\n  markType: MarkType\n  regex: RegExp\n  getAttrs?: (match: RegExpExecArray) => Attrs | null | undefined | false\n  shouldSkip?: (node: ProseMirrorNode) => boolean\n}\n\nfunction replaceMarkInSlice(options: MarkPasteRuleHandlerOptions, slice: Slice): Slice {\n  const newFragment = replaceMarkInFragment(options, slice.content)\n  if (!newFragment) {\n    return slice\n  }\n  return new Slice(newFragment, slice.openStart, slice.openEnd)\n}\n\nfunction replaceMarkInFragment(options: MarkPasteRuleHandlerOptions, fragment: Fragment): Fragment | undefined {\n  let changed = false\n  let children: ProseMirrorNode[] = []\n\n  for (const child of fragment.content) {\n    const newChild = replaceMarkInNode(options, child)\n    if (newChild) {\n      changed = true\n    }\n    children.push(newChild || child)\n  }\n\n  if (changed) {\n    return Fragment.from(children)\n  }\n\n  return\n}\n\nfunction replaceMarkInNode(options: MarkPasteRuleHandlerOptions, node: ProseMirrorNode): ProseMirrorNode | undefined {\n  if (node.type.spec.code) {\n    return\n  }\n  if (node.type.isInline) {\n    return\n  }\n  if (node.type.isTextblock) {\n    return replaceMarkInTextblockNode(options, node)\n  }\n\n  const newChildren = replaceMarkInFragment(options, node.content)\n  if (!newChildren) {\n    return\n  }\n  return node.copy(newChildren)\n}\n\nfunction replaceMarkInTextblockNode(options: MarkPasteRuleHandlerOptions, node: ProseMirrorNode): ProseMirrorNode | undefined {\n  const newChildren: ProseMirrorNode[] = []\n  let changed = false\n\n  for (const inlineNode of node.content.content) {\n    const newInlineNodes = replaceMarkInInlineNode(options, inlineNode)\n    if (newInlineNodes) {\n      changed = true\n      newChildren.push(...newInlineNodes)\n    } else {\n      newChildren.push(inlineNode)\n    }\n  }\n  if (changed) {\n    return node.copy(Fragment.from(newChildren))\n  }\n  return\n}\n\nfunction replaceMarkInInlineNode(options: MarkPasteRuleHandlerOptions, node: ProseMirrorNode): ProseMirrorNode[] | undefined {\n  const text = node.text\n  if (!text) {\n    return\n  }\n\n  const { markType, shouldSkip } = options\n\n  // Use custom skip logic if provided, otherwise use default\n  if (shouldSkip) {\n    if (shouldSkip(node)) {\n      return\n    }\n  } else {\n    // Default skip logic: skip if already has the target mark or has code mark\n    if (node.marks.some((mark) => mark.type === markType)) {\n      return\n    }\n    if (node.marks.some((mark) => mark.type.spec.code)) {\n      return\n    }\n  }\n\n  const chunks = splitTextByRegex(text, options.regex)\n  if (!chunks) {\n    return\n  }\n\n  const schema = node.type.schema\n  const nodes: ProseMirrorNode[] = []\n\n  for (const [text, match] of chunks) {\n    if (!text) {\n      continue\n    }\n    if (match) {\n      const attrs = options.getAttrs?.(match) ?? null\n      if (attrs !== false) {\n        const mark = markType.create(attrs)\n        nodes.push(schema.text(text, [...node.marks, mark]))\n      } else {\n        nodes.push(schema.text(text, node.marks))\n      }\n    } else {\n      nodes.push(schema.text(text, node.marks))\n    }\n  }\n\n  return nodes\n}\n"],"mappings":"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"}

package/dist/placeholder/style.css

@@ -6,3 +6,5 @@
   pointer-events: none;
 }
 
+
+/*# sourceMappingURL=style.css.map*/

package/dist/placeholder/style.css.map

@@ -0,0 +1 @@
+{"version":3,"file":"style.css","names":[],"sources":["../../src/placeholder/style.css"],"sourcesContent":[".prosekit-placeholder::before {\n  position: absolute;\n  height: 0;\n  content: attr(data-placeholder);\n  opacity: 30%;\n  pointer-events: none;\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA"}

package/dist/placeholder/style.js

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

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

@@ -102,4 +102,5 @@ declare class AutocompleteRule {
 //#region src/autocomplete/autocomplete.d.ts
 declare function defineAutocomplete(rule: AutocompleteRule): Extension;
 //#endregion
-export { AutocompleteRule, type AutocompleteRuleOptions, type CanMatchOptions, type CanMatchPredicate, type MatchHandler, type MatchHandlerOptions, defineAutocomplete };
+export { AutocompleteRule, type AutocompleteRuleOptions, type CanMatchOptions, type CanMatchPredicate, type MatchHandler, type MatchHandlerOptions, defineAutocomplete };
+//# sourceMappingURL=prosekit-extensions-autocomplete.d.ts.map

package/dist/prosekit-extensions-autocomplete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prosekit-extensions-autocomplete.d.ts","names":[],"sources":["../src/autocomplete/autocomplete-rule.ts","../src/autocomplete/autocomplete.ts"],"sourcesContent":[],"mappings":";;;;;;;AAOiB,UAAA,mBAAA,CAAmB;EAAA;;;EASZ,KAAA,EALf,WAKe;EA8BZ;AAKZ;AAUA;EAKiB,KAAA,EAlDR,eAkDQ;EAAuB;;;MAmB5B,EAAA,MAAA;;;AAeZ;EAA6B,EAAA,EAAA,MAAA;;;;;aAUN,EAAA,GAAA,GAAA,IAAA;EAAuB;;;;ACnG9C;EAAkC,WAAA,EAAA,GAAA,GAAA,IAAA;;;;;;KDmCtB,YAAA,aAAyB;;;;UAKpB,eAAA;;;;SAIR;;;;;KAMG,iBAAA,aAA8B;;;;UAKzB,uBAAA;;;;;;;;SAQR;;;;;WAME;;;;YAKC;;;;;;aAOC;;;;;;;cAQA,gBAAA;;kBAEK;;oBAEE;;qBAEC;;;WAEmB;;uBAEjB;;;;iBCnGP,kBAAA,OAAyB,mBAAmB"}

package/dist/prosekit-extensions-autocomplete.js

@@ -136,14 +136,6 @@ const autocompleteFacet = defineFacet({
 * @public
 */
 var AutocompleteRule = class {
-	/** @internal */
-	regex;
-	/** @internal */
-	onMatch;
-	/** @internal */
-	onLeave;
-	/** @internal */
-	canMatch;
 	constructor(options) {
 		this.regex = options.regex;
 		this.onMatch = options.onEnter;
@@ -153,4 +145,5 @@ var AutocompleteRule = class {
 };
 
 //#endregion
-export { AutocompleteRule, defineAutocomplete };
+export { AutocompleteRule, defineAutocomplete };
+//# sourceMappingURL=prosekit-extensions-autocomplete.js.map

package/dist/prosekit-extensions-autocomplete.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prosekit-extensions-autocomplete.js","names":["pluginKey: PluginKey<PredictionPluginState>","parentOffset: number","textBefore: string","rules: AutocompleteRule[]"],"sources":["../src/autocomplete/autocomplete-helpers.ts","../src/autocomplete/autocomplete-plugin.ts","../src/autocomplete/autocomplete.ts","../src/autocomplete/autocomplete-rule.ts"],"sourcesContent":["import type { ResolvedPos } from '@prosekit/pm/model'\nimport {\n  PluginKey,\n  type EditorState,\n  type Transaction,\n} from '@prosekit/pm/state'\n\nimport type { AutocompleteRule } from './autocomplete-rule'\n\nexport function defaultCanMatch({ state }: { state: EditorState }): boolean {\n  return state.selection.empty && !isInsideCode(state.selection.$from)\n}\n\nfunction isInsideCode($pos: ResolvedPos): boolean {\n  for (let d = $pos.depth; d > 0; d--) {\n    if ($pos.node(d).type.spec.code) {\n      return true\n    }\n  }\n\n  return $pos.marks().some((mark) => mark.type.name === 'code')\n}\n\n/**\n * @internal\n */\nexport interface PredictionPluginMatching {\n  rule: AutocompleteRule\n  from: number\n  to: number\n  match: RegExpExecArray\n}\n\n/**\n * @internal\n */\nexport interface PredictionPluginState {\n  /**\n   * The matching positions that should be ignored.\n   */\n  ignores: number[]\n\n  /**\n   * The current active matching.\n   */\n  matching: PredictionPluginMatching | null\n}\n\n/**\n * @internal\n */\ninterface PredictionTransactionMeta {\n  /**\n   * The from position that should be ignored.\n   */\n  ignore: number\n}\n\nexport function getPluginState(state: EditorState): PredictionPluginState | undefined {\n  return pluginKey.getState(state)\n}\n\nexport function getTrMeta(tr: Transaction): PredictionTransactionMeta | undefined {\n  return tr.getMeta(pluginKey) as PredictionTransactionMeta | undefined\n}\n\nexport function setTrMeta(\n  tr: Transaction,\n  meta: PredictionTransactionMeta,\n): Transaction {\n  return tr.setMeta(pluginKey, meta)\n}\n\nexport const pluginKey: PluginKey<PredictionPluginState> = new PluginKey<PredictionPluginState>('prosekit-autocomplete')\n","import { OBJECT_REPLACEMENT_CHARACTER } from '@prosekit/core'\nimport {\n  Plugin,\n  type EditorState,\n  type Transaction,\n} from '@prosekit/pm/state'\nimport {\n  Decoration,\n  DecorationSet,\n} from '@prosekit/pm/view'\n\nimport {\n  getPluginState,\n  getTrMeta,\n  pluginKey,\n  setTrMeta,\n  type PredictionPluginMatching,\n  type PredictionPluginState,\n} from './autocomplete-helpers'\nimport type { AutocompleteRule } from './autocomplete-rule'\n\nexport function createAutocompletePlugin({\n  getRules,\n}: {\n  getRules: () => AutocompleteRule[]\n}): Plugin {\n  return new Plugin<PredictionPluginState>({\n    key: pluginKey,\n\n    state: {\n      init: (): PredictionPluginState => {\n        return { ignores: [], matching: null }\n      },\n      apply: (\n        tr: Transaction,\n        prevValue: PredictionPluginState,\n        oldState: EditorState,\n        newState: EditorState,\n      ): PredictionPluginState => {\n        const meta = getTrMeta(tr)\n\n        // No changes\n        if (\n          !tr.docChanged\n          && oldState.selection.eq(newState.selection)\n          && !meta\n        ) {\n          return prevValue\n        }\n\n        // Receiving a meta means that we are ignoring a match\n        if (meta) {\n          let ignores = prevValue.ignores\n          if (!ignores.includes(meta.ignore)) {\n            ignores = [...ignores, meta.ignore]\n          }\n          return { matching: null, ignores }\n        }\n\n        // Calculate the new ignores\n        const ignoreSet = new Set(prevValue.ignores.map(pos => tr.mapping.map(pos)))\n\n        // Calculate the new matching\n        let matching = calcPluginStateMatching(newState, getRules())\n\n        // Check if the matching should be ignored\n        if (matching && ignoreSet.has(matching.from)) {\n          matching = null\n        }\n\n        // Return the new matching and ignores\n        return { matching, ignores: Array.from(ignoreSet) }\n      },\n    },\n\n    view: () => ({\n      update: (view, prevState) => {\n        const prevValue = getPluginState(prevState)\n        const currValue = getPluginState(view.state)\n\n        if (\n          prevValue?.matching\n          && prevValue.matching.rule !== currValue?.matching?.rule\n        ) {\n          // Deactivate the previous rule\n          prevValue.matching.rule.onLeave?.()\n        }\n\n        if (\n          currValue?.matching\n          && !currValue.ignores.includes(currValue.matching.from)\n        ) {\n          // Activate the current rule\n\n          const { from, to, match, rule } = currValue.matching\n\n          const textContent = view.state.doc.textBetween(\n            from,\n            to,\n            null,\n            OBJECT_REPLACEMENT_CHARACTER,\n          )\n\n          const deleteMatch = () => {\n            if (\n              view.state.doc.textBetween(\n                from,\n                to,\n                null,\n                OBJECT_REPLACEMENT_CHARACTER,\n              ) === textContent\n            ) {\n              view.dispatch(view.state.tr.delete(from, to))\n            }\n          }\n\n          const ignoreMatch = () => {\n            view.dispatch(\n              setTrMeta(view.state.tr, { ignore: from }),\n            )\n          }\n\n          rule.onMatch({\n            state: view.state,\n            match,\n            from,\n            to,\n            deleteMatch,\n            ignoreMatch,\n          })\n        }\n      },\n    }),\n\n    props: {\n      decorations: (state: EditorState) => {\n        const pluginState = getPluginState(state)\n        if (pluginState?.matching) {\n          const { from, to } = pluginState.matching\n          const deco = Decoration.inline(from, to, {\n            class: 'prosemirror-prediction-match',\n          })\n          return DecorationSet.create(state.doc, [deco])\n        }\n        return null\n      },\n    },\n  })\n}\n\nconst MAX_MATCH = 200\n\nfunction calcPluginStateMatching(\n  state: EditorState,\n  rules: AutocompleteRule[],\n): PredictionPluginMatching | null {\n  const $pos = state.selection.$from\n\n  const parentOffset: number = $pos.parentOffset\n\n  const textBefore: string = $pos.parent.textBetween(\n    Math.max(0, parentOffset - MAX_MATCH),\n    parentOffset,\n    null,\n    OBJECT_REPLACEMENT_CHARACTER,\n  )\n\n  for (const rule of rules) {\n    if (!rule.canMatch({ state })) {\n      continue\n    }\n\n    rule.regex.lastIndex = 0\n    const match = rule.regex.exec(textBefore)\n    if (!match) {\n      continue\n    }\n\n    const to = $pos.pos\n    const from = to - textBefore.length + match.index\n\n    return { rule, match, from, to }\n  }\n\n  return null\n}\n","import {\n  defineFacet,\n  defineFacetPayload,\n  pluginFacet,\n  type Extension,\n  type PluginPayload,\n} from '@prosekit/core'\n\nimport { createAutocompletePlugin } from './autocomplete-plugin'\nimport type { AutocompleteRule } from './autocomplete-rule'\n\nexport function defineAutocomplete(rule: AutocompleteRule): Extension {\n  return defineFacetPayload(autocompleteFacet, [rule])\n}\n\nconst autocompleteFacet = defineFacet<AutocompleteRule, PluginPayload>({\n  reduce: () => {\n    let rules: AutocompleteRule[] = []\n    const getRules = () => rules\n    const plugin = createAutocompletePlugin({ getRules })\n\n    return function reducer(inputs) {\n      rules = inputs\n      return plugin\n    }\n  },\n  parent: pluginFacet,\n  singleton: true,\n})\n","import type { EditorState } from '@prosekit/pm/state'\n\nimport { defaultCanMatch } from './autocomplete-helpers'\n\n/**\n * Options for the {@link MatchHandler} callback.\n */\nexport interface MatchHandlerOptions {\n  /**\n   * The editor state.\n   */\n  state: EditorState\n\n  /**\n   * The result of `RegExp.exec`.\n   */\n  match: RegExpExecArray\n\n  /**\n   * The start position of the matched text.\n   */\n  from: number\n\n  /**\n   * The end position of the matched text.\n   */\n  to: number\n\n  /**\n   * Call this function to ignore the match. You probably want to call this\n   * function when the user presses the `Escape` key.\n   */\n  ignoreMatch: () => void\n\n  /**\n   * Call this function to delete the matched text. For example, in a slash\n   * menu, you might want to delete the matched text first then do something\n   * else when the user presses the `Enter` key.\n   */\n  deleteMatch: () => void\n}\n\n/**\n * A callback that is called when the rule starts to match, and also on\n * subsequent updates while the rule continues to match.\n */\nexport type MatchHandler = (options: MatchHandlerOptions) => void\n\n/**\n * Options for the {@link CanMatchPredicate} callback.\n */\nexport interface CanMatchOptions {\n  /**\n   * The editor state.\n   */\n  state: EditorState\n}\n\n/**\n * A predicate to determine if the rule can be applied in the current editor state.\n */\nexport type CanMatchPredicate = (options: CanMatchOptions) => boolean\n\n/**\n * Options for creating an {@link AutocompleteRule}\n */\nexport interface AutocompleteRuleOptions {\n  /**\n   * The regular expression to match against the text before the cursor. The\n   * last match before the cursor is used.\n   *\n   * For a slash menu, you might use `/(?<!\\S)\\/(|\\S.*)$/u`.\n   * For a mention, you might use `/@\\w*$/`\n   */\n  regex: RegExp\n\n  /**\n   * A callback that is called when the rule starts to match, and also on\n   * subsequent updates while the rule continues to match.\n   */\n  onEnter: MatchHandler\n\n  /**\n   * A callback that is called when the rule stops matching.\n   */\n  onLeave?: VoidFunction\n\n  /**\n   * A predicate to determine if the rule can be applied in the current editor\n   * state. If not provided, it defaults to only allowing matches in empty\n   * selections that are not inside a code block or code mark.\n   */\n  canMatch?: CanMatchPredicate\n}\n\n/**\n * An autocomplete rule that can be used to create an autocomplete extension.\n *\n * @public\n */\nexport class AutocompleteRule {\n  /** @internal */\n  readonly regex: RegExp\n  /** @internal */\n  readonly onMatch: MatchHandler\n  /** @internal */\n  readonly onLeave?: VoidFunction\n  /** @internal */\n  readonly canMatch: (options: { state: EditorState }) => boolean\n\n  constructor(options: AutocompleteRuleOptions) {\n    this.regex = options.regex\n    this.onMatch = options.onEnter\n    this.onLeave = options.onLeave\n    this.canMatch = options.canMatch ?? defaultCanMatch\n  }\n}\n"],"mappings":"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"}

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

@@ -45,4 +45,5 @@ declare function defineBlockquoteInputRule(): PlainExtension;
  */
 declare function defineBlockquoteKeymap(): PlainExtension;
 //#endregion
-export { type BlockquoteCommandsExtension, type BlockquoteExtension, type BlockquoteSpecExtension, defineBlockquote, defineBlockquoteCommands, defineBlockquoteInputRule, defineBlockquoteKeymap, defineBlockquoteSpec };
+export { type BlockquoteCommandsExtension, type BlockquoteExtension, type BlockquoteSpecExtension, defineBlockquote, defineBlockquoteCommands, defineBlockquoteInputRule, defineBlockquoteKeymap, defineBlockquoteSpec };
+//# sourceMappingURL=prosekit-extensions-blockquote.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prosekit-extensions-blockquote.d.ts","names":[],"sources":["../src/blockquote/blockquote-commands.ts","../src/blockquote/blockquote-spec.ts","../src/blockquote/blockquote.ts","../src/blockquote/blockquote-input-rule.ts","../src/blockquote/blockquote-keymap.ts"],"sourcesContent":[],"mappings":";;;;KAQY,2BAAA,GAA8B;;;IAA9B,gBAAA,EAAA,EAAA;IAWI,gBAAA,EAAA,EAAA;;;;ACbhB;;AAEgB,iBDWA,wBAAA,CAAA,CCXA,EDW4B,2BCX5B;;;KAFJ,uBAAA,GAA0B;;IDE1B,UAAA,ECAI,KDAJ;EAWI,CAAA;;iBCPA,oBAAA,CAAA,GAAwB;;;;ADJxC;AAWA;KEAY,mBAAA,GAAsB,OAC/B,yBAAyB,4BDd5B,CAAA;;;;AAA+C,iBCoB/B,gBAAA,CAAA,CDpB+B,ECoBX,mBDpBW;;;;;;ADE/C;AAWgB,iBGXA,yBAAA,CAAA,CHW4B,EGXC,cHWD;;;;;;AAXhC,iBIiBI,sBAAA,CAAA,CJjB0B,EIiBA,cJjBS"}

package/dist/prosekit-extensions-blockquote.js

@@ -1,4 +1,4 @@
-import { defineWrappingInputRule } from "./input-rule-Gji4N7Oe.js";
+import { defineWrappingInputRule } from "./input-rule-B17tpW4m.js";
 import { defineCommands, defineKeymap, defineNodeSpec, insertNode, isAtBlockStart, toggleWrap, union, wrap } from "@prosekit/core";
 import { joinBackward } from "@prosekit/pm/commands";
 
@@ -40,8 +40,7 @@ function toggleBlockquoteKeybinding() {
 }
 function backspaceUnsetBlockquote() {
 	return (state, dispatch, view) => {
-		const $pos = isAtBlockStart(state, view);
-		if ($pos?.node(-1).type.name === "blockquote") return joinBackward(state, dispatch, view);
+		if (isAtBlockStart(state, view)?.node(-1).type.name === "blockquote") return joinBackward(state, dispatch, view);
 		return false;
 	};
 }
@@ -80,4 +79,5 @@ function defineBlockquote() {
 }
 
 //#endregion
-export { defineBlockquote, defineBlockquoteCommands, defineBlockquoteInputRule, defineBlockquoteKeymap, defineBlockquoteSpec };
+export { defineBlockquote, defineBlockquoteCommands, defineBlockquoteInputRule, defineBlockquoteKeymap, defineBlockquoteSpec };
+//# sourceMappingURL=prosekit-extensions-blockquote.js.map

package/dist/prosekit-extensions-blockquote.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prosekit-extensions-blockquote.js","names":[],"sources":["../src/blockquote/blockquote-commands.ts","../src/blockquote/blockquote-input-rule.ts","../src/blockquote/blockquote-keymap.ts","../src/blockquote/blockquote-spec.ts","../src/blockquote/blockquote.ts"],"sourcesContent":["import {\n  defineCommands,\n  insertNode,\n  toggleWrap,\n  wrap,\n  type Extension,\n} from '@prosekit/core'\n\nexport type BlockquoteCommandsExtension = Extension<{\n  Commands: {\n    setBlockquote: []\n    insertBlockquote: []\n    toggleBlockquote: []\n  }\n}>\n\n/**\n * @internal\n */\nexport function defineBlockquoteCommands(): BlockquoteCommandsExtension {\n  return defineCommands({\n    setBlockquote: () => {\n      return wrap({ type: 'blockquote' })\n    },\n    insertBlockquote: () => {\n      return insertNode({ type: 'blockquote' })\n    },\n    toggleBlockquote: () => {\n      return toggleWrap({ type: 'blockquote' })\n    },\n  })\n}\n","import type { PlainExtension } from '@prosekit/core'\n\nimport { defineWrappingInputRule } from '../input-rule'\n\n/**\n * Wraps the text block in a blockquote when `>` is typed at the start of a new\n * line followed by a space.\n */\nexport function defineBlockquoteInputRule(): PlainExtension {\n  return defineWrappingInputRule({\n    regex: /^>\\s/,\n    type: 'blockquote',\n  })\n}\n","import {\n  defineKeymap,\n  isAtBlockStart,\n  toggleWrap,\n  type PlainExtension,\n} from '@prosekit/core'\nimport { joinBackward } from '@prosekit/pm/commands'\nimport type { Command } from '@prosekit/pm/state'\n\nfunction toggleBlockquoteKeybinding(): Command {\n  return toggleWrap({ type: 'blockquote' })\n}\n\nfunction backspaceUnsetBlockquote(): Command {\n  return (state, dispatch, view) => {\n    const $pos = isAtBlockStart(state, view)\n    if ($pos?.node(-1).type.name === 'blockquote') {\n      return joinBackward(state, dispatch, view)\n    }\n    return false\n  }\n}\n/**\n * @internal\n */\nexport function defineBlockquoteKeymap(): PlainExtension {\n  return defineKeymap({\n    'mod-shift-b': toggleBlockquoteKeybinding(),\n    'Backspace': backspaceUnsetBlockquote(),\n  })\n}\n","import {\n  defineNodeSpec,\n  type Extension,\n} from '@prosekit/core'\nimport type { Attrs } from '@prosekit/pm/model'\n\nexport type BlockquoteSpecExtension = Extension<{\n  Nodes: {\n    blockquote: Attrs\n  }\n}>\n\nexport function defineBlockquoteSpec(): BlockquoteSpecExtension {\n  return defineNodeSpec({\n    name: 'blockquote',\n    content: 'block+',\n    group: 'block',\n    defining: true,\n    parseDOM: [{ tag: 'blockquote' }],\n    toDOM() {\n      return ['blockquote', 0]\n    },\n  })\n}\n","import {\n  union,\n  type Union,\n} from '@prosekit/core'\n\nimport {\n  defineBlockquoteCommands,\n  type BlockquoteCommandsExtension,\n} from './blockquote-commands'\nimport { defineBlockquoteInputRule } from './blockquote-input-rule'\nimport { defineBlockquoteKeymap } from './blockquote-keymap'\nimport {\n  defineBlockquoteSpec,\n  type BlockquoteSpecExtension,\n} from './blockquote-spec'\n\n/**\n * @internal\n */\nexport type BlockquoteExtension = Union<\n  [BlockquoteSpecExtension, BlockquoteCommandsExtension]\n>\n\n/**\n * @public\n */\nexport function defineBlockquote(): BlockquoteExtension {\n  return union(\n    defineBlockquoteSpec(),\n    defineBlockquoteInputRule(),\n    defineBlockquoteCommands(),\n    defineBlockquoteKeymap(),\n  )\n}\n"],"mappings":";;;;;;;;AAmBA,SAAgB,2BAAwD;AACtE,QAAO,eAAe;EACpB,qBAAqB;AACnB,UAAO,KAAK,EAAE,MAAM,cAAc,CAAC;;EAErC,wBAAwB;AACtB,UAAO,WAAW,EAAE,MAAM,cAAc,CAAC;;EAE3C,wBAAwB;AACtB,UAAO,WAAW,EAAE,MAAM,cAAc,CAAC;;EAE5C,CAAC;;;;;;;;;ACtBJ,SAAgB,4BAA4C;AAC1D,QAAO,wBAAwB;EAC7B,OAAO;EACP,MAAM;EACP,CAAC;;;;;ACHJ,SAAS,6BAAsC;AAC7C,QAAO,WAAW,EAAE,MAAM,cAAc,CAAC;;AAG3C,SAAS,2BAAoC;AAC3C,SAAQ,OAAO,UAAU,SAAS;AAEhC,MADa,eAAe,OAAO,KAAK,EAC9B,KAAK,GAAG,CAAC,KAAK,SAAS,aAC/B,QAAO,aAAa,OAAO,UAAU,KAAK;AAE5C,SAAO;;;;;;AAMX,SAAgB,yBAAyC;AACvD,QAAO,aAAa;EAClB,eAAe,4BAA4B;EAC3C,aAAa,0BAA0B;EACxC,CAAC;;;;;ACjBJ,SAAgB,uBAAgD;AAC9D,QAAO,eAAe;EACpB,MAAM;EACN,SAAS;EACT,OAAO;EACP,UAAU;EACV,UAAU,CAAC,EAAE,KAAK,cAAc,CAAC;EACjC,QAAQ;AACN,UAAO,CAAC,cAAc,EAAE;;EAE3B,CAAC;;;;;;;;ACIJ,SAAgB,mBAAwC;AACtD,QAAO,MACL,sBAAsB,EACtB,2BAA2B,EAC3B,0BAA0B,EAC1B,wBAAwB,CACzB"}

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

@@ -51,4 +51,5 @@ declare function defineBoldInputRule(): PlainExtension;
  */
 declare function defineBoldKeymap(): PlainExtension;
 //#endregion
-export { type BoldCommandsExtension, type BoldExtension, type BoldSpecExtension, defineBold, defineBoldCommands, defineBoldInputRule, defineBoldKeymap, defineBoldSpec };
+export { type BoldCommandsExtension, type BoldExtension, type BoldSpecExtension, defineBold, defineBoldCommands, defineBoldInputRule, defineBoldKeymap, defineBoldSpec };
+//# sourceMappingURL=prosekit-extensions-bold.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prosekit-extensions-bold.d.ts","names":[],"sources":["../src/bold/bold-commands.ts","../src/bold/bold-spec.ts","../src/bold/bold.ts","../src/bold/bold-input-rule.ts","../src/bold/bold-keymap.ts"],"sourcesContent":[],"mappings":";;;;;;;AASY,KAAA,qBAAA,GAAwB,SAAA,CAAA;EASpB,QAAA,EAAA;;;;ACThB;;;AAAgC,iBDShB,kBAAA,CAAA,CCTgB,EDSM,qBCTN;;;;;ADAhC;AASgB,KCTJ,iBAAA,GAAoB,SDSM,CAAA;;UCP5B;;AAFV,CAAA,CAAA;;;;AAAyC,iBASzB,cAAA,CAAA,CATyB,EASP,iBATO;;;;ADAzC;AASA;KECY,aAAA,GAAgB,OAAO,mBAAmB;;;ADVtD;AAA6B,iBCeb,UAAA,CAAA,CDfa,ECeC,aDfD;;;;;;ADAjB,iBGCI,mBAAA,CAAA,CHDoB,EGCG,cHDM;;;;;;AAAjC,iBIAI,gBAAA,CAAA,CJAoB,EIAA,cJAS"}

package/dist/prosekit-extensions-bold.js

@@ -1,4 +1,4 @@
-import { defineMarkInputRule } from "./input-rule-Gji4N7Oe.js";
+import { defineMarkInputRule } from "./input-rule-B17tpW4m.js";
 import { canUseRegexLookbehind, defineCommands, defineKeymap, defineMarkSpec, toggleMark, union } from "@prosekit/core";
 
 //#region src/bold/bold-commands.ts
@@ -73,4 +73,5 @@ function defineBold() {
 }
 
 //#endregion
-export { defineBold, defineBoldCommands, defineBoldInputRule, defineBoldKeymap, defineBoldSpec };
+export { defineBold, defineBoldCommands, defineBoldInputRule, defineBoldKeymap, defineBoldSpec };
+//# sourceMappingURL=prosekit-extensions-bold.js.map

package/dist/prosekit-extensions-bold.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prosekit-extensions-bold.js","names":[],"sources":["../src/bold/bold-commands.ts","../src/bold/bold-input-rule.ts","../src/bold/bold-keymap.ts","../src/bold/bold-spec.ts","../src/bold/bold.ts"],"sourcesContent":["import {\n  defineCommands,\n  toggleMark,\n  type Extension,\n} from '@prosekit/core'\n\n/**\n * @internal\n */\nexport type BoldCommandsExtension = Extension<{\n  Commands: {\n    toggleBold: []\n  }\n}>\n\n/**\n * @internal\n */\nexport function defineBoldCommands(): BoldCommandsExtension {\n  return defineCommands({\n    toggleBold: () => toggleMark({ type: 'bold' }),\n  })\n}\n","import {\n  canUseRegexLookbehind,\n  type PlainExtension,\n} from '@prosekit/core'\n\nimport { defineMarkInputRule } from '../input-rule'\n\n/**\n * @internal\n */\nexport function defineBoldInputRule(): PlainExtension {\n  return defineMarkInputRule({\n    regex: canUseRegexLookbehind()\n      ? /(?<=\\s|^)\\*\\*([^\\s*]|[^\\s*][^*]*[^\\s*])\\*\\*$/\n      : /\\*\\*([^\\s*]|[^\\s*][^*]*[^\\s*])\\*\\*$/,\n    type: 'bold',\n  })\n}\n","import {\n  defineKeymap,\n  toggleMark,\n  type PlainExtension,\n} from '@prosekit/core'\n\n/**\n * @internal\n */\nexport function defineBoldKeymap(): PlainExtension {\n  return defineKeymap({\n    'Mod-b': toggleMark({ type: 'bold' }),\n  })\n}\n","import {\n  defineMarkSpec,\n  type Extension,\n} from '@prosekit/core'\nimport type { Attrs } from '@prosekit/pm/model'\n\n/**\n * @internal\n */\nexport type BoldSpecExtension = Extension<{\n  Marks: {\n    bold: Attrs\n  }\n}>\n\n/**\n * @internal\n */\nexport function defineBoldSpec(): BoldSpecExtension {\n  return defineMarkSpec({\n    name: 'bold',\n    parseDOM: [\n      { tag: 'strong' },\n      // This works around a Google Docs misbehavior where\n      // pasted content will be inexplicably wrapped in `<b>`\n      // tags with a font-weight normal.\n      {\n        tag: 'b',\n        getAttrs: (node: string | HTMLElement): null | false => {\n          return (\n            typeof node !== 'string'\n            && node.style.fontWeight !== 'normal'\n            && null\n          )\n        },\n      },\n      { style: 'font-weight=400', clearMark: (m) => m.type.name == 'strong' },\n      {\n        style: 'font-weight',\n        getAttrs: (value: string | HTMLElement): null | false => {\n          return (\n            typeof value === 'string'\n            && /^(bold(er)?|[5-9]\\d{2,})$/.test(value)\n            && null\n          )\n        },\n      },\n    ],\n    toDOM() {\n      return ['strong', 0]\n    },\n  })\n}\n","import {\n  union,\n  type Union,\n} from '@prosekit/core'\n\nimport {\n  defineBoldCommands,\n  type BoldCommandsExtension,\n} from './bold-commands'\nimport { defineBoldInputRule } from './bold-input-rule'\nimport { defineBoldKeymap } from './bold-keymap'\nimport {\n  defineBoldSpec,\n  type BoldSpecExtension,\n} from './bold-spec'\n\n/**\n * @internal\n */\nexport type BoldExtension = Union<[BoldSpecExtension, BoldCommandsExtension]>\n\n/**\n * @public\n */\nexport function defineBold(): BoldExtension {\n  return union(\n    defineBoldSpec(),\n    defineBoldCommands(),\n    defineBoldKeymap(),\n    defineBoldInputRule(),\n  )\n}\n"],"mappings":";;;;;;;AAkBA,SAAgB,qBAA4C;AAC1D,QAAO,eAAe,EACpB,kBAAkB,WAAW,EAAE,MAAM,QAAQ,CAAC,EAC/C,CAAC;;;;;;;;ACXJ,SAAgB,sBAAsC;AACpD,QAAO,oBAAoB;EACzB,OAAO,uBAAuB,GAC1B,iDACA;EACJ,MAAM;EACP,CAAC;;;;;;;;ACPJ,SAAgB,mBAAmC;AACjD,QAAO,aAAa,EAClB,SAAS,WAAW,EAAE,MAAM,QAAQ,CAAC,EACtC,CAAC;;;;;;;;ACMJ,SAAgB,iBAAoC;AAClD,QAAO,eAAe;EACpB,MAAM;EACN,UAAU;GACR,EAAE,KAAK,UAAU;GAIjB;IACE,KAAK;IACL,WAAW,SAA6C;AACtD,YACE,OAAO,SAAS,YACb,KAAK,MAAM,eAAe,YAC1B;;IAGR;GACD;IAAE,OAAO;IAAmB,YAAY,MAAM,EAAE,KAAK,QAAQ;IAAU;GACvE;IACE,OAAO;IACP,WAAW,UAA8C;AACvD,YACE,OAAO,UAAU,YACd,4BAA4B,KAAK,MAAM,IACvC;;IAGR;GACF;EACD,QAAQ;AACN,UAAO,CAAC,UAAU,EAAE;;EAEvB,CAAC;;;;;;;;AC3BJ,SAAgB,aAA4B;AAC1C,QAAO,MACL,gBAAgB,EAChB,oBAAoB,EACpB,kBAAkB,EAClB,qBAAqB,CACtB"}

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

@@ -156,4 +156,5 @@ declare function defineCodeBlockShiki({
   ...rest
 }?: CodeBlockShikiOptions): Extension;
 //#endregion
-export { type CodeBlockAttrs, type CodeBlockCommandsExtension, type CodeBlockExtension, type CodeBlockHighlightOptions, type CodeBlockSpecExtension, type HighlightParser, type ShikiBundledLanguage, type ShikiBundledLanguageInfo, type ShikiBundledTheme, type ShikiBundledThemeInfo, defineCodeBlock, defineCodeBlockCommands, defineCodeBlockEnterRule, defineCodeBlockHighlight, defineCodeBlockInputRule, defineCodeBlockKeymap, defineCodeBlockShiki, defineCodeBlockSpec, shikiBundledLanguagesInfo, shikiBundledThemesInfo };
+export { type CodeBlockAttrs, type CodeBlockCommandsExtension, type CodeBlockExtension, type CodeBlockHighlightOptions, type CodeBlockSpecExtension, type HighlightParser, type ShikiBundledLanguage, type ShikiBundledLanguageInfo, type ShikiBundledTheme, type ShikiBundledThemeInfo, defineCodeBlock, defineCodeBlockCommands, defineCodeBlockEnterRule, defineCodeBlockHighlight, defineCodeBlockInputRule, defineCodeBlockKeymap, defineCodeBlockShiki, defineCodeBlockSpec, shikiBundledLanguagesInfo, shikiBundledThemesInfo };
+//# sourceMappingURL=prosekit-extensions-code-block.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prosekit-extensions-code-block.d.ts","names":[],"sources":["../src/code-block/code-block-types.ts","../src/code-block/code-block-commands.ts","../src/code-block/code-block-spec.ts","../src/code-block/code-block.ts","../src/code-block/code-block-highlight.ts","../src/code-block/code-block-input-rule.ts","../src/code-block/code-block-keymap.ts","../src/code-block/code-block-shiki.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;UAKiB,cAAA;EAAA,QAAA,EAAA,MAAA;;;;;;;KCSL,0BAAA,GAA6B;EDTxB,QAAA,EAAA;2BCWU;8BACG;8BACA;IAJlB,iBAAA,EAAA,CAAA,KAA0B,EAKP,cALO,CAAA;EAAA,CAAA;;;;;;;AActB,iBAAA,uBAAA,CAAA,CAA2B,EAAA,0BAA0B;;;;;;KClBzD,sBAAA,GAAyB;EFLpB,KAAA,EAAA;eEOF;;;ADEf;;;;;AAK+B,iBCEf,mBAAA,CAAA,CDFe,ECEQ,sBDFR;;;;;;ADdd,KGiBL,kBAAA,GAAqB,KHjBF,CAAA,CGkB5B,wBAAwB;AFT3B;;;;;;;;AAcA;;;iBESgB,eAAA,CAAA,GAAmB;;;;;;;AHhCnC;KISY,eAAA,GAAkB;;;AHA9B;AAAsC,KGK1B,yBAAA,GHL0B;QAEX,EGIjB,eHJiB;;;;;;AAY3B;;;;AClBA;;AAEe,iBEqBC,wBAAA,CFrBD;EAAA;AAAA,CAAA,EEuBZ,yBFvBY,CAAA,EEuBgB,SFvBhB;;;;;;;;AFPE,iBKOD,wBAAA,CAAA,CLPe,EKOa,cLPb;;;;ACS/B;;AAE2B,iBISX,wBAAA,CAAA,CJTW,EISiB,cJTjB;;;;;;iBKHX,qBAAA,CAAA,GAAyB;;;;;ANRzC;;;UOWiB,qBAAA,SAA8B,KAAK;ENFxC;;;;;;QAA6B,CAAA,EMS9B,iBNT8B,EAAA;EAAS;AAclD;;;;EClBY,KAAA,CAAA,EAAA,CKoBD,oBLpBuB,GKoBA,eLpBA,CAAA,EAAA;EAAA;;;EAAY,MAAA,CAAA,EKyBnC,uBLzBmC,CAAA,QAAA,CAAA;AAW9C;;;;ACCA;;;;;;AAeA;;;iBIagB,oBAAA;;;;IAIb,wBAA6B"}

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

@@ -1,4 +1,4 @@
-import { defineTextBlockInputRule } from "./input-rule-Gji4N7Oe.js";
+import { defineTextBlockInputRule } from "./input-rule-B17tpW4m.js";
 import { defineTextBlockEnterRule } from "./enter-rule-RdhEA900.js";
 import { defaultBlockAt, defineCommands, defineKeymap, defineNodeSpec, definePlugin, insertNode, setBlockType, setNodeAttrs, toggleNode, union } from "@prosekit/core";
 import { TextSelection } from "@prosekit/pm/state";
@@ -131,8 +131,7 @@ function defineCodeBlockSpec() {
 			tag: "pre",
 			preserveWhitespace: "full",
 			getAttrs: (node) => {
-				const language = extractLanguageFromElement(node) || extractLanguageFromElement(node.querySelector("code"));
-				return { language };
+				return { language: extractLanguageFromElement(node) || extractLanguageFromElement(node.querySelector("code")) };
 			}
 		}],
 		toDOM(node) {
@@ -153,8 +152,7 @@ function extractLanguageFromElement(element) {
 	if (!element) return "";
 	const attr = element.getAttribute("data-language");
 	if (attr) return attr;
-	const className = element.className;
-	const match = className.match(/language-(\w+)/);
+	const match = element.className.match(/language-(\w+)/);
 	if (match) return match[1];
 	return "";
 }
@@ -247,4 +245,5 @@ function defineCodeBlockShiki({ themes = ["one-dark-pro"], langs = ["text"],...r
 }
 
 //#endregion
-export { defineCodeBlock, defineCodeBlockCommands, defineCodeBlockEnterRule, defineCodeBlockHighlight, defineCodeBlockInputRule, defineCodeBlockKeymap, defineCodeBlockShiki, defineCodeBlockSpec, shikiBundledLanguagesInfo, shikiBundledThemesInfo };
+export { defineCodeBlock, defineCodeBlockCommands, defineCodeBlockEnterRule, defineCodeBlockHighlight, defineCodeBlockInputRule, defineCodeBlockKeymap, defineCodeBlockShiki, defineCodeBlockSpec, shikiBundledLanguagesInfo, shikiBundledThemesInfo };
+//# sourceMappingURL=prosekit-extensions-code-block.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prosekit-extensions-code-block.js","names":["existCodeBlock: Command","loaded: ((options: HighlighterOptions) => HighlighterResult) | undefined","createOrGetHighlighter","parser: Parser | undefined"],"sources":["../src/code-block/code-block-commands.ts","../src/code-block/code-block-input-rule.ts","../src/code-block/code-block-keymap.ts","../src/code-block/code-block-spec.ts","../src/code-block/code-block.ts","../src/code-block/code-block-highlight.ts","../src/code-block/shiki-highlighter.ts","../src/code-block/shiki-parser.ts","../src/code-block/code-block-shiki.ts"],"sourcesContent":["import {\n  defineCommands,\n  insertNode,\n  setBlockType,\n  setNodeAttrs,\n  toggleNode,\n  type Extension,\n} from '@prosekit/core'\n\nimport type { CodeBlockAttrs } from './code-block-types'\n\n/**\n * @internal\n */\nexport type CodeBlockCommandsExtension = Extension<{\n  Commands: {\n    setCodeBlock: [attrs?: CodeBlockAttrs]\n    insertCodeBlock: [attrs?: CodeBlockAttrs]\n    toggleCodeBlock: [attrs?: CodeBlockAttrs]\n    setCodeBlockAttrs: [attrs: CodeBlockAttrs]\n  }\n}>\n\n/**\n * Adds commands for working with `codeBlock` nodes.\n *\n * @public\n */\nexport function defineCodeBlockCommands(): CodeBlockCommandsExtension {\n  return defineCommands({\n    setCodeBlock: (attrs?: CodeBlockAttrs) => {\n      return setBlockType({ type: 'codeBlock', attrs })\n    },\n    insertCodeBlock: (attrs?: CodeBlockAttrs) => {\n      return insertNode({ type: 'codeBlock', attrs })\n    },\n    toggleCodeBlock: (attrs?: CodeBlockAttrs) => {\n      return toggleNode({ type: 'codeBlock', attrs })\n    },\n    setCodeBlockAttrs: (attrs: CodeBlockAttrs) => {\n      return setNodeAttrs({ type: 'codeBlock', attrs })\n    },\n  })\n}\n","import type { PlainExtension } from '@prosekit/core'\n\nimport { defineTextBlockEnterRule } from '../enter-rule'\nimport { defineTextBlockInputRule } from '../input-rule'\n\nimport type { CodeBlockAttrs } from './code-block-types'\n\n/**\n * Adds input rules for `codeBlock` nodes.\n *\n * @public\n */\nexport function defineCodeBlockInputRule(): PlainExtension {\n  return defineTextBlockInputRule({\n    regex: /^```(\\S*)\\s$/,\n    type: 'codeBlock',\n    attrs: getAttrs,\n  })\n}\n\n/**\n * Adds enter rules for `codeBlock` nodes.\n *\n * @public\n */\nexport function defineCodeBlockEnterRule(): PlainExtension {\n  return defineTextBlockEnterRule({\n    regex: /^```(\\S*)$/,\n    type: 'codeBlock',\n    attrs: getAttrs,\n  })\n}\n\nfunction getAttrs(match: RegExpMatchArray): CodeBlockAttrs {\n  return { language: match[1] || '' }\n}\n","import {\n  defaultBlockAt,\n  defineKeymap,\n  type PlainExtension,\n} from '@prosekit/core'\nimport {\n  TextSelection,\n  type Command,\n} from '@prosekit/pm/state'\n\n/**\n * Defines the keymap for code blocks.\n */\nexport function defineCodeBlockKeymap(): PlainExtension {\n  return defineKeymap({\n    Enter: existCodeBlock,\n  })\n}\n\n/**\n * Exit a code block and insert a default block below if the cursor is at the\n * end of the code block and the code block is ended with two new lines.\n */\nconst existCodeBlock: Command = (state, dispatch) => {\n  if (!state.selection.empty) {\n    return false\n  }\n\n  const { $head } = state.selection\n  const parent = $head.parent\n  if (\n    parent.isTextblock\n    && parent.type.spec.code\n    && $head.parentOffset === parent.content.size\n    && parent.textContent.endsWith('\\n\\n')\n  ) {\n    const grandParent = $head.node(-1)\n    const insertIndex = $head.indexAfter(-1)\n    const type = defaultBlockAt(grandParent.contentMatchAt(insertIndex))\n\n    if (!type || !grandParent.canReplaceWith(insertIndex, insertIndex, type)) {\n      return false\n    }\n\n    if (dispatch) {\n      const { tr } = state\n      tr.delete($head.pos - 2, $head.pos)\n      const pos = tr.selection.$head.after()\n      const node = type.createAndFill()\n      if (node) {\n        tr.replaceWith(pos, pos, node)\n        tr.setSelection(TextSelection.near(tr.doc.resolve(pos), 1))\n        dispatch(tr.scrollIntoView())\n      }\n    }\n\n    return true\n  }\n\n  return false\n}\n","import {\n  defineNodeSpec,\n  type Extension,\n} from '@prosekit/core'\n\nimport type { CodeBlockAttrs } from './code-block-types'\n\n/**\n * @internal\n */\nexport type CodeBlockSpecExtension = Extension<{\n  Nodes: {\n    codeBlock: CodeBlockAttrs\n  }\n}>\n\n/**\n * Defines the `codeBlock` node spec.\n *\n * @public\n */\nexport function defineCodeBlockSpec(): CodeBlockSpecExtension {\n  return defineNodeSpec({\n    name: 'codeBlock',\n    content: 'text*',\n    group: 'block',\n    code: true,\n    defining: true,\n    marks: '',\n    attrs: { language: { default: '', validate: 'string' } },\n    parseDOM: [\n      {\n        tag: 'pre',\n        preserveWhitespace: 'full',\n        getAttrs: (node): CodeBlockAttrs => {\n          const language = extractLanguageFromElement(node)\n            || extractLanguageFromElement(node.querySelector('code'))\n          return { language }\n        },\n      },\n    ],\n    toDOM(node) {\n      const { language } = node.attrs as CodeBlockAttrs\n      return [\n        'pre',\n        { 'data-language': language || undefined },\n        // `class: language-${language}` is used by remark-rehype to highlight the code block\n        ['code', { class: language ? `language-${language}` : undefined }, 0],\n      ]\n    },\n  })\n}\n\nfunction extractLanguageFromElement(element: HTMLElement | null | undefined): string {\n  if (!element) {\n    return ''\n  }\n\n  const attr = element.getAttribute('data-language')\n  if (attr) {\n    return attr\n  }\n\n  const className = element.className\n  const match = className.match(/language-(\\w+)/)\n  if (match) {\n    return match[1]\n  }\n\n  return ''\n}\n","import {\n  union,\n  type Union,\n} from '@prosekit/core'\n\nimport {\n  defineCodeBlockCommands,\n  type CodeBlockCommandsExtension,\n} from './code-block-commands'\nimport {\n  defineCodeBlockEnterRule,\n  defineCodeBlockInputRule,\n} from './code-block-input-rule'\nimport { defineCodeBlockKeymap } from './code-block-keymap'\nimport {\n  defineCodeBlockSpec,\n  type CodeBlockSpecExtension,\n} from './code-block-spec'\n\n/**\n * @internal\n */\nexport type CodeBlockExtension = Union<\n  [CodeBlockSpecExtension, CodeBlockCommandsExtension]\n>\n\n/**\n * Adds `codeBlock` nodes to the editor. This includes the following extensions:\n *\n * - {@link defineCodeBlockSpec}\n * - {@link defineCodeBlockInputRule}\n * - {@link defineCodeBlockEnterRule}\n * - {@link defineCodeBlockKeymap}\n * - {@link defineCodeBlockCommands}.\n *\n * @public\n */\nexport function defineCodeBlock(): CodeBlockExtension {\n  return union(\n    defineCodeBlockSpec(),\n    defineCodeBlockInputRule(),\n    defineCodeBlockEnterRule(),\n    defineCodeBlockKeymap(),\n    defineCodeBlockCommands(),\n  )\n}\n","import {\n  definePlugin,\n  type Extension,\n} from '@prosekit/core'\nimport {\n  createHighlightPlugin,\n  type Parser,\n} from 'prosemirror-highlight'\n\n/**\n * @public\n *\n * An alias for the `Parser` type from the `prosemirror-highlight` package.\n */\nexport type HighlightParser = Parser\n\n/**\n * @public\n */\nexport type CodeBlockHighlightOptions = {\n  parser: HighlightParser\n}\n\n/**\n * Adds syntax highlighting to code blocks. This function requires a `Parser`\n * instance from the `prosemirror-highlight` package. See the\n * [documentation](https://github.com/ocavue/prosemirror-highlight) for more\n * information.\n *\n * @param options\n *\n * @public\n */\nexport function defineCodeBlockHighlight({\n  parser,\n}: CodeBlockHighlightOptions): Extension {\n  return definePlugin(\n    createHighlightPlugin({ parser }),\n  )\n}\n","import type {\n  HighlighterOptions,\n  HighlighterResult,\n} from './shiki-highlighter-chunk'\n\nlet loaded: ((options: HighlighterOptions) => HighlighterResult) | undefined\n\nasync function load() {\n  const { createOrGetHighlighter } = await import('./shiki-highlighter-chunk')\n  loaded = createOrGetHighlighter\n}\n\nexport function createOrGetHighlighter(\n  options: HighlighterOptions,\n): HighlighterResult {\n  if (!loaded) {\n    return { promise: load() }\n  }\n  return loaded(options)\n}\n\nexport type { HighlighterOptions }\n","import type { Parser } from 'prosemirror-highlight'\nimport { createParser } from 'prosemirror-highlight/shiki'\n\nimport type { ShikiBundledLanguage } from './shiki-bundle'\nimport {\n  createOrGetHighlighter,\n  type HighlighterOptions,\n} from './shiki-highlighter'\n\n/**\n * @internal\n */\nexport function createLazyParser(\n  highlighterOptions: HighlighterOptions,\n): Parser {\n  let parser: Parser | undefined\n\n  return function lazyParser(options) {\n    const language = (options.language || '') as ShikiBundledLanguage\n    const { highlighter, promise } = createOrGetHighlighter({\n      ...highlighterOptions,\n      langs: [language],\n    })\n\n    if (!highlighter) {\n      return promise\n    }\n\n    if (!parser) {\n      parser = createParser(highlighter, {\n        theme: highlighterOptions.themes[0],\n      })\n    }\n    return parser(options)\n  }\n}\n","import type { Extension } from '@prosekit/core'\nimport type { SpecialLanguage } from 'shiki'\n\nimport { defineCodeBlockHighlight } from './code-block-highlight'\nimport type {\n  ShikiBundledLanguage,\n  ShikiBundledTheme,\n} from './shiki-bundle'\nimport type { ShikiHighlighterOptions } from './shiki-highlighter-chunk'\nimport { createLazyParser } from './shiki-parser'\n\n/**\n * The options to configure the Shiki highlighter.\n *\n * @public\n */\nexport interface CodeBlockShikiOptions extends Omit<ShikiHighlighterOptions, 'themes' | 'langs' | 'engine'> {\n  /**\n   * A list of Shiki themes to pre-load. The first theme in the list will be\n   * used to render the code block.\n   *\n   * @default ['one-dark-pro']\n   */\n  themes?: ShikiBundledTheme[]\n\n  /**\n   * A list of Shiki languages to pre-load.\n   *\n   * @default ['text']\n   */\n  langs?: (ShikiBundledLanguage | SpecialLanguage)[]\n\n  /**\n   * The RegExp engine to use. By default, the JavaScript engine is used.\n   */\n  engine?: ShikiHighlighterOptions['engine']\n}\n\n/**\n * Adds syntax highlighting to code blocks using the [Shiki](https://github.com/shikijs/shiki) package.\n *\n * It will set two CSS variables on the code block elements:\n *\n * - `--prosemirror-highlight`: sets text color\n * - `--prosemirror-highlight-bg`: sets background color\n *\n * @param options - The options to configure the Shiki highlighter.\n *\n * @public\n */\nexport function defineCodeBlockShiki({\n  themes = ['one-dark-pro'],\n  langs = ['text'],\n  ...rest\n}: CodeBlockShikiOptions = {}): Extension {\n  const parser = createLazyParser({ themes, langs, ...rest })\n  return defineCodeBlockHighlight({ parser })\n}\n"],"mappings":"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"}