Go YAML

https://github.com/goccy/go-yaml
Admin
Go YAML is a high-performance YAML parser library for Go with better compatibility and error...
Tokens:133,431
Snippets:1,052
Trust Score:9.1
License:MIT
Update:3 weeks ago
Show doc for...
Tokens:
Raw
### Install go-yaml with go get

Source: https://github.com/goccy/go-yaml/blob/master/README.md

Install the goccy/go-yaml library using the go get command.

```sh
go get github.com/goccy/go-yaml
```

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

### Install ycat tool

Source: https://github.com/goccy/go-yaml/blob/master/README.md

Clone the go-yaml repository and install the ycat command using go install. This command should be run from the cmd/ycat directory.

```sh
git clone https://github.com/goccy/go-yaml.git
cd go-yaml/cmd/ycat && go install .
```

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

### Syntax-highlighting setup equivalent to cmd/ycat

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/printer.md

Configures a Printer with line numbers and custom PrintFunc properties for numbers and map keys using ANSI color codes. This setup is equivalent to the ycat CLI.

```go
// Syntax-highlighting setup equivalent to cmd/ycat.
var p printer.Printer
p.LineNumber = true
p.Number = func() *printer.Property {
	return &printer.Property{Prefix: "\x1b[95m", Suffix: "\x1b[0m"}
}
p.MapKey = func() *printer.Property {
	return &printer.Property{Prefix: "\x1b[96m", Suffix: "\x1b[0m"}
}
fmt.Println(p.PrintTokens(tokens))
```

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

### Counter walker example

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/ast.md

Implements a Visitor that counts nodes and uses ast.Walk to traverse a document. The example prints the total node count.

```go
type counterWalker struct{ n int }
func (w *counterWalker) Visit(n ast.Node) ast.Visitor {
	if n != nil {
		w.n++
		return w
	}
	return nil
}
w := &counterWalker{}
ast.Walk(w, file.Docs[0])
fmt.Println(w.n)
```

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

### YAMLToJSON and JSONToYAML usage example

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/yaml.md

Example showing conversion between YAML and JSON, with comments showing the expected output.

```go
j, err := yaml.YAMLToJSON([]byte("a: 1\nb: true"))
// {"a":1,"b":true}
y, err := yaml.JSONToYAML(j)
// a: 1
// b: true
```

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

### Using WithSmartAnchor EncodeOption

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/options.md

Example of creating an encoder with smart anchor enabled.

```go
enc := yaml.NewEncoder(&buf, yaml.WithSmartAnchor())
```

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

### PrintNode usage example

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/printer.md

Example of converting a map to a node and printing it. Outputs 'a: 1'.

```go
node, _ := yaml.ValueToNode(map[string]int{"a": 1})
var p printer.Printer
out := p.PrintNode(node)
fmt.Println(string(out)) // a: 1
```

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

### Using Flow EncodeOption

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/options.md

Example of marshaling with flow style enabled.

```go
out, _ := yaml.MarshalWithOptions(v, yaml.Flow(true))
```

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

### MarshalWithOptions usage example

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/yaml.md

Shows using MarshalWithOptions with Indent and UseSingleQuote options.

```go
out, err := yaml.MarshalWithOptions(v, yaml.Indent(4), yaml.UseSingleQuote(true))
```

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

### Using IndentSequence EncodeOption

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/options.md

Example of creating an encoder with IndentSequence enabled.

```go
enc := yaml.NewEncoder(&buf, yaml.IndentSequence(true))
```

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

### Using WithComment EncodeOption

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/options.md

Example of creating a CommentMap and marshaling with comments.

```go
cm := yaml.CommentMap{
	"$.a": {yaml.HeadComment("hello")},
}
out, err := yaml.MarshalWithOptions(v, yaml.WithComment(cm))
```

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

### Pipeline example (lexer → parser → AST → printer)

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/parser.md

Shows the full pipeline: tokenize, parse, navigate with a YAML path, and print a value.

```go
src := "store:\n  book:\n    - author: john\n    - author: ken\n"
tokens := lexer.Tokenize(src)
f, err := parser.Parse(tokens, 0)
if err != nil {
	log.Fatal(err)
}
// Navigate: store → book → [0] → "author"
path, _ := yaml.PathString("$.store.book[0].author")
node, err := path.FilterFile(f)
if err != nil {
	log.Fatal(yaml.IsNotFoundNodeError(err))
}
fmt.Println(node.GetValue()) // john
```

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

### Example: building tokens for ast constructors

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/token.md

Shows how to create a token with token.New and pass it to ast.String. Uses a Position with Line, Column, and Offset set to 1.

```go
tk := token.New("name", "name", &token.Position{Line: 1, Column: 1, Offset: 1})
key := ast.String(tk)
```

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

### MarshalContext usage example

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/yaml.md

Shows using MarshalContext with a timeout context and a custom marshaler.

```go
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
out, err := yaml.MarshalContext(ctx, v, yaml.CustomMarshalerContext[BigType](slowMarshal))
```

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

### ValueToNode usage example

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/yaml.md

Shows converting a map to an AST node and checking its type.

```go
node, err := yaml.ValueToNode(map[string]int{"a": 1})
if err != nil {
	log.Fatal(err)
}
fmt.Println(node.Type()) // ast.MappingType
```

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

### RegisterCustomMarshaler example

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/yaml.md

Example of registering a custom marshaler for the Epoch type, converting the struct to a string of seconds.

