@stll/folio-core 0.44.0 → 0.46.0

package/dist/prosemirror/pageBreakRunProjection.js

@@ -1,34 +1,44 @@
 import { expectParagraphAttrs } from "./attrs/index.js";
 //#region src/prosemirror/pageBreakRunProjection.ts
+/**
+* Paragraph shapes whose explicit page-break run the editor lays out
+* approximately.
+*
+* Layout splits a paragraph into fragments at its breaks, and a paragraph
+* property that describes the paragraph as a whole then applies to each
+* fragment. That is an approximation, not a loss: the run is projected, it is
+* saved, and the document opens. Folio used to refuse these instead, which
+* meant a file Word opens could not be opened, laid out or exported at all.
+*/
 const PAGE_BREAK_RUN_PARAGRAPH_PROJECTION_MESSAGES = {
-	borders: "A bordered paragraph containing an explicit page-break run cannot be projected",
-	frame: "A framed paragraph containing an explicit page-break run cannot be projected",
-	outline: "An outline paragraph containing an explicit page-break run cannot be projected",
-	textBoxAnchor: "A paragraph whose text-box anchor follows an explicit page-break run cannot be projected"
+	borders: "A bordered paragraph is split at its explicit page-break run, so its border is drawn around each part",
+	frame: "A framed paragraph is split at its explicit page-break run, so its frame applies to each part",
+	outline: "An outline paragraph is split at its explicit page-break run, so each part carries the outline level",
+	textBoxAnchor: "A text-box anchor following an explicit page-break run is hosted by the paragraph's first part"
 };
 /** Keep source-import and ProseMirror-layout ownership decisions on one predicate. */
 const pageBreakRunParagraphProjectionDispositionForFeatures = ({ attrs, effectiveFrame, textBoxAnchorAfterPageBreak }) => {
 	if (effectiveFrame !== void 0 && effectiveFrame.dropCap !== "drop" && effectiveFrame.dropCap !== "margin") return {
-		status: "unsupported",
+		status: "approximate",
 		reason: "frame",
 		message: PAGE_BREAK_RUN_PARAGRAPH_PROJECTION_MESSAGES.frame
 	};
 	if (attrs.outlineLevel !== void 0) return {
-		status: "unsupported",
+		status: "approximate",
 		reason: "outline",
 		message: PAGE_BREAK_RUN_PARAGRAPH_PROJECTION_MESSAGES.outline
 	};
 	if (attrs.borders !== void 0 && Object.values(attrs.borders).some((border) => border !== void 0)) return {
-		status: "unsupported",
+		status: "approximate",
 		reason: "borders",
 		message: PAGE_BREAK_RUN_PARAGRAPH_PROJECTION_MESSAGES.borders
 	};
 	if (textBoxAnchorAfterPageBreak) return {
-		status: "unsupported",
+		status: "approximate",
 		reason: "textBoxAnchor",
 		message: PAGE_BREAK_RUN_PARAGRAPH_PROJECTION_MESSAGES.textBoxAnchor
 	};
-	return { status: "supported" };
+	return { status: "exact" };
 };
 const pageBreakRunParagraphProjectionDisposition = (paragraph) => {
 	const attrs = expectParagraphAttrs(paragraph);

package/dist/prosemirror/paragraphFormattingProvenance.d.ts

@@ -95,10 +95,12 @@ declare const PARAGRAPH_FORMATTING_WRITE_BACK: {
     readonly attr: "tabs";
   };
   readonly keepNext: {
-    readonly kind: "original-only";
+    readonly kind: "style-resolved-attr";
+    readonly attr: "keepNext";
   };
   readonly keepLines: {
-    readonly kind: "original-only";
+    readonly kind: "style-resolved-attr";
+    readonly attr: "keepLines";
   };
   readonly widowControl: {
     readonly kind: "style-resolved-attr";
@@ -142,7 +144,8 @@ declare const PARAGRAPH_FORMATTING_WRITE_BACK: {
     readonly kind: "original-only";
   };
   readonly runInWithNext: {
-    readonly kind: "original-only";
+    readonly kind: "style-resolved-attr";
+    readonly attr: "runInWithNext";
   };
 };
 type StyleResolvedParagraphField = { [Field in keyof typeof PARAGRAPH_FORMATTING_WRITE_BACK]: (typeof PARAGRAPH_FORMATTING_WRITE_BACK)[Field] extends {

package/dist/prosemirror/paragraphFormattingProvenance.js

@@ -53,8 +53,14 @@ const PARAGRAPH_FORMATTING_WRITE_BACK = {
 		kind: "style-resolved-attr",
 		attr: "tabs"
 	},
-	keepNext: { kind: "original-only" },
-	keepLines: { kind: "original-only" },
+	keepNext: {
+		kind: "style-resolved-attr",
+		attr: "keepNext"
+	},
+	keepLines: {
+		kind: "style-resolved-attr",
+		attr: "keepLines"
+	},
 	widowControl: {
 		kind: "style-resolved-attr",
 		attr: "widowControl"
@@ -82,7 +88,10 @@ const PARAGRAPH_FORMATTING_WRITE_BACK = {
 		attr: "suppressAutoHyphens"
 	},
 	runProperties: { kind: "original-only" },
-	runInWithNext: { kind: "original-only" }
+	runInWithNext: {
+		kind: "style-resolved-attr",
+		attr: "runInWithNext"
+	}
 };
 const STYLE_RESOLVED_PARAGRAPH_FIELDS = Object.keys(PARAGRAPH_FORMATTING_WRITE_BACK).filter((field) => PARAGRAPH_FORMATTING_WRITE_BACK[field].kind === "style-resolved-attr");
 /**

package/dist/prosemirror/replacedAnnotations.d.ts

@@ -0,0 +1,59 @@
+import { Fragment, Mark, Node, Schema } from "prosemirror-model";
+//#region src/prosemirror/replacedAnnotations.d.ts
+/**
+ * What a replacement does with each mark the schema declares
+ * `inclusive: false`. Boundary inheritance already handles every other mark,
+ * so this table is exactly the set that needs a decision; a new
+ * non-inclusive mark that is missing from it fails
+ * `replacedAnnotations.test.ts` rather than silently following the text.
+ */
+declare const NON_INCLUSIVE_MARK_DISPOSITION: {
+  readonly comment: "carry";
+  readonly hyperlink: "carry";
+  readonly footnoteRef: "followsTheText";
+  readonly pageBreakRunOwner: "followsTheText";
+  readonly insertion: "followsTheText";
+  readonly deletion: "followsTheText";
+  readonly runPropertyChange: "followsTheText";
+  readonly inlineWrapper: "followsTheText";
+};
+/** The mark names in the schema that a replacement must not silently drop. */
+declare const nonInclusiveMarkNames: (schema: Schema) => string[];
+type ReplacedAnnotations = {
+  /** Marks the replacement must carry, in document order. */
+  carried: readonly Mark[];
+  /** Anchors restored before the replacement, in their original order. */
+  leading: readonly Node[];
+  /** Anchors restored after the replacement, in their original order. */
+  trailing: readonly Node[];
+};
+declare const hasReplacedAnnotations: ({ carried, leading, trailing }: ReplacedAnnotations) => boolean;
+/**
+ * The annotations carried by `[from, to)`. An anchor counts only when the
+ * range covers it whole: a partially covered atom is not deleted by the
+ * replacement either.
+ */
+declare const surveyReplacedAnnotations: (doc: Node, from: number, to: number) => ReplacedAnnotations;
+type AnnotatedReplacementOptions = {
+  annotations: ReplacedAnnotations;
+  /** The replacement's own inline content, already carrying its formatting. */
+  content: Fragment;
+};
+type AnnotatedReplacement = {
+  fragment: Fragment;
+  /** Size of the anchors restored before the replacement's own content. */
+  leadingSize: number;
+  /** Size of the replacement's own content, once the marks are on it. */
+  contentSize: number;
+};
+/** `marks` with the carried marks added, each type's exclusions respected. */
+declare const addCarriedMarks: (marks: readonly Mark[], carried: readonly Mark[]) => readonly Mark[];
+/** `content` with the surveyed marks on it and the surveyed anchors around it. */
+declare const annotatedReplacement: ({ annotations: { carried, leading, trailing }, content }: AnnotatedReplacementOptions) => AnnotatedReplacement;
+/**
+ * The marks a replacement inherits at `[from, to)`, exactly as
+ * `Transaction.insertText` would compute them.
+ */
+declare const inheritedReplacementMarks: (doc: Node, from: number, to: number) => readonly Mark[];
+//#endregion
+export { NON_INCLUSIVE_MARK_DISPOSITION, ReplacedAnnotations, addCarriedMarks, annotatedReplacement, hasReplacedAnnotations, inheritedReplacementMarks, nonInclusiveMarkNames, surveyReplacedAnnotations };

package/dist/prosemirror/replacedAnnotations.js

@@ -0,0 +1,165 @@
+import { BOOKMARK_BOUNDARY_NODE_NAME } from "./extensions/nodes/BookmarkBoundaryExtension.js";
+import { COMMENT_REFERENCE_NODE_NAME } from "./extensions/nodes/CommentReferenceExtension.js";
+import { TEXT_BOX_ANCHOR_NODE_NAME } from "./extensions/nodes/TextBoxAnchorExtension.js";
+import { Fragment, Mark } from "prosemirror-model";
+//#region src/prosemirror/replacedAnnotations.ts
+/**
+* What survives when an edit replaces a span of inline content.
+*
+* ProseMirror gives a replacement the marks it inherits at the boundary, and
+* drops any mark declared `inclusive: false` once the span reaches the end of
+* what that mark covers. For formatting that is right. For a mark that names
+* something outside itself — the comment this text is commented by, the
+* address this text links to — it is not: the target survives the edit, and
+* only the mark saying so is lost. A comment loses the range start that lived
+* on the replaced text, so the save emits a `commentRangeEnd` with no
+* `commentRangeStart`, invalid OOXML and a comment anchored to nothing; a
+* hyperlink simply stops being a link. Zero-width anchors fare worse still: a
+* plain replace deletes them outright.
+*
+* Word moves a range start that sits inside a replaced span to the beginning
+* of the replacement and lets the range keep covering the new text; it keeps
+* a link across a replacement of its display text. A range wholly inside the
+* span collapses onto the replacement, and disappears only when every
+* character it covered is gone. One rule per marker kind, and that is the
+* whole contract:
+*
+* - `comment` mark: the replacement carries every comment the span covered, so
+*   a range that started inside it starts at the replacement instead.
+* - `hyperlink` mark: the replacement carries the first link the span held, so
+*   replacing a link's display text leaves the link on the new text. A span
+*   crossing two links keeps the one it opens in, because the mark excludes
+*   itself and a replacement is one run of text with one address.
+* - `footnoteRef` mark (footnotes and endnotes alike): not carried. It marks
+*   the reference's own number, not prose around it, and it serializes as a
+*   bare `w:footnoteReference` run, so carrying it onto a replacement would
+*   discard the new text. Replacing a reference's text deletes the reference,
+*   as deleting that text does.
+* - `pageBreakRunOwner` mark: not carried. It is editor-only identity for one
+*   authored run, not a target, and carrying it would fuse the replacement
+*   into a run it was never part of.
+* - tracked-change marks (`insertion`, `deletion`, `runPropertyChange`): not
+*   carried. The applier decides them per edit mode and writes them itself.
+* - `inlineWrapper` mark: not carried. Every wrapper kind states something
+*   about the text under it and names nothing outside itself, so boundary
+*   inheritance is the right rule: a replacement inside a bidirectional
+*   override is still inside it, and one that replaces the whole of it is not.
+* - `commentReference` node: kept after the replacement, where the comment's
+*   last covered position now is.
+* - `bookmarkBoundary` node: a start kept before the replacement, an end after
+*   it, so the bookmark still covers the new text.
+* - `textBoxAnchor` node: kept after the replacement; the shape it anchors
+*   outlives the sentence it was typed into.
+* - `renderedPageBreak` node: dropped with the text. It is Word's cached
+*   pagination, re-derived on layout, and nothing else names it.
+* - every other mark: formatting, and left to boundary inheritance, which
+*   already gives the replacement the formatting of the text it replaces.
+*
+* Deleting the whole of a comment's span leaves it no mark anywhere, so
+* `CommentReferenceExtension` drops the orphan reference and the save drops
+* the comment: the one case where a range is meant to disappear.
+*/
+/**
+* What a replacement does with each mark the schema declares
+* `inclusive: false`. Boundary inheritance already handles every other mark,
+* so this table is exactly the set that needs a decision; a new
+* non-inclusive mark that is missing from it fails
+* `replacedAnnotations.test.ts` rather than silently following the text.
+*/
+const NON_INCLUSIVE_MARK_DISPOSITION = {
+	comment: "carry",
+	hyperlink: "carry",
+	footnoteRef: "followsTheText",
+	pageBreakRunOwner: "followsTheText",
+	insertion: "followsTheText",
+	deletion: "followsTheText",
+	runPropertyChange: "followsTheText",
+	inlineWrapper: "followsTheText"
+};
+/** The mark names in the schema that a replacement must not silently drop. */
+const nonInclusiveMarkNames = (schema) => Object.entries(schema.marks).filter(([, type]) => type.spec.inclusive === false).map(([name]) => name);
+const isCarried = (mark) => NON_INCLUSIVE_MARK_DISPOSITION[mark.type.name] === "carry";
+/** Anchors an edit must put back, and where relative to the replacement. */
+const ANCHOR_PLACEMENT = {
+	[COMMENT_REFERENCE_NODE_NAME]: "after",
+	[TEXT_BOX_ANCHOR_NODE_NAME]: "after",
+	[BOOKMARK_BOUNDARY_NODE_NAME]: "byBoundaryType"
+};
+const anchorPlacement = (node) => ANCHOR_PLACEMENT[node.type.name];
+const NOTHING_REPLACED = {
+	carried: [],
+	leading: [],
+	trailing: []
+};
+const hasReplacedAnnotations = ({ carried, leading, trailing }) => carried.length > 0 || leading.length > 0 || trailing.length > 0;
+/**
+* The annotations carried by `[from, to)`. An anchor counts only when the
+* range covers it whole: a partially covered atom is not deleted by the
+* replacement either.
+*/
+const surveyReplacedAnnotations = (doc, from, to) => {
+	if (to <= from) return NOTHING_REPLACED;
+	const carried = [];
+	const leading = [];
+	const trailing = [];
+	doc.nodesBetween(from, to, (node, position) => {
+		if (!node.isInline) return true;
+		for (const mark of node.marks) if (isCarried(mark) && !alreadyCarried(mark, carried)) carried.push(mark);
+		const placement = anchorPlacement(node);
+		if (placement === void 0 || position < from || position + node.nodeSize > to) return false;
+		(placement === "byBoundaryType" && node.attrs["type"] === "start" ? leading : trailing).push(node);
+		return false;
+	});
+	return {
+		carried,
+		leading,
+		trailing
+	};
+};
+/**
+* Whether the span already contributed this mark, or one the mark would evict.
+* Comments do not exclude each other, so every comment is collected; a
+* hyperlink excludes its own type, so the first address in the span wins
+* rather than the last silently overwriting it.
+*/
+const alreadyCarried = (mark, carried) => carried.some((other) => other.eq(mark) || mark.type.excludes(other.type));
+const anchorsSize = (anchors) => {
+	let size = 0;
+	for (const node of anchors) size += node.nodeSize;
+	return size;
+};
+/** `marks` with the carried marks added, each type's exclusions respected. */
+const addCarriedMarks = (marks, carried) => {
+	let next = marks;
+	for (const mark of carried) next = mark.addToSet(next);
+	return next;
+};
+const withCarriedMarks = (node, carried) => node.mark(addCarriedMarks(node.marks, carried));
+/** `content` with the surveyed marks on it and the surveyed anchors around it. */
+const annotatedReplacement = ({ annotations: { carried, leading, trailing }, content }) => {
+	const inline = [];
+	content.forEach((child) => {
+		inline.push(carried.length === 0 ? child : withCarriedMarks(child, carried));
+	});
+	const fragment = Fragment.fromArray([
+		...leading,
+		...inline,
+		...trailing
+	]);
+	const leadingSize = anchorsSize(leading);
+	return {
+		fragment,
+		leadingSize,
+		contentSize: fragment.size - leadingSize - anchorsSize(trailing)
+	};
+};
+/**
+* The marks a replacement inherits at `[from, to)`, exactly as
+* `Transaction.insertText` would compute them.
+*/
+const inheritedReplacementMarks = (doc, from, to) => {
+	const $from = doc.resolve(from);
+	return (to === from ? $from.marks() : $from.marksAcross(doc.resolve(to))) ?? Mark.none;
+};
+//#endregion
+export { NON_INCLUSIVE_MARK_DISPOSITION, addCarriedMarks, annotatedReplacement, hasReplacedAnnotations, inheritedReplacementMarks, nonInclusiveMarkNames, surveyReplacedAnnotations };

package/dist/prosemirror/runFormattingInlineCarriers.d.ts

@@ -1,7 +1,7 @@
 import { Transaction } from "prosemirror-state";
 import { Mark, Node } from "prosemirror-model";
 //#region src/prosemirror/runFormattingInlineCarriers.d.ts
-type RunFormattingInlineAtomDisposition = "break-run" | "field-run" | "not-a-run" | "page-break-carrier" | "structured-field" | "symbol-run" | "tab-run" | "text-run";
+type RunFormattingInlineAtomDisposition = "break-run" | "field-run" | "not-a-run" | "page-break-carrier" | "preserved-xml-run" | "structured-field" | "symbol-run" | "tab-run" | "text-run";
 /**
  * How every inline atom maps to a serialized run-formatting carrier.
  *
@@ -12,11 +12,13 @@ type RunFormattingInlineAtomDisposition = "break-run" | "field-run" | "not-a-run
  */
 declare const RUN_FORMATTING_INLINE_ATOM_DISPOSITIONS: Readonly<{
   readonly bookmarkBoundary: "not-a-run";
+  readonly commentReference: "not-a-run";
   readonly field: "field-run";
   readonly hardBreak: "break-run";
   readonly image: "not-a-run";
   readonly math: "not-a-run";
   readonly pageBreakRun: "page-break-carrier";
+  readonly preservedXml: "preserved-xml-run";
   readonly renderedPageBreak: "not-a-run";
   readonly shape: "not-a-run";
   readonly structuredField: "structured-field";

package/dist/prosemirror/runFormattingInlineCarriers.js

@@ -1,5 +1,5 @@
 import { decodeOoxmlSymbolCharacter } from "../utils/ooxmlSymbol.js";
-import { expectFieldAttrs, expectSymbolAttrs } from "./attrs/index.js";
+import { expectFieldAttrs, expectPreservedXmlAttrs, expectSymbolAttrs } from "./attrs/index.js";
 import { panic } from "better-result";
 import { Mark } from "prosemirror-model";
 //#region src/prosemirror/runFormattingInlineCarriers.ts
@@ -13,11 +13,13 @@ import { Mark } from "prosemirror-model";
 */
 const RUN_FORMATTING_INLINE_ATOM_DISPOSITIONS = Object.freeze({
 	bookmarkBoundary: "not-a-run",
+	commentReference: "not-a-run",
 	field: "field-run",
 	hardBreak: "break-run",
 	image: "not-a-run",
 	math: "not-a-run",
 	pageBreakRun: "page-break-carrier",
+	preservedXml: "preserved-xml-run",
 	renderedPageBreak: "not-a-run",
 	shape: "not-a-run",
 	structuredField: "structured-field",
@@ -32,6 +34,7 @@ const CONTROL_CHARACTER_BY_DISPOSITION = Object.freeze({
 	"field-run": null,
 	"not-a-run": null,
 	"page-break-carrier": null,
+	"preserved-xml-run": null,
 	"structured-field": null,
 	"symbol-run": null,
 	"tab-run": "	",
@@ -162,6 +165,7 @@ const runFormattingCarrierReviewText = (carrier) => {
 			const { char } = expectSymbolAttrs(carrier.node);
 			return decodeOoxmlSymbolCharacter(char) ?? "�";
 		}
+		case "preserved-xml-run": return expectPreservedXmlAttrs(carrier.node).text;
 		case "field-run":
 		case "structured-field": return expectFieldAttrs(carrier.node).displayText ?? carrier.node.textContent;
 	}

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

@@ -1,5 +1,5 @@
-import { CharacterSpacingAttrs, CharacterStyleAttrs, CommentAttrs, EmphasisMarkAttrs, FontFamilyAttrs, FontSizeAttrs, FootnoteRefAttrs, HighlightAttrs, HyperlinkAttrs, LanguageAttrs, PageBreakRunOwnerMarkAttrs, RunFormattingOverrideAttrs, RunPropertyChangeMarkAttrs, RunShadingAttrs, StrikeAttrs, TextColorAttrs, TextEffectAttrs, TrackedChangeMarkAttrs, UnderlineAttrs } from "./marks.js";
-import { BlockSdtAttrs, BookmarkBoundaryAttrs, FieldAttrs, HardBreakAttrs, ImageAttrs, ImagePositionAttrs, MathAttrs, PageBreakRunAttrs, ParagraphAttrs, ParagraphPropertyChangeAttrs, SdtAttrs, ShapeAttrs, SymbolAttrs, TabAttrs, TableAttrs, TableCellAttrs, TableRowAttrs, TextBoxAttrs } from "./nodes.js";
+import { CharacterSpacingAttrs, CharacterStyleAttrs, CommentAttrs, EmphasisMarkAttrs, FontFamilyAttrs, FontSizeAttrs, FootnoteRefAttrs, HighlightAttrs, HyperlinkAttrs, InlineWrapperAttrs, InlineWrapperKind, InlineWrapperLayer, LanguageAttrs, PageBreakRunOwnerMarkAttrs, RunFormattingOverrideAttrs, RunPropertyChangeMarkAttrs, RunShadingAttrs, StrikeAttrs, TextColorAttrs, TextEffectAttrs, TrackedChangeMarkAttrs, UnderlineAttrs } from "./marks.js";
+import { BlockSdtAttrs, BookmarkBoundaryAttrs, FieldAttrs, HardBreakAttrs, ImageAttrs, ImagePositionAttrs, MathAttrs, PageBreakRunAttrs, ParagraphAttrs, ParagraphPropertyChangeAttrs, PreservedBlockAttrs, PreservedXmlAttrs, PreservedXmlLevel, SdtAttrs, ShapeAttrs, SymbolAttrs, TabAttrs, TableAttrs, TableCellAttrs, TableRowAttrs, TextBoxAttrs } from "./nodes.js";
 import { ExtensionManager } from "../extensions/ExtensionManager.js";
 //#region src/prosemirror/schema/index.d.ts
 declare const singletonManager: ExtensionManager;
@@ -11,4 +11,4 @@ type DocxSchema = typeof schema;
 type DocxNode = ReturnType<typeof schema.node>;
 type DocxMark = ReturnType<typeof schema.mark>;
 //#endregion
-export { type BlockSdtAttrs, type BookmarkBoundaryAttrs, type CharacterSpacingAttrs, type CharacterStyleAttrs, type CommentAttrs, DocxMark, DocxNode, DocxSchema, type EmphasisMarkAttrs, type FieldAttrs, type FontFamilyAttrs, type FontSizeAttrs, type FootnoteRefAttrs, type HardBreakAttrs, type HighlightAttrs, type HyperlinkAttrs, type ImageAttrs, type ImagePositionAttrs, type LanguageAttrs, type MathAttrs, type PageBreakRunAttrs, type PageBreakRunOwnerMarkAttrs, type ParagraphAttrs, type ParagraphPropertyChangeAttrs, type RunFormattingOverrideAttrs, type RunPropertyChangeMarkAttrs, type RunShadingAttrs, type SdtAttrs, type ShapeAttrs, type StrikeAttrs, type SymbolAttrs, type TabAttrs, type TableAttrs, type TableCellAttrs, type TableRowAttrs, type TextBoxAttrs, type TextColorAttrs, type TextEffectAttrs, type TrackedChangeMarkAttrs, type UnderlineAttrs, schema, singletonManager };
+export { type BlockSdtAttrs, type BookmarkBoundaryAttrs, type CharacterSpacingAttrs, type CharacterStyleAttrs, type CommentAttrs, DocxMark, DocxNode, DocxSchema, type EmphasisMarkAttrs, type FieldAttrs, type FontFamilyAttrs, type FontSizeAttrs, type FootnoteRefAttrs, type HardBreakAttrs, type HighlightAttrs, type HyperlinkAttrs, type ImageAttrs, type ImagePositionAttrs, type InlineWrapperAttrs, type InlineWrapperKind, type InlineWrapperLayer, type LanguageAttrs, type MathAttrs, type PageBreakRunAttrs, type PageBreakRunOwnerMarkAttrs, type ParagraphAttrs, type ParagraphPropertyChangeAttrs, type PreservedBlockAttrs, type PreservedXmlAttrs, type PreservedXmlLevel, type RunFormattingOverrideAttrs, type RunPropertyChangeMarkAttrs, type RunShadingAttrs, type SdtAttrs, type ShapeAttrs, type StrikeAttrs, type SymbolAttrs, type TabAttrs, type TableAttrs, type TableCellAttrs, type TableRowAttrs, type TextBoxAttrs, type TextColorAttrs, type TextEffectAttrs, type TrackedChangeMarkAttrs, type UnderlineAttrs, schema, singletonManager };

package/dist/prosemirror/schema/marks.d.ts

@@ -127,6 +127,30 @@ type RunPropertyChangeMarkAttrs = {
 type PageBreakRunOwnerMarkAttrs = {
   id: number;
 };
+/**
+ * One transparent wrapper a leaf sits inside, minus the content ProseMirror
+ * now holds instead.
+ *
+ * Distributed over the model's union rather than written out beside it: a
+ * wrapper kind exists in both places or in neither, and the fields a kind
+ * carries are stated once. A smart tag cannot gain a `control` this way, and
+ * a kind added to the model reaches the editor as a compile error at every
+ * site that decides per kind.
+ */
+type WrapperLayer<Wrapper> = Wrapper extends unknown ? Omit<Wrapper, "type" | "content"> : never;
+type InlineWrapperLayer = WrapperLayer<document_d_exports.InlineWrapper>;
+type InlineWrapperKind = InlineWrapperLayer["kind"];
+/**
+ * The wrappers a leaf sits inside, outermost first.
+ *
+ * Multiplicity lives here rather than in the mark set: ProseMirror marks are
+ * unordered across types and a mark excludes its own type, so nesting a
+ * wrapper inside another cannot be spelled as two marks. `null` is no
+ * wrapper; an empty stack is never stored.
+ */
+type InlineWrapperAttrs = {
+  stack: readonly InlineWrapperLayer[];
+};
 declare const COMPLEX_SCRIPT_RUN_PROPERTY_KEYS: readonly ["boldCs", "italicCs", "fontSizeCs"];
 type ComplexScriptRunPropertyKey = (typeof COMPLEX_SCRIPT_RUN_PROPERTY_KEYS)[number];
 declare const RUN_FORMATTING_BOOLEAN_PROPERTIES: readonly ["bold", "boldCs", "italic", "italicCs", "strike", "doubleStrike", "smallCaps", "allCaps", "hidden", "noProof", "emboss", "imprint", "outline", "shadow", "rtl", "cs"];
@@ -231,4 +255,4 @@ type HyperlinkAttrs = {
   _docxHyperlinkIndex?: number;
 };
 //#endregion
-export { AuthoredRunFormattingValues, COMPLEX_SCRIPT_RUN_PROPERTY_KEYS, CharacterSpacingAttrs, CharacterStyleAttrs, CommentAttrs, ComplexScriptRunPropertyKey, EmphasisMarkAttrs, FontFamilyAttrs, FontSizeAttrs, FootnoteRefAttrs, HighlightAttrs, HyperlinkAttrs, LanguageAttrs, PageBreakRunOwnerMarkAttrs, RUN_FORMATTING_BOOLEAN_PROPERTIES, RUN_FORMATTING_PROPERTY_SPECS, RUN_FORMATTING_VALUE_PROPERTIES, RunFormattingBooleanProperty, RunFormattingOverrideAttrs, RunFormattingValueProperty, RunPropertyChangeMarkAttrs, RunShadingAttrs, StrikeAttrs, TRACKED_CHANGE_PROVENANCE_VALUES, TextColorAttrs, TextEffectAttrs, TrackedChangeMarkAttrs, TrackedChangeProvenance, UnderlineAttrs };
+export { AuthoredRunFormattingValues, COMPLEX_SCRIPT_RUN_PROPERTY_KEYS, CharacterSpacingAttrs, CharacterStyleAttrs, CommentAttrs, ComplexScriptRunPropertyKey, EmphasisMarkAttrs, FontFamilyAttrs, FontSizeAttrs, FootnoteRefAttrs, HighlightAttrs, HyperlinkAttrs, InlineWrapperAttrs, InlineWrapperKind, InlineWrapperLayer, LanguageAttrs, PageBreakRunOwnerMarkAttrs, RUN_FORMATTING_BOOLEAN_PROPERTIES, RUN_FORMATTING_PROPERTY_SPECS, RUN_FORMATTING_VALUE_PROPERTIES, RunFormattingBooleanProperty, RunFormattingOverrideAttrs, RunFormattingValueProperty, RunPropertyChangeMarkAttrs, RunShadingAttrs, StrikeAttrs, TRACKED_CHANGE_PROVENANCE_VALUES, TextColorAttrs, TextEffectAttrs, TrackedChangeMarkAttrs, TrackedChangeProvenance, UnderlineAttrs };