YAML

https://eemeli.org/yaml/
Admin
A complete JavaScript implementation of YAML parsing and stringification with support for YAML 1.1...
Tokens:45,579
Snippets:219
Trust Score:7.9
Update:5 days ago
Show doc for...
Tokens:
Raw
### Example YAML file (file.yml)

Source: https://eemeli.org/yaml

A sample YAML document used in the parse example to demonstrate reading a file with YAML.parse.

```yaml
# file.yml
YAML:
  - A human-readable data serialization language
  - https://en.wikipedia.org/wiki/YAML
yaml:
  - A complete JavaScript implementation
  - https://www.npmjs.com/package/yaml

```

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

### Install yaml with npm or deno

Source: https://eemeli.org/yaml

Install the yaml package using npm or the Deno registry. The npm command is the standard installation; the deno command uses the jsr:@eemeli/yaml package.

```bash
npm install yaml
# or
deno add jsr:@eemeli/yaml
```

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

### YAML 1.0 example showing tag syntax

Source: https://eemeli.org/yaml

Example YAML 1.0 document demonstrating tag syntax with '!int', '!str', '!!ball', '!domain.tld', and '!^customer'. This is used to illustrate the changes in tag syntax between YAML 1.0 and 1.1.

```yaml
%YAML:1.0
---
date: 2001-01-23
number: !int '123'
string: !str 123
pool: !!ball { number: 8 }
invoice: !domain.tld,2002/^invoice
  customers: !^customer
    - !^customer
      given : Chris
      family : Dumars

```

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

### Document accessor methods example

Source: https://eemeli.org/yaml

Shows how to use get, getIn, hasIn, addIn, and deleteIn on a parsed document. The document is created from a YAML string with parseDocument. The example demonstrates accessing and modifying nested values.

```javascript
const doc = parseDocument('a: 1\nb: [2, 3]\n')
doc.get('a') // 1
doc.getIn([]) // YAMLMap { items: [Pair, Pair], ... }
doc.hasIn(['b', 0]) // true
doc.addIn(['b'], 4) // -> doc.get('b').items.length === 3
doc.deleteIn(['b', 1]) // true
doc.getIn(['b', 1]) // 4

```

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

### YAML 1.1 example showing boolean, octal, sexagesimal, and binary

Source: https://eemeli.org/yaml

Example YAML 1.1 document demonstrating boolean 'Yes', octal '014', sexagesimal '3:25:45', and binary data. This is used to illustrate the differences in parsing between YAML 1.1 and 1.2.

```yaml
%YAML 1.1
---
true: Yes
octal: 014
sexagesimal: 3:25:45
picture: !!binary |
  R0lGODlhDAAMAIQAAP//9/X
  17unp5WZmZgAAAOfn515eXv
  Pz7Y6OjuDg4J+fn5OTk6enp
  56enmleECcgggoBADs=

```

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

### Parsed output of YAML 1.1 example

Source: https://eemeli.org/yaml

The parsed output of the YAML 1.1 example, showing how the library interprets the values: 'Yes' becomes true, octal 014 becomes 12, sexagesimal becomes 12345, and binary becomes a Buffer.

```javascript
{ true: true,
  octal: 12,
  sexagesimal: 12345,
  picture:
   Buffer [Uint8Array] [
     71, 73, 70, 56, 57, 97, 12, 0, 12, 0, 132, 0, 0,
     255, 255, 247, 245, 245, 238, 233, 233, 229, 102,
     102, 102, 0, 0, 0, 231, 231, 231, 94, 94, 94, 243,
     243, 237, 142, 142, 142, 224, 224, 224, 159, 159,
     159, 147, 147, 147, 167, 167, 167, 158, 158, 158,
     105, 94, 16, 39, 32, 130, 10, 1, 0, 59 ] }

```

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

### Using collection accessor methods on a Document

Source: https://eemeli.org/yaml

Demonstrates add, addIn, set, setIn, delete, deleteIn, get, getIn, and has methods on a YAML Document. Shows that setIn on a scalar path throws an error, and that get with keepScalar returns the Scalar node.