```go
type Epoch struct{ Sec int64 }

func init() {
	yaml.RegisterCustomMarshaler(func(e Epoch) ([]byte, error) {
		return []byte(fmt.Sprintf("%d", e.Sec)), nil
	})
}
```

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

### Basic YAML Path example

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/path.md

Parses a YAML path selecting the author of every book in the store. On error, logs fatal.

```go
path, err := yaml.PathString("$.store.book[*].author")
if err != nil {
	log.Fatal(err)
}
```

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

### MergeFromReader usage example

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/path.md

Creates a path, parses an original file, and merges a YAML string into it.

```go
path, err := yaml.PathString("$.comments")
if err != nil {
	log.Fatal(err)
}
f, _ := parser.ParseBytes(orig, 0)
src := strings.NewReader("comments: updated")
if err := path.MergeFromReader(f, src); err != nil {
	log.Fatal(err)
}
```

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

### Using UseLiteralStyleIfMultiline EncodeOption

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/options.md

Example of creating an encoder with literal style for multiline strings.

```go
enc := yaml.NewEncoder(&buf, yaml.UseLiteralStyleIfMultiline(true))
```

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

### Using MarshalAnchor EncodeOption

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/options.md

Example of creating an encoder with a MarshalAnchor callback that can rename anchors.

```go
enc := yaml.NewEncoder(&buf, yaml.MarshalAnchor(func(n *ast.AnchorNode, v interface{}) error {
	// e.g. n.Name = ast.String(token.New("renamed", "renamed", nil))
	return nil
}))
```

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

### FilterFile usage example

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/path.md

Parses YAML bytes into an AST file and filters it with the path.

```go
f, _ := parser.ParseBytes([]byte(yml), 0)
node, err := path.FilterFile(f)
```

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

### Marshal with struct tags example

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/yaml.md

Demonstrates marshaling a struct with yaml tags, showing output with lowercased field names.

```go
type Config struct {
	Host string `yaml:"host"`
	Port int    `yaml:"port"`
}
out, err := yaml.Marshal(Config{Host: "localhost", Port: 8080})
if err != nil {
	log.Fatal(err) // e.g. duplicated struct field name
}
fmt.Println(string(out))
// host: localhost
// port: 8080
```

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

### Using Indent EncodeOption

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/options.md

Example of creating an encoder with a custom indent width of 4 spaces.

```go
enc := yaml.NewEncoder(&buf, yaml.Indent(4))
```

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

### RegisterCustomUnmarshaler example with error propagation

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/yaml.md

Example of registering a custom unmarshaler that validates input and returns an error for empty input. Shows error propagation through Unmarshal.

```go
// Error propagation works through the registration:
yaml.RegisterCustomUnmarshaler(func(e *Epoch, b []byte) error {
	if len(b) == 0 {
		return errors.New("epoch cannot be empty")
	}
	n, err := strconv.ParseInt(strings.TrimSpace(string(b)), 10, 64)
	if err != nil {
		return err
	}
	e.Sec = n
	return nil
})
var e Epoch
if err := yaml.Unmarshal([]byte("epoch: abc"), &e); err != nil {
	log.Fatal(err)
}
```

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

### UnmarshalWithOptions usage

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/yaml.md

Example of using UnmarshalWithOptions with Strict and UseOrderedMap options.

```go
err := yaml.UnmarshalWithOptions(data, &v, yaml.Strict(), yaml.UseOrderedMap())
```

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

### Build a mapping node with ast.Mapping and ast.MappingValue

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/ast.md

Constructs a mapping node with a single key-value pair using the ast.String, ast.MappingValue, and ast.Mapping constructors. The example creates a mapping with key "name" and value "go-yaml".

```go
key := ast.String(token.New("name", "name", nil))
val := ast.String(token.New("go-yaml", "go-yaml", nil))
entry := ast.MappingValue(nil, key, val)
mapping := ast.Mapping(nil, false, entry)
```

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

### Read usage example

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/path.md

Parses YAML from a reader, filters with the path, and unmarshals the matched node into a slice of strings.

```go
var authors []string
if err := path.Read(strings.NewReader(yml), &authors); err != nil {
	log.Fatal(err)
}
// [john ken]
```

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

### PrintErrorToken usage example

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/printer.md

Example of parsing invalid YAML and printing the error token without color. Uses yaml.SyntaxError and PrintErrorToken.

```go
f, err := parser.ParseBytes([]byte("a: [1, 2"), 0)
if err != nil {
	se := err.(*yaml.SyntaxError) // alias of internal/errors.SyntaxError
	var p printer.Printer
	fmt.Println(p.PrintErrorToken(se.GetToken(), false))
}
```

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

### Use YAMLPath to read values from YAML

Source: https://github.com/goccy/go-yaml/blob/master/README.md

Shows how to use yaml.PathString to create a path and read matching values into a slice. The example reads all authors from a YAML document and prints them.

```go
yml := `
store:
  book:
    - author: john
      price: 10
    - author: ken
      price: 12
  bicycle:
    color: red
    price: 19.95
`
path, err := yaml.PathString("$.store.book[*].author")
if err != nil {
  //...
}
var authors []string
if err := path.Read(strings.NewReader(yml), &authors); err != nil {
  //...
}
fmt.Println(authors)
// [john ken]
```

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

### Using CustomMarshaler EncodeOption

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/options.md

Example of creating an encoder with a custom marshaler for a UUID type.

```go
enc := yaml.NewEncoder(&buf, yaml.CustomMarshaler(func(t UUID) ([]byte, error) {
	return []byte(t.String()), nil
}))
```

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

