Lezer Documentation

https://lezer.codemirror.net/docs
Admin
Lezer is a parser generator system. This documentation covers its concepts, grammar syntax, public...
Tokens:60,047
Snippets:577
Trust Score:9.9
Update:1 week ago
Show doc for...
Tokens:
Raw
### Dynamic precedence example

Source: https://lezer.codemirror.net/docs/guide

Uses @dynamicPrecedence=1 on rule A to favor it over B when both match. Precedence values range from -10 to 10; positive values give a bonus, negative penalize.

```lezer
@top Program { (A | B)+ }

A[@dynamicPrecedence=1] { "!" ~ambig }

B { "!" ~ambig }

```

--------------------------------

### Simple Lezer grammar example

Source: https://lezer.codemirror.net/docs/guide

Defines a grammar with an entry point 'Program' that matches an expression, which can be a name, number, or binary expression. Tokens for names and numbers are defined in the @tokens block. Capitalized rules appear in the syntax tree, while lower-case rules do not.

```lezer
@top Program { expression }

expression { Name | Number | BinaryExpression }

BinaryExpression { "(" expression ("+" | "-") expression ")" }

@tokens {
  Name { @asciiLetter+ }
  Number { @digit+ }
}

```

--------------------------------

### Tree.resolve

Source: https://lezer.codemirror.net/docs/ref

Get the syntax node at the given position.

```APIDOC
## Tree.resolve

### Description
Get the syntax node at the given position. If `side` is -1, this will move into nodes that end at the position. If 1, it'll move into nodes that start at the position. With 0, it'll only enter nodes that cover the position from both sides. Note that this will not enter overlays, and you often want `resolveInner` instead.

### Method
Method

### Endpoint
`resolve(pos: number, side?: -1 | 0 | 1 = 0) → SyntaxNode`

### Parameters
- **pos** (number) - Required - The position to resolve.
- **side** (-1 | 0 | 1) - Optional - The side to use.

### Response
- **SyntaxNode** - The syntax node at the given position.
```

--------------------------------

### Ambiguity markers example

Source: https://lezer.codemirror.net/docs/guide

Shows a grammar with ambiguity markers (~statement) to resolve a reduce/reduce conflict. The parser splits its state and tries both paths, dropping the one that fails on the next token.

```lezer
@top Program { (GoodStatement | BadStatement)+ }

GoodStatement { "(" GoodValue ")" ";" }

GoodValue { "val" ~statement }

BadStatement { "(" BadValue ")" "!" }

BadValue { "val" ~statement }

```

--------------------------------

### styleTags usage example

Source: https://lezer.codemirror.net/docs/ref

Shows how to pass a spec object to styleTags within parser.configure. The spec maps node selectors to tags or arrays of tags, with support for paths, wildcards, and special suffixes like '!' and '/...'.

```javascript
parser.configure({props: [
  styleTags({
    // Style Number and BigNumber nodes
    "Number BigNumber": tags.number,
    // Style Escape nodes whose parent is String
    "String/Escape": tags.escape,
    // Style anything inside Attributes nodes
    "Attributes!": tags.meta,
    // Add a style to all content inside Italic nodes
    "Italic/...": tags.emphasis,
    // Style InvalidString nodes as both `string` and `invalid`
    "InvalidString": [tags.string, tags.invalid],
    // Style the node named "/" as punctuation
    '"/"': tags.punctuation
  })
]})
```

--------------------------------

### Traverse all nodes with TreeCursor

Source: https://lezer.codemirror.net/docs/guide

Creates a cursor from a tree and iterates over every node using the next() method in a do/while loop, logging each node's name and position. Cursors start at the first node, so no initial next() call is needed.

```javascript
let cursor = tree.cursor()
do {
  console.log(`Node ${cursor.name} from ${cursor.from} to ${cursor.to}`)
} while (cursor.next())

```

--------------------------------

### Tree.prop

Source: https://lezer.codemirror.net/docs/ref

Get the value of the given node prop for this node.

```APIDOC
## Tree.prop

### Description
Get the value of the given node prop for this node. Works with both per-node and per-type props.

### Method
Method

### Endpoint
`prop<T>(prop: NodeProp<T>) → T | undefined`

### Parameters
- **prop** (NodeProp<T>) - Required - The node prop to get.

### Response
- **T | undefined** - The value of the prop, or undefined if not set.
```