```javascript
const doc = new YAML.Document({ a: 1, b: [2, 3] }) // { a: 1, b: [ 2, 3 ] }
doc.add({ key: 'c', value: 4 }) // { a: 1, b: [ 2, 3 ], c: 4 }
doc.addIn(['b'], 5)             // { a: 1, b: [ 2, 3, 5 ], c: 4 }
doc.set('c', 42)                // { a: 1, b: [ 2, 3, 5 ], c: 42 }
doc.setIn(['c', 'x']) // Error: Expected YAML collection at c. Remaining path: x
doc.delete('c')                 // { a: 1, b: [ 2, 3, 5 ] }
doc.deleteIn(['b', 1])          // { a: 1, b: [ 2, 5 ] }

doc.get('a') // 1
doc.get('a', true) // Scalar { value: 1 }
doc.getIn(['b', 1]) // 5
doc.has(doc.createNode('a')) // true
doc.has('c') // false
doc.hasIn(['b', '0']) // true
```

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

### YAML.parse examples

Source: https://eemeli.org/yaml

Shows how to use YAML.parse on strings and a file. The function returns the parsed value, throwing on error and logging warnings via console.warn. It only supports a single document.

```javascript
import fs from 'fs'
import YAML from 'yaml'

YAML.parse('3.14159')
// 3.14159

YAML.parse('[ true, false, maybe, null ]\n')
// [ true, false, 'maybe', null ]

const file = fs.readFileSync('./file.yml', 'utf8')
YAML.parse(file)
// { YAML:
//   [ 'A human-readable data serialization language',
//     'https://en.wikipedia.org/wiki/YAML' ],
//   yaml:
//   [ 'A complete JavaScript implementation',
//     'https://www.npmjs.com/package/yaml' ] }

```

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

### new Parser(onNewLine?: (offset: number) => void)

Source: https://eemeli.org/yaml

Creates a new Parser instance. If onNewLine is provided, it is called with the start position of each new line during parsing.

```APIDOC
## new Parser(onNewLine?: (offset: number) => void)

### Description
Creates a new Parser instance. If onNewLine is provided, it is called with the start position of each new line during parsing.

### Constructor
`new Parser(onNewLine?: (offset: number) => void)`

### Parameters
- **onNewLine** (function) - Optional - Called with the start position of each new line (in parse(), including the start of input).
```

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

### Counting lines with LineCounter and Parser

Source: https://eemeli.org/yaml

Parses a YAML string and uses LineCounter to track line starts and compute line/column positions for offsets. The example shows the expected output for lineStarts and linePos calls.

```javascript
import { LineCounter, Parser } from 'yaml'

const lineCounter = new LineCounter()
const parser = new Parser(lineCounter.addNewLine))
const tokens = parser.parse('foo:\n- 24\n- "42"\n')
Array.from(tokens) // forces iteration

lineCounter.lineStarts
> [ 0, 5, 10, 17 ]
lineCounter.linePos(3)
> { line: 1, col: 4 }
lineCounter.linePos(5)
> { line: 2, col: 1 }
```

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

### parse() with merge option

Source: https://eemeli.org/yaml

Example of using the merge option to enable YAML 1.1 merge keys.

```APIDOC
## parse() with merge option

### Description
Enables support for `<<` merge keys when parsing YAML 1.1 documents.

### Method
parse

### Parameters
#### Options
- **merge** (boolean) - Optional - Enable support for `<<` merge keys. Default depends on YAML version (true for 1.1, false for 1.2).

### Request Example
```js
const src = `
  source: &base { a: 1, b: 2 }
  target:
    <<: *base
    b: base`
const mergeResult = parse(src, { merge: true })
mergeResult.target
// { a: 1, b: 'base' }
```

### Response
#### Success Response
Returns the parsed JavaScript value with merge keys applied.
```

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

### Lexer example: tokenize YAML string

Source: https://eemeli.org/yaml

Creates a Lexer instance and lexes the YAML string 'foo: bar\nfee:\n  [24,"42"]\n'. The output is an array of tokens, including control characters like '\x02' (doc-mode) and '\x1f' (scalar).

