@effected/markdown 0.23.0 → 0.24.0

package/MarkdownDiagnostic.js

@@ -1,4 +1,5 @@
 import { MARKDOWN_PARSE_ERROR_CODES } from "./internal/carriers.js";
+import { LineIndex } from "@effected/source";
 import { Schema } from "effect";
 
 // src/MarkdownDiagnostic.ts
@@ -16,14 +17,20 @@ const MarkdownParseErrorCode = Schema.Literals(MARKDOWN_PARSE_ERROR_CODES);
 * zero-based `line`/`character`).
 *
 * @remarks
-* The five-field positional core (`code`/`offset`/`length`/`line`/`character`)
-* is structurally identical to `@effected/toml`'s `TomlDiagnostic` (and, by
-* the same cross-package contract, `@effected/jsonc`'s parse-error detail
-* shape and `@effected/yaml`'s `YamlDiagnostic`); `message` is this
-* package's additive extra. `line`/`character` here are zero-based to match
-* that contract — a different numbering from the one-based `line`/`column`
-* unist `Point`s carried on `MarkdownNode` positions, which is a deliberate,
-* unrelated convention for the AST rather than a mismatch to reconcile.
+* Satisfies `@effected/source`'s `SourceDiagnostic<MarkdownParseErrorCode>`:
+* the positional core (`code`/`message`/`offset`/`length`/`line`/`character`)
+* the kit's format packages share, so a consumer printing or serving
+* diagnostics (an LSP server, a CLI annotation) is written once against that
+* shape. `line`/`character` are zero-based, `character` in UTF-16 code units,
+* with `\n`, `\r\n` and a bare `\r` as line breaks: exactly
+* `LineIndex.make(source).positionAt(offset)`, and the same index
+* {@link MarkdownDocument.lineIndex} returns. An offset at the `\n` of a
+* `\r\n` reads as the end of its line.
+*
+* The one-based `line`/`column` unist `Point`s carried on `MarkdownNode`
+* positions read the same index, one-based: a deliberate, different
+* convention for the AST rather than a mismatch to reconcile (see
+* {@link MarkdownDocument.lineIndex} for the exact mapping).
 *
 * @public
 */
