@stll/folio-core 0.52.0 → 0.54.0

package/dist/managers/ContextMenuManager.js

@@ -1,4 +1,5 @@
 import { isInTable as isInTableCell } from "../prosemirror/extensions/nodes/TableExtension.js";
+import { NO_LIST_NUMBERING_MENU, listNumberingMenuState } from "../prosemirror/listNumbering.js";
 import { Subscribable } from "./Subscribable.js";
 //#region src/managers/ContextMenuManager.ts
 const CLOSED_STATE = {
@@ -13,7 +14,8 @@ const CLOSED_STATE = {
 		to: 0
 	},
 	cursorInTable: false,
-	cursorInTrackedChange: false
+	cursorInTrackedChange: false,
+	listNumbering: NO_LIST_NUMBERING_MENU
 };
 var ContextMenuManager = class extends Subscribable {
 	constructor() {
@@ -36,7 +38,8 @@ var ContextMenuManager = class extends Subscribable {
 				to: selection.to
 			},
 			cursorInTable,
-			cursorInTrackedChange
+			cursorInTrackedChange,
+			listNumbering: state ? listNumberingMenuState(state) : NO_LIST_NUMBERING_MENU
 		});
 	}
 	/** Close the menu. */

package/dist/managers/types.d.ts

@@ -1,3 +1,4 @@
+import { ListNumberingMenuState } from "../prosemirror/listNumbering.js";
 //#region src/managers/types.d.ts
 /** Cell coordinates in a table */
 type CellCoordinates = {
@@ -21,6 +22,8 @@ type ContextMenuSnapshot = {
   };
   cursorInTable: boolean;
   cursorInTrackedChange: boolean;
+  /** Restart / continue / set-value entries for the list item under the caret. */
+  listNumbering: ListNumberingMenuState;
 };
 /** Error severity levels */
 type ErrorSeverity = "error" | "warning" | "info";

package/dist/markdown/escape.d.ts

@@ -7,8 +7,8 @@
  */
 /**
  * Escape only characters that would change markdown structure mid-text:
- *   - backslash, backtick, asterisk, brackets (always)
- *   - underscore: only at word boundaries (emphasis trigger)
+ *   - backslash, backtick, asterisk, brackets, tilde (always)
+ *   - underscore: unless between two letters or digits (emphasis trigger)
  *   - angle brackets: only when they look like a tag/autolink
  *
  * Characters like `.` `-` `+` `#` `(` `)` `!` are only meaningful at line

package/dist/markdown/escape.js

@@ -7,8 +7,8 @@
 */
 /**
 * Escape only characters that would change markdown structure mid-text:
-*   - backslash, backtick, asterisk, brackets (always)
-*   - underscore: only at word boundaries (emphasis trigger)
+*   - backslash, backtick, asterisk, brackets, tilde (always)
+*   - underscore: unless between two letters or digits (emphasis trigger)
 *   - angle brackets: only when they look like a tag/autolink
 *
 * Characters like `.` `-` `+` `#` `(` `)` `!` are only meaningful at line
@@ -16,9 +16,8 @@
 * when to escape those.
 */
 function escapeInline(text) {
-	let out = text.replace(/(?<ch>[\\`*[\]])/gu, "\\$<ch>");
-	out = out.replace(/(?<pre>^|\s)_/gu, "$<pre>\\_");
-	out = out.replace(/_(?<post>\s|$)/gu, "\\_$<post>");
+	let out = text.replace(/(?<ch>[\\`*[\]~])/gu, "\\$<ch>");
+	out = out.replace(/(?<![\p{L}\p{N}])_|_(?![\p{L}\p{N}])/gu, "\\_");
 	out = out.replace(/<(?<tag>\/?[A-Za-z][\w-]*)(?=[\s/>])/gu, "\\<$<tag>");
 	return out;
 }

package/dist/markdown/fromMarkdown.js