```javascript
import { Lexer } from 'yaml'

const tokens = new Lexer().lex('foo: bar\nfee:\n  [24,"42"]\n')
console.dir(Array.from(tokens))
> [
    '\x02', '\x1F', 'foo',  ':',
    ' ',    '\x1F', 'bar',  '\n',
    '\x1F', 'fee',  ':',    '\n',
    '  ',   '[',    '\x1F', '24',
    ',',    '"42"', ']',    '\n'
  ]

```

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

### parse() with schema options

Source: https://eemeli.org/yaml

Examples of using the parse() function with different schema options to control how scalar values are interpreted.

```APIDOC
## parse()

### Description
Parses a YAML string and returns the resulting JavaScript value. The schema option determines how scalar values are interpreted.

### Method
parse

### Parameters
#### Options
- **schema** (string) - Optional - The base schema to use. Built-in support is provided for 'core', 'failsafe', 'json', and 'yaml-1.1'. Default depends on YAML version.
- **version** (string) - Optional - The YAML version used by documents without a %YAML directive. Default '1.2'.

### Request Example
```js
parse('3') // 3 (Using YAML 1.2 core schema by default)
parse('3', { schema: 'failsafe' }) // '3'

parse('No') // 'No'
parse('No', { schema: 'json' }) // SyntaxError: Unresolved plain scalar "No"
parse('No', { schema: 'yaml-1.1' }) // false
parse('No', { version: '1.1' }) // false
```

### Response
#### Success Response
Returns the parsed JavaScript value.

#### Error Response
May throw a SyntaxError if the input cannot be parsed with the given schema.
```

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

### Using type guard functions to identify YAML nodes

Source: https://eemeli.org/yaml

Shows how to use the type guard functions from the 'yaml' library to check node types. The example creates a Document and tests various nodes with isDocument, isNode, isMap, isPair, isCollection, and isScalar. These guards work across different instances of the library.

```javascript
import {
  isAlias,
  isCollection, // map or seq
  isDocument,
  isMap,
  isNode, // alias, scalar, map or seq
  isPair,
  isScalar,
  isSeq
} from 'yaml'

const doc = new Document({ foo: [13, 42] })
isDocument(doc) === true
isNode(doc) === false
isMap(doc.contents) === true
isNode(doc.contents) === true
isPair(doc.contents.items[0]) === true
isCollection(doc.get('foo')) === true
isScalar(doc.getIn(['foo', 1])) === true
```

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

### lineCounter.addNewLine(offset: number)

Source: https://eemeli.org/yaml

Adds the starting index of a new line. Should be called in order, or the internal lineStarts array will need to be sorted before calling linePos(). Bound to the instance, so may be used directly as a callback.

```APIDOC
## lineCounter.addNewLine(offset: number)

### Description
Adds the starting index of a new line. Should be called in order, or the internal lineStarts array will need to be sorted before calling linePos(). Bound to the instance, so may be used directly as a callback.

### Method
`addNewLine(offset: number)`

### Parameters
- **offset** (number) - Required - The starting index of a new line.
```

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

### YAML.stringify examples

Source: https://eemeli.org/yaml

Shows how to use YAML.stringify on numbers, arrays, and objects. The returned string always ends with a newline, and the simplest string style is chosen based on content.

```javascript
YAML.stringify(3.14159)
// '3.14159\n'

YAML.stringify([true, false, 'maybe', null])
// `- true
// - false
// - maybe
// - null
// `

YAML.stringify({ number: 3, plain: 'string', block: 'two\nlines\n' })
// `number: 3
// plain: string
// block: >
//   two
//
//   lines
// `

```

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

### ToJS mapAsMap option example

Source: https://eemeli.org/yaml

Shows the difference in output when parsing a mapping with a complex key, with and without the mapAsMap option. Without mapAsMap, the key is converted to a string; with mapAsMap, the result is a Map with the original array as key.

```javascript
parse('{[1, 2]: many}') // { '[ 1, 2 ]': 'many' }
parse('{[1, 2]: many}', { mapAsMap: true }) // Map { [ 1, 2 ] => 'many' }

```

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

### stringify() with defaultStringType and nullStr options

Source: https://eemeli.org/yaml

Example of calling stringify() with options to control string quoting and null representation. The output shows that null values are rendered as '~' and string values are single-quoted.

```javascript
stringify(
  { this: null, that: 'value' },
  { defaultStringType: 'QUOTE_SINGLE', nullStr: '~' }
)
// 'this': ~
// 'that': 'value'

