@effected/markdown 0.18.0 → 0.20.0

package/index.d.ts

@@ -1,5 +1,4 @@
 import { Data, Effect, Result, Schema, Stream } from "effect";
-//#region src/MarkdownNode.d.ts
 declare const Point_base: Schema.Class<Point, Schema.Struct<{
   readonly line: Schema.Number;
   readonly column: Schema.Number;
@@ -941,8 +940,6 @@ type MarkdownNodeType = MarkdownNode["type"];
 type MarkdownNodeOfType<T extends MarkdownNodeType> = Extract<MarkdownNode, {
   readonly type: T;
 }>;
-//#endregion
-//#region src/MarkdownDiagnostic.d.ts
 /**
  * Error codes `Markdown.parse`/`MarkdownDocument.parse` can fail with.
  * Currently exactly one, `"NestingDepthExceeded"`, the hardening-guard trip;
@@ -999,8 +996,6 @@ export declare class MarkdownDiagnostic extends MarkdownDiagnostic_base {
     readonly length: number;
   }): MarkdownDiagnostic;
 }
-//#endregion
-//#region src/Markdown.d.ts
 /**
  * The markdown dialects the parser can be pointed at. `"gfm"` — CommonMark
  * 0.31.2 plus the GitHub extensions (tables, strikethrough, autolink
@@ -1204,11 +1199,20 @@ export declare class Markdown {
    */
   static readonly parsePhrasing: (text: string, options?: MarkdownParseOptions | undefined) => Effect.Effect<readonly PhrasingContent[], MarkdownParseError, never>;
   /**
-   * 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
@@ -1291,15 +1295,15 @@ export declare 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: Root): Result.Result<string, MarkdownStringifyError>;
+  static stringifyResult(node: Root | FlowContent): Result.Result<string, MarkdownStringifyError>;
   /**
-   * 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
@@ -1315,11 +1319,14 @@ export declare 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 readonly stringify: (root: Root) => Effect.Effect<string, MarkdownStringifyError, never>;
+  static readonly stringify: (node: Root | FlowContent) => Effect.Effect<string, MarkdownStringifyError, never>;
   /**
    * A `Schema<Root, string>` decoding markdown source into a {@link Root}
    * tree and encoding a tree back to canonical markdown via
@@ -1342,8 +1349,6 @@ export declare class Markdown {
    */
   static readonly MarkdownFromString: Schema.Codec<Root, string>;
 }
-//#endregion
-//#region src/MarkdownEdit.d.ts
 /**
  * A single path segment: a `number` for child indices in the node tree, or a
  * `string` for named addressing (reserved, e.g. for definition identifiers).
@@ -1400,8 +1405,6 @@ export declare class MarkdownEdit extends MarkdownEdit_base {
    */
   static applyAll(text: string, edits: ReadonlyArray<MarkdownEdit>): string;
 }
-//#endregion
-//#region src/MarkdownDocument.d.ts
 /**
  * A heading entry from {@link MarkdownDocument.headings}: the {@link Heading}
  * node plus the derivations navigation wants — its `depth` and its plain-text
@@ -1755,8 +1758,6 @@ export declare class MarkdownDocument extends MarkdownDocument_base {
    */
   static readonly parse: (text: string, options?: MarkdownParseOptions | undefined) => Effect.Effect<MarkdownDocument, MarkdownParseError, never>;
 }