--------------------------------

### buildParserFile(text: string, options?: BuildOptions) → {parser: string, terms: string}

Source: https://lezer.codemirror.net/docs/ref

Builds the code that represents the parser tables for a given grammar description. Returns an object with 'parser' and 'terms' properties containing the generated code.

```APIDOC
## buildParserFile(text: string, options?: BuildOptions) → {parser: string, terms: string}

### Description
Builds the code that represents the parser tables for a given grammar description. The `parser` property in the return value holds the main file that exports the `Parser` instance. The `terms` property holds a declaration file that defines constants for all of the named terms in grammar, holding their ids as value. This is useful when external code, such as a tokenizer, needs to be able to use these ids. It is recommended to run a tree-shaking bundler when importing this file, since you usually only need a handful of the many terms in your code.

### Method
buildParserFile

### Parameters
#### text (string) - Required - The grammar description text.
#### options (BuildOptions) - Optional - Configuration options for the build.

### Returns
- **parser** (string) - The main file that exports the Parser instance.
- **terms** (string) - A declaration file defining constants for all named terms.

```

--------------------------------

### Tree.topNode

Source: https://lezer.codemirror.net/docs/ref

Get a syntax node object for the top of the tree.

```APIDOC
## Tree.topNode

### Description
Get a syntax node object for the top of the tree.

### Method
Property

### Endpoint
`topNode`

### Response
- **SyntaxNode** - A syntax node object for the top of the tree.
```

--------------------------------

### Tree.cursor

Source: https://lezer.codemirror.net/docs/ref

Get a tree cursor positioned at the top of the tree.

```APIDOC
## Tree.cursor

### Description
Get a tree cursor positioned at the top of the tree. Mode can be used to control which nodes the cursor visits.

### Method
Method

### Endpoint
`cursor(mode?: IterMode = 0 as IterMode) → TreeCursor`

### Parameters
- **mode** (IterMode) - Optional - Controls which nodes the cursor visits.

### Response
- **TreeCursor** - A tree cursor positioned at the top of the tree.
```

--------------------------------

### new TreeFragment(from, to, tree, offset, openStart?, openEnd?)

Source: https://lezer.codemirror.net/docs/ref

Constructs a tree fragment. You'll usually want to use addTree and applyChanges instead of calling this directly.

```APIDOC
## new TreeFragment(from, to, tree, offset, openStart?, openEnd?)

### Description
Constructs a tree fragment. You'll usually want to use `addTree` and `applyChanges` instead of calling this directly.

### Constructor
`new **TreeFragment**(
  from: number,
  to: number,
  tree: Tree,
  offset: number,
  openStart?: boolean = false,
  openEnd?: boolean = false
)`

### Parameters
- **from** (number) - Required - The start of the unchanged range pointed to by this fragment. This refers to an offset in the _updated_ document (as opposed to the original tree).
- **to** (number) - Required - The end of the unchanged range.
- **tree** (Tree) - Required - The tree that this fragment is based on.
- **offset** (number) - Required - The offset between the fragment's tree and the document that this fragment can be used against. Add this when going from document to tree positions, subtract it to go from tree to document positions.
- **openStart** (boolean) - Optional, default `false` - Whether the start of the fragment represents the start of a parse, or the end of a change. (In the second case, it may not be safe to reuse some nodes at the start, depending on the parsing algorithm.)
- **openEnd** (boolean) - Optional, default `false` - Whether the end of the fragment represents the end of a full-document parse, or the start of a change.

### Properties
- **from** (number) - The start of the unchanged range pointed to by this fragment. This refers to an offset in the _updated_ document (as opposed to the original tree).
- **to** (number) - The end of the unchanged range.
- **tree** (Tree) - The tree that this fragment is based on.
- **offset** (number) - The offset between the fragment's tree and the document that this fragment can be used against. Add this when going from document to tree positions, subtract it to go from tree to document positions.
- **openStart** (boolean) - Whether the start of the fragment represents the start of a parse, or the end of a change. (In the second case, it may not be safe to reuse some nodes at the start, depending on the parsing algorithm.)
- **openEnd** (boolean) - Whether the end of the fragment represents the end of a full-document parse, or the start of a change.
```

--------------------------------

### Tree.positions

Source: https://lezer.codemirror.net/docs/ref

The positions (offsets relative to the start of this tree) of the children.