### SequenceEntry

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/ast.md

Constructs a new SequenceEntryNode with the given start token, value, and head comment.

```APIDOC
## SequenceEntry

### Description
Constructs a new SequenceEntryNode with the given start token, value, and head comment.

### Function
SequenceEntry(start *token.Token, value Node, headComment *CommentGroupNode) *SequenceEntryNode

### Parameters
- **start** (*token.Token) - The start token.
- **value** (Node) - The value node.
- **headComment** (*CommentGroupNode) - The head comment group.

### Returns
- ***SequenceEntryNode** - The constructed sequence entry node.

### Source
`ast/ast.go:1754`
```

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

### ReplaceWithNode usage example

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/path.md

Parses an original file, converts a new value to a node, and replaces the matched path with it.

```go
f, _ := parser.ParseBytes(orig, 0)
newNode, _ := yaml.ValueToNode(newValue)
if err := path.ReplaceWithNode(f, newNode); err != nil {
	log.Fatal(err)
}
out, _ := yaml.Marshal(f) // or printer.PrintNode on the file body
```

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

### Using CommentMap with MarshalWithOptions

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/options.md

Example of creating a CommentMap and passing it to MarshalWithOptions via WithComment to add comments to YAML output.

```go
cm := yaml.CommentMap{
	"$.server": {yaml.HeadComment("main server block"), yaml.FootComment("end of server")},
	"$.server.port": {yaml.LineComment("listen port")},
}
out, err := yaml.MarshalWithOptions(cfg, yaml.WithComment(cm))
```

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

### Handle option application error

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/decoder.md

Options that fail during application are surfaced only at first decode. This example shows how to catch such errors when calling Decode.

```go
// Options that fail during application are surfaced only at first decode.
dec := yaml.NewDecoder(strings.NewReader("a: 1"), yaml.WithComment(nil))
var v map[string]int
if err := dec.Decode(&v); err != nil {
	log.Fatal(err) // error from applying the option
}
```

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

### AnnotateSource usage example

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/path.md

Annotates the source YAML and prints an error-style message pointing to the matched value.

```go
source, err := path.AnnotateSource([]byte(yml), true)
if err != nil {
	log.Fatal(err)
}
fmt.Printf("a value expected 2 but actual %d:\n%s\n", v.A, string(source))
```

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

### Show testdata directory structure with anchor.yml

Source: https://github.com/goccy/go-yaml/blob/master/README.md

Displays the directory tree of the testdata folder containing anchor.yml, which is referenced in the following example.

```shell
├── testdata
   └── anchor.yml
```

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

### Catch and inspect go-yaml errors with errors.As and errors.Is

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/errors.md

Shows how to catch errors from yaml.Unmarshal and inspect them using errors.As for typed errors (*yaml.TypeError, yaml.Error) and errors.Is with sentinel errors and exported predicates. The example includes a duplicate key error and demonstrates accessing error details like message, token position, and destination/source types.

```go
import (
	"errors"
	"github.com/goccy/go-yaml"
)

var v struct{ A int `yaml:"a"` }
err := yaml.Unmarshal([]byte("a: x"), &v)
if err == nil {
	log.Fatal("expected error")
}

// 1) Typed errors: type-assert / errors.As
var te *yaml.TypeError
if errors.As(err, &te) {
	fmt.Println(te.GetMessage())            // "cannot unmarshal string into Go value of type int"
	fmt.Println(te.GetToken().Position.Line) // line of the offending token
	fmt.Println(te.DstType, te.SrcType)      // int, string
}

// 2) All typed YAML errors satisfy yaml.Error and render with source:
var ye yaml.Error
if errors.As(err, &ye) {
	_ = ye.FormatError(true, true)
}

// 3) Sentinel errors via the exported predicates or errors.Is:
if errors.Is(err, yaml.ErrDecodeRequiredPointerType) { ... }
if yaml.IsInvalidPathStringError(err) { ... }
if yaml.IsNotFoundNodeError(err) { ... }
```

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

### EncodeToNodeContext usage example

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/encoder.md

Encodes a value to an AST node and type-asserts it to a *ast.MappingNode.

```go
node, err := enc.EncodeToNodeContext(ctx, &T{C: 1})
mapping, ok := node.(*ast.MappingNode)
```

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

### Filter usage example

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/path.md

Filters an in-memory Go value (map) and extracts the matched authors into a slice.

```go
store := map[string][]Book{...}
var authors []string
if err := path.Filter(store, &authors); err != nil {
	log.Fatal(err)
}
```

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

### Format go-yaml errors with yaml.FormatError

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/errors.md

Shows how to format a go-yaml error using yaml.FormatError with colored output and source inclusion, compared against the raw error string. The example uses a duplicate key error from unmarshalling 'a: 1\na: 2\n'.

```go
// Custom formatting compared against the raw error string.
err := yaml.Unmarshal([]byte("a: 1\na: 2\n"), &m) // duplicate key
if err != nil {
	fmt.Println(err.Error())                              // includes position + source
	fmt.Println(yaml.FormatError(err, true /*colored*/, false /*no source*/))
}
```

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

### Unmarshal basic usage with error handling

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/yaml.md

Example of unmarshaling YAML into a struct, handling *yaml.TypeError with errors.As and printing the message.