-//#endregion
-//#region src/Frontmatter.d.ts
 declare const FrontmatterFormatMismatchError_base: Schema.Class<FrontmatterFormatMismatchError, Schema.TaggedStruct<"FrontmatterFormatMismatchError", {
   /** The format the codec decodes. */
   readonly expected: Schema.Literals<readonly ["yaml", "toml", "json"]>;
@@ -2049,8 +2050,6 @@ export declare class MarkdownFrontmatter {
    */
   static setToString<T, E, RD = never, RE = never>(schema: Schema.Codec<T, E, RD, RE>, codec: FrontmatterCodec): (document: MarkdownDocument, data: T) => Effect.Effect<string, FrontmatterWriteError, RE>;
 }
-//#endregion
-//#region src/FrontmatterResolver.d.ts
 declare const SchemaDeclarationByUrl_base: Schema.Class<SchemaDeclarationByUrl, Schema.TaggedStruct<"ByUrl", {
   /** The URL as written in the declaration. */
   readonly url: Schema.String;
@@ -2280,8 +2279,6 @@ export declare class SchemaResolver {
    */
   static fromRegistry(registrations: Readonly<Record<string, Schema.Top>>): FrontmatterSchemaResolver;
 }
-//#endregion
-//#region src/FrontmatterSource.d.ts
 /**
  * The three line-terminator spellings a fence line may end with. Recorded by
  * {@link FrontmatterSource.split} as fidelity — what the source's fence
@@ -2418,8 +2415,6 @@ export declare class FrontmatterSource {
    */
   static join(split: FrontmatterSourceSplit): string;
 }
-//#endregion
-//#region src/JsonFrontmatter.d.ts
 /**
  * The json frontmatter codec, over `@effected/jsonc`.
  *
@@ -2445,8 +2440,6 @@ export declare class FrontmatterSource {
  * @public
  */
 export declare const JsonFrontmatter: FrontmatterCodec;
-//#endregion
-//#region src/MarkdownFormat.d.ts
 /**
  * A range accepted at the `format`/`formatToString` call sites: either a
  * {@link MarkdownRange} instance or a plain `{ offset, length }` literal (the
@@ -2660,8 +2653,249 @@ export declare class MarkdownFormat {
    */
   static readonly modifyToString: (document: MarkdownDocument, target: MarkdownNode, replacement: string | MarkdownNode) => Effect.Effect<string, MarkdownModificationError, never>;
 }