```

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

### yaml CLI help and usage

Source: https://eemeli.org/yaml

Shows the yaml command-line tool's help message, including usage, options, and additional options for the bare 'yaml' command. Available as 'npx yaml' or 'npm exec yaml'.

```text
yaml: A command-line YAML processor and inspector

Reads stdin and writes output to stdout and errors & warnings to stderr.

Usage:
  yaml          Process a YAML stream, outputting it as YAML
  yaml cst      Parse the CST of a YAML stream
  yaml lex      Parse the lexical tokens of a YAML stream
  yaml valid    Validate a YAML stream, returning 0 on success

Options:
  --help, -h    Show this message.
  --json, -j    Output JSON.
  --indent 2    Output pretty-printed data, indented by the given number of spaces.
  --merge, -m   Enable support for "<<" merge keys.

Additional options for bare "yaml" command:
  --doc, -d     Output pretty-printed JS Document objects.
  --single, -1  Require the input to consist of a single YAML document.
  --strict, -s  Stop on errors.
  --visit, -v   Apply a visitor to each document (requires a path to import)
  --yaml 1.1    Set the YAML version. (default: 1.2)

```

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

### Constructing YAMLSeq and creating pairs

Source: https://eemeli.org/yaml

Imports Document and YAMLSeq, creates a document with a sequence, sets items, adds a pair, and stringifies. Shows how to use createPair and direct item assignment.

```javascript
import { Document, YAMLSeq } from 'yaml'

const doc = new Document(new YAMLSeq())
doc.contents.items = [
  'some values',
  42,
  { including: 'objects', 3: 'a string' }
]
doc.add(doc.createPair(1, 'a number'))

doc.toString()
// - some values
// - 42
// - "3": a string
//   including: objects
// - 1: a number
```

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

### Alias Node class definition and usage example

Source: https://eemeli.org/yaml

Defines the Alias class with source and resolve method. The example parses a YAML string with an anchor and alias, showing that alias nodes reference the same object, and stringifies with an autogenerated anchor.

```javascript
class Alias extends NodeBase {
  source: string
  resolve(doc: Document): Scalar | YAMLMap | YAMLSeq | undefined
}

const obj = YAML.parse('[ &x { X: 42 }, Y, *x ]')
  // => [ { X: 42 }, 'Y', { X: 42 } ]
obj[2].Z = 13
  // => [ { X: 42, Z: 13 }, 'Y', { X: 42, Z: 13 } ]
YAML.stringify(obj)
  // - &a1
  //   X: 42
  //   Z: 13
  // - Y
  // - *a1
```

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

### Parse with intAsBigInt and schema options

Source: https://eemeli.org/yaml

Shows how to use the parse function with different options. The intAsBigInt option parses integers as BigInt, and the schema option 'failsafe' parses numbers as strings.

```javascript
import { parse, stringify } from 'yaml'

parse('number: 999')
// { number: 999 }

parse('number: 999', { intAsBigInt: true })
// { number: 999n }

parse('number: 999', { schema: 'failsafe' })
// { number: '999' }
```

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

### Creating nodes with Document constructor and createNode

Source: https://eemeli.org/yaml

Shows how to create a Document from an array, use createNode to wrap an object, add the node to the document, and set a comment. The output shows the resulting YAML with the comment.

```javascript
const doc = new YAML.Document(['some', 'values'])
// Document {
//   contents:
//     YAMLSeq {
//       items:
//        [ Scalar { value: 'some' },
//          Scalar { value: 'values' } ] } }

const map = doc.createNode({ balloons: 99 })
// YAMLMap {
//   items:
//    [ Pair {
//        key: Scalar { value: 'balloons' },
//        value: Scalar { value: 99 } } ] }

doc.add(map)
doc.get(0, true).comment = ' A commented item'
String(doc)
// - some # A commented item
// - values
// - balloons: 99
```

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

### CST.visit.parentCollection(cst, path)

Source: https://eemeli.org/yaml

Gets the immediate parent collection of the item at the given path. Throws an error if the collection is not found.

```APIDOC
## CST.visit.parentCollection(cst, path)