```go
var cfg Config
if err := yaml.Unmarshal([]byte("host: localhost\nport: 8080"), &cfg); err != nil {
	var te *yaml.TypeError
	if errors.As(err, &te) {
		fmt.Println(te.GetMessage())
	}
	log.Fatal(err)
}
```

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

### PrintTokens usage with line numbers

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/printer.md

Example of using PrintTokens with LineNumber enabled. Outputs lines prefixed with line numbers.

```go
p := printer.Printer{LineNumber: true}
out := p.PrintTokens(lexer.Tokenize("a: 1\nb: 2"))
fmt.Println(out)
//  1 | a: 1
//  2 | b: 2
```

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

### Implementing BytesMarshaler and BytesUnmarshaler for a custom type

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/yaml.md

Example of a custom type Money that implements both BytesMarshaler and BytesUnmarshaler. MarshalYAML formats the value as a string with 'USD', and UnmarshalYAML parses that string back into the integer value.

```go
type Money int64

func (m Money) MarshalYAML() ([]byte, error) {
	return []byte(fmt.Sprintf("%d USD", int64(m))), nil
}

func (m *Money) UnmarshalYAML(b []byte) error {
	var s string
	if err := yaml.Unmarshal(b, &s); err != nil {
		return err
	}
	v, err := strconv.Atoi(strings.TrimSuffix(s, " USD"))
	if err != nil {
		return err
	}
	*m = Money(v)
	return nil
}
```

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

### Print customized error with YAML source code

Source: https://github.com/goccy/go-yaml/blob/master/README.md

Demonstrates using yaml.PathString and AnnotateSource to output an error message that includes the YAML source with the error location annotated. The example checks a value and prints a custom error if it does not match.

```go
package main

import (
  "fmt"

  "github.com/goccy/go-yaml"
)

func main() {
  yml := `
a: 1
b: "hello"
`
  var v struct {
    A int
    B string
  }
  if err := yaml.Unmarshal([]byte(yml), &v); err != nil {
    panic(err)
  }
  if v.A != 2 {
    // output error with YAML source
    path, err := yaml.PathString("$.a")
    if err != nil {
      panic(err)
    }
    source, err := path.AnnotateSource([]byte(yml), true)
    if err != nil {
      panic(err)
    }
    fmt.Printf("a value expected 2 but actual %d:\n%s\n", v.A, string(source))
  }
}
```

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

### Build a path with PathBuilder and print it

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/path.md

Builds the path $.store[*].author and prints it. Demonstrates chaining Root, Child, IndexAll, and Build.

```go
p := (&yaml.PathBuilder{}).Root().Child("store").IndexAll().Child("author").Build()
fmt.Println(p.String()) // $.store[*].author
```

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

### Unmarshal YAML into a struct with yaml.Unmarshal

Source: https://github.com/goccy/go-yaml/blob/master/README.md

Shows how to decode a YAML document into a Go struct using yaml.Unmarshal. The YAML input includes a version directive and a document start marker.

```go
	yml := `
%YAML 1.2
---
a: 1
b: c
`
var v struct {
	A int
	B string
}
if err := yaml.Unmarshal([]byte(yml), &v); err != nil {
	//...
}
```

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

### FormatError usage example

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/yaml.md

Example of using FormatError to print a colorized error with source excerpt after a failed Unmarshal.

```go
err := yaml.Unmarshal([]byte("a: [1, 2"), &v)
fmt.Println(yaml.FormatError(err, true, true)) // colorized, with source excerpt
```

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

### Init method signature

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/scanner.md

Resets the scanner state with the given YAML source text. Must be called before Scan.

```go
func (s *Scanner) Init(text string)
```

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

### AllowFieldPrefixes

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/options.md

When combined with DisallowUnknownField, keys starting with any listed prefix bypass the unknown-field check.

```APIDOC
## AllowFieldPrefixes

### Description
When combined with DisallowUnknownField, keys starting with any listed prefix bypass the unknown-field check.

### Function Signature
func AllowFieldPrefixes(prefixes ...string) DecodeOption

### Parameters
- **prefixes** (string) - Variadic - Prefixes that allow unknown fields to be accepted.

### Example
```go
dec := yaml.NewDecoder(r, yaml.Strict(), yaml.AllowFieldPrefixes("x-"))
```
```

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

### Basic scanning loop

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/scanner.md

Initializes a scanner with a YAML string and iterates over tokens until io.EOF, accumulating them. Prints the total token count.

```go
var s scanner.Scanner
s.Init("a: 1\nb:\n  - x\n  - y\n")
var all token.Tokens
for {
	tks, err := s.Scan()
	if err == io.EOF {
		break
	}
	if err != nil {
		log.Fatal(err)
	}
	all.Add(tks...)
}
fmt.Println(len(all)) // number of tokens
```

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

### NodeToValue usage with PathString

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/yaml.md

Example of decoding a filtered AST node into a variable using NodeToValue.

```go
f, _ := parser.ParseBytes([]byte("a: 1\nb: 2"), 0)
node, _ := yaml.PathString("$.a")
scalar, _ := node.FilterFile(f)
var a int
if err := yaml.NodeToValue(scalar, &a); err != nil {
	log.Fatal(err)
}
```

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

### Property prefix using a public ColorAttribute

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/printer.md

Shows how to construct a property prefix using a public ColorAttribute constant, producing an ANSI escape sequence.

```go
// property prefix using a public ColorAttribute
prefix := fmt.Sprintf("\x1b[%dm", 90+int(printer.ColorFgHiRed))
```

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

### Create decoder with options

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/decoder.md

