@stll/folio-core 0.53.0 → 0.54.1

package/dist/prosemirror/plugins/documentStyleState.js

@@ -0,0 +1,32 @@
+import { EMPTY_BUILT_IN_STYLE_INDEX } from "../../docx/builtInStyles.js";
+import { PluginKey } from "prosemirror-state";
+//#region src/prosemirror/plugins/documentStyleState.ts
+const documentStylesKey = new PluginKey("documentStyles");
+/** Read the document's StyleResolver, or null when the plugin isn't installed. */
+function getDocumentStyleResolver(state) {
+	return documentStylesKey.getState(state) ?? null;
+}
+/**
+* The document's style definitions by id, or `null` when the state carries no
+* styles plugin and so cannot say what the document defines. A document
+* without a styles part defines none.
+*/
+function getDocumentStyleDefinitions(state) {
+	if (documentStylesKey.get(state) === void 0) return null;
+	const resolver = getDocumentStyleResolver(state);
+	return {
+		get: (styleId) => resolver?.getStyle(styleId),
+		paragraphStyles: () => resolver?.getParagraphStyles() ?? []
+	};
+}
+/**
+* Read the document's built-in style index, for the callers that classify
+* paragraphs (heading collection, markdown export, the AI snapshot). Without
+* the plugin every lookup misses, which degrades classification to the
+* paragraph's own outline level rather than to English style ids.
+*/
+function getDocumentBuiltInStyles(state) {
+	return getDocumentStyleResolver(state)?.builtInStyles ?? EMPTY_BUILT_IN_STYLE_INDEX;
+}
+//#endregion
+export { documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleDefinitions, getDocumentStyleResolver };

package/dist/prosemirror/plugins/documentStyles.d.ts

@@ -1,9 +1,8 @@
 import { document_d_exports } from "../../types/document.js";
-import { BuiltInStyleIndex } from "../../docx/builtInStyles.js";
 import { StyleResolver } from "../styles/styleResolver.js";
-import { EditorState, Plugin, PluginKey } from "prosemirror-state";
+import { documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleDefinitions, getDocumentStyleResolver } from "./documentStyleState.js";
+import { EditorState, Plugin } from "prosemirror-state";
 //#region src/prosemirror/plugins/documentStyles.d.ts
-declare const documentStylesKey: PluginKey<StyleResolver | null>;
 /**
  * Create the plugin holding a StyleResolver for the document's `styles` for
  * the lifetime of the EditorState. The resolver is fixed per document load;
@@ -12,24 +11,6 @@ declare const documentStylesKey: PluginKey<StyleResolver | null>;
  * have one.
  */
 declare function createDocumentStylesPlugin(styles: document_d_exports.StyleDefinitions | StyleResolver | null | undefined): Plugin;
-/** Read the document's StyleResolver, or null when the plugin isn't installed. */
-declare function getDocumentStyleResolver(state: EditorState): StyleResolver | null;
-/**
- * The document's style definitions by id, or `null` when the state carries no
- * styles plugin and so cannot say what the document defines. A document
- * without a styles part defines none.
- */
-declare function getDocumentStyleDefinitions(state: EditorState): {
-  get: (styleId: string) => document_d_exports.Style | undefined;
-  paragraphStyles: () => document_d_exports.Style[];
-} | null;
-/**
- * Read the document's built-in style index, for the callers that classify
- * paragraphs (heading collection, markdown export, the AI snapshot). Without
- * the plugin every lookup misses, which degrades classification to the
- * paragraph's own outline level rather than to English style ids.
- */
-declare function getDocumentBuiltInStyles(state: EditorState): BuiltInStyleIndex;
 /** Reconfigure so ProseMirror replaces the keyed plugin's resolver state. */
 declare const withDocumentStyles: (state: EditorState, styles: document_d_exports.StyleDefinitions | StyleResolver | null | undefined) => EditorState;
 //#endregion

package/dist/prosemirror/plugins/documentStyles.js

@@ -1,6 +1,13 @@
-import { EMPTY_BUILT_IN_STYLE_INDEX } from "../../docx/builtInStyles.js";
+import "../extensions/features/JoinedRunStyleExtension.js";
+import { rebaseParagraphRuns } from "../rebaseParagraphRuns.js";
 import { StyleResolver, createStyleResolver } from "../styles/styleResolver.js";