### Description
Get the immediate parent collection of the item at `path` from `cst` as the root. Throws an error if the collection is not found.

### Parameters
- **cst** (CST.Document | CST.CollectionItem) - Required - The root CST node.
- **path** (array) - Required - Steps from root to target node as `['key' | 'value', number]` tuples.

### Returns
- **CST.BlockMap | CST.BlockSequence | CST.FlowCollection** - The parent collection.
```

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

### YAML.visitAsync(node, visitor): Promise<void>

Source: https://eemeli.org/yaml

The same as visit(), but allows for visitor functions that return a promise which resolves to one of the control values.

```APIDOC
## YAML.visitAsync(node, visitor): Promise<void>

### Description
The same as `visit()`, but allows for visitor functions that return a promise which resolves to one of the above-defined control values.

### Method
visitAsync

### Parameters
- **node** (Node) - Required - The AST node or document to visit.
- **visitor** (Function | Object) - Required - A visitor function or an object with separate visitor functions for each node type.

### Return Value
- **Promise<void>** - A promise that resolves when the traversal is complete.

### Example
```javascript
await YAML.visitAsync(doc, async (key, node, path) => {
  // async visitor logic
})
```
```

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

### Document#createPair(key, value, options?)

Source: https://eemeli.org/yaml

Recursively wraps key and value into a Pair object. See Creating Nodes for more information.

```APIDOC
## Document#createPair(key, value, options?)

### Description
Recursively wraps `key` and `value` into a `Pair` object. See Creating Nodes for more information.

### Method
createPair(key, value, options?)

### Parameters
- **key** (any) - Required - The key for the pair.
- **value** (any) - Required - The value for the pair.
- **options** (object) - Optional - Options for creating the pair.

### Returns
`Pair` - The created Pair object.
```

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

### Collection Accessor Methods

Source: https://eemeli.org/yaml

Common methods available on all collections (YAMLMap, YAMLSeq, and their subclasses) for adding, deleting, getting, hashing, and setting values.

```APIDOC
## Collection Accessor Methods

### Description
Common methods available on all collections (YAMLMap, YAMLSeq, and their subclasses) for adding, deleting, getting, hashing, and setting values.

### Methods
#### add(value) / addIn(path, value)
Adds a value to the collection. For `!!map` and `!!omap` the value must be a Pair instance or a `{ key, value }` object, which may not have a key that already exists in the map.
- **value** (any) - The value to add.
- **path** (Iterable<unknown>) - The path to the collection where the value should be added.
- Returns: void

#### delete(key) / deleteIn(path)
Removes a value from the collection. Returns `true` if the item was found and removed.
- **key** (any) - The key to delete.
- **path** (Iterable<unknown>) - The path to the value to delete.
- Returns: boolean

#### get(key, [keep]) / getIn(path, [keep])
Returns value at `key`, or `undefined` if not found. By default unwraps scalar values from their surrounding node; to disable set `keep` to `true` (collections are always returned intact).
- **key** (any) - The key to get.
- **path** (Iterable<unknown>) - The path to the value.
- **keep** (boolean) - If true, returns the scalar node instead of unwrapping.
- Returns: any

#### has(key) / hasIn(path)
Checks if the collection includes a value with the key `key`.
- **key** (any) - The key to check.
- **path** (Iterable<unknown>) - The path to check.
- Returns: boolean

#### set(key, value) / setIn(path, value)
Sets a value in this collection. For `!!set`, `value` needs to be a boolean to add/remove the item from the set. When overwriting a `Scalar` value with a scalar, the original node is retained.
- **key** (any) - The key to set.
- **value** (any) - The value to set.
- **path** (Iterable<unknown>) - The path to the value to set.
- Returns: any

```

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

### YAMLSeq Class

Source: https://eemeli.org/yaml

Represents a YAML sequence (list). Extends Collection and provides methods for adding, deleting, getting, hashing, and setting values by index.

```APIDOC
## YAMLSeq Class

### Description
Represents a YAML sequence (list). Extends Collection and provides methods for adding, deleting, getting, hashing, and setting values by index.

### Properties
- **items** (T[]) - The array of items in the sequence.

### Methods
#### add(value)
Adds a value to the sequence.
- **value** (T) - The value to add.
- Returns: void