Creates a decoder with ReferenceDirs and Strict options. The decoder reads from a string reader containing YAML.

```go
dec := yaml.NewDecoder(strings.NewReader(yml), yaml.ReferenceDirs("./conf"), yaml.Strict())
```

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

### Comment constructors: LineComment, HeadComment, FootComment

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/options.md

Constructors for creating comments: LineComment for one-line, HeadComment and FootComment for multiline comments.

```go
// LineComment create a one-line comment for CommentMap.
func LineComment(text string) *Comment
// HeadComment create a multiline comment for CommentMap.
func HeadComment(texts ...string) *Comment
// FootComment create a multiline comment for CommentMap.
func FootComment(texts ...string) *Comment
```

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

### ReferenceFiles option usage

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/options.md

Creates a decoder with the ReferenceFiles option, which opens the given files and registers their anchor definitions.

```go
dec := yaml.NewDecoder(r, yaml.ReferenceFiles("shared/anchor.yml"))
```

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

### DecodeContext with time.Time

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/decoder.md

Example of using DecodeContext to decode a YAML timestamp into a time.Time field. The context is passed as context.Background().

```go
dec := yaml.NewDecoder(strings.NewReader("t: 2024-01-02T03:04:05Z"))
var v struct{ T time.Time `yaml:"t"` }
if err := dec.DecodeContext(context.Background(), &v); err != nil {
	log.Fatal(err)
}
```

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

### Basic Tokenize and Parse usage

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/lexer.md

Shows how to tokenize a YAML string and parse it with parser.Parse. The parser returns an error if the token stream contains invalid tokens.

```go
tokens := lexer.Tokenize("a: 1\nb: [true, null]\n")
f, err := parser.Parse(tokens, 0)
if err != nil {
	log.Fatal(err)
}
```

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

### Parse with lexer.Tokenize

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/parser.md

Tokenizes source with lexer.Tokenize and passes the tokens to parser.Parse.

```go
tokens := lexer.Tokenize(src)
f, err := parser.Parse(tokens, 0)
```

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

### PrintTokens usage for syntax highlighting

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/lexer.md

Shows how to use the token stream with printer.Printer.PrintTokens, enabling line numbers for syntax highlighting, as used by the ycat CLI tool.

```go
tokens := lexer.Tokenize(string(data))
var p printer.Printer
p.LineNumber = true
fmt.Println(p.PrintTokens(tokens))
```

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

### FilterFile and FilterNode method signatures

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/path.md

FilterFile filters from an ast.File by YAMLPath; FilterNode filters from an ast.Node by YAMLPath.

```go
// FilterFile filter from ast.File by YAMLPath.
func (p *Path) FilterFile(f *ast.File) (ast.Node, error)

// FilterNode filter from node by YAMLPath.
func (p *Path) FilterNode(node ast.Node) (ast.Node, error)
```

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

### Decode with non-pointer returns ErrDecodeRequiredPointerType

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/decoder.md

Example showing that passing a non-pointer to Decode returns ErrDecodeRequiredPointerType. The error is checked with errors.Is.

```go
dec := yaml.NewDecoder(strings.NewReader("a: 1"))
var v map[string]int
if err := dec.Decode("not-a-pointer"); err != nil {
	fmt.Println(errors.Is(err, yaml.ErrDecodeRequiredPointerType)) // true
}
```

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

### CommentPosition

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/options.md

Enum representing the position of a comment (head, line, or foot). Provides a String() method to get the textual representation.

```APIDOC
## CommentPosition

### Description
Type of the position for a comment. Constants: CommentHeadPosition, CommentLinePosition, CommentFootPosition.

### Type
`type CommentPosition int`

### Constants
- `CommentHeadPosition` - Head position
- `CommentLinePosition` - Line position
- `CommentFootPosition` - Foot position

### Methods
#### String()
Returns the string representation: "Head", "Line", "Foot", or "" for unknown values.

### Source
`option.go:273`–`option.go:281`
```

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

### MarshalWithOptions function signature

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/yaml.md

Same as Marshal but accepts EncodeOptions like Indent, Flow, JSON, UseSingleQuote, OmitEmpty.

```go
func MarshalWithOptions(v interface{}, opts ...EncodeOption) ([]byte, error)
```

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

### DecodeOption: ReferenceFiles

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/configuration.md

Opens the specified files and registers their anchors for use in the main stream.

```APIDOC
## DecodeOption: ReferenceFiles

### Description
Opens the specified files and registers their anchors for use in the main stream.

### Signature
`func ReferenceFiles(files ...string) DecodeOption`

### Parameters
- **files** (string) - Required - Paths to files containing anchor definitions.

### Usage Example
```go
import "github.com/goccy/go-yaml"

dec := yaml.NewDecoder(reader, yaml.ReferenceFiles("anchors.yaml"))
```
```

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

### DecodeFromNodeContext with parsed node

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/decoder.md

Example of using DecodeFromNodeContext to decode a parsed AST node. The decoder's reader is unused for nodes, and the node is parsed from a separate byte slice.

```go
f, err := parser.ParseBytes([]byte("x: 1"), 0)
if err != nil {
	log.Fatal(err)
}
dec := yaml.NewDecoder(strings.NewReader("ignored: 0")) // reader unused for nodes
var v struct{ X int `yaml:"x"` }
if err := dec.DecodeFromNodeContext(context.Background(), f.Docs[0].Body, &v); err != nil {
	log.Fatal(err)
}
fmt.Println(v.X) // 1
```

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