```APIDOC
## Tree.positions

### Description
The positions (offsets relative to the start of this tree) of the children.

### Method
Property

### Endpoint
`positions`

### Response
- **positions** (readonly number[]) - The positions of the children.
```

--------------------------------

### Tree.build(data)

Source: https://lezer.codemirror.net/docs/ref

Builds a tree from a postfix-ordered buffer of node information or a cursor over such a buffer. This is a static method on the Tree class.

```APIDOC
## Tree.build(data)

### Description
Build a tree from a postfix-ordered buffer of node information, or a cursor over such a buffer.

### Method
static build

### Parameters
- **data** (Object) - Required - The data object containing the buffer, node set, and other options.
  - **buffer** (BufferCursor | readonly number[]) - Required - The buffer or buffer cursor to read the node data from. When an array, it contains four values per node: type ID, start offset, end offset, and space taken.
  - **nodeSet** (NodeSet) - Required - The node types to use.
  - **topID** (number) - Required - The id of the top node type.
  - **start** (number) - Optional - The position the tree should start at. Defaults to 0.
  - **bufferStart** (number) - Optional - The position in the buffer where the function should stop reading. Defaults to 0.
  - **length** (number) - Optional - The length of the wrapping node. The end offset of the last child is used when not provided.
  - **maxBufferLength** (number) - Optional - The maximum buffer length to use. Defaults to `DefaultBufferLength`.
  - **reused** (readonly Tree[]) - Optional - An array holding reused nodes that the buffer can refer to.
  - **minRepeatType** (number) - Optional - The first node type that indicates repeat constructs in this grammar.

### Returns
- **Tree** - The newly built tree.
```

--------------------------------

### Tag.tags.escape

Source: https://lezer.codemirror.net/docs/ref

An escape literal, for example a backslash escape in a string.

```APIDOC
## Tag.tags.escape

### Description
An escape literal, for example a backslash escape in a string.

### Method
Property

### Endpoint
Tag.tags.escape

### Parameters
None

### Response
#### Success Response
- **value** (Tag) - The tag for escape literals.

#### Response Example

"escape"

```

--------------------------------

### Tag.tags.docString

Source: https://lezer.codemirror.net/docs/ref

A documentation string.

```APIDOC
## Tag.tags.docString

### Description
A documentation string.

### Method
Property

### Endpoint
Tag.tags.docString

### Parameters
None

### Response
#### Success Response
- **value** (Tag) - The tag for documentation strings.

#### Response Example

"docString"

```

--------------------------------

### Tree.resolveStack

Source: https://lezer.codemirror.net/docs/ref

Get an iterator that produces all nodes around a position, including those in overlays.

```APIDOC
## Tree.resolveStack

### Description
In some situations, it can be useful to iterate through all nodes around a position, including those in overlays that don't directly cover the position. This method gives you an iterator that will produce all nodes, from small to big, around the given position.

### Method
Method

### Endpoint
`resolveStack(pos: number, side?: -1 | 0 | 1 = 0) → NodeIterator`

### Parameters
- **pos** (number) - Required - The position to resolve.
- **side** (-1 | 0 | 1) - Optional - The side to use.

### Response
- **NodeIterator** - An iterator that produces all nodes around the position.
```

--------------------------------

### Tree.cursorAt

Source: https://lezer.codemirror.net/docs/ref

Get a tree cursor pointing into this tree at the given position and side.

```APIDOC
## Tree.cursorAt

### Description
Get a tree cursor pointing into this tree at the given position and side (see `moveTo`).

### Method
Method

### Endpoint
`cursorAt(pos: number, side?: -1 | 0 | 1 = 0, mode?: IterMode = 0 as IterMode) → TreeCursor`

### Parameters
- **pos** (number) - Required - The position to point at.
- **side** (-1 | 0 | 1) - Optional - The side to use (see `moveTo`).
- **mode** (IterMode) - Optional - Controls which nodes the cursor visits.

### Response
- **TreeCursor** - A tree cursor pointing into the tree at the given position and side.
```

--------------------------------

### Parser

Source: https://lezer.codemirror.net/docs/ref

Abstract class that parsers should extend. Provides methods to start and run parses.

