@portabletext/markdown 1.5.0 → 2.1.0

package/dist/index.js

@@ -1,5 +1,6 @@
 import { compileSchema, defineSchema, isSpan, isTextBlock, isTypedObject } from "@portabletext/schema";
-import { buildMarksTree, isPortableTextBlock, isPortableTextListItemBlock, isPortableTextToolkitSpan, isPortableTextToolkitTextNode, spanToPlainText } from "@portabletext/toolkit";
+import { buildMarksTree, isPortableTextBlock, isPortableTextListItemBlock, isPortableTextSpan, isPortableTextToolkitSpan, isPortableTextToolkitTextNode, spanToPlainText } from "@portabletext/toolkit";
+import LinkifyIt from "linkify-it";
 import { alert } from "@mdit/plugin-alert";
 import markdownit from "markdown-it";
 function defaultKeyGenerator() {
@@ -91,27 +92,431 @@ function buildListIndexMap(blocks) {
 		listDepthMap
 	};
 }
-const createRenderNode = (renderers, listIndexMap, listDepthMap) => {
-	function renderNode(options) {
-		let { node, index, isInline } = options;
-		return isPortableTextListItemBlock(node) ? renderListItem(node, index) : isPortableTextToolkitSpan(node) ? renderSpan(node) : isPortableTextBlock(node) ? renderBlock(node, index, isInline) : isPortableTextToolkitTextNode(node) ? renderText(node) : renderCustomBlock(node, index, isInline);
+/**
+* The CommonMark ASCII punctuation set. Only these characters can be
+* backslash-escaped into a literal without changing the parsed text.
+*/
+const ASCII_PUNCTUATION = /[!-/:-@[-`{-~]/, ENTITY_REFERENCE = /&(?:[a-zA-Z][a-zA-Z0-9]*|#[0-9]+|#[xX][0-9a-fA-F]+);/g, BACKSLASH_BEFORE_PUNCTUATION = RegExp(`\\\\(?=${ASCII_PUNCTUATION.source})`, "g"), TILDE_RUN = /~{2,}/g, HTML_LIKE_ANGLE_BRACKET = /<(?=[a-zA-Z/!?])/g, BRACKET_BEFORE_LINK_OPEN = /\](?=[([])/g, UNICODE_PUNCTUATION_OR_SYMBOL = /^(?:\p{P}|\p{S})$/u, linkify = new LinkifyIt();
+/**
+* Plans the escaped replacement for every plain-text leaf a block's children
+* will produce, in the exact left-to-right order `renderText` visits them
+* (mirroring `buildMarksTree`'s own `text.split('\n')` leaf splitting).
+*
+* Escaping runs ahead of rendering, over the flat span sequence: some
+* hazards only exist across a leaf boundary (an ordered-list marker, a
+* ref-def label, an emphasis run) because an annotation or decorator mark
+* that introduces no markup of its own splices its children in seamlessly.
+* The plan works line by line (a block's children joined into text, split
+* at hard breaks) rather than leaf by leaf: each line's leaves are joined
+* into one string first, opaque children (inline objects, or leaves a
+* custom renderer will replace) masked with a sentinel that can't match any
+* hazard, and every hazard - inline and line-start alike - is detected once
+* against that real, complete line, with true left/right context on both
+* sides. Detected hazards become position-tracked edits against the line's
+* raw text, which are then split back into each contributing leaf's own
+* escaped text; only that composition step is leaf-scoped.
+*
+* A joined line's text that markdown-it's own linkify pass (bundled as
+* `linkify-it`) would claim as a bare URL or email is masked from most
+* edits: the linkify carve-out promises that substring round-trips
+* byte-identical, gaining only a link mark, so escaping inside it would
+* corrupt text linkify is about to claim as a link's visible text. An
+* entity-reference or backtick escape is never masked (see `computeLinkifyMask`
+* for why), and a claim spliced across a decorator boundary is never masked
+* in the first place.
+*
+* `isHeading` is set for ATX headings: only the first joined line sits
+* inside the `# ` prefix an ATX heading can never be reparsed as a block
+* construct within, so line-leading hazards are skipped there; a hard
+* break's later lines are ordinary markdown lines and get the full
+* line-start battery. That first line carries a line-*end* hazard of its
+* own instead: a trailing `#`-run reads back as the heading's own optional
+* closing sequence.
+*
+* `isListItem` is set when the block renders as list-item content: a
+* `[ ] `/`[x] `/`[X] ` at the very start of the first joined line reads
+* back as a GFM task-list checkbox, regardless of the list's own item type.
+*
+* `hardBreakOutputHasNewline` says whether the renderer's actual hard-break
+* output contains a newline. A custom `hardBreak` can render to something
+* with no newline of its own (eg `() => '<br />'`), in which case the
+* leaves on either side of it land on the same rendered line, not two: a
+* hard break like that can't be planned as a line boundary, so it's walled
+* off as an opaque segment instead, the same protection an inline object's
+* unknown rendered text already gets.
+*/
+function planLeafEscaping(children, markDefs, options) {
+	let linkMarkKeys = new Set(markDefs.filter((def) => def._type === "link").map((def) => def._key)), markDefKeys = new Set(markDefs.map((def) => def._key)), pieces = [];
+	for (let child of children) if (isPortableTextSpan(child)) {
+		let isLinkLabel = (child.marks ?? []).some((mark) => linkMarkKeys.has(mark)), markSignature = (child.marks ?? []).filter((mark) => !markDefKeys.has(mark)).sort().join(",");
+		child.text.split("\n").forEach((line, index) => {
+			index > 0 && pieces.push(options.hardBreakOutputHasNewline ? { kind: "hardBreak" } : { kind: "opaque" }), pieces.push({
+				kind: "text",
+				raw: line,
+				isLinkLabel,
+				markSignature
+			});
+		});
+	} else pieces.push({ kind: "opaque" });
+	let pieceOutputs = pieces.map(() => ""), lineIndex = 0, lineText = "", lineChars = [], lineIsLinkLabelChar = [], lineMarkSignature = [], flushLine = () => {
+		processLine({
+			text: lineText,
+			chars: lineChars,
+			isLinkLabelChar: lineIsLinkLabelChar,
+			markSignature: lineMarkSignature,
+			lineIndex,
+			isHeading: options.isHeading,
+			isListItem: options.isListItem,
+			pieceOutputs
+		}), lineIndex++, lineText = "", lineChars = [], lineIsLinkLabelChar = [], lineMarkSignature = [];
+	};
+	for (let pieceIndex = 0; pieceIndex < pieces.length; pieceIndex++) {
+		let piece = pieces[pieceIndex];
+		if (!piece || piece.kind === "hardBreak") {
+			flushLine();
+			continue;
+		}
+		if (piece.kind === "opaque") {
+			lineText += "\0", lineChars.push(null), lineIsLinkLabelChar.push(!1), lineMarkSignature.push("");
+			continue;
+		}
+		let prepared = piece.isLinkLabel ? escapeLinkLabelBrackets(piece.raw) : piece.raw;
+		for (let offset = 0; offset < prepared.length; offset++) lineText += prepared[offset], lineChars.push({
+			pieceIndex,
+			offset
+		}), lineIsLinkLabelChar.push(piece.isLinkLabel), lineMarkSignature.push(piece.markSignature);
 	}
-	function renderListItem(node, index) {
-		let renderer = renderers.listItem, itemHandler = (typeof renderer == "function" ? renderer : renderer[node.listItem]) || renderers.unknownListItem, children = buildMarksTree(node).map((child, i) => renderNode({
+	flushLine();
+	let escaped = [];
+	return pieces.forEach((piece, index) => {
+		piece.kind === "text" && escaped.push(pieceOutputs[index] ?? "");
+	}), escaped;
+}
+function processLine(args) {
+	let { text, chars, isLinkLabelChar, markSignature, pieceOutputs } = args, linkifyMask = computeLinkifyMask(text, chars, isLinkLabelChar, markSignature);
+	applyEdits(text, chars, [...collectInlineEdits(text, isLinkLabelChar), ...collectLineStartEdits(text, args)].filter((edit) => edit.bypassLinkifyMask || !isMasked(edit, linkifyMask)), pieceOutputs);
+}
+/**
+* Marks every character of this line that markdown-it's linkify pass would
+* claim as part of a bare URL or email. Link-label and opaque characters
+* are blanked out first: a link label's visible text sits inside `[...]`
+* markup real linkify never reconsiders, and an opaque child's rendered
+* text is unknown at plan time, so neither should join or seed a match.
+*
+* The probe only sees this line's raw, undecoded text, one hazard pass
+* ahead of markdown-it's own pipeline: it runs linkify against inline
+* tokenization and entity decoding, not before them. A claim survives only
+* if it lies entirely inside one run of identical decorator marks: a
+* decorator boundary crossing it splices that decorator's delimiters
+* (`**`, `` ` ``, ...) into the middle of the range real linkify would see,
+* which breaks the very claim being trusted. An annotation-only boundary
+* (a link's own label text is already excluded above; any other
+* annotation type falls back to rendering with no delimiters at all,
+* same as an unregistered decorator) never splices, so it can't invalidate
+* a claim either.
+*/
+function computeLinkifyMask(text, chars, isLinkLabelChar, markSignature) {
+	let mask = Array(text.length).fill(!1);
+	if (!/[.:@]/.test(text)) return mask;
+	let probe = "";
+	for (let index = 0; index < text.length; index++) probe += chars[index] === null || isLinkLabelChar[index] ? " " : text[index];
+	let matches = linkify.match(probe) ?? [];
+	for (let match of matches) {
+		if (match.schema === "") continue;
+		let signature = markSignature[match.index], staysWithinOneMarkRun = !0;
+		for (let index = match.index; index < match.lastIndex; index++) if (markSignature[index] !== signature) {
+			staysWithinOneMarkRun = !1;
+			break;
+		}
+		if (staysWithinOneMarkRun) for (let index = match.index; index < match.lastIndex; index++) mask[index] = !0;
+	}
+	return mask;
+}
+function isMasked(edit, mask) {
+	let end = edit.at + Math.max(edit.deleteCount, 1);
+	for (let index = edit.at; index < end; index++) if (mask[index]) return !0;
+	return !1;
+}
+/** Rewrites a line's raw text into each contributing leaf's escaped text by
+* walking it once, left to right, applying at most one edit per position.
+* Every hazard is keyed off its own trigger character - a backslash, a
+* tilde, a backtick, an `&`, a `<`, a `*`/`_`, a `]`, or (line-start only,
+* one hazard per line) a `#`, `>`, `[`, `-`/`+`/`*`, the `.`/`)` after an
+* ordered-list marker's digits, `=`, 4 spaces, or a tab - and no two of
+* those characters coincide at one position, so two edits can never target
+* the same position. */
+function applyEdits(text, chars, edits, pieceOutputs) {
+	let editsByPosition = /* @__PURE__ */ new Map();
+	for (let edit of edits) {
+		if (editsByPosition.has(edit.at)) throw Error(`Two hazard edits targeted the same position (${edit.at}); hazard trigger characters are assumed disjoint by construction.`);
+		editsByPosition.set(edit.at, edit);
+	}
+	let index = 0;
+	for (; index < text.length;) {
+		let edit = editsByPosition.get(index), owner = chars[index];
+		if (edit && (owner && (pieceOutputs[owner.pieceIndex] = (pieceOutputs[owner.pieceIndex] ?? "") + edit.insert), edit.deleteCount > 0)) {
+			index += edit.deleteCount;
+			continue;
+		}
+		owner && (pieceOutputs[owner.pieceIndex] = (pieceOutputs[owner.pieceIndex] ?? "") + (text[index] ?? "")), index++;
+	}
+}
+/**
+* Hazards that can appear anywhere on a line: emphasis/strikethrough runs,
+* a backtick, an entity reference, an HTML/autolink-shaped `<`, a literal
+* backslash before punctuation, and a `]` immediately before `(`/`[`
+* (which would otherwise read back as a link/image open).
+*/
+function collectInlineEdits(text, isLinkLabelChar) {
+	let edits = [];
+	for (let match of text.matchAll(BACKSLASH_BEFORE_PUNCTUATION)) {
+		let at = match.index ?? 0;
+		isLinkLabelChar[at] || edits.push({
+			at,
+			deleteCount: 0,
+			insert: "\\"
+		});
+	}
+	for (let match of text.matchAll(TILDE_RUN)) {
+		let start = match.index ?? 0;
+		for (let index = start; index < start + match[0].length; index++) edits.push({
+			at: index,
+			deleteCount: 0,
+			insert: "\\"
+		});
+	}
+	for (let index = 0; index < text.length; index++) text[index] === "`" && edits.push({
+		at: index,
+		deleteCount: 0,
+		insert: "\\",
+		bypassLinkifyMask: !0
+	});
+	for (let match of text.matchAll(ENTITY_REFERENCE)) edits.push({
+		at: match.index ?? 0,
+		deleteCount: 0,
+		insert: "\\",
+		bypassLinkifyMask: !0
+	});
+	for (let match of text.matchAll(HTML_LIKE_ANGLE_BRACKET)) edits.push({
+		at: match.index ?? 0,
+		deleteCount: 0,
+		insert: "\\"
+	});
+	edits.push(...collectEmphasisEdits(text));
+	for (let match of text.matchAll(BRACKET_BEFORE_LINK_OPEN)) {
+		let at = match.index ?? 0;
+		isLinkLabelChar[at] || edits.push({
+			at,
+			deleteCount: 0,
+			insert: "\\"
+		});
+	}
+	return edits;
+}
+function isWhitespace(char) {
+	return char === void 0 || /\s/.test(char);
+}
+function isPunctuation(char) {
+	return char !== void 0 && UNICODE_PUNCTUATION_OR_SYMBOL.test(char);
+}
+/**
+* The full code point sitting immediately before `index`: two UTF-16 code
+* units for an astral character (eg an emoji) whose low surrogate lands at
+* `index - 1`, one otherwise.
+*/
+function codePointBefore(text, index) {
+	if (!(index <= 0)) return index >= 2 && isLowSurrogate(text[index - 1]) && isHighSurrogate(text[index - 2]) ? text.slice(index - 2, index) : text[index - 1];
+}
+/**
+* The full code point sitting immediately at `index`: two UTF-16 code units
+* for an astral character whose high surrogate lands at `index`, one
+* otherwise.
+*/
+function codePointAt(text, index) {
+	if (!(index >= text.length)) return isHighSurrogate(text[index]) && isLowSurrogate(text[index + 1]) ? text.slice(index, index + 2) : text[index];
+}
+function isHighSurrogate(char) {
+	if (char === void 0) return !1;
+	let code = char.charCodeAt(0);
+	return code >= 55296 && code <= 56319;
+}
+function isLowSurrogate(char) {
+	if (char === void 0) return !1;
+	let code = char.charCodeAt(0);
+	return code >= 56320 && code <= 57343;
+}
+function isLeftFlanking(before, after) {
+	return isWhitespace(after) ? !1 : !isPunctuation(after) || isWhitespace(before) || isPunctuation(before);
+}
+function isRightFlanking(before, after) {
+	return isWhitespace(before) ? !1 : !isPunctuation(before) || isWhitespace(after) || isPunctuation(after);
+}
+/**
+* Finds `*`/`_` runs CommonMark would treat as flanking delimiters, using
+* each run's true neighbors on the joined line (the start/end of the line
+* itself counts as whitespace, matching the spec's treatment of line
+* boundaries).
+*/
+function collectEmphasisEdits(text) {
+	let edits = [], index = 0;
+	for (; index < text.length;) {
+		let char = text[index];
+		if (char !== "*" && char !== "_") {
+			index++;
+			continue;
+		}
+		let end = index;
+		for (; end < text.length && text[end] === char;) end++;
+		let before = codePointBefore(text, index), after = codePointAt(text, end), leftFlanking = isLeftFlanking(before, after), rightFlanking = isRightFlanking(before, after), canOpen = char === "_" ? leftFlanking && (!rightFlanking || isPunctuation(before)) : leftFlanking, canClose = char === "_" ? rightFlanking && (!leftFlanking || isPunctuation(after)) : rightFlanking;
+		if (canOpen || canClose) for (let position = index; position < end; position++) edits.push({
+			at: position,
+			deleteCount: 0,
+			insert: "\\"
+		});
+		index = end;
+	}
+	return edits;
+}
+/**
+* Hazards that only matter at the start (or, for a handful of whole-line
+* constructs, the start *and* end) of a line: headings, blockquotes, list
+* markers, ref-defs, setext underlines, thematic breaks, indented code, and
+* a list item's own GFM task-checkbox prefix. A fence needs no branch of
+* its own here: the inline backtick/tilde escaping every line already
+* neutralizes the run a fence needs, so it can never open one on reparse.
+* The remaining branches are mutually exclusive by construction
+* (each targets a disjoint leading character) and return as soon as one
+* matches, mirroring how CommonMark itself commits to one block-start
+* interpretation per line; the checkbox branch above is the one exception,
+* since a list item's checkbox prefix and, say, its heading marker are two
+* independent hazards that can both apply to the same first line.
+*/
+function collectLineStartEdits(text, context) {
+	let edits = [], isFirstLine = context.lineIndex === 0, leadingSpaces = /^ {0,3}/.exec(text)?.[0].length ?? 0, rest = text.slice(leadingSpaces);
+	if (context.isListItem && isFirstLine && /^\[[ xX]\] /.test(rest) && edits.push({
+		at: leadingSpaces,
+		deleteCount: 0,
+		insert: "\\"
+	}), context.isHeading && isFirstLine) {
+		let closingSequence = /^(?:(.*[ \t]))?(#+[ \t]*)$/.exec(text);
+		return closingSequence && edits.push({
+			at: closingSequence[1]?.length ?? 0,
+			deleteCount: 0,
+			insert: "\\"
+		}), edits;
+	}
+	let orderedListMarker = /^ {0,3}(\d{1,9})([.)])(?=[ \t]|$)/.exec(text);
+	if (orderedListMarker) return edits.push({
+		at: orderedListMarker[0].length - 1,
+		deleteCount: 0,
+		insert: "\\"
+	}), edits;
+	if (/^#{1,6}(?:[ \t]|$)/.test(rest) || rest.startsWith(">") || /^\[[^\]\n]*\]:/.test(rest) || /^[-+*](?:[ \t]|$)/.test(rest) || /^ {0,3}([-*_])(?:[ \t]*\1){2,}[ \t]*$/.test(text) || /^ {0,3}=+[ \t]*$/.test(text) || /^ {0,3}-+[ \t]*$/.test(text)) return edits.push({
+		at: leadingSpaces,
+		deleteCount: 0,
+		insert: "\\"
+	}), edits;
+	if (/^ {4}/.test(text)) return edits.push({
+		at: 0,
+		deleteCount: 1,
+		insert: "&#32;"
+	}), edits;
+	let tabIndent = /^ {0,3}\t/.exec(text);
+	return tabIndent && edits.push({
+		at: tabIndent[0].length - 1,
+		deleteCount: 1,
+		insert: "&#9;"
+	}), edits;
+}
+/**
+* Text rendered inside a link label needs every `[`, `]` and `\` escaped
+* unconditionally, on top of the general-purpose hazard escaping every
+* line gets: a link label must stay bracket-balanced, and any literal
+* backslash in it needs protecting regardless of what follows (unlike
+* plain text, where only a backslash immediately before punctuation is a
+* hazard).
+*/
+function escapeLinkLabelBrackets(text) {
+	return text.replace(/[[\]\\]/g, (char) => `\\${char}`);
+}
+/**
+* Blocks currently known to be a list item's first content block: it shares
+* its first line with the list marker (and, for a task item, its GFM
+* checkbox), which changes how `renderBlock` plans line-start hazard
+* escaping. Internal to this package so the signal never reaches the
+* public `Serializable`/`RenderNode` types a custom renderer's `.d.ts`
+* would otherwise expose it through.
+*
+* A block is marked right before rendering it; the `renderNode` call that
+* dispatches to `renderBlock` consumes the membership on the way past so a
+* later, unrelated render of the same object (still possible - `renderNode`
+* accepts any `TypedObject`) doesn't inherit a stale claim.
+*/
+const listItemFirstBlocks = /* @__PURE__ */ new WeakSet();
+function markListItemFirstBlock(block) {
+	listItemFirstBlocks.add(block);
+}
+function consumeListItemFirstBlock(block) {
+	let isListItemFirstBlock = listItemFirstBlocks.has(block);
+	return listItemFirstBlocks.delete(block), isListItemFirstBlock;
+}
+/**
+* ATX headings are single-line, inline-only leaf blocks: an ATX heading's
+* first line sits inside its `# ` prefix and can never be reparsed as a
+* block construct, so line-leading hazards never apply there. A hard
+* break's later lines are ordinary markdown lines outside that prefix and
+* get the full line-start battery, same as any other block's continuation.
+*/
+const HEADING_STYLES = /* @__PURE__ */ new Set([
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6"
+]), createRenderNode = (renderers, listIndexMap, listDepthMap) => {
+	let escapedTextByNode = /* @__PURE__ */ new WeakMap(), hardBreakOutputHasNewline = renderers.hardBreak().includes("\n");
+	function renderBlockChildren(node, isHeading, isListItem = !1) {
+		let chunks = planLeafEscaping(node.children ?? [], node.markDefs ?? [], {
+			isHeading,
+			isListItem,
+			hardBreakOutputHasNewline
+		}), tree = buildMarksTree(node);
+		return assignEscapedText(tree, chunks), tree.map((child, i) => renderNode({
 			node: child,
 			isInline: !0,
 			index: i,
 			renderNode
 		})).join("");
+	}
+	function assignEscapedText(nodes, chunks) {
+		let pointer = 0, visit = (node) => {
+			if (isPortableTextToolkitTextNode(node)) {
+				if (node.text !== "\n") {
+					let escaped = chunks[pointer];
+					escaped !== void 0 && escapedTextByNode.set(node, escaped), pointer++;
+				}
+				return;
+			}
+			isPortableTextToolkitSpan(node) && node.children.forEach(visit);
+		};
+		nodes.forEach(visit);
+	}
+	function renderNode(options) {
+		let { node, index, isInline } = options;
+		return isPortableTextListItemBlock(node) ? renderListItem(node, index) : isPortableTextToolkitSpan(node) ? renderSpan(node) : isPortableTextBlock(node) ? renderBlock(node, index, isInline, consumeListItemFirstBlock(node)) : isPortableTextToolkitTextNode(node) ? renderText(node) : renderCustomBlock(node, index, isInline);
+	}
+	function renderListItem(node, index) {
+		let renderer = renderers.listItem, itemHandler = (typeof renderer == "function" ? renderer : renderer[node.listItem]) || renderers.unknownListItem, children;
 		if (node.style && node.style !== "normal") {
 			let { listItem: _listItem, ...blockNode } = node;
-			children = renderNode({
+			markListItemFirstBlock(blockNode), children = renderNode({
 				node: blockNode,
 				index,
 				isInline: !1,
 				renderNode
 			}), children = children.replace(/\n+$/, "");
-		}
+		} else children = renderBlockChildren(node, !1, !0);
 		return itemHandler({
 			value: node,
 			index,
@@ -138,21 +543,18 @@ const createRenderNode = (renderers, listIndexMap, listDepthMap) => {
 			children: children.join("")
 		});
 	}
-	function renderBlock(node, index, isInline) {
-		let { _key, ...props } = serializeBlock({
-			node,
+	function renderBlock(node, index, isInline, isListItem) {
+		let style = node.style || "normal", children = renderBlockChildren(node, HEADING_STYLES.has(style), isListItem);
+		return ((typeof renderers.block == "function" ? renderers.block : renderers.block[style]) || renderers.unknownBlockStyle)({
 			index,
 			isInline,
-			renderNode
-		}), style = props.node.style || "normal";
-		return ((typeof renderers.block == "function" ? renderers.block : renderers.block[style]) || renderers.unknownBlockStyle)({
-			...props,
-			value: props.node,
+			children,
+			value: node,
 			renderNode
 		});
 	}
 	function renderText(node) {
-		return node.text === "\n" ? renderers.hardBreak() : node.text;
+		return node.text === "\n" ? renderers.hardBreak() : escapedTextByNode.get(node) ?? node.text;
 	}
 	function renderCustomBlock(value, index, isInline) {
 		return (renderers.types[value._type] ?? renderers.unknownType)({
@@ -163,26 +565,7 @@ const createRenderNode = (renderers, listIndexMap, listDepthMap) => {
 		});
 	}
 	return renderNode;
-};
-function serializeBlock(options) {
-	let { node, index, isInline, renderNode } = options, renderedChildren = buildMarksTree(node).map((child, i) => renderNode({
-		node: child,
-		isInline: !0,
-		index: i,
-		renderNode
-	}));
-	return {
-		_key: node._key || defaultKeyGenerator(),
-		children: renderedChildren.join(""),
-		index,
-		isInline,
-		node
-	};
-}
-/**
-* @public
-*/
-const DefaultBlockSpacingRenderer = ({ current, next }) => isPortableTextListItemBlock(current) && isPortableTextListItemBlock(next) ? "\n" : isPortableTextBlock(current) && isPortableTextBlock(next) && current.style === "blockquote" && next.style === "blockquote" ? "\n>\n" : "\n\n", DefaultHardBreakRenderer = () => "  \n", DefaultListItemRenderer = ({ children, value, listIndex, listDepth }) => {
+}, DefaultBlockSpacingRenderer = ({ current, next }) => isPortableTextListItemBlock(current) && isPortableTextListItemBlock(next) ? "\n" : isPortableTextBlock(current) && isPortableTextBlock(next) && current.style === "blockquote" && next.style === "blockquote" ? "\n>\n" : "\n\n", DefaultHardBreakRenderer = () => "  \n", DefaultListItemRenderer = ({ children, value, listIndex, listDepth }) => {
 	let listStyle = value.listItem || "bullet", depth = listDepth ?? (value.level || 1) - 1, indent = "   ".repeat(depth);
 	return listStyle === "number" ? `${indent}${listIndex ?? 1}. ${children}` : listStyle === "task" ? `${indent}- ${"checked" in value && typeof value.checked == "boolean" && value.checked ? "[x]" : "[ ]"} ${children}` : `${indent}- ${children}`;
 }, DefaultUnknownListItemRenderer = ({ children }) => `- ${children}\n`;
@@ -208,32 +591,39 @@ function escapeImageAndLinkTitle(text) {
 * Escapes characters that have special meaning at the row level of a GFM
 * table cell.
 *
-* A literal `|` ends the cell, so unescaped pipes are replaced with `\|`.
-* Newlines end the row, so they are replaced with `<br>` to keep the
-* visible line break inside the cell. Already-escaped pipes (`\|`) are
-* left intact so that escapes introduced by mark renderers survive the
-* pass.
+* A literal `|` ends the cell, so a pipe preceded by an even number of
+* backslashes (including zero) gets one more: paired backslashes cancel
+* out to a literal backslash and leave the pipe live, so parity, not mere
+* presence, decides whether it is already escaped. Newlines end the row,
+* so they are replaced with `<br>` to keep the visible line break inside
+* the cell.
 *
-* Backslashes are intentionally not escaped here so that other escapes
-* already in the rendered cell (such as `\[` and `\]` in link text) are
-* not double-escaped.
+* Backslashes themselves are left alone here; only the parity check reads
+* them, so escapes already in the rendered cell (such as `\[` and `\]` in
+* link text) survive the pass untouched.
 */
 function escapeTableCell(text) {
-	return text.replace(RegExp("(?<!\\\\)\\|", "g"), "\\|").replace(/\n/g, "<br>");
+	return text.replace(/(\\*)\|/g, (match, backslashes) => backslashes.length % 2 == 0 ? `${backslashes}\\|` : match).replace(/\n/g, "<br>");
+}
+/**
+* @public
+*/
+const DefaultEmRenderer = ({ children }) => `_${children}_`, DefaultStrongRenderer = ({ children }) => `**${children}**`, DefaultCodeRenderer = ({ text }) => wrapInCodeSpan(text);
+function wrapInCodeSpan(text) {
+	let fence = "`".repeat(longestBacktickRun(text) + 1), touchesBacktick = text.startsWith("`") || text.endsWith("`"), wouldBeStripped = text.startsWith(" ") && text.endsWith(" ") && text.trim() !== "", padding = touchesBacktick || wouldBeStripped ? " " : "";
+	return `${fence}${padding}${text}${padding}${fence}`;
+}
+function longestBacktickRun(text) {
+	let longest = 0;
+	for (let run of text.match(/`+/g) ?? []) longest = Math.max(longest, run.length);
+	return longest;
 }
 /**
 * @public
 */
-const DefaultEmRenderer = ({ children }) => `_${children}_`, DefaultStrongRenderer = ({ children }) => `**${children}**`, DefaultCodeRenderer = ({ children }) => `\`${children}\``, DefaultUnderlineRenderer = ({ children }) => `<u>${children}</u>`, DefaultStrikeThroughRenderer = ({ children }) => `~~${children}~~`, DefaultLinkRenderer = ({ children, value }) => {
+const DefaultUnderlineRenderer = ({ children }) => `<u>${children}</u>`, DefaultStrikeThroughRenderer = ({ children }) => `~~${children}~~`, DefaultLinkRenderer = ({ children, value }) => {
 	let href = value?.href || "", title = value?.title || "";
-	if (uriLooksSafe(href)) {
-		if (/["'][^"']*[<>]|[<>][^<>]*["']/.test(href)) {
-			let encodedHref = href.replace(/["<>() ]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`);
-			return `[${escapeImageAndLinkText(children)}](${encodedHref})`;
-		}
-		return `[${escapeImageAndLinkText(children)}](${href}${title ? ` "${escapeImageAndLinkTitle(title)}"` : ""})`;
-	}
-	return children;
+	return uriLooksSafe(href) ? /["'][^"']*[<>]|[<>][^<>]*["']/.test(href) ? `[${children}](${href.replace(/["<>() ]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`)})` : `[${children}](${href}${title ? ` "${escapeImageAndLinkTitle(title)}"` : ""})` : children;
 };
 function uriLooksSafe(uri) {
 	let url = (uri || "").trim(), first = url.charAt(0);
@@ -267,7 +657,7 @@ function isCodeShaped(value) {
 * as absent instead of guarded.
 */
 function normalizeLanguage(language) {
-	return typeof language != "string" || language.includes("\n") ? "" : language;
+	return typeof language != "string" || language.includes("\n") || language === "json:object" ? "" : language;
 }
 /**
 * @public
@@ -393,7 +783,7 @@ const DefaultBlockquoteObjectRenderer = ({ value, renderNode }) => value.content
 })).join("\n\n").split("\n").map((line) => line === "" ? ">" : `> ${line}`).join("\n"), DefaultListRenderer = ({ value, renderNode }) => {
 	let itemSeparator = value.items.some((item) => item.content.filter((block) => block._type !== "list").length > 1) ? "\n\n" : "\n";
 	return value.items.map((item, itemIndex) => {
-		let marker = getListMarker(value.kind, itemIndex, item.checked), indentWidth = value.kind === "task" ? 2 : marker.length, indent = " ".repeat(indentWidth), [first, ...rest] = item.content.map((block, blockIndex) => ({
+		let marker = getListMarker(value.kind, itemIndex, item.checked), indentWidth = value.kind === "task" ? 2 : marker.length, indent = " ".repeat(indentWidth), [first, ...rest] = item.content.map((block, blockIndex) => (blockIndex === 0 && isPortableTextBlock(block) && markListItemFirstBlock(block), {
 			isNestedList: block._type === "list",
 			text: renderNode({
 				node: block,
@@ -414,10 +804,7 @@ function getListMarker(kind, itemIndex, checked) {
 /**
 * @public
 */
-const DefaultUnknownTypeRenderer = ({ value, isInline }) => {
-	let json = `\`\`\`json\n${JSON.stringify(value, null, 2)}\n\`\`\``;
-	return isInline ? `\n${json}\n` : json;
-}, defaultRenderers = {
+const DefaultUnknownTypeRenderer = ({ value, isInline }) => isInline ? `json:object${wrapInCodeSpan(JSON.stringify(value))}` : `\`\`\`json:object\n${JSON.stringify(value, null, 2)}\n\`\`\``, defaultRenderers = {
 	types: {
 		callout: DefaultCalloutRenderer,
 		code: DefaultCodeBlockRenderer,
@@ -611,7 +998,66 @@ const normalStyleDefinition = { name: "normal" }, h1StyleDefinition = { name: "h
 		defaultTableObjectDefinition
 	],
 	inlineObjects: [defaultImageObjectDefinition]
-}));
+})), degradationMessage = {
+	"decorator-dropped": (decorator) => {
+		switch (decorator) {
+			case "code": return "Removed inline-code formatting, kept the text: the schema has no `code` decorator";
+			case "strong": return "Removed bold formatting, kept the text: the schema has no `strong` decorator";
+			case "em": return "Removed italic formatting, kept the text: the schema has no `em` decorator";
+			case "strikeThrough": return "Removed strikethrough formatting, kept the text: the schema has no `strike-through` decorator";
+		}
+	},
+	"annotation-dropped": (cause) => cause === "missing-url" ? "Removed a link that has no URL, kept its text" : "Removed the link, kept its text: the schema has no `link` annotation",
+	"style-fallback": (name) => /^h[1-6]$/.test(name) ? `\`${"#".repeat(Number(name.slice(1)))}\` heading became a normal paragraph: the schema has no \`${name}\` style` : name === "blockquote" ? "Blockquote became normal paragraphs: the schema has no `blockquote` style" : `Fell back to \`normal\` style: \`${name}\` not in schema`,
+	"list-flattened": (kind) => `${kind === "number" ? "Numbered" : "Bullet"} list became plain paragraphs: the schema has no \`${kind}\` list`,
+	"task-checkbox-stripped": (checked) => `Removed the \`${checked ? "[x]" : "[ ]"}\` checkbox, kept a plain list item: the schema has no \`task\` list`,
+	"table-flattened": "Table became plain text blocks, rows and columns lost: the schema has no `table` block object",
+	"code-block-to-text": (language) => language ? `\`${language}\` code block became plain text: the schema has no \`code\` block object` : "Code block became plain text: the schema has no `code` block object",
+	"horizontal-rule-to-text": "Horizontal rule became the text `---`: the schema has no `horizontal-rule` block object",
+	"html-block-to-text": "HTML block became plain text: the schema has no `html` block object",
+	"inline-html-dropped": "Removed inline HTML tags, kept nothing: `html.inline` is `skip` (the default)",
+	"image-block-to-inline": (cause) => cause === "table-cell" ? "The image became inline: a table cell can't hold a block-level `image`" : "The image became inline: the schema has no block-level `image`",
+	"image-inline-to-block": "The image became its own block, splitting the paragraph: the schema has no inline `image`",
+	"image-to-text": "Image became its markdown source as plain text: the schema has no `image` object",
+	"callout-fallback": (calloutType, style) => `\`[!${calloutType.toUpperCase()}]\` callout became ${style}-styled text: the schema has no \`callout\` block object`,
+	"fields-dropped": (names, construct) => `Dropped ${names} from \`${construct}\`: not in the schema's \`${construct}\` fields`,
+	"object-carrier-invalid": (kind, payload) => kind === "fence" ? `\`json:object\` fence fell back to a code block: ${describeObjectCarrierFailure(payload)}` : `\`json:object\`-tagged code span fell back to a plain code span: ${describeObjectCarrierFailure(payload)}`
+};
+/**
+* Names why a `json:object` payload failed to parse as an object carrier:
+* a payload that isn't a JSON object at all reads differently from one
+* that is but has no usable `_type`.
+*/
+function describeObjectCarrierFailure(payload) {
+	let parsed;
+	try {
+		parsed = JSON.parse(payload);
+	} catch {
+		return "the payload is not valid JSON";
+	}
+	return typeof parsed != "object" || !parsed || Array.isArray(parsed) ? "the payload is not a JSON object" : "the payload has no string `_type`";
+}
+const droppedFieldsTag = Symbol("droppedFields");
+function readDroppedFields(object) {
+	if (object) return object[droppedFieldsTag];
+}
+function buildFilteredObject(schemaDefinition, value, keyGenerator) {
+	let filteredValue = schemaDefinition.fields.reduce((filteredValue, field) => {
+		let fieldValue = value[field.name];
+		return fieldValue !== void 0 && (filteredValue[field.name] = fieldValue), filteredValue;
+	}, {}), object = {
+		_key: keyGenerator(),
+		_type: schemaDefinition.name,
+		...filteredValue
+	}, droppedKeys = Object.entries(value).filter(([, fieldValue]) => fieldValue !== void 0).map(([key]) => key).filter((key) => !(key in filteredValue));
+	return droppedKeys.length > 0 && Object.defineProperty(object, droppedFieldsTag, {
+		value: {
+			construct: schemaDefinition.name,
+			keys: droppedKeys
+		},
+		enumerable: !1
+	}), object;
+}
 function buildStyleMatcher(definition) {
 	return ({ context }) => {
 		let schemaDefinition = context.schema.styles.find((item) => item.name === definition.name);
@@ -633,31 +1079,13 @@ function buildDecoratorMatcher(definition) {
 function buildAnnotationMatcher(definition) {
 	return ({ context, value }) => {
 		let schemaDefinition = context.schema.annotations.find((item) => item.name === definition.name);
-		if (!schemaDefinition) return;
-		let filteredValue = schemaDefinition.fields.reduce((filteredValue, field) => {
-			let fieldValue = value[field.name];
-			return fieldValue !== void 0 && (filteredValue[field.name] = fieldValue), filteredValue;
-		}, {});
-		return {
-			_key: context.keyGenerator(),
-			_type: schemaDefinition.name,
-			...filteredValue
-		};
+		if (schemaDefinition) return buildFilteredObject(schemaDefinition, value, context.keyGenerator);
 	};
 }
 function buildObjectMatcher(definition) {
 	return ({ context, value, isInline }) => {
 		let schemaDefinition = (isInline ? context.schema.inlineObjects : context.schema.blockObjects).find((item) => item.name === definition.name);
-		if (!schemaDefinition) return;
-		let filteredValue = schemaDefinition.fields.reduce((filteredValue, field) => {
-			let fieldValue = value[field.name];
-			return fieldValue !== void 0 && (filteredValue[field.name] = fieldValue), filteredValue;
-		}, {});
-		return {
-			_key: context.keyGenerator(),
-			_type: schemaDefinition.name,
-			...filteredValue
-		};
+		if (schemaDefinition) return buildFilteredObject(schemaDefinition, value, context.keyGenerator);
 	};
 }
 const codeBlockMatcher = ({ context, value, isInline }) => {
@@ -742,6 +1170,83 @@ function flattenTable(table, portableText) {
 	for (let row of table.rows) for (let cell of row.cells) for (let block of cell.value) portableText.push(block);
 }
 /**
+* Truncates a degradation message's snippet to keep the thrown/reported
+* message readable. Truncates on character count, not word boundaries: the
+* snippet is a diagnostic pointer back to the source, not prose. Undefined
+* for empty input, so a construct with nothing to quote (an empty link's
+* text, say) omits `snippet` entirely instead of reporting `""`. Backs the
+* cut off by one unit when it would land on a lead surrogate, so a snippet
+* ending mid-emoji doesn't produce an unpaired surrogate. A literal newline
+* surviving into the snippet is escaped to `\n`, since the reported message
+* is one line per finding.
+*/
+function truncateSnippet(text, maxLength = 40) {
+	if (text.length === 0) return;
+	if (text.length <= maxLength) return text.replace(/\n/g, "\\n");
+	let cut = maxLength, codeUnit = text.charCodeAt(cut - 1);
+	return codeUnit >= 55296 && codeUnit <= 56319 && --cut, `${text.slice(0, cut).replace(/\n/g, "\\n")}...`;
+}
+/**
+* Concatenates the plain text between an inline open token (`strong_open`,
+* `em_open`, `s_open`, `link_open`) and its matching close, for use as a
+* degradation message snippet. Tracks nesting depth so a same-type token
+* nested inside itself doesn't stop the scan at the wrong close.
+*/
+function collectInlineText(children, openIndex, openType, closeType) {
+	let depth = 1, text = "";
+	for (let i = openIndex + 1; i < children.length; i++) {
+		let child = children[i];
+		if (child) {
+			if (child.type === openType) depth++;
+			else if (child.type === closeType) {
+				if (depth--, depth === 0) break;
+			} else child.type === "text" ? text += child.content : child.type === "softbreak" ? text += " " : child.type === "hardbreak" && (text += "\n");
+		}
+	}
+	return text;
+}
+function capList(values) {
+	if (values.length <= 5) return values.join(", ");
+	let shown = values.slice(0, 5), more = values.length - 5;
+	return `${shown.join(", ")}, and ${more} more`;
+}
+/**
+* Builds the canonical grouped message reported alongside a non-empty
+* `degradations` array: identical (`type`, `message`) pairs collapse into one
+* line, so a document with the same missing decorator on three spans
+* doesn't repeat the same sentence three times. Groups sort by their
+* earliest-lined entry so the message reads top-to-bottom regardless of walk
+* order: nested constructs (a blockquote inside a blockquote, say) report
+* the innermost closing first even though it opened last, and that line may
+* arrive after another entry already in the group. Groups without any lined
+* entry sort last, in their relative encounter order.
+*/
+function buildDegradationMessage(degradations) {
+	let groups = [], groupIndexByKey = /* @__PURE__ */ new Map();
+	for (let degradation of degradations) {
+		let key = `${degradation.type}\u0000${degradation.message}`, groupIndex = groupIndexByKey.get(key);
+		groupIndex === void 0 && (groupIndex = groups.length, groupIndexByKey.set(key, groupIndex), groups.push({
+			base: degradation.message,
+			entries: []
+		})), groups[groupIndex].entries.push(degradation);
+	}
+	let minLine = (entries) => {
+		let definedLines = entries.map((entry) => entry.line).filter((line) => line !== void 0);
+		return definedLines.length > 0 ? Math.min(...definedLines) : void 0;
+	};
+	return ["Markdown could not be converted without loss:", ...[...groups].sort((a, b) => {
+		let lineA = minLine(a.entries), lineB = minLine(b.entries);
+		return lineA === void 0 ? lineB === void 0 ? 0 : 1 : lineB === void 0 ? -1 : lineA - lineB;
+	}).map((group) => {
+		if (group.entries.length === 1) {
+			let event = group.entries[0], snippetPart = event.snippet === void 0 ? "" : ` ("${event.snippet}")`;
+			return event.line === void 0 ? `- ${event.message}${snippetPart}` : `- line ${event.line}: ${event.message}${snippetPart}`;
+		}
+		let snippets = group.entries.map((entry) => entry.snippet).filter((snippet) => snippet !== void 0), linesAscending = [...new Set(group.entries.map((entry) => entry.line).filter((line) => line !== void 0).sort((a, b) => a - b))], count = group.entries.length, suffix = snippets.length === count ? `(${count}\u00d7: ${capList(snippets.map((snippet) => `"${snippet}"`))})` : linesAscending.length > 0 ? `(${count}\u00d7: lines ${capList(linesAscending.map(String))})` : `(${count}\u00d7)`;
+		return `- ${group.base} ${suffix}`;
+	})].join("\n");
+}
+/**
 * Converts a markdown string to an array of Portable Text blocks.
 *
 * @public
@@ -767,11 +1272,46 @@ function markdownToPortableText(markdown, options) {
 			...defaultOptions.types,
 			...options?.types
 		}
+	}, degradationEvents = [], report = (event) => {
+		degradationEvents.push(event);
+	}, lineOf = (candidateToken) => candidateToken?.map ? candidateToken.map[0] + 1 : void 0, reportStyleFallback = (name, line, snippet) => {
+		if (/^h[1-6]$/.test(name)) {
+			let truncated = snippet === void 0 ? void 0 : truncateSnippet(snippet);
+			report({
+				type: "style-fallback",
+				message: degradationMessage["style-fallback"](name),
+				line,
+				snippet: truncated
+			});
+			return;
+		}
+		if (name === "blockquote") {
+			report({
+				type: "style-fallback",
+				message: degradationMessage["style-fallback"](name),
+				line
+			});
+			return;
+		}
+		report({
+			type: "style-fallback",
+			message: degradationMessage["style-fallback"](name),
+			line
+		});
+	}, reportFieldsDropped = (object, line) => {
+		let dropped = readDroppedFields(object);
+		if (!dropped) return;
+		let names = dropped.keys.map((key) => `\`${key}\``).join(", ");
+		report({
+			type: "fields-dropped",
+			message: degradationMessage["fields-dropped"](names, dropped.construct),
+			line
+		});
 	}, tokens = markdownit({
 		html: !0,
 		linkify: !0,
 		typographer: !1
-	}).enable(["strikethrough", "table"]).use(alert).parse(markdown, {}), taskCheckedByListItemIndex = /* @__PURE__ */ new Map();
+	}).enable(["strikethrough", "table"]).use(alert).parse(markdown, {}), taskCheckedByListItemIndex = /* @__PURE__ */ new Map(), taskItemTextByListItemIndex = /* @__PURE__ */ new Map();
 	for (let i = 0; i < tokens.length; i++) {
 		if (tokens[i]?.type !== "list_item_open") continue;
 		let inlineIndex = -1;
@@ -791,11 +1331,11 @@ function markdownToPortableText(markdown, options) {
 		let match = inlineToken.content.match(/^\[([ xX])\] /);
 		if (!match) continue;
 		let checked = match[1] !== " ";
-		taskCheckedByListItemIndex.set(i, checked), inlineToken.content = inlineToken.content.slice(match[0].length);
+		taskCheckedByListItemIndex.set(i, checked), inlineToken.content = inlineToken.content.slice(match[0].length), taskItemTextByListItemIndex.set(i, inlineToken.content);
 		let firstChild = inlineToken.children?.[0];
 		firstChild && typeof firstChild.content == "string" && (firstChild.content = firstChild.content.slice(match[0].length));
 	}
-	let portableText = [], currentBlock = null, currentListStack = [], markDefRefs = [], currentMarkDefs = [], currentBlockquoteStyle = null, inListItem = !1, calloutStartIndex = null, calloutStartTarget = null, calloutType = null, blockquoteStack = [], currentTable = null, currentTableRow = null, inTableHead = !1, listContainerStack = [], blockTarget = () => {
+	let portableText = [], currentBlock = null, currentListStack = [], markDefRefs = [], currentMarkDefs = [], currentBlockquoteStyle = null, inListItem = !1, currentBlockTookBlockquoteStyle = !1, currentBlockIsPlainParagraph = !1, plainParagraphBlocks = /* @__PURE__ */ new WeakSet(), calloutStartIndex = null, calloutStartTarget = null, calloutType = null, calloutStartLine, calloutPendingStyleFallbacks = [], blockquoteStack = [], currentTable = null, currentTableRow = null, inTableHead = !1, demotedTableImages = /* @__PURE__ */ new WeakMap(), listContainerStack = [], pendingListFlattenedStack = [], taskInfoByListItem = /* @__PURE__ */ new WeakMap(), blockTarget = () => {
 		for (let i = listContainerStack.length - 1; i >= 0; i--) {
 			let frame = listContainerStack[i];
 			if (frame && frame.currentItem) return frame.currentItem.content;
@@ -803,26 +1343,35 @@ function markdownToPortableText(markdown, options) {
 		return portableText;
 	}, pushBlock = (block) => {
 		blockTarget().push(block);
-	}, startBlock = (style) => {
+	}, startBlock = (style, provenance) => {
 		flushBlock(), currentBlock = {
 			_type: "block",
 			style,
 			children: [],
 			_key: consolidatedOptions.keyGenerator(),
 			markDefs: []
-		}, currentMarkDefs = [];
+		}, currentMarkDefs = [], currentBlockTookBlockquoteStyle = provenance?.tookBlockquoteStyle ?? !1, currentBlockIsPlainParagraph = provenance?.isPlainParagraph ?? !1;
 	}, flushBlock = () => {
-		currentBlock && (currentBlock.children.length === 0 && currentBlock.children.push({
-			_type: consolidatedOptions.schema.span.name,
-			_key: consolidatedOptions.keyGenerator(),
-			text: "",
-			marks: []
-		}), currentBlock.markDefs = currentMarkDefs, pushBlock(currentBlock), currentBlock = null, currentMarkDefs = []);
+		if (currentBlock) {
+			if (calloutPendingStyleFallbacks.length > 0 && currentBlockTookBlockquoteStyle) {
+				for (let name of calloutPendingStyleFallbacks) reportStyleFallback(name, calloutStartLine);
+				calloutPendingStyleFallbacks = [];
+			}
+			currentBlock.children.length === 0 && currentBlock.children.push({
+				_type: consolidatedOptions.schema.span.name,
+				_key: consolidatedOptions.keyGenerator(),
+				text: "",
+				marks: []
+			}), currentBlock.markDefs = currentMarkDefs, currentBlockIsPlainParagraph && plainParagraphBlocks.add(currentBlock), pushBlock(currentBlock), currentBlock = null, currentMarkDefs = [];
+		}
 	}, addSpan = (text) => {
 		if (text.length === 0) return;
 		if (!currentBlock) {
 			let style = currentBlockquoteStyle ?? consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
-			style ? startBlock(style) : (console.warn("No default style found, using \"normal\""), startBlock("normal"));
+			style ? startBlock(style, {
+				tookBlockquoteStyle: currentBlockquoteStyle !== null,
+				isPlainParagraph: !0
+			}) : (reportStyleFallback("normal"), startBlock("normal", { isPlainParagraph: !0 }));
 		}
 		if (!currentBlock) throw Error("Expected current block");
 		let lastChild = currentBlock.children.at(-1);
@@ -835,7 +1384,7 @@ function markdownToPortableText(markdown, options) {
 	}, listLevel = () => currentListStack.length, ensureListBlock = (listItem, checked) => {
 		if (!currentBlock) {
 			let style = currentBlockquoteStyle ?? consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
-			style ? startBlock(style) : (console.warn("No default style found, using \"normal\""), startBlock("normal"));
+			style ? startBlock(style, { tookBlockquoteStyle: currentBlockquoteStyle !== null }) : (reportStyleFallback("normal"), startBlock("normal"));
 		}
 		if (!currentBlock) throw Error("Expected current block");
 		(currentBlock.listItem !== listItem || currentBlock.level !== listLevel()) && (currentBlock.listItem = listItem, currentBlock.level = listLevel()), checked !== void 0 && (currentBlock.checked = checked);
@@ -846,7 +1395,13 @@ function markdownToPortableText(markdown, options) {
 			case "paragraph_open": {
 				if (inListItem) {
 					if (listContainerStack.at(-1)) {
-						currentBlock || startBlock(currentBlockquoteStyle ?? consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } }) ?? "normal");
+						if (!currentBlock) {
+							let style = currentBlockquoteStyle ?? consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
+							style || reportStyleFallback("normal", lineOf(token)), startBlock(style ?? "normal", {
+								tookBlockquoteStyle: currentBlockquoteStyle !== null,
+								isPlainParagraph: !0
+							});
+						}
 						break;
 					}
 					if (!currentBlock) {
@@ -857,10 +1412,13 @@ function markdownToPortableText(markdown, options) {
 				}
 				let style = currentBlockquoteStyle ?? consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
 				if (!style) {
-					console.warn("No default style found, using \"normal\""), startBlock("normal");
+					reportStyleFallback("normal", lineOf(token)), startBlock("normal", { isPlainParagraph: !0 });
 					break;
 				}
-				startBlock(style);
+				startBlock(style, {
+					tookBlockquoteStyle: currentBlockquoteStyle !== null,
+					isPlainParagraph: !0
+				});
 				break;
 			}
 			case "paragraph_close":
@@ -878,9 +1436,11 @@ function markdownToPortableText(markdown, options) {
 					4: consolidatedOptions.block.h4,
 					5: consolidatedOptions.block.h5,
 					6: consolidatedOptions.block.h6
-				}[level], style = headingMatcher?.({ context: { schema: consolidatedOptions.schema } }) ?? consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
+				}[level], headingStyle = headingMatcher?.({ context: { schema: consolidatedOptions.schema } });
+				headingStyle || reportStyleFallback(`h${level}`, lineOf(token), tokens[tokenIndex + 1]?.content);
+				let style = headingStyle ?? consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
 				if (!style) {
-					console.warn("No heading style found, using \"normal\""), startBlock("normal");
+					reportStyleFallback("normal", lineOf(token)), startBlock("normal");
 					break;
 				}
 				startBlock(style);
@@ -889,17 +1449,22 @@ function markdownToPortableText(markdown, options) {
 			case "heading_close":
 				flushBlock();
 				break;
-			case "blockquote_open":
+			case "blockquote_open": {
 				if (flushBlock(), consolidatedOptions.types.blockquote) {
 					let startTarget = blockTarget();
 					blockquoteStack.push({
 						startTarget,
-						startIndex: startTarget.length
+						startIndex: startTarget.length,
+						line: lineOf(token)
 					});
 					break;
 				}
-				currentBlockquoteStyle = consolidatedOptions.block.blockquote({ context: { schema: consolidatedOptions.schema } }) ?? consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } }) ?? "normal";
+				let blockquoteStyle = consolidatedOptions.block.blockquote({ context: { schema: consolidatedOptions.schema } });
+				blockquoteStyle || reportStyleFallback("blockquote", lineOf(token));
+				let style = blockquoteStyle ?? consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
+				style || reportStyleFallback("normal", lineOf(token)), currentBlockquoteStyle = style ?? "normal";
 				break;
+			}
 			case "blockquote_close":
 				if (flushBlock(), consolidatedOptions.types.blockquote && blockquoteStack.length > 0) {
 					let frame = blockquoteStack.pop();
@@ -914,11 +1479,18 @@ function markdownToPortableText(markdown, options) {
 						});
 						if (blockquoteObject) pushBlock(blockquoteObject);
 						else {
-							let blockquoteStyle = consolidatedOptions.block.blockquote({ context: { schema: consolidatedOptions.schema } }) ?? consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } }) ?? "blockquote";
-							for (let block of contentBlocks) block._type === "block" ? pushBlock({
-								...block,
-								style: blockquoteStyle
-							}) : pushBlock(block);
+							let blockquoteStyle = consolidatedOptions.block.blockquote({ context: { schema: consolidatedOptions.schema } });
+							blockquoteStyle || reportStyleFallback("blockquote", frame.line);
+							let resolvedStyle = blockquoteStyle ?? consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
+							resolvedStyle || reportStyleFallback("normal", frame.line);
+							let fallbackStyle = resolvedStyle ?? "blockquote";
+							for (let block of contentBlocks) if (block._type === "block" && plainParagraphBlocks.has(block)) {
+								let restyledBlock = {
+									...block,
+									style: fallbackStyle
+								};
+								plainParagraphBlocks.add(restyledBlock), pushBlock(restyledBlock);
+							} else pushBlock(block);
 						}
 					}
 					break;
@@ -930,16 +1502,21 @@ function markdownToPortableText(markdown, options) {
 					listContainerStack.push({
 						kind: "bullet",
 						items: [],
-						currentItem: null
-					}), currentListStack.push(null);
+						currentItem: null,
+						line: lineOf(token)
+					}), currentListStack.push(null), pendingListFlattenedStack.push(null);
 					break;
 				}
 				let listItem = consolidatedOptions.listItem.bullet({ context: { schema: consolidatedOptions.schema } });
 				if (listContainerStack.push(null), !listItem) {
-					currentListStack.push(null);
+					pendingListFlattenedStack.push({
+						line: lineOf(token),
+						kindName: "bullet",
+						reported: !1
+					}), currentListStack.push(null);
 					break;
 				}
-				currentListStack.push(listItem);
+				pendingListFlattenedStack.push(null), currentListStack.push(listItem);
 				break;
 			}
 			case "ordered_list_open": {
@@ -947,22 +1524,27 @@ function markdownToPortableText(markdown, options) {
 					listContainerStack.push({
 						kind: "number",
 						items: [],
-						currentItem: null
-					}), currentListStack.push(null);
+						currentItem: null,
+						line: lineOf(token)
+					}), currentListStack.push(null), pendingListFlattenedStack.push(null);
 					break;
 				}
 				let listItem = consolidatedOptions.listItem.number({ context: { schema: consolidatedOptions.schema } });
 				if (listContainerStack.push(null), !listItem) {
-					currentListStack.push(null);
+					pendingListFlattenedStack.push({
+						line: lineOf(token),
+						kindName: "number",
+						reported: !1
+					}), currentListStack.push(null);
 					break;
 				}
-				currentListStack.push(listItem);
+				pendingListFlattenedStack.push(null), currentListStack.push(listItem);
 				break;
 			}
 			case "bullet_list_close":
 			case "ordered_list_close": {
 				let frame = listContainerStack.pop();
-				if (currentListStack.pop(), frame && consolidatedOptions.types.list) {
+				if (currentListStack.pop(), pendingListFlattenedStack.pop(), frame && consolidatedOptions.types.list) {
 					let kind = frame.items.some((item) => "checked" in item) ? "task" : frame.kind, listObject = consolidatedOptions.types.list({
 						context: {
 							schema: consolidatedOptions.schema,
@@ -976,13 +1558,45 @@ function markdownToPortableText(markdown, options) {
 					});
 					if (listObject) pushBlock(listObject);
 					else {
-						let flatListItem = (kind === "task" ? consolidatedOptions.listItem.task?.({ context: { schema: consolidatedOptions.schema } }) : kind === "number" ? consolidatedOptions.listItem.number({ context: { schema: consolidatedOptions.schema } }) : consolidatedOptions.listItem.bullet({ context: { schema: consolidatedOptions.schema } })) ?? null, level = listContainerStack.length + 1;
-						for (let item of frame.items) for (let block of item.content) block._type === "block" && flatListItem !== null && !("listItem" in block) ? pushBlock({
-							...block,
-							listItem: flatListItem,
-							level,
-							...item.checked === void 0 ? {} : { checked: item.checked }
-						}) : pushBlock(block);
+						let kindListItem = (frame.kind === "number" ? consolidatedOptions.listItem.number : consolidatedOptions.listItem.bullet)({ context: { schema: consolidatedOptions.schema } }) ?? null, taskListItemType = consolidatedOptions.listItem.task?.({ context: { schema: consolidatedOptions.schema } }) ?? null, kindName = frame.kind === "number" ? "number" : "bullet", level = listContainerStack.length + 1, flattenedReported = !1;
+						for (let item of frame.items) {
+							let itemListType = kindListItem, itemChecked;
+							if (item.checked !== void 0) {
+								if (taskListItemType) itemListType = taskListItemType, itemChecked = item.checked;
+								else if (kindListItem !== null) {
+									let info = taskInfoByListItem.get(item);
+									report({
+										type: "task-checkbox-stripped",
+										message: degradationMessage["task-checkbox-stripped"](item.checked),
+										line: info?.line,
+										snippet: info?.snippet
+									});
+								}
+							}
+							itemListType === null && !flattenedReported && (report({
+								type: "list-flattened",
+								message: degradationMessage["list-flattened"](kindName),
+								line: frame.line
+							}), flattenedReported = !0);
+							let mergeTarget = null;
+							for (let block of item.content) {
+								if (!(itemListType !== null && block._type === "block" && !("listItem" in block) && !/^h[1-6]$/.test(block.style ?? "") && plainParagraphBlocks.has(block))) {
+									mergeTarget = null, pushBlock(block);
+									continue;
+								}
+								let textBlock = block;
+								if (mergeTarget && mergeTarget.style === textBlock.style) {
+									mergeTarget.children.push(...textBlock.children), mergeTarget.markDefs = [...mergeTarget.markDefs ?? [], ...textBlock.markDefs ?? []];
+									continue;
+								}
+								mergeTarget = {
+									...textBlock,
+									listItem: itemListType,
+									level,
+									...itemChecked === void 0 ? {} : { checked: itemChecked }
+								}, pushBlock(mergeTarget);
+							}
+						}
 					}
 				}
 				break;
@@ -996,7 +1610,10 @@ function markdownToPortableText(markdown, options) {
 						_key: consolidatedOptions.keyGenerator(),
 						...taskChecked === void 0 ? {} : { checked: taskChecked },
 						content: []
-					}, inListItem = !0;
+					}, taskChecked !== void 0 && taskInfoByListItem.set(frame.currentItem, {
+						line: lineOf(token),
+						snippet: truncateSnippet(taskItemTextByListItemIndex.get(tokenIndex) ?? "")
+					}), inListItem = !0;
 					break;
 				}
 				let baseListType = currentListStack.at(-1);
@@ -1007,10 +1624,25 @@ function markdownToPortableText(markdown, options) {
 					taskListType && (listType = taskListType, checked = taskChecked);
 				}
 				if (listType === null) {
+					let pendingFlattened = pendingListFlattenedStack.at(-1);
+					pendingFlattened && !pendingFlattened.reported && (report({
+						type: "list-flattened",
+						message: degradationMessage["list-flattened"](pendingFlattened.kindName),
+						line: pendingFlattened.line
+					}), pendingFlattened.reported = !0);
 					let style = currentBlockquoteStyle ?? consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
-					style ? startBlock(style) : (console.warn("No default style found, using \"normal\""), startBlock("normal")), inListItem = !0;
+					style ? startBlock(style, { tookBlockquoteStyle: currentBlockquoteStyle !== null }) : (reportStyleFallback("normal", lineOf(token)), startBlock("normal")), inListItem = !0;
 					break;
 				}
+				if (taskChecked !== void 0 && checked === void 0) {
+					let snippet = truncateSnippet(taskItemTextByListItemIndex.get(tokenIndex) ?? "");
+					report({
+						type: "task-checkbox-stripped",
+						message: degradationMessage["task-checkbox-stripped"](taskChecked),
+						line: lineOf(token),
+						snippet
+					});
+				}
 				ensureListBlock(listType, checked), inListItem = !0;
 				break;
 			}
@@ -1025,7 +1657,21 @@ function markdownToPortableText(markdown, options) {
 			}
 			case "fence": {
 				flushBlock();
-				let language = token.info.trim() || void 0, code = token.content.replace(/\n$/, ""), codeObject = consolidatedOptions.types.code({
+				let language = token.info.trim() || void 0, code = token.content.replace(/\n$/, "");
+				if (language === "json:object") {
+					let objectValue = parseJsonObjectFence(code);
+					if (objectValue) {
+						pushBlock(objectValue);
+						break;
+					}
+					report({
+						type: "object-carrier-invalid",
+						message: degradationMessage["object-carrier-invalid"]("fence", code),
+						line: lineOf(token),
+						snippet: truncateSnippet(code)
+					});
+				}
+				let codeObject = consolidatedOptions.types.code({
 					context: {
 						schema: consolidatedOptions.schema,
 						keyGenerator: consolidatedOptions.keyGenerator
@@ -1037,11 +1683,18 @@ function markdownToPortableText(markdown, options) {
 					isInline: !1
 				});
 				if (!codeObject) {
+					let snippet = truncateSnippet(code.split("\n")[0] ?? "");
+					report({
+						type: "code-block-to-text",
+						message: degradationMessage["code-block-to-text"](language),
+						line: lineOf(token),
+						snippet
+					});
 					let style = consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
-					style ? startBlock(style) : (console.warn("No default style found, using \"normal\""), startBlock("normal")), addSpan(code), flushBlock();
+					style ? startBlock(style) : (reportStyleFallback("normal", lineOf(token)), startBlock("normal")), addSpan(code), flushBlock();
 					break;
 				}
-				pushBlock(codeObject);
+				reportFieldsDropped(codeObject, lineOf(token)), pushBlock(codeObject);
 				break;
 			}
 			case "hr": {
@@ -1055,8 +1708,13 @@ function markdownToPortableText(markdown, options) {
 					isInline: !1
 				});
 				if (!hrObject) {
+					report({
+						type: "horizontal-rule-to-text",
+						message: degradationMessage["horizontal-rule-to-text"],
+						line: lineOf(token)
+					});
 					let style = consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
-					style ? startBlock(style) : (console.warn("No default style found, using \"normal\""), startBlock("normal")), addSpan("---"), flushBlock();
+					style ? startBlock(style) : (reportStyleFallback("normal", lineOf(token)), startBlock("normal")), addSpan("---"), flushBlock();
 					break;
 				}
 				pushBlock(hrObject);
@@ -1075,11 +1733,18 @@ function markdownToPortableText(markdown, options) {
 					isInline: !1
 				});
 				if (!htmlObject) {
+					let snippet = truncateSnippet(htmlContent);
+					report({
+						type: "html-block-to-text",
+						message: degradationMessage["html-block-to-text"],
+						line: lineOf(token),
+						snippet
+					});
 					let style = consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
-					style ? startBlock(style) : (console.warn("No default style found, using \"normal\""), startBlock("normal")), addSpan(htmlContent), flushBlock();
+					style ? startBlock(style) : (reportStyleFallback("normal", lineOf(token)), startBlock("normal")), addSpan(htmlContent), flushBlock();
 					break;
 				}
-				pushBlock(htmlObject);
+				reportFieldsDropped(htmlObject, lineOf(token)), pushBlock(htmlObject);
 				break;
 			}
 			case "code_block": {
@@ -1095,10 +1760,17 @@ function markdownToPortableText(markdown, options) {
 					},
 					isInline: !1
 				});
-				if (codeObject) pushBlock(codeObject);
+				if (codeObject) reportFieldsDropped(codeObject, lineOf(token)), pushBlock(codeObject);
 				else {
+					let snippet = truncateSnippet(code.split("\n")[0] ?? "");
+					report({
+						type: "code-block-to-text",
+						message: degradationMessage["code-block-to-text"](void 0),
+						line: lineOf(token),
+						snippet
+					});
 					let style = consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
-					style ? startBlock(style) : (console.warn("No default style found, using \"normal\""), startBlock("normal")), addSpan(code), flushBlock();
+					style ? startBlock(style) : (reportStyleFallback("normal", lineOf(token)), startBlock("normal")), addSpan(code), flushBlock();
 				}
 				break;
 			}
@@ -1107,7 +1779,8 @@ function markdownToPortableText(markdown, options) {
 					rows: [],
 					headerRows: 0,
 					emptyHeaderDropped: !1,
-					alignment: []
+					alignment: [],
+					line: lineOf(token)
 				};
 				break;
 			case "table_close":
@@ -1125,8 +1798,16 @@ function markdownToPortableText(markdown, options) {
 						},
 						isInline: !1
 					});
-					tableObject ? pushBlock(tableObject) : flattenTable(currentTable, blockTarget());
-				} else flattenTable(currentTable, blockTarget());
+					tableObject ? (reportFieldsDropped(tableObject, currentTable.line), pushBlock(tableObject)) : (report({
+						type: "table-flattened",
+						message: degradationMessage["table-flattened"],
+						line: currentTable.line
+					}), flattenTable(currentTable, blockTarget()));
+				} else report({
+					type: "table-flattened",
+					message: degradationMessage["table-flattened"],
+					line: currentTable.line
+				}), flattenTable(currentTable, blockTarget());
 				currentTable = null;
 				break;
 			case "thead_open":
@@ -1151,7 +1832,7 @@ function markdownToPortableText(markdown, options) {
 			case "td_open": {
 				currentTable && inTableHead && token.type === "th_open" && currentTable.alignment.push(extractAlignmentFromStyleAttr(token.attrGet("style")));
 				let style = consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
-				style ? startBlock(style) : (console.warn("No default style found, using \"normal\""), startBlock("normal"));
+				style ? startBlock(style) : (reportStyleFallback("normal", currentTable?.line), startBlock("normal"));
 				break;
 			}
 			case "th_close":
@@ -1174,10 +1855,21 @@ function markdownToPortableText(markdown, options) {
 					_key: consolidatedOptions.keyGenerator(),
 					markDefs: []
 				});
-				let firstBlock = cellBlocks[0];
+				let demotedInlineImages = [];
+				for (let block of cellBlocks) if (block._type === "block" && "children" in block && Array.isArray(block.children)) for (let child of block.children) typeof child == "object" && child && demotedTableImages.has(child) && demotedInlineImages.push(child);
+				let firstBlock = cellBlocks[0], liftedImage;
 				if (cellBlocks.length === 1 && firstBlock && firstBlock._type === "block" && "children" in firstBlock && Array.isArray(firstBlock.children) && firstBlock.children.length === 1) {
 					let onlyChild = firstBlock.children[0];
-					typeof onlyChild == "object" && onlyChild && "_type" in onlyChild && onlyChild._type !== consolidatedOptions.schema.span.name && onlyChild._type === "image" && (cellBlocks[0] = onlyChild);
+					typeof onlyChild == "object" && onlyChild && "_type" in onlyChild && onlyChild._type !== consolidatedOptions.schema.span.name && onlyChild._type === "image" && (cellBlocks[0] = onlyChild, liftedImage = onlyChild);
+				}
+				for (let demotedImage of demotedInlineImages) if (demotedImage !== liftedImage) {
+					let { alt, src } = demotedImage;
+					report({
+						type: "image-block-to-inline",
+						message: degradationMessage["image-block-to-inline"](demotedTableImages.get(demotedImage) ?? "table-cell"),
+						line: currentTable?.line,
+						snippet: truncateSnippet(alt || src || "")
+					});
 				}
 				currentTableRow !== null && currentTableRow.push({
 					_type: "cell",
@@ -1187,7 +1879,7 @@ function markdownToPortableText(markdown, options) {
 				break;
 			}
 			case "inline": {
-				let inTableCell = currentTableRow !== null;
+				let inTableCell = currentTableRow !== null, inlineLine = () => lineOf(token) ?? currentTable?.line;
 				if (token.children?.length === 1 && token.children[0]?.type === "image") {
 					let imageToken = token.children[0];
 					if (!imageToken) break;
@@ -1204,7 +1896,7 @@ function markdownToPortableText(markdown, options) {
 						isInline: !1
 					});
 					if (blockImageObject) {
-						inTableCell ? currentBlock && "children" in currentBlock && currentBlock.children.push(blockImageObject) : (currentBlock && "children" in currentBlock && currentBlock.children.length > 0 ? flushBlock() : (currentBlock = null, currentMarkDefs = []), pushBlock(blockImageObject));
+						reportFieldsDropped(blockImageObject, inlineLine()), inTableCell ? (demotedTableImages.set(blockImageObject, "table-cell"), currentBlock && "children" in currentBlock && currentBlock.children.push(blockImageObject)) : (currentBlock && "children" in currentBlock && currentBlock.children.length > 0 ? flushBlock() : (currentBlock = null, currentMarkDefs = []), pushBlock(blockImageObject));
 						break;
 					}
 					let inlineImageObject = consolidatedOptions.types.image({
@@ -1220,165 +1912,281 @@ function markdownToPortableText(markdown, options) {
 						isInline: !0
 					});
 					if (inlineImageObject) {
-						if (!currentBlock) if (inListItem) if (listContainerStack.at(-1)) startBlock(consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } }) ?? "normal");
-						else {
-							let listType = currentListStack.at(-1);
-							listType && ensureListBlock(listType);
-						}
-						else {
-							let style = consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
-							style && startBlock(style);
+						if (reportFieldsDropped(inlineImageObject, inlineLine()), inTableCell ? demotedTableImages.set(inlineImageObject, "no-block-image") : report({
+							type: "image-block-to-inline",
+							message: degradationMessage["image-block-to-inline"]("no-block-image"),
+							line: inlineLine(),
+							snippet: truncateSnippet(alt || src)
+						}), !currentBlock) {
+							if (inListItem) {
+								if (listContainerStack.at(-1)) {
+									let style = consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
+									style || reportStyleFallback("normal", inlineLine()), startBlock(style ?? "normal");
+								} else {
+									let listType = currentListStack.at(-1);
+									listType && ensureListBlock(listType);
+								}
+							} else {
+								let style = consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
+								style && startBlock(style);
+							}
 						}
 						currentBlock && "children" in currentBlock && currentBlock.children.push(inlineImageObject);
 						break;
 					}
-					addSpan(`![${alt}](${src})`);
+					let standaloneImageSnippet = truncateSnippet(alt || src);
+					report({
+						type: "image-to-text",
+						message: degradationMessage["image-to-text"],
+						line: inlineLine(),
+						snippet: standaloneImageSnippet
+					}), addSpan(`![${alt}](${src})`);
 					break;
 				}
-				for (let childToken of token.children ?? []) switch (childToken.type) {
-					case "text":
-						addSpan(childToken.content);
-						break;
-					case "softbreak":
-					case "hardbreak":
-						addSpan("\n");
-						break;
-					case "code_inline": {
-						let decorator = consolidatedOptions.marks.code({ context: { schema: consolidatedOptions.schema } });
-						if (!decorator) {
+				let inlineChildren = token.children ?? [];
+				for (let childIndex = 0; childIndex < inlineChildren.length; childIndex++) {
+					let childToken = inlineChildren[childIndex];
+					if (childToken) switch (childToken.type) {
+						case "text": {
+							let nextToken = inlineChildren[childIndex + 1];
+							if (childToken.content.endsWith("json:object") && nextToken?.type === "code_inline" && currentBlock && "children" in currentBlock) {
+								let objectValue = parseJsonObjectFence(nextToken.content);
+								if (objectValue) {
+									let prefix = childToken.content.slice(0, -11);
+									prefix.length > 0 && addSpan(prefix), currentBlock.children.push(objectValue), childIndex++;
+									break;
+								}
+								report({
+									type: "object-carrier-invalid",
+									message: degradationMessage["object-carrier-invalid"]("code-span", nextToken.content),
+									line: inlineLine(),
+									snippet: truncateSnippet(nextToken.content)
+								});
+							}
 							addSpan(childToken.content);
 							break;
 						}
-						markDefRefs.push(decorator), addSpan(childToken.content);
-						let index = markDefRefs.lastIndexOf(decorator);
-						index !== -1 && markDefRefs.splice(index, 1);
-						break;
-					}
-					case "strong_open": {
-						let decorator = consolidatedOptions.marks.strong({ context: { schema: consolidatedOptions.schema } });
-						if (!decorator) break;
-						markDefRefs.push(decorator);
-						break;
-					}
-					case "strong_close": {
-						let decorator = consolidatedOptions.marks.strong({ context: { schema: consolidatedOptions.schema } });
-						if (!decorator) break;
-						let index = markDefRefs.lastIndexOf(decorator);
-						index !== -1 && markDefRefs.splice(index, 1);
-						break;
-					}
-					case "em_open": {
-						let decorator = consolidatedOptions.marks.em({ context: { schema: consolidatedOptions.schema } });
-						if (!decorator) break;
-						markDefRefs.push(decorator);
-						break;
-					}
-					case "em_close": {
-						let decorator = consolidatedOptions.marks.em({ context: { schema: consolidatedOptions.schema } });
-						if (!decorator) break;
-						let index = markDefRefs.lastIndexOf(decorator);
-						index !== -1 && markDefRefs.splice(index, 1);
-						break;
-					}
-					case "s_open": {
-						let decorator = consolidatedOptions.marks.strikeThrough({ context: { schema: consolidatedOptions.schema } });
-						if (!decorator) break;
-						markDefRefs.push(decorator);
-						break;
-					}
-					case "s_close": {
-						let decorator = consolidatedOptions.marks.strikeThrough({ context: { schema: consolidatedOptions.schema } });
-						if (!decorator) break;
-						let index = markDefRefs.lastIndexOf(decorator);
-						index !== -1 && markDefRefs.splice(index, 1);
-						break;
-					}
-					case "link_open": {
-						let href = childToken.attrs?.find(([name]) => name === "href")?.at(1);
-						if (!href) break;
-						let title = childToken.attrs?.find(([name]) => name === "title")?.at(1), linkObject = consolidatedOptions.marks.link({
-							context: {
-								schema: consolidatedOptions.schema,
-								keyGenerator: consolidatedOptions.keyGenerator
-							},
-							value: {
-								href,
-								title
+						case "softbreak":
+							addSpan(" ");
+							break;
+						case "hardbreak":
+							addSpan("\n");
+							break;
+						case "code_inline": {
+							let decorator = consolidatedOptions.marks.code({ context: { schema: consolidatedOptions.schema } });
+							if (!decorator) {
+								let codeSnippet = truncateSnippet(childToken.content);
+								report({
+									type: "decorator-dropped",
+									message: degradationMessage["decorator-dropped"]("code"),
+									line: inlineLine(),
+									snippet: codeSnippet
+								}), addSpan(childToken.content);
+								break;
 							}
-						});
-						if (!linkObject) break;
-						currentMarkDefs.push(linkObject), markDefRefs.push(linkObject._key);
-						break;
-					}
-					case "link_close": {
-						let markDefKeys = new Set(currentMarkDefs.map((d) => d._key)), lastLinkIndex;
-						for (let markDefRef of markDefRefs.reverse()) if (markDefKeys.has(markDefRef)) {
-							lastLinkIndex = markDefRefs.indexOf(markDefRef);
+							markDefRefs.push(decorator), addSpan(childToken.content);
+							let index = markDefRefs.lastIndexOf(decorator);
+							index !== -1 && markDefRefs.splice(index, 1);
 							break;
 						}
-						if (lastLinkIndex !== void 0) {
-							let realIndex = markDefRefs.length - 1 - lastLinkIndex;
-							markDefRefs.splice(realIndex, 1);
+						case "strong_open": {
+							let decorator = consolidatedOptions.marks.strong({ context: { schema: consolidatedOptions.schema } });
+							if (!decorator) {
+								let strongSnippet = truncateSnippet(collectInlineText(inlineChildren, childIndex, "strong_open", "strong_close"));
+								report({
+									type: "decorator-dropped",
+									message: degradationMessage["decorator-dropped"]("strong"),
+									line: inlineLine(),
+									snippet: strongSnippet
+								});
+								break;
+							}
+							markDefRefs.push(decorator);
+							break;
 						}
-						break;
-					}
-					case "image": {
-						let src = childToken.attrs?.find(([name]) => name === "src")?.at(1) || "", alt = unescapeImageAndLinkText(childToken.content || ""), inlineImageObject = consolidatedOptions.types.image({
-							context: {
-								schema: consolidatedOptions.schema,
-								keyGenerator: consolidatedOptions.keyGenerator
-							},
-							value: {
-								src,
-								alt,
-								title: void 0
-							},
-							isInline: !0
-						});
-						if (inlineImageObject) {
-							if (!currentBlock) {
-								let style = consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
-								style ? startBlock(style) : (console.warn("No default style found, using \"normal\""), startBlock("normal"));
+						case "strong_close": {
+							let decorator = consolidatedOptions.marks.strong({ context: { schema: consolidatedOptions.schema } });
+							if (!decorator) break;
+							let index = markDefRefs.lastIndexOf(decorator);
+							index !== -1 && markDefRefs.splice(index, 1);
+							break;
+						}
+						case "em_open": {
+							let decorator = consolidatedOptions.marks.em({ context: { schema: consolidatedOptions.schema } });
+							if (!decorator) {
+								let emSnippet = truncateSnippet(collectInlineText(inlineChildren, childIndex, "em_open", "em_close"));
+								report({
+									type: "decorator-dropped",
+									message: degradationMessage["decorator-dropped"]("em"),
+									line: inlineLine(),
+									snippet: emSnippet
+								});
+								break;
 							}
-							if (!currentBlock) throw Error("Expected current block after startBlock");
-							currentBlock.children.push(inlineImageObject);
+							markDefRefs.push(decorator);
 							break;
 						}
-						let blockImageObject = consolidatedOptions.types.image({
-							context: {
-								schema: consolidatedOptions.schema,
-								keyGenerator: consolidatedOptions.keyGenerator
-							},
-							value: {
-								src,
-								alt,
-								title: void 0
-							},
-							isInline: !1
-						});
-						if (!blockImageObject) {
-							addSpan(`![${alt}](${src})`);
+						case "em_close": {
+							let decorator = consolidatedOptions.marks.em({ context: { schema: consolidatedOptions.schema } });
+							if (!decorator) break;
+							let index = markDefRefs.lastIndexOf(decorator);
+							index !== -1 && markDefRefs.splice(index, 1);
 							break;
 						}
-						if (inTableCell) {
-							currentBlock && "children" in currentBlock && currentBlock.children.push(blockImageObject);
+						case "s_open": {
+							let decorator = consolidatedOptions.marks.strikeThrough({ context: { schema: consolidatedOptions.schema } });
+							if (!decorator) {
+								let strikeSnippet = truncateSnippet(collectInlineText(inlineChildren, childIndex, "s_open", "s_close"));
+								report({
+									type: "decorator-dropped",
+									message: degradationMessage["decorator-dropped"]("strikeThrough"),
+									line: inlineLine(),
+									snippet: strikeSnippet
+								});
+								break;
+							}
+							markDefRefs.push(decorator);
 							break;
 						}
-						flushBlock(), pushBlock(blockImageObject);
-						let style = consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
-						style && startBlock(style);
-						break;
+						case "s_close": {
+							let decorator = consolidatedOptions.marks.strikeThrough({ context: { schema: consolidatedOptions.schema } });
+							if (!decorator) break;
+							let index = markDefRefs.lastIndexOf(decorator);
+							index !== -1 && markDefRefs.splice(index, 1);
+							break;
+						}
+						case "link_open": {
+							let href = childToken.attrs?.find(([name]) => name === "href")?.at(1);
+							if (!href) {
+								let missingHrefSnippet = truncateSnippet(collectInlineText(inlineChildren, childIndex, "link_open", "link_close"));
+								report({
+									type: "annotation-dropped",
+									message: degradationMessage["annotation-dropped"]("missing-url"),
+									line: inlineLine(),
+									snippet: missingHrefSnippet
+								});
+								break;
+							}
+							let title = childToken.attrs?.find(([name]) => name === "title")?.at(1), linkObject = consolidatedOptions.marks.link({
+								context: {
+									schema: consolidatedOptions.schema,
+									keyGenerator: consolidatedOptions.keyGenerator
+								},
+								value: {
+									href,
+									title
+								}
+							});
+							if (!linkObject) {
+								let linkSnippet = truncateSnippet(collectInlineText(inlineChildren, childIndex, "link_open", "link_close"));
+								report({
+									type: "annotation-dropped",
+									message: degradationMessage["annotation-dropped"]("no-annotation"),
+									line: inlineLine(),
+									snippet: linkSnippet
+								});
+								break;
+							}
+							reportFieldsDropped(linkObject, inlineLine()), currentMarkDefs.push(linkObject), markDefRefs.push(linkObject._key);
+							break;
+						}
+						case "link_close": {
+							let markDefKeys = new Set(currentMarkDefs.map((d) => d._key)), lastLinkIndex;
+							for (let markDefRef of markDefRefs.reverse()) if (markDefKeys.has(markDefRef)) {
+								lastLinkIndex = markDefRefs.indexOf(markDefRef);
+								break;
+							}
+							if (lastLinkIndex !== void 0) {
+								let realIndex = markDefRefs.length - 1 - lastLinkIndex;
+								markDefRefs.splice(realIndex, 1);
+							}
+							break;
+						}
+						case "image": {
+							let src = childToken.attrs?.find(([name]) => name === "src")?.at(1) || "", alt = unescapeImageAndLinkText(childToken.content || ""), inlineImageObject = consolidatedOptions.types.image({
+								context: {
+									schema: consolidatedOptions.schema,
+									keyGenerator: consolidatedOptions.keyGenerator
+								},
+								value: {
+									src,
+									alt,
+									title: void 0
+								},
+								isInline: !0
+							});
+							if (inlineImageObject) {
+								if (reportFieldsDropped(inlineImageObject, inlineLine()), !currentBlock) {
+									let style = consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
+									style ? startBlock(style) : (reportStyleFallback("normal", inlineLine()), startBlock("normal"));
+								}
+								if (!currentBlock) throw Error("Expected current block after startBlock");
+								currentBlock.children.push(inlineImageObject);
+								break;
+							}
+							let blockImageObject = consolidatedOptions.types.image({
+								context: {
+									schema: consolidatedOptions.schema,
+									keyGenerator: consolidatedOptions.keyGenerator
+								},
+								value: {
+									src,
+									alt,
+									title: void 0
+								},
+								isInline: !1
+							});
+							if (!blockImageObject) {
+								let inlineImageSnippet = truncateSnippet(alt || src);
+								report({
+									type: "image-to-text",
+									message: degradationMessage["image-to-text"],
+									line: inlineLine(),
+									snippet: inlineImageSnippet
+								}), addSpan(`![${alt}](${src})`);
+								break;
+							}
+							if (inTableCell) {
+								reportFieldsDropped(blockImageObject, inlineLine()), demotedTableImages.set(blockImageObject, "table-cell"), currentBlock && "children" in currentBlock && currentBlock.children.push(blockImageObject);
+								break;
+							}
+							reportFieldsDropped(blockImageObject, inlineLine()), report({
+								type: "image-inline-to-block",
+								message: degradationMessage["image-inline-to-block"],
+								line: inlineLine(),
+								snippet: truncateSnippet(alt || src)
+							}), flushBlock(), pushBlock(blockImageObject);
+							let style = consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
+							style && startBlock(style);
+							break;
+						}
+						case "html_inline": if (consolidatedOptions.html.inline === "text") addSpan(childToken.content);
+						else if (childToken.content) {
+							let htmlInlineSnippet = truncateSnippet(childToken.content);
+							report({
+								type: "inline-html-dropped",
+								message: degradationMessage["inline-html-dropped"],
+								line: inlineLine(),
+								snippet: htmlInlineSnippet
+							});
+						}
 					}
-					case "html_inline": consolidatedOptions.html.inline === "text" && addSpan(childToken.content);
 				}
 				break;
 			}
-			case "alert_open":
-				flushBlock(), calloutStartTarget = blockTarget(), calloutStartIndex = calloutStartTarget.length, calloutType = token.markup, currentBlockquoteStyle = consolidatedOptions.block.blockquote({ context: { schema: consolidatedOptions.schema } }) ?? consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } }) ?? "normal";
+			case "alert_open": {
+				flushBlock(), calloutStartTarget = blockTarget(), calloutStartIndex = calloutStartTarget.length, calloutType = token.markup, calloutStartLine = lineOf(token);
+				let blockquoteStyle = consolidatedOptions.block.blockquote({ context: { schema: consolidatedOptions.schema } });
+				calloutPendingStyleFallbacks = [], blockquoteStyle || calloutPendingStyleFallbacks.push("blockquote");
+				let style = blockquoteStyle ?? consolidatedOptions.block.normal({ context: { schema: consolidatedOptions.schema } });
+				style || calloutPendingStyleFallbacks.push("normal"), currentBlockquoteStyle = style ?? "normal";
+				break;
+			}
+			case "alert_title":
+				calloutStartLine = lineOf(token);
 				break;
-			case "alert_title": break;
 			case "alert_close":
-				if (flushBlock(), calloutStartIndex !== null && calloutType !== null && calloutStartTarget !== null) {
+				if (flushBlock(), calloutPendingStyleFallbacks = [], calloutStartIndex !== null && calloutType !== null && calloutStartTarget !== null) {
 					let contentBlocks = calloutStartTarget.splice(calloutStartIndex), calloutObject = consolidatedOptions.types.callout?.({
 						context: {
 							schema: consolidatedOptions.schema,
@@ -1390,13 +2198,41 @@ function markdownToPortableText(markdown, options) {
 						},
 						isInline: !1
 					});
-					if (calloutObject) pushBlock(calloutObject);
-					else for (let block of contentBlocks) pushBlock(block);
+					if (calloutObject) reportFieldsDropped(calloutObject, calloutStartLine), pushBlock(calloutObject);
+					else {
+						report({
+							type: "callout-fallback",
+							message: degradationMessage["callout-fallback"](calloutType, currentBlockquoteStyle ?? "normal"),
+							line: calloutStartLine
+						});
+						for (let block of contentBlocks) pushBlock(block);
+					}
 				}
-				calloutStartIndex = null, calloutStartTarget = null, calloutType = null, currentBlockquoteStyle = null;
+				calloutStartIndex = null, calloutStartTarget = null, calloutType = null, calloutStartLine = void 0, currentBlockquoteStyle = null;
 		}
 	}
-	return flushBlock(), portableText;
+	return flushBlock(), degradationEvents.length > 0 && options?.onDegradation?.({
+		degradations: degradationEvents,
+		message: buildDegradationMessage(degradationEvents)
+	}), portableText;
+}
+/**
+* A `json:object` fence always reconstructs its object, schema or no
+* schema: the fence carries its own `_type`, and degrading it to a code
+* block would reintroduce the loss the syntax exists to remove. Returns
+* `undefined` instead of throwing, so an unusable fence falls through to
+* the regular code path.
+*/
+function parseJsonObjectFence(code) {
+	let parsed;
+	try {
+		parsed = JSON.parse(code);
+	} catch {
+		return;
+	}
+	if (typeof parsed != "object" || !parsed || Array.isArray(parsed)) return;
+	let objectValue = parsed;
+	if (typeof objectValue._type == "string" && objectValue._type.length !== 0) return objectValue;
 }
 export { DefaultBlockSpacingRenderer, DefaultBlockquoteObjectRenderer, DefaultBlockquoteRenderer, DefaultCalloutRenderer, DefaultCodeBlockRenderer, DefaultCodeRenderer, DefaultEmRenderer, DefaultH1Renderer, DefaultH2Renderer, DefaultH3Renderer, DefaultH4Renderer, DefaultH5Renderer, DefaultH6Renderer, DefaultHardBreakRenderer, DefaultHorizontalRuleRenderer, DefaultHtmlRenderer, DefaultImageRenderer, DefaultLinkRenderer, DefaultListItemRenderer, DefaultListRenderer, DefaultNormalRenderer, DefaultStrikeThroughRenderer, DefaultStrongRenderer, DefaultTableRenderer, DefaultUnderlineRenderer, markdownToPortableText, portableTextToMarkdown };