### ReferenceFiles

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/options.md

Opens the given files and registers their anchor definitions for use in the main stream.

```APIDOC
## ReferenceFiles

### Description
Opens the given files (os.Open) and registers their anchor definitions.

### Function Signature
func ReferenceFiles(files ...string) DecodeOption

### Parameters
- **files** (string) - Variadic - Paths to files containing anchor definitions.

### Example
```go
dec := yaml.NewDecoder(r, yaml.ReferenceFiles("shared/anchor.yml"))
```
```

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

### Using MapSlice with UseOrderedMap and ToMap

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/yaml.md

Shows how to unmarshal YAML into a MapSlice using UseOrderedMap, preserving insertion order, and then convert to a plain map with ToMap.

```go
var v yaml.MapSlice
if err := yaml.Unmarshal([]byte("b: 2\na: 1"), &v, yaml.UseOrderedMap()); err != nil {
	log.Fatal(err)
}
fmt.Println(v[0].Key) // "b" -- insertion order preserved
m := v.ToMap()
```

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

### Decode multiple documents until io.EOF

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/decoder.md

Example of using Decode in a loop to read multiple YAML documents separated by '---'. The loop breaks when io.EOF is returned, and prints the value of 'a' for each document.

```go
ymls := "---\na: 1\n---\na: 2\n"
dec := yaml.NewDecoder(strings.NewReader(ymls))
for {
	var v struct{ A int `yaml:"a"` }
	err := dec.Decode(&v)
	if errors.Is(err, io.EOF) {
		break
	}
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(v.A) // 1, then 2
}
```

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

### Use merge key and alias with inline,alias tag

Source: https://github.com/goccy/go-yaml/blob/master/README.md

Demonstrates using merge key (<<: *alias) by embedding a structure with the `inline,alias` tag. The embedded Person pointer provides default values that can be overridden. The output shows the default anchor and people entries using merge keys.

```go
type Person struct {
	*Person `yaml:",omitempty,inline,alias"` // embed Person type for default value
	Name    string `yaml:",omitempty"`
	Age     int    `yaml:",omitempty"`
}
defaultPerson := &Person{
	Name: "John Smith",
	Age:  20,
}
people := []*Person{
	{
		Person: defaultPerson, // assign default value
		Name:   "Ken",         // override Name property
		Age:    10,            // override Age property
	},
	{
		Person: defaultPerson, // assign default value only
	},
}
var doc struct {
	Default *Person   `yaml:"default,anchor"`
	People  []*Person `yaml:"people"`
}
doc.Default = defaultPerson
doc.People = people
bytes, err := yaml.Marshal(doc)
if err != nil {
	//...
}
fmt.Println(string(bytes))
/*
default: &default
  name: John Smith
  age: 20
people:
- <<: *default
  name: Ken
  age: 10
- <<: *default
*/
```

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

### ParseFile usage

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/parser.md

Parses a YAML file and prints the file name set on the AST.

```go
f, err := parser.ParseFile("config.yaml", 0)
if err != nil {
	log.Fatal(err)
}
fmt.Println(f.Name) // config.yaml
```

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

### Scanner.Init

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/scanner.md

Initializes the scanner with the YAML source text, resetting all internal state. Must be called before Scan.

```APIDOC
## Scanner.Init

### Description
Initializes the scanner with the YAML source text, resetting all internal state. Must be called before Scan.

### Method
Init

### Signature
func (s *Scanner) Init(text string)

### Parameters
- **text** (string) - Required - YAML source

### Source
scanner/scanner.go:1497

### Example
```go
var s scanner.Scanner
s.Init("a: 1\nb:\n  - x\n  - y\n")
```
```

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

### String

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/ast.md

Creates a string node from a token.

```APIDOC
## String

### Description
Creates a string node from a token.

### Signature
`func String(tk *token.Token) *StringNode`

### Parameters
- `tk` (*token.Token) - Required - The token to create the node from.

### Returns
- `*StringNode` - The created string node.
```

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

### Visitor and Walk

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/ast.md

Defines the Visitor interface and the Walk function for traversing the AST in depth-first order.

```APIDOC
## Visitor and Walk

### Description
Defines the Visitor interface and the Walk function for traversing the AST in depth-first order.

### Interface
```go
type Visitor interface {
	Visit(Node) Visitor
}
```

### Function
```go
func Walk(v Visitor, node Node)
```

### Behavior
`Walk` traverses an AST in depth-first order: It starts by calling `v.Visit(node)`; node must not be nil. If the visitor returned by `v.Visit(node)` is non-nil, children are visited with that visitor, ending with `w.Visit(nil)`.

### Source
`ast/ast.go:2153` and `ast/ast.go:2158`
```

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

### Merge family method signatures

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/path.md

MergeFromReader, MergeFromFile, and MergeFromNode merge YAML content into an ast.File.

```go
// MergeFromReader merge YAML text into ast.File.
func (p *Path) MergeFromReader(dst *ast.File, src io.Reader) error
// MergeFromFile merge ast.File into ast.File.
func (p *Path) MergeFromFile(dst *ast.File, src *ast.File) error
// MergeFromNode merge ast.Node into ast.File.
func (p *Path) MergeFromNode(dst *ast.File, src ast.Node) error
```

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

### Marshal a struct to YAML with yaml.Marshal

Source: https://github.com/goccy/go-yaml/blob/master/README.md

Shows how to encode a Go struct into YAML bytes using yaml.Marshal. The output is printed as 'a: 1\nb: hello\n'.