```APIDOC
## Parser

### Description
A superclass that parsers should extend.

### Methods
- **createParse**(input: Input, fragments: readonly TreeFragment[], ranges: readonly {from: number, to: number}[]) → PartialParse - Start a parse for a single tree. This is the method concrete parser implementations must implement. Called by `startParse`, with the optional arguments resolved.
- **startParse**(input: Input | string, fragments?: readonly TreeFragment[], ranges?: readonly {from: number, to: number}[]) → PartialParse - Start a parse, returning a partial parse object. `fragments` can be passed in to make the parse incremental. By default, the entire input is parsed. You can pass `ranges`, which should be a sorted array of non-empty, non-overlapping ranges, to parse only those ranges. The tree returned in that case will start at `ranges[0].from`.
- **parse**(input: Input | string, fragments?: readonly TreeFragment[], ranges?: readonly {from: number, to: number}[]) → Tree - Run a full parse, returning the resulting tree.
```

--------------------------------

### Run lezer-generator to compile a grammar file

Source: https://lezer.codemirror.net/docs/guide/index.html

Command-line invocation of lezer-generator to convert lang.grammar into lang.js. If the grammar is valid, it writes lang.js and lang.terms.js. The output file depends on @lezer/lr and any external token declarations.

```bash
lezer-generator lang.grammar -o lang.js

```

--------------------------------

### @context declaration for context tracking

Source: https://lezer.codemirror.net/docs/guide

Enables context tracking with a context tracker imported from './helpers.js'. The tracker describes how to create and update the context value. If context affects node reuse, it should export a 'hash' function.

```lezer
@context trackIndent from "./helpers.js"

```

--------------------------------

### Tree constructor

Source: https://lezer.codemirror.net/docs/ref

Constructs a new syntax tree with the given type, children, positions, length, and optional per-node props.

```APIDOC
## Tree constructor

### Description
Construct a new tree. See also `Tree.build`.

### Method
Constructor

### Endpoint
`new Tree(type: NodeType, children: readonly (Tree | TreeBuffer)[], positions: readonly number[], length: number, props?: readonly [number | NodeProp<any>, any][])`

### Parameters
- **type** (NodeType) - Required - The type of the top node.
- **children** (readonly (Tree | TreeBuffer)[]) - Required - This node's child nodes.
- **positions** (readonly number[]) - Required - The positions (offsets relative to the start of this tree) of the children.
- **length** (number) - Required - The total length of this tree.
- **props** (readonly [number | NodeProp<any>, any][]) - Optional - Per-node node props to associate with this node.

### Response
No return value (constructor).
```

--------------------------------

### Input

Source: https://lezer.codemirror.net/docs/ref

Interface parsers use to access the document. Implement this to run Lezer on custom document data structures.

```APIDOC
## Input

### Description
This is the interface parsers use to access the document. To run Lezer directly on your own document data structure, you have to write an implementation of it.

### Properties
- **length** (number) - The length of the document.
- **lineChunks** (boolean) - Indicates whether the chunks already end at line breaks, so that client code that wants to work by-line can avoid re-scanning them for line breaks. When this is true, the result of `chunk()` should either be a single line break, or the content between `from` and the next line break.

### Methods
- **chunk**(from: number) → string - Get the chunk after the given position. The returned string should start at `from` and, if that isn't the end of the document, may be of any length greater than zero.
- **read**(from: number, to: number) → string - Read the part of the document between the given positions.
```

--------------------------------

### TreeFragment.addTree(tree, fragments?, partial?)

Source: https://lezer.codemirror.net/docs/ref

Creates a set of fragments from a freshly parsed tree, or updates an existing set of fragments by replacing the ones that overlap with a tree with content from the new tree. When partial is true, the parse is treated as incomplete, and the resulting fragment has openEnd set to true.

```APIDOC
## TreeFragment.addTree(tree, fragments?, partial?)

### Description
Creates a set of fragments from a freshly parsed tree, or updates an existing set of fragments by replacing the ones that overlap with a tree with content from the new tree. When `partial` is true, the parse is treated as incomplete, and the resulting fragment has `openEnd` set to true.

### Method
`static **addTree**(
  tree: Tree,
  fragments?: readonly TreeFragment[] = [],
  partial?: boolean = false
) → readonly TreeFragment[]`

### Parameters
- **tree** (Tree) - Required - The tree to add to the fragments.
- **fragments** (readonly TreeFragment[]) - Optional, default `[]` - The existing fragments to update.
- **partial** (boolean) - Optional, default `false` - When true, the parse is treated as incomplete, and the resulting fragment has `openEnd` set to true.

### Returns
- **readonly TreeFragment[]** - The updated set of fragments.
```

