@portabletext/plugin-input-rule 6.0.13 → 6.0.14

package/dist/index.js

@@ -1,443 +1,377 @@
 import { c } from "react/compiler-runtime";
 import { useEditor } from "@portabletext/editor";
-import { defineBehavior, raise, effect, forward } from "@portabletext/editor/behaviors";
-import { getNextInlineObjects, getPreviousInlineObjects, getBlockOffsets, getFocusBlock, getBlockTextBefore, getMarkState } from "@portabletext/editor/selectors";
-import { blockOffsetToSpanSelectionPoint, childSelectionPointToBlockOffset, isKeyedSegment, isEqualSelections, isSelectionCollapsed } from "@portabletext/editor/utils";
+import { defineBehavior, effect, forward, raise } from "@portabletext/editor/behaviors";
+import { getBlockOffsets, getBlockTextBefore, getFocusBlock, getMarkState, getNextInlineObjects, getPreviousInlineObjects } from "@portabletext/editor/selectors";
+import { blockOffsetToSpanSelectionPoint, childSelectionPointToBlockOffset, isEqualSelections, isKeyedSegment, isSelectionCollapsed } from "@portabletext/editor/utils";
 import { useActorRef } from "@xstate/react";
-import { setup, fromCallback } from "xstate";
+import { fromCallback, setup } from "xstate";
+/**
+* @public
+*/
 function defineInputRule(config) {
-  return config;
+	return config;
 }