@@ -36,9 +36,10 @@ const applyMarkdownPageGeometry = (document) => {
 */
 function fromMarkdown(markdown) {
 	const document = createEmptyDocument();
-	const { content, numbering } = compileMarkdownToContent(markdown);
+	const { content, numbering, warnings } = compileMarkdownToContent(markdown);
 	if (content.length > 0) document.package.document.content = content;
 	if (numbering) document.package.numbering = numbering;
+	if (warnings && warnings.length > 0) document.warnings = [...document.warnings ?? [], ...warnings];
 	applyMarkdownPageGeometry(document);
 	return document;
 }

package/dist/markdown/internals.d.ts

@@ -1,4 +1,5 @@
 import { document_d_exports } from "../types/document.js";
+import { NoteReferenceKind } from "../utils/noteReferenceLabels.js";
 import { MarkdownOptions, RenderContext } from "./types.js";
 //#region src/markdown/internals.d.ts
 /**
@@ -15,5 +16,14 @@ declare function newContext(opts?: MarkdownOptions, styles?: document_d_exports.
  * recurring messages appear at most once.
  */
 declare function pushWarning(ctx: RenderContext, message: string): void;
+/**
+ * Number a footnote or endnote reference in reading order and record its
+ * note for the definitions trailer on the note's first reference. Returns the
+ * bare token (`1`, `e1`) and the inline marker (`[^1]`, `[^e1]`).
+ */
+declare function numberNoteReference(ctx: RenderContext, kind: NoteReferenceKind, refId: number): {
+  token: string;
+  marker: string;
+};
 //#endregion
-export { newContext, pushWarning };
+export { newContext, numberNoteReference, pushWarning };

package/dist/markdown/internals.js

@@ -1,4 +1,6 @@
 import { createBuiltInStyleIndex } from "../docx/builtInStyles.js";
+import { createListLabelCounter } from "../prosemirror/listLabels.js";
+import { createNoteReferenceNumbering, noteReferenceMarker, noteReferenceToken } from "../utils/noteReferenceLabels.js";
 //#region src/markdown/internals.ts
 /**
 * Internal helpers shared by the markdown converter: context construction and
@@ -30,11 +32,12 @@ function newContext(opts = {}, styles) {
 		imagesByPath: /* @__PURE__ */ new Map(),
 		warnings: [],
 		footnoteRefs: [],
+		noteNumbering: createNoteReferenceNumbering(),
 		commentRefs: [],
 		hyperlinkRefs: [],
 		imageCounter: 0,
-		listCounters: /* @__PURE__ */ new Map(),
-		listSeenLevels: /* @__PURE__ */ new Set()
+		nextListLabel: createListLabelCounter(),
+		listIndentWidths: []
 	};
 }
 /**
@@ -44,5 +47,23 @@ function newContext(opts = {}, styles) {
 function pushWarning(ctx, message) {
 	if (!ctx.warnings.includes(message)) ctx.warnings.push(message);
 }
+/**
+* Number a footnote or endnote reference in reading order and record its
+* note for the definitions trailer on the note's first reference. Returns the
+* bare token (`1`, `e1`) and the inline marker (`[^1]`, `[^e1]`).
+*/
+function numberNoteReference(ctx, kind, refId) {
+	const { displayNumber, first } = ctx.noteNumbering.next(kind, refId);
+	const marker = noteReferenceMarker(kind, displayNumber);
+	if (first) ctx.footnoteRefs.push({
+		refId,
+		marker,
+		kind
+	});
+	return {
+		token: noteReferenceToken(kind, displayNumber),
+		marker
+	};
+}
 //#endregion
-export { newContext, pushWarning };
+export { newContext, numberNoteReference, pushWarning };

package/dist/markdown/renderBlock.js

@@ -1,5 +1,7 @@
+import { ALT_CHUNK_READER_DIAGNOSTIC, isAltChunkMarkup } from "../docx/altChunk.js";
+import { OPAQUE_REVISION_CARRIER_READER_DIAGNOSTIC, isOpaqueNestedRowMarkup, opaqueRevisionCarrierName } from "../docx/opaqueCarrier.js";
 import { cloneParagraphWithoutPropertySource } from "../docx/paragraphPropertySource.js";
-import { renderParagraph } from "./renderParagraph.js";
+import { renderParagraphBlock } from "./renderParagraph.js";
 import { renderTable } from "./renderTable.js";
 import { panic } from "better-result";
 //#region src/markdown/renderBlock.ts
