@markuplint/markdown-parser 5.0.0-alpha.0

package/ARCHITECTURE.md

@@ -0,0 +1,190 @@
+# @markuplint/markdown-parser
+
+## Overview
+
+`@markuplint/markdown-parser` parses Markdown (`.md`) files for markuplint. It converts both Markdown-native syntax and embedded HTML into markuplint's AST. Markdown constructs (headings, links, images, lists, emphasis, tables, etc.) are mapped to their equivalent HTML elements, enabling lint rules like `heading-levels`, `required-attr`, and `wai-aria` to work on Markdown content. Raw HTML regions are delegated to `HtmlParser`.
+
+## Design Decisions
+
+### Why `remark-parse` (unified ecosystem)?
+
+| Approach                     | Pros                                                                    | Cons                                                              | Verdict    |
+| ---------------------------- | ----------------------------------------------------------------------- | ----------------------------------------------------------------- | ---------- |
+| **`remark-parse`** (unified) | De facto standard; mdast AST with position info; extensible via plugins | Adds unified ecosystem as dependency                              | **Chosen** |
+| **`@mdx-js/mdx`**            | Official MDX package                                                    | Wraps `remark-parse` internally; adds 24 unnecessary dependencies | Rejected   |
+| **`micromark`** (direct)     | Maximum control; lowest level                                           | Must build mdast conversion manually; no practical benefit        | Rejected   |
+
+### Why extend `Parser` via `MarkdownAwareParser` (not `HtmlParser`)?
+
+Earlier designs extended `HtmlParser` and treated Markdown as opaque psblock nodes. The current design extends `Parser<MdastNode>` through `MarkdownAwareParser` because:
+
+1. **Markdown elements are now lintable** -- headings, links, images, etc. are converted to their HTML equivalents, enabling rule coverage
+2. **Synthetic attributes** -- Markdown's `![alt](src)` produces `<img src="..." alt="...">` with synthesized attributes
+3. **Shared base class** -- `MarkdownAwareParser` provides common Markdown-to-HTML conversion logic reused by `@markuplint/mdx-parser`
+
+Raw HTML regions (CommonMark HTML blocks and inline HTML) are still parsed via a cached `HtmlParser` instance for full HTML support.
+
+### Markdown elements as HTML equivalents
+
+| Markdown Syntax     | HTML Element               | Attributes                       |
+| ------------------- | -------------------------- | -------------------------------- |
+| `# Heading`         | `h1`-`h6`                  | --                               |
+| `[text](url)`       | `a`                        | `href`, optionally `title`       |
+| `![alt](url)`       | `img`                      | `src`, `alt`, optionally `title` |
+| `*text*` / `_text_` | `em`                       | --                               |
+| `**text**`          | `strong`                   | --                               |
+| `- item`            | `ul` > `li`                | --                               |
+| `1. item`           | `ol` > `li`                | `start` when != 1                |
+| `> quote`           | `blockquote`               | --                               |
+| `` `code` ``        | `code`                     | --                               |
+| ` ```lang ... ``` ` | `pre` > `code`             | `class="language-{lang}"`        |
+| `---`               | `hr`                       | --                               |
+| GFM `\| table \|`   | `table` > `tr` > `th`/`td` | --                               |
+| GFM `~~text~~`      | `del`                      | --                               |
+| `[text][ref]`       | `a`                        | resolved from definitions        |
+| `![alt][ref]`       | `img`                      | resolved from definitions        |
+
+### Synthetic attribute positions
+
+Markdown syntax does not have discrete source positions for attributes. Synthesized attributes (e.g., `href` from `[text](url)`) point to the element's own token range. This is an intentional trade-off: markuplint can check attribute existence and values, but attribute-level source positions are approximate.
+
+### blockquote and cite
+
+The HTML `<blockquote>` element supports a `cite` attribute for source URLs, but Markdown's `> quote` syntax has no equivalent. The parser does not synthesize a `cite` attribute.
+
+## How It Works
+
+```
+.md source file
+    |
+    v
+[remark-parse + remark-gfm + remark-frontmatter]
+    |                       Parse Markdown into mdast AST
+    v
+[collectDefinitions()]     Extract [id]: url definitions
+    |
+    v
+[nodeize() per mdast node]
+    |
+    +-- heading         -->  h1-h6 element with text children
+    +-- paragraph       -->  p element with inline children
+    +-- emphasis/strong -->  em/strong elements
+    +-- link            -->  a element with href, title attrs
+    +-- image           -->  img element with src, alt, title attrs
+    +-- list/listItem   -->  ul/ol > li elements
+    +-- blockquote      -->  blockquote element
+    +-- inlineCode      -->  code element with text child
+    +-- code (fenced)   -->  pre > code elements
+    +-- table/row/cell  -->  table > tr > th/td elements
+    +-- delete (GFM)    -->  del element
+    +-- linkReference   -->  a element (resolved) or psblock
+    +-- imageReference  -->  img element (resolved) or psblock
+    +-- html            -->  HtmlParser.parse() with offset mapping
+    +-- text            -->  MLASTText
+    +-- yaml            -->  psblock (#ps:yaml)
+    +-- definition      -->  psblock
+    v
+MLASTDocument             Positions reference the original .md file
+```
+
+### Class Hierarchy
+
+```
+Parser<MdastNode>               (from @markuplint/parser-utils)
+  |
+  MarkdownAwareParser           (shared Markdown-to-HTML conversion)
+    |                            - createSyntheticAttr()
+    |                            - visitMarkdownElement()
+    |                            - visitLinkElement() / visitImageElement()
+    |                            - visitListElement() / visitCodeBlock()
+    |                            - visitTableElement()
+    |                            - nodeizeMarkdownNode()
+    |                            - collectDefinitions()
+    |
+    MarkdownParser              (this package)
+      |                          - tokenize(): remark-parse + remark-gfm
+      |                          - nodeize(): delegates then handles html/text/yaml
+      |                          - #htmlParser: cached HtmlParser for HTML regions
+```
+
+### GFM Table Header Detection
+
+GFM tables use the first row as the header row. The parser tracks this via:
+
+1. `visitTableElement()` records the first row's source offset in `#headerRowOffsets`
+2. `nodeizeMarkdownNode()` for `tableRow` checks the offset set to decide `th` vs `td`
+3. The set is consumed (deleted) after use, so subsequent rows produce `td` cells
+
+### Link/Image Reference Resolution
+
+1. `tokenize()` calls `collectDefinitions()` to build a `Map<identifier, Definition>`
+2. `nodeizeMarkdownNode()` dispatches `linkReference`/`imageReference` to resolution methods
+3. Resolved references produce `<a>` or `<img>` elements; unresolved ones become psblock nodes
+4. Note: remark-parse resolves references at parse time when definitions exist, so unresolved references typically appear as plain text rather than `linkReference` nodes
+
+## Architecture Diagram
+
+```mermaid
+flowchart TD
+    subgraph upstream ["Upstream"]
+        parserUtils["@markuplint/parser-utils\n(Parser base class)"]
+        htmlParser["@markuplint/html-parser\n(HtmlParser for HTML regions)"]
+        remark["remark-parse\n(Markdown -> mdast)"]
+        remarkGfm["remark-gfm\n(GFM tables, strikethrough)"]
+        remarkFm["remark-frontmatter\n(Front matter support)"]
+    end
+
+    subgraph pkg ["@markuplint/markdown-parser"]
+        aware["MarkdownAwareParser\nextends Parser<MdastNode>"]
+        mdParser["MarkdownParser\nextends MarkdownAwareParser"]
+    end
+
+    subgraph downstream ["Downstream"]
+        mdxParser["@markuplint/mdx-parser\n(reuses MarkdownAwareParser)"]
+        mlCore["@markuplint/ml-core\n(MLASTDocument -> MLDOM)"]
+    end
+
+    parserUtils -->|"base class"| aware
+    remark -->|"mdast AST"| mdParser
+    remarkGfm -->|"GFM extensions"| mdParser
+    remarkFm -->|"front matter"| mdParser
+    htmlParser -->|"HTML region parsing"| mdParser
+    aware -->|"extends"| mdParser
+    aware -->|"shared base"| mdxParser
+    mdParser -->|"MLASTDocument"| mlCore
+```
+
+## External Dependencies
+
+| Dependency                 | Purpose                                |
+| -------------------------- | -------------------------------------- |
+| `@markuplint/html-parser`  | Parses raw HTML regions in Markdown    |
+| `@markuplint/ml-ast`       | AST type definitions                   |
+| `@markuplint/parser-utils` | Parser base class, token utilities     |
+| `unified`                  | Processor pipeline for remark          |
+| `remark-parse`             | Markdown -> mdast parser               |
+| `remark-gfm`               | GFM extensions (tables, strikethrough) |
+| `remark-frontmatter`       | Front matter (YAML) support in mdast   |
+
+## Directory Structure
+
+```
+src/
++-- index.ts                 -- Re-exports parser instance and MarkdownAwareParser
++-- parser.ts                -- MarkdownParser class
++-- markdown-aware-parser.ts -- MarkdownAwareParser shared base class
++-- index.spec.ts            -- Unit and integration tests
+```
+
+## Relationship to @markuplint/mdx-parser
+
+Both parsers share `MarkdownAwareParser` as a common base class. The key differences:
+
+| Aspect          | markdown-parser (.md)      | mdx-parser (.mdx)                  |
+| --------------- | -------------------------- | ---------------------------------- |
+| Base class      | MarkdownAwareParser        | MarkdownAwareParser                |
+| HTML regions    | HtmlParser re-parse        | parseCodeFragment (XML-style)      |
+| JSX support     | No                         | Yes (components, expressions, ESM) |
+| Attribute style | HTML (`class`, `for`)      | JSX (`className`, `htmlFor`)       |
+| Tag closing     | HTML rules (void elements) | XML rules (self-closing required)  |
+| Spec package    | None needed                | `@markuplint/react-spec`           |