#### delete(key)
Deletes an item at the given index.
- **key** (number | Scalar<number>) - The index to delete.
- Returns: boolean - true if the item was found and removed.

#### get(key, keepScalar?)
Gets the value at the given index.
- **key** (number | Scalar<number>) - The index to get.
- **keepScalar** (boolean) - If true, returns the scalar node instead of unwrapping.
- Returns: unknown

#### has(key)
Checks if the sequence has an item at the given index.
- **key** (number | Scalar<number>) - The index to check.
- Returns: boolean

#### set(key, value)
Sets a value at the given index.
- **key** (number | Scalar<number>) - The index to set.
- **value** (T) - The value to set.
- Returns: void

```

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

### YAMLMap Class

Source: https://eemeli.org/yaml

Represents a YAML mapping (key-value pairs). Extends Collection and provides methods for adding, deleting, getting, hashing, and setting key-value pairs.

```APIDOC
## YAMLMap Class

### Description
Represents a YAML mapping (key-value pairs). Extends Collection and provides methods for adding, deleting, getting, hashing, and setting key-value pairs.

### Properties
- **items** (Pair<K, V>[]) - The array of pairs in the map.

### Methods
#### add(pair, overwrite?)
Adds a pair to the map.
- **pair** (Pair<K, V> | { key: K; value: V }) - The pair to add.
- **overwrite** (boolean) - If true, overwrite existing key.
- Returns: void

#### delete(key)
Deletes a key from the map.
- **key** (K) - The key to delete.
- Returns: boolean - true if the item was found and removed.

#### get(key, keepScalar?)
Gets the value for a key.
- **key** (K) - The key to get.
- **keepScalar** (boolean) - If true, returns the scalar node instead of unwrapping.
- Returns: unknown

#### has(key)
Checks if the map has a key.
- **key** (K) - The key to check.
- Returns: boolean

#### set(key, value)
Sets a value for a key.
- **key** (K) - The key to set.
- **value** (V) - The value to set.
- Returns: void

```

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

### new Composer(options?: ParseOptions & DocumentOptions & SchemaOptions)

Source: https://eemeli.org/yaml

Creates a new Document composer. Does not include an internal Parser instance, so an external one will be needed. Options will be used during composition and passed to the new Document constructor.

```APIDOC
## new Composer(options?: ParseOptions & DocumentOptions & SchemaOptions)

### Description
Creates a new Document composer. Does not include an internal Parser instance, so an external one will be needed. Options will be used during composition and passed to the new Document constructor.

### Constructor
`new Composer(options?: ParseOptions & DocumentOptions & SchemaOptions)`

### Parameters
- **options** (ParseOptions & DocumentOptions & SchemaOptions) - Optional - Options for parsing, document creation, and schema.

### Usage Example
```js
import { Composer, Parser } from 'yaml'

const src = 'foo: bar\nfee: [24, "42"]'
const tokens = new Parser().parse(src)
const docs = new Composer().compose(tokens)

Array.from(docs, doc => doc.toJS())
> [{ foo: 'bar', fee: [24, '42'] }]
```
```

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

### Collection Class

Source: https://eemeli.org/yaml

Base class for YAML collections (YAMLMap and YAMLSeq). Provides methods for adding, deleting, getting, hashing, and setting values using paths.

```APIDOC
## Collection Class

### Description
Base class for YAML collections (YAMLMap and YAMLSeq). Provides methods for adding, deleting, getting, hashing, and setting values using paths.

### Properties
- **anchor** (string) - An anchor associated with this node.
- **flow** (boolean) - Use flow style when stringifying this.
- **schema** (Schema) - The schema associated with this collection.

### Methods
#### addIn(path, value)
Adds a value to the collection at the specified path.
- **path** (Iterable<unknown>) - The path to the collection where the value should be added.
- **value** (unknown) - The value to add.
- Returns: void

#### clone(schema?)
Returns a deep copy of this collection.
- **schema** (Schema) - Optional schema to use for the clone.
- Returns: NodeBase

#### deleteIn(path)
Removes a value from the collection at the specified path.
- **path** (Iterable<unknown>) - The path to the value to delete.
- Returns: boolean - true if the item was found and removed.