@@ -9,41 +11,130 @@ import { panic } from "better-result";
 * of the same list. Ported from eigenpal/docx-editor PR #595.
 */
 /**
-* In `trackedChanges: "clean"` mode every change is accepted. A paragraph whose
-* end-of-paragraph mark is a pending deletion (`pPrMark.kind === "del"`) loses
-* its break on accept and merges with the following paragraph. Word's join
-* keeps the FIRST paragraph's properties (style, list) and drops the resolved
-* mark; the surviving break is the next paragraph's, so a run of consecutive
-* deletions collapses into one paragraph. A non-paragraph next block (table,
-* SDT) is structurally incompatible and stays unmerged, matching the editor's
-* accept-change join guard (`commands/comments.ts`).
+* In `trackedChanges: "clean"` mode every change is accepted, as the editor's
+* accept-all resolves the story (`internal/wholeStoryRevisionResolution.ts`).
+*
+* A paragraph whose mark is pending deletion loses its break on accept and
+* runs on into the paragraph after it, which is the paragraph left: its mark
+* ends the joined text, and a paragraph's properties (style, list) live on its
+* mark. A run of consecutive deletions collapses into that last paragraph.
+*
+* With a table right after it, its words run on into the table's first cell
+* and lead that cell's first paragraph (`prosemirror/tableRunIn.ts`), unless
+* it ends a section, keeps nothing once accepted, or that cell is pending.
+* Otherwise a paragraph that cannot join keeps its place, or goes when it
+* keeps nothing and something follows it.
 */
 function mergeAcceptedParagraphBreaks(blocks) {
-	const merged = [];
-	for (const block of blocks) {
-		const prev = merged.at(-1);
-		if (prev?.type === "paragraph" && prev.pPrMark?.kind === "del" && block.type === "paragraph") {
-			const next = block.pPrMark;
-			const joined = cloneParagraphWithoutPropertySource(prev, {
-				content: [...prev.content, ...block.content],
-				...next ? { pPrMark: next } : {}
-			});
-			if (!next) Reflect.deleteProperty(joined, "pPrMark");
-			merged[merged.length - 1] = joined;
+	const reversed = [];
+	let survivor = null;
+	let tableFollows = false;
+	let followed = false;
+	const flush = () => {
+		if (survivor) reversed.push(survivor);
+		survivor = null;
+	};
+	for (let index = blocks.length - 1; index >= 0; index--) {
+		const block = blocks[index];
+		if (!block) continue;
+		if (block.type !== "paragraph") {
+			flush();
+			reversed.push(block);
+			tableFollows = block.type === "table";
+			followed ||= tableFollows;
 			continue;
 		}
-		merged.push(block);
+		const goes = block.pPrMark?.kind === "del" || block.pPrMark?.kind === "moveFrom";
+		if (goes && survivor) {
+			survivor = cloneParagraphWithoutPropertySource(survivor, { content: [...block.content, ...survivor.content] });
+			continue;
+		}
+		const table = reversed.at(-1);
+		if (goes && tableFollows && table?.type === "table") {
+			const ranIn = tableWithParagraphRunIn(table, block);
+			if (ranIn) {
+				reversed[reversed.length - 1] = ranIn;
+				continue;
+			}
+		}
+		flush();
+		tableFollows = false;
+		if (goes && holdsNothingOnAccept(block) && followed && index + reversed.length > 0) continue;
+		survivor = block;
+		followed = true;
 	}
-	return merged;
+	flush();
+	return reversed.reverse();
 }
+/**
+* Whether the cell a paragraph's words would run into is itself pending (its
+* row or the cell, through nested tables' first cells), as
+* `prosemirror/tableRunIn.ts` reads it.
+*/
+const runInCellPending = (table) => {
+	const row = table.rows[0];
+	const cell = row?.cells[0];
+	if (!row || !cell) return false;
+	if (row.structuralChange !== void 0 || cell.structuralChange !== void 0) return true;
+	const first = cell.content[0];
+	return first?.type === "table" && runInCellPending(first);
+};
+/**
+* `table` with `paragraph`'s words leading its first cell's first paragraph,
+* descending into nested tables, or null when the paragraph keeps its place.
+*/
+const tableWithParagraphRunIn = (table, paragraph) => {
+	if (paragraph.sectionProperties !== void 0 || holdsNothingOnAccept(paragraph)) return null;
+	if (runInCellPending(table)) return null;
+	const runIn = (current) => {
+		const [row, ...rows] = current.rows;
+		const [cell, ...cells] = row?.cells ?? [];
+		const [first, ...rest] = cell?.content ?? [];
+		if (!row || !cell || !first) return null;
+		let led = null;
+		if (first.type === "paragraph") led = cloneParagraphWithoutPropertySource(first, { content: [...paragraph.content, ...first.content] });
+		else if (first.type === "table") led = runIn(first);
+		if (!led) return null;
+		return {
+			...current,
+			rows: [{
+				...row,
+				cells: [{
+					...cell,
+					content: [led, ...rest]
+				}, ...cells]
+			}, ...rows]
+		};
+	};
+	return runIn(table);
+};
+/** Paragraph content that shows nothing: range boundaries and anchors. */
+const ZERO_WIDTH_CONTENT = /* @__PURE__ */ new Set([
+	"bookmarkStart",
+	"bookmarkEnd",
+	"commentRangeStart",
+	"commentRangeEnd",
+	"commentReference",
+	"moveFromRangeStart",
+	"moveFromRangeEnd",
+	"moveToRangeStart",
+	"moveToRangeEnd"
+]);
+/** Whether an item shows nothing once every change is accepted. */
+const showsNothingOnAccept = (item) => {
+	if (item.type === "deletion" || item.type === "moveFrom" || ZERO_WIDTH_CONTENT.has(item.type)) return true;
+	if (item.type === "insertion" || item.type === "moveTo") return item.content.every(showsNothingOnAccept);
+	return item.type === "run" && item.content.every((content) => content.type === "renderedPageBreak");
+};
+/** Whether a paragraph keeps no visible content once every change is accepted. */
+const holdsNothingOnAccept = (paragraph) => paragraph.content.every(showsNothingOnAccept);
 function renderBlocks(ctx, pkg, blocks) {
 	const out = [];
 	let prevWasListItem = false;
 	const ordered = ctx.opts.trackedChanges === "clean" ? mergeAcceptedParagraphBreaks(blocks) : blocks;
 	for (const block of ordered) switch (block.type) {
 		case "paragraph": {
-			const isListItem = !!block.listRendering && !block.listRendering.markerHidden;
-			const md = renderParagraph(ctx, pkg, block);
+			const { markdown: md, isListItem } = renderParagraphBlock(ctx, pkg, block);
 			if (!md) {
 				prevWasListItem = false;
 				continue;
@@ -63,7 +154,8 @@ function renderBlocks(ctx, pkg, blocks) {
 			prevWasListItem = false;
 			break;
 		}
-		case "blockSdt": {
+		case "blockSdt":
+		case "blockCustomXml": {
 			const nested = renderBlocks(ctx, pkg, block.content);
 			if (nested) {
 				if (out.length) out.push("");
@@ -72,6 +164,10 @@ function renderBlocks(ctx, pkg, blocks) {
 			break;
 		}
 		case "preservedBlock":
+			if (isAltChunkMarkup(block.xml)) out.push(block.readerText === void 0 ? ALT_CHUNK_READER_DIAGNOSTIC : `${ALT_CHUNK_READER_DIAGNOSTIC}\n\n${block.readerText}`);
+			else if (opaqueRevisionCarrierName(block.xml) !== void 0) out.push(OPAQUE_REVISION_CARRIER_READER_DIAGNOSTIC);
+			else if (isOpaqueNestedRowMarkup(block.xml)) out.push("[Unsupported nested w:tr content]");
+			break;
 		case "bookmarkStart":
 		case "bookmarkEnd": break;
 		default: panic(`Unsupported block content in markdown: ${JSON.stringify(block)}`);

package/dist/markdown/renderParagraph.d.ts

@@ -6,5 +6,17 @@ import { RenderContext } from "./types.js";
  * caller joins blocks.
  */
 declare function renderParagraph(ctx: RenderContext, pkg: document_d_exports.DocxPackage | undefined, para: document_d_exports.Paragraph): string;
+/** A rendered paragraph, and whether it is a Markdown list item. */
+type RenderedParagraph = {
+  markdown: string;
+  isListItem: boolean;
+};
+/**
+ * Render a paragraph. A list item is a paragraph that shows a marker, which is
+ * when the list counter gives it a label: a numbered heading renders as a
+ * heading, and a level that hides its marker (`w:vanish`) or that its list
+ * does not define as prose, as every other reader reads them.
+ */
+declare function renderParagraphBlock(ctx: RenderContext, pkg: document_d_exports.DocxPackage | undefined, para: document_d_exports.Paragraph): RenderedParagraph;
 //#endregion
-export { renderParagraph };
+export { RenderedParagraph, renderParagraph, renderParagraphBlock };

package/dist/markdown/renderParagraph.js

@@ -1,5 +1,5 @@
 import { isQuoteStyle, resolveHeadingLevel } from "../docx/builtInStyles.js";
-import { resolveListTemplate } from "../prosemirror/listMarker.js";
+import { listLabelAttrsFromRendering } from "../prosemirror/listLabels.js";
 import { renderParagraphInline } from "./renderRuns.js";
 //#region src/markdown/renderParagraph.ts
 /**
@@ -9,6 +9,8 @@ import { renderParagraphInline } from "./renderRuns.js";
 * `IntenseQuote` styles become blockquotes. Ported from eigenpal/docx-editor
 * PR #595.
 *
+* A numbered heading keeps its number after the hashes (`## 1. Scope`).
+*
 * Which paragraphs those are is `builtInStyles`' decision, not this file's: the
 * id `Nadpis1` and the id `Heading1` are the same heading, and `ClauseHeading1`
 * is not one at all.
@@ -20,19 +22,59 @@ const MAX_MARKDOWN_HEADING_LEVEL = 6;
 * caller joins blocks.
 */
 function renderParagraph(ctx, pkg, para) {
+	return renderParagraphBlock(ctx, pkg, para).markdown;
+}
+/**
+* Render a paragraph. A list item is a paragraph that shows a marker, which is
+* when the list counter gives it a label: a numbered heading renders as a
+* heading, and a level that hides its marker (`w:vanish`) or that its list
+* does not define as prose, as every other reader reads them.
+*/
+function renderParagraphBlock(ctx, pkg, para) {
+	const label = ctx.nextListLabel(listLabelAttrs(para));
 	const inline = renderParagraphInline(ctx, pkg, para.content, para.paraId);
 	const styleId = para.formatting?.styleId;
-	const headingLevel = resolveHeadingLevel({
-		outlineLevel: para.formatting?.outlineLevel,
-		styleId
-	}, ctx.builtInStyles);
+	const headingLevel = markdownHeadingLevel(ctx, para);
 	if (headingLevel !== void 0) {
-		if (!inline) return "";
-		return `${"#".repeat(Math.min(MAX_MARKDOWN_HEADING_LEVEL, headingLevel + 1))} ${inline}`;
+		if (!inline) return {
+			markdown: "",
+			isListItem: false
+		};
+		const hashes = "#".repeat(Math.min(MAX_MARKDOWN_HEADING_LEVEL, headingLevel + 1));
+		return {
+			markdown: label ? `${hashes} ${label} ${inline}` : `${hashes} ${inline}`,
+			isListItem: false
+		};
 	}
-	if (para.listRendering && !para.listRendering.markerHidden) return renderListItem(ctx, para.listRendering, inline);
-	if (isQuoteStyle(styleId, ctx.builtInStyles)) return inline.split("\n").map((line) => `> ${line}`).join("\n");
-	return escapeLeadingBlockMarker(inline);
+	if (para.listRendering && label !== void 0) return {
+		markdown: renderListItem(ctx, para.listRendering, label, inline),
+		isListItem: true
+	};
+	if (isQuoteStyle(styleId, ctx.builtInStyles)) return {
+		markdown: inline.split("\n").map((line) => `> ${line}`).join("\n"),
+		isListItem: false
+	};
+	return {
+		markdown: escapeLeadingBlockMarker(inline),
+		isListItem: false
+	};
+}
+/** The paragraph's 0-based heading level, as `builtInStyles` classifies it. */
+function markdownHeadingLevel(ctx, para) {
+	return resolveHeadingLevel({
+		outlineLevel: para.formatting?.outlineLevel,
+		styleId: para.formatting?.styleId
+	}, ctx.builtInStyles);
+}
+const UNNUMBERED = Object.freeze({});
+/**
+* The attrs the page's list counter reads, projected from the paragraph the
+* way the editor projects them (`toProseDoc`). A paragraph without a list
+* rendering counts as unnumbered.
+*/
+function listLabelAttrs(para) {
+	const list = para.listRendering;
+	return list ? listLabelAttrsFromRendering(list, para.formatting?.numPrFromStyle) : UNNUMBERED;
 }
 /**
 * A plain paragraph whose visible text begins with markdown block syntax (e.g.
@@ -43,36 +85,41 @@ function renderParagraph(ctx, pkg, para) {
 function escapeLeadingBlockMarker(text) {
 	return text.replace(/^(?<ws>[ \t]*)(?<marker>[#>])/gmu, "$<ws>\\$<marker>").replace(/^(?<ws>[ \t]*)(?<marker>[-+*])(?<after>[ \t])/gmu, "$<ws>\\$<marker>$<after>").replace(/^(?<ws>[ \t]*)(?<num>\d{1,9})(?<marker>[.)])(?<after>[ \t])/gmu, "$<ws>$<num>\\$<marker>$<after>");
 }
-function renderListItem(ctx, list, inline) {
-	const indent = "  ".repeat(list.level);
-	if (list.isBullet) return `${indent}- ${inline}`.trimEnd();
-	return `${indent}${list.marker.includes("%") ? resolveTemplateMarker(ctx, list) : list.marker.trim()} ${inline}`.trimEnd();
+/**
+* A markdown list marker's width when no ancestor at that level has rendered
+* yet (e.g. a DOCX paragraph numbered at a level its list skipped over). Two
+* spaces is the old fixed-indent behaviour, kept as a fallback rather than a
+* guess of zero.
+*/
+const DEFAULT_LIST_INDENT_WIDTH = 2;
+/**
+* The indent a level's item needs: the combined marker width of every
+* shallower level's most recently rendered item (see
+* `RenderContext.listIndentWidths`), so a child sits inside its parent's
+* content column per CommonMark's list-nesting rule, not a fixed guess.
+*/
+function listIndentWidth(ctx, level) {
+	let width = 0;
+	for (let ancestor = 0; ancestor < level; ancestor++) width += ctx.listIndentWidths[ancestor] ?? DEFAULT_LIST_INDENT_WIDTH;
+	return width;
 }
 /**
-* Resolve a `lvlText`-style marker template ("%1.") against live counters, the
-* same way the layout engine paints it. Editor-emitted documents carry
-* templates rather than baked numbers, so the serializer must count items in
-* document order; counters live on the context (`listCounters`) so they span
-* the whole render, including list items inside tables and block SDTs.
+* A list item line with the label the page shows (`1.`, `a)`, `i.`), counted
+* in document order across the whole render, list items inside tables and
+* block SDTs included. A bullet is Markdown's `-`.
+*
+* The indent before the marker is not a fixed two spaces: CommonMark keeps a
+* child nested under its parent only when it starts at or past the column
+* where the parent item's content begins, which is the width of the parent's
+* marker plus its one trailing space (`1. ` is 3 columns, `10. ` is 4, `- ` is
+* 2). `ctx.listIndentWidths` is updated with this item's own marker width so
+* a following, deeper item can indent correctly under it.
 */
-function resolveTemplateMarker(ctx, list) {
-	const counters = ctx.listCounters.get(list.numId) ?? Array.from({ length: 9 }, () => 0);
-	const level = list.level;
-	const seenKey = `${list.numId}:${level}`;
-	if (!ctx.listSeenLevels.has(seenKey)) {
-		ctx.listSeenLevels.add(seenKey);
-		if (list.startOverride !== void 0) counters[level] = list.startOverride - 1;
-	}
-	counters[level] = (counters[level] ?? 0) + 1;
-	for (let i = level + 1; i < counters.length; i += 1) counters[i] = 0;
-	ctx.listCounters.set(list.numId, counters);
-	const levelFormats = list.levelNumFmts ?? (list.numFmt ? [list.numFmt] : void 0);
-	return resolveListTemplate({
-		template: list.marker,
-		counters,
-		levelFormats,
-		forceDecimal: list.isLegal
-	}).trim();
+function renderListItem(ctx, list, label, inline) {
+	const indent = " ".repeat(listIndentWidth(ctx, list.level));
+	const marker = list.isBullet ? "- " : `${label} `;
+	ctx.listIndentWidths[list.level] = marker.length;
+	return `${indent}${marker}${inline}`.trimEnd();
 }
 //#endregion
-export { renderParagraph };
+export { renderParagraph, renderParagraphBlock };

package/dist/markdown/renderRuns.d.ts

@@ -1,10 +1,19 @@
 import { document_d_exports } from "../types/document.js";
 import { RenderContext } from "./types.js";
 //#region src/markdown/renderRuns.d.ts
+/**
+ * The character beside a run's delimiters: `""` at the paragraph's edge,
+ * `undefined` when it cannot be told (read as a letter, the strictest case).
+ */
+type Neighbor = string | undefined;
+type RunNeighbors = {
+  before: Neighbor;
+  after: Neighbor;
+};
 /**
  * Render the full inline content of a paragraph, tracking comment-range
  * boundaries to apply the configured wrapper.
  */
-declare function renderParagraphInline(ctx: RenderContext, pkg: document_d_exports.DocxPackage | undefined, content: readonly document_d_exports.ParagraphContent[], paraId: string | undefined): string;
+declare function renderParagraphInline(ctx: RenderContext, pkg: document_d_exports.DocxPackage | undefined, content: readonly document_d_exports.ParagraphContent[], paraId: string | undefined, edges?: RunNeighbors): string;
 //#endregion
 export { renderParagraphInline };