-function getInputRuleMatchLocation({
-  match,
-  adjustIndexBy,
-  snapshot,
-  focusBlock,
-  originalTextBefore,
-  allowedInlineObjectRanges
-}) {
-  const [text, start, end] = match, adjustedIndex = start + adjustIndexBy, targetOffsets = {
-    anchor: {
-      path: focusBlock.path,
-      offset: adjustedIndex
-    },
-    focus: {
-      path: focusBlock.path,
-      offset: adjustedIndex + end - start
-    },
-    backward: !1
-  }, normalizedOffsets = {
-    anchor: {
-      path: focusBlock.path,
-      offset: Math.min(targetOffsets.anchor.offset, originalTextBefore.length)
-    },
-    focus: {
-      path: focusBlock.path,
-      offset: Math.min(targetOffsets.focus.offset, originalTextBefore.length)
-    }
-  }, anchorBackwards = blockOffsetToSpanSelectionPoint({
-    snapshot,
-    blockOffset: normalizedOffsets.anchor,
-    direction: "backward"
-  }), focusForwards = blockOffsetToSpanSelectionPoint({
-    snapshot,
-    blockOffset: normalizedOffsets.focus,
-    direction: "forward"
-  });
-  if (!anchorBackwards || !focusForwards)
-    return;
-  const selection = {
-    anchor: anchorBackwards,
-    focus: focusForwards
-  }, inlineObjectsAfterMatch = getNextInlineObjects({
-    ...snapshot,
-    context: {
-      ...snapshot.context,
-      selection: {
-        anchor: selection.anchor,
-        focus: selection.anchor
-      }
-    }
-  }), inlineObjectsBefore = getPreviousInlineObjects(snapshot), inlineObjectsInMatch = inlineObjectsAfterMatch.filter((inlineObjectAfter) => inlineObjectsBefore.some((inlineObjectBefore) => inlineObjectAfter.node._key === inlineObjectBefore.node._key));
-  for (const inlineObject of inlineObjectsInMatch) {
-    const inlineObjectOffset = childSelectionPointToBlockOffset({
-      snapshot,
-      selectionPoint: {
-        path: inlineObject.path,
-        offset: 0
-      }
-    });
-    if (!inlineObjectOffset || !allowedInlineObjectRanges.some((range) => inlineObjectOffset.offset >= range.start + adjustIndexBy && inlineObjectOffset.offset <= range.end + adjustIndexBy))
-      return;
-  }
-  return {
-    text,
-    selection,
-    targetOffsets
-  };
+function getInputRuleMatchLocation({ match, adjustIndexBy, snapshot, focusBlock, originalTextBefore, allowedInlineObjectRanges }) {
+	let [text, start, end] = match, adjustedIndex = start + adjustIndexBy, targetOffsets = {
+		anchor: {
+			path: focusBlock.path,
+			offset: adjustedIndex
+		},
+		focus: {
+			path: focusBlock.path,
+			offset: adjustedIndex + end - start
+		},
+		backward: !1
+	}, normalizedOffsets = {
+		anchor: {
+			path: focusBlock.path,
+			offset: Math.min(targetOffsets.anchor.offset, originalTextBefore.length)
+		},
+		focus: {
+			path: focusBlock.path,
+			offset: Math.min(targetOffsets.focus.offset, originalTextBefore.length)
+		},
+		backward: !1
+	}, anchorBackwards = blockOffsetToSpanSelectionPoint({
+		snapshot,
+		blockOffset: normalizedOffsets.anchor,
+		direction: "backward"
+	}), focusForwards = blockOffsetToSpanSelectionPoint({
+		snapshot,
+		blockOffset: normalizedOffsets.focus,
+		direction: "forward"
+	});
+	if (!anchorBackwards || !focusForwards) return;
+	let selection = {
+		anchor: anchorBackwards,
+		focus: focusForwards
+	}, inlineObjectsAfterMatch = getNextInlineObjects({
+		...snapshot,
+		context: {
+			...snapshot.context,
+			selection: {
+				anchor: selection.anchor,
+				focus: selection.anchor
+			}
+		}
+	}), inlineObjectsBefore = getPreviousInlineObjects(snapshot), inlineObjectsInMatch = inlineObjectsAfterMatch.filter((inlineObjectAfter) => inlineObjectsBefore.some((inlineObjectBefore) => inlineObjectAfter.node._key === inlineObjectBefore.node._key));
+	for (let inlineObject of inlineObjectsInMatch) {
+		let inlineObjectOffset = childSelectionPointToBlockOffset({
+			snapshot,
+			selectionPoint: {
+				path: inlineObject.path,
+				offset: 0
+			}
+		});
+		if (!inlineObjectOffset || !allowedInlineObjectRanges.some((range) => inlineObjectOffset.offset >= range.start + adjustIndexBy && inlineObjectOffset.offset <= range.end + adjustIndexBy)) return;
+	}
+	return {
+		text,
+		selection,
+		targetOffsets
+	};
 }
+/**
+* @public
+*/
 function defineInputRuleBehavior(config) {
-  return defineBehavior({
-    on: "insert.text",
-    guard: ({
-      snapshot,
-      event,
-      dom
-    }) => {
-      if (!snapshot.context.selection || !isSelectionCollapsed(snapshot.context.selection))
-        return !1;
-      const focusBlock = getFocusBlock(snapshot);
-      if (!focusBlock)
-        return !1;
-      const originalTextBefore = getBlockTextBefore(snapshot);
-      let textBefore = originalTextBefore;
-      const originalNewText = textBefore + event.text;
-      let newText = originalNewText;
-      const foundMatches = [], foundActions = [];
-      for (const rule of config.rules) {
-        const safeUserFlags = rule.on.flags.replace(/[^imsu]/g, ""), matcher = new RegExp(rule.on.source, `gd${safeUserFlags}`);
-        for (; ; ) {
-          const ruleMatches = [...newText.matchAll(matcher)].flatMap((regExpMatch) => {
-            if (regExpMatch.indices === void 0)
-              return [];
-            const match = regExpMatch.indices.at(0);
-            if (!match)
-              return [];
-            const allowedInlineObjectRanges = (rule.inlineObjects?.allow ?? []).flatMap((groupName) => {
-              const span = regExpMatch.indices?.groups?.[groupName];
-              return span ? [{
-                start: span[0],
-                end: span[1]
-              }] : [];
-            }), matchLocation = getInputRuleMatchLocation({
-              match: [regExpMatch.at(0) ?? "", ...match],
-              adjustIndexBy: originalNewText.length - newText.length,
-              snapshot,
-              focusBlock,
-              originalTextBefore,
-              allowedInlineObjectRanges
-            });
-            if (!matchLocation)
-              return [];
-            if (matchLocation.targetOffsets.focus.offset <= originalTextBefore.length)
-              return [];
-            if (foundMatches.some((foundMatch) => foundMatch.targetOffsets.anchor.offset === matchLocation.targetOffsets.anchor.offset))
-              return [];
-            const groups = {};
-            for (const [groupName, span] of Object.entries(regExpMatch.indices.groups ?? {})) {
-              if (!span)
-                continue;
-              const groupLocation = getInputRuleMatchLocation({
-                match: [regExpMatch.groups?.[groupName] ?? "", span[0], span[1]],
-                adjustIndexBy: originalNewText.length - newText.length,
-                snapshot,
-                focusBlock,
-                originalTextBefore,
-                allowedInlineObjectRanges
-              });
-              groupLocation && (groups[groupName] = groupLocation);
-            }
-            return [{
-              text: matchLocation.text,
-              selection: matchLocation.selection,
-              targetOffsets: matchLocation.targetOffsets,
-              groups
-            }];
-          });
-          if (ruleMatches.length > 0) {
-            const guardResult = rule.guard?.({
-              snapshot,
-              event: {
-                type: "custom.input rule",
-                matches: ruleMatches,
-                focusBlock,
-                textBefore: originalTextBefore,
-                textInserted: event.text
-              },
-              dom
-            }) ?? !0;
-            if (!guardResult)
-              break;
-            const actionSets = rule.actions.map((action) => action({
-              snapshot,
-              event: {
-                type: "custom.input rule",
-                matches: ruleMatches,
-                focusBlock,
-                textBefore: originalTextBefore,
-                textInserted: event.text
-              },
-              dom
-            }, guardResult));
-            for (const actionSet of actionSets)
-              for (const action of actionSet)
-                foundActions.push(action);
-            const matches = ruleMatches.flatMap((match) => {
-              const groupLocations = Object.values(match.groups).filter((location) => location !== void 0);
-              return groupLocations.length === 0 ? [match] : groupLocations;
-            });
-            for (const match of matches)
-              foundMatches.push(match), textBefore = newText.slice(0, match.targetOffsets.focus.offset ?? 0), newText = originalNewText.slice(match.targetOffsets.focus.offset ?? 0);
-          } else
-            break;
-        }
-      }
-      return foundActions.length === 0 ? !1 : {
-        actions: foundActions
-      };
-    },
-    actions: [({
-      event
-    }) => [forward(event)], (_, {
-      actions
-    }) => actions, ({
-      snapshot
-    }) => [effect(() => {
-      const blockOffsets = getBlockOffsets(snapshot);
-      config.onApply?.({
-        endOffsets: blockOffsets,
-        endSelection: snapshot.context.selection
-      });
-    })]]
-  });
+	return defineBehavior({
+		on: "insert.text",
+		guard: ({ snapshot, event, dom }) => {
+			if (!snapshot.context.selection || !isSelectionCollapsed(snapshot.context.selection)) return !1;
+			let focusBlock = getFocusBlock(snapshot);
+			if (!focusBlock) return !1;
+			let originalTextBefore = getBlockTextBefore(snapshot), textBefore = originalTextBefore, originalNewText = textBefore + event.text, newText = originalNewText, foundMatches = [], foundActions = [];
+			for (let rule of config.rules) {
+				let safeUserFlags = rule.on.flags.replace(/[^imsu]/g, ""), matcher = new RegExp(rule.on.source, `gd${safeUserFlags}`);
+				for (;;) {
+					let ruleMatches = [...newText.matchAll(matcher)].flatMap((regExpMatch) => {
+						if (regExpMatch.indices === void 0) return [];
+						let match = regExpMatch.indices.at(0);
+						if (!match) return [];
+						let allowedInlineObjectRanges = (rule.inlineObjects?.allow ?? []).flatMap((groupName) => {
+							let span = regExpMatch.indices?.groups?.[groupName];
+							return span ? [{
+								start: span[0],
+								end: span[1]
+							}] : [];
+						}), matchLocation = getInputRuleMatchLocation({
+							match: [regExpMatch.at(0) ?? "", ...match],
+							adjustIndexBy: originalNewText.length - newText.length,
+							snapshot,
+							focusBlock,
+							originalTextBefore,
+							allowedInlineObjectRanges
+						});
+						if (!matchLocation || matchLocation.targetOffsets.focus.offset <= originalTextBefore.length || foundMatches.some((foundMatch) => foundMatch.targetOffsets.anchor.offset === matchLocation.targetOffsets.anchor.offset)) return [];
+						let groups = {};
+						for (let [groupName, span] of Object.entries(regExpMatch.indices.groups ?? {})) {
+							if (!span) continue;
+							let groupLocation = getInputRuleMatchLocation({
+								match: [
+									regExpMatch.groups?.[groupName] ?? "",
+									span[0],
+									span[1]
+								],
+								adjustIndexBy: originalNewText.length - newText.length,
+								snapshot,
+								focusBlock,
+								originalTextBefore,
+								allowedInlineObjectRanges
+							});
+							groupLocation && (groups[groupName] = groupLocation);
+						}
+						return [{
+							text: matchLocation.text,
+							selection: matchLocation.selection,
+							targetOffsets: matchLocation.targetOffsets,
+							groups
+						}];
+					});
+					if (ruleMatches.length > 0) {
+						let guardResult = rule.guard?.({
+							snapshot,
+							event: {
+								type: "custom.input rule",
+								matches: ruleMatches,
+								focusBlock,
+								textBefore: originalTextBefore,
+								textInserted: event.text
+							},
+							dom
+						}) ?? !0;
+						if (!guardResult) break;
+						let actionSets = rule.actions.map((action) => action({
+							snapshot,
+							event: {
+								type: "custom.input rule",
+								matches: ruleMatches,
+								focusBlock,
+								textBefore: originalTextBefore,
+								textInserted: event.text
+							},
+							dom
+						}, guardResult));
+						for (let actionSet of actionSets) for (let action of actionSet) foundActions.push(action);
+						let matches = ruleMatches.flatMap((match) => {
+							let groupLocations = Object.values(match.groups).filter((location) => location !== void 0);
+							return groupLocations.length === 0 ? [match] : groupLocations;
+						});
+						for (let match of matches) foundMatches.push(match), textBefore = newText.slice(0, match.targetOffsets.focus.offset ?? 0), newText = originalNewText.slice(match.targetOffsets.focus.offset ?? 0);
+					} else break;
+				}
+			}
+			return foundActions.length !== 0 && { actions: foundActions };
+		},
+		actions: [
+			({ event }) => [forward(event)],
+			(_, { actions }) => actions,
+			({ snapshot }) => [effect(() => {
+				let blockOffsets = getBlockOffsets(snapshot);
+				config.onApply?.({
+					endOffsets: blockOffsets,
+					endSelection: snapshot.context.selection
+				});
+			})]
+		]
+	});
 }
+/**
+* Turn an array of `InputRule`s into a Behavior that can be used to apply the
+* rules to the editor.
+*
+* The plugin handles undo/redo out of the box including smart undo with
+* Backspace.
+*
+* @example
+* ```tsx
+* <InputRulePlugin rules={smartQuotesRules} />
+* ```
+*
+* @public
+*/
 function InputRulePlugin(props) {
-  const $ = c(3), editor = useEditor();
-  let t0;
-  return $[0] !== editor || $[1] !== props.rules ? (t0 = {
-    input: {
-      editor,
-      rules: props.rules
-    }
-  }, $[0] = editor, $[1] = props.rules, $[2] = t0) : t0 = $[2], useActorRef(inputRuleMachine, t0), null;
+	let $ = c(3), editor = useEditor(), t0;
+	return $[0] !== editor || $[1] !== props.rules ? (t0 = { input: {
+		editor,
+		rules: props.rules
+	} }, $[0] = editor, $[1] = props.rules, $[2] = t0) : t0 = $[2], useActorRef(inputRuleMachine, t0), null;
 }
-const inputRuleListenerCallback = ({
-  input,
-  sendBack
-}) => {
-  const unregister = input.editor.registerBehavior({
-    behavior: defineInputRuleBehavior({
-      rules: input.rules,
-      onApply: ({
-        endOffsets,
-        endSelection
-      }) => {
-        sendBack({
-          type: "input rule raised",
-          endOffsets,
-          endSelection
-        });
-      }
-    })
-  });
-  return () => {
-    unregister();
-  };
-}, deleteBackwardListenerCallback = ({
-  input,
-  sendBack
-}) => input.editor.registerBehavior({
-  behavior: defineBehavior({
-    on: "delete.backward",
-    actions: [() => [raise({
-      type: "history.undo"
-    }), effect(() => {
-      sendBack({
-        type: "history.undo raised"
-      });
-    })]]
-  })
-}), selectionListenerCallback = ({
-  sendBack,
-  input
-}) => {
-  const subscription = input.editor.on("selection", (event) => {
-    const blockOffsets = getBlockOffsets({
-      ...input.editor.getSnapshot(),
-      context: {
-        ...input.editor.getSnapshot().context,
-        selection: event.selection
-      }
-    });
-    sendBack({
-      type: "selection changed",
-      blockOffsets,
-      selection: event.selection
-    });
-  });
-  return () => subscription.unsubscribe();
+const inputRuleListenerCallback = ({ input, sendBack }) => {
+	let unregister = input.editor.registerBehavior({ behavior: defineInputRuleBehavior({
+		rules: input.rules,
+		onApply: ({ endOffsets, endSelection }) => {
+			sendBack({
+				type: "input rule raised",
+				endOffsets,
+				endSelection
+			});
+		}
+	}) });
+	return () => {
+		unregister();
+	};
+}, deleteBackwardListenerCallback = ({ input, sendBack }) => input.editor.registerBehavior({ behavior: defineBehavior({
+	on: "delete.backward",
+	actions: [() => [raise({ type: "history.undo" }), effect(() => {
+		sendBack({ type: "history.undo raised" });
+	})]]
+}) }), selectionListenerCallback = ({ sendBack, input }) => {
+	let subscription = input.editor.on("selection", (event) => {
+		sendBack({
+			type: "selection changed",
+			blockOffsets: getBlockOffsets({
+				...input.editor.getSnapshot(),
+				context: {
+					...input.editor.getSnapshot().context,
+					selection: event.selection
+				}
+			}),
+			selection: event.selection
+		});
+	});
+	return () => subscription.unsubscribe();
 }, inputRuleSetup = setup({
-  types: {
-    context: {},
-    input: {},
-    events: {}
-  },
-  actors: {
-    "delete.backward listener": fromCallback(deleteBackwardListenerCallback),
-    "input rule listener": fromCallback(inputRuleListenerCallback),
-    "selection listener": fromCallback(selectionListenerCallback)
-  },
-  guards: {
-    "selection changed": ({
-      context,
-      event
-    }) => {
-      if (event.type !== "selection changed")
-        return !1;
-      if (event.blockOffsets && context.endOffsets) {
-        const contextStartBlock = context.endOffsets.start.path.at(-1), eventStartBlock = event.blockOffsets.start.path.at(-1), contextEndBlock = context.endOffsets.end.path.at(-1), eventEndBlock = event.blockOffsets.end.path.at(-1);
-        if (!isKeyedSegment(contextStartBlock) || !isKeyedSegment(eventStartBlock) || !isKeyedSegment(contextEndBlock) || !isKeyedSegment(eventEndBlock))
-          return !1;
-        const startChanged = contextStartBlock._key !== eventStartBlock._key || context.endOffsets.start.offset !== event.blockOffsets.start.offset, endChanged = contextEndBlock._key !== eventEndBlock._key || context.endOffsets.end.offset !== event.blockOffsets.end.offset;
-        return startChanged || endChanged;
-      }
-      return !isEqualSelections(context.endSelection, event.selection);
-    }
-  }
+	types: {
+		context: {},
+		input: {},
+		events: {}
+	},
+	actors: {
+		"delete.backward listener": fromCallback(deleteBackwardListenerCallback),
+		"input rule listener": fromCallback(inputRuleListenerCallback),
+		"selection listener": fromCallback(selectionListenerCallback)
+	},
+	guards: { "selection changed": ({ context, event }) => {
+		if (event.type !== "selection changed") return !1;
+		if (event.blockOffsets && context.endOffsets) {
+			let contextStartBlock = context.endOffsets.start.path.at(-1), eventStartBlock = event.blockOffsets.start.path.at(-1), contextEndBlock = context.endOffsets.end.path.at(-1), eventEndBlock = event.blockOffsets.end.path.at(-1);
+			if (!isKeyedSegment(contextStartBlock) || !isKeyedSegment(eventStartBlock) || !isKeyedSegment(contextEndBlock) || !isKeyedSegment(eventEndBlock)) return !1;
+			let startChanged = contextStartBlock._key !== eventStartBlock._key || context.endOffsets.start.offset !== event.blockOffsets.start.offset, endChanged = contextEndBlock._key !== eventEndBlock._key || context.endOffsets.end.offset !== event.blockOffsets.end.offset;
+			return startChanged || endChanged;
+		}
+		return !isEqualSelections(context.endSelection, event.selection);
+	} }
 }), assignEndState = inputRuleSetup.assign({
-  endOffsets: ({
-    context,
-    event
-  }) => event.type === "input rule raised" ? event.endOffsets : context.endOffsets,
-  endSelection: ({
-    context,
-    event
-  }) => event.type === "input rule raised" ? event.endSelection : context.endSelection
+	endOffsets: ({ context, event }) => event.type === "input rule raised" ? event.endOffsets : context.endOffsets,
+	endSelection: ({ context, event }) => event.type === "input rule raised" ? event.endSelection : context.endSelection
 }), inputRuleMachine = inputRuleSetup.createMachine({
-  id: "input rule",
-  context: ({
-    input
-  }) => ({
-    editor: input.editor,
-    rules: input.rules,
-    endOffsets: void 0,
-    endSelection: null
-  }),
-  initial: "idle",
-  invoke: {
-    src: "input rule listener",
-    input: ({
-      context
-    }) => ({
-      editor: context.editor,
-      rules: context.rules
-    })
-  },
-  on: {
-    "input rule raised": {
-      target: ".input rule applied",
-      actions: assignEndState
-    }
-  },
-  states: {
-    idle: {},
-    "input rule applied": {
-      invoke: [{
-        src: "delete.backward listener",
-        input: ({
-          context
-        }) => ({
-          editor: context.editor
-        })
-      }, {
-        src: "selection listener",
-        input: ({
-          context
-        }) => ({
-          editor: context.editor
-        })
-      }],
-      on: {
-        "selection changed": {
-          target: "idle",
-          guard: "selection changed"
-        },
-        "history.undo raised": {
-          target: "idle"
-        }
-      }
-    }
-  }
+	id: "input rule",
+	context: ({ input }) => ({
+		editor: input.editor,
+		rules: input.rules,
+		endOffsets: void 0,
+		endSelection: null
+	}),
+	initial: "idle",
+	invoke: {
+		src: "input rule listener",
+		input: ({ context }) => ({
+			editor: context.editor,
+			rules: context.rules
+		})
+	},
+	on: { "input rule raised": {
+		target: ".input rule applied",
+		actions: assignEndState
+	} },
+	states: {
+		idle: {},
+		"input rule applied": {
+			invoke: [{
+				src: "delete.backward listener",
+				input: ({ context }) => ({ editor: context.editor })
+			}, {
+				src: "selection listener",
+				input: ({ context }) => ({ editor: context.editor })
+			}],
+			on: {
+				"selection changed": {
+					target: "idle",
+					guard: "selection changed"
+				},
+				"history.undo raised": { target: "idle" }
+			}
+		}
+	}
 });
+/**
+* Define an `InputRule` specifically designed to transform matched text into
+* some other text.
+*
+* @example
+* ```tsx
+* const transformRule = defineTextTransformRule({
+*   on: /--/,
+*   transform: () => '—',
+* })
+* ```
+*
+* @public
+*/
 function defineTextTransformRule(config) {
-  const transformRecord = typeof config.transform == "function" ? void 0 : config.transform;
-  if (transformRecord) {
-    const probeFlags = config.on.flags.replace(/[gyd]/g, ""), namedGroups = Object.keys(new RegExp(`${config.on.source}|`, probeFlags).exec("")?.groups ?? {});
-    for (const groupName of Object.keys(transformRecord))
-      if (!namedGroups.includes(groupName))
-        throw new Error(`defineTextTransformRule: \`transform\` targets the group "${groupName}", but \`on\` (${config.on}) has no such named capture group` + (namedGroups.length > 0 ? `. Named groups: ${namedGroups.map((name) => `"${name}"`).join(", ")}` : ". The pattern has no named capture groups"));
-  }
-  return {
-    on: config.on,
-    guard: config.guard ?? (() => !0),
-    actions: [({
-      snapshot,
-      event
-    }, guardResponse) => {
-      const targets = event.matches.flatMap((match) => transformRecord ? Object.entries(transformRecord).flatMap(([groupName, groupTransform]) => {
-        const location = match.groups[groupName];
-        return location ? [{
-          location,
-          transform: groupTransform
-        }] : [];
-      }) : [{
-        location: match,
-        transform: config.transform
-      }]).sort((a, b) => a.location.targetOffsets.anchor.offset - b.location.targetOffsets.anchor.offset), newText = event.textBefore + event.textInserted;
-      let textLengthDelta = 0;
-      const actions = [];
-      for (const {
-        location,
-        transform
-      } of targets.reverse()) {
-        const text = transform({
-          location
-        }, guardResponse);
-        textLengthDelta = textLengthDelta - (text.length - (location.targetOffsets.focus.offset - location.targetOffsets.anchor.offset)), actions.push(raise({
-          type: "select",
-          at: location.targetOffsets
-        })), actions.push(raise({
-          type: "delete",
-          at: location.targetOffsets
-        })), actions.push(raise({
-          type: "insert.child",
-          child: {
-            _type: snapshot.context.schema.span.name,
-            text,
-            marks: getMarkState({
-              ...snapshot,
-              context: {
-                ...snapshot.context,
-                selection: {
-                  anchor: location.selection.anchor,
-                  focus: {
-                    path: location.selection.focus.path,
-                    offset: Math.min(location.selection.focus.offset, event.textBefore.length)
-                  }
-                }
-              }
-            })?.marks ?? []
-          }
-        }));
-      }
-      const endCaretPosition = {
-        path: event.focusBlock.path,
-        offset: newText.length - textLengthDelta
-      };
-      return [...actions, raise({
-        type: "select",
-        at: {
-          anchor: endCaretPosition,
-          focus: endCaretPosition
-        }
-      })];
-    }]
-  };
+	let transformRecord = typeof config.transform == "function" ? void 0 : config.transform;
+	if (transformRecord) {
+		let probeFlags = config.on.flags.replace(/[gyd]/g, ""), namedGroups = Object.keys(RegExp(`${config.on.source}|`, probeFlags).exec("")?.groups ?? {});
+		for (let groupName of Object.keys(transformRecord)) if (!namedGroups.includes(groupName)) throw Error(`defineTextTransformRule: \`transform\` targets the group "${groupName}", but \`on\` (${config.on}) has no such named capture group` + (namedGroups.length > 0 ? `. Named groups: ${namedGroups.map((name) => `"${name}"`).join(", ")}` : ". The pattern has no named capture groups"));
+	}
+	return {
+		on: config.on,
+		guard: config.guard ?? (() => !0),
+		actions: [({ snapshot, event }, guardResponse) => {
+			let targets = event.matches.flatMap((match) => transformRecord ? Object.entries(transformRecord).flatMap(([groupName, groupTransform]) => {
+				let location = match.groups[groupName];
+				return location ? [{
+					location,
+					transform: groupTransform
+				}] : [];
+			}) : [{
+				location: match,
+				transform: config.transform
+			}]).sort((a, b) => a.location.targetOffsets.anchor.offset - b.location.targetOffsets.anchor.offset), newText = event.textBefore + event.textInserted, textLengthDelta = 0, actions = [];
+			for (let { location, transform } of targets.reverse()) {
+				let text = transform({ location }, guardResponse);
+				textLengthDelta -= text.length - (location.targetOffsets.focus.offset - location.targetOffsets.anchor.offset), actions.push(raise({
+					type: "select",
+					at: location.targetOffsets
+				})), actions.push(raise({
+					type: "delete",
+					at: location.targetOffsets
+				})), actions.push(raise({
+					type: "insert.child",
+					child: {
+						_type: snapshot.context.schema.span.name,
+						text,
+						marks: getMarkState({
+							...snapshot,
+							context: {
+								...snapshot.context,
+								selection: {
+									anchor: location.selection.anchor,
+									focus: {
+										path: location.selection.focus.path,
+										offset: Math.min(location.selection.focus.offset, event.textBefore.length)
+									}
+								}
+							}
+						})?.marks ?? []
+					}
+				}));
+			}
+			let endCaretPosition = {
+				path: event.focusBlock.path,
+				offset: newText.length - textLengthDelta
+			};
+			return [...actions, raise({
+				type: "select",
+				at: {
+					anchor: endCaretPosition,
+					focus: endCaretPosition
+				}
+			})];
+		}]
+	};
 }
-export {
-  InputRulePlugin,
-  defineInputRule,
-  defineInputRuleBehavior,
-  defineTextTransformRule
-};
-//# sourceMappingURL=index.js.map
+export { InputRulePlugin, defineInputRule, defineInputRuleBehavior, defineTextTransformRule };
+
+//# sourceMappingURL=index.js.map