#### getIn(path, keepScalar?)
Returns the value at the specified path.
- **path** (Iterable<unknown>) - The path to the value.
- **keepScalar** (boolean) - If true, returns the scalar node instead of unwrapping.
- Returns: unknown

#### hasIn(path)
Checks if the collection has a value at the specified path.
- **path** (Iterable<unknown>) - The path to check.
- Returns: boolean

#### setIn(path, value)
Sets a value in the collection at the specified path.
- **path** (Iterable<unknown>) - The path to the value to set.
- **value** (unknown) - The value to set.
- Returns: void

```

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

### visitAsync(node, visitor)

Source: https://eemeli.org/yaml

Asynchronously visits all nodes in a YAML document, calling the visitor function for each node.

```APIDOC
## visitAsync(node, visitor)

### Description
Asynchronously visits all nodes in a YAML document.

### Method
visitAsync

### Parameters
- **node** (Node) - Required - The root node to visit.
- **visitor** (function) - Required - The visitor function.

### Returns
- **Promise<void>**
```

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

### Import Composer, Lexer, and Parser

Source: https://eemeli.org/yaml

Import the low-level parsing classes Composer, Lexer, and Parser for advanced YAML parsing.

```javascript
import { Composer, Lexer, Parser } from 'yaml'
```

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

### new Lexer()

Source: https://eemeli.org/yaml

Creates a new Lexer instance for tokenizing YAML input. The lexer operates a state machine and should never throw an error except due to resource exhaustion.

```APIDOC
## new Lexer()

### Description
Creates a new Lexer instance for tokenizing YAML input. The lexer operates a state machine and should never throw an error except due to resource exhaustion.

### Method
Constructor

### Parameters
None

### Response
Returns a Lexer instance.
```

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

### Import CST from 'yaml'

Source: https://eemeli.org/yaml

Import the CST namespace from the yaml package to work with concrete syntax tree tokens.

```javascript
import { CST } from 'yaml'

```

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

### Import content node utilities

Source: https://eemeli.org/yaml

Import type guards, Scalar, YAMLMap, YAMLSeq, and visit functions for working with content nodes.

```javascript
import {
  isAlias, isCollection, isMap, isNode,
  isPair, isScalar, isSeq, Scalar,
  visit, visitAsync, YAMLMap, YAMLSeq
} from 'yaml'
```

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

### Document#createNode(value, options?)

Source: https://eemeli.org/yaml

Recursively wraps any input with appropriate Node containers. See Creating Nodes for more information.

```APIDOC
## Document#createNode(value, options?)

### Description
Recursively wraps any input with appropriate `Node` containers. See Creating Nodes for more information.

### Method
createNode(value, options?)

### Parameters
- **value** (any) - Required - The value to wrap.
- **options** (object) - Optional - Options for creating the node.

### Returns
`Node` - The wrapped Node.
```

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

### Document#toJS(), toJSON(), toString() example

Source: https://eemeli.org/yaml

Shows the output of toJS(), toJSON(), and String(doc) for a document with a timestamp tag. The document is parsed with customTags: ['timestamp']. toJS() returns a Date object, toJSON() returns a string, and String(doc) returns a YAML string.

```javascript
const src = '1969-07-21T02:56:15Z'
const doc = parseDocument(src, { customTags: ['timestamp'] })

doc.toJS()
// Date { 1969-07-21T02:56:15.000Z }

doc.toJSON()
// '1969-07-21T02:56:15.000Z'

String(doc)
// '1969-07-21T02:56:15\n'

```

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

### new Composer(options?).compose(tokens)

Source: https://eemeli.org/yaml

Composes a stream of CST tokens into a YAML document.

```APIDOC
## new Composer(options?).compose(tokens)

### Description
Composes a stream of CST tokens into a YAML document.

### Method
compose

### Parameters
- **options** (object) - Optional - Composer options.
- **tokens** (Iterable<Token>) - Required - The tokens to compose.

### Returns
- **Document** - The composed document.
```

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

### Document constructor

Source: https://eemeli.org/yaml

Creates a new Document instance, which represents a YAML document and provides methods for modification and serialization.

```APIDOC
## new Document(value, replacer?, options?)

### Description
Creates a new Document instance.

### Method
constructor