@@ -40,12 +47,20 @@ var MarkdownDiagnostic = class MarkdownDiagnostic extends Schema.Class("Markdown
 	* from `offset` against the source text. Advanced — the parse entry
 	* points call this for you.
 	*
-	* @param source - The source text the record's `offset` indexes into.
+	* @remarks
+	* Pass a line index already built over the source to materialize many
+	* records without rescanning the text; a string builds one. The
+	* parameter is the structural `SourceIndex`, so an index from any
+	* installed copy of `@effected/source` is accepted. An offset
+	* outside the source clamps into it, as `LineIndex.positionAt` does.
+	*
+	* @param source - The source text the record's `offset` indexes into, or
+	*   a `LineIndex` over it.
 	* @param raw - The engine record: `code`, `message`, `offset` and `length`.
 	* @returns The diagnostic with `line` and `character` filled in.
 	*/
 	static fromRaw(source, raw) {
-		const { line, character } = lineChar(source, raw.offset);
+		const { line, character } = (typeof source === "string" ? LineIndex.make(source) : source).positionAt(raw.offset);
 		return MarkdownDiagnostic.make({
 			code: raw.code,
 			message: raw.message,
@@ -56,32 +71,5 @@ var MarkdownDiagnostic = class MarkdownDiagnostic extends Schema.Class("Markdown
 		});
 	}
 };
-/**
-* Compute the zero-based line/character position of `offset` within `text`.
-* Recognizes `\n`, `\r` and `\r\n` as line breaks; a CRLF pair counts as a
-* single newline (toml `TomlDiagnostic` precedent — kept independent of
-* `internal/lineIndex.ts`, which answers a different, one-based question
-* for AST positions).
-*/
-function lineChar(text, offset) {
-	let line = 0;
-	let lineStart = 0;
-	const limit = Math.min(offset, text.length);
-	for (let i = 0; i < limit; i++) {
-		const ch = text.charCodeAt(i);
-		if (ch === 10) {
-			line++;
-			lineStart = i + 1;
-		} else if (ch === 13) {
-			if (i + 1 < text.length && text.charCodeAt(i + 1) === 10) i++;
-			line++;
-			lineStart = i + 1;
-		}
-	}
-	return {
-		line,
-		character: offset - lineStart
-	};
-}
 
 export { MarkdownDiagnostic, MarkdownParseErrorCode };

package/MarkdownDocument.js

@@ -6,6 +6,7 @@ import { normalizeLabelText } from "./internal/references.js";
 import { MarkdownDiagnostic } from "./MarkdownDiagnostic.js";
 import { rootHeadingBounds } from "./internal/sectionBounds.js";
 import { parsePassResult } from "./Markdown.js";
+import { LineIndex } from "@effected/source";
 import { Effect, Option, Result, Schema } from "effect";
 
 // src/MarkdownDocument.ts
@@ -122,6 +123,12 @@ const phrasingText = (nodes) => {
 	return out;
 };
 /**
+* Each document's line index, built at most once. A side table rather than a
+* field: the index is derived from `source`, so it is no part of the
+* document's schema, its equality or its encoded form.
+*/
+const lineIndexes = /* @__PURE__ */ new WeakMap();
+/**
 * A parsed markdown document: the original `source`, the mdast-shaped
 * {@link Root} tree, the non-fatal {@link MarkdownDiagnostic}s the parse
 * produced, and the link-reference `definitions` index.
@@ -213,6 +220,55 @@ var MarkdownDocument = class MarkdownDocument extends Schema.Class("MarkdownDocu
 		return scanFrontmatter(preprocessLines(this.source), this.source) !== null;
 	}
 	/**
+	* The line index over `source`: offsets to zero-based `{ line, character }`
+	* and back, with exactly the rules this package's own positions use.
+	*
+	* @remarks
+	* A `LineIndex` from `@effected/source` (re-exported from this package's
+	* entry point), typed as the structural `SourceIndex` so a consumer on
+	* another installed copy of `@effected/source` can pass it on, with its
+	* default `"lsp"` line breaks: `\n`, `\r\n` and a
+	* bare `\r`, `character` in UTF-16 code units, an offset at the `\n` of a
+	* `\r\n` reading as the end of its line. So for any offset into
+	* `source`:
+	*
+	* - `doc.lineIndex.positionAt(offset)` is the `line`/`character` a
+	*   {@link MarkdownDiagnostic} at that offset carries;
+	* - a node's unist `Point` has `line` = `lineAt(offset) + 1` and
+	*   `column` = `offset - lineStart(line) + 1`: `positionAt` plus one on
+	*   both axes everywhere except at the `\n` of a `\r\n`, which a Point
+	*   counts as one column past the `\r` (as `vfile-location` does) and
+	*   `positionAt` reads as the end of its line;
+	* - `offsetAt`, `spanOf` and `rangeOf` convert an LSP `Position` or
+	*   `Range` back to an offset or a `MarkdownRange`-shaped
+	*   `{ offset, length }`.
+	*
+	* A parsed document returns the index the parse itself built; a document
+	* constructed with `make` builds one on first access. Either way it is
+	* built once per document and shared by every later access. To index a
+	* text with no document, `LineIndex.make(text)` gives the same answers.
+	*
+	* @example
+	* ```ts
+	* import { MarkdownDocument } from "@effected/markdown";
+	* import { Result } from "effect";
+	*
+	* const result = MarkdownDocument.parseResult("# Title\r\n\r\nBody\n");
+	* if (Result.isSuccess(result)) {
+	*   const index = result.success.lineIndex;
+	*   console.log(index.positionAt(12)); // => { line: 2, character: 1 }
+	*   console.log(index.offsetAt({ line: 2, character: 0 })); // => 11
+	* }
+	* ```
+	*/
+	get lineIndex() {
+		const cached = lineIndexes.get(this);
+		if (cached !== void 0) return cached;
+		const index = LineIndex.make(this.source);
+		lineIndexes.set(this, index);
+		return index;
+	}
+	/**
 	* Every heading in the document, in document order, wherever it sits —
 	* including headings nested inside blockquotes and list items.
 	*
@@ -379,12 +435,16 @@ var MarkdownDocument = class MarkdownDocument extends Schema.Class("MarkdownDocu
 	*   `MarkdownParseError`.
 	*/
 	static parseResult(text, options) {
-		return Result.map(parsePassResult(text, options), (pass) => MarkdownDocument.make({
-			source: text,
-			root: pass.root,
-			diagnostics: pass.carriers.map((carrier) => MarkdownDiagnostic.fromRaw(text, carrier)),
-			definitions: pass.refmap
-		}));
+		return Result.map(parsePassResult(text, options), (pass) => {
+			const document = MarkdownDocument.make({
+				source: text,
+				root: pass.root,
+				diagnostics: pass.carriers.map((carrier) => MarkdownDiagnostic.fromRaw(pass.lineIndex, carrier)),
+				definitions: pass.refmap
+			});
+			lineIndexes.set(document, pass.lineIndex);
+			return document;
+		});
 	}
 	/**
 	* Parse markdown into a {@link MarkdownDocument}. Defined in terms of

package/README.md

@@ -5,7 +5,7 @@
 [![Node.js %3E%3D24.11.0](https://img.shields.io/badge/Node.js-%3E%3D24.11.0-5fa04e.svg)](https://nodejs.org/)
 [![TypeScript 7.0](https://img.shields.io/badge/TypeScript-7.0-3178c6.svg)](https://www.typescriptlang.org/)
 
-Zero-dependency CommonMark 0.31.2 and GFM parsing, editing and transformation expressed as Effect schemas and pure functions. Parse markdown into mdast-shaped nodes carrying byte offsets, navigate headings, sections and links, compute surgical offset-splice edits, normalize markers, decode frontmatter into a validated domain schema, project to and from plain mdast for the remark ecosystem, and walk a document as a `Stream`.
+CommonMark 0.31.2 and GFM parsing, editing and transformation expressed as Effect schemas and pure functions. Parse markdown into mdast-shaped nodes carrying byte offsets, navigate headings, sections and links, compute surgical offset-splice edits, normalize markers, decode frontmatter into a validated domain schema, project to and from plain mdast for the remark ecosystem, and walk a document as a `Stream`.
 
 > **Pre-`1.0.0`.** This package is part of the `@effected/*` kit, built on stable
 > Effect v4 (`effect` `^4.0.0`) and still in `0.x` development. Stable Effect
@@ -41,7 +41,7 @@ npm install @effected/markdown effect
 pnpm add @effected/markdown effect
 ```
 
-Requires Node.js >=24.11.0. `effect` v4 is a peer dependency; the package itself adds no runtime dependencies.
+Requires Node.js >=24.11.0. `effect` v4 is a peer dependency; the package's one runtime dependency is the dependency-free `@effected/source`, whose `LineIndex` it re-exports.
 
 `@effected/yaml`, `@effected/toml` and `@effected/jsonc` are **optional** peers, required only by the frontmatter codec module you import. A consumer decoding yaml frontmatter installs `@effected/yaml` and nothing else; a consumer who never touches frontmatter installs none of them.
 

package/index.d.ts

@@ -1,3 +1,4 @@
+import { LineBreaks, LineIndex, LineIndexOptions, SourceDiagnostic, SourceIndex, SourceIndex as SourceIndex$1, SourceLocation, SourcePosition, SourceRange, SourceSpan } from "@effected/source";
 import { Data, Effect, Option, Result, Schema, Stream } from "effect";
 declare const Point_base: Schema.Class<Point, Schema.Struct<{
   readonly line: Schema.Number;
@@ -968,14 +969,20 @@ declare const MarkdownDiagnostic_base: Schema.Class<MarkdownDiagnostic, Schema.S
  * zero-based `line`/`character`).
  *
  * @remarks
- * The five-field positional core (`code`/`offset`/`length`/`line`/`character`)
- * is structurally identical to `@effected/toml`'s `TomlDiagnostic` (and, by
- * the same cross-package contract, `@effected/jsonc`'s parse-error detail
- * shape and `@effected/yaml`'s `YamlDiagnostic`); `message` is this
- * package's additive extra. `line`/`character` here are zero-based to match
- * that contract — a different numbering from the one-based `line`/`column`
- * unist `Point`s carried on `MarkdownNode` positions, which is a deliberate,
- * unrelated convention for the AST rather than a mismatch to reconcile.
+ * Satisfies `@effected/source`'s `SourceDiagnostic<MarkdownParseErrorCode>`:
+ * the positional core (`code`/`message`/`offset`/`length`/`line`/`character`)
+ * the kit's format packages share, so a consumer printing or serving
+ * diagnostics (an LSP server, a CLI annotation) is written once against that
+ * shape. `line`/`character` are zero-based, `character` in UTF-16 code units,
+ * with `\n`, `\r\n` and a bare `\r` as line breaks: exactly
+ * `LineIndex.make(source).positionAt(offset)`, and the same index
+ * {@link MarkdownDocument.lineIndex} returns. An offset at the `\n` of a
+ * `\r\n` reads as the end of its line.
+ *
+ * The one-based `line`/`column` unist `Point`s carried on `MarkdownNode`
+ * positions read the same index, one-based: a deliberate, different
+ * convention for the AST rather than a mismatch to reconcile (see
+ * {@link MarkdownDocument.lineIndex} for the exact mapping).
  *
  * @public
  */
@@ -985,11 +992,19 @@ export declare class MarkdownDiagnostic extends MarkdownDiagnostic_base {
    * from `offset` against the source text. Advanced — the parse entry
    * points call this for you.
    *
-   * @param source - The source text the record's `offset` indexes into.
+   * @remarks
+   * Pass a line index already built over the source to materialize many
+   * records without rescanning the text; a string builds one. The
+   * parameter is the structural `SourceIndex`, so an index from any
+   * installed copy of `@effected/source` is accepted. An offset
+   * outside the source clamps into it, as `LineIndex.positionAt` does.
+   *
+   * @param source - The source text the record's `offset` indexes into, or
+   *   a `LineIndex` over it.
    * @param raw - The engine record: `code`, `message`, `offset` and `length`.
    * @returns The diagnostic with `line` and `character` filled in.
    */
-  static fromRaw(source: string, raw: {
+  static fromRaw(source: string | SourceIndex$1, raw: {
     readonly code: MarkdownParseErrorCode;
     readonly message: string;
     readonly offset: number;
@@ -1653,6 +1668,49 @@ export declare class MarkdownDocument extends MarkdownDocument_base {
    * checking repeatedly.
    */
   get hasFrontmatterBlock(): boolean;
+  /**
+   * The line index over `source`: offsets to zero-based `{ line, character }`
+   * and back, with exactly the rules this package's own positions use.
+   *
+   * @remarks
+   * A `LineIndex` from `@effected/source` (re-exported from this package's
+   * entry point), typed as the structural `SourceIndex` so a consumer on
+   * another installed copy of `@effected/source` can pass it on, with its
+   * default `"lsp"` line breaks: `\n`, `\r\n` and a
+   * bare `\r`, `character` in UTF-16 code units, an offset at the `\n` of a
+   * `\r\n` reading as the end of its line. So for any offset into
+   * `source`:
+   *
+   * - `doc.lineIndex.positionAt(offset)` is the `line`/`character` a
+   *   {@link MarkdownDiagnostic} at that offset carries;
+   * - a node's unist `Point` has `line` = `lineAt(offset) + 1` and
+   *   `column` = `offset - lineStart(line) + 1`: `positionAt` plus one on
+   *   both axes everywhere except at the `\n` of a `\r\n`, which a Point
+   *   counts as one column past the `\r` (as `vfile-location` does) and
+   *   `positionAt` reads as the end of its line;
+   * - `offsetAt`, `spanOf` and `rangeOf` convert an LSP `Position` or
+   *   `Range` back to an offset or a `MarkdownRange`-shaped
+   *   `{ offset, length }`.
+   *
+   * A parsed document returns the index the parse itself built; a document
+   * constructed with `make` builds one on first access. Either way it is
+   * built once per document and shared by every later access. To index a
+   * text with no document, `LineIndex.make(text)` gives the same answers.
+   *
+   * @example
+   * ```ts
+   * import { MarkdownDocument } from "@effected/markdown";
+   * import { Result } from "effect";
+   *
+   * const result = MarkdownDocument.parseResult("# Title\r\n\r\nBody\n");
+   * if (Result.isSuccess(result)) {
+   *   const index = result.success.lineIndex;
+   *   console.log(index.positionAt(12)); // => { line: 2, character: 1 }
+   *   console.log(index.offsetAt({ line: 2, character: 0 })); // => 11
+   * }
+   * ```
+   */
+  get lineIndex(): SourceIndex$1;
   /**
    * Every heading in the document, in document order, wherever it sits —
    * including headings nested inside blockquotes and list items.
@@ -3004,120 +3062,22 @@ export type MarkdownVisitorEvent = Data.TaggedEnum<{
  *
  * @public
  */
-export declare const MarkdownVisitorEvent: {
-  readonly $is: <Tag extends "Enter" | "Error" | "Exit">(tag: Tag) => (u: unknown) => u is Extract<{
-    readonly _tag: "Enter";
-    readonly node: MarkdownNode;
-    readonly path: MarkdownPath;
-    readonly depth: number;
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "Error";
-    readonly diagnostic: MarkdownDiagnostic;
-    readonly path: MarkdownPath;
-    readonly depth: number;
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "Exit";
-    readonly node: MarkdownNode;
-    readonly path: MarkdownPath;
-    readonly depth: number;
-  }, {
-    readonly _tag: Tag;
-  }>;
-  readonly $match: {
-    <Cases extends {
-      readonly Enter: (args: {
-        readonly _tag: "Enter";
-        readonly node: MarkdownNode;
-        readonly path: MarkdownPath;
-        readonly depth: number;
-      }) => any;
-      readonly Error: (args: {
-        readonly _tag: "Error";
-        readonly diagnostic: MarkdownDiagnostic;
-        readonly path: MarkdownPath;
-        readonly depth: number;
-      }) => any;
-      readonly Exit: (args: {
-        readonly _tag: "Exit";
-        readonly node: MarkdownNode;
-        readonly path: MarkdownPath;
-        readonly depth: number;
-      }) => any;
-    }>(cases: Cases): (value: {
-      readonly _tag: "Enter";
-      readonly node: MarkdownNode;
-      readonly path: MarkdownPath;
-      readonly depth: number;
-    } | {
-      readonly _tag: "Error";
-      readonly diagnostic: MarkdownDiagnostic;
-      readonly path: MarkdownPath;
-      readonly depth: number;
-    } | {
-      readonly _tag: "Exit";
-      readonly node: MarkdownNode;
-      readonly path: MarkdownPath;
-      readonly depth: number;
-    }) => import("effect/Unify").Unify<ReturnType<Cases["Enter" | "Error" | "Exit"]>>;
-    <Cases extends {
-      readonly Enter: (args: {
-        readonly _tag: "Enter";
-        readonly node: MarkdownNode;
-        readonly path: MarkdownPath;
-        readonly depth: number;
-      }) => any;
-      readonly Error: (args: {
-        readonly _tag: "Error";
-        readonly diagnostic: MarkdownDiagnostic;
-        readonly path: MarkdownPath;
-        readonly depth: number;
-      }) => any;
-      readonly Exit: (args: {
-        readonly _tag: "Exit";
-        readonly node: MarkdownNode;
-        readonly path: MarkdownPath;
-        readonly depth: number;
-      }) => any;
-    }>(value: {
-      readonly _tag: "Enter";
-      readonly node: MarkdownNode;
-      readonly path: MarkdownPath;
-      readonly depth: number;
-    } | {
-      readonly _tag: "Error";
-      readonly diagnostic: MarkdownDiagnostic;
-      readonly path: MarkdownPath;
-      readonly depth: number;
-    } | {
-      readonly _tag: "Exit";
-      readonly node: MarkdownNode;
-      readonly path: MarkdownPath;
-      readonly depth: number;
-    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Enter" | "Error" | "Exit"]>>;
-  };
-  readonly Enter: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Enter";
-    readonly node: MarkdownNode;
-    readonly path: MarkdownPath;
-    readonly depth: number;
-  }, "_tag">;
-  readonly Error: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Error";
-    readonly diagnostic: MarkdownDiagnostic;
-    readonly path: MarkdownPath;
-    readonly depth: number;
-  }, "_tag">;
-  readonly Exit: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Exit";
-    readonly node: MarkdownNode;
-    readonly path: MarkdownPath;
-    readonly depth: number;
-  }, "_tag">;
-};
+export declare const MarkdownVisitorEvent: Data.TaggedEnum.Constructor<{
+  readonly _tag: "Enter";
+  readonly node: MarkdownNode;
+  readonly path: MarkdownPath;
+  readonly depth: number;
+} | {
+  readonly _tag: "Error";
+  readonly diagnostic: MarkdownDiagnostic;
+  readonly path: MarkdownPath;
+  readonly depth: number;
+} | {
+  readonly _tag: "Exit";
+  readonly node: MarkdownNode;
+  readonly path: MarkdownPath;
+  readonly depth: number;
+}>;
 /**
  * Walks a parsed markdown tree as a lazy sequence of `Enter`/`Exit` events in
  * document pre-order — synchronously with {@link MarkdownVisitor.walk}, or as
@@ -3443,5 +3403,5 @@ export declare const TomlFrontmatter: FrontmatterCodec;
  * @public
  */
 export declare const YamlFrontmatter: FrontmatterCodec;
-export type { DocumentHeading, DocumentLink, FrontmatterCodec, FrontmatterResolveError, FrontmatterSchemaError, FrontmatterSchemaResolver, FrontmatterWriteError, LinkBearingNode, MarkdownNodeOfType, MarkdownNodeType, MarkdownPath, MarkdownPhrasingOnlyType, MarkdownRangeLike, MarkdownSegment, MarkdownStringifyOptions, MarkdownTransformHandlers, MarkdownTransformResult, MdastNode, MdastToTextOptions, SectionHeadingMatch, SectionQueryOptions, SectionSpan, SectionSpanOptions, ShiftHeadingsOptions };
+export { type DocumentHeading, type DocumentLink, type FrontmatterCodec, type FrontmatterResolveError, type FrontmatterSchemaError, type FrontmatterSchemaResolver, type FrontmatterWriteError, type LineBreaks, LineIndex, type LineIndexOptions, type LinkBearingNode, type MarkdownNodeOfType, type MarkdownNodeType, type MarkdownPath, type MarkdownPhrasingOnlyType, type MarkdownRangeLike, type MarkdownSegment, type MarkdownStringifyOptions, type MarkdownTransformHandlers, type MarkdownTransformResult, type MdastNode, type MdastToTextOptions, type SectionHeadingMatch, type SectionQueryOptions, type SectionSpan, type SectionSpanOptions, type ShiftHeadingsOptions, type SourceDiagnostic, type SourceIndex, type SourceLocation, type SourcePosition, type SourceRange, type SourceSpan };
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -13,5 +13,6 @@ import { MarkdownVisitor, MarkdownVisitorEvent } from "./MarkdownVisitor.js";
 import { Mdast, MdastDecodeError } from "./Mdast.js";
 import { TomlFrontmatter } from "./TomlFrontmatter.js";
 import { YamlFrontmatter } from "./YamlFrontmatter.js";
+import { LineIndex } from "@effected/source";
 
-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 };
+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, LineIndex, 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

@@ -1,12 +1,13 @@
-import { Frontmatter, Point, Position, Root } from "../MarkdownNode.js";
+import { Frontmatter, Position, Root } from "../MarkdownNode.js";
 import { scanFrontmatter } from "./blocks/frontmatter.js";
 import { makeBlockNode } from "./blockTypes.js";
 import { columnsToNextTabStop, preprocessLines } from "./preprocess.js";
 import { isHtmlBlockEnd } from "./blocks/htmlBlock.js";
 import { blockDialect } from "./blockRegistry.js";
 import { GuardExceeded } from "./carriers.js";
-import { LineIndex } from "./lineIndex.js";
+import { pointAt } from "./point.js";
 import { prepareInline } from "./rawInline.js";
+import { LineIndex } from "@effected/source";
 
 // src/internal/blockParser.ts
 /** Upstream's cheap pre-filter: a line that cannot start any block. */
@@ -42,9 +43,7 @@ var BlockParser = class {
 	constructor(text, dialect, dialectName, frontmatter = false) {
 		this.lines = preprocessLines(text);
 		this.frontmatterCapture = frontmatter ? scanFrontmatter(this.lines, text) : null;
-		const starts = this.lines.map((line) => line.start);
-		if (text.endsWith("\n")) starts.push(text.length);
-		this.lineIndex = LineIndex.fromLineStarts(text, starts);
+		this.lineIndex = LineIndex.make(text);
 		this.sourceLength = text.length;
 		this.dialect = dialect;
 		this.dialectName = dialectName;
@@ -306,19 +305,9 @@ var BlockParser = class {
 	position(startOffset, endOffset) {
 		const start = Math.min(Math.max(startOffset, 0), this.sourceLength);
 		const end = Math.min(Math.max(endOffset, start), this.sourceLength);
-		const startPoint = this.lineIndex.positionAt(start);
-		const endPoint = this.lineIndex.positionAt(end);
 		return Position.make({
-			start: Point.make({
-				line: startPoint.line,
-				column: startPoint.column,
-				offset: start
-			}),
-			end: Point.make({
-				line: endPoint.line,
-				column: endPoint.column,
-				offset: end
-			})
+			start: pointAt(this.lineIndex, start),
+			end: pointAt(this.lineIndex, end)
 		});
 	}
 	/**
@@ -402,7 +391,8 @@ var BlockParser = class {
 			rawInlines,
 			carriers: [],
 			refmap,
-			footnoteLabels
+			footnoteLabels,
+			lineIndex: this.lineIndex
 		};
 	}
 };

package/internal/phrasing.js

@@ -1,8 +1,9 @@
-import { Point, Position } from "../MarkdownNode.js";
+import { Position } from "../MarkdownNode.js";
 import { preprocessLines } from "./preprocess.js";
-import { LineIndex } from "./lineIndex.js";
+import { pointAt } from "./point.js";
 import { parseInlines } from "./inlineParser.js";
 import { trimWithSegments } from "./rawInline.js";
+import { LineIndex } from "@effected/source";
 
 // src/internal/phrasing.ts
 const EMPTY_REFMAP = /* @__PURE__ */ new Map();
@@ -26,24 +27,14 @@ const parsePhrasingText = (text, dialect) => {
 	if (trimmed.text.length === 0) return [];
 	const first = trimmed.segments[0];
 	const startOffset = first === void 0 ? 0 : first.sourceOffset;
-	const lineIndex = LineIndex.fromLineStarts(text, lines.map((line) => line.start));
+	const lineIndex = LineIndex.make(text);
 	const sourceLength = text.length;
 	const positionOf = (start, end) => {
 		const clampedStart = Math.min(Math.max(start, 0), sourceLength);
 		const clampedEnd = Math.min(Math.max(end, clampedStart), sourceLength);
-		const startPoint = lineIndex.positionAt(clampedStart);
-		const endPoint = lineIndex.positionAt(clampedEnd);
 		return Position.make({
-			start: Point.make({
-				line: startPoint.line,
-				column: startPoint.column,
-				offset: clampedStart
-			}),
-			end: Point.make({
-				line: endPoint.line,
-				column: endPoint.column,
-				offset: clampedEnd
-			})
+			start: pointAt(lineIndex, clampedStart),
+			end: pointAt(lineIndex, clampedEnd)
 		});
 	};
 	return parseInlines({

package/internal/point.js

@@ -0,0 +1,32 @@
+import { Point } from "../MarkdownNode.js";
+
+// src/internal/point.ts
+/**
+* The unist `Point` of `offset` within `index`'s text: one-based `line` and
+* `column`, plus the offset itself.
+*
+* @remarks
+* The caller clamps `offset` into `[0, text.length]` first, so `offset` is
+* always the point's own offset.
+*
+* The column is `offset - lineStart(line) + 1`, NOT `positionAt(offset)`
+* plus one. The two differ at exactly one offset class, the `\n` of a
+* `\r\n`: `positionAt` reads it as the end of its line (LSP cannot name the
+* middle of a terminator), while a unist Point counts it as one column past
+* the `\r`, as `vfile-location` and `mdast-util-from-markdown` do. Node
+* positions DO land there: an empty list item before a CRLF ends at its `\n`
+* (`"*\r\na"` ends the item at offset 2, line 1, column 3), so the
+* `positionAt` form would change published positions.
+*
+* @internal
+*/
+const pointAt = (index, offset) => {
+	const line = index.lineAt(offset);
+	return Point.make({
+		line: line + 1,
+		column: offset - index.lineStart(line) + 1,
+		offset
+	});
+};
+
+export { pointAt };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/markdown",
-	"version": "0.23.0",
+	"version": "0.24.0",
 	"private": false,
 	"description": "CommonMark and GFM markdown parse, edit and transform schemas for Effect",
 	"keywords": [
@@ -38,10 +38,13 @@
 		},
 		"./package.json": "./package.json"
 	},
+	"dependencies": {
+		"@effected/source": "^0.1.0"
+	},
 	"peerDependencies": {
-		"@effected/jsonc": "^0.20.0",
-		"@effected/toml": "^0.16.0",
-		"@effected/yaml": "^0.25.1",
+		"@effected/jsonc": "^0.21.0",
+		"@effected/toml": "^0.17.0",
+		"@effected/yaml": "^0.26.0",
 		"effect": "^4.0.0"
 	},
 	"peerDependenciesMeta": {

package/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.59.1"
+      "packageVersion": "7.59.4"
     }
   ]
 }

package/internal/lineIndex.js

@@ -1,75 +0,0 @@
-// src/internal/lineIndex.ts
-/**
-* A precomputed index of line-start offsets over a fixed source text,
-* answering `positionAt(offset)` in `O(log n)` via binary search rather than
-* rescanning the text per query.
-*
-* @remarks
-* Only `\n` begins a new line. A `\r` immediately before a `\n` (CRLF) is
-* left as the trailing character of the prior line — the pair still reads as
-* a single boundary because the following `\n` is what advances the line
-* counter, not the `\r`. A bare `\r` (old Mac line endings) is not
-* recognized as a break; CommonMark's preprocessing pass normalizes those
-* before this index is ever built.
-*/
-var LineIndex = class LineIndex {
-	text;
-	lineStarts;
-	constructor(text, lineStarts) {
-		this.text = text;
-		this.lineStarts = lineStarts;
-	}
-	/**
-	* Build a {@link LineIndex} over `text` with one forward scan.
-	*
-	* @remarks
-	* Recognizes only `\n`, which is why the block pass hands over its own
-	* line table instead — see {@link LineIndex.fromLineStarts}.
-	*/
-	static make(text) {
-		const lineStarts = [0];
-		for (let i = 0; i < text.length; i++) if (text.charCodeAt(i) === 10) lineStarts.push(i + 1);
-		return new LineIndex(text, lineStarts);
-	}
-	/**
-	* Build a {@link LineIndex} over `text` from a line table someone else
-	* already computed.
-	*
-	* @remarks
-	* The parser splits lines on `\r\n`, `\n` AND a bare `\r`; this index's
-	* own scan recognizes only `\n`. For any document without a bare `\r` the
-	* two agree, but for one with them they disagree about what a line is, and
-	* every reported line number would be wrong. Handing the parser's own
-	* table over removes the possibility rather than documenting it: there is
-	* one definition of a line, and it belongs to the preprocessor.
-	*
-	* `starts` must be ascending and begin at 0; a table that is neither is a
-	* wiring bug and dies as a defect.
-	*/
-	static fromLineStarts(text, starts) {
-		if (starts.length === 0 || starts[0] !== 0) throw new TypeError("line index: a line table must be non-empty and start at offset 0");
-		return new LineIndex(text, starts);
-	}
-	/**
-	* The 1-based `{ line, column }` of `offset` within this index's text.
-	* Out-of-range offsets clamp to the nearest valid position (`0` or
-	* `text.length`) rather than throwing.
-	*/
-	positionAt(offset) {
-		const clamped = Math.min(Math.max(offset, 0), this.text.length);
-		let low = 0;
-		let high = this.lineStarts.length - 1;
-		while (low < high) {
-			const mid = low + high + 1 >> 1;
-			if ((this.lineStarts[mid] ?? 0) <= clamped) low = mid;
-			else high = mid - 1;
-		}
-		const lineStart = this.lineStarts[low] ?? 0;
-		return {
-			line: low + 1,
-			column: clamped - lineStart + 1
-		};
-	}
-};
-
-export { LineIndex };