```go
var v struct {
	A int
	B string
}
v.A = 1
v.B = "hello"
bytes, err := yaml.Marshal(v)
if err != nil {
	//...
}
fmt.Println(string(bytes)) // "a: 1\nb: hello\n"
```

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

### MarshalWithOptions

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/yaml.md

Same as Marshal but accepts EncodeOptions such as Indent, Flow, JSON, UseSingleQuote, and OmitEmpty to customize the output.

```APIDOC
## MarshalWithOptions

### Description
Serializes a value to YAML with additional encoding options. This is the underlying implementation that `Marshal` delegates to.

### Method
MarshalWithOptions

### Signature
`func MarshalWithOptions(v interface{}, opts ...EncodeOption) ([]byte, error)`

### Parameters
#### Arguments
- **v** (interface{}) - Required - The value to serialize.
- **opts** (EncodeOption) - Optional - Encoding options (e.g., Indent, Flow, JSON, UseSingleQuote, OmitEmpty).

### Returns
- **[]byte** - The YAML document.
- **error** - An error if serialization fails.

### Example
```go
out, err := yaml.MarshalWithOptions(v, yaml.Indent(4), yaml.UseSingleQuote(true))
```
```

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

### RecursiveDir option usage

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/options.md

Creates a decoder with the ReferenceDirs and RecursiveDir options, enabling recursive directory walking.

```go
dec := yaml.NewDecoder(r, yaml.ReferenceDirs("conf"), yaml.RecursiveDir(true))
```

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

### Replace family method signatures

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/path.md

ReplaceWithReader, ReplaceWithFile, and ReplaceWithNode replace an ast.File with content from a reader, file, or node.

```go
// ReplaceWithReader replace ast.File with io.Reader.
func (p *Path) ReplaceWithReader(dst *ast.File, src io.Reader) error
// ReplaceWithFile replace ast.File with ast.File.
func (p *Path) ReplaceWithFile(dst *ast.File, src *ast.File) error
// ReplaceNode replace ast.File with ast.Node.
func (p *Path) ReplaceWithNode(dst *ast.File, node ast.Node) error
```

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

### Visitor interface and Walk function

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/ast.md

Defines the Visitor interface and the Walk function that traverses an AST in depth-first order, mirroring go/ast.Walk semantics. Source: ast/ast.go:2153 and ast/ast.go:2158.

```go
type Visitor interface {
	Visit(Node) Visitor
}

// Walk traverses an AST in depth-first order: It starts by calling v.Visit(node); node must not be nil.
func Walk(v Visitor, node Node)
```

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

### MarshalContext function signature

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/yaml.md

Same as MarshalWithOptions but with a context.Context for context-aware marshaler hooks.

```go
func MarshalContext(ctx context.Context, v interface{}, opts ...EncodeOption) ([]byte, error)
```

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

### NewEncoder with buffer and options

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/encoder.md

Creates an encoder writing to a bytes.Buffer with Indent(4) and Flow(false) options.

```go
var buf bytes.Buffer
enc := yaml.NewEncoder(&buf, yaml.Indent(4), yaml.Flow(false))
```

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

### ReferenceDirs

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/options.md

