@effected/markdown 0.18.0 → 0.20.0

package/Frontmatter.js

@@ -2,7 +2,7 @@ import { MarkdownEdit } from "./MarkdownEdit.js";
 import { FrontmatterFormat } from "./MarkdownNode.js";
 import { Effect, Schema } from "effect";
 
-//#region src/Frontmatter.ts
+// src/Frontmatter.ts
 /**
 * Indicates that a frontmatter codec was handed a capture of a different
 * format — a yaml codec applied to a `+++` toml capture, for example.
@@ -303,5 +303,4 @@ var MarkdownFrontmatter = class MarkdownFrontmatter {
 	}
 };
 
-//#endregion
 export { FrontmatterDecodeError, FrontmatterEncodeError, FrontmatterFormatMismatchError, FrontmatterMissingError, FrontmatterMissingReason, FrontmatterValidationError, MarkdownFrontmatter };

package/FrontmatterResolver.js

@@ -1,6 +1,6 @@
 import { Effect, Result, Schema } from "effect";
 
-//#region src/FrontmatterResolver.ts
+// src/FrontmatterResolver.ts
 /**
 * A `$schema` declaration referencing a schema by URL — any string containing
 * `://`.
@@ -267,5 +267,4 @@ var SchemaResolver = class SchemaResolver {
 	}
 };
 
-//#endregion
 export { SchemaDeclaration, SchemaDeclarationByName, SchemaDeclarationByPath, SchemaDeclarationByUrl, SchemaDeclarationInline, SchemaDeclarationInvalidError, SchemaDeclarationMissingError, SchemaNameUnknownError, SchemaResolver, SchemaVersionUnresolvableError };

package/FrontmatterSource.js

@@ -2,7 +2,7 @@ import { FrontmatterFormat } from "./MarkdownNode.js";
 import { scanRawFrontmatter } from "./internal/blocks/frontmatter.js";
 import { Effect, Schema } from "effect";
 
-//#region src/FrontmatterSource.ts
+// src/FrontmatterSource.ts
 /**
 * The three line-terminator spellings a fence line may end with. Recorded by
 * {@link FrontmatterSource.split} as fidelity — what the source's fence
@@ -169,5 +169,4 @@ var FrontmatterSource = class {
 	}
 };
 
-//#endregion
 export { FrontmatterNewline, FrontmatterSource, FrontmatterSourceBlock, FrontmatterSourceSplit };

package/JsonFrontmatter.js

@@ -2,7 +2,7 @@ import { FrontmatterDecodeError, FrontmatterEncodeError, FrontmatterFormatMismat
 import { Effect } from "effect";
 import { Jsonc } from "@effected/jsonc";
 
-//#region src/JsonFrontmatter.ts
+// src/JsonFrontmatter.ts
 /**
 * The json frontmatter codec, over `@effected/jsonc`.
 *
@@ -42,5 +42,4 @@ const JsonFrontmatter = {
 	})))
 };
 
-//#endregion
 export { JsonFrontmatter };

package/Markdown.js

@@ -2,11 +2,11 @@ import { Root } from "./MarkdownNode.js";
 import { isGuardExceeded, isRawMarkdownError } from "./internal/carriers.js";
 import { parseBlocks } from "./internal/blockParser.js";
 import { parsePhrasingText } from "./internal/phrasing.js";
-import { stringifyTree } from "./internal/stringify.js";
+import { stringifyBlocks } from "./internal/stringify.js";
 import { MarkdownDiagnostic } from "./MarkdownDiagnostic.js";
 import { Effect, Result, Schema, SchemaIssue, SchemaTransformation } from "effect";
 
-//#region src/Markdown.ts
+// src/Markdown.ts
 /**
 * The markdown dialects the parser can be pointed at. `"gfm"` — CommonMark
 * 0.31.2 plus the GitHub extensions (tables, strikethrough, autolink
@@ -256,11 +256,20 @@ var Markdown = class Markdown {
 	*/
 	static parsePhrasing = Effect.fn("Markdown.parsePhrasing")((text, options) => Effect.fromResult(Markdown.parsePhrasingResult(text, options)));
 	/**
-	* Serialize a {@link Root} tree to canonical markdown, synchronously, as a
-	* `Result`. The pure primitive twin of {@link Markdown.stringify}, on the
-	* same terms as {@link Markdown.parseResult}.
+	* Serialize a {@link Root} tree, or a single {@link (FlowContent:type)} node, to
+	* canonical markdown, synchronously, as a `Result`. The pure primitive twin
+	* of {@link Markdown.stringify}, on the same terms as
+	* {@link Markdown.parseResult}.
 	*
 	* @remarks
+	* **A single flow node is defined as its one-child document**: passing
+	* `node` is exactly `stringifyResult(Root.make({ children: [node] }))` —
+	* the same code path, the same trailing `\n`, the same canonical choices.
+	* This lets a caller serialize one block (a table, a section's paragraph,
+	* an MDX flow element) without building the wrapper by hand.
+	* `Frontmatter` and `MdxjsEsm` are deliberately not admitted alone — each
+	* is meaningful only at a document's root — so wrap them in a `Root`.
+	*
 	* Canonical serialization: fidelity fields (marker characters, fence
 	* style, heading spelling) win when present; documented canonical
 	* defaults apply when absent. One default surprises: a language-less
@@ -343,13 +352,13 @@ var Markdown = class Markdown {
 	* trip on a tree nesting past the depth cap fails, and only synthesized
 	* or decoded trees can nest that far.
 	*
-	* @param root - The document tree to serialize.
+	* @param node - The document tree, or a single flow node, to serialize.
 	* @returns A `Result` succeeding with markdown source, or failing with
 	*   {@link MarkdownStringifyError}.
 	*/
