@lofcz/platejs-core 52.3.6 → 53.0.0

package/dist/{withSlate-BfRR5wTZ.js → withSlate-DsAgt7dN.js}

@@ -112,6 +112,7 @@ function createSlatePlugin(config = {}) {
 		render: {},
 		rules: {},
 		shortcuts: {},
+		inputRules: [],
 		transforms: {}
 	}, config);
 	if (plugin.node.isLeaf && !isDefined(plugin.node.isDecoration)) plugin.node.isDecoration = true;
@@ -283,6 +284,11 @@ function getEditorPlugin(editor, p) {
 
 //#endregion
 //#region src/internal/plugin/resolvePlugin.ts
+const normalizeConfiguredInputRules = (config) => {
+	if (config === void 0) return [];
+	if (Array.isArray(config)) return [...config];
+	throw new Error("inputRules config must be an array of explicit rule instances.");
+};
 /**
 * Resolves and finalizes a plugin configuration for use in a Plate editor.
 *
@@ -303,6 +309,11 @@ const resolvePlugin = (editor, _plugin) => {
 	plugin.__resolved = true;
 	if (plugin.__configuration) {
 		const configResult = plugin.__configuration(getEditorPlugin(editor, plugin));
+		if (configResult.inputRules !== void 0) {
+			const normalizedInputRules = normalizeConfiguredInputRules(configResult.inputRules);
+			plugin.__configuredInputRules = [...normalizeConfiguredInputRules(plugin.__configuredInputRules), ...normalizedInputRules];
+			configResult.inputRules = void 0;
+		}
 		plugin = mergePlugins(plugin, configResult);
 		plugin.__configuration = void 0;
 	}
@@ -361,11 +372,390 @@ const getPluginByType = (editor, type) => {
 };
 const getContainerTypes = (editor) => getPluginTypes(editor, editor.meta.pluginCache.node.isContainer);
 
+//#endregion
+//#region src/lib/plugins/input-rules/defineInputRule.ts
+function defineInputRule(rule) {
+	return rule;
+}
+
+//#endregion
+//#region src/lib/plugins/input-rules/createInputRules.ts
+const noWhiteSpaceRegex = /\S+/;
+const isPreviousCharacterEmpty = (editor, at) => {
+	const range = editor.api.range("before", at);
+	if (!range) return true;
+	const text = editor.api.string(range);
+	return text ? !noWhiteSpaceRegex.exec(text) : true;
+};
+const getMarkMatch = (editor, { end = "", start }) => {
+	const { selection } = editor;
+	if (!selection) return;
+	let beforeEndMatchPoint = selection.anchor;
+	if (end) {
+		beforeEndMatchPoint = editor.api.before(selection, { matchString: end });
+		if (!beforeEndMatchPoint) return;
+	}
+	const afterStartMatchPoint = editor.api.before(beforeEndMatchPoint, {
+		afterMatch: true,
+		matchString: start,
+		skipInvalid: true
+	});
+	if (!afterStartMatchPoint) return;
+	const beforeStartMatchPoint = editor.api.before(beforeEndMatchPoint, {
+		matchString: start,
+		skipInvalid: true
+	});
+	if (!beforeStartMatchPoint) return;
+	if (!isPreviousCharacterEmpty(editor, beforeStartMatchPoint)) return;
+	return {
+		afterStartMatchPoint,
+		beforeEndMatchPoint,
+		beforeStartMatchPoint
+	};
+};
+const createMarkInputRule = (config) => defineInputRule({
+	enabled: config.enabled,
+	priority: config.priority,
+	target: "insertText",
+	trigger: config.trigger,
+	resolve: ({ editor, text }) => {
+		if (text !== config.trigger || !editor.selection || !editor.api.isCollapsed()) return;
+		const match = getMarkMatch(editor, {
+			end: config.end,
+			start: config.start
+		});
+		if (!match) return;
+		const range = {
+			anchor: match.afterStartMatchPoint,
+			focus: match.beforeEndMatchPoint
+		};
+		const matchText = editor.api.string(range);
+		if (config.trim !== "allow" && matchText.trim() !== matchText) return;
+		return {
+			...match,
+			end: config.end
+		};
+	},
+	apply: ({ editor, pluginKey }, match) => {
+		const marks = config.marks ? [...config.marks] : [config.mark ?? pluginKey];
+		if (match.beforeEndMatchPoint !== editor.selection?.anchor) editor.tf.delete({ at: {
+			anchor: match.beforeEndMatchPoint,
+			focus: editor.selection.anchor
+		} });
+		editor.tf.select({
+			anchor: match.afterStartMatchPoint,
+			focus: match.beforeEndMatchPoint
+		});
+		marks.forEach((mark) => {
+			editor.tf.addMark(editor.getType(mark), true);
+		});
+		editor.tf.collapse({ edge: "end" });
+		editor.tf.removeMarks(marks.map((mark) => editor.getType(mark)), { shouldChange: false });
+		editor.tf.delete({ at: {
+			anchor: match.beforeStartMatchPoint,
+			focus: match.afterStartMatchPoint
+		} });
+		return true;
+	}
+});
+const matchBlockStart = (context, config) => {
+	if (!context.isCollapsed) return;
+	const pattern = typeof config.match === "function" ? config.match(context) : config.match;
+	if (!pattern) return;
+	const range = context.getBlockStartRange();
+	const blockText = context.getBlockStartText();
+	if (!range || blockText === void 0) return;
+	const baseMatch = {
+		range,
+		text: blockText
+	};
+	if (typeof pattern === "string") {
+		if (blockText !== pattern) return;
+		if (config.resolveMatch) {
+			const resolved = config.resolveMatch({
+				match: pattern,
+				range,
+				text: blockText
+			});
+			if (resolved === void 0) return;
+			return {
+				...baseMatch,
+				...resolved
+			};
+		}
+		return baseMatch;
+	}
+	const regexMatch = blockText.match(pattern);
+	if (!regexMatch) return;
+	if (config.resolveMatch) {
+		const resolved = config.resolveMatch({
+			match: regexMatch,
+			range,
+			text: blockText
+		});
+		if (resolved === void 0) return;
+		return {
+			...baseMatch,
+			...resolved
+		};
+	}
+	return baseMatch;
+};
+const createBlockStartInputRule = (config) => defineInputRule({
+	enabled: config.enabled,
+	priority: config.priority,
+	target: "insertText",
+	trigger: config.trigger,
+	resolve: (context) => matchBlockStart(context, config),
+	apply: (context, match) => {
+		if (config.apply) return config.apply(context, match);
+		const { editor, pluginKey } = context;
+		const defaultMatch = match;
+		if (config.removeMatchedText !== false) editor.tf.delete({ at: defaultMatch.range });
+		const node = editor.getType(config.node ?? pluginKey);
+		if (config.mode === "wrap") {
+			editor.tf.toggleBlock(node, { wrap: true });
+			return true;
+		}
+		if (config.mode === "toggle") {
+			editor.tf.toggleBlock(node);
+			return true;
+		}
+		editor.tf.setNodes({ type: node }, { match: (entryNode) => editor.api.isBlock(entryNode) });
+		return true;
+	}
+});
+const matchBlockFence = (context, config) => {
+	const { editor } = context;
+	const { selection } = editor;
+	if (!context.isCollapsed || !selection) return;
+	const blockEntry = context.getBlockEntry();
+	if (!blockEntry) return;
+	const [blockNode, path] = blockEntry;
+	const endPoint = editor.api.end(path);
+	if (config.block && blockNode.type !== editor.getType(config.block)) return;
+	if (!endPoint || !editor.api.isEnd(selection.focus, path)) return;
+	const range = context.getBlockStartRange();
+	const blockText = context.getBlockStartText();
+	if (!range || blockText === void 0 || blockText !== config.fence) return;
+	return config.resolveMatch ? config.resolveMatch({
+		fence: config.fence,
+		path,
+		range,
+		text: blockText
+	}) : {
+		path,
+		range,
+		text: blockText
+	};
+};
+function createBlockFenceInputRule(config) {
+	if (config.on === "break") return defineInputRule({
+		priority: config.priority,
+		target: "insertBreak",
+		enabled: config.enabled,
+		resolve: (context) => matchBlockFence(context, {
+			block: config.block,
+			fence: config.fence,
+			resolveMatch: config.resolveMatch
+		}),
+		apply: config.apply
+	});
+	const trigger = config.fence.at(-1);
+	if (!trigger) throw new Error("createBlockFenceInputRule requires a non-empty fence.");
+	return defineInputRule({
+		priority: config.priority,
+		target: "insertText",
+		enabled: config.enabled,
+		trigger,
+		resolve: (context) => {
+			if (context.text !== trigger) return;
+			return matchBlockFence(context, {
+				block: config.block,
+				fence: config.fence.slice(0, -trigger.length),
+				resolveMatch: config.resolveMatch
+			});
+		},
+		apply: config.apply
+	});
+}
+const matchDelimitedInline = (context, { boundaryRe, close, followRe, open, requireClosingDelimiter = true, rejectRepeatedOpen = true, trim = "reject" }) => {
+	const { editor } = context;
+	const { selection } = editor;
+	if (!selection || !context.isCollapsed) return;
+	const blockRange = context.getBlockStartRange();
+	if (!blockRange) return;
+	const openingDelimiter = open;
+	const closingDelimiter = close ?? open;
+	const textBefore = editor.api.string(blockRange);
+	const beforeClose = requireClosingDelimiter ? (() => {
+		const closeLength = closingDelimiter.length;
+		if (textBefore.length < closeLength) return;
+		if (!textBefore.endsWith(closingDelimiter)) return;
+		return textBefore.slice(0, -closeLength);
+	})() : textBefore;
+	if (!beforeClose) return;
+	const openIndex = beforeClose.lastIndexOf(openingDelimiter);
+	if (openIndex < 0) return;
+	const prefix = beforeClose.slice(0, openIndex);
+	const content = beforeClose.slice(openIndex + openingDelimiter.length);
+	if (!content) return;
+	if (trim === "reject" && content.trim() !== content) return;
+	if (rejectRepeatedOpen && openingDelimiter === closingDelimiter && prefix.endsWith(openingDelimiter)) return;
+	const previousChar = prefix.at(-1);
+	if (previousChar && boundaryRe && !boundaryRe.test(previousChar)) return;
+	const nextPoint = editor.api.after(selection, {
+		distance: 1,
+		unit: "character"
+	});
+	if (nextPoint && followRe) {
+		const nextChar = editor.api.string({
+			anchor: selection.anchor,
+			focus: nextPoint
+		});
+		if (nextChar && !followRe.test(nextChar)) return;
+	}
+	const startPoint = editor.api.before(selection, {
+		distance: content.length + openingDelimiter.length,
+		unit: "character"
+	});
+	if (!startPoint) return;
+	return {
+		content,
+		deleteRange: {
+			anchor: startPoint,
+			focus: selection.anchor
+		}
+	};
+};
+const getTextSubstitutionMatchRange = ({ match, trigger }) => {
+	const start = match;
+	const reversed = start.split("").reverse().join("");
+	const triggers = trigger ? Array.isArray(trigger) ? [...trigger] : [trigger] : [reversed.slice(-1)];
+	return {
+		end: trigger ? reversed : reversed.slice(0, -1),
+		start,
+		triggers
+	};
+};
+const getTextSubstitutionMatchPoints = (editor, { end, start }) => {
+	const { selection } = editor;
+	if (!selection) return;
+	let beforeEndMatchPoint = selection.anchor;
+	if (end) {
+		beforeEndMatchPoint = editor.api.before(selection, { matchString: end });
+		if (!beforeEndMatchPoint) return;
+	}
+	let afterStartMatchPoint;
+	let beforeStartMatchPoint;
+	if (start) {
+		afterStartMatchPoint = editor.api.before(beforeEndMatchPoint, {
+			afterMatch: true,
+			matchString: start,
+			skipInvalid: true
+		});
+		if (!afterStartMatchPoint) return;
+		beforeStartMatchPoint = editor.api.before(beforeEndMatchPoint, {
+			matchString: start,
+			skipInvalid: true
+		});
+		if (!beforeStartMatchPoint) return;
+		if (!isPreviousCharacterEmpty(editor, beforeStartMatchPoint)) return;
+	}
+	return {
+		afterStartMatchPoint,
+		beforeEndMatchPoint,
+		beforeStartMatchPoint
+	};
+};
+const getTextSubstitutionTriggers = (patterns) => Array.from(new Set(patterns.flatMap((pattern) => {
+	return (Array.isArray(pattern.match) ? [...pattern.match] : [pattern.match]).flatMap((match) => getTextSubstitutionMatchRange({
+		match,
+		trigger: pattern.trigger
+	}).triggers);
+})));
+const resolveTextSubstitution = ({ editor, patterns, text }) => {
+	for (const pattern of patterns) {
+		const matches = Array.isArray(pattern.match) ? [...pattern.match] : [pattern.match];
+		for (const match of matches) {
+			const { end, start, triggers } = getTextSubstitutionMatchRange({
+				match,
+				trigger: pattern.trigger
+			});
+			if (!triggers.includes(text)) continue;
+			const points = getTextSubstitutionMatchPoints(editor, {
+				end: Array.isArray(pattern.format) ? "" : end,
+				start
+			});
+			if (!points) continue;
+			return {
+				end: Array.isArray(pattern.format) ? "" : end,
+				pattern,
+				points
+			};
+		}
+	}
+};
+const applyTextSubstitution = (editor, match) => {
+	const selection = editor.selection;
+	if (!selection || !match) return false;
+	if (match.end) editor.tf.delete({ at: {
+		anchor: match.points.beforeEndMatchPoint,
+		focus: selection.anchor
+	} });
+	const formatEnd = Array.isArray(match.pattern.format) ? match.pattern.format[1] : match.pattern.format;
+	editor.tf.insertText(formatEnd);
+	if (match.points.beforeStartMatchPoint && match.points.afterStartMatchPoint) {
+		const formatStart = Array.isArray(match.pattern.format) ? match.pattern.format[0] : match.pattern.format;
+		editor.tf.delete({ at: {
+			anchor: match.points.beforeStartMatchPoint,
+			focus: match.points.afterStartMatchPoint
+		} });
+		editor.tf.insertText(formatStart, { at: match.points.beforeStartMatchPoint });
+	}
+	return true;
+};
+const createTextSubstitutionInputRule = ({ enabled, patterns, priority }) => defineInputRule({
+	enabled,
+	priority,
+	target: "insertText",
+	trigger: getTextSubstitutionTriggers(patterns),
+	resolve: ({ editor, text }) => {
+		if (!editor.selection || !editor.api.isCollapsed()) return;
+		return resolveTextSubstitution({
+			editor,
+			patterns,
+			text
+		});
+	},
+	apply: ({ editor }, match) => applyTextSubstitution(editor, match)
+});
+
+//#endregion
+//#region src/lib/plugins/input-rules/internal/createInputRuleBuilder.ts
+const createInputRuleBuilder = () => ({
+	blockFence: (config) => createBlockFenceInputRule(config),
+	blockStart: (config) => createBlockStartInputRule(config),
+	insertBreak: (rule) => defineInputRule(rule),
+	insertData: (rule) => defineInputRule(rule),
+	insertText: (rule) => defineInputRule(rule),
+	mark: (config) => createMarkInputRule(config)
+});
+
 //#endregion
 //#region src/internal/plugin/resolvePlugins.ts
 const resolvePlugins = (editor, plugins = [], createStore = createVanillaStore) => {
 	editor.plugins = {};
 	editor.meta.pluginList = [];
+	editor.meta.inputRules = {
+		insertBreak: [],
+		insertData: [],
+		insertText: {
+			all: [],
+			byTrigger: {}
+		},
+		plugins: {}
+	};
 	editor.meta.shortcuts = {};
 	editor.meta.components = {};
 	editor.meta.pluginCache = {
@@ -435,6 +825,8 @@ const resolvePlugins = (editor, plugins = [], createStore = createVanillaStore)
 		if (plugin.handlers?.onTextChange) editor.meta.pluginCache.handlers.onTextChange.push(plugin.key);
 	});
 	resolvePluginShortcuts(editor);
+	resolvePluginInputRules(editor);
+	validateRemovedRuntimePlugins(editor);
 	return editor;
 };
 const resolvePluginStores = (editor, createStore) => {
@@ -512,6 +904,68 @@ const resolvePluginShortcuts = (editor) => {
 		});
 	});
 };
+const resolvePluginInputRules = (editor) => {
+	const resolvedMeta = {
+		insertBreak: [],
+		insertData: [],
+		insertText: {
+			all: [],
+			byTrigger: {}
+		},
+		plugins: {}
+	};
+	editor.meta.pluginList.forEach((plugin, pluginIndex) => {
+		const pluginKey = plugin.key;
+		const inputRulesDefinition = plugin.inputRules;
+		const definitionRules = typeof inputRulesDefinition === "function" ? inputRulesDefinition({ rule: createInputRuleBuilder() }) : inputRulesDefinition ?? [];
+		const configuredRules = plugin.__configuredInputRules ?? [];
+		const ruleDefinitions = [...definitionRules, ...configuredRules];
+		resolvedMeta.plugins[pluginKey] = { rules: [] };
+		ruleDefinitions.forEach((definition, ruleIndex) => {
+			if (!definition) return;
+			const mergedRule = mergePlugins({}, definition);
+			const resolvedRule = {
+				...mergedRule,
+				id: `${pluginKey}.${ruleIndex}`,
+				pluginIndex,
+				pluginKey,
+				priority: mergedRule.priority ?? plugin.priority,
+				ruleIndex
+			};
+			resolvedMeta.plugins[pluginKey].rules.push(resolvedRule);
+			if (resolvedRule.target === "insertText") {
+				const triggers = Array.isArray(resolvedRule.trigger) ? [...resolvedRule.trigger] : [resolvedRule.trigger];
+				resolvedMeta.insertText.all.push(resolvedRule);
+				triggers.forEach((trigger) => {
+					if (!resolvedMeta.insertText.byTrigger[trigger]) resolvedMeta.insertText.byTrigger[trigger] = [];
+					resolvedMeta.insertText.byTrigger[trigger].push(resolvedRule);
+				});
+			} else if (resolvedRule.target === "insertBreak") resolvedMeta.insertBreak.push(resolvedRule);
+			else if (resolvedRule.target === "insertData") resolvedMeta.insertData.push(resolvedRule);
+		});
+	});
+	const sortRules = (a, b) => {
+		if (b.priority !== a.priority) return b.priority - a.priority;
+		if (a.pluginIndex !== b.pluginIndex) return a.pluginIndex - b.pluginIndex;
+		return a.ruleIndex - b.ruleIndex;
+	};
+	resolvedMeta.insertBreak.sort(sortRules);
+	resolvedMeta.insertData.sort(sortRules);
+	resolvedMeta.insertText.all.sort(sortRules);
+	Object.values(resolvedMeta.insertText.byTrigger).forEach((rules) => {
+		rules.sort(sortRules);
+	});
+	editor.meta.inputRules = resolvedMeta;
+};
+const validateRemovedRuntimePlugins = (editor) => {
+	const hasAutoformatPlugin = !!editor.plugins.autoformat;
+	const hasResolvedInputRules = editor.meta.inputRules.insertBreak.length > 0 || editor.meta.inputRules.insertData.length > 0 || editor.meta.inputRules.insertText.all.length > 0;
+	if (hasAutoformatPlugin && hasResolvedInputRules) throw new Error([
+		"AutoformatPlugin cannot be used with plugin-owned input rules.",
+		"Remove AutoformatPlugin from your editor plugins.",
+		"Enable inputRules on the feature plugins you use instead."
+	].join(" "));
+};
 const flattenAndResolvePlugins = (editor, plugins) => {
 	const pluginMap = /* @__PURE__ */ new Map();
 	const processPlugin = (plugin) => {
@@ -643,11 +1097,11 @@ const withBreakRules = (ctx) => {
 				node: blockNode,
 				path: blockPath,
 				rule
-			})) return overridePlugin.rules.break;
+			})) return overridePlugin;
 		}
 		return null;
 	};