package/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+
+# [5.0.0-alpha.0](https://github.com/markuplint/markuplint/compare/v4.14.1...v5.0.0-alpha.0) (2026-02-20)
+
+### Features
+
+- **markdown-parser:** add Markdown parser for markuplint ([cc30558](https://github.com/markuplint/markuplint/commit/cc3055816f1fad56ba4691df445865f3f82dc500))

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017-2024 Yusuke Hirao
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.ja.md

@@ -0,0 +1,47 @@
+# @markuplint/markdown-parser
+
+[![npm version](https://badge.fury.io/js/%40markuplint%2Fmarkdown-parser.svg)](https://www.npmjs.com/package/@markuplint/markdown-parser)
+
+**Markdown** ファイルで **markuplint** を使用するためのパーサーです。
+
+Markdown 構文（見出し、リンク、画像、リスト、テーブルなど）を対応する HTML 要素に変換し、markuplint のルールで解析できるようにします。[GFM](https://github.github.com/gfm/)（テーブル、取り消し線、オートリンク）および YAML フロントマターをサポートしています。
+
+## インストール
+
+```shell
+$ npm install -D @markuplint/markdown-parser
+
+$ yarn add -D @markuplint/markdown-parser
+```
+
+## 使い方
+
+[設定ファイル](https://markuplint.dev/configuration/#properties/parser)に `parser` オプションを追加してください。
+
+```json
+{
+  "parser": {
+    ".md$": "@markuplint/markdown-parser"
+  }
+}
+```
+
+## 対応構文
+
+| Markdown                              | HTML                         |
+| ------------------------------------- | ---------------------------- |
+| `# 見出し`                            | `<h1>` – `<h6>`              |
+| `[テキスト](url)` / `[テキスト][ref]` | `<a href="...">`             |
+| `![alt](url)` / `![alt][ref]`         | `<img src="..." alt="...">`  |
+| `- アイテム` / `1. アイテム`          | `<ul>` / `<ol>` と `<li>`    |
+| `` `コード` ``                        | `<code>`                     |
+| フェンスコードブロック                | `<pre><code>`                |
+| `> 引用`                              | `<blockquote>`               |
+| GFM テーブル                          | `<table>` と `<th>` / `<td>` |
+| `~~テキスト~~`                        | `<del>`                      |
+| `---`                                 | `<hr>`                       |
+| 生 HTML                               | HTML としてパース            |
+
+## 既知の制限事項
+
+- **合成された属性位置**: Markdown 構文から導出された属性（例: `[テキスト](url)` の `href`）は、属性値の正確な文字位置ではなく、Markdown 構文全体のソース位置を共有します。

package/README.md

@@ -0,0 +1,47 @@
+# @markuplint/markdown-parser
+
+[![npm version](https://badge.fury.io/js/%40markuplint%2Fmarkdown-parser.svg)](https://www.npmjs.com/package/@markuplint/markdown-parser)
+
+Use **markuplint** with **Markdown** files.
+
+Converts Markdown constructs (headings, links, images, lists, tables, etc.) to their corresponding HTML elements so that markuplint rules can analyze them. Supports [GFM](https://github.github.com/gfm/) (tables, strikethrough, autolinks) and YAML frontmatter.
+
+## Install
+
+```shell
+$ npm install -D @markuplint/markdown-parser
+
+$ yarn add -D @markuplint/markdown-parser
+```
+
+## Usage
+
+Add `parser` option to your [configuration](https://markuplint.dev/configuration/#properties/parser).
+
+```json
+{
+  "parser": {
+    ".md$": "@markuplint/markdown-parser"
+  }
+}
+```
+
+## Supported Syntax
+
+| Markdown                      | HTML                           |
+| ----------------------------- | ------------------------------ |
+| `# Heading`                   | `<h1>` – `<h6>`                |
+| `[text](url)` / `[text][ref]` | `<a href="...">`               |
+| `![alt](url)` / `![alt][ref]` | `<img src="..." alt="...">`    |
+| `- item` / `1. item`          | `<ul>` / `<ol>` with `<li>`    |
+| `` `code` ``                  | `<code>`                       |
+| Fenced code block             | `<pre><code>`                  |
+| `> quote`                     | `<blockquote>`                 |
+| GFM table                     | `<table>` with `<th>` / `<td>` |
+| `~~text~~`                    | `<del>`                        |
+| `---`                         | `<hr>`                         |
+| Raw HTML                      | Parsed as HTML                 |
+
+## Known Limitations
+
+- **Synthesized attribute positions**: Attributes derived from Markdown syntax (e.g., `href` from `[text](url)`) share the source position of the enclosing Markdown construct rather than pointing to the exact character range of the attribute value.

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @module @markuplint/markdown-parser
+ */
+/** @internal Exported for subclass use by mdx-parser; not part of the public API. */
+export { MarkdownAwareParser } from './markdown-aware-parser.js';
+export { parser } from './parser.js';

package/lib/index.js

@@ -0,0 +1,6 @@
+/**
+ * @module @markuplint/markdown-parser
+ */
+/** @internal Exported for subclass use by mdx-parser; not part of the public API. */
+export { MarkdownAwareParser } from './markdown-aware-parser.js';
+export { parser } from './parser.js';

package/lib/markdown-aware-parser.d.ts

@@ -0,0 +1,179 @@
+import type { MLASTAttr, MLASTHTMLAttr, MLASTNodeTreeItem, MLASTParentNode } from '@markuplint/ml-ast';
+import type { ParserOptions, Token } from '@markuplint/parser-utils';
+import type { Code, Definition, Image, InlineCode, Link, List, RootContent, Table } from 'mdast';
+import { Parser } from '@markuplint/parser-utils';
+type MdastNode = RootContent;
+/**
+ * Abstract base class for parsers that handle Markdown content.
+ *
+ * Provides shared logic for converting mdast nodes (headings, links, images,
+ * lists, code, tables, etc.) into markuplint's AST. Both MarkdownParser and
+ * MDXParser extend this class to avoid code duplication.
+ */
+export declare abstract class MarkdownAwareParser extends Parser<MdastNode> {
+    #private;
+    /**
+     * Stores link/image reference definitions (`[id]: url "title"`)
+     * extracted during tokenization for resolving linkReference/imageReference nodes.
+     */
+    protected definitions: Map<string, Definition>;
+    constructor(options?: ParserOptions);
+    /**
+     * Resets mutable state accumulated during a previous `parse()` call.
+     *
+     * Must be called at the beginning of every `tokenize()` invocation to
+     * prevent definitions, header-row offsets, and cell-name state from
+     * leaking across successive `parse()` calls on the same parser instance.
+     */
+    protected resetMarkdownState(): void;
+    /**
+     * Adjusts the flattened node list for Markdown output.
+     *
+     * Disables whitespace and invalid-node exposure because Markdown
+     * generates only synthetic elements with no real HTML whitespace tokens.
+     *
+     * @param nodeList - The flattened node tree produced by the base class.
+     * @returns The adjusted node list.
+     */
+    afterFlattenNodes(nodeList: readonly MLASTNodeTreeItem[]): readonly MLASTNodeTreeItem[];
+    /**
+     * Creates a synthetic HTML attribute token for Markdown-derived elements.
+     *
+     * The attribute positions point to the element's own token range because
+     * Markdown syntax does not have discrete attribute source positions.
+     *
+     * @param name - The attribute name (e.g., `"href"`, `"alt"`).
+     * @param value - The attribute value extracted from Markdown syntax.
+     * @param token - The source token whose position is reused for the attribute.
+     * @returns A fully-formed HTML attribute node.
+     */
+    protected createSyntheticAttr(name: string, value: string, token: Token): MLASTHTMLAttr;
+    /**
+     * Builds a generic HTML element node from a Markdown construct.
+     *
+     * @param token - The source token covering the entire construct.
+     * @param nodeName - The HTML element name (e.g., `"p"`, `"h1"`, `"li"`).
+     * @param childNodes - The mdast children to recurse into.
+     * @param depth - Current nesting depth in the AST.
+     * @param parentNode - Parent AST node, or `null` for top-level nodes.
+     * @param attributes - Optional pre-built attributes to attach.
+     * @returns The element node followed by its descendants.
+     */
+    protected visitMarkdownElement(token: Token, nodeName: string, childNodes: readonly MdastNode[], depth: number, parentNode: MLASTParentNode | null, attributes?: readonly MLASTAttr[]): readonly MLASTNodeTreeItem[];
+    /**
+     * Builds an `<a>` element with `href` (and optionally `title`) attributes.
+     *
+     * @param originNode - The mdast `link` node.
+     * @param token - The source token covering the link.
+     * @param depth - Current nesting depth.
+     * @param parentNode - Parent AST node, or `null` for top-level.
+     * @returns The `<a>` element node and its descendants.
+     */
+    protected visitLinkElement(originNode: Link, token: Token, depth: number, parentNode: MLASTParentNode | null): readonly MLASTNodeTreeItem[];
+    /**
+     * Builds an `<img>` element with `src`, `alt`, and optionally `title` attributes.
+     *
+     * @param originNode - The mdast `image` node.
+     * @param token - The source token covering the image.
+     * @param depth - Current nesting depth.
+     * @param parentNode - Parent AST node, or `null` for top-level.
+     * @returns The `<img>` element node.
+     */
+    protected visitImageElement(originNode: Image, token: Token, depth: number, parentNode: MLASTParentNode | null): readonly MLASTNodeTreeItem[];
+    /**
+     * Builds a `<ul>` or `<ol>` element. Adds a `start` attribute when the
+     * ordered list begins at a number other than 1.
+     *
+     * @param originNode - The mdast `list` node.
+     * @param token - The source token covering the list.
+     * @param depth - Current nesting depth.
+     * @param parentNode - Parent AST node, or `null` for top-level.
+     * @returns The list element node and its descendants.
+     */
+    protected visitListElement(originNode: List, token: Token, depth: number, parentNode: MLASTParentNode | null): readonly MLASTNodeTreeItem[];
+    /**
+     * Builds a `<code>` element for inline code spans (backtick-delimited).
+     *
+     * @param originNode - The mdast `inlineCode` node.
+     * @param token - The source token covering the code span.
+     * @param offset - Start offset in the original source.
+     * @param endOffset - End offset in the original source.
+     * @param depth - Current nesting depth.
+     * @param parentNode - Parent AST node, or `null` for top-level.
+     * @returns The `<code>` element node (with a text child when content is found).
+     */
+    protected visitInlineCode(originNode: InlineCode, token: Token, offset: number, endOffset: number, depth: number, parentNode: MLASTParentNode | null): readonly MLASTNodeTreeItem[];
+    /**
+     * Builds a `<pre><code>` structure for fenced code blocks.
+     * When a language is specified, adds `class="language-{lang}"` to the `<code>` element.
+     *
+     * @param originNode - The mdast `code` node.
+     * @param token - The source token covering the fenced block.
+     * @param depth - Current nesting depth.
+     * @param parentNode - Parent AST node, or `null` for top-level.
+     * @returns The `<pre>` and `<code>` element nodes.
+     */
+    protected visitCodeBlock(originNode: Code, token: Token, depth: number, parentNode: MLASTParentNode | null): readonly MLASTNodeTreeItem[];
+    /**
+     * Builds a `<table>` element from a GFM table node.
+     * Marks the first row's offset as a header row so that its cells become `<th>`.
+     *
+     * @param originNode - The mdast `table` node (GFM extension).
+     * @param token - The source token covering the table.
+     * @param depth - Current nesting depth.
+     * @param parentNode - Parent AST node, or `null` for top-level.
+     * @returns The `<table>` element node and its descendants.
+     */
+    protected visitTableElement(originNode: Table, token: Token, depth: number, parentNode: MLASTParentNode | null): readonly MLASTNodeTreeItem[];
+    /**
+     * Dispatches a single mdast node to the appropriate visit method.
+     *
+     * @param originNode - The mdast node to convert.
+     * @param token - The source token covering the node's range.
+     * @param offset - Start offset in the original source.
+     * @param endOffset - End offset in the original source.
+     * @param depth - Current nesting depth.
+     * @param parentNode - Parent AST node, or `null` for top-level nodes.
+     * @returns An array of AST nodes for recognized Markdown constructs,
+     *   or `null` when the node type is not handled here (the caller is
+     *   responsible for handling it — typically `text`, `html`, or
+     *   parser-specific node types).
+     */
+    protected nodeizeMarkdownNode(originNode: MdastNode, token: Token, offset: number, endOffset: number, depth: number, parentNode: MLASTParentNode | null): readonly MLASTNodeTreeItem[] | null;
+    /**
+     * Resolves a linkReference using collected definitions, producing an `<a>` element.
+     * Falls back to a psblock when the definition is not found.
+     */
+    private visitLinkReference;
+    /**
+     * Resolves an imageReference using collected definitions, producing an `<img>` element.
+     * Falls back to a psblock when the definition is not found.
+     */
+    private visitImageReference;
+    /**
+     * Extracts definition nodes from mdast children and populates `this.definitions`.
+     *
+     * Per CommonMark spec, the first definition for a given identifier takes
+     * precedence. remark-parse emits all definition nodes in source order, so
+     * we skip duplicates via `Map.has` to honour the first-wins rule.
+     *
+     * @param children - The root-level mdast children to scan for `definition` nodes.
+     */
+    protected collectDefinitions(children: readonly RootContent[]): void;
+}
+/**
+ * Computes the 1-based line number and 1-based column for a given offset.
+ *
+ * Equivalent to `getPosition()` in `@markuplint/parser-utils`, but that
+ * function is not exported from the package. Kept as a standalone utility
+ * to avoid coupling to parser-utils internals.
+ *
+ * @param source - The full source string.
+ * @param offset - The 0-based character offset to resolve.
+ * @returns An object with 1-based `line` and `col` values.
+ */
+export declare function getLineAndColumn(source: string, offset: number): {
+    line: number;
+    col: number;
+};
+export {};