-import { Plugin, PluginKey } from "prosemirror-state";
+import { getDocumentNumbering } from "./documentNumbering.js";
+import { documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleDefinitions, getDocumentStyleResolver } from "./documentStyleState.js";
+import { resolveEditedParagraphStyles } from "./paragraphStyleResolution.js";
+import { Mark } from "prosemirror-model";
+import { Mapping, ReplaceStep } from "prosemirror-transform";
+import { Plugin } from "prosemirror-state";
+import { isHistoryTransaction } from "prosemirror-history";
 //#region src/prosemirror/plugins/documentStyles.ts
 /**
 * documentStyles plugin — makes the document's StyleResolver reachable from
@@ -18,7 +25,57 @@ import { Plugin, PluginKey } from "prosemirror-state";
 * EditorState. When absent, style-aware commands fall back to their
 * style-agnostic behavior.
 */
-const documentStylesKey = new PluginKey("documentStyles");
+/** Rebase surviving right-hand runs when ordinary replacement steps consume a paragraph opening. */
+const rebaseEditedParagraphJoins = (transactions, tr, resolver) => {
+	const maps = transactions.flatMap((transaction) => transaction.mapping.maps);
+	let offset = 0;
+	for (const transaction of transactions) {
+		if (isHistoryTransaction(transaction) || transaction.getMeta("joinedRunsRestyled") === true || !transaction.steps.every((step) => step instanceof ReplaceStep)) {
+			offset += transaction.steps.length;
+			continue;
+		}
+		for (const [index, step] of transaction.steps.entries()) {
+			const before = transaction.docs[index];
+			if (!before) continue;
+			const map = step.getMap();
+			const mapping = new Mapping([map, ...new Mapping(maps.slice(offset + index + 1)).maps]);
+			map.forEach((oldFrom, oldTo) => {
+				before.nodesBetween(oldFrom, oldTo, (paragraph, position) => {
+					if (paragraph.type.name !== "paragraph") return true;
+					if (!map.mapResult(position, 1).deleted) return false;
+					const from = mapping.map(position + 1, 1);
+					const to = mapping.map(position + paragraph.nodeSize - 1, -1);
+					if (from >= to) return false;
+					const at = tr.doc.resolve(from);
+					if (at.parent.type.name !== "paragraph") return false;
+					const targetPosition = at.start() - 1;
+					if (targetPosition === mapping.map(position, 1)) return false;
+					const surviving = tr.doc.nodeAt(from);
+					const original = before.nodeAt(mapping.invert().map(from, 1));
+					if (!surviving || !original || !Mark.sameSet(surviving.marks, original.marks)) return false;
+					rebaseParagraphRuns({
+						tr,
+						position: targetPosition,
+						previous: paragraph,
+						styleResolver: resolver,
+						range: {
+							from,
+							to
+						}
+					});
+					return false;
+				});
+			});
+		}
+		offset += transaction.steps.length;
+	}
+};
+let bareStyleResolver;
+/** The cascade of a package that defines no styles: docDefaults-free built-ins. */
+const bareResolver = () => {
+	bareStyleResolver ??= createStyleResolver(void 0);
+	return bareStyleResolver;
+};
 /**
 * Create the plugin holding a StyleResolver for the document's `styles` for
 * the lifetime of the EditorState. The resolver is fixed per document load;
@@ -36,35 +93,15 @@ function createDocumentStylesPlugin(styles) {
 		state: {
 			init: () => resolver,
 			apply: (_tr, value) => value
+		},
+		appendTransaction: (transactions, _oldState, newState) => {
+			const styleResolver = documentStylesKey.getState(newState) ?? bareResolver();
+			const tr = resolveEditedParagraphStyles(transactions, newState, styleResolver, () => getDocumentNumbering(newState)) ?? newState.tr;
+			rebaseEditedParagraphJoins(transactions, tr, styleResolver);
+			return tr.docChanged ? tr : null;
 		}
 	});
 }
-/** Read the document's StyleResolver, or null when the plugin isn't installed. */
-function getDocumentStyleResolver(state) {
-	return documentStylesKey.getState(state) ?? null;
-}
-/**
-* The document's style definitions by id, or `null` when the state carries no
-* styles plugin and so cannot say what the document defines. A document
-* without a styles part defines none.
-*/
-function getDocumentStyleDefinitions(state) {
-	if (documentStylesKey.get(state) === void 0) return null;
-	const resolver = getDocumentStyleResolver(state);
-	return {
-		get: (styleId) => resolver?.getStyle(styleId),
-		paragraphStyles: () => resolver?.getParagraphStyles() ?? []
-	};
-}
-/**
-* Read the document's built-in style index, for the callers that classify
-* paragraphs (heading collection, markdown export, the AI snapshot). Without
-* the plugin every lookup misses, which degrades classification to the
-* paragraph's own outline level rather than to English style ids.
-*/
-function getDocumentBuiltInStyles(state) {
-	return getDocumentStyleResolver(state)?.builtInStyles ?? EMPTY_BUILT_IN_STYLE_INDEX;
-}
 /** Reconfigure so ProseMirror replaces the keyed plugin's resolver state. */
 const withDocumentStyles = (state, styles) => {
 	const previous = documentStylesKey.get(state);

package/dist/prosemirror/plugins/index.d.ts

@@ -1,3 +1,4 @@
 import { SelectionChangeCallback, SelectionContext, createSelectionTrackerPlugin, extractSelectionContext, getSelectionContext, selectionTrackerKey } from "./selectionTracker.js";
-import { createDocumentStylesPlugin, documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleResolver } from "./documentStyles.js";
+import { documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleResolver } from "./documentStyleState.js";
+import { createDocumentStylesPlugin } from "./documentStyles.js";
 export { type SelectionChangeCallback, type SelectionContext, createDocumentStylesPlugin, createSelectionTrackerPlugin, documentStylesKey, extractSelectionContext, getDocumentBuiltInStyles, getDocumentStyleResolver, getSelectionContext, selectionTrackerKey };

package/dist/prosemirror/plugins/index.js

@@ -1,3 +1,4 @@
-import { createDocumentStylesPlugin, documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleResolver } from "./documentStyles.js";
+import { documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleResolver } from "./documentStyleState.js";
+import { createDocumentStylesPlugin } from "./documentStyles.js";
 import { createSelectionTrackerPlugin, extractSelectionContext, getSelectionContext, selectionTrackerKey } from "./selectionTracker.js";
 export { createDocumentStylesPlugin, createSelectionTrackerPlugin, documentStylesKey, extractSelectionContext, getDocumentBuiltInStyles, getDocumentStyleResolver, getSelectionContext, selectionTrackerKey };

package/dist/prosemirror/plugins/paragraphStyleResolution.d.ts

@@ -0,0 +1,15 @@
+import { StyleEngine } from "../../style-engine/styleEngine.js";
+import "../../style-engine/index.js";
+import { NumberingMap } from "../../docx/numberingParser.js";
+import { ParagraphCascadeResolver } from "../styles/paragraphStyleCascade.js";
+import { EditorState, Transaction } from "prosemirror-state";
+//#region src/prosemirror/plugins/paragraphStyleResolution.d.ts
+type ParagraphStyleResolver = ParagraphCascadeResolver & Pick<StyleEngine, "getDefaultTableStyle">;
+/**
+ * Project the style cascade onto every paragraph the transactions touched
+ * that has not been projected yet. Returns the transaction to append, or null
+ * when every touched paragraph already reads as a reopened document would.
+ */
+declare const resolveEditedParagraphStyles: (transactions: readonly Transaction[], state: EditorState, resolver: ParagraphStyleResolver, numbering: () => NumberingMap | null) => Transaction | null;
+//#endregion
+export { resolveEditedParagraphStyles };

package/dist/prosemirror/plugins/paragraphStyleResolution.js

@@ -0,0 +1,230 @@
+import { resolveTableLook } from "../../docx/tableLook.js";
+import { tableOfContentsStyleLevel } from "../../utils/tableOfContentsStyle.js";
+import { expectParagraphAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs } from "../attrs/index.js";
+import { setAutospacingBaseValue } from "../autospacingBase.js";
+import { directionToAuthoredBidi } from "../paragraphDirection.js";
+import { paragraphStyleCascadeAttrs, tableCellParagraphOverlay } from "../styles/paragraphStyleCascade.js";
+import { listAttrsFromResolvedStyle } from "../styles/resolvedStyleAttrs.js";
+import { tableCellStyleRegions, tableRowBand } from "../styles/tableStyleRegions.js";
+import { TableMap } from "prosemirror-tables";
+import { Mapping } from "prosemirror-transform";
+import { isHistoryTransaction } from "prosemirror-history";
+//#region src/prosemirror/plugins/paragraphStyleResolution.ts
+/** The ranges of `doc` the given transactions changed, in its own positions. */
+const changedRanges = (transactions) => {
+	const ranges = [];
+	const maps = transactions.flatMap((transaction) => transaction.mapping.maps);
+	let offset = 0;
+	for (const transaction of transactions) {
+		const own = transaction.mapping.maps.length;
+		if (transaction.docChanged && !isHistoryTransaction(transaction)) for (const [index, map] of transaction.mapping.maps.entries()) {
+			const following = new Mapping(maps.slice(offset + index + 1));
+			map.forEach((_oldFrom, _oldTo, from, to) => {
+				ranges.push([following.map(from, -1), following.map(to, 1)]);
+			});
+		}
+		offset += own;
+	}
+	return ranges;
+};
+/**
+* What the paragraph states itself, as the cascade reads it: every attr the
+* node holds a value for. Only called for paragraphs the load path never
+* projected, whose attrs hold nothing inherited yet.
+*/
+const statedFormatting = (attrs) => {
+	const formatting = {};
+	const copy = (key) => {
+		const value = attrs[key];
+		if (value !== null && value !== void 0) Reflect.set(formatting, key, value);
+	};
+	copy("alignment");
+	copy("spaceBefore");
+	copy("spaceAfter");
+	copy("lineSpacing");
+	copy("lineSpacingRule");
+	copy("snapToGrid");
+	copy("indentLeft");
+	copy("indentRight");
+	copy("indentFirstLine");
+	if (attrs.indentFirstLine !== null && attrs.indentFirstLine !== void 0) copy("hangingIndent");
+	copy("borders");
+	copy("shading");
+	copy("tabs");
+	copy("kinsoku");
+	copy("overflowPunctuation");
+	copy("suppressAutoHyphens");
+	copy("pageBreakBefore");
+	copy("keepNext");
+	copy("keepLines");
+	copy("widowControl");
+	copy("contextualSpacing");
+	copy("runInWithNext");
+	copy("outlineLevel");
+	copy("numPr");
+	const bidi = directionToAuthoredBidi(attrs.direction);
+	if (bidi !== void 0) formatting.bidi = bidi;
+	return formatting;
+};
+const isUnset = (value) => value === null || value === void 0;
+/**
+* The attrs the cascade supplies that `paragraph` leaves unset, or null when
+* it already reads the way a reopened document would.
+*/
+const cascadePatch = (node, resolver, tableParagraphOverlay, numbering) => {
+	const attrs = expectParagraphAttrs(node);
+	const styleId = attrs.styleId ?? void 0;
+	const { attrs: cascade, stylePpr } = paragraphStyleCascadeAttrs({
+		styleId,
+		formatting: statedFormatting(attrs),
+		styleResolver: resolver,
+		tableParagraphOverlay,
+		includeParagraphMarkRunProperties: false
+	});
+	const patch = {};
+	const fill = (key) => {
+		const value = cascade[key];
+		if (!isUnset(value) && isUnset(attrs[key])) patch[key] = value;
+	};
+	const lineProvenance = attrs.lineSpacingExplicit;
+	const filledSides = {
+		before: !attrs.spacingExplicit?.before && isUnset(attrs.spaceBefore),
+		after: !attrs.spacingExplicit?.after && isUnset(attrs.spaceAfter)
+	};
+	if (filledSides.before) fill("spaceBefore");
+	if (filledSides.after) fill("spaceAfter");
+	if (lineProvenance !== "value" && lineProvenance !== "both" && lineProvenance !== true) fill("lineSpacing");
+	if (lineProvenance !== "rule" && lineProvenance !== "both" && lineProvenance !== true) fill("lineSpacingRule");
+	for (const key of ["spacingFromDocDefaults", "spacingFromImplicitDefaultStyle"]) {
+		const inherited = cascade[key];
+		const side = {
+			...inherited?.before && filledSides.before ? { before: true } : {},
+			...inherited?.after && filledSides.after ? { after: true } : {}
+		};
+		if (side.before || side.after) patch[key] = {
+			...attrs[key],
+			...side
+		};
+	}
+	if (isUnset(attrs.indentFirstLine) && attrs.hangingIndent !== true) {
+		fill("indentFirstLine");
+		if (cascade.hangingIndent === true) patch.hangingIndent = true;
+	}
+	for (const key of [
+		"alignment",
+		"alignmentFromStyle",
+		"_resolvedFormatting",
+		"snapToGrid",
+		"indentLeft",
+		"indentRight",
+		"borders",
+		"shading",
+		"tabs",
+		"kinsoku",
+		"overflowPunctuation",
+		"suppressAutoHyphens",
+		"pageBreakBefore",
+		"keepNext",
+		"keepLines",
+		"widowControl",
+		"contextualSpacing",
+		"runInWithNext",
+		"outlineLevel",
+		"direction",
+		"defaultTextFormatting"
+	]) fill(key);
+	if (styleId !== void 0 && isUnset(attrs._tableOfContentsLevel)) {
+		const styleName = resolver.getStyle(styleId)?.name;
+		const level = tableOfContentsStyleLevel({
+			styleId,
+			...styleName ? { styleName } : {}
+		});
+		if (level !== void 0) patch._tableOfContentsLevel = level;
+	}
+	if (stylePpr?.numPr?.kind === "reference" && isUnset(attrs.numPr) && isUnset(attrs.numPrFromStyle)) {
+		const listAttrs = listAttrsFromResolvedStyle({ paragraphFormatting: stylePpr }, numbering());
+		const takesLevelIndent = {
+			indentLeft: isUnset(attrs.indentLeft) && patch.indentLeft === void 0,
+			indentFirstLine: isUnset(attrs.indentFirstLine) && attrs.hangingIndent !== true && patch.indentFirstLine === void 0
+		};
+		takesLevelIndent["hangingIndent"] = takesLevelIndent["indentFirstLine"] === true;
+		for (const [key, value] of Object.entries(listAttrs ?? {})) {
+			if (takesLevelIndent[key] === false) continue;
+			Reflect.set(patch, key, value);
+		}
+	}
+	const autospacingBase = {};
+	if (stylePpr?.beforeAutospacing && patch.spaceBefore !== void 0) setAutospacingBaseValue(autospacingBase, "before", patch.spaceBefore);
+	if (stylePpr?.afterAutospacing && patch.spaceAfter !== void 0) setAutospacingBaseValue(autospacingBase, "after", patch.spaceAfter);
+	if (Object.keys(autospacingBase).length > 0) patch._autospacingBase = {
+		...attrs._autospacingBase,
+		...autospacingBase
+	};
+	return Object.keys(patch).length > 0 ? patch : null;
+};
+/** The table-style regions for the cell at `depth` of `$pos`, as the load path picks them. */
+const cellStyleRegions = ($pos, depth) => {
+	const table = $pos.node(depth - 2);
+	const row = $pos.node(depth - 1);
+	const map = TableMap.get(table);
+	const cellPos = $pos.before(depth) - $pos.start(depth - 2);
+	const rect = map.findCell(cellPos);
+	const look = resolveTableLook(expectTableAttrs(table).look ?? void 0);
+	return tableCellStyleRegions({
+		look,
+		rowIndex: rect.top,
+		totalRows: map.height,
+		column: rect.left,
+		colspan: rect.right - rect.left,
+		totalColumns: map.width,
+		rowBand: tableRowBand(look, rect.top, map.height),
+		rowConditionalFormat: expectTableRowAttrs(row)._originalFormatting?.conditionalFormat,
+		cellConditionalFormat: expectTableCellAttrs($pos.node(depth))._originalFormatting?.conditionalFormat
+	});
+};
+/**
+* The table-style paragraph overlay for a paragraph directly inside a table
+* cell (or a block container in one), as the load path layers it.
+*/
+const cellParagraphOverlay = ($pos, resolver) => {
+	for (let depth = $pos.depth; depth > 0; depth -= 1) {
+		const ancestor = $pos.node(depth);
+		const role = ancestor.type.spec["tableRole"];
+		if (role === "cell" || role === "header_cell") {
+			const styleId = $pos.node(depth - 2).attrs["styleId"];
+			return tableCellParagraphOverlay(resolver, typeof styleId === "string" ? styleId : null, cellStyleRegions($pos, depth));
+		}
+		if (ancestor.type.name === "textBox") return;
+	}
+};
+/**
+* Project the style cascade onto every paragraph the transactions touched
+* that has not been projected yet. Returns the transaction to append, or null
+* when every touched paragraph already reads as a reopened document would.
+*/
+const resolveEditedParagraphStyles = (transactions, state, resolver, numbering) => {
+	const ranges = changedRanges(transactions);
+	if (ranges.length === 0) return null;
+	const tr = state.tr;
+	const seen = /* @__PURE__ */ new Set();
+	const docSize = state.doc.content.size;
+	for (const [rangeFrom, rangeTo] of ranges) {
+		const from = Math.max(0, Math.min(rangeFrom, docSize));
+		const to = Math.max(from, Math.min(rangeTo, docSize));
+		state.doc.nodesBetween(from, to, (node, pos) => {
+			if (node.type.name !== "paragraph") return !node.isTextblock;
+			if (seen.has(pos)) return false;
+			seen.add(pos);
+			if (node.attrs["_originalFormatting"] !== null) return false;
+			const patch = cascadePatch(node, resolver, cellParagraphOverlay(state.doc.resolve(pos), resolver), numbering);
+			if (patch) for (const [key, value] of Object.entries(patch)) {
+				const current = node.attrs[key];
+				if (current !== value && !(isUnset(current) && isUnset(value))) tr.setNodeAttribute(pos, key, value);
+			}
+			return false;
+		});
+	}
+	return tr.docChanged ? tr : null;
+};
+//#endregion
+export { resolveEditedParagraphStyles };

package/dist/prosemirror/plugins/suggestionMode.d.ts

@@ -24,11 +24,21 @@ declare function makeRevisionInfo(state: EditorState): {
  * With track changes on, pasting over a non-empty text selection marks the
  * replaced text as a tracked deletion and the pasted slice as a tracked
  * insertion (so they read as one replacement), matching typing over a
- * selection. Returns false for a collapsed cursor or non-text selection so the
+ * selection. Select-all (an `AllSelection`) counts as a text selection over the
+ * whole document. Returns false for a collapsed cursor or another selection so the
  * default paste + the `appendTransaction` catch-all marks a plain insertion
  * (eigenpal/docx-editor#784).
  */
 declare function handleSuggestionPaste(view: EditorView, slice: Slice, pluginState: SuggestionModeState): boolean;
+/**
+ * With track changes on, a paste into a table's cells (a cell selection, or a
+ * block of copied cells) replaces each cell's content the way a paste over a
+ * text selection does: the old content struck through, the pasted content
+ * after it as an insertion. When the pasted content is whole paragraphs, the
+ * last one ends the cell, so its paragraph mark is tracked as added too:
+ * rejecting then drops it and accepting joins the struck paragraphs into it.
+ */
+declare function handleSuggestionTableCellPaste(view: EditorView, slice: Slice, pluginState: SuggestionModeState): boolean;
 /**
  * Remove `from`..`to` of `tr.doc` as a suggestion: text the current author
  * inserted is retracted, anything else is marked deleted. `false` when the
@@ -80,4 +90,4 @@ declare function setSuggestionMode(active: boolean, state: EditorState, dispatch
  */
 declare function isSuggestionModeActive(state: EditorState): boolean;
 //#endregion
-export { SUGGESTED_TEXT_INPUT_META, SUGGESTION_BYPASS_META, SUGGESTION_META, createSuggestionModePlugin, deleteSelectionAsSuggestion, handleSuggestionEnter, handleSuggestionPaste, isSuggestionModeActive, makeRevisionInfo, paragraphBoundaryTarget, setSuggestionMode, suggestRangeDeletion, suggestionModeKey, toggleSuggestionMode };
+export { SUGGESTED_TEXT_INPUT_META, SUGGESTION_BYPASS_META, SUGGESTION_META, createSuggestionModePlugin, deleteSelectionAsSuggestion, handleSuggestionEnter, handleSuggestionPaste, handleSuggestionTableCellPaste, isSuggestionModeActive, makeRevisionInfo, paragraphBoundaryTarget, setSuggestionMode, suggestRangeDeletion, suggestionModeKey, toggleSuggestionMode };