--------------------------------

### highlightCode

Source: https://lezer.codemirror.net/docs/ref

Highlight the given tree with the given highlighter, calling putText for every piece of text and putBreak for every line break.

```APIDOC
## highlightCode

### Description
Highlight the given tree with the given highlighter, calling `putText` for every piece of text, either with a set of classes or with the empty string when unstyled, and `putBreak` for every line break.

### Parameters
- **code** (string) - Required - The code string.
- **tree** (Tree) - Required - The syntax tree.
- **highlighter** (Highlighter | readonly Highlighter[]) - Required - The highlighter(s) to use.
- **putText** (fn(code: string, classes: string)) - Required - Callback for text pieces.
- **putBreak** (fn()) - Required - Callback for line breaks.
- **from** (number) - Optional, default 0 - The start of the range to highlight.
- **to** (number) - Optional, default code.length - The end of the range.
```

--------------------------------

### NodeProp.add(match: Object<T> | fn(type: NodeType) → T | undefined) → NodePropSource

Source: https://lezer.codemirror.net/docs/ref

Computes prop values for each node type in a set. Takes a match object or function that returns undefined if the node type doesn't get this prop, and the prop's value if it does.

```APIDOC
## NodeProp.add(match: Object<T> | fn(type: NodeType) → T | undefined) → NodePropSource

### Description
This is meant to be used with `NodeSet.extend` or `LRParser.configure` to compute prop values for each node type in the set. Takes a match object or function that returns undefined if the node type doesn't get this prop, and the prop's value if it does.

### Method
`add(match: Object<T> | fn(type: NodeType) → T | undefined) → NodePropSource`

### Parameters
- **match** (Object<T> | fn(type: NodeType) → T | undefined) - Required - A match object or function that returns undefined if the node type doesn't get this prop, and the prop's value if it does.

### Returns
- **NodePropSource** - A function that describes whether a prop should be added to a given node type in a node set, and what value it should have.
```

--------------------------------

### Tag.tags.string

Source: https://lezer.codemirror.net/docs/ref

A string literal.

```APIDOC
## Tag.tags.string

### Description
A string literal.

### Method
Property

### Endpoint
Tag.tags.string

### Parameters
None

### Response
#### Success Response
- **value** (Tag) - The tag for string literals.

#### Response Example

"string"

```

--------------------------------

### Tag.tags.namespace

Source: https://lezer.codemirror.net/docs/ref

A namespace name.

```APIDOC
## Tag.tags.namespace

### Description
A namespace name.

### Method
Property

### Endpoint
Tag.tags.namespace

### Parameters
None

### Response
#### Success Response
- **value** (Tag) - The tag for namespace names.

#### Response Example

"namespace"

```

--------------------------------

### Grammar using @cut for function declaration precedence

Source: https://lezer.codemirror.net/docs/guide

This grammar uses a @cut precedence marker to force the parser to enter the FunctionDeclaration rule when seeing the `function` keyword at the start of a statement, even though FunctionExpression could also match. The `!decl` marker is placed before the `function` token in the declaration rule.

```lezer
@precedence { decl @cut }

@top Program { statement+ }

statement { FunctionDeclaration | FunctionExpression }

FunctionExpression { "function" "..." }

FunctionDeclaration { !decl "function" "..." }

```

--------------------------------

### parseMixed(nest)

Source: https://lezer.codemirror.net/docs/ref

Creates a parse wrapper that, after the inner parse completes, scans its tree for mixed language regions using the provided nest function, runs the resulting inner parses, and mounts their results onto the tree.

```APIDOC
## parseMixed(nest)

### Description
Create a parse wrapper that, after the inner parse completes, scans its tree for mixed language regions with the `nest` function, runs the resulting inner parses, and then mounts their results onto the tree.

### Method
parseMixed

### Parameters
- **nest** (fn(node: SyntaxNodeRef, input: Input) → NestedParse | null) - Required - A function that, given a syntax node and input, returns a NestedParse object or null if no nested parse is needed.

### Returns
- **ParseWrapper** - A parse wrapper that can be used as a parser.

```

--------------------------------

### Highlighter interface

Source: https://lezer.codemirror.net/docs/ref