-//#endregion
-//#region src/MarkdownVisitor.d.ts
+/**
+ * The node `type` tags whose handler may change the node's type — the
+ * phrasing-only types, i.e. every member of `PhrasingContent` that is
+ * not also flow content.
+ *
+ * @remarks
+ * `html` is excluded: an `html` node is both phrasing and flow content, so it
+ * can sit in a `Root`, `Blockquote` or `ListItem` child list, where only flow
+ * content is valid. Its handler must therefore return an `Html`.
+ *
+ * @public
+ */
+type MarkdownPhrasingOnlyType = Exclude<PhrasingContent, FlowContent>["type"];
+/**
+ * The handler table for `MarkdownTransform.map`: at most one function
+ * per node `type` tag, each receiving the node narrowed to its class.
+ *
+ * @remarks
+ * A handler for a phrasing-only type (see {@link MarkdownPhrasingOnlyType})
+ * may return any {@link (PhrasingContent:type)} — turning a `link` into a
+ * `linkReference`, say. That is sound because every parent of a phrasing
+ * node holds `PhrasingContent` children, so any phrasing node is valid in its
+ * place. Every other handler must return a node of its own type, which keeps
+ * `map` total: no handler can put a node where its parent forbids it.
+ *
+ * @public
+ */
+type MarkdownTransformHandlers = { readonly [T in MarkdownNodeType]?: (node: MarkdownNodeOfType<T>) => T extends MarkdownPhrasingOnlyType ? PhrasingContent : MarkdownNodeOfType<T>; };
+/**
+ * What `MarkdownTransform.map` returns for an input of type `N`: any
+ * `PhrasingContent` when `N` is phrasing-only (its handler may change
+ * its type), otherwise `N` itself.
+ *
+ * @public
+ */
+type MarkdownTransformResult<N extends MarkdownNode> = N extends Exclude<PhrasingContent, FlowContent> ? PhrasingContent : N;
+/**
+ * Options for {@link MarkdownTransform.shiftHeadings}: the inclusive depth
+ * range shifted headings are clamped into.
+ *
+ * @public
+ */
+interface ShiftHeadingsOptions {
+  /** The shallowest depth a shifted heading may take. Defaults to `1`. */
+  readonly min?: HeadingDepth;
+  /** The deepest depth a shifted heading may take. Defaults to `6`. */
+  readonly max?: HeadingDepth;
+}
+/**
+ * Options for {@link MarkdownTransform.sections}: the heading depth to match
+ * and the window of `root.children` indexes to search.
+ *
+ * @public
+ */
+interface SectionSpanOptions {
+  /** The exact heading depth to match. */
+  readonly depth: HeadingDepth;
+  /** The first child index searched, inclusive. Defaults to `0`. */
+  readonly start?: number;
+  /** The child index the search stops at, exclusive. Defaults to `root.children.length`. */
+  readonly end?: number;
+}
+/**
+ * A root-level section located by index: the heading, its index in
+ * `root.children`, and the exclusive index its section ends at. The body is
+ * the children at `[headingIndex + 1, end)`.
+ *
+ * @public
+ */
+interface SectionSpan {
+  readonly heading: Heading;
+  readonly headingIndex: number;
+  readonly end: number;
+}
+/**
+ * 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
+ */
+export declare class MarkdownTransform {
+  private constructor();
+  /**
+   * Rebuild a tree by applying `handlers` to its nodes, bottom-up.
+   *
+   * @remarks
+   * **Walk order is a contract:** post-order, children left to right. A
+   * handler sees its node with its children ALREADY transformed, and
+   * handlers are called in document order of the nodes' closing positions,
+   * so a stateful handler can rely on it — deduplicating while keeping the
+   * first occurrence, or remembering the last paragraph seen. The input
+   * node itself is visited last.
+   *
+   * **Structural sharing:** a subtree no handler changed is returned as the
+   * same instance (`===`), so `map(node, {})` returns `node`. A parent whose
+   * children changed is rebuilt with only `children` swapped — every other
+   * field, including `position`, kept as it was. A rebuilt parent therefore
+   * carries its ORIGINAL `position`: offsets into the pre-transform source,
+   * which no longer describe the transformed tree.
+   *
+   * **Handler typing keeps the map total.** A handler for a phrasing-only
+   * type ({@link MarkdownPhrasingOnlyType}) may return any phrasing node —
+   * a `link` may become a `linkReference` — because every parent of a
+   * phrasing node holds phrasing children. Every other handler must return a
+   * node of its own type. `html` is the one phrasing type excluded from the
+   * type-changing set: it is a member of BOTH the phrasing and the flow
+   * unions, so an `html` node can be a child of a `Root`, `Blockquote` or
+   * `ListItem`, where only flow content is valid — its handler must return
+   * an `Html`, and `map` of an `Html` returns an `Html`. See
+   * {@link MarkdownTransformHandlers}. A handler that throws propagates the
+   * exception unchanged; `map` has no error channel of its own.
+   *
+   * 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.
+   *
+   * **Two signatures.** This one covers every node whose handler cannot
+   * change its type — a `Root`, any flow node, a list item, a table row or
+   * cell, an `html` node — and returns `N` itself, so a generic caller
+   * constrained to, say, `Root | FlowContent` gets its own type parameter
+   * back. A lone phrasing-only node resolves to the second signature, whose
+   * result widens to `PhrasingContent`.
+   *
+   * @param node - The node to transform — typically a {@link Root}.
+   * @param handlers - At most one function per node `type` tag.
+   * @returns The transformed node, of the input's own type: `node` itself
+   *   when nothing changed.
+   */
+  static map<N extends Exclude<MarkdownNode, Exclude<PhrasingContent, FlowContent>>>(node: N, handlers: MarkdownTransformHandlers): N;
+  /**
+   * Rebuild a tree by applying `handlers` to its nodes, bottom-up — the
+   * signature for any node, including a lone phrasing-only node whose own
+   * handler may change its type.
+   *
+   * @remarks
+   * Walk order, structural sharing, handler typing and the recursion limit
+   * are exactly as documented on the first signature. The difference is the
+   * result type, {@link MarkdownTransformResult}: for a phrasing-only node
+   * (a `link`, `text`, `emphasis`, ...) it is any `PhrasingContent`, since
+   * that node's handler may return, say, a `linkReference` for a `link`. For
+   * every other node it is `N`, but a caller holding a node of a known
+   * non-phrasing type resolves to the first signature, which returns `N`
+   * without the conditional type.
+   *
+   * @param node - Any node.
+   * @param handlers - At most one function per node `type` tag.
+   * @returns The transformed node: `node` itself when nothing changed.
+   */
+  static map<N extends MarkdownNode>(node: N, handlers: MarkdownTransformHandlers): MarkdownTransformResult<N>;
+  /**
+   * 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<N extends MarkdownNode>(node: N, by: number, options?: ShiftHeadingsOptions): N;
+  /**
+   * 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: Root, options: SectionSpanOptions): ReadonlyArray<SectionSpan>;
+}
 /**
  * The discriminated union of markdown visitor events, in document pre-order.
  * `Enter` fires when the walk reaches a node, `Exit` when it leaves — for a
@@ -2856,8 +3090,6 @@ export declare class MarkdownVisitor {
    */
   static visit(root: Root): Stream.Stream<MarkdownVisitorEvent>;
 }