Globs dir/* and registers anchors from every *.yml/*.yaml file found (non-recursive unless RecursiveDir(true) is used).

```APIDOC
## ReferenceDirs

### Description
Globs dir/* and registers anchors from every *.yml/*.yaml file found (non-recursive unless RecursiveDir(true) is used).

### Function Signature
func ReferenceDirs(dirs ...string) DecodeOption

### Parameters
- **dirs** (string) - Variadic - Directories to scan for anchor files.

### Example
```go
dec := yaml.NewDecoder(r, yaml.ReferenceDirs("testdata"))
```
```

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

### Marshal with flow and omitempty options

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/yaml.md

Shows marshaling a map with the flow option, producing inline YAML.

```go
type Custom struct {
	V interface{} `yaml:"v,omitempty,flow"`
}
out, err := yaml.Marshal(Custom{V: map[string]int{"a": 1}})
// v: {a: 1}
```

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

### DecodeOption: ReferenceDirs

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/configuration.md

Globs the specified directories and registers anchors from all *.yml and *.yaml files found.

```APIDOC
## DecodeOption: ReferenceDirs

### Description
Globs the specified directories and registers anchors from all *.yml and *.yaml files found.

### Signature
`func ReferenceDirs(dirs ...string) DecodeOption`

### Parameters
- **dirs** (string) - Required - Directories to search for anchor files.

### Usage Example
```go
import "github.com/goccy/go-yaml"

dec := yaml.NewDecoder(reader, yaml.ReferenceDirs("./config"))
```
```

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

### ReferenceDirs option usage

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/options.md

Creates a decoder with the ReferenceDirs option, which globs the directory and registers anchors from every *.yml/*.yaml file found.

```go
dec := yaml.NewDecoder(r, yaml.ReferenceDirs("testdata"))
```

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

### Parent, Filter, and FilterFile functions

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/ast.md

Declarations for Parent, Filter, and FilterFile utility functions. Source: ast/ast.go:2321, ast/ast.go:2327, ast/ast.go:2334.

```go
// Parent get parent node from child node.
func Parent(root, child Node) Node
// Filter returns a list of nodes that match the given type.
func Filter(typ NodeType, node Node) []Node
// FilterFile returns a list of nodes that match the given type.
func FilterFile(typ NodeType, file *File) []Node
```

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

### Strict option usage and error

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/options.md

Uses the Strict option to reject unknown struct keys, showing the resulting UnknownFieldError.

```go
err := yaml.Unmarshal(data, &v, yaml.Strict())
// *yaml.UnknownFieldError: unknown field "extra"
```

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

### EncodeToNodeContext method signature

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/encoder.md

Converts v to an ast.Node with context.Context. Applies all stored options first; an option error aborts. If UseSmartAnchor is set, a first pass records pointer-to-anchor mappings.

```go
// EncodeToNodeContext convert v to ast.Node with context.Context.
func (e *Encoder) EncodeToNodeContext(ctx context.Context, v interface{}) (ast.Node, error)
```

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

### PathBuilder.IndexAll

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/path.md

Adds the wildcard index selector '[*]' to the path.

```APIDOC
## PathBuilder.IndexAll

### Description
Adds the wildcard index selector `[*]` to the path.

### Method
IndexAll

### Signature
`func (b *PathBuilder) IndexAll() *PathBuilder`

### Parameters
None.

### Returns
- `*PathBuilder` - The receiver for chaining.

### Example
```go
p := (&yaml.PathBuilder{}).Root().Child("store").IndexAll().Child("author").Build()
fmt.Println(p.String()) // $.store[*].author
```
```

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

### Node, MapKeyNode, ScalarNode interface definitions

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/ast.md

Defines the core AST interfaces. Node includes io.Reader and methods for token access, comments, and YAML path. MapKeyNode adds IsMergeKey and stringWithoutComment. ScalarNode adds GetValue. Note: readLen/addReadLen/clearLen and stringWithoutComment are unexported; consumers implement Node with documented methods or use concrete node types.

```go
type Node interface {
	io.Reader
	String() string
	GetToken() *token.Token
	Type() NodeType
	AddColumn(int)
	SetComment(*CommentGroupNode) error
	GetComment() *CommentGroupNode
	GetPath() string
	SetPath(string)
	MarshalYAML() ([]byte, error)
	readLen() int
	addReadLen(int)
	clearLen()
}

// MapKeyNode type for map key node
type MapKeyNode interface {
	Node
	IsMergeKey() bool
	stringWithoutComment() string
}

// ScalarNode type for scalar node
type ScalarNode interface {
	MapKeyNode
	GetValue() interface{}
}
```

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

### ParseFile

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/parser.md

Reads a YAML file from disk and parses it, returning an *ast.File with the filename set. Propagates OS read errors.

```APIDOC
## ParseFile

### Description
Reads a YAML file from disk and parses it, returning an *ast.File with the filename set. Propagates OS read errors.

### Signature
func ParseFile(filename string, mode Mode, opts ...Option) (*ast.File, error)

### Parameters
- **filename** (string) - Required - Path to a YAML file
- **mode** (Mode) - Required - 0 or ParseComments
- **opts** (...Option) - Optional - Parser options

### Example
```go
f, err := parser.ParseFile("config.yaml", 0)
if err != nil {
	log.Fatal(err)
}
fmt.Println(f.Name) // config.yaml
```
```

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

### Directive

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/ast.md

Creates a directive node from a token.

```APIDOC
## Directive

### Description
Creates a directive node from a token.

### Signature
`func Directive(tk *token.Token) *DirectiveNode`

### Parameters
- `tk` (*token.Token) - Required - The token to create the node from.

### Returns
- `*DirectiveNode` - The created directive node.
```

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

### Tokens.Dump()

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/token.md

Prints all tokens for debugging purposes.

```APIDOC
## Tokens.Dump()

### Description
Prints all tokens for debugging purposes.

### Method
Dump

### Signature
func (t Tokens) Dump()

```

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

### AllowDuplicateMapKey option usage

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/options.md

Uses the AllowDuplicateMapKey option to allow duplicate map keys, avoiding the duplicate-key syntax error.

```go
var m map[string]int
err := yaml.Unmarshal([]byte("a: 1\na: 2\n"), &m, yaml.AllowDuplicateMapKey()) // ok
```

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

### CommentPosition, Comment, and CommentMap definitions

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/types.md

Defines CommentPosition constants (Head, Line, Foot), the Comment struct with Texts and Position, and CommentMap. Constructors LineComment, HeadComment, and FootComment create comments. Consumed by WithComment (encode) and filled by CommentToMap (decode).

```go
type CommentPosition int
const (
	CommentHeadPosition CommentPosition = CommentPosition(iota)
	CommentLinePosition
	CommentFootPosition
)
func (p CommentPosition) String() string

type Comment struct {
	Texts    []string
	Position CommentPosition
}
type CommentMap map[string][]*Comment

```

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

### Document

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/ast.md

Creates a document node from a token and a body node.

```APIDOC
## Document

### Description
Creates a document node from a token and a body node.

### Signature
`func Document(tk *token.Token, body Node) *DocumentNode`

### Parameters
- `tk` (*token.Token) - Required - The token to create the node from.
- `body` (Node) - Required - The body node.

### Returns
- `*DocumentNode` - The created document node.
```

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

### AllowFieldPrefixes option usage

Source: https://github.com/goccy/go-yaml/blob/master/_autodocs/api-reference/options.md

Creates a decoder with Strict and AllowFieldPrefixes, allowing keys with the given prefix to bypass the unknown-field check.

```go
dec := yaml.NewDecoder(r, yaml.Strict(), yaml.AllowFieldPrefixes("x-"))
```
Tokens:
Raw