Defines a mapping from highlighting tags and language scopes to CSS class names. Implementations must provide a style method and may optionally provide a scope predicate.

```APIDOC
## Highlighter interface

### Description
A highlighter defines a mapping from highlighting tags and language scopes to CSS class names. They are usually defined via `tagHighlighter` or some wrapper around that, but it is also possible to implement them from scratch.

### Methods

#### style(tags: readonly Tag[]) → string | null
Get the set of classes that should be applied to the given set of highlighting tags, or null if this highlighter doesn't assign a style to the tags.

#### scope?: fn(node: NodeType) → boolean
When given, the highlighter will only be applied to trees on whose top node this predicate returns true.
```

--------------------------------

### new TreeBuffer(buffer: Uint16Array, length: number, set: NodeSet)

Source: https://lezer.codemirror.net/docs/ref

Creates a tree buffer with the given content, length, and node set.

```APIDOC
## new TreeBuffer(buffer: Uint16Array, length: number, set: NodeSet)

### Description
Create a tree buffer. Tree buffers contain (type, start, end, endIndex) quads for each node. In such a buffer, nodes are stored in prefix order (parents before children, with the endIndex of the parent indicating which children belong to it).

### Constructor
`new TreeBuffer(buffer: Uint16Array, length: number, set: NodeSet)`

### Parameters
- **buffer** (Uint16Array) - Required - The buffer's content.
- **length** (number) - Required - The total length of the group of nodes in the buffer.
- **set** (NodeSet) - Required - The node set used in this buffer.
```

--------------------------------

### Run lezer-generator to compile a grammar file

Source: https://lezer.codemirror.net/docs/guide

Command-line invocation of lezer-generator to convert lang.grammar into lang.js. The -o option specifies the output file; without it, output goes to standard output and no terms file is generated.

```bash
lezer-generator lang.grammar -o lang.js
```

--------------------------------

### Tag.tags.macroName

Source: https://lezer.codemirror.net/docs/ref

The name of a macro.

```APIDOC
## Tag.tags.macroName

### Description
The name of a macro.

### Method
Property

### Endpoint
Tag.tags.macroName

### Parameters
None

### Response
#### Success Response
- **value** (Tag) - The tag for macro names.

#### Response Example

"macroName"

```

--------------------------------

### buildParser(text: string, options?: BuildOptions) → LRParser

Source: https://lezer.codemirror.net/docs/ref

Builds an in-memory parser instance for a given grammar. This is mostly useful for testing. If your grammar uses external tokenizers, you'll have to provide the `externalTokenizer` option for the returned parser to be able to parse anything.

```APIDOC
## buildParser(text: string, options?: BuildOptions) → LRParser

### Description
Builds an in-memory parser instance for a given grammar. This is mostly useful for testing. If your grammar uses external tokenizers, you'll have to provide the `externalTokenizer` option for the returned parser to be able to parse anything.

### Method
buildParser

### Parameters
#### text (string) - Required - The grammar description text.
#### options (BuildOptions) - Optional - Configuration options for the build.

### Returns
- **LRParser** - The built parser instance.

```

--------------------------------

### Tag.tags.null

Source: https://lezer.codemirror.net/docs/ref

The keyword for null.

```APIDOC
## Tag.tags.null

### Description
The keyword for null.

### Method
Property

### Endpoint
Tag.tags.null

### Parameters
None

### Response
#### Success Response
- **value** (Tag) - The tag for null keywords.

#### Response Example

"null"

```

--------------------------------

### NodeSet constructor

Source: https://lezer.codemirror.net/docs/ref

Creates a new NodeSet with the given types.

```APIDOC
## NodeSet constructor

### Description
Create a set with the given types. The `id` property of each type should correspond to its position within the array.

### Method
`new NodeSet(types: readonly NodeType[])`

### Parameters
- **types** (readonly NodeType[]) - Required - The node types to include in the set.
```

--------------------------------

### Tag.tags.docComment

Source: https://lezer.codemirror.net/docs/ref

A documentation comment.

```APIDOC
## Tag.tags.docComment

### Description
A documentation comment.

### Method
Property

### Endpoint
Tag.tags.docComment

### Parameters
None

### Response
#### Success Response
- **value** (Tag) - The tag for documentation comments.

#### Response Example

"docComment"

```
Tokens:
Raw