-//#endregion
-//#region src/Mdast.d.ts
 /**
  * A plain mdast node: a `type` tag plus whatever fields that type carries.
  *
@@ -2872,6 +3104,17 @@ interface MdastNode {
   readonly type: string;
   readonly [key: string]: unknown;
 }
+/**
+ * Options for {@link Mdast.toText}, matching `mdast-util-to-string`'s.
+ *
+ * @public
+ */
+interface MdastToTextOptions {
+  /** Whether an `image` or `imageReference` contributes its `alt` text. Defaults to `true`. */
+  readonly includeImageAlt?: boolean;
+  /** Whether an `html` node contributes its raw value. Defaults to `true`. */
+  readonly includeHtml?: boolean;
+}
 declare const MdastDecodeError_base: Schema.Class<MdastDecodeError, Schema.TaggedStruct<"MdastDecodeError", {
   /** The structured schema issue. Never a string. */
   readonly issue: Schema.Defect;
@@ -2993,9 +3236,40 @@ export declare class Mdast {
    *   fails with {@link MdastDecodeError}.
    */
   static readonly fromMdast: (input: unknown) => Effect.Effect<Root, MdastDecodeError, never>;
+  /**
+   * 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: MarkdownNode, options?: MdastToTextOptions): string;
 }
-//#endregion
-//#region src/TomlFrontmatter.d.ts
 /**
  * The toml frontmatter codec, over `@effected/toml`.
  *
@@ -3019,8 +3293,6 @@ export declare class Mdast {
  * @public
  */
 export declare const TomlFrontmatter: FrontmatterCodec;
-//#endregion
-//#region src/YamlFrontmatter.d.ts
 /**
  * The yaml frontmatter codec, over `@effected/yaml`.
  *
@@ -3045,6 +3317,5 @@ export declare const TomlFrontmatter: FrontmatterCodec;
  * @public
  */
 export declare const YamlFrontmatter: FrontmatterCodec;
-//#endregion
-export type { DocumentHeading, DocumentLink, FrontmatterCodec, FrontmatterResolveError, FrontmatterSchemaError, FrontmatterSchemaResolver, FrontmatterWriteError, LinkBearingNode, MarkdownNodeOfType, MarkdownNodeType, MarkdownPath, MarkdownRangeLike, MarkdownSegment, MdastNode, SectionHeadingMatch, SectionQueryOptions };
+export type { DocumentHeading, DocumentLink, FrontmatterCodec, FrontmatterResolveError, FrontmatterSchemaError, FrontmatterSchemaResolver, FrontmatterWriteError, LinkBearingNode, MarkdownNodeOfType, MarkdownNodeType, MarkdownPath, MarkdownPhrasingOnlyType, MarkdownRangeLike, MarkdownSegment, MarkdownTransformHandlers, MarkdownTransformResult, MdastNode, MdastToTextOptions, SectionHeadingMatch, SectionQueryOptions, SectionSpan, SectionSpanOptions, ShiftHeadingsOptions };
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -8,9 +8,10 @@ import { MarkdownDiagnostic, MarkdownParseErrorCode } from "./MarkdownDiagnostic
 import { Markdown, MarkdownDialect, MarkdownParseError, MarkdownParseOptions, MarkdownStringifyError } from "./Markdown.js";
 import { DocumentSection, MarkdownDocument } from "./MarkdownDocument.js";
 import { CodeBlockStyle, MarkdownFormat, MarkdownFormattingOptions, MarkdownModificationError, MarkdownModificationErrorCode } from "./MarkdownFormat.js";
+import { MarkdownTransform } from "./MarkdownTransform.js";
 import { MarkdownVisitor, MarkdownVisitorEvent } from "./MarkdownVisitor.js";
 import { Mdast, MdastDecodeError } from "./Mdast.js";
 import { TomlFrontmatter } from "./TomlFrontmatter.js";
 import { YamlFrontmatter } from "./YamlFrontmatter.js";
 
-export { Blockquote, Break, BreakStyle, BulletChar, Code, CodeBlockStyle, Definition, Delete, DocumentSection, Emphasis, EmphasisChar, FenceChar, FlowContent, FootnoteDefinition, FootnoteReference, Frontmatter, FrontmatterContent, FrontmatterDecodeError, FrontmatterEncodeError, FrontmatterFormat, FrontmatterFormatMismatchError, FrontmatterMissingError, FrontmatterMissingReason, FrontmatterNewline, FrontmatterSource, FrontmatterSourceBlock, FrontmatterSourceSplit, FrontmatterValidationError, Heading, HeadingDepth, HeadingStyle, Html, Image, ImageReference, InlineCode, JsonFrontmatter, Link, LinkReference, List, ListContent, ListDelimiter, ListItem, Markdown, MarkdownDiagnostic, MarkdownDialect, MarkdownDocument, MarkdownEdit, MarkdownFormat, MarkdownFormattingOptions, MarkdownFrontmatter, MarkdownModificationError, MarkdownModificationErrorCode, MarkdownNode, MarkdownParseError, MarkdownParseErrorCode, MarkdownParseOptions, MarkdownRange, MarkdownStringifyError, MarkdownVisitor, MarkdownVisitorEvent, Mdast, MdastDecodeError, MdxFlowExpression, MdxJsxAttribute, MdxJsxAttributeContent, MdxJsxAttributeValueExpression, MdxJsxExpressionAttribute, MdxJsxFlowElement, MdxJsxTextElement, MdxTextExpression, MdxjsEsm, Paragraph, PhrasingContent, Point, Position, ReferenceType, Root, RowContent, SchemaDeclaration, SchemaDeclarationByName, SchemaDeclarationByPath, SchemaDeclarationByUrl, SchemaDeclarationInline, SchemaDeclarationInvalidError, SchemaDeclarationMissingError, SchemaNameUnknownError, SchemaResolver, SchemaVersionUnresolvableError, Strong, Table, TableAlign, TableCell, TableContent, TableRow, Text, ThematicBreak, ThematicBreakChar, TomlFrontmatter, YamlFrontmatter };
+export { Blockquote, Break, BreakStyle, BulletChar, Code, CodeBlockStyle, Definition, Delete, DocumentSection, Emphasis, EmphasisChar, FenceChar, FlowContent, FootnoteDefinition, FootnoteReference, Frontmatter, FrontmatterContent, FrontmatterDecodeError, FrontmatterEncodeError, FrontmatterFormat, FrontmatterFormatMismatchError, FrontmatterMissingError, FrontmatterMissingReason, FrontmatterNewline, FrontmatterSource, FrontmatterSourceBlock, FrontmatterSourceSplit, FrontmatterValidationError, Heading, HeadingDepth, HeadingStyle, Html, Image, ImageReference, InlineCode, JsonFrontmatter, Link, LinkReference, List, ListContent, ListDelimiter, ListItem, Markdown, MarkdownDiagnostic, MarkdownDialect, MarkdownDocument, MarkdownEdit, MarkdownFormat, MarkdownFormattingOptions, MarkdownFrontmatter, MarkdownModificationError, MarkdownModificationErrorCode, MarkdownNode, MarkdownParseError, MarkdownParseErrorCode, MarkdownParseOptions, MarkdownRange, MarkdownStringifyError, MarkdownTransform, MarkdownVisitor, MarkdownVisitorEvent, Mdast, MdastDecodeError, MdxFlowExpression, MdxJsxAttribute, MdxJsxAttributeContent, MdxJsxAttributeValueExpression, MdxJsxExpressionAttribute, MdxJsxFlowElement, MdxJsxTextElement, MdxTextExpression, MdxjsEsm, Paragraph, PhrasingContent, Point, Position, ReferenceType, Root, RowContent, SchemaDeclaration, SchemaDeclarationByName, SchemaDeclarationByPath, SchemaDeclarationByUrl, SchemaDeclarationInline, SchemaDeclarationInvalidError, SchemaDeclarationMissingError, SchemaNameUnknownError, SchemaResolver, SchemaVersionUnresolvableError, Strong, Table, TableAlign, TableCell, TableContent, TableRow, Text, ThematicBreak, ThematicBreakChar, TomlFrontmatter, YamlFrontmatter };

package/internal/blockParser.js

@@ -8,7 +8,7 @@ import { GuardExceeded } from "./carriers.js";
 import { LineIndex } from "./lineIndex.js";
 import { prepareInline } from "./rawInline.js";
 
-//#region src/internal/blockParser.ts
+// src/internal/blockParser.ts
 /** Upstream's cheap pre-filter: a line that cannot start any block. */
 const reMaybeSpecial = /^[#`~*+_=<>0-9-]/;
 var BlockParser = class {
@@ -415,5 +415,4 @@ var BlockParser = class {
 */
 const parseBlocks = (text, dialect = "commonmark", frontmatter = false) => new BlockParser(text, blockDialect(dialect), dialect, frontmatter).parse();
 
-//#endregion
 export { parseBlocks };

package/internal/blockRegistry.js

@@ -14,7 +14,7 @@ import { tableCellConstruct, tableConstruct, tableHeaderStart, tableRowConstruct
 import { taskListItemStart } from "./blocks/taskListItem.js";
 import { thematicBreakConstruct, thematicBreakStart } from "./blocks/thematicBreak.js";
 
-//#region src/internal/blockRegistry.ts
+// src/internal/blockRegistry.ts
 const constructTable = (constructs) => new Map(constructs.map((construct) => [construct.type, construct]));
 const commonmarkDialect = {
 	constructs: constructTable([
@@ -86,5 +86,4 @@ const blockDialect = (dialect) => {
 	return found;
 };
 
-//#endregion
 export { blockDialect };

package/internal/blockTypes.js

@@ -1,4 +1,4 @@
-//#region src/internal/blockTypes.ts
+// src/internal/blockTypes.ts
 /** Narrow materialized children to the flow content most constructs contain. */
 const flowChildren = (children) => children.filter((child) => child.type !== "root" && child.type !== "listItem" && child.type !== "tableRow" && child.type !== "tableCell");
 /** Narrow materialized children to the list items a list contains. */
@@ -23,5 +23,4 @@ const makeBlockNode = (type, startOffset, startLine, depth = 0) => ({
 	data: {}
 });
 
-//#endregion
 export { flowChildren, listItemChildren, makeBlockNode, tableCellChildren, tableRowChildren };

package/internal/blocks/atxHeading.js

@@ -1,6 +1,6 @@
 import { Heading } from "../../MarkdownNode.js";
 
-//#region src/internal/blocks/atxHeading.ts
+// src/internal/blocks/atxHeading.ts
 const reATXHeadingMarker = /^#{1,6}(?:[ \t]+|$)/;
 const reOnlyTrailingHashes = /^[ \t]*#+[ \t]*$/;
 const reClosingHashes = /[ \t]+#+[ \t]*$/;
@@ -50,5 +50,4 @@ const atxHeadingStart = {
 	}
 };
 
-//#endregion
 export { atxHeadingStart, headingConstruct };

package/internal/blocks/blockquote.js

@@ -2,7 +2,7 @@ import { Blockquote } from "../../MarkdownNode.js";
 import { flowChildren } from "../blockTypes.js";
 import { isSpaceOrTab, peekCode } from "../preprocess.js";
 
-//#region src/internal/blocks/blockquote.ts
+// src/internal/blocks/blockquote.ts
 const C_GREATERTHAN = 62;
 /** Blockquote: continues while each line carries its `>` marker. */
 const blockquoteConstruct = {
@@ -36,5 +36,4 @@ const blockquoteStart = {
 	}
 };
 
-//#endregion
 export { blockquoteConstruct, blockquoteStart };

package/internal/blocks/code.js

@@ -2,7 +2,7 @@ import { Code } from "../../MarkdownNode.js";
 import { isSpaceOrTab, peekCode } from "../preprocess.js";
 import { unescapeString } from "../unescape.js";
 
-//#region src/internal/blocks/code.ts
+// src/internal/blocks/code.ts
 const reBlankLine = /^[ \t]*$/;
 const reClosingCodeFence = /^(?:`{3,}|~{3,})(?=[ \t]*$)/;
 /**
@@ -86,5 +86,4 @@ const codeConstruct = {
 	}
 };
 
-//#endregion
 export { codeConstruct };

package/internal/blocks/document.js

@@ -1,6 +1,6 @@
 import { Root } from "../../MarkdownNode.js";
 
-//#region src/internal/blocks/document.ts
+// src/internal/blocks/document.ts
 /** The document root: contains everything except a bare list item. */
 const documentConstruct = {
 	type: "document",
@@ -13,5 +13,4 @@ const documentConstruct = {
 	})
 };
 
-//#endregion
 export { documentConstruct };

package/internal/blocks/fencedCode.js

@@ -1,4 +1,4 @@
-//#region src/internal/blocks/fencedCode.ts
+// src/internal/blocks/fencedCode.ts
 const reCodeFence = /^`{3,}(?!.*`)|^~{3,}/;
 const fenceCharOf = (char) => char === "`" || char === "~" ? char : void 0;
 /** The fenced-code block start: three or more backticks or tildes. */
@@ -22,5 +22,4 @@ const fencedCodeStart = {
 	}
 };
 
-//#endregion
 export { fencedCodeStart };

package/internal/blocks/footnoteDefinition.js

@@ -3,7 +3,7 @@ import { flowChildren } from "../blockTypes.js";
 import { stickyOf } from "../patterns.js";
 import { normalizeLabelText } from "../references.js";
 
-//#region src/internal/blocks/footnoteDefinition.ts
+// src/internal/blocks/footnoteDefinition.ts
 /**
 * `_scan_footnote_definition` from `src/scanners.re`:
 *
@@ -80,5 +80,4 @@ const footnoteDefinitionStart = {
 	}
 };
 
-//#endregion
 export { footnoteDefinitionConstruct, footnoteDefinitionStart };

package/internal/blocks/frontmatter.js

@@ -1,4 +1,4 @@
-//#region src/internal/blocks/frontmatter.ts
+// src/internal/blocks/frontmatter.ts
 const FENCES = /* @__PURE__ */ new Map([
 	["---", {
 		format: "yaml",
@@ -98,5 +98,4 @@ const scanRawFrontmatter = (source) => {
 	return null;
 };
 
-//#endregion
 export { scanFrontmatter, scanRawFrontmatter };

package/internal/blocks/htmlBlock.js

@@ -2,7 +2,7 @@ import { Html } from "../../MarkdownNode.js";
 import { peekCode } from "../preprocess.js";
 import { CLOSETAG, OPENTAG } from "../htmlTags.js";
 
-//#region src/internal/blocks/htmlBlock.ts
+// src/internal/blocks/htmlBlock.ts
 const C_LESSTHAN = 60;
 const reHtmlBlockOpen = [
 	/./,
@@ -68,5 +68,4 @@ const htmlBlockStart = {
 	}
 };
 
-//#endregion
 export { htmlBlockConstruct, htmlBlockStart, isHtmlBlockEnd };