-	const executeBreakAction = (action, blockPath) => {
+	const executeBreakAction = (action, blockPath, type) => {
 		if (action === "reset") {
 			editor.tf.resetBlock({ at: blockPath });
 			return true;
@@ -665,30 +1119,40 @@ const withBreakRules = (ctx) => {
 			editor.tf.insertSoftBreak();
 			return true;
 		}
+		if (action === "lift" && type) return !!editor.tf.liftBlock({
+			at: blockPath,
+			match: { type }
+		});
 		return false;
 	};
 	return { transforms: { insertBreak() {
-		if (editor.selection && editor.api.isCollapsed()) {
+		if (editor.selection) {
 			const block = editor.api.block();
 			if (block) {
 				const [blockNode, blockPath] = block;
 				const breakRules = getPluginByType(editor, blockNode.type)?.rules.break;
-				if (editor.api.isEmpty(editor.selection, { block: true })) {
-					const emptyAction = (checkMatchRulesOverride("break.empty", blockNode, blockPath) || breakRules)?.empty;
-					if (executeBreakAction(emptyAction, blockPath)) return;
+				if (editor.api.isCollapsed() && editor.api.isEmpty(editor.selection, { block: true })) {
+					const overridePlugin = checkMatchRulesOverride("break.empty", blockNode, blockPath);
+					const emptyAction = (overridePlugin?.rules.break ?? breakRules)?.empty;
+					const actionType = overridePlugin?.node.type;
+					if (executeBreakAction(emptyAction, blockPath, actionType)) return;
 				}
-				if (!editor.api.isEmpty(editor.selection, { block: true }) && editor.api.isAt({ end: true })) {
+				if (editor.api.isCollapsed() && !editor.api.isEmpty(editor.selection, { block: true }) && editor.api.isAt({ end: true })) {
 					const range = editor.api.range("before", editor.selection);
 					if (range) {
 						if (editor.api.string(range) === "\n") {
-							const emptyLineEndAction = (checkMatchRulesOverride("break.emptyLineEnd", blockNode, blockPath) || breakRules)?.emptyLineEnd;
-							if (executeBreakAction(emptyLineEndAction, blockPath)) return;
+							const overridePlugin = checkMatchRulesOverride("break.emptyLineEnd", blockNode, blockPath);
+							const emptyLineEndAction = (overridePlugin?.rules.break ?? breakRules)?.emptyLineEnd;
+							const actionType = overridePlugin?.node.type;
+							if (executeBreakAction(emptyLineEndAction, blockPath, actionType)) return;
 						}
 					}
 				}
-				const defaultAction = (checkMatchRulesOverride("break.default", blockNode, blockPath) || breakRules)?.default;
-				if (executeBreakAction(defaultAction, blockPath)) return;
-				if (checkMatchRulesOverride("break.splitReset", blockNode, blockPath)?.splitReset ?? breakRules?.splitReset) {
+				const overrideDefaultPlugin = checkMatchRulesOverride("break.default", blockNode, blockPath);
+				const defaultAction = (overrideDefaultPlugin?.rules.break ?? breakRules)?.default;
+				const defaultActionType = overrideDefaultPlugin?.node.type;
+				if (executeBreakAction(defaultAction, blockPath, defaultActionType)) return;
+				if ((checkMatchRulesOverride("break.splitReset", blockNode, blockPath)?.rules.break?.splitReset ?? breakRules?.splitReset) && !editor.api.isAt({ blocks: true })) {
 					const isAtStart = editor.api.isAt({ start: true });
 					insertBreak();
 					editor.tf.resetBlock({ at: isAtStart ? blockPath : PathApi.next(blockPath) });
@@ -716,15 +1180,19 @@ const withDeleteRules = (ctx) => {
 				node: blockNode,
 				path: blockPath,
 				rule
-			})) return overridePlugin.rules.delete;
+			})) return overridePlugin;
 		}
 		return null;
 	};
-	const executeDeleteAction = (action, blockPath) => {
+	const executeDeleteAction = (action, blockPath, type) => {
 		if (action === "reset") {
 			editor.tf.resetBlock({ at: blockPath });
 			return true;
 		}
+		if (action === "lift" && type) return !!editor.tf.liftBlock({
+			at: blockPath,
+			match: { type }
+		});
 		return false;
 	};
 	return { transforms: {
@@ -735,12 +1203,16 @@ const withDeleteRules = (ctx) => {
 					const [blockNode, blockPath] = block;
 					const deleteRules = getPluginByType(editor, blockNode.type)?.rules.delete;
 					if (editor.api.isAt({ start: true })) {
-						const startAction = (checkMatchRulesOverride("delete.start", blockNode, blockPath) || deleteRules)?.start;
-						if (executeDeleteAction(startAction, blockPath)) return;
+						const overridePlugin = checkMatchRulesOverride("delete.start", blockNode, blockPath);
+						const startAction = (overridePlugin?.rules.delete ?? deleteRules)?.start;
+						const actionType = overridePlugin?.node.type;
+						if (executeDeleteAction(startAction, blockPath, actionType)) return;
 					}
 					if (editor.api.isEmpty(editor.selection, { block: true })) {
-						const emptyAction = (checkMatchRulesOverride("delete.empty", blockNode, blockPath) || deleteRules)?.empty;
-						if (executeDeleteAction(emptyAction, blockPath)) return;
+						const overridePlugin = checkMatchRulesOverride("delete.empty", blockNode, blockPath);
+						const emptyAction = (overridePlugin?.rules.delete ?? deleteRules)?.empty;
+						const actionType = overridePlugin?.node.type;
+						if (executeDeleteAction(emptyAction, blockPath, actionType)) return;
 					}
 				}
 				if (PointApi.equals(editor.selection.anchor, editor.api.start([]))) {
@@ -994,6 +1466,7 @@ const getInjectMatch = (editor, plugin) => {
 			if (targetPlugins && !targetPlugins.includes(getPluginKey(editor, element.type))) return false;
 		}
 		if (excludeBelowPlugins || maxLevel) {
+			if (!path) return false;
 			if (maxLevel && path.length > maxLevel) return false;
 			if (excludeBelowPlugins) {
 				const excludeTypes = getPluginKeys(editor, excludeBelowPlugins);
@@ -2067,6 +2540,182 @@ const LengthPlugin = createTSlatePlugin({ key: "length" }).overrideEditor(({ edi
 	});
 } } }));
 
+//#endregion
+//#region src/lib/plugins/navigation-feedback/types.ts
+const NAVIGATION_FEEDBACK_KEY = "navigationFeedback";
+const NavigationFeedbackPluginKey = { key: NAVIGATION_FEEDBACK_KEY };
+
+//#endregion
+//#region src/lib/plugins/navigation-feedback/transforms/flashTarget.ts
+const NAVIGATION_FEEDBACK_TIMEOUT = /* @__PURE__ */ new WeakMap();
+const NAVIGATION_FEEDBACK_PULSE = /* @__PURE__ */ new WeakMap();
+const NAVIGATION_FEEDBACK_ATTRIBUTES = [
+	"data-nav-cycle",
+	"data-nav-highlight",
+	"data-nav-pulse",
+	"data-nav-target"
+];
+const clearNavigationPathRef = (target) => {
+	target?.pathRef.unref();
+};
+const resolveNavigationFeedbackTarget = (target) => {
+	const path = target?.pathRef.current;
+	if (!target || !path) return null;
+	const { pathRef: _pathRef, ...rest } = target;
+	return {
+		...rest,
+		path
+	};
+};
+const getNavigationElement = (editor, target) => {
+	const node = NodeApi.get(editor, target.path);
+	if (!node) return;
+	try {
+		return editor.api.toDOMNode(node);
+	} catch {
+		return;
+	}
+};
+const clearNavigationElement = (editor, target) => {
+	if (!target) return;
+	const element = getNavigationElement(editor, target);
+	if (!element) return;
+	for (const attribute of NAVIGATION_FEEDBACK_ATTRIBUTES) element.removeAttribute(attribute);
+	element.style.removeProperty("--plate-nav-feedback-duration");
+};
+const setNavigationElement = (editor, target) => {
+	const element = getNavigationElement(editor, target);
+	if (!element) return;
+	element.setAttribute("data-nav-cycle", String(target.cycle));
+	element.setAttribute("data-nav-highlight", target.variant);
+	element.setAttribute("data-nav-pulse", String(target.pulse));
+	element.setAttribute("data-nav-target", "true");
+	element.style.setProperty("--plate-nav-feedback-duration", `${target.duration}ms`);
+};
+const clearNavigationTimeout = (editor) => {
+	const timeoutId = NAVIGATION_FEEDBACK_TIMEOUT.get(editor);
+	if (timeoutId) {
+		clearTimeout(timeoutId);
+		NAVIGATION_FEEDBACK_TIMEOUT.delete(editor);
+	}
+};
+const nextPulse = (editor) => {
+	const pulse = (NAVIGATION_FEEDBACK_PULSE.get(editor) ?? 0) + 1;
+	NAVIGATION_FEEDBACK_PULSE.set(editor, pulse);
+	return pulse;
+};
+const clearNavigationFeedbackTarget = (editor, pulse) => {
+	const storedTarget = editor.getOption(NavigationFeedbackPluginKey, "activeTarget");
+	const activeTarget = resolveNavigationFeedbackTarget(storedTarget);
+	if (!storedTarget) return false;
+	if (pulse !== void 0 && storedTarget.pulse !== pulse) return false;
+	clearNavigationTimeout(editor);
+	clearNavigationElement(editor, activeTarget);
+	clearNavigationPathRef(storedTarget);
+	editor.setOption(NavigationFeedbackPluginKey, "activeTarget", null);
+	return true;
+};
+const flashTarget = (editor, { duration, target, variant = "navigated" }) => {
+	if (!editor.api.node(target.path)) return false;
+	const pulse = nextPulse(editor);
+	const timeoutMs = duration ?? editor.getOption(NavigationFeedbackPluginKey, "duration") ?? 800;
+	const previousTarget = editor.getOption(NavigationFeedbackPluginKey, "activeTarget");
+	clearNavigationTimeout(editor);
+	clearNavigationElement(editor, resolveNavigationFeedbackTarget(previousTarget));
+	clearNavigationPathRef(previousTarget);
+	const pathRef = editor.api.pathRef(target.path);
+	const activeTarget = {
+		cycle: pulse % 2,
+		duration: timeoutMs,
+		pathRef,
+		pulse,
+		type: target.type,
+		variant
+	};
+	editor.setOption(NavigationFeedbackPluginKey, "activeTarget", activeTarget);
+	setNavigationElement(editor, resolveNavigationFeedbackTarget(activeTarget) ?? {
+		cycle: activeTarget.cycle,
+		duration: activeTarget.duration,
+		path: target.path,
+		pulse: activeTarget.pulse,
+		type: activeTarget.type,
+		variant: activeTarget.variant
+	});
+	const timeoutId = setTimeout(() => {
+		clearNavigationFeedbackTarget(editor, pulse);
+	}, timeoutMs);
+	NAVIGATION_FEEDBACK_TIMEOUT.set(editor, timeoutId);
+	return true;
+};
+
+//#endregion
+//#region src/lib/plugins/navigation-feedback/transforms/navigate.ts
+const getScrollTarget = (editor, { scrollTarget, select, target }) => {
+	if (scrollTarget) return scrollTarget;
+	if (select && "focus" in select && select.focus) return select.focus;
+	if (select && "anchor" in select && select.anchor) return select.anchor;
+	if (select && "path" in select) return select;
+	return editor.api.start(target.path);
+};
+const navigate = (editor, { flash, focus = true, scroll = true, scrollTarget, select, target }) => {
+	if (!editor.api.node(target.path)) return false;
+	if (select) if ("focus" in select) editor.tf.select(select);
+	else editor.tf.select({
+		anchor: select,
+		focus: select
+	});
+	if (focus) editor.tf.focus();
+	if (scroll) {
+		const point = getScrollTarget(editor, {
+			flash,
+			focus,
+			scroll,
+			scrollTarget,
+			select,
+			target
+		});
+		if (point) editor.api.scrollIntoView(point);
+	}
+	if (flash !== false) flashTarget(editor, {
+		duration: flash?.duration,
+		target,
+		variant: flash?.variant
+	});
+	return true;
+};
+
+//#endregion
+//#region src/lib/plugins/navigation-feedback/NavigationFeedbackPlugin.ts
+const NavigationFeedbackPlugin = createTSlatePlugin({
+	key: NAVIGATION_FEEDBACK_KEY,
+	options: {
+		activeTarget: null,
+		duration: 1600
+	}
+}).extendEditorApi(({ editor }) => {
+	const getActiveTarget = () => {
+		const storedTarget = editor.getOption(NavigationFeedbackPluginKey, "activeTarget");
+		const activeTarget = resolveNavigationFeedbackTarget(storedTarget);
+		if (!activeTarget && storedTarget) {
+			clearNavigationFeedbackTarget(editor);
+			return null;
+		}
+		return activeTarget;
+	};
+	return { navigation: {
+		activeTarget: getActiveTarget,
+		clear: () => clearNavigationFeedbackTarget(editor),
+		isTarget: (path) => {
+			const activeTarget = getActiveTarget();
+			return !!activeTarget && PathApi.equals(activeTarget.path, path);
+		}
+	} };
+}).extendEditorTransforms(({ editor }) => ({ navigation: {
+	clear: () => clearNavigationFeedbackTarget(editor),
+	flashTarget: (options) => flashTarget(editor, options),
+	navigate: (options) => navigate(editor, options)
+} }));
+
 //#endregion
 //#region src/lib/plugins/node-id/withNodeId.ts
 /** Enables support for inserting nodes with an id key. */
@@ -2402,6 +3051,31 @@ const insertExitBreak = (editor, { match, reverse } = {}) => {
 	return true;
 };
 
+//#endregion
+//#region src/lib/plugins/slate-extension/transforms/liftBlock.ts
+/**
+* Lift the current block out of the nearest matching ancestor container.
+*
+* This unwraps only the current block and splits the ancestor around it when
+* needed, so one keypress changes one structural level instead of exploding the
+* whole container.
+*/
+const liftBlock = (editor, { at, match } = {}) => {
+	const block = editor.api.block({ at });
+	if (!block || !match) return;
+	const [, blockPath] = block;
+	if (!editor.api.above({
+		at: blockPath,
+		match: combineMatchOptions(editor, (_node, path) => path.length < blockPath.length, { match })
+	})) return;
+	editor.tf.unwrapNodes({
+		at: blockPath,
+		match,
+		split: true
+	});
+	return true;
+};
+
 //#endregion
 //#region src/lib/plugins/slate-extension/transforms/resetBlock.ts
 /**
@@ -2439,25 +3113,27 @@ const setValue = (editor, value) => {
 
 //#endregion
 //#region src/lib/plugins/slate-extension/SlateExtensionPlugin.ts
+const NOOP_ON_NODE_CHANGE = () => {};
+const NOOP_ON_TEXT_CHANGE = () => {};
 /** Opinionated extension of slate default behavior. */
 const SlateExtensionPlugin = createTSlatePlugin({
 	api: { redecorate: () => {} },
 	key: "slateExtension",
 	options: {
-		onNodeChange: () => {},
-		onTextChange: () => {}
+		onNodeChange: NOOP_ON_NODE_CHANGE,
+		onTextChange: NOOP_ON_TEXT_CHANGE
 	}
 }).extendEditorTransforms(({ editor, getOption, tf }) => {
 	const apply = tf?.apply ?? editor.tf.apply;
 	return {
 		init: bindFirst(init, editor),
 		insertExitBreak: bindFirst(insertExitBreak, editor),
+		liftBlock: bindFirst(liftBlock, editor),
 		resetBlock: bindFirst(resetBlock, editor),
 		setValue: bindFirst(setValue, editor),
 		apply(operation) {
-			const noop = () => {};
-			const hasNodeHandlers = editor.meta.pluginCache.handlers.onNodeChange.length > 0 || getOption("onNodeChange") !== noop;
-			const hasTextHandlers = editor.meta.pluginCache.handlers.onTextChange.length > 0 || getOption("onTextChange") !== noop;
+			const hasNodeHandlers = editor.meta.pluginCache.handlers.onNodeChange.length > 0 || getOption("onNodeChange") !== NOOP_ON_NODE_CHANGE;
+			const hasTextHandlers = editor.meta.pluginCache.handlers.onTextChange.length > 0 || getOption("onTextChange") !== NOOP_ON_TEXT_CHANGE;
 			if (!hasNodeHandlers && !hasTextHandlers) {
 				apply(operation);
 				return;
@@ -2655,16 +3331,159 @@ const ParserPlugin = createSlatePlugin({ key: "parser" }).overrideEditor(({ edit
 	insertData(dataTransfer);
 } } }));
 
+//#endregion
+//#region src/lib/plugins/input-rules/internal/InputRulesPlugin.ts
+const createCachedGetter = (compute) => {
+	let hasValue = false;
+	let value;
+	return () => {
+		if (!hasValue) {
+			value = compute();
+			hasValue = true;
+		}
+		return value;
+	};
+};
+const createSelectionContext = ({ editor }) => {
+	const { selection } = editor;
+	const isCollapsed = !!selection && editor.api.isCollapsed();
+	const getBlockStartRange = createCachedGetter(() => {
+		if (!selection) return;
+		return editor.api.range("start", selection);
+	});
+	const getBlockStartText = createCachedGetter(() => {
+		const range = getBlockStartRange();
+		return range ? editor.api.string(range) : void 0;
+	});
+	return {
+		editor,
+		getBlockEntry: createCachedGetter(() => {
+			if (!selection) return;
+			return editor.api.block({ at: selection });
+		}),
+		getBlockStartRange,
+		getBlockStartText,
+		getBlockTextBeforeSelection: createCachedGetter(() => getBlockStartText() ?? ""),
+		getCharAfter: createCachedGetter(() => {
+			if (!selection || !isCollapsed) return;
+			const afterPoint = editor.api.after(selection, {
+				distance: 1,
+				unit: "character"
+			});
+			if (!afterPoint) return;
+			return editor.api.string({
+				anchor: selection.anchor,
+				focus: afterPoint
+			}) || void 0;
+		}),
+		getCharBefore: createCachedGetter(() => {
+			if (!selection || !isCollapsed) return;
+			const beforePoint = editor.api.before(selection, {
+				distance: 1,
+				unit: "character"
+			});
+			if (!beforePoint) return;
+			return editor.api.string({
+				anchor: beforePoint,
+				focus: selection.anchor
+			}) || void 0;
+		}),
+		isCollapsed
+	};
+};
+const isTriggerMatch = (trigger, text) => Array.isArray(trigger) ? trigger.includes(text) : trigger === text;
+const InputRulesPlugin = createTSlatePlugin({
+	editOnly: true,
+	key: "inputRules"
+}).overrideEditor(({ editor, tf: { insertBreak, insertData, insertText } }) => ({ transforms: {
+	insertBreak() {
+		const selectionContext = createSelectionContext({ editor });
+		let handled = false;
+		for (const rule of editor.meta.inputRules.insertBreak) {
+			const context = {
+				cause: "insertBreak",
+				insertBreak,
+				pluginKey: rule.pluginKey,
+				...selectionContext
+			};
+			if (rule.enabled?.(context) === false) continue;
+			const match = rule.resolve ? rule.resolve(context) : true;
+			if (match === void 0) continue;
+			if (rule.apply(context, match) !== false) {
+				handled = true;
+				break;
+			}
+		}
+		if (handled) return;
+		insertBreak();
+	},
+	insertData(data) {
+		const text = data.getData("text/plain") || null;
+		const selectionContext = createSelectionContext({ editor });
+		let handled = false;
+		for (const rule of editor.meta.inputRules.insertData) {
+			const context = {
+				cause: "insertData",
+				data,
+				insertData,
+				pluginKey: rule.pluginKey,
+				text,
+				...selectionContext
+			};
+			if (rule.enabled?.(context) === false) continue;
+			if (rule.mimeTypes && rule.mimeTypes.length > 0 && !rule.mimeTypes.some((type) => !!context.data.getData(type))) continue;
+			const match = rule.resolve ? rule.resolve(context) : true;
+			if (match === void 0) continue;
+			if (rule.apply(context, match) !== false) {
+				handled = true;
+				break;
+			}
+		}
+		if (handled) return;
+		insertData(data);
+	},
+	insertText(text, options) {
+		const rules = editor.meta.inputRules.insertText.byTrigger[text] ?? [];
+		const selectionContext = createSelectionContext({ editor });
+		let handled = false;
+		for (const rule of rules) {
+			const context = {
+				cause: "insertText",
+				insertText,
+				options,
+				pluginKey: rule.pluginKey,
+				text,
+				...selectionContext
+			};
+			if (!isTriggerMatch(rule.trigger, context.text)) continue;
+			if (rule.enabled?.(context) === false) continue;
+			const match = rule.resolve ? rule.resolve(context) : true;
+			if (match === void 0) continue;
+			if (rule.apply(context, match) !== false) {
+				handled = true;
+				break;
+			}
+		}
+		if (handled) return;
+		insertText(text, options);
+	}
+} }));
+
 //#endregion
 //#region src/lib/plugins/getCorePlugins.ts
-const getCorePlugins = ({ affinity, chunking, maxLength, nodeId, plugins = [] }) => {
+const getCorePlugins = ({ affinity, chunking, maxLength, navigationFeedback, nodeId, plugins = [] }) => {
 	let resolvedNodeId = nodeId;
 	if (process.env.NODE_ENV === "test" && nodeId === void 0) resolvedNodeId = false;
 	let corePlugins = [
 		DebugPlugin,
 		SlateExtensionPlugin,
 		DOMPlugin,
+		NavigationFeedbackPlugin.configure({
+			enabled: navigationFeedback !== false,
+			options: typeof navigationFeedback === "boolean" ? void 0 : navigationFeedback
+		}),
 		HistoryPlugin,
+		InputRulesPlugin,
 		OverridePlugin,
 		ParserPlugin,
 		maxLength ? LengthPlugin.configure({ options: { maxLength } }) : LengthPlugin,
@@ -2707,7 +3526,7 @@ const getCorePlugins = ({ affinity, chunking, maxLength, nodeId, plugins = [] })
 * @see {@link usePlateEditor} for a memoized React version.
 * @see {@link withPlate} for the React-specific enhancement function.
 */
-const withSlate = (e, { id, affinity = true, autoSelect, chunking = true, maxLength, nodeId, optionsStoreFactory, plugins = [], readOnly = false, rootPlugin, selection, shouldNormalizeEditor, skipInitialization, userId, value, onReady, ...pluginConfig } = {}) => {
+const withSlate = (e, { id, affinity = true, autoSelect, chunking = true, maxLength, navigationFeedback, nodeId, optionsStoreFactory, plugins = [], readOnly = false, rootPlugin, selection, shouldNormalizeEditor, skipInitialization, userId, value, onReady, ...pluginConfig } = {}) => {
 	const editor = e;
 	editor.id = id ?? editor.id ?? nanoid();
 	editor.meta.key = editor.meta.key ?? nanoid();
@@ -2765,6 +3584,7 @@ const withSlate = (e, { id, affinity = true, autoSelect, chunking = true, maxLen
 		affinity,
 		chunking,
 		maxLength,
+		navigationFeedback,
 		nodeId,
 		plugins
 	});
@@ -2837,4 +3657,4 @@ const withSlate = (e, { id, affinity = true, autoSelect, chunking = true, maxLen
 const createSlateEditor = ({ editor = createEditor(), ...options } = {}) => withSlate(editor, options);
 
 //#endregion
-export { DebugPlugin as $, pluginDeserializeHtml as A, withNormalizeRules as At, collapseWhiteSpaceText as B, getPluginKey as Bt, deserializeHtmlElement as C, isSlatePluginNode as Ct, pipeDeserializeHtmlLeaf as D, applyDeepToNodes as Dt, htmlElementToLeaf as E, isSlateVoid as Et, collapseWhiteSpace as F, HistoryPlugin as Ft, isHtmlBlockElement as G, getEditorPlugin as Gt, upsertInlineFormattingContext as H, getPluginType as Ht, collapseWhiteSpaceElement as I, withPlateHistory as It, isHtmlText as J, isHtmlInlineElement as K, createSlatePlugin as Kt, inferWhiteSpaceRule as L, AstPlugin as Lt, htmlBrToNewLine as M, withDeleteRules as Mt, htmlBodyToFragment as N, withBreakRules as Nt, htmlElementToElement as O, OverridePlugin as Ot, deserializeHtmlNodeChildren as P, BaseParagraphPlugin as Pt, withScrolling as Q, collapseWhiteSpaceChildren as R, getContainerTypes as Rt, htmlStringToDOMNode as S, isSlatePluginElement as St, htmlTextNodeToString as T, isSlateText as Tt, isLastNonEmptyTextOfInlineFormattingContext as U, getPluginTypes as Ut, endInlineFormattingContext as V, getPluginKeys as Vt, collapseString as W, getSlatePlugin as Wt, AUTO_SCROLL as X, isHtmlElement as Y, DOMPlugin as Z, withNodeId as _, getSlateElements as _t, pipeInsertDataQuery as a, isNodeAffinity as at, parseHtmlDocument as b, isSlateLeaf as bt, setValue as c, getEdgeNodes as ct, init as d, getPluginNodeProps as dt, PlateError as et, isEditOnly as f, getNodeDataAttributeKeys as ft, normalizeNodeId as g, defaultsDeepToNodes as gt, NodeIdPlugin as h, getInjectMatch as ht, ParserPlugin as i, setAffinitySelection as it, getDataNodeProps as j, withMergeRules as jt, pipeDeserializeHtmlElement as k, withOverrides as kt, resetBlock as l, mergeDeepToNodes as lt, pipeOnNodeChange as m, getInjectedPlugins as mt, withSlate as n, withChunking as nt, normalizeDescendantsToDocumentFragment as o, isNodesAffinity as ot, pipeOnTextChange as p, keyToDataAttribute as pt, inlineTagNames as q, createTSlatePlugin as qt, getCorePlugins as r, AffinityPlugin as rt, SlateExtensionPlugin as s, getMarkBoundaryAffinity as st, createSlateEditor as t, ChunkingPlugin as tt, insertExitBreak as u, getSlateClass as ut, LengthPlugin as v, isSlateEditor as vt, deserializeHtmlNode as w, isSlateString as wt, deserializeHtml as x, isSlateNode as xt, HtmlPlugin as y, isSlateElement as yt, collapseWhiteSpaceNode as z, getPluginByType as zt };
+export { isHtmlBlockElement as $, defineInputRule as $t, htmlStringToDOMNode as A, isSlatePluginElement as At, htmlBrToNewLine as B, withDeleteRules as Bt, resolveNavigationFeedbackTarget as C, getInjectMatch as Ct, HtmlPlugin as D, isSlateElement as Dt, LengthPlugin as E, isSlateEditor as Et, pipeDeserializeHtmlLeaf as F, applyDeepToNodes as Ft, inferWhiteSpaceRule as G, AstPlugin as Gt, deserializeHtmlNodeChildren as H, BaseParagraphPlugin as Ht, htmlElementToElement as I, OverridePlugin as It, collapseWhiteSpaceText as J, createMarkInputRule as Jt, collapseWhiteSpaceChildren as K, createBlockFenceInputRule as Kt, pipeDeserializeHtmlElement as L, withOverrides as Lt, deserializeHtmlNode as M, isSlateString as Mt, htmlTextNodeToString as N, isSlateText as Nt, parseHtmlDocument as O, isSlateLeaf as Ot, htmlElementToLeaf as P, isSlateVoid as Pt, collapseString as Q, matchDelimitedInline as Qt, pluginDeserializeHtml as R, withNormalizeRules as Rt, flashTarget as S, getInjectedPlugins as St, NavigationFeedbackPluginKey as T, getSlateElements as Tt, collapseWhiteSpace as U, HistoryPlugin as Ut, htmlBodyToFragment as V, withBreakRules as Vt, collapseWhiteSpaceElement as W, withPlateHistory as Wt, upsertInlineFormattingContext as X, matchBlockFence as Xt, endInlineFormattingContext as Y, createTextSubstitutionInputRule as Yt, isLastNonEmptyTextOfInlineFormattingContext as Z, matchBlockStart as Zt, normalizeNodeId as _, mergeDeepToNodes as _t, pipeInsertDataQuery as a, getPluginTypes as an, DOMPlugin as at, navigate as b, getNodeDataAttributeKeys as bt, setValue as c, createSlatePlugin as cn, PlateError as ct, insertExitBreak as d, AffinityPlugin as dt, getContainerTypes as en, isHtmlInlineElement as et, init as f, setAffinitySelection as ft, NodeIdPlugin as g, getEdgeNodes as gt, pipeOnNodeChange as h, getMarkBoundaryAffinity as ht, ParserPlugin as i, getPluginType as in, AUTO_SCROLL as it, deserializeHtmlElement as j, isSlatePluginNode as jt, deserializeHtml as k, isSlateNode as kt, resetBlock as l, createTSlatePlugin as ln, ChunkingPlugin as lt, pipeOnTextChange as m, isNodesAffinity as mt, withSlate as n, getPluginKey as nn, isHtmlText as nt, normalizeDescendantsToDocumentFragment as o, getSlatePlugin as on, withScrolling as ot, isEditOnly as p, isNodeAffinity as pt, collapseWhiteSpaceNode as q, createBlockStartInputRule as qt, getCorePlugins as r, getPluginKeys as rn, isHtmlElement as rt, SlateExtensionPlugin as s, getEditorPlugin as sn, DebugPlugin as st, createSlateEditor as t, getPluginByType as tn, inlineTagNames as tt, liftBlock as u, withChunking as ut, withNodeId as v, getSlateClass as vt, NAVIGATION_FEEDBACK_KEY as w, defaultsDeepToNodes as wt, clearNavigationFeedbackTarget as x, keyToDataAttribute as xt, NavigationFeedbackPlugin as y, getPluginNodeProps as yt, getDataNodeProps as z, withMergeRules as zt };