-	static stringifyResult(root) {
+	static stringifyResult(node) {
 		try {
-			return Result.succeed(stringifyTree(root));
+			return Result.succeed(stringifyBlocks(node.type === "root" ? node.children : [node]));
 		} catch (caught) {
 			if (isGuardExceeded(caught)) return Result.fail(new MarkdownStringifyError({ diagnostic: MarkdownDiagnostic.make({
 				code: caught.reason,
@@ -363,9 +372,9 @@ var Markdown = class Markdown {
 		}
 	}
 	/**
-	* Serialize a {@link Root} tree to canonical markdown. Defined in terms of
-	* {@link Markdown.stringifyResult} — synchronous callers can use that
-	* variant directly.
+	* Serialize a {@link Root} tree, or a single {@link (FlowContent:type)} node, to
+	* canonical markdown. Defined in terms of {@link Markdown.stringifyResult}
+	* — synchronous callers can use that variant directly.
 	*
 	* @remarks
 	* The canonical form is a **stability commitment** and safe to assert
@@ -381,11 +390,14 @@ var Markdown = class Markdown {
 	* `escapeStyle`, an emitter instruction rather than a source spelling,
 	* which the boundary admits.
 	*
-	* @param root - The document tree to serialize.
+	* A single flow node serializes exactly as its one-child document does;
+	* see {@link Markdown.stringifyResult}.
+	*
+	* @param node - The document tree, or a single flow node, to serialize.
 	* @returns An `Effect` that succeeds with markdown source, or fails with
 	*   {@link MarkdownStringifyError}.
 	*/
-	static stringify = Effect.fn("Markdown.stringify")((root) => Effect.fromResult(Markdown.stringifyResult(root)));
+	static stringify = Effect.fn("Markdown.stringify")((node) => Effect.fromResult(Markdown.stringifyResult(node)));
 	/**
 	* A `Schema<Root, string>` decoding markdown source into a {@link Root}
 	* tree and encoding a tree back to canonical markdown via
@@ -414,5 +426,4 @@ var Markdown = class Markdown {
 	static MarkdownFromString = Markdown.fromString();
 };
 
-//#endregion
 export { Markdown, MarkdownDialect, MarkdownParseError, MarkdownParseOptions, MarkdownStringifyError, parsePassResult };

package/MarkdownDiagnostic.js

@@ -1,7 +1,7 @@
 import { MARKDOWN_PARSE_ERROR_CODES } from "./internal/carriers.js";
 import { Schema } from "effect";
 
-//#region src/MarkdownDiagnostic.ts
+// src/MarkdownDiagnostic.ts
 /**
 * Error codes `Markdown.parse`/`MarkdownDocument.parse` can fail with.
 * Currently exactly one, `"NestingDepthExceeded"`, the hardening-guard trip;
@@ -84,5 +84,4 @@ function lineChar(text, offset) {
 	};
 }
 
-//#endregion
 export { MarkdownDiagnostic, MarkdownParseErrorCode };

package/MarkdownDocument.js

@@ -5,9 +5,10 @@ import { preprocessLines } from "./internal/preprocess.js";
 import { normalizeLabelText } from "./internal/references.js";
 import { MarkdownDiagnostic } from "./MarkdownDiagnostic.js";
 import { parsePassResult } from "./Markdown.js";
+import { rootHeadingBounds } from "./internal/sectionBounds.js";
 import { Effect, Result, Schema } from "effect";
 
-//#region src/MarkdownDocument.ts
+// src/MarkdownDocument.ts
 /**
 * A heading-delimited span from {@link MarkdownDocument.sections}: the
 * heading, its depth, the source `range` the section occupies and the
@@ -239,43 +240,9 @@ var MarkdownDocument = class MarkdownDocument extends Schema.Class("MarkdownDocu
 	get sections() {
 		const blocks = this.root.children;
 		const sections = [];
-		const headings = [];
-		for (let index = 0; index < blocks.length; index += 1) {
-			const block = blocks[index];
-			if (block !== void 0 && block.type === "heading") headings.push({
-				index,
-				node: block
-			});
-		}
-		const nextByDepth = [
-			void 0,
-			void 0,
-			void 0,
-			void 0,
-			void 0,
-			void 0,
-			void 0
-		];
-		const boundaryByHeading = new Array(headings.length);
-		for (let index = headings.length - 1; index >= 0; index -= 1) {
-			const current = headings[index]?.node;
-			if (current === void 0) continue;
-			let boundary;
-			for (let depth = 1; depth <= current.depth; depth += 1) {
-				const candidate = nextByDepth[depth];
-				if (candidate !== void 0 && (boundary === void 0 || candidate < boundary)) boundary = candidate;
-			}
-			boundaryByHeading[index] = boundary;
-			nextByDepth[current.depth] = index;
-		}
-		for (let index = 0; index < headings.length; index += 1) {
-			const current = headings[index];
-			if (current === void 0) continue;
-			const block = current.node;
-			const boundaryHeading = boundaryByHeading[index];
-			const boundaryNode = boundaryHeading === void 0 ? void 0 : headings[boundaryHeading]?.node;
+		for (const { heading: block, index, end } of rootHeadingBounds(blocks)) {
+			const boundaryNode = blocks[end];
 			const boundary = boundaryNode === void 0 ? this.source.length : boundaryNode.position.start.offset;
-			const end = boundaryHeading === void 0 ? blocks.length : headings[boundaryHeading]?.index ?? blocks.length;
 			const start = block.position.start.offset;
 			const bodyStart = block.position.end.offset;
 			sections.push(new DocumentSection({
@@ -285,7 +252,7 @@ var MarkdownDocument = class MarkdownDocument extends Schema.Class("MarkdownDocu
 					offset: start,
 					length: boundary - start
 				}),
-				children: blocks.slice(current.index + 1, end).filter((child) => child.type !== "frontmatter" && child.type !== "mdxjsEsm"),
+				children: blocks.slice(index + 1, end).filter((child) => child.type !== "frontmatter" && child.type !== "mdxjsEsm"),
 				text: phrasingText(block.children),
 				bodyRange: MarkdownRange.make({
 					offset: bodyStart,
@@ -424,5 +391,4 @@ var MarkdownDocument = class MarkdownDocument extends Schema.Class("MarkdownDocu
 	static parse = Effect.fn("MarkdownDocument.parse")((text, options) => Effect.fromResult(MarkdownDocument.parseResult(text, options)));
 };
 
-//#endregion
 export { DocumentSection, MarkdownDocument };

package/MarkdownEdit.js

@@ -1,6 +1,6 @@
 import { Schema } from "effect";
 
-//#region src/MarkdownEdit.ts
+// src/MarkdownEdit.ts
 /**
 * A range within a markdown document, expressed as a zero-based character
 * `offset` and a `length` in UTF-16 code units. Pass to `MarkdownFormat.format`
@@ -52,5 +52,4 @@ var MarkdownEdit = class extends Schema.Class("MarkdownEdit")({
 	}
 };
 
-//#endregion
 export { MarkdownEdit, MarkdownRange };

package/MarkdownFormat.js

@@ -3,7 +3,7 @@ import { BulletChar, EmphasisChar, FenceChar, HeadingStyle, Paragraph, Root, Tex
 import { Markdown, MarkdownDialect, MarkdownParseOptions } from "./Markdown.js";
 import { Effect, Result, Schema } from "effect";
 
-//#region src/MarkdownFormat.ts
+// src/MarkdownFormat.ts
 /**
 * The two ways CommonMark spells a code block: `fenced` (a backtick or tilde
 * fence) and `indented` (four-space indentation).
@@ -511,5 +511,4 @@ var MarkdownFormat = class MarkdownFormat {
 	});
 };
 
-//#endregion
 export { CodeBlockStyle, MarkdownFormat, MarkdownFormattingOptions, MarkdownModificationError, MarkdownModificationErrorCode };

package/MarkdownNode.js

@@ -1,6 +1,6 @@
 import { Effect, Schema } from "effect";
 
-//#region src/MarkdownNode.ts
+// src/MarkdownNode.ts
 /**
 * A single point in a source document: 1-based `line` and `column`, 0-based
 * `offset`.
@@ -854,5 +854,4 @@ const MarkdownNode = Schema.suspend(() => Schema.Union([
 	TableContent
 ]));
 
-//#endregion
 export { Blockquote, Break, BreakStyle, BulletChar, Code, Definition, Delete, Emphasis, EmphasisChar, FenceChar, FlowContent, FootnoteDefinition, FootnoteReference, Frontmatter, FrontmatterContent, FrontmatterFormat, Heading, HeadingDepth, HeadingStyle, Html, Image, ImageReference, InlineCode, Link, LinkReference, List, ListContent, ListDelimiter, ListItem, MarkdownNode, MdxFlowExpression, MdxJsxAttribute, MdxJsxAttributeContent, MdxJsxAttributeValueExpression, MdxJsxExpressionAttribute, MdxJsxFlowElement, MdxJsxTextElement, MdxTextExpression, MdxjsEsm, Paragraph, PhrasingContent, Point, Position, ReferenceType, Root, RowContent, Strong, Table, TableAlign, TableCell, TableContent, TableRow, Text, ThematicBreak, ThematicBreakChar };

package/MarkdownTransform.js

@@ -0,0 +1,166 @@
+import { rootHeadingBounds } from "./internal/sectionBounds.js";
+
+// src/MarkdownTransform.ts
+/**
+* Pure, total tree-to-tree transforms over the markdown node classes. Not
+* instantiable.
+*
+* @remarks
+* Every method returns a plain value — none has an error channel. They work
+* on a tree, never on source text, so they compose with
+* {@link Markdown.stringify} for output and with each other; offset-splice
+* editing stays the job of `MarkdownFormat` and `MarkdownEdit`.
+*
+* @example
+* ```ts
+* import { LinkReference, Markdown, MarkdownTransform } from "@effected/markdown";
+* import { Result } from "effect";
+*
+* const parsed = Markdown.parseResult("# Title\n\nSee [docs](https://example.com).\n");
+* if (Result.isSuccess(parsed)) {
+*   const shifted = MarkdownTransform.shiftHeadings(parsed.success, 1);
+*   const rewritten = MarkdownTransform.map(shifted, {
+*     link: (link) =>
+*       LinkReference.make({ identifier: "docs", referenceType: "full", children: link.children }),
+*   });
+*   Markdown.stringifyResult(rewritten); // "## Title\n\nSee [docs][docs].\n"
+* }
+* ```
+*
+* @public
+*/
+var MarkdownTransform = class {
+	constructor() {}
+	static map(node, handlers) {
+		return mapNode(node, handlers);
+	}
+	/**
+	* Shift every heading's depth by `by`, clamped into `[min, max]`.
+	*
+	* @remarks
+	* The new depth is `clamp(depth + by, min ?? 1, max ?? 6)`. A heading
+	* whose new depth exceeds 2 loses `headingStyle: "setext"` (the key is
+	* omitted), since setext spells depths 1 and 2 only; it then serializes
+	* as ATX. A heading whose depth does not change, and needs no setext
+	* drop, keeps its identity; structural sharing follows
+	* {@link MarkdownTransform.(map:1)}, on which this is built. Accepts any node,
+	* including a lone {@link Heading}.
+	*
+	* Built on `map`, it recurses the same way: a hand-built tree nested far
+	* deeper than anything `Markdown.parse` or `Mdast.fromMdast` produces can
+	* overflow the call stack.
+	*
+	* @param node - The node whose headings to shift.
+	* @param by - The signed depth offset; must be an integer.
+	* @param options - Optional {@link ShiftHeadingsOptions} clamp bounds.
+	* @returns The node with headings shifted.
+	* @throws `RangeError` when `by` is not an integer, or `min` / `max` is not
+	*   a heading depth or `min > max` — a wiring error, not a data error.
+	*/
+	static shiftHeadings(node, by, options) {
+		if (!Number.isInteger(by)) throw new RangeError(`MarkdownTransform.shiftHeadings: by must be an integer, got ${by}`);
+		const min = options?.min ?? 1;
+		const max = options?.max ?? 6;
+		if (!isHeadingDepth(min) || !isHeadingDepth(max) || min > max) throw new RangeError(`MarkdownTransform.shiftHeadings: invalid depth bounds min=${min} max=${max}`);
+		return mapNode(node, { heading: (heading) => {
+			const depth = Math.min(max, Math.max(min, heading.depth + by));
+			const dropSetext = depth > 2 && heading.headingStyle === "setext";
+			if (depth === heading.depth && !dropSetext) return heading;
+			const { headingStyle, ...rest } = heading;
+			const ctor = heading.constructor;
+			return new ctor({
+				...rest,
+				depth,
+				...headingStyle !== void 0 && !dropSetext ? { headingStyle } : {}
+			}, { disableChecks: true });
+		} });
+	}
+	/**
+	* Locate the root-level sections of one heading depth by child index —
+	* no source text needed, so it works on a tree a
+	* `MarkdownTransform.map` has reshaped.
+	*
+	* @remarks
+	* Returns the root-level headings of exactly `depth` whose index lies in
+	* `[start, end)`, in document order. Each section ends at the next
+	* root-level heading of equal or shallower depth, or at `end` — the same
+	* boundary rule as `MarkdownDocument.sections`, from one shared
+	* implementation. The window is what lets a caller nest: find the depth-2
+	* blocks, then the depth-3 sections inside one block's
+	* `[headingIndex + 1, end)`.
+	*
+	* **A shallower heading ends a section too.** Querying depth 2 on
+	* `## Features`, a list, a stray `# Top` and another list yields one span
+	* whose `end` is the `# Top` heading's index, so neither `# Top` nor the
+	* list after it belongs to the section. That is the outline reading. A
+	* caller that wants each section to run to the next heading of the SAME
+	* depth (slicing a changeset or changelog by entry, where a stray H1 is
+	* content) computes each body's end from the next span's `headingIndex`
+	* instead, or the window's end for the last span, as in the example.
+	*
+	* @example
+	* Bodies that run to the next same-depth heading:
+	*
+	* ```ts
+	* import { Markdown, MarkdownTransform } from "@effected/markdown";
+	* import { Result } from "effect";
+	*
+	* const root = Result.getOrThrow(Markdown.parseResult("## Features\n\n- a\n\n# Top\n\n- b\n"));
+	* const spans = MarkdownTransform.sections(root, { depth: 2 });
+	* // spans[0].end === 2: the outline section stops at `# Top`
+	* const bodies = spans.map((span, index) =>
+	*   root.children.slice(span.headingIndex + 1, spans[index + 1]?.headingIndex ?? root.children.length),
+	* );
+	* // bodies[0] holds the first list, `# Top` and the second list
+	* ```
+	*
+	* @param root - The tree whose root-level headings delimit sections.
+	* @param options - The {@link SectionSpanOptions} depth and window.
+	* @returns The matching {@link SectionSpan}s, in document order.
+	* @throws `RangeError` when `depth` is not an integer from 1 to 6, when
+	*   `start` or `end` is not an integer in `[0, root.children.length]`, or
+	*   when `start > end`.
+	*/
+	static sections(root, options) {
+		if (!isHeadingDepth(options.depth)) throw new RangeError(`MarkdownTransform.sections: depth must be a heading depth 1-6, got ${options.depth}`);
+		const length = root.children.length;
+		const start = options.start ?? 0;
+		const end = options.end ?? length;
+		if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end > length || start > end) throw new RangeError(`MarkdownTransform.sections: invalid window start=${start} end=${end} for ${length} children`);
+		const spans = [];
+		for (const bound of rootHeadingBounds(root.children)) {
+			if (bound.index < start || bound.index >= end || bound.heading.depth !== options.depth) continue;
+			spans.push({
+				heading: bound.heading,
+				headingIndex: bound.index,
+				end: Math.min(bound.end, end)
+			});
+		}
+		return spans;
+	}
+};
+const isHeadingDepth = (value) => Number.isInteger(value) && value >= 1 && value <= 6;
+function mapNode(node, handlers) {
+	let current = node;
+	if ("children" in node) {
+		const children = node.children;
+		let next;
+		for (let index = 0; index < children.length; index += 1) {
+			const child = children[index];
+			const mapped = mapNode(child, handlers);
+			if (next === void 0 && mapped !== child) next = children.slice(0, index);
+			next?.push(mapped);
+		}
+		if (next !== void 0) {
+			const ctor = node.constructor;
+			current = new ctor({
+				...node,
+				children: next
+			}, { disableChecks: true });
+		}
+	}
+	const handler = handlers[current.type];
+	return handler === void 0 ? current : handler(current);
+}
+
+export { MarkdownTransform };

package/MarkdownVisitor.js

@@ -1,7 +1,7 @@
 import { MarkdownDiagnostic } from "./MarkdownDiagnostic.js";
 import { Data, Stream } from "effect";
 
-//#region src/MarkdownVisitor.ts
+// src/MarkdownVisitor.ts
 /**
 * Constructors and matchers for the `MarkdownVisitorEvent` union (e.g.
 * `MarkdownVisitorEvent.Enter({ node, path, depth })`,
@@ -105,5 +105,4 @@ function* walkNode(node, path, depth) {
 	});
 }
 
-//#endregion
 export { MarkdownVisitor, MarkdownVisitorEvent };

package/Mdast.js

@@ -2,7 +2,7 @@ import { Root } from "./MarkdownNode.js";
 import { unescapeString } from "./internal/unescape.js";
 import { Effect, Result, Schema } from "effect";
 
-//#region src/Mdast.ts
+// src/Mdast.ts
 /**
 * Indicates that foreign mdast input failed to decode into the package's
 * node classes.
@@ -469,7 +469,55 @@ var Mdast = class Mdast {
 	*   fails with {@link MdastDecodeError}.
 	*/
 	static fromMdast = Effect.fn("Mdast.fromMdast")((input) => Effect.fromResult(Mdast.fromMdastResult(input)));
+	/**
+	* The plain-text content of a node, defined as `mdast-util-to-string`
+	* applied to the node's {@link Mdast.toMdast} projection.
+	*
+	* @remarks
+	* A node carrying a string `value` yields it (an `html` node only when
+	* `includeHtml`); an `image` or `imageReference` yields its non-empty
+	* `alt` when `includeImageAlt`; a node with children yields the
+	* concatenation of its children's text; anything else — a `break`, a
+	* `thematicBreak`, a `definition` — yields `""`. Both options default to
+	* `true`. Pure and total.
+	*
+	* **Values are read as the projection spells them.** The one value the
+	* projection changes is a `code` node's: this package keeps the final line
+	* ending of a code block's content, plain mdast does not, so `toText`
+	* strips it exactly as {@link Mdast.toMdast} does — `"let x"`, not
+	* `"let x\n"`, for a fenced block holding one line.
+	*
+	* This is the remark-ecosystem derivation, and it deliberately differs
+	* from the display derivation behind `DocumentHeading.text` and
+	* `DocumentSection.text`, which render a hard break as a space and drop
+	* raw HTML. Reach for `toText` when matching what remark tooling computes
+	* (slugs, search indexes); reach for the document accessors for display.
+	*
+	* The walk recurses once per nesting level. Every tree `Markdown.parse` or
+	* `Mdast.fromMdast` produces stays within the package's nesting cap, but a
+	* hand-built tree nested far deeper than that can overflow the call stack.
+	*
+	* @param node - The node to flatten.
+	* @param options - Optional {@link MdastToTextOptions}.
+	* @returns The node's text content.
+	*/
+	static toText(node, options) {
+		return nodeText(node, options?.includeImageAlt ?? true, options?.includeHtml ?? true);
+	}
 };
+/** `mdast-util-to-string`'s `one`, over the node classes as `toMdast` projects them. */
+function nodeText(node, includeImageAlt, includeHtml) {
+	if ("value" in node) {
+		if (node.type === "html") return includeHtml ? node.value : "";
+		return node.type === "code" ? stripFinalLineEnding(node.value) : node.value;
+	}
+	if (includeImageAlt && "alt" in node && node.alt) return node.alt;
+	if ("children" in node) {
+		let text = "";
+		for (const child of node.children) text += nodeText(child, includeImageAlt, includeHtml);
+		return text;
+	}
+	return "";
+}
 
-//#endregion
 export { Mdast, MdastDecodeError };

package/TomlFrontmatter.js

@@ -2,7 +2,7 @@ import { FrontmatterDecodeError, FrontmatterEncodeError, FrontmatterFormatMismat
 import { Effect } from "effect";
 import { Toml } from "@effected/toml";
 
-//#region src/TomlFrontmatter.ts
+// src/TomlFrontmatter.ts
 /**
 * The toml frontmatter codec, over `@effected/toml`.
 *
@@ -40,5 +40,4 @@ const TomlFrontmatter = {
 	})))
 };
 
-//#endregion
 export { TomlFrontmatter };

package/YamlFrontmatter.js

@@ -2,7 +2,7 @@ import { FrontmatterDecodeError, FrontmatterEncodeError, FrontmatterFormatMismat
 import { Effect } from "effect";
 import { Yaml } from "@effected/yaml";
 
-//#region src/YamlFrontmatter.ts
+// src/YamlFrontmatter.ts
 /**
 * The yaml frontmatter codec, over `@effected/yaml`.
 *
@@ -41,5 +41,4 @@ const YamlFrontmatter = {
 	})))
 };
 
-//#endregion
 export { YamlFrontmatter };