### Parameters
- **value** (any) - Required - The initial value for the document.
- **replacer** (function) - Optional - A replacer function.
- **options** (object) - Optional - Document options.

### Returns
- **Document** - A new Document instance.
```

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

### Merge keys example: parse() with merge option

Source: https://eemeli.org/yaml

Demonstrates using merge keys (YAML 1.1 feature) with the merge option set to true. The source uses an anchor and alias to merge a base map, and the result shows that the target map has the merged values with the local 'b' overriding.

```javascript
const src = `
  source: &base { a: 1, b: 2 }
  target:
    <<: *base
    b: base`
const mergeResult = parse(src, { merge: true })
mergeResult.target
// { a: 1, b: 'base' }
```

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

### new Parser(onNewLine?).parse(src)

Source: https://eemeli.org/yaml

Parses a YAML string into a stream of CST (concrete syntax tree) tokens.

```APIDOC
## new Parser(onNewLine?).parse(src)

### Description
Parses a YAML string into a stream of CST tokens.

### Method
parse

### Parameters
- **onNewLine** (function) - Optional - Callback for new lines.
- **src** (string) - Required - The YAML source string.

### Returns
- **Iterable<Token>** - An iterable of CST tokens.
```

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

### Schema options example: parse() with different schemas

Source: https://eemeli.org/yaml

Shows how the schema option affects parsing of scalar values. The default core schema parses '3' as number 3, while failsafe keeps it as string '3'. The json schema throws a SyntaxError for 'No', and yaml-1.1 or version '1.1' parses 'No' as false.

```javascript
parse('3') // 3 (Using YAML 1.2 core schema by default)
parse('3', { schema: 'failsafe' }) // '3'

parse('No') // 'No'
parse('No', { schema: 'json' }) // SyntaxError: Unresolved plain scalar "No"
parse('No', { schema: 'yaml-1.1' }) // false
parse('No', { version: '1.1' }) // false
```

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

### Document.createPair(key, value, options?)

Source: https://eemeli.org/yaml

Creates a new Pair object, recursively wrapping the key and value as nodes. Accepts the same options as createNode.

```APIDOC
## Document.createPair(key, value, options?)

### Description
Creates a new Pair object, recursively wrapping the key and value as nodes. Accepts the same options as createNode.

### Method
createPair

### Parameters
- **key** (any) - Required - The key for the pair.
- **value** (any) - Required - The value for the pair.
- **options** (CreateNodeOptions) - Optional - Options for node creation.

### Returns
- **Pair** - The created pair.

### Example
```js
const doc = new Document(new YAMLSeq())
doc.contents.items = [
  'some values',
  42,
  { including: 'objects', 3: 'a string' }
]
doc.add(doc.createPair(1, 'a number'))
doc.toString()
// - some values
// - 42
// - "3": a string
//   including: objects
// - 1: a number
```
```

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

### Document Accessor Methods

Source: https://eemeli.org/yaml

The document object provides the same accessor methods as collections, based on the top-level collection: add, delete, get, has, and set, along with their deeper variants addIn, deleteIn, getIn, hasIn, and setIn. For the *In methods using an empty path value (null, undefined, or []) will refer to the document's top-level contents.

```APIDOC
## Document Accessor Methods

### Description
The document object provides the same **accessor methods** as collections, based on the top-level collection: `add`, `delete`, `get`, `has`, and `set`, along with their deeper variants `addIn`, `deleteIn`, `getIn`, `hasIn`, and `setIn`. For the `*In` methods using an empty `path` value (i.e. `null`, `undefined`, or `[]`) will refer to the document's top-level `contents`.

### Methods
- `add`
- `delete`
- `get`
- `has`
- `set`
- `addIn`
- `deleteIn`
- `getIn`
- `hasIn`
- `setIn`

### Example
```js
const doc = parseDocument('a: 1\nb: [2, 3]\n')
doc.get('a') // 1
doc.getIn([]) // YAMLMap { items: [Pair, Pair], ... }
doc.hasIn(['b', 0]) // true
doc.addIn(['b'], 4) // -> doc.get('b').items.length === 3
doc.deleteIn(['b', 1]) // true
doc.getIn(['b', 1]) // 4
```
```
Tokens:
Raw