Preserve original formatting in Unmarshaler by using raw byte ranges

Instead of reconstructing key-value lines from parsed components, now uses the original raw bytes from the document. This preserves: - Whitespace around '=' (e.g., "key = value") - String quoting style (basic vs literal) - Number formats (hex, octal, binary) - Inline table formatting Changes: - Add Raw range tracking to KeyValue expressions in parseKeyval - Update handleKeyValuesUnmarshaler to use expr.Raw directly - Remove keyNeedsQuoting helper (no longer needed) - Add TestIssue873_FormattingPreservation test - Update expected output in ExampleParser_comments
Add Example tests and fix raw value extraction for boolean types
2026-01-26 21:30:16 +00:00 · 2026-01-26 21:30:15 +00:00 · 2026-01-26 21:30:15 +00:00 · 2026-01-26 21:30:15 +00:00 · 2026-01-26 21:30:15 +00:00 · 2026-01-26 21:30:14 +00:00
102 changed files with 19863 additions and 6097 deletions
@@ -0,0 +1,4 @@
 * text=auto
 benchmark/benchmark.toml text eol=lf
 testdata/** text eol=lf
@@ -1,5 +1,19 @@
-**Issue:** add link to pelletier/go-toml issue here
+<!--
 Thank you for your pull request!
 Please read the Code changes section of the CONTRIBUTING.md file,
 and make sure you have followed the instructions.
 https://github.com/pelletier/go-toml/blob/v2/CONTRIBUTING.md#code-changes
 -->
 Explanation of what this pull request does.
-More detailed description of the decisions being made and the reasons why (if the patch is non-trivial).
+More detailed description of the decisions being made and the reasons why (if
 the patch is non-trivial).
 ---
 Paste `benchstat` results here
@@ -1,6 +1,17 @@
 version: 2
 updates:
-  - package-ecosystem: "gomod"
+- package-ecosystem: gomod
-    directory: "/" # Location of package manifests
+  directory: /
-    schedule:
+  schedule:
-      interval: "daily"
+    interval: daily
  open-pull-requests-limit: 10
 - package-ecosystem: github-actions
  directory: /
  schedule:
    interval: daily
  open-pull-requests-limit: 10
 - package-ecosystem: docker
  directory: /
  schedule:
    interval: daily
  open-pull-requests-limit: 10
@@ -0,0 +1,21 @@
 changelog:
  exclude:
    labels:
      - build
      - testing
  categories:
    - title: What's new
      labels:
        - feature
    - title: Performance
      labels:
        - performance
    - title: Fixed bugs
      labels:
        - bug
    - title: Documentation
      labels:
        - doc
    - title: Other changes
      labels:
        - "*"
@@ -0,0 +1,26 @@
 name: CIFuzz
 on: [pull_request]
 jobs:
  Fuzzing:
    runs-on: ubuntu-latest
    steps:
    - name: Build Fuzzers
      id: build
      uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master
      with:
        oss-fuzz-project-name: 'go-toml'
        dry-run: false
        language: go
    - name: Run Fuzzers
      uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master
      with:
        oss-fuzz-project-name: 'go-toml'
        fuzz-seconds: 300
        dry-run: false
        language: go
    - name: Upload Crash
      uses: actions/upload-artifact@v6
      if: failure() && steps.build.outcome == 'success'
      with:
        name: artifacts
        path: ./out/artifacts
@@ -35,11 +35,11 @@ jobs:
    steps:
    - name: Checkout repository
-      uses: actions/checkout@v2
+      uses: actions/checkout@v6
    # Initializes the CodeQL tools for scanning.
    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v1
+      uses: github/codeql-action/init@v4
      with:
        languages: ${{ matrix.language }}
        # If you wish to specify custom queries, you can do so here or in a config file.
@@ -47,10 +47,10 @@ jobs:
        # Prefix the list here with "+" to use these queries and those in the config file.
        # queries: ./path/to/local/query, your-org/your-repo/queries@main
-    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # Autobuild attempts to build any compiled languages (C/C++, C#, or Java).
    # If this step fails, then you should remove it and run the build manually (see below)
    - name: Autobuild
-      uses: github/codeql-action/autobuild@v1
+      uses: github/codeql-action/autobuild@v4
    # ℹ️ Command-line programs to run using the OS shell.
    # 📚 https://git.io/JvXDl
@@ -64,4 +64,4 @@ jobs:
    #   make release
    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v1
+      uses: github/codeql-action/analyze@v4
@@ -0,0 +1,20 @@
 name: coverage
 on:
  pull_request:
    branches:
      - v2
 jobs:
  report:
    runs-on: "ubuntu-latest"
    name: report
    steps:
      - uses: actions/checkout@v6
        with:
          fetch-depth: 0
      - name: Setup go
        uses: actions/setup-go@v6
        with:
          go-version: "1.25"
      - name: Run tests with coverage
        run: ./ci.sh coverage -d "${GITHUB_BASE_REF-HEAD}"
@@ -0,0 +1,36 @@
 name: Go Versions Compatibility Test
 on:
  workflow_dispatch:
    inputs:
      go_versions:
        description: 'Go versions to test (space-separated, e.g., "1.21 1.22 1.23")'
        required: false
        default: ''
        type: string
 jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v6
        with:
          fetch-depth: 0
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3
      - name: Run Go versions compatibility test
        run: |
          VERSIONS="${{ github.event.inputs.go_versions }}"
          ./test-go-versions.sh --output ./test-results $VERSIONS
      - name: Upload test results
        uses: actions/upload-artifact@v6
        with:
          name: go-versions-test-results
          path: |
            test-results/
          retention-days: 30
@@ -0,0 +1,22 @@
 name: lint
 on:
  pull_request:
    branches:
      - v2
 jobs:
  golangci:
    name: lint
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v6
        with:
          fetch-depth: 0
      - name: Setup go
        uses: actions/setup-go@v6
        with:
          go-version: "1.24"
      - name: Run golangci-lint
        uses: golangci/golangci-lint-action@v9
        with:
          version: v2.8.0
@@ -0,0 +1,39 @@
 name: release
 on:
  push:
    tags:
      - "v2.*"
  workflow_call:
    inputs:
      args:
        description: "Extra arguments to pass goreleaser"
        default: ""
        required: false
        type: string
 jobs:
  release:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v6
        with:
          fetch-depth: 0
      - name: Set up Go
        uses: actions/setup-go@v6
        with:
          go-version: "1.25"
      - name: Login to GitHub Container Registry
        uses: docker/login-action@v3
        with:
          registry: ghcr.io
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}
      - name: Run GoReleaser
        uses: goreleaser/goreleaser-action@v6
        with:
          distribution: goreleaser
          version: '~> v2'
          args: release ${{ inputs.args }} --clean
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -11,18 +11,22 @@ jobs:
  build:
    strategy:
      matrix:
-        os: [ 'ubuntu-latest', 'windows-latest', 'macos-latest']
+        os: [ 'ubuntu-latest', 'windows-latest', 'macos-latest', 'macos-14' ]
-        go: [ '1.15', '1.16' ]
+        go: [ '1.24', '1.25' ]
    runs-on: ${{ matrix.os }}
    name: ${{ matrix.go }}/${{ matrix.os }}
    steps:
-      - uses: actions/checkout@master
+      - uses: actions/checkout@v6
        with:
          fetch-depth: 0
      - name: Setup go ${{ matrix.go }}
-        uses: actions/setup-go@master
+        uses: actions/setup-go@v6
        with:
          go-version: ${{ matrix.go }}
      - name: Run unit tests
        run: go test -race ./...
-      - name: Run benchmark tests
+  release-check:
-        run: go test -race ./...
+    if: ${{ github.ref != 'refs/heads/v2' }}
-        working-directory: benchmark
+    uses: ./.github/workflows/release.yml
    with:
      args: --snapshot
@@ -3,3 +3,6 @@ fuzz/
 cmd/tomll/tomll
 cmd/tomljson/tomljson
 cmd/tomltestgen/tomltestgen
 dist
 tests/
 test-results
@@ -1,84 +1,76 @@
-[service]
+version = "2"
 golangci-lint-version =  "1.39.0"
 [linters-settings.wsl]
 allow-assign-and-anything = true
 [linters-settings.exhaustive]
 default-signifies-exhaustive = true
 [linters]
-disable-all = true
+default = "none"
 enable = [
    "asciicheck",
    "bodyclose",
    "cyclop",
    "deadcode",
    "depguard",
    "dogsled",
    "dupl",
    "durationcheck",
    "errcheck",
    "errorlint",
    "exhaustive",
    "exhaustivestruct",
    "exportloopref",
    "forbidigo",
    "forcetypeassert",
    "funlen",
    "gci",
    "gochecknoglobals",
    "gochecknoinits",
    "gocognit",
    "goconst",
    "gocritic",
-    "gocyclo",
+    "godoclint",
    "godot",
    "godox",
    "goerr113",
    "gofmt",
    "gofumpt",
    "goheader",
    "goimports",
    "golint",
    "gomnd",
    # "gomoddirectives",
    "gomodguard",
    "goprintffuncname",
    "gosec",
    "gosimple",
    "govet",
    # "ifshort",
    "importas",
    "ineffassign",
    "lll",
    "makezero",
    "mirror",
    "misspell",
    "nakedret",
    "nestif",
    "nilerr",
    "nlreturn",
    "noctx",
    "nolintlint",
-    "paralleltest",
+    "perfsprint",
    "prealloc",
    "predeclared",
    "revive",
    "rowserrcheck",
    "sqlclosecheck",
    "staticcheck",
    "structcheck",
    "stylecheck",
    # "testpackage",
    "thelper",
    "tparallel",
    "typecheck",
    "unconvert",
    "unparam",
    "unused",
-    "varcheck",
+    "usetesting",
    "wastedassign",
    "whitespace",
-    "wrapcheck",
+]
-    "wsl"
+
 [linters.settings.exhaustive]
 default-signifies-exhaustive = true
 [linters.settings.lll]
 line-length = 150
 [[linters.exclusions.rules]]
 path = ".test.go"
 linters = ["goconst", "gosec"]
 [[linters.exclusions.rules]]
 path = "main.go"
 linters = ["forbidigo"]
 [[linters.exclusions.rules]]
 path = "internal"
 linters = ["revive"]
 text = "(exported|indent-error-flow): "
 [formatters]
 enable = [
    "gci",
    "gofmt",
    "gofumpt",
    "goimports",
 ]
@@ -0,0 +1,127 @@
 version: 2
 before:
  hooks:
    - go mod tidy
    - go fmt ./...
    - go test ./...
 builds:
  - id: tomll
    main: ./cmd/tomll
    binary: tomll
    env:
      - CGO_ENABLED=0
    flags:
      - -trimpath
    ldflags:
      - -X main.version={{.Version}} -X main.commit={{.Commit}} -X main.date={{.CommitDate}}
    mod_timestamp: '{{ .CommitTimestamp }}'
    targets:
      - linux_amd64
      - linux_arm64
      - linux_arm
      - linux_riscv64
      - windows_amd64
      - windows_arm64
      - windows_arm
      - darwin_amd64
      - darwin_arm64
  - id: tomljson
    main: ./cmd/tomljson
    binary: tomljson
    env:
      - CGO_ENABLED=0
    flags:
      - -trimpath
    ldflags:
      - -X main.version={{.Version}} -X main.commit={{.Commit}} -X main.date={{.CommitDate}}
    mod_timestamp: '{{ .CommitTimestamp }}'
    targets:
      - linux_amd64
      - linux_arm64
      - linux_arm
      - linux_riscv64
      - windows_amd64
      - windows_arm64
      - windows_arm
      - darwin_amd64
      - darwin_arm64
  - id: jsontoml
    main: ./cmd/jsontoml
    binary: jsontoml
    env:
      - CGO_ENABLED=0
    flags:
      - -trimpath
    ldflags:
      - -X main.version={{.Version}} -X main.commit={{.Commit}} -X main.date={{.CommitDate}}
    mod_timestamp: '{{ .CommitTimestamp }}'
    targets:
      - linux_amd64
      - linux_arm64
      - linux_riscv64
      - linux_arm
      - windows_amd64
      - windows_arm64
      - windows_arm
      - darwin_amd64
      - darwin_arm64
 universal_binaries:
  - id: tomll
    replace: true
    name_template: tomll
  - id: tomljson
    replace: true
    name_template: tomljson
  - id: jsontoml
    replace: true
    name_template: jsontoml
 archives:
 - id: jsontoml
  format: tar.xz
  builds:
    - jsontoml
  files:
  - none*
  name_template: "{{ .Binary }}_{{.Version}}_{{ .Os }}_{{ .Arch }}"
 - id: tomljson
  format: tar.xz
  builds:
    - tomljson
  files:
  - none*
  name_template: "{{ .Binary }}_{{.Version}}_{{ .Os }}_{{ .Arch }}"
 - id: tomll
  format: tar.xz
  builds:
    - tomll
  files:
  - none*
  name_template: "{{ .Binary }}_{{.Version}}_{{ .Os }}_{{ .Arch }}"
 dockers:
  - id: tools
    goos: linux
    goarch: amd64
    ids:
      - jsontoml
      - tomljson
      - tomll
    image_templates:
      - "ghcr.io/pelletier/go-toml:latest"
      - "ghcr.io/pelletier/go-toml:{{ .Tag }}"
      - "ghcr.io/pelletier/go-toml:v{{ .Major }}"
    skip_push: false
 checksum:
  name_template: 'sha256sums.txt'
 snapshot:
  version_template: "{{ incpatch .Version }}-next"
 release:
  github:
    owner: pelletier
    name: go-toml
  draft: true
  prerelease: auto
  mode: replace
 changelog:
  use: github-native
 announce:
  skip: true
@@ -0,0 +1,64 @@
 # Agent Guidelines for go-toml
 This file provides guidelines for AI agents contributing to go-toml. All agents must follow these rules derived from [CONTRIBUTING.md](./CONTRIBUTING.md).
 ## Project Overview
 go-toml is a TOML library for Go. The goal is to provide an easy-to-use and efficient TOML implementation that gets the job done without getting in the way.
 ## Code Change Rules
 ### Backward Compatibility
 - **No backward-incompatible changes** unless explicitly discussed and approved
 - Avoid breaking people's programs unless absolutely necessary
 ### Testing Requirements
 - **All bug fixes must include regression tests**
 - **All new code must be tested**
 - Run tests before submitting: `go test -race ./...`
 - Test coverage must not decrease. Check with:
  ```bash
  go test -covermode=atomic -coverprofile=coverage.out
  go tool cover -func=coverage.out
  ```
 - All lines of code touched by changes should be covered by tests
 ### Performance Requirements
 - go-toml aims to stay efficient; avoid performance regressions
 - Run benchmarks to verify: `go test ./... -bench=. -count=10`
 - Compare results using [benchstat](https://pkg.go.dev/golang.org/x/perf/cmd/benchstat)
 ### Documentation
 - New features or feature extensions must include documentation
 - Documentation lives in [README.md](./README.md) and throughout source code
 ### Code Style
 - Follow existing code format and structure
 - Code must pass `go fmt`
 - Code must pass linting with the same golangci-lint version as CI (see version in `.github/workflows/lint.yml`):
  ```bash
  # Install specific version (check lint.yml for current version)
  curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/HEAD/install.sh | sh -s -- -b $(go env GOPATH)/bin <version>
  # Run linter
  golangci-lint run ./...
  ```
 ### Commit Messages
 - Commit messages must explain **why** the change is needed
 - Keep messages clear and informative even if details are in the PR description
 ## Pull Request Checklist
 Before submitting:
 1. Tests pass (`go test -race ./...`)
 2. No backward-incompatible changes (unless discussed)
 3. Relevant documentation added/updated
 4. No performance regression (verify with benchmarks)
 5. Title is clear and understandable for changelog
@@ -1,74 +1,74 @@
-## Contributing
+# Contributing
 Thank you for your interest in go-toml! We appreciate you considering
 contributing to go-toml!
-The main goal is the project is to provide an easy-to-use TOML
+The main goal is the project is to provide an easy-to-use and efficient TOML
-implementation for Go that gets the job done and gets out of your way –
+implementation for Go that gets the job done and gets out of your way – dealing
-dealing with TOML is probably not the central piece of your project.
+with TOML is probably not the central piece of your project.
-As the single maintainer of go-toml, time is scarce. All help, big or
+As the single maintainer of go-toml, time is scarce. All help, big or small, is
-small, is more than welcomed!
+more than welcomed!
-### Ask questions
+## Ask questions
-Any question you may have, somebody else might have it too. Always feel
+Any question you may have, somebody else might have it too. Always feel free to
-free to ask them on the [issues tracker][issues-tracker].  We will try to
+ask them on the [discussion board][discussions]. We will try to answer them as
-answer them as clearly and quickly as possible, time permitting.
+clearly and quickly as possible, time permitting.
 Asking questions also helps us identify areas where the documentation needs
 improvement, or new features that weren't envisioned before. Sometimes, a
-seemingly innocent question leads to the fix of a bug. Don't hesitate and
+seemingly innocent question leads to the fix of a bug. Don't hesitate and ask
-ask away!
+away!
-### Improve the documentation
+[discussions]: https://github.com/pelletier/go-toml/discussions
-The best way to share your knowledge and experience with go-toml is to
+## Improve the documentation
 improve the documentation. Fix a typo, clarify an interface, add an
 example, anything goes!
-The documentation is present in the [README][readme] and thorough the
+The best way to share your knowledge and experience with go-toml is to improve
-source code. On release, it gets updated on [pkg.go.dev][pkg.go.dev]. To make a
+the documentation. Fix a typo, clarify an interface, add an example, anything
-change to the documentation, create a pull request with your proposed
+goes!
 changes. For simple changes like that, the easiest way to go is probably
 the "Fork this project and edit the file" button on Github, displayed at
 the top right of the file. Unless it's a trivial change (for example a
 typo), provide a little bit of context in your pull request description or
 commit message.
-### Report a bug
+The documentation is present in the [README][readme] and thorough the source
 code. On release, it gets updated on [pkg.go.dev][pkg.go.dev]. To make a change
 to the documentation, create a pull request with your proposed changes. For
 simple changes like that, the easiest way to go is probably the "Fork this
 project and edit the file" button on GitHub, displayed at the top right of the
 file. Unless it's a trivial change (for example a typo), provide a little bit of
 context in your pull request description or commit message.
-Found a bug! Sorry to hear that :(. Help us and other track them down and
+## Report a bug
 fix by reporting it. [File a new bug report][bug-report] on the [issues
 tracker][issues-tracker]. The template should provide enough guidance on
 what to include. When in doubt: add more details! By reducing ambiguity and
 providing more information, it decreases back and forth and saves everyone
 time.
-### Code changes
+Found a bug! Sorry to hear that :(. Help us and other track them down and fix by
 reporting it. [File a new bug report][bug-report] on the [issues
 tracker][issues-tracker]. The template should provide enough guidance on what to
 include. When in doubt: add more details! By reducing ambiguity and providing
 more information, it decreases back and forth and saves everyone time.
 ## Code changes
 Want to contribute a patch? Very happy to hear that!
 First, some high-level rules:
-* A short proposal with some POC code is better than a lengthy piece of
+- A short proposal with some POC code is better than a lengthy piece of text
-  text with no code. Code speaks louder than words.
+  with no code. Code speaks louder than words. That being said, bigger changes
-* No backward-incompatible patch will be accepted unless discussed.
+  should probably start with a [discussion][discussions].
-  Sometimes it's hard, and Go's lack of versioning by default does not
+- No backward-incompatible patch will be accepted unless discussed. Sometimes
-  help, but we try not to break people's programs unless we absolutely have
+  it's hard, but we try not to break people's programs unless we absolutely have
  to.
-* If you are writing a new feature or extending an existing one, make sure
+- If you are writing a new feature or extending an existing one, make sure to
-  to write some documentation.
+  write some documentation.
-* Bug fixes need to be accompanied with regression tests.
+- Bug fixes need to be accompanied with regression tests.
-* New code needs to be tested.
+- New code needs to be tested.
-* Your commit messages need to explain why the change is needed, even if
+- Your commit messages need to explain why the change is needed, even if already
-  already included in the PR description.
+  included in the PR description.
-It does sound like a lot, but those best practices are here to save time
+It does sound like a lot, but those best practices are here to save time overall
-overall and continuously improve the quality of the project, which is
+and continuously improve the quality of the project, which is something everyone
-something everyone benefits from.
+benefits from.
-#### Get started
+### Get started
 The fairly standard code contribution process looks like that:
@@ -76,50 +76,153 @@ The fairly standard code contribution process looks like that:
 2. Make your changes, commit on any branch you like.
 3. [Open up a pull request][pull-request]
 4. Review, potential ask for changes.
-5. Merge. You're in!
+5. Merge.
 Feel free to ask for help! You can create draft pull requests to gather
 some early feedback!
-#### Run the tests
+### Run the tests
-You can run tests for go-toml using Go's test tool: `go test ./...`.
+You can run tests for go-toml using Go's test tool: `go test -race ./...`.
 When creating a pull requests, all tests will be ran on Linux on a few Go
 versions (Travis CI), and on Windows using the latest Go version
 (AppVeyor).
-#### Style
+During the pull request process, all tests will be ran on Linux, Windows, and
 MacOS on the last two versions of Go.
-Try to look around and follow the same format and structure as the rest of
+However, given GitHub's new policy to _not_ run Actions on pull requests until a
-the code. We enforce using `go fmt` on the whole code base.
+maintainer clicks on button, it is highly recommended that you run them locally
 as you make changes.
 ### Test across Go versions
 The repository includes tooling to test go-toml across multiple Go versions
 (1.11 through 1.25) both locally and in GitHub Actions.
 #### Local testing with Docker
 Prerequisites: Docker installed and running, Bash shell, `rsync` command.
 ```bash
 # Test all Go versions in parallel (default)
 ./test-go-versions.sh
 # Test specific versions
 ./test-go-versions.sh 1.21 1.22 1.23
 # Test sequentially (slower but uses less resources)
 ./test-go-versions.sh --sequential
 # Verbose output with custom results directory
 ./test-go-versions.sh --verbose --output ./my-results 1.24 1.25
 # Show all options
 ./test-go-versions.sh --help
 ```
 The script creates Docker containers for each Go version and runs the full test
 suite. Results are saved to a `test-results/` directory with individual logs and
 a comprehensive summary report.
 The script only exits with a non-zero status code if either of the two most
 recent Go versions fail.
 #### GitHub Actions testing (maintainers)
 1. Go to the **Actions** tab in the GitHub repository
 2. Select **"Go Versions Compatibility Test"** from the workflow list
 3. Click **"Run workflow"**
 4. Optionally customize:
   - **Go versions**: Space-separated list (e.g., `1.21 1.22 1.23`)
   - **Execution mode**: Parallel (faster) or sequential (more stable)
 ### Check coverage
 We use `go tool cover` to compute test coverage. Most code editors have a way to
 run and display code coverage, but at the end of the day, we do this:
 ```
 go test -covermode=atomic -coverprofile=coverage.out
 go tool cover -func=coverage.out
 ```
 and verify that the overall percentage of tested code does not go down. This is
 a requirement. As a rule of thumb, all lines of code touched by your changes
 should be covered. On Unix you can use `./ci.sh coverage -d v2` to check if your
 code lowers the coverage.
 ### Verify performance
 Go-toml aims to stay efficient. We rely on a set of scenarios executed with Go's
 builtin benchmark systems. Because of their noisy nature, containers provided by
 GitHub Actions cannot be reliably used for benchmarking. As a result, you are
 responsible for checking that your changes do not incur a performance penalty.
 You can run their following to execute benchmarks:
 ```
 go test ./... -bench=. -count=10
 ```
 Benchmark results should be compared against each other with
 [benchstat][benchstat]. Typical flow looks like this:
 1. On the `v2` branch, run `go test ./... -bench=. -count 10` and save output to
   a file (for example `old.txt`).
 2. Make some code changes.
 3. Run `go test ....` again, and save the output to an other file (for example
   `new.txt`).
 4. Run `benchstat old.txt new.txt` to check that time/op does not go up in any
   test.
 On Unix you can use `./ci.sh benchmark -d v2` to verify how your code impacts
 performance.
 It is highly encouraged to add the benchstat results to your pull request
 description. Pull requests that lower performance will receive more scrutiny.
 [benchstat]: https://pkg.go.dev/golang.org/x/perf/cmd/benchstat
 ### Style
 Try to look around and follow the same format and structure as the rest of the
 code. We enforce using `go fmt` on the whole code base.
 ---
-### Maintainers-only
+## Maintainers-only
-#### Merge pull request
+### Merge pull request
 Checklist:
-* Passing CI.
+- Passing CI.
-* Does not introduce backward-incompatible changes (unless discussed).
+- Does not introduce backward-incompatible changes (unless discussed).
-* Has relevant doc changes.
+- Has relevant doc changes.
-* Has relevant unit tests.
+- Benchstat does not show performance regression.
 - Pull request is [labeled appropriately][pr-labels].
 - Title will be understandable in the changelog.
 1. Merge using "squash and merge".
 2. Make sure to edit the commit message to keep all the useful information
   nice and clean.
 3. Make sure the commit title is clear and contains the PR number (#123).
-#### New release
+### New release
 1. Decide on the next version number. Use semver. Review commits since last
   version to assess.
 2. Tag release. For example:
   ```
   git checkout v2
   git pull
   git tag v2.2.0
   git push --tags
   ```
 3. CI automatically builds a draft GitHub release. Review it and edit as
   necessary. Look for "Other changes". That would indicate a pull request not
   labeled properly. Tweak labels and pull request titles until changelog looks
   good for users.
 4. Check "create discussion" box, in the "Releases" category.
 5. If new version is an alpha or beta only, check pre-release box.
 1. Go to [releases][releases]. Click on "X commits to master since this
   release".
 2. Make note of all the changes. Look for backward incompatible changes,
   new features, and bug fixes.
 3. Pick the new version using the above and semver.
 4. Create a [new release][new-release].
 5. Follow the same format as [1.1.0][release-110].
 [issues-tracker]: https://github.com/pelletier/go-toml/issues
 [bug-report]: https://github.com/pelletier/go-toml/issues/new?template=bug_report.md
@@ -127,6 +230,6 @@ Checklist:
 [readme]: ./README.md
 [fork]: https://help.github.com/articles/fork-a-repo
 [pull-request]: https://help.github.com/en/articles/creating-a-pull-request
 [releases]: https://github.com/pelletier/go-toml/releases
 [new-release]: https://github.com/pelletier/go-toml/releases/new
-[release-110]: https://github.com/pelletier/go-toml/releases/tag/v1.1.0
+[gh]: https://github.com/cli/cli
 [pr-labels]: https://github.com/pelletier/go-toml/blob/v2/.github/release.yml
@@ -0,0 +1,5 @@
 FROM scratch
 ENV PATH "$PATH:/bin"
 COPY tomll /bin/tomll
 COPY tomljson /bin/tomljson
 COPY jsontoml /bin/jsontoml
@@ -1,6 +1,7 @@
 The MIT License (MIT)
-Copyright (c) 2013 - 2021 Thomas Pelletier, Eric Anderton
+go-toml v2
 Copyright (c) 2021 - 2023 Thomas Pelletier
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -1,57 +1,635 @@
-# go-toml V2
+# go-toml v2
-Development branch. Use at your own risk.
+Go library for the [TOML](https://toml.io/en/) format.
-[👉 Discussion on github](https://github.com/pelletier/go-toml/discussions/471).
+This library supports [TOML v1.0.0](https://toml.io/en/v1.0.0).
-* `toml.Unmarshal()` should work as well as v1.
+[🐞 Bug Reports](https://github.com/pelletier/go-toml/issues)
-## Must do
+[💬 Anything else](https://github.com/pelletier/go-toml/discussions)
-### Unmarshal
+## Documentation
- [x] Unmarshal into maps.
+Full API, examples, and implementation notes are available in the Go
- [x] Support Array Tables.
+documentation.
 - [x] Unmarshal into pointers.
 - [x] Support Date / times.
 - [x] Support struct tags annotations.
 - [x] Support Arrays.
 - [x] Support Unmarshaler interface.
 - [x] Original go-toml unmarshal tests pass.
 - [x] Benchmark!
 - [x] Abstract AST.
 - [x] Original go-toml testgen tests pass.
 - [x] Track file position (line, column) for errors.
 - [x] Strict mode.
 - [ ] Document Unmarshal / Decode
-### Marshal
+[![Go Reference](https://pkg.go.dev/badge/github.com/pelletier/go-toml/v2.svg)](https://pkg.go.dev/github.com/pelletier/go-toml/v2)
- [x] Minimal implementation
+## Import
 - [x] Multiline strings
 - [ ] Multiline arrays
 - [ ] `inline` tag for tables
 - [ ] Optional indentation
 - [ ] Option to pick default quotes
-### Document
+```go
 import "github.com/pelletier/go-toml/v2"
 ```
- [ ] Gather requirements and design API.
+See [Modules](#Modules).
-## Ideas
+## Features
- [ ] Allow types to implement a `ASTUnmarshaler` interface to unmarshal
+### Stdlib behavior
      straight from the AST?
 - [x] Rewrite AST to use a single array as storage instead of one allocation per
      node.
 - [ ] Provide "minimal allocations" option that uses `unsafe` to reuse the input
      byte array as storage for strings.
 - [x] Cache reflection operations per type.
 - [ ] Optimize tracker pass.
-## Differences with v1
+As much as possible, this library is designed to behave similarly as the
 standard library's `encoding/json`.
-* [unmarshal](https://github.com/pelletier/go-toml/discussions/488)
+### Performance
 While go-toml favors usability, it is written with performance in mind. Most
 operations should not be shockingly slow. See [benchmarks](#benchmarks).
 ### Strict mode
 `Decoder` can be set to "strict mode", which makes it error when some parts of
 the TOML document was not present in the target structure. This is a great way
 to check for typos. [See example in the documentation][strict].
 [strict]: https://pkg.go.dev/github.com/pelletier/go-toml/v2#example-Decoder.DisallowUnknownFields
 ### Contextualized errors
 When most decoding errors occur, go-toml returns [`DecodeError`][decode-err],
 which contains a human readable contextualized version of the error. For
 example:
 ```
 1| [server]
 2| path = 100
 |        ~~~ cannot decode TOML integer into struct field toml_test.Server.Path of type string
 3| port = 50
 ```
 [decode-err]: https://pkg.go.dev/github.com/pelletier/go-toml/v2#DecodeError
 ### Local date and time support
 TOML supports native [local date/times][ldt]. It allows to represent a given
 date, time, or date-time without relation to a timezone or offset. To support
 this use-case, go-toml provides [`LocalDate`][tld], [`LocalTime`][tlt], and
 [`LocalDateTime`][tldt]. Those types can be transformed to and from `time.Time`,
 making them convenient yet unambiguous structures for their respective TOML
 representation.
 [ldt]: https://toml.io/en/v1.0.0#local-date-time
 [tld]: https://pkg.go.dev/github.com/pelletier/go-toml/v2#LocalDate
 [tlt]: https://pkg.go.dev/github.com/pelletier/go-toml/v2#LocalTime
 [tldt]: https://pkg.go.dev/github.com/pelletier/go-toml/v2#LocalDateTime
 ### Commented config
 Since TOML is often used for configuration files, go-toml can emit documents
 annotated with [comments and commented-out values][comments-example]. For
 example, it can generate the following file:
 ```toml
 # Host IP to connect to.
 host = '127.0.0.1'
 # Port of the remote server.
 port = 4242
 # Encryption parameters (optional)
 # [TLS]
 # cipher = 'AEAD-AES128-GCM-SHA256'
 # version = 'TLS 1.3'
 ```
 [comments-example]: https://pkg.go.dev/github.com/pelletier/go-toml/v2#example-Marshal-Commented
 ## Getting started
 Given the following struct, let's see how to read it and write it as TOML:
 ```go
 type MyConfig struct {
 	Version int
 	Name    string
 	Tags    []string
 }
 ```
 ### Unmarshaling
 [`Unmarshal`][unmarshal] reads a TOML document and fills a Go structure with its
 content. 
 Note that the struct variable names are _capitalized_, while the variables in the toml document are _lowercase_.
 For example:
 ```go
 doc := `
 version = 2
 name = "go-toml"
 tags = ["go", "toml"]
 `
 var cfg MyConfig
 err := toml.Unmarshal([]byte(doc), &cfg)
 if err != nil {
 	panic(err)
 }
 fmt.Println("version:", cfg.Version)
 fmt.Println("name:", cfg.Name)
 fmt.Println("tags:", cfg.Tags)
 // Output:
 // version: 2
 // name: go-toml
 // tags: [go toml]
 ```
 [unmarshal]: https://pkg.go.dev/github.com/pelletier/go-toml/v2#Unmarshal
 Here is an example using tables with some simple nesting:
 ```go
 doc := `
 age = 45
 fruits = ["apple", "pear"]
 # these are very important!
 [my-variables]
 first = 1
 second = 0.2
 third = "abc"
 # this is not so important.
 [my-variables.b]
 bfirst = 123
 `
 var Document struct {
 	Age int
 	Fruits []string
 	Myvariables struct {
 		First  int
 		Second float64
 		Third  string
 		B struct {
 			Bfirst int
 		}
 	} `toml:"my-variables"`
 }
 err := toml.Unmarshal([]byte(doc), &Document)
 if err != nil {
 	panic(err)
 }
 fmt.Println("age:", Document.Age)
 fmt.Println("fruits:", Document.Fruits)
 fmt.Println("my-variables.first:", Document.Myvariables.First)
 fmt.Println("my-variables.second:", Document.Myvariables.Second)
 fmt.Println("my-variables.third:", Document.Myvariables.Third)
 fmt.Println("my-variables.B.Bfirst:", Document.Myvariables.B.Bfirst)
 // Output:
 // age: 45
 // fruits: [apple pear]
 // my-variables.first: 1
 // my-variables.second: 0.2
 // my-variables.third: abc
 // my-variables.B.Bfirst: 123
 ```
 ### Marshaling
 [`Marshal`][marshal] is the opposite of Unmarshal: it represents a Go structure
 as a TOML document:
 ```go
 cfg := MyConfig{
 	Version: 2,
 	Name:    "go-toml",
 	Tags:    []string{"go", "toml"},
 }
 b, err := toml.Marshal(cfg)
 if err != nil {
 	panic(err)
 }
 fmt.Println(string(b))
 // Output:
 // Version = 2
 // Name = 'go-toml'
 // Tags = ['go', 'toml']
 ```
 [marshal]: https://pkg.go.dev/github.com/pelletier/go-toml/v2#Marshal
 ## Unstable API
 This API does not yet follow the backward compatibility guarantees of this
 library. They provide early access to features that may have rough edges or an
 API subject to change.
 ### Parser
 Parser is the unstable API that allows iterative parsing of a TOML document at
 the AST level. See https://pkg.go.dev/github.com/pelletier/go-toml/v2/unstable.
 ## Benchmarks
 Execution time speedup compared to other Go TOML libraries:
 <table>
 	<thead>
 		<tr><th>Benchmark</th><th>go-toml v1</th><th>BurntSushi/toml</th></tr>
 	</thead>
 	<tbody>
 		<tr><td>Marshal/HugoFrontMatter-2</td><td>1.9x</td><td>2.2x</td></tr>
 		<tr><td>Marshal/ReferenceFile/map-2</td><td>1.7x</td><td>2.1x</td></tr>
 		<tr><td>Marshal/ReferenceFile/struct-2</td><td>2.2x</td><td>3.0x</td></tr>
 		<tr><td>Unmarshal/HugoFrontMatter-2</td><td>2.9x</td><td>2.7x</td></tr>
 		<tr><td>Unmarshal/ReferenceFile/map-2</td><td>2.6x</td><td>2.7x</td></tr>
 		<tr><td>Unmarshal/ReferenceFile/struct-2</td><td>4.6x</td><td>5.1x</td></tr>
 	 </tbody>
 </table>
 <details><summary>See more</summary>
 <p>The table above has the results of the most common use-cases. The table below
 contains the results of all benchmarks, including unrealistic ones. It is
 provided for completeness.</p>
 <table>
 	<thead>
 		<tr><th>Benchmark</th><th>go-toml v1</th><th>BurntSushi/toml</th></tr>
 	</thead>
 	<tbody>
 		<tr><td>Marshal/SimpleDocument/map-2</td><td>1.8x</td><td>2.7x</td></tr>
 		<tr><td>Marshal/SimpleDocument/struct-2</td><td>2.7x</td><td>3.8x</td></tr>
 		<tr><td>Unmarshal/SimpleDocument/map-2</td><td>3.8x</td><td>3.0x</td></tr>
 		<tr><td>Unmarshal/SimpleDocument/struct-2</td><td>5.6x</td><td>4.1x</td></tr>
 		<tr><td>UnmarshalDataset/example-2</td><td>3.0x</td><td>3.2x</td></tr>
 		<tr><td>UnmarshalDataset/code-2</td><td>2.3x</td><td>2.9x</td></tr>
 		<tr><td>UnmarshalDataset/twitter-2</td><td>2.6x</td><td>2.7x</td></tr>
 		<tr><td>UnmarshalDataset/citm_catalog-2</td><td>2.2x</td><td>2.3x</td></tr>
 		<tr><td>UnmarshalDataset/canada-2</td><td>1.8x</td><td>1.5x</td></tr>
 		<tr><td>UnmarshalDataset/config-2</td><td>4.1x</td><td>2.9x</td></tr>
 		<tr><td>geomean</td><td>2.7x</td><td>2.8x</td></tr>
 	 </tbody>
 </table>
 <p>This table can be generated with <code>./ci.sh benchmark -a -html</code>.</p>
 </details>
 ## Modules
 go-toml uses Go's standard modules system.
 Installation instructions:
 - Go ≥ 1.16: Nothing to do. Use the import in your code. The `go` command deals
  with it automatically.
 - Go ≥ 1.13: `GO111MODULE=on go get github.com/pelletier/go-toml/v2`.
 In case of trouble: [Go Modules FAQ][mod-faq].
 [mod-faq]: https://github.com/golang/go/wiki/Modules#why-does-installing-a-tool-via-go-get-fail-with-error-cannot-find-main-module
 ## Tools
 Go-toml provides three handy command line tools:
 * `tomljson`: Reads a TOML file and outputs its JSON representation.
 	```
 	$ go install github.com/pelletier/go-toml/v2/cmd/tomljson@latest
 	$ tomljson --help
 	```
 * `jsontoml`: Reads a JSON file and outputs a TOML representation.
 	```
 	$ go install github.com/pelletier/go-toml/v2/cmd/jsontoml@latest
 	$ jsontoml --help
 	```
 * `tomll`: Lints and reformats a TOML file.
 	```
 	$ go install github.com/pelletier/go-toml/v2/cmd/tomll@latest
 	$ tomll --help
 	```
 ### Docker image
 Those tools are also available as a [Docker image][docker]. For example, to use
 `tomljson`:
 ```
 docker run -i ghcr.io/pelletier/go-toml:v2 tomljson < example.toml
 ```
 Multiple versions are available on [ghcr.io][docker].
 [docker]: https://github.com/pelletier/go-toml/pkgs/container/go-toml
 ## Migrating from v1
 This section describes the differences between v1 and v2, with some pointers on
 how to get the original behavior when possible.
 ### Decoding / Unmarshal
 #### Automatic field name guessing
 When unmarshaling to a struct, if a key in the TOML document does not exactly
 match the name of a struct field or any of the `toml`-tagged field, v1 tries
 multiple variations of the key ([code][v1-keys]).
 V2 instead does a case-insensitive matching, like `encoding/json`.
 This could impact you if you are relying on casing to differentiate two fields,
 and one of them is a not using the `toml` struct tag. The recommended solution
 is to be specific about tag names for those fields using the `toml` struct tag.
 [v1-keys]: https://github.com/pelletier/go-toml/blob/a2e52561804c6cd9392ebf0048ca64fe4af67a43/marshal.go#L775-L781
 #### Ignore preexisting value in interface
 When decoding into a non-nil `interface{}`, go-toml v1 uses the type of the
 element in the interface to decode the object. For example:
 ```go
 type inner struct {
 	B interface{}
 }
 type doc struct {
 	A interface{}
 }
 d := doc{
 	A: inner{
 		B: "Before",
 	},
 }
 data := `
 [A]
 B = "After"
 `
 toml.Unmarshal([]byte(data), &d)
 fmt.Printf("toml v1: %#v\n", d)
 // toml v1: main.doc{A:main.inner{B:"After"}}
 ```
 In this case, field `A` is of type `interface{}`, containing a `inner` struct.
 V1 sees that type and uses it when decoding the object.
 When decoding an object into an `interface{}`, V2 instead disregards whatever
 value the `interface{}` may contain and replaces it with a
 `map[string]interface{}`. With the same data structure as above, here is what
 the result looks like:
 ```go
 toml.Unmarshal([]byte(data), &d)
 fmt.Printf("toml v2: %#v\n", d)
 // toml v2: main.doc{A:map[string]interface {}{"B":"After"}}
 ```
 This is to match `encoding/json`'s behavior. There is no way to make the v2
 decoder behave like v1.
 #### Values out of array bounds ignored
 When decoding into an array, v1 returns an error when the number of elements
 contained in the doc is superior to the capacity of the array. For example:
 ```go
 type doc struct {
 	A [2]string
 }
 d := doc{}
 err := toml.Unmarshal([]byte(`A = ["one", "two", "many"]`), &d)
 fmt.Println(err)
 // (1, 1): unmarshal: TOML array length (3) exceeds destination array length (2)
 ```
 In the same situation, v2 ignores the last value:
 ```go
 err := toml.Unmarshal([]byte(`A = ["one", "two", "many"]`), &d)
 fmt.Println("err:", err, "d:", d)
 // err: <nil> d: {[one two]}
 ```
 This is to match `encoding/json`'s behavior. There is no way to make the v2
 decoder behave like v1.
 #### Support for `toml.Unmarshaler` has been dropped
 This method was not widely used, poorly defined, and added a lot of complexity.
 A similar effect can be achieved by implementing the `encoding.TextUnmarshaler`
 interface and use strings.
 #### Support for `default` struct tag has been dropped
 This feature adds complexity and a poorly defined API for an effect that can be
 accomplished outside of the library.
 It does not seem like other format parsers in Go support that feature (the
 project referenced in the original ticket #202 has not been updated since 2017).
 Given that go-toml v2 should not touch values not in the document, the same
 effect can be achieved by pre-filling the struct with defaults (libraries like
 [go-defaults][go-defaults] can help). Also, string representation is not well
 defined for all types: it creates issues like #278.
 The recommended replacement is pre-filling the struct before unmarshaling.
 [go-defaults]: https://github.com/mcuadros/go-defaults
 #### `toml.Tree` replacement
 This structure was the initial attempt at providing a document model for
 go-toml. It allows manipulating the structure of any document, encoding and
 decoding from their TOML representation. While a more robust feature was
 initially planned in go-toml v2, this has been ultimately [removed from
 scope][nodoc] of this library, with no plan to add it back at the moment. The
 closest equivalent at the moment would be to unmarshal into an `interface{}` and
 use type assertions and/or reflection to manipulate the arbitrary
 structure. However this would fall short of providing all of the TOML features
 such as adding comments and be specific about whitespace.
 #### `toml.Position` are not retrievable anymore
 The API for retrieving the position (line, column) of a specific TOML element do
 not exist anymore. This was done to minimize the amount of concepts introduced
 by the library (query path), and avoid the performance hit related to storing
 positions in the absence of a document model, for a feature that seemed to have
 little use. Errors however have gained more detailed position
 information. Position retrieval seems better fitted for a document model, which
 has been [removed from the scope][nodoc] of go-toml v2 at the moment.
 ### Encoding / Marshal
 #### Default struct fields order
 V1 emits struct fields order alphabetically by default. V2 struct fields are
 emitted in order they are defined. For example:
 ```go
 type S struct {
 	B string
 	A string
 }
 data := S{
 	B: "B",
 	A: "A",
 }
 b, _ := tomlv1.Marshal(data)
 fmt.Println("v1:\n" + string(b))
 b, _ = tomlv2.Marshal(data)
 fmt.Println("v2:\n" + string(b))
 // Output:
 // v1:
 // A = "A"
 // B = "B"
 // v2:
 // B = 'B'
 // A = 'A'
 ```
 There is no way to make v2 encoder behave like v1. A workaround could be to
 manually sort the fields alphabetically in the struct definition, or generate
 struct types using `reflect.StructOf`.
 #### No indentation by default
 V1 automatically indents content of tables by default. V2 does not. However the
 same behavior can be obtained using [`Encoder.SetIndentTables`][sit]. For example:
 ```go
 data := map[string]interface{}{
 	"table": map[string]string{
 		"key": "value",
 	},
 }
 b, _ := tomlv1.Marshal(data)
 fmt.Println("v1:\n" + string(b))
 b, _ = tomlv2.Marshal(data)
 fmt.Println("v2:\n" + string(b))
 buf := bytes.Buffer{}
 enc := tomlv2.NewEncoder(&buf)
 enc.SetIndentTables(true)
 enc.Encode(data)
 fmt.Println("v2 Encoder:\n" + string(buf.Bytes()))
 // Output:
 // v1:
 //
 // [table]
 //   key = "value"
 //
 // v2:
 // [table]
 // key = 'value'
 //
 //
 // v2 Encoder:
 // [table]
 //   key = 'value'
 ```
 [sit]: https://pkg.go.dev/github.com/pelletier/go-toml/v2#Encoder.SetIndentTables
 #### Keys and strings are single quoted
 V1 always uses double quotes (`"`) around strings and keys that cannot be
 represented bare (unquoted). V2 uses single quotes instead by default (`'`),
 unless a character cannot be represented, then falls back to double quotes. As a
 result of this change, `Encoder.QuoteMapKeys` has been removed, as it is not
 useful anymore.
 There is no way to make v2 encoder behave like v1.
 #### `TextMarshaler` emits as a string, not TOML
 Types that implement [`encoding.TextMarshaler`][tm] can emit arbitrary TOML in
 v1. The encoder would append the result to the output directly. In v2 the result
 is wrapped in a string. As a result, this interface cannot be implemented by the
 root object.
 There is no way to make v2 encoder behave like v1.
 [tm]: https://golang.org/pkg/encoding/#TextMarshaler
 #### `Encoder.CompactComments` has been removed
 Emitting compact comments is now the default behavior of go-toml. This option
 is not necessary anymore.
 #### Struct tags have been merged
 V1 used to provide multiple struct tags: `comment`, `commented`, `multiline`,
 `toml`, and `omitempty`. To behave more like the standard library, v2 has merged
 `toml`, `multiline`, `commented`, and `omitempty`. For example:
 ```go
 type doc struct {
 	// v1
 	F string `toml:"field" multiline:"true" omitempty:"true" commented:"true"`
 	// v2
 	F string `toml:"field,multiline,omitempty,commented"`
 }
 ```
 Has a result, the `Encoder.SetTag*` methods have been removed, as there is just
 one tag now.
 #### `Encoder.ArraysWithOneElementPerLine` has been renamed
 The new name is `Encoder.SetArraysMultiline`. The behavior should be the same.
 #### `Encoder.Indentation` has been renamed
 The new name is `Encoder.SetIndentSymbol`. The behavior should be the same.
 #### Embedded structs behave like stdlib
 V1 defaults to merging embedded struct fields into the embedding struct. This
 behavior was unexpected because it does not follow the standard library. To
 avoid breaking backward compatibility, the `Encoder.PromoteAnonymous` method was
 added to make the encoder behave correctly. Given backward compatibility is not
 a problem anymore, v2 does the right thing by default: it follows the behavior
 of `encoding/json`. `Encoder.PromoteAnonymous` has been removed.
 [nodoc]: https://github.com/pelletier/go-toml/discussions/506#discussioncomment-1526038
 ### `query`
 go-toml v1 provided the [`go-toml/query`][query] package. It allowed to run
 JSONPath-style queries on TOML files. This feature is not available in v2. For a
 replacement, check out [dasel][dasel].
 This package has been removed because it was essentially not supported anymore
 (last commit May 2020), increased the complexity of the code base, and more
 complete solutions exist out there.
 [query]: https://github.com/pelletier/go-toml/tree/f99d6bbca119636aeafcf351ee52b3d202782627/query
 [dasel]: https://github.com/TomWright/dasel
 ## Versioning
 Expect for parts explicitly marked otherwise, go-toml follows [Semantic
 Versioning](https://semver.org). The supported version of
 [TOML](https://github.com/toml-lang/toml) is indicated at the beginning of this
 document. The last two major versions of Go are supported (see [Go Release
 Policy](https://golang.org/doc/devel/release.html#policy)).
 ## License
@@ -0,0 +1,16 @@
 # Security Policy
 ## Supported Versions
 | Version    | Supported          |
 | ---------- | ------------------ |
 | Latest 2.x | :white_check_mark: |
 | All 1.x    | :x:                |
 | All 0.x    | :x:                |
 ## Reporting a Vulnerability
 Email a vulnerability report to `security@pelletier.codes`. Make sure to include
 as many details as possible to reproduce the vulnerability. This is a
 side-project: I will try to get back to you as quickly as possible, time
 permitting in my personal life. Providing a working patch helps very much!
@@ -3,15 +3,16 @@ package benchmark_test
 import (
 	"compress/gzip"
 	"encoding/json"
-	"io/ioutil"
+	"io"
 	"os"
 	"path/filepath"
 	"testing"
-	"github.com/stretchr/testify/require"
+	"github.com/pelletier/go-toml/v2"
 	"github.com/pelletier/go-toml/v2/internal/assert"
 )
-var bench_inputs = []struct {
+var benchInputs = []struct {
 	name    string
 	jsonLen int
 }{
@@ -29,66 +30,51 @@ var bench_inputs = []struct {
 }
 func TestUnmarshalDatasetCode(t *testing.T) {
-	for _, tc := range bench_inputs {
+	for _, tc := range benchInputs {
 		buf := fixture(t, tc.name)
 		t.Run(tc.name, func(t *testing.T) {
-			for _, r := range runners {
+			buf := fixture(t, tc.name)
 				if r.name == "bs" && tc.name == "canada" {
 					t.Skip("skipping: burntsushi can't handle mixed arrays")
 				}
-				t.Run(r.name, func(t *testing.T) {
+			var v interface{}
-					var v interface{}
+			assert.NoError(t, toml.Unmarshal(buf, &v))
 					check(t, r.unmarshal(buf, &v))
-					b, err := json.Marshal(v)
+			b, err := json.Marshal(v)
-					check(t, err)
+			assert.NoError(t, err)
-					require.Equal(t, len(b), tc.jsonLen)
+			assert.Equal(t, len(b), tc.jsonLen)
 				})
 			}
 		})
 	}
 }
 func BenchmarkUnmarshalDataset(b *testing.B) {
-	for _, tc := range bench_inputs {
+	for _, tc := range benchInputs {
 		buf := fixture(b, tc.name)
 		b.Run(tc.name, func(b *testing.B) {
-			bench(b, func(r runner, b *testing.B) {
+			buf := fixture(b, tc.name)
-				if r.name == "bs" && tc.name == "canada" {
+			b.SetBytes(int64(len(buf)))
-					b.Skip("skipping: burntsushi can't handle mixed arrays")
+			b.ReportAllocs()
-				}
+			b.ResetTimer()
-
+			for i := 0; i < b.N; i++ {
-				b.SetBytes(int64(len(buf)))
+				var v interface{}
-				b.ReportAllocs()
+				assert.NoError(b, toml.Unmarshal(buf, &v))
-				b.ResetTimer()
+			}
 				for i := 0; i < b.N; i++ {
 					var v interface{}
 					check(b, r.unmarshal(buf, &v))
 				}
 			})
 		})
 	}
 }
 // fixture returns the uncompressed contents of path.
 func fixture(tb testing.TB, path string) []byte {
-	f, err := os.Open(filepath.Join("testdata", path+".toml.gz"))
+	tb.Helper()
-	check(tb, err)
+
-	defer f.Close()
+	file := path + ".toml.gz"
 	f, err := os.Open(filepath.Join("testdata", file))
 	if os.IsNotExist(err) {
 		tb.Skip("benchmark fixture not found:", file)
 	}
 	assert.NoError(tb, err)
 	defer func() { _ = f.Close() }()
 	gz, err := gzip.NewReader(f)
-	check(tb, err)
+	assert.NoError(tb, err)
 	buf, err := ioutil.ReadAll(gz)
 	check(tb, err)
 	buf, err := io.ReadAll(gz)
 	assert.NoError(tb, err)
 	return buf
 }
 func check(tb testing.TB, err error) {
 	if err != nil {
 		tb.Helper()
 		tb.Fatal(err)
 	}
 }
@@ -186,7 +186,7 @@ key3 = 1979-05-27T00:32:00.999999-07:00
 key1 = [ 1, 2, 3 ]
 key2 = [ "red", "yellow", "green" ]
 key3 = [ [ 1, 2 ], [3, 4, 5] ]
-#key4 = [ [ 1, 2 ], ["a", "b", "c"] ] # this is ok
+key4 = [ [ 1, 2 ], ["a", "b", "c"] ] # this is ok
 # Arrays can also be multiline. So in addition to ignoring whitespace, arrays
 # also ignore newlines between the brackets.  Terminating commas are ok before
@@ -1,50 +1,241 @@
 package benchmark_test
 import (
-	"io/ioutil"
+	"bytes"
 	"os"
 	"testing"
 	"time"
 	tomlbs "github.com/BurntSushi/toml"
 	tomlv1 "github.com/pelletier/go-toml-v1"
 	"github.com/pelletier/go-toml/v2"
-	"github.com/stretchr/testify/require"
+	"github.com/pelletier/go-toml/v2/internal/assert"
 )
-type runner struct {
+func TestUnmarshalSimple(t *testing.T) {
-	name      string
+	doc := []byte(`A = "hello"`)
-	unmarshal func([]byte, interface{}) error
+	d := struct {
-}
+		A string
 	}{}
-var runners = []runner{
+	err := toml.Unmarshal(doc, &d)
-	{"v2", toml.Unmarshal},
+	if err != nil {
-	{"v1", tomlv1.Unmarshal},
+		t.Error(err)
 	{"bs", tomlbs.Unmarshal},
 }
 func bench(b *testing.B, f func(r runner, b *testing.B)) {
 	for _, r := range runners {
 		b.Run(r.name, func(b *testing.B) {
 			f(r, b)
 		})
 	}
 }
-func BenchmarkUnmarshalSimple(b *testing.B) {
+func BenchmarkUnmarshal(b *testing.B) {
-	bench(b, func(r runner, b *testing.B) {
+	b.Run("SimpleDocument", func(b *testing.B) {
 		d := struct {
 			A string
 		}{}
 		doc := []byte(`A = "hello"`)
 		b.Run("struct", func(b *testing.B) {
 			b.SetBytes(int64(len(doc)))
 			b.ReportAllocs()
 			b.ResetTimer()
 			for i := 0; i < b.N; i++ {
 				d := struct {
 					A string
 				}{}
 				err := toml.Unmarshal(doc, &d)
 				if err != nil {
 					b.Error(err)
 				}
 			}
 		})
 		b.Run("map", func(b *testing.B) {
 			b.SetBytes(int64(len(doc)))
 			b.ReportAllocs()
 			b.ResetTimer()
 			for i := 0; i < b.N; i++ {
 				d := map[string]interface{}{}
 				err := toml.Unmarshal(doc, &d)
 				if err != nil {
 					b.Error(err)
 				}
 			}
 		})
 	})
 	b.Run("ReferenceFile", func(b *testing.B) {
 		bytes, err := os.ReadFile("benchmark.toml")
 		if err != nil {
 			b.Fatal(err)
 		}
 		b.Run("struct", func(b *testing.B) {
 			b.SetBytes(int64(len(bytes)))
 			b.ReportAllocs()
 			b.ResetTimer()
 			for i := 0; i < b.N; i++ {
 				d := benchmarkDoc{}
 				err := toml.Unmarshal(bytes, &d)
 				if err != nil {
 					b.Error(err)
 				}
 			}
 		})
 		b.Run("map", func(b *testing.B) {
 			b.SetBytes(int64(len(bytes)))
 			b.ReportAllocs()
 			b.ResetTimer()
 			for i := 0; i < b.N; i++ {
 				d := map[string]interface{}{}
 				err := toml.Unmarshal(bytes, &d)
 				if err != nil {
 					b.Error(err)
 				}
 			}
 		})
 	})
 	b.Run("HugoFrontMatter", func(b *testing.B) {
 		b.SetBytes(int64(len(hugoFrontMatterbytes)))
 		b.ReportAllocs()
 		b.ResetTimer()
 		for i := 0; i < b.N; i++ {
-			err := r.unmarshal(doc, &d)
+			d := map[string]interface{}{}
 			err := toml.Unmarshal(hugoFrontMatterbytes, &d)
 			if err != nil {
-				panic(err)
+				b.Error(err)
 			}
 		}
 	})
 }
 func marshal(v interface{}) ([]byte, error) {
 	var b bytes.Buffer
 	enc := toml.NewEncoder(&b)
 	err := enc.Encode(v)
 	return b.Bytes(), err
 }
 func BenchmarkMarshal(b *testing.B) {
 	b.Run("SimpleDocument", func(b *testing.B) {
 		doc := []byte(`A = "hello"`)
 		b.Run("struct", func(b *testing.B) {
 			d := struct {
 				A string
 			}{}
 			err := toml.Unmarshal(doc, &d)
 			if err != nil {
 				b.Error(err)
 			}
 			b.ReportAllocs()
 			b.ResetTimer()
 			var out []byte
 			for i := 0; i < b.N; i++ {
 				out, err = marshal(d)
 				if err != nil {
 					b.Error(err)
 				}
 			}
 			b.SetBytes(int64(len(out)))
 		})
 		b.Run("map", func(b *testing.B) {
 			d := map[string]interface{}{}
 			err := toml.Unmarshal(doc, &d)
 			if err != nil {
 				b.Error(err)
 			}
 			b.ReportAllocs()
 			b.ResetTimer()
 			var out []byte
 			for i := 0; i < b.N; i++ {
 				out, err = marshal(d)
 				if err != nil {
 					b.Error(err)
 				}
 			}
 			b.SetBytes(int64(len(out)))
 		})
 	})
 	b.Run("ReferenceFile", func(b *testing.B) {
 		bytes, err := os.ReadFile("benchmark.toml")
 		if err != nil {
 			b.Fatal(err)
 		}
 		b.Run("struct", func(b *testing.B) {
 			d := benchmarkDoc{}
 			err := toml.Unmarshal(bytes, &d)
 			if err != nil {
 				b.Error(err)
 			}
 			b.ReportAllocs()
 			b.ResetTimer()
 			var out []byte
 			for i := 0; i < b.N; i++ {
 				out, err = marshal(d)
 				if err != nil {
 					b.Error(err)
 				}
 			}
 			b.SetBytes(int64(len(out)))
 		})
 		b.Run("map", func(b *testing.B) {
 			d := map[string]interface{}{}
 			err := toml.Unmarshal(bytes, &d)
 			if err != nil {
 				b.Error(err)
 			}
 			b.ReportAllocs()
 			b.ResetTimer()
 			var out []byte
 			for i := 0; i < b.N; i++ {
 				out, err = marshal(d)
 				if err != nil {
 					b.Error(err)
 				}
 			}
 			b.SetBytes(int64(len(out)))
 		})
 	})
 	b.Run("HugoFrontMatter", func(b *testing.B) {
 		d := map[string]interface{}{}
 		err := toml.Unmarshal(hugoFrontMatterbytes, &d)
 		if err != nil {
 			b.Error(err)
 		}
 		b.ReportAllocs()
 		b.ResetTimer()
 		var out []byte
 		for i := 0; i < b.N; i++ {
 			out, err = marshal(d)
 			if err != nil {
 				b.Error(err)
 			}
 		}
 		b.SetBytes(int64(len(out)))
 	})
 }
 type benchmarkDoc struct {
 	Table struct {
 		Key      string
@@ -58,7 +249,7 @@ type benchmarkDoc struct {
 			}
 			Point struct {
 				X int64
-				U int64
+				Y int64
 			}
 		}
 	}
@@ -131,6 +322,7 @@ type benchmarkDoc struct {
 		Key2 []string
 		Key3 [][]int64
 		// TODO: Key4 not supported by go-toml's Unmarshal
 		Key4 []interface{}
 		Key5 []int64
 		Key6 []int64
 	}
@@ -142,38 +334,321 @@ type benchmarkDoc struct {
 	Fruit []struct {
 		Name     string
 		Physical struct {
-			Color   string
+			Color string
-			Shape   string
+			Shape string
-			Variety []struct {
+		}
-				Name string
+		Variety []struct {
-			}
+			Name string
 		}
 	}
 }
-func BenchmarkReferenceFile(b *testing.B) {
+func TestUnmarshalReferenceFile(t *testing.T) {
-	bench(b, func(r runner, b *testing.B) {
+	bytes, err := os.ReadFile("benchmark.toml")
-		bytes, err := ioutil.ReadFile("benchmark.toml")
+	assert.NoError(t, err)
 		if err != nil {
 			b.Fatal(err)
 		}
 		b.SetBytes(int64(len(bytes)))
 		b.ReportAllocs()
 		b.ResetTimer()
 		for i := 0; i < b.N; i++ {
 			d := benchmarkDoc{}
 			err := r.unmarshal(bytes, &d)
 			if err != nil {
 				panic(err)
 			}
 		}
 	})
 }
 func TestReferenceFile(t *testing.T) {
 	bytes, err := ioutil.ReadFile("benchmark.toml")
 	require.NoError(t, err)
 	d := benchmarkDoc{}
 	err = toml.Unmarshal(bytes, &d)
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	expected := benchmarkDoc{
 		Table: struct {
 			Key      string
 			Subtable struct{ Key string }
 			Inline   struct {
 				Name struct {
 					First string
 					Last  string
 				}
 				Point struct {
 					X int64
 					Y int64
 				}
 			}
 		}{
 			Key: "value",
 			Subtable: struct{ Key string }{
 				Key: "another value",
 			},
 			// note: x.y.z.w is purposefully missing
 			Inline: struct {
 				Name struct {
 					First string
 					Last  string
 				}
 				Point struct {
 					X int64
 					Y int64
 				}
 			}{
 				Name: struct {
 					First string
 					Last  string
 				}{
 					First: "Tom",
 					Last:  "Preston-Werner",
 				},
 				Point: struct {
 					X int64
 					Y int64
 				}{
 					X: 1,
 					Y: 2,
 				},
 			},
 		},
 		String: struct {
 			Basic     struct{ Basic string }
 			Multiline struct {
 				Key1      string
 				Key2      string
 				Key3      string
 				Continued struct {
 					Key1 string
 					Key2 string
 					Key3 string
 				}
 			}
 			Literal struct {
 				Winpath   string
 				Winpath2  string
 				Quoted    string
 				Regex     string
 				Multiline struct {
 					Regex2 string
 					Lines  string
 				}
 			}
 		}{
 			Basic: struct{ Basic string }{
 				Basic: "I'm a string. \"You can quote me\". Name\tJos\u00E9\nLocation\tSF.",
 			},
 			Multiline: struct {
 				Key1      string
 				Key2      string
 				Key3      string
 				Continued struct {
 					Key1 string
 					Key2 string
 					Key3 string
 				}
 			}{
 				Key1: "One\nTwo",
 				Key2: "One\nTwo",
 				Key3: "One\nTwo",
 				Continued: struct {
 					Key1 string
 					Key2 string
 					Key3 string
 				}{
 					Key1: `The quick brown fox jumps over the lazy dog.`,
 					Key2: `The quick brown fox jumps over the lazy dog.`,
 					Key3: `The quick brown fox jumps over the lazy dog.`,
 				},
 			},
 			Literal: struct {
 				Winpath   string
 				Winpath2  string
 				Quoted    string
 				Regex     string
 				Multiline struct {
 					Regex2 string
 					Lines  string
 				}
 			}{
 				Winpath:  `C:\Users\nodejs\templates`,
 				Winpath2: `\\ServerX\admin$\system32\`,
 				Quoted:   `Tom "Dubs" Preston-Werner`,
 				Regex:    `<\i\c*\s*>`,
 				Multiline: struct {
 					Regex2 string
 					Lines  string
 				}{
 					Regex2: `I [dw]on't need \d{2} apples`,
 					Lines: `The first newline is
 trimmed in raw strings.
   All other whitespace
   is preserved.
 `,
 				},
 			},
 		},
 		Integer: struct {
 			Key1        int64
 			Key2        int64
 			Key3        int64
 			Key4        int64
 			Underscores struct {
 				Key1 int64
 				Key2 int64
 				Key3 int64
 			}
 		}{
 			Key1: 99,
 			Key2: 42,
 			Key3: 0,
 			Key4: -17,
 			Underscores: struct {
 				Key1 int64
 				Key2 int64
 				Key3 int64
 			}{
 				Key1: 1000,
 				Key2: 5349221,
 				Key3: 12345,
 			},
 		},
 		Float: struct {
 			Fractional struct {
 				Key1 float64
 				Key2 float64
 				Key3 float64
 			}
 			Exponent struct {
 				Key1 float64
 				Key2 float64
 				Key3 float64
 			}
 			Both        struct{ Key float64 }
 			Underscores struct {
 				Key1 float64
 				Key2 float64
 			}
 		}{
 			Fractional: struct {
 				Key1 float64
 				Key2 float64
 				Key3 float64
 			}{
 				Key1: 1.0,
 				Key2: 3.1415,
 				Key3: -0.01,
 			},
 			Exponent: struct {
 				Key1 float64
 				Key2 float64
 				Key3 float64
 			}{
 				Key1: 5e+22,
 				Key2: 1e6,
 				Key3: -2e-2,
 			},
 			Both: struct{ Key float64 }{
 				Key: 6.626e-34,
 			},
 			Underscores: struct {
 				Key1 float64
 				Key2 float64
 			}{
 				Key1: 9224617.445991228313,
 				Key2: 1e100,
 			},
 		},
 		Boolean: struct {
 			True  bool
 			False bool
 		}{
 			True:  true,
 			False: false,
 		},
 		Datetime: struct {
 			Key1 time.Time
 			Key2 time.Time
 			Key3 time.Time
 		}{
 			Key1: time.Date(1979, 5, 27, 7, 32, 0, 0, time.UTC),
 			Key2: time.Date(1979, 5, 27, 0, 32, 0, 0, time.FixedZone("", -7*3600)),
 			Key3: time.Date(1979, 5, 27, 0, 32, 0, 999999000, time.FixedZone("", -7*3600)),
 		},
 		Array: struct {
 			Key1 []int64
 			Key2 []string
 			Key3 [][]int64
 			Key4 []interface{}
 			Key5 []int64
 			Key6 []int64
 		}{
 			Key1: []int64{1, 2, 3},
 			Key2: []string{"red", "yellow", "green"},
 			Key3: [][]int64{{1, 2}, {3, 4, 5}},
 			Key4: []interface{}{
 				[]interface{}{int64(1), int64(2)},
 				[]interface{}{"a", "b", "c"},
 			},
 			Key5: []int64{1, 2, 3},
 			Key6: []int64{1, 2},
 		},
 		Products: []struct {
 			Name  string
 			Sku   int64
 			Color string
 		}{
 			{
 				Name: "Hammer",
 				Sku:  738594937,
 			},
 			{},
 			{
 				Name:  "Nail",
 				Sku:   284758393,
 				Color: "gray",
 			},
 		},
 		Fruit: []struct {
 			Name     string
 			Physical struct {
 				Color string
 				Shape string
 			}
 			Variety []struct{ Name string }
 		}{
 			{
 				Name: "apple",
 				Physical: struct {
 					Color string
 					Shape string
 				}{
 					Color: "red",
 					Shape: "round",
 				},
 				Variety: []struct{ Name string }{
 					{Name: "red delicious"},
 					{Name: "granny smith"},
 				},
 			},
 			{
 				Name: "banana",
 				Variety: []struct{ Name string }{
 					{Name: "plantain"},
 				},
 			},
 		},
 	}
 	assert.Equal(t, expected, d)
 }
 var hugoFrontMatterbytes = []byte(`
 categories = ["Development", "VIM"]
 date = "2012-04-06"
 description = "spf13-vim is a cross platform distribution of vim plugins and resources for Vim."
 slug = "spf13-vim-3-0-release-and-new-website"
 tags = [".vimrc", "plugins", "spf13-vim", "vim"]
 title = "spf13-vim 3.0 release and new website"
 include_toc = true
 show_comments = false
 [[cascade]]
  background = "yosemite.jpg"
  [cascade._target]
    kind = "page"
    lang = "en"
    path = "/blog/**"
 [[cascade]]
  background = "goldenbridge.jpg"
  [cascade._target]
    kind = "section"
 `)
@@ -1,14 +0,0 @@
 module github.com/pelletier/go-toml/v2/benchmark
 go 1.16
 replace github.com/pelletier/go-toml/v2 => ../
 replace github.com/pelletier/go-toml-v1 => github.com/pelletier/go-toml v1.8.1
 require (
 	github.com/BurntSushi/toml v0.3.1
 	github.com/pelletier/go-toml-v1 v0.0.0-00010101000000-000000000000
 	github.com/pelletier/go-toml/v2 v2.0.0-00010101000000-000000000000
 	github.com/stretchr/testify v1.7.0
 )
@@ -1,16 +0,0 @@
 github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/pelletier/go-toml v1.8.1 h1:1Nf83orprkJyknT6h7zbuEGUEjcyVlCxSUGTENmNCRM=
 github.com/pelletier/go-toml v1.8.1/go.mod h1:T2/BmBdy8dvIRq1a/8aqjN41wvWlN4lrapLU/GW4pbc=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
@@ -0,0 +1,284 @@
 #!/usr/bin/env bash
 stderr() {
    echo "$@" 1>&2
 }
 usage() {
    b=$(basename "$0")
    echo $b: ERROR: "$@" 1>&2
    cat 1>&2 <<EOF
 DESCRIPTION
    $(basename "$0") is the script to run continuous integration commands for
    go-toml on unix.
    Requires Go and Git to be available in the PATH. Expects to be ran from the
    root of go-toml's Git repository.
 USAGE
    $b COMMAND [OPTIONS...]
 COMMANDS
 benchmark [OPTIONS...] [BRANCH]
    Run benchmarks.
    ARGUMENTS
        BRANCH Optional. Defines which Git branch to use when running
               benchmarks.
    OPTIONS
        -d      Compare benchmarks of HEAD with BRANCH using benchstats. In
                this form the BRANCH argument is required.
        -a      Compare benchmarks of HEAD against go-toml v1 and
                BurntSushi/toml.
        -html   When used with -a, emits the output as HTML, ready to be
                embedded in the README.
 coverage [OPTIONS...] [BRANCH]
    Generates code coverage.
    ARGUMENTS
        BRANCH  Optional. Defines which Git branch to use when reporting
                coverage. Defaults to HEAD.
    OPTIONS
        -d      Compare coverage of HEAD with the one of BRANCH. In this form,
                the BRANCH argument is required. Exit code is non-zero when
                coverage percentage decreased.
 EOF
    exit 1
 }
 cover() {
    branch="${1}"
    dir="$(mktemp -d)"
    stderr "Executing coverage for ${branch} at ${dir}"
    if [ "${branch}" = "HEAD" ]; then
 	    cp -r . "${dir}/"
    else
 	    git worktree add "$dir" "$branch"
    fi
    pushd "$dir"
    go test -covermode=atomic  -coverpkg=./... -coverprofile=coverage.out.tmp ./...
    grep -Ev '(fuzz|testsuite|tomltestgen|gotoml-test-decoder|gotoml-test-encoder)' coverage.out.tmp > coverage.out
    go tool cover -func=coverage.out
    echo "Coverage profile for ${branch}: ${dir}/coverage.out" >&2
    popd
    if [ "${branch}" != "HEAD" ]; then
 	    git worktree remove --force "$dir"
    fi
 }
 coverage() {
    case "$1" in
 	-d)
 	    shift
 	    target="${1?Need to provide a target branch argument}"
 	    output_dir="$(mktemp -d)"
 	    target_out="${output_dir}/target.txt"
 	    head_out="${output_dir}/head.txt"
 	    cover "${target}" > "${target_out}"
 	    cover "HEAD" > "${head_out}"
 	    cat "${target_out}"
 	    cat "${head_out}"
 	    echo ""
 	    target_pct="$(tail -n2 ${target_out} | head -n1 | sed -E 's/.*total.*\t([0-9.]+)%.*/\1/')"
 	    head_pct="$(tail -n2 ${head_out} | head -n1 | sed -E 's/.*total.*\t([0-9.]+)%/\1/')"
 	    echo "Results: ${target} ${target_pct}% HEAD ${head_pct}%"
 	    delta_pct=$(echo "$head_pct - $target_pct" | bc -l)
 	    echo "Delta: ${delta_pct}"
 	    if [[ $delta_pct = \-* ]]; then
 		    echo "Regression!";
            target_diff="${output_dir}/target.diff.txt"
            head_diff="${output_dir}/head.diff.txt"
            cat "${target_out}" | grep -E '^github.com/pelletier/go-toml' | tr -s "\t " | cut -f 2,3 | sort > "${target_diff}"
            cat "${head_out}" | grep -E '^github.com/pelletier/go-toml' | tr -s "\t " | cut -f 2,3 | sort > "${head_diff}"
            diff --side-by-side --suppress-common-lines "${target_diff}" "${head_diff}"
 		    return 1
 	    fi
 	    return 0
 	    ;;
    esac
    cover "${1-HEAD}"
 }
 bench() {
    branch="${1}"
    out="${2}"
    replace="${3}"
    dir="$(mktemp -d)"
    stderr "Executing benchmark for ${branch} at ${dir}"
    if [ "${branch}" = "HEAD" ]; then
    	cp -r . "${dir}/"
    else
 	    git worktree add "$dir" "$branch"
    fi
    pushd "$dir"
    if [ "${replace}" != "" ]; then
        find ./benchmark/ -iname '*.go' -exec sed -i -E "s|github.com/pelletier/go-toml/v2|${replace}|g" {} \;
        go get "${replace}"
    fi
    export GOMAXPROCS=2
    go test '-bench=^Benchmark(Un)?[mM]arshal' -count=10 -run=Nothing ./... | tee "${out}"
    popd
    if [ "${branch}" != "HEAD" ]; then
 	    git worktree remove --force "$dir"
    fi
 }
 fmktemp() {
    if mktemp --version &> /dev/null; then
 	# GNU
        mktemp --suffix=-$1
    else
 	# BSD
 	mktemp -t $1
    fi
 }
 benchstathtml() {
 python3 - $1 <<'EOF'
 import sys
 lines = []
 stop = False
 with open(sys.argv[1]) as f:
    for line in f.readlines():
        line = line.strip()
        if line == "":
            stop = True
        if not stop:
            lines.append(line.split(','))
 results = []
 for line in reversed(lines[2:]):
    if len(line) < 8 or line[0] == "":
        continue
    v2 = float(line[1])
    results.append([
        line[0].replace("-32", ""),
        "%.1fx" % (float(line[3])/v2),  # v1
        "%.1fx" % (float(line[7])/v2),  # bs
    ])
 # move geomean to the end
 results.append(results[0])
 del results[0]
 def printtable(data):
    print("""
 <table>
    <thead>
        <tr><th>Benchmark</th><th>go-toml v1</th><th>BurntSushi/toml</th></tr>
    </thead>
    <tbody>""")
    for r in data:
        print("        <tr><td>{}</td><td>{}</td><td>{}</td></tr>".format(*r))
    print("""     </tbody>
 </table>""")
 def match(x):
    return "ReferenceFile" in x[0] or "HugoFrontMatter" in x[0]
 above = [x for x in results if match(x)]
 below = [x for x in results if not match(x)]
 printtable(above)
 print("<details><summary>See more</summary>")
 print("""<p>The table above has the results of the most common use-cases. The table below
 contains the results of all benchmarks, including unrealistic ones. It is
 provided for completeness.</p>""")
 printtable(below)
 print('<p>This table can be generated with <code>./ci.sh benchmark -a -html</code>.</p>')
 print("</details>")
 EOF
 }
 benchmark() {
    case "$1" in
    -d)
        shift
     	target="${1?Need to provide a target branch argument}"
        old=`fmktemp ${target}`
        bench "${target}" "${old}"
        new=`fmktemp HEAD`
        bench HEAD "${new}"
        benchstat "${old}" "${new}"
        return 0
        ;;
    -a)
        shift
        v2stats=`fmktemp go-toml-v2`
        bench HEAD "${v2stats}" "github.com/pelletier/go-toml/v2"
        v1stats=`fmktemp go-toml-v1`
        bench HEAD "${v1stats}" "github.com/pelletier/go-toml"
        bsstats=`fmktemp bs-toml`
        bench HEAD "${bsstats}" "github.com/BurntSushi/toml"
        cp "${v2stats}" go-toml-v2.txt
        cp "${v1stats}" go-toml-v1.txt
        cp "${bsstats}" bs-toml.txt
        if [ "$1" = "-html" ]; then
            tmpcsv=`fmktemp csv`
            benchstat -format csv go-toml-v2.txt go-toml-v1.txt bs-toml.txt > $tmpcsv
            benchstathtml $tmpcsv
        else
            benchstat go-toml-v2.txt go-toml-v1.txt bs-toml.txt
        fi
        rm -f go-toml-v2.txt go-toml-v1.txt bs-toml.txt
        return $?
    esac
    bench "${1-HEAD}" `mktemp`
 }
 case "$1" in
    coverage) shift; coverage $@;;
    benchmark) shift; benchmark $@;;
    *) usage "bad argument $1";;
 esac
@@ -0,0 +1,31 @@
 // Package gotoml-test-decoder is a minimal decoder program used to compare this library with other TOML implementations.
 package main
 import (
 	"flag"
 	"log"
 	"os"
 	"path"
 	"github.com/pelletier/go-toml/v2/internal/testsuite"
 )
 func main() {
 	log.SetFlags(0)
 	flag.Usage = usage
 	flag.Parse()
 	if flag.NArg() != 0 {
 		flag.Usage()
 	}
 	err := testsuite.DecodeStdin()
 	if err != nil {
 		log.Fatal(err)
 	}
 }
 func usage() {
 	log.Printf("Usage: %s < toml-file\n", path.Base(os.Args[0]))
 	flag.PrintDefaults()
 	os.Exit(1)
 }
@@ -0,0 +1,31 @@
 // Package gotoml-test-encoder is a minimal encoder program used to compare this library with other TOML implementations.
 package main
 import (
 	"flag"
 	"log"
 	"os"
 	"path"
 	"github.com/pelletier/go-toml/v2/internal/testsuite"
 )
 func main() {
 	log.SetFlags(0)
 	flag.Usage = usage
 	flag.Parse()
 	if flag.NArg() != 0 {
 		flag.Usage()
 	}
 	err := testsuite.EncodeStdin()
 	if err != nil {
 		log.Fatal(err)
 	}
 }
 func usage() {
 	log.Printf("Usage: %s < json-file\n", path.Base(os.Args[0]))
 	flag.PrintDefaults()
 	os.Exit(1)
 }
@@ -0,0 +1,66 @@
 // Package jsontoml is a program that converts JSON to TOML.
 //
 // # Usage
 //
 // Reading from stdin:
 //
 //	cat file.json | jsontoml > file.toml
 //
 // Reading from a file:
 //
 //	jsontoml file.json > file.toml
 //
 // # Installation
 //
 // Using Go:
 //
 //	go install github.com/pelletier/go-toml/v2/cmd/jsontoml@latest
 package main
 import (
 	"encoding/json"
 	"flag"
 	"io"
 	"github.com/pelletier/go-toml/v2"
 	"github.com/pelletier/go-toml/v2/internal/cli"
 )
 const usage = `jsontoml can be used in two ways:
 Reading from stdin:
  cat file.json | jsontoml > file.toml
 Reading from a file:
  jsontoml file.json > file.toml
 `
 var useJSONNumber bool
 func main() {
 	flag.BoolVar(&useJSONNumber, "use-json-number", false, "unmarshal numbers into `json.Number` type instead of as `float64`")
 	p := cli.Program{
 		Usage: usage,
 		Fn:    convert,
 	}
 	p.Execute()
 }
 func convert(r io.Reader, w io.Writer) error {
 	var v interface{}
 	d := json.NewDecoder(r)
 	e := toml.NewEncoder(w)
 	if useJSONNumber {
 		d.UseNumber()
 		e.SetMarshalJSONNumbers(true)
 	}
 	err := d.Decode(&v)
 	if err != nil {
 		return err
 	}
 	return e.Encode(v)
 }
@@ -0,0 +1,62 @@
 package main
 import (
 	"bytes"
 	"strings"
 	"testing"
 	"github.com/pelletier/go-toml/v2/internal/assert"
 )
 func TestConvert(t *testing.T) {
 	examples := []struct {
 		name          string
 		input         string
 		expected      string
 		errors        bool
 		useJSONNumber bool
 	}{
 		{
 			name: "valid json",
 			input: `
 {
  "mytoml": {
    "a": 42
  }
 }`,
 			expected: `[mytoml]
 a = 42.0
 `,
 		},
 		{
 			name:          "use json number",
 			useJSONNumber: true,
 			input: `
 {
  "mytoml": {
    "a": 42
  }
 }`,
 			expected: `[mytoml]
 a = 42
 `,
 		},
 		{
 			name:   "invalid json",
 			input:  `{ foo`,
 			errors: true,
 		},
 	}
 	for _, e := range examples {
 		b := new(bytes.Buffer)
 		useJSONNumber = e.useJSONNumber
 		err := convert(strings.NewReader(e.input), b)
 		if e.errors {
 			assert.Error(t, err)
 		} else {
 			assert.NoError(t, err)
 			assert.Equal(t, e.expected, b.String())
 		}
 	}
 }
@@ -0,0 +1,63 @@
 // Package tomljson is a program that converts TOML to JSON.
 //
 // # Usage
 //
 // Reading from stdin:
 //
 //	cat file.toml | tomljson > file.json
 //
 // Reading from a file:
 //
 //	tomljson file.toml > file.json
 //
 // # Installation
 //
 // Using Go:
 //
 //	go install github.com/pelletier/go-toml/v2/cmd/tomljson@latest
 package main
 import (
 	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
 	"github.com/pelletier/go-toml/v2"
 	"github.com/pelletier/go-toml/v2/internal/cli"
 )
 const usage = `tomljson can be used in two ways:
 Reading from stdin:
  cat file.toml | tomljson > file.json
 Reading from a file:
  tomljson file.toml > file.json
 `
 func main() {
 	p := cli.Program{
 		Usage: usage,
 		Fn:    convert,
 	}
 	p.Execute()
 }
 func convert(r io.Reader, w io.Writer) error {
 	var v interface{}
 	d := toml.NewDecoder(r)
 	err := d.Decode(&v)
 	if err != nil {
 		var derr *toml.DecodeError
 		if errors.As(err, &derr) {
 			row, col := derr.Position()
 			return fmt.Errorf("%s\nerror occurred at row %d column %d", derr.String(), row, col)
 		}
 		return err
 	}
 	e := json.NewEncoder(w)
 	e.SetIndent("", "  ")
 	return e.Encode(v)
 }
@@ -0,0 +1,60 @@
 package main
 import (
 	"bytes"
 	"errors"
 	"io"
 	"strings"
 	"testing"
 	"github.com/pelletier/go-toml/v2/internal/assert"
 )
 func TestConvert(t *testing.T) {
 	examples := []struct {
 		name     string
 		input    io.Reader
 		expected string
 		errors   bool
 	}{
 		{
 			name: "valid toml",
 			input: strings.NewReader(`
 [mytoml]
 a = 42`),
 			expected: `{
  "mytoml": {
    "a": 42
  }
 }
 `,
 		},
 		{
 			name:   "invalid toml",
 			input:  strings.NewReader(`bad = []]`),
 			errors: true,
 		},
 		{
 			name:   "bad reader",
 			input:  &badReader{},
 			errors: true,
 		},
 	}
 	for _, e := range examples {
 		b := new(bytes.Buffer)
 		err := convert(e.input, b)
 		if e.errors {
 			assert.Error(t, err)
 		} else {
 			assert.NoError(t, err)
 			assert.Equal(t, e.expected, b.String())
 		}
 	}
 }
 type badReader struct{}
 func (r *badReader) Read([]byte) (int, error) {
 	return 0, errors.New("reader failed on purpose")
 }
@@ -0,0 +1,58 @@
 // Package tomll is a linter program for TOML.
 //
 // # Usage
 //
 // Reading from stdin, writing to stdout:
 //
 //	cat file.toml | tomll
 //
 // Reading and updating a list of files in place:
 //
 //	tomll a.toml b.toml c.toml
 //
 // # Installation
 //
 // Using Go:
 //
 //	go install github.com/pelletier/go-toml/v2/cmd/tomll@latest
 package main
 import (
 	"io"
 	"github.com/pelletier/go-toml/v2"
 	"github.com/pelletier/go-toml/v2/internal/cli"
 )
 const usage = `tomll can be used in two ways:
 Reading from stdin, writing to stdout:
  cat file.toml | tomll > file.toml
 Reading and updating a list of files in place:
  tomll a.toml b.toml c.toml
 When given a list of files, tomll will modify all files in place without asking.
 `
 func main() {
 	p := cli.Program{
 		Usage:   usage,
 		Fn:      convert,
 		Inplace: true,
 	}
 	p.Execute()
 }
 func convert(r io.Reader, w io.Writer) error {
 	var v interface{}
 	d := toml.NewDecoder(r)
 	err := d.Decode(&v)
 	if err != nil {
 		return err
 	}
 	e := toml.NewEncoder(w)
 	return e.Encode(v)
 }
@@ -0,0 +1,44 @@
 package main
 import (
 	"bytes"
 	"strings"
 	"testing"
 	"github.com/pelletier/go-toml/v2/internal/assert"
 )
 func TestConvert(t *testing.T) {
 	examples := []struct {
 		name     string
 		input    string
 		expected string
 		errors   bool
 	}{
 		{
 			name: "valid toml",
 			input: `
 mytoml.a = 42.0
 `,
 			expected: `[mytoml]
 a = 42.0
 `,
 		},
 		{
 			name:   "invalid toml",
 			input:  `[what`,
 			errors: true,
 		},
 	}
 	for _, e := range examples {
 		b := new(bytes.Buffer)
 		err := convert(strings.NewReader(e.input), b)
 		if e.errors {
 			assert.Error(t, err)
 		} else {
 			assert.NoError(t, err)
 			assert.Equal(t, e.expected, b.String())
 		}
 	}
 }
@@ -0,0 +1,183 @@
 // tomltestgen retrieves a given version of the language-agnostic TOML test suite in
 // https://github.com/BurntSushi/toml-test and generates go-toml unit tests.
 //
 // Within the go-toml package, run `go generate`.  Otherwise, use:
 //
 //	go run github.com/pelletier/go-toml/cmd/tomltestgen -o toml_testgen_test.go
 package main
 import (
 	"bytes"
 	"flag"
 	"fmt"
 	"go/format"
 	"log"
 	"os"
 	"path/filepath"
 	"strconv"
 	"strings"
 	"text/template"
 	"time"
 	"unicode"
 )
 type invalid struct {
 	Name  string
 	Input string
 }
 type valid struct {
 	Name    string
 	Input   string
 	JSONRef string
 }
 type testsCollection struct {
 	Ref       string
 	Timestamp string
 	Invalid   []invalid
 	Valid     []valid
 	Count     int
 }
 const srcTemplate = "// Code generated by tomltestgen for toml-test ref {{.Ref}} on {{.Timestamp}}. DO NOT EDIT.\n" +
 	"package toml_test\n" +
 	" import (\n" +
 	"	\"testing\"\n" +
 	")\n" +
 	"{{range .Invalid}}\n" +
 	"func TestTOMLTest_Invalid_{{.Name}}(t *testing.T) {\n" +
 	"	input := {{.Input|gostr}}\n" +
 	"	testgenInvalid(t, input)\n" +
 	"}\n" +
 	"{{end}}\n" +
 	"\n" +
 	"{{range .Valid}}\n" +
 	"func TestTOMLTest_Valid_{{.Name}}(t *testing.T) {\n" +
 	"   input := {{.Input|gostr}}\n" +
 	"   jsonRef := {{.JSONRef|gostr}}\n" +
 	"   testgenValid(t, input, jsonRef)\n" +
 	"}\n" +
 	"{{end}}\n"
 func kebabToCamel(kebab string) string {
 	var buf strings.Builder
 	nextUpper := true
 	for _, c := range kebab {
 		if nextUpper {
 			buf.WriteRune(unicode.ToUpper(c))
 			nextUpper = false
 		} else {
 			switch c {
 			case '-':
 				nextUpper = true
 			case '/':
 				nextUpper = true
 				buf.WriteByte('_')
 			default:
 				buf.WriteRune(c)
 			}
 		}
 	}
 	return buf.String()
 }
 func templateGoStr(input string) string {
 	return strconv.Quote(input)
 }
 var (
 	ref = flag.String("r", "master", "git reference")
 	out = flag.String("o", "", "output file")
 )
 func usage() {
 	_, _ = fmt.Fprintf(os.Stderr, "usage: tomltestgen [flags]\n")
 	flag.PrintDefaults()
 }
 func main() {
 	flag.Usage = usage
 	flag.Parse()
 	collection := testsCollection{
 		Ref:       *ref,
 		Timestamp: time.Now().Format(time.RFC3339),
 	}
 	dirContent, _ := filepath.Glob("tests/invalid/**/*.toml")
 	for _, f := range dirContent {
 		filename := strings.TrimPrefix(f, "tests/valid/")
 		name := kebabToCamel(strings.TrimSuffix(filename, ".toml"))
 		name = strings.ReplaceAll(name, ".", "_")
 		log.Printf("> [%s] %s\n", "invalid", name)
 		tomlContent, err := os.ReadFile(f) // #nosec G304
 		if err != nil {
 			fmt.Printf("failed to read test file: %s\n", err)
 			os.Exit(1)
 		}
 		collection.Invalid = append(collection.Invalid, invalid{
 			Name:  name,
 			Input: string(tomlContent),
 		})
 		collection.Count++
 	}
 	dirContent, _ = filepath.Glob("tests/valid/**/*.toml")
 	for _, f := range dirContent {
 		filename := strings.TrimPrefix(f, "tests/valid/")
 		name := kebabToCamel(strings.TrimSuffix(filename, ".toml"))
 		name = strings.ReplaceAll(name, ".", "_")
 		log.Printf("> [%s] %s\n", "valid", name)
 		tomlContent, err := os.ReadFile(f) // #nosec G304
 		if err != nil {
 			fmt.Printf("failed reading test file: %s\n", err)
 			os.Exit(1)
 		}
 		filename = strings.TrimSuffix(f, ".toml")
 		jsonContent, err := os.ReadFile(filename + ".json") // #nosec G304
 		if err != nil {
 			fmt.Printf("failed reading validation json: %s\n", err)
 			os.Exit(1)
 		}
 		collection.Valid = append(collection.Valid, valid{
 			Name:    name,
 			Input:   string(tomlContent),
 			JSONRef: string(jsonContent),
 		})
 		collection.Count++
 	}
 	log.Printf("Collected %d tests from toml-test\n", collection.Count)
 	funcMap := template.FuncMap{
 		"gostr": templateGoStr,
 	}
 	t := template.Must(template.New("src").Funcs(funcMap).Parse(srcTemplate))
 	buf := new(bytes.Buffer)
 	err := t.Execute(buf, collection)
 	if err != nil {
 		panic(err)
 	}
 	outputBytes, err := format.Source(buf.Bytes())
 	if err != nil {
 		panic(err)
 	}
 	if *out == "" {
 		fmt.Println(string(outputBytes))
 		return
 	}
 	err = os.WriteFile(*out, outputBytes, 0o600)
 	if err != nil {
 		panic(err)
 	}
 }
@@ -1,12 +1,12 @@
 package toml
 import (
 	"errors"
 	"fmt"
 	"math"
 	"strconv"
 	"strings"
 	"time"
 	"github.com/pelletier/go-toml/v2/unstable"
 )
 func parseInteger(b []byte) (int64, error) {
@@ -19,7 +19,7 @@ func parseInteger(b []byte) (int64, error) {
 		case 'o':
 			return parseIntOct(b)
 		default:
-			return 0, newDecodeError(b[1:2], "invalid base: '%c'", b[1])
+			panic(fmt.Errorf("invalid base '%c', should have been checked by scanIntOrFloat", b[1]))
 		}
 	}
@@ -34,41 +34,40 @@ func parseLocalDate(b []byte) (LocalDate, error) {
 	var date LocalDate
 	if len(b) != 10 || b[4] != '-' || b[7] != '-' {
-		return date, newDecodeError(b, "dates are expected to have the format YYYY-MM-DD")
+		return date, unstable.NewParserError(b, "dates are expected to have the format YYYY-MM-DD")
 	}
 	var err error
 	date.Year, err = parseDecimalDigits(b[0:4])
 	if err != nil {
-		return date, err
+		return LocalDate{}, err
 	}
-	v, err := parseDecimalDigits(b[5:7])
+	date.Month, err = parseDecimalDigits(b[5:7])
 	if err != nil {
-		return date, err
+		return LocalDate{}, err
 	}
 	date.Month = time.Month(v)
 	date.Day, err = parseDecimalDigits(b[8:10])
 	if err != nil {
-		return date, err
+		return LocalDate{}, err
 	}
 	if !isValidDate(date.Year, date.Month, date.Day) {
 		return LocalDate{}, unstable.NewParserError(b, "impossible date")
 	}
 	return date, nil
 }
 var errNotDigit = errors.New("not a digit")
 func parseDecimalDigits(b []byte) (int, error) {
 	v := 0
-	for _, c := range b {
+	for i, c := range b {
-		if !isDigit(c) {
+		if c < '0' || c > '9' {
-			return 0, fmt.Errorf("%s: %w", b, errNotDigit)
+			return 0, unstable.NewParserError(b[i:i+1], "expected digit (0-9)")
 		}
 		v *= 10
 		v += int(c - '0')
 	}
@@ -76,13 +75,12 @@ func parseDecimalDigits(b []byte) (int, error) {
 	return v, nil
 }
 var errParseDateTimeMissingInfo = errors.New("date-time missing timezone information")
 func parseDateTime(b []byte) (time.Time, error) {
 	// offset-date-time = full-date time-delim full-time
 	// full-time      = partial-time time-offset
 	// time-offset    = "Z" / time-numoffset
 	// time-numoffset = ( "+" / "-" ) time-hour ":" time-minute
 	dt, b, err := parseLocalDateTime(b)
 	if err != nil {
 		return time.Time{}, err
@@ -91,95 +89,115 @@ func parseDateTime(b []byte) (time.Time, error) {
 	var zone *time.Location
 	if len(b) == 0 {
-		return time.Time{}, errParseDateTimeMissingInfo
+		// parser should have checked that when assigning the date time node
 		panic("date time should have a timezone")
 	}
-	if b[0] == 'Z' {
+	if b[0] == 'Z' || b[0] == 'z' {
 		b = b[1:]
 		zone = time.UTC
 	} else {
 		const dateTimeByteLen = 6
 		if len(b) != dateTimeByteLen {
-			return time.Time{}, newDecodeError(b, "invalid date-time timezone")
+			return time.Time{}, unstable.NewParserError(b, "invalid date-time timezone")
 		}
-		direction := 1
+		var direction int
 		switch b[0] {
 		case '+':
 		case '-':
 			direction = -1
 		case '+':
 			direction = +1
 		default:
-			return time.Time{}, newDecodeError(b[0:1], "invalid timezone offset character")
+			return time.Time{}, unstable.NewParserError(b[:1], "invalid timezone offset character")
 		}
 		if b[3] != ':' {
 			return time.Time{}, unstable.NewParserError(b[3:4], "expected a : separator")
 		}
 		hours, err := parseDecimalDigits(b[1:3])
 		if err != nil {
 			return time.Time{}, err
 		}
 		if hours > 23 {
 			return time.Time{}, unstable.NewParserError(b[:1], "invalid timezone offset hours")
 		}
 		minutes, err := parseDecimalDigits(b[4:6])
 		if err != nil {
 			return time.Time{}, err
 		}
 		if minutes > 59 {
 			return time.Time{}, unstable.NewParserError(b[:1], "invalid timezone offset minutes")
 		}
 		hours := digitsToInt(b[1:3])
 		minutes := digitsToInt(b[4:6])
 		seconds := direction * (hours*3600 + minutes*60)
-		zone = time.FixedZone("", seconds)
+		if seconds == 0 {
 			zone = time.UTC
 		} else {
 			zone = time.FixedZone("", seconds)
 		}
 		b = b[dateTimeByteLen:]
 	}
 	if len(b) > 0 {
-		return time.Time{}, newDecodeError(b, "extra bytes at the end of the timezone")
+		return time.Time{}, unstable.NewParserError(b, "extra bytes at the end of the timezone")
 	}
 	t := time.Date(
-		dt.Date.Year,
+		dt.Year,
-		dt.Date.Month,
+		time.Month(dt.Month),
-		dt.Date.Day,
+		dt.Day,
-		dt.Time.Hour,
+		dt.Hour,
-		dt.Time.Minute,
+		dt.Minute,
-		dt.Time.Second,
+		dt.Second,
-		dt.Time.Nanosecond,
+		dt.Nanosecond,
 		zone)
 	return t, nil
 }
 var (
 	errParseLocalDateTimeWrongLength = errors.New(
 		"local datetimes are expected to have the format YYYY-MM-DDTHH:MM:SS[.NNNNNN]",
 	)
 	errParseLocalDateTimeWrongSeparator = errors.New("datetime separator is expected to be T or a space")
 )
 func parseLocalDateTime(b []byte) (LocalDateTime, []byte, error) {
 	var dt LocalDateTime
-	const localDateTimeByteLen = 11
+	const localDateTimeByteMinLen = 11
-	if len(b) < localDateTimeByteLen {
+	if len(b) < localDateTimeByteMinLen {
-		return dt, nil, errParseLocalDateTimeWrongLength
+		return dt, nil, unstable.NewParserError(b, "local datetimes are expected to have the format YYYY-MM-DDTHH:MM:SS[.NNNNNNNNN]")
 	}
 	date, err := parseLocalDate(b[:10])
 	if err != nil {
 		return dt, nil, err
 	}
-	dt.Date = date
+	dt.LocalDate = date
 	sep := b[10]
-	if sep != 'T' && sep != ' ' {
+	if sep != 'T' && sep != ' ' && sep != 't' {
-		return dt, nil, errParseLocalDateTimeWrongSeparator
+		return dt, nil, unstable.NewParserError(b[10:11], "datetime separator is expected to be T or a space")
 	}
 	t, rest, err := parseLocalTime(b[11:])
 	if err != nil {
 		return dt, nil, err
 	}
-	dt.Time = t
+	dt.LocalTime = t
 	return dt, rest, nil
 }
 var errParseLocalTimeWrongLength = errors.New("times are expected to have the format HH:MM:SS[.NNNNNN]")
 // parseLocalTime is a bit different because it also returns the remaining
 // []byte that is didn't need. This is to allow parseDateTime to parse those
 // remaining bytes as a timezone.
 func parseLocalTime(b []byte) (LocalTime, []byte, error) {
-	var t LocalTime
+	var (
 		nspow = [10]int{0, 1e8, 1e7, 1e6, 1e5, 1e4, 1e3, 1e2, 1e1, 1e0}
 		t     LocalTime
 	)
 	// check if b matches to have expected format HH:MM:SS[.NNNNNN]
 	const localTimeByteLen = 8
 	if len(b) < localTimeByteLen {
-		return t, nil, errParseLocalTimeWrongLength
+		return t, nil, unstable.NewParserError(b, "times are expected to have the format HH:MM:SS[.NNNNNN]")
 	}
 	var err error
@@ -189,17 +207,22 @@ func parseLocalTime(b []byte) (LocalTime, []byte, error) {
 		return t, nil, err
 	}
 	if t.Hour > 23 {
 		return t, nil, unstable.NewParserError(b[0:2], "hour cannot be greater 23")
 	}
 	if b[2] != ':' {
-		return t, nil, newDecodeError(b[2:3], "expecting colon between hours and minutes")
+		return t, nil, unstable.NewParserError(b[2:3], "expecting colon between hours and minutes")
 	}
 	t.Minute, err = parseDecimalDigits(b[3:5])
 	if err != nil {
 		return t, nil, err
 	}
-
+	if t.Minute > 59 {
 		return t, nil, unstable.NewParserError(b[3:5], "minutes cannot be greater 59")
 	}
 	if b[5] != ':' {
-		return t, nil, newDecodeError(b[5:6], "expecting colon between minutes and seconds")
+		return t, nil, unstable.NewParserError(b[5:6], "expecting colon between minutes and seconds")
 	}
 	t.Second, err = parseDecimalDigits(b[6:8])
@@ -207,175 +230,320 @@ func parseLocalTime(b []byte) (LocalTime, []byte, error) {
 		return t, nil, err
 	}
-	if len(b) >= 15 && b[8] == '.' {
+	if t.Second > 59 {
-		t.Nanosecond, err = parseDecimalDigits(b[9:15])
+		return t, nil, unstable.NewParserError(b[6:8], "seconds cannot be greater than 59")
 		if err != nil {
 			return t, nil, err
 		}
 		return t, b[15:], nil
 	}
-	return t, b[8:], nil
+	b = b[8:]
 	if len(b) >= 1 && b[0] == '.' {
 		frac := 0
 		precision := 0
 		digits := 0
 		for i, c := range b[1:] {
 			if !isDigit(c) {
 				if i == 0 {
 					return t, nil, unstable.NewParserError(b[0:1], "need at least one digit after fraction point")
 				}
 				break
 			}
 			digits++
 			const maxFracPrecision = 9
 			if i >= maxFracPrecision {
 				// go-toml allows decoding fractional seconds
 				// beyond the supported precision of 9
 				// digits. It truncates the fractional component
 				// to the supported precision and ignores the
 				// remaining digits.
 				//
 				// https://github.com/pelletier/go-toml/discussions/707
 				continue
 			}
 			frac *= 10
 			frac += int(c - '0')
 			precision++
 		}
 		if precision == 0 {
 			return t, nil, unstable.NewParserError(b[:1], "nanoseconds need at least one digit")
 		}
 		t.Nanosecond = frac * nspow[precision]
 		t.Precision = precision
 		return t, b[1+digits:], nil
 	}
 	return t, b, nil
 }
 var (
 	errParseFloatStartDot = errors.New("float cannot start with a dot")
 	errParseFloatEndDot   = errors.New("float cannot end with a dot")
 )
 //nolint:cyclop
 func parseFloat(b []byte) (float64, error) {
 	//nolint:godox
 	// TODO: inefficient
 	if len(b) == 4 && (b[0] == '+' || b[0] == '-') && b[1] == 'n' && b[2] == 'a' && b[3] == 'n' {
 		return math.NaN(), nil
 	}
-	tok := string(b)
+	cleaned, err := checkAndRemoveUnderscoresFloats(b)
 	err := numberContainsInvalidUnderscore(tok)
 	if err != nil {
 		return 0, err
 	}
-	cleanedVal := cleanupNumberToken(tok)
+	if cleaned[0] == '.' {
-	if cleanedVal[0] == '.' {
+		return 0, unstable.NewParserError(b, "float cannot start with a dot")
 		return 0, errParseFloatStartDot
 	}
-	if cleanedVal[len(cleanedVal)-1] == '.' {
+	if cleaned[len(cleaned)-1] == '.' {
-		return 0, errParseFloatEndDot
+		return 0, unstable.NewParserError(b, "float cannot end with a dot")
 	}
-	f, err := strconv.ParseFloat(cleanedVal, 64)
+	dotAlreadySeen := false
 	for i, c := range cleaned {
 		if c == '.' {
 			if dotAlreadySeen {
 				return 0, unstable.NewParserError(b[i:i+1], "float can have at most one decimal point")
 			}
 			if !isDigit(cleaned[i-1]) {
 				return 0, unstable.NewParserError(b[i-1:i+1], "float decimal point must be preceded by a digit")
 			}
 			if !isDigit(cleaned[i+1]) {
 				return 0, unstable.NewParserError(b[i:i+2], "float decimal point must be followed by a digit")
 			}
 			dotAlreadySeen = true
 		}
 	}
 	start := 0
 	if cleaned[0] == '+' || cleaned[0] == '-' {
 		start = 1
 	}
 	if cleaned[start] == '0' && len(cleaned) > start+1 && isDigit(cleaned[start+1]) {
 		return 0, unstable.NewParserError(b, "float integer part cannot have leading zeroes")
 	}
 	f, err := strconv.ParseFloat(string(cleaned), 64)
 	if err != nil {
-		return 0, fmt.Errorf("coudn't ParseFloat %w", err)
+		return 0, unstable.NewParserError(b, "unable to parse float: %w", err)
 	}
 	return f, nil
 }
 func parseIntHex(b []byte) (int64, error) {
-	tok := string(b)
+	cleaned, err := checkAndRemoveUnderscoresIntegers(b[2:])
 	cleanedVal := cleanupNumberToken(tok)
 	err := hexNumberContainsInvalidUnderscore(cleanedVal)
 	if err != nil {
 		return 0, err
 	}
-	i, err := strconv.ParseInt(cleanedVal[2:], 16, 64)
+	i, err := strconv.ParseInt(string(cleaned), 16, 64)
 	if err != nil {
-		return 0, fmt.Errorf("coudn't ParseIntHex %w", err)
+		return 0, unstable.NewParserError(b, "couldn't parse hexadecimal number: %w", err)
 	}
 	return i, nil
 }
 func parseIntOct(b []byte) (int64, error) {
-	tok := string(b)
+	cleaned, err := checkAndRemoveUnderscoresIntegers(b[2:])
 	cleanedVal := cleanupNumberToken(tok)
 	err := numberContainsInvalidUnderscore(cleanedVal)
 	if err != nil {
 		return 0, err
 	}
-	i, err := strconv.ParseInt(cleanedVal[2:], 8, 64)
+	i, err := strconv.ParseInt(string(cleaned), 8, 64)
 	if err != nil {
-		return 0, fmt.Errorf("coudn't ParseIntOct %w", err)
+		return 0, unstable.NewParserError(b, "couldn't parse octal number: %w", err)
 	}
 	return i, nil
 }
 func parseIntBin(b []byte) (int64, error) {
-	tok := string(b)
+	cleaned, err := checkAndRemoveUnderscoresIntegers(b[2:])
 	cleanedVal := cleanupNumberToken(tok)
 	err := numberContainsInvalidUnderscore(cleanedVal)
 	if err != nil {
 		return 0, err
 	}
-	i, err := strconv.ParseInt(cleanedVal[2:], 2, 64)
+	i, err := strconv.ParseInt(string(cleaned), 2, 64)
 	if err != nil {
-		return 0, fmt.Errorf("coudn't ParseIntBin %w", err)
+		return 0, unstable.NewParserError(b, "couldn't parse binary number: %w", err)
 	}
 	return i, nil
 }
 func isSign(b byte) bool {
 	return b == '+' || b == '-'
 }
 func parseIntDec(b []byte) (int64, error) {
-	tok := string(b)
+	cleaned, err := checkAndRemoveUnderscoresIntegers(b)
 	cleanedVal := cleanupNumberToken(tok)
 	err := numberContainsInvalidUnderscore(cleanedVal)
 	if err != nil {
 		return 0, err
 	}
-	i, err := strconv.ParseInt(cleanedVal, 10, 64)
+	startIdx := 0
 	if isSign(cleaned[0]) {
 		startIdx++
 	}
 	if len(cleaned) > startIdx+1 && cleaned[startIdx] == '0' {
 		return 0, unstable.NewParserError(b, "leading zero not allowed on decimal number")
 	}
 	i, err := strconv.ParseInt(string(cleaned), 10, 64)
 	if err != nil {
-		return 0, fmt.Errorf("coudn't parseIntDec %w", err)
+		return 0, unstable.NewParserError(b, "couldn't parse decimal number: %w", err)
 	}
 	return i, nil
 }
-func numberContainsInvalidUnderscore(value string) error {
+func checkAndRemoveUnderscoresIntegers(b []byte) ([]byte, error) {
-	// For large numbers, you may use underscores between digits to enhance
+	start := 0
-	// readability. Each underscore must be surrounded by at least one digit on
+	if b[start] == '+' || b[start] == '-' {
-	// each side.
+		start++
 	hasBefore := false
 	for idx, r := range value {
 		if r == '_' {
 			if !hasBefore || idx+1 >= len(value) {
 				// can't end with an underscore
 				return errInvalidUnderscore
 			}
 		}
 		hasBefore = isDigitRune(r)
 	}
-	return nil
+	if len(b) == start {
-}
+		return b, nil
 func hexNumberContainsInvalidUnderscore(value string) error {
 	hasBefore := false
 	for idx, r := range value {
 		if r == '_' {
 			if !hasBefore || idx+1 >= len(value) {
 				// can't end with an underscore
 				return errInvalidUnderscoreHex
 			}
 		}
 		hasBefore = isHexDigit(r)
 	}
-	return nil
+	if b[start] == '_' {
 		return nil, unstable.NewParserError(b[start:start+1], "number cannot start with underscore")
 	}
 	if b[len(b)-1] == '_' {
 		return nil, unstable.NewParserError(b[len(b)-1:], "number cannot end with underscore")
 	}
 	// fast path
 	i := 0
 	for ; i < len(b); i++ {
 		if b[i] == '_' {
 			break
 		}
 	}
 	if i == len(b) {
 		return b, nil
 	}
 	before := false
 	cleaned := make([]byte, i, len(b))
 	copy(cleaned, b)
 	for i++; i < len(b); i++ {
 		c := b[i]
 		if c == '_' {
 			if !before {
 				return nil, unstable.NewParserError(b[i-1:i+1], "number must have at least one digit between underscores")
 			}
 			before = false
 		} else {
 			before = true
 			cleaned = append(cleaned, c)
 		}
 	}
 	return cleaned, nil
 }
-func cleanupNumberToken(value string) string {
+func checkAndRemoveUnderscoresFloats(b []byte) ([]byte, error) {
-	cleanedVal := strings.ReplaceAll(value, "_", "")
+	if b[0] == '_' {
 		return nil, unstable.NewParserError(b[0:1], "number cannot start with underscore")
 	}
-	return cleanedVal
+	if b[len(b)-1] == '_' {
 		return nil, unstable.NewParserError(b[len(b)-1:], "number cannot end with underscore")
 	}
 	// fast path
 	i := 0
 	for ; i < len(b); i++ {
 		if b[i] == '_' {
 			break
 		}
 	}
 	if i == len(b) {
 		return b, nil
 	}
 	before := false
 	cleaned := make([]byte, 0, len(b))
 	for i := 0; i < len(b); i++ {
 		c := b[i]
 		switch c {
 		case '_':
 			if !before {
 				return nil, unstable.NewParserError(b[i-1:i+1], "number must have at least one digit between underscores")
 			}
 			if i < len(b)-1 && (b[i+1] == 'e' || b[i+1] == 'E') {
 				return nil, unstable.NewParserError(b[i+1:i+2], "cannot have underscore before exponent")
 			}
 			before = false
 		case '+', '-':
 			// signed exponents
 			cleaned = append(cleaned, c)
 			before = false
 		case 'e', 'E':
 			if i < len(b)-1 && b[i+1] == '_' {
 				return nil, unstable.NewParserError(b[i+1:i+2], "cannot have underscore after exponent")
 			}
 			cleaned = append(cleaned, c)
 		case '.':
 			if i < len(b)-1 && b[i+1] == '_' {
 				return nil, unstable.NewParserError(b[i+1:i+2], "cannot have underscore after decimal point")
 			}
 			if i > 0 && b[i-1] == '_' {
 				return nil, unstable.NewParserError(b[i-1:i], "cannot have underscore before decimal point")
 			}
 			cleaned = append(cleaned, c)
 		default:
 			before = true
 			cleaned = append(cleaned, c)
 		}
 	}
 	return cleaned, nil
 }
-func isHexDigit(r rune) bool {
+// isValidDate checks if a provided date is a date that exists.
-	return isDigitRune(r) ||
+func isValidDate(year int, month int, day int) bool {
-		(r >= 'a' && r <= 'f') ||
+	return month > 0 && month < 13 && day > 0 && day <= daysIn(month, year)
 		(r >= 'A' && r <= 'F')
 }
-func isDigitRune(r rune) bool {
+// daysBefore[m] counts the number of days in a non-leap year
 // before month m begins. There is an entry for m=12, counting
 // the number of days before January of next year (365).
 var daysBefore = [...]int32{
 	0,
 	31,
 	31 + 28,
 	31 + 28 + 31,
 	31 + 28 + 31 + 30,
 	31 + 28 + 31 + 30 + 31,
 	31 + 28 + 31 + 30 + 31 + 30,
 	31 + 28 + 31 + 30 + 31 + 30 + 31,
 	31 + 28 + 31 + 30 + 31 + 30 + 31 + 31,
 	31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30,
 	31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31,
 	31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30,
 	31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30 + 31,
 }
 func daysIn(m int, year int) int {
 	if m == 2 && isLeap(year) {
 		return 29
 	}
 	return int(daysBefore[m] - daysBefore[m-1])
 }
 func isLeap(year int) bool {
 	return year%4 == 0 && (year%100 != 0 || year%400 == 0)
 }
 func isDigit(r byte) bool {
 	return r >= '0' && r <= '9'
 }
 var (
 	errInvalidUnderscore    = errors.New("invalid use of _ in number")
 	errInvalidUnderscoreHex = errors.New("invalid use of _ in hex number")
 )
@@ -0,0 +1,2 @@
 // Package toml is a library to read and write TOML documents.
 package toml
@@ -2,10 +2,11 @@ package toml
 import (
 	"fmt"
 	"reflect"
 	"strconv"
 	"strings"
-	"github.com/pelletier/go-toml/v2/internal/unsafe"
+	"github.com/pelletier/go-toml/v2/unstable"
 )
 // DecodeError represents an error encountered during the parsing or decoding
@@ -27,13 +28,13 @@ type DecodeError struct {
 // corresponding field in the target value. It contains all the missing fields
 // in Errors.
 //
-// Emitted by Decoder when SetStrict(true) was called.
+// Emitted by Decoder when DisallowUnknownFields() was called.
 type StrictMissingError struct {
 	// One error per field that could not be found.
 	Errors []DecodeError
 }
-// Error returns the cannonical string for this error.
+// Error returns the canonical string for this error.
 func (s *StrictMissingError) Error() string {
 	return "strict mode: fields in the document are missing in the target struct"
 }
@@ -41,39 +42,35 @@ func (s *StrictMissingError) Error() string {
 // String returns a human readable description of all errors.
 func (s *StrictMissingError) String() string {
 	var buf strings.Builder
 	for i, e := range s.Errors {
 		if i > 0 {
 			buf.WriteString("\n---\n")
 		}
 		buf.WriteString(e.String())
 	}
 	return buf.String()
 }
-type Key []string
+// Unwrap returns wrapped decode errors
-
+//
-// internal version of DecodeError that is used as the base to create a
+// Implements errors.Join() interface.
-// DecodeError with full context.
+func (s *StrictMissingError) Unwrap() []error {
-type decodeError struct {
+	errs := make([]error, len(s.Errors))
-	highlight []byte
+	for i := range s.Errors {
-	message   string
+		errs[i] = &s.Errors[i]
 	key       Key // optional
 }
 func (de *decodeError) Error() string {
 	return de.message
 }
 func newDecodeError(highlight []byte, format string, args ...interface{}) error {
 	return &decodeError{
 		highlight: highlight,
 		message:   fmt.Sprintf(format, args...),
 	}
 	return errs
 }
 // Key represents a TOML key as a sequence of key parts.
 type Key []string
 // Error returns the error message contained in the DecodeError.
 func (e *DecodeError) Error() string {
-	return e.message
+	return "toml: " + e.message
 }
 // String returns the human-readable contextualized error. This string is multi-line.
@@ -87,35 +84,34 @@ func (e *DecodeError) Position() (row int, column int) {
 	return e.line, e.column
 }
-// Key that was being processed when the error occured.
+// Key that was being processed when the error occurred. The key is present only
 // if this DecodeError is part of a StrictMissingError.
 func (e *DecodeError) Key() Key {
 	return e.key
 }
-// decodeErrorFromHighlight creates a DecodeError referencing to a highlighted
+// wrapDecodeError creates a DecodeError referencing a highlighted
 // range of bytes from document.
 //
 // highlight needs to be a sub-slice of document, or this function panics.
 //
 // The function copies all bytes used in DecodeError, so that document and
 // highlight can be freely deallocated.
 //
 //nolint:funlen
-func wrapDecodeError(document []byte, de *decodeError) *DecodeError {
+func wrapDecodeError(document []byte, de *unstable.ParserError) *DecodeError {
-	if de == nil {
+	offset := subsliceOffset(document, de.Highlight)
 		return nil
 	}
-	offset := unsafe.SubsliceOffset(document, de.highlight)
+	errMessage := de.Error()
 	errMessage := de.message
 	errLine, errColumn := positionAtEnd(document[:offset])
-	before, after := linesOfContext(document, de.highlight, offset, 3)
+	before, after := linesOfContext(document, de.Highlight, offset, 3)
 	var buf strings.Builder
 	maxLine := errLine + len(after) - 1
 	lineColumnWidth := len(strconv.Itoa(maxLine))
 	// Write the lines of context strictly before the error.
 	for i := len(before) - 1; i > 0; i-- {
 		line := errLine - i
 		buf.WriteString(formatLineNumber(line, lineColumnWidth))
@@ -129,6 +125,8 @@ func wrapDecodeError(document []byte, de *decodeError) *DecodeError {
 		buf.WriteRune('\n')
 	}
 	// Write the document line that contains the error.
 	buf.WriteString(formatLineNumber(errLine, lineColumnWidth))
 	buf.WriteString("| ")
@@ -136,13 +134,17 @@ func wrapDecodeError(document []byte, de *decodeError) *DecodeError {
 		buf.Write(before[0])
 	}
-	buf.Write(de.highlight)
+	buf.Write(de.Highlight)
 	if len(after) > 0 {
 		buf.Write(after[0])
 	}
 	buf.WriteRune('\n')
 	// Write the line with the error message itself (so it does not have a line
 	// number).
 	buf.WriteString(strings.Repeat(" ", lineColumnWidth))
 	buf.WriteString("| ")
@@ -150,13 +152,15 @@ func wrapDecodeError(document []byte, de *decodeError) *DecodeError {
 		buf.WriteString(strings.Repeat(" ", len(before[0])))
 	}
-	buf.WriteString(strings.Repeat("~", len(de.highlight)))
+	buf.WriteString(strings.Repeat("~", len(de.Highlight)))
 	if len(errMessage) > 0 {
 		buf.WriteString(" ")
 		buf.WriteString(errMessage)
 	}
 	// Write the lines of context strictly after the error.
 	for i := 1; i < len(after); i++ {
 		buf.WriteRune('\n')
 		line := errLine + i
@@ -173,7 +177,7 @@ func wrapDecodeError(document []byte, de *decodeError) *DecodeError {
 		message: errMessage,
 		line:    errLine,
 		column:  errColumn,
-		key:     de.key,
+		key:     de.Key,
 		human:   buf.String(),
 	}
 }
@@ -230,7 +234,7 @@ forward:
 			rest = rest[o+1:]
 			o = 0
-		case o == len(rest)-1 && o > 0:
+		case o == len(rest)-1:
 			// add last line only if it's non-empty
 			afterLines = append(afterLines, rest)
@@ -256,5 +260,24 @@ func positionAtEnd(b []byte) (row int, column int) {
 		}
 	}
-	return
+	return row, column
 }
 // subsliceOffset returns the byte offset of subslice within data.
 // subslice must share the same backing array as data.
 func subsliceOffset(data []byte, subslice []byte) int {
 	if len(subslice) == 0 {
 		return 0
 	}
 	// Use reflect to get the data pointers of both slices.
 	// This is safe because we're only reading the pointer values for comparison.
 	dataPtr := reflect.ValueOf(data).Pointer()
 	subPtr := reflect.ValueOf(subslice).Pointer()
 	offset := int(subPtr - dataPtr)
 	if offset < 0 || offset > len(data) {
 		panic("subslice is not within data")
 	}
 	return offset
 }
@@ -3,16 +3,16 @@ package toml
 import (
 	"bytes"
 	"errors"
 	"fmt"
 	"strings"
 	"testing"
-	"github.com/stretchr/testify/assert"
+	"github.com/pelletier/go-toml/v2/internal/assert"
 	"github.com/pelletier/go-toml/v2/unstable"
 )
 //nolint:funlen
 func TestDecodeError(t *testing.T) {
 	t.Parallel()
 	examples := []struct {
 		desc     string
 		doc      [3]string
@@ -148,24 +148,30 @@ line 5`,
 6|
 7| line 4`,
 		},
 		{
 			desc: "handle remainder of the error line when there is only one line",
 			doc:  [3]string{`P=`, `[`, `#`},
 			msg:  "array is incomplete",
 			expected: `1| P=[#
 |   ~ array is incomplete`,
 		},
 	}
 	for _, e := range examples {
 		e := e
 		t.Run(e.desc, func(t *testing.T) {
 			t.Parallel()
 			b := bytes.Buffer{}
-			b.Write([]byte(e.doc[0]))
+			b.WriteString(e.doc[0])
 			start := b.Len()
-			b.Write([]byte(e.doc[1]))
+			b.WriteString(e.doc[1])
 			end := b.Len()
-			b.Write([]byte(e.doc[2]))
+			b.WriteString(e.doc[2])
 			doc := b.Bytes()
 			hl := doc[start:end]
-			err := wrapDecodeError(doc, &decodeError{
+			err := wrapDecodeError(doc, &unstable.ParserError{
-				highlight: hl,
+				Highlight: hl,
-				message:   e.msg,
+				Message:   e.msg,
 			})
 			var derr *DecodeError
@@ -179,3 +185,133 @@ line 5`,
 		})
 	}
 }
 func TestDecodeError_Accessors(t *testing.T) {
 	e := DecodeError{
 		message: "foo",
 		line:    1,
 		column:  2,
 		key:     []string{"one", "two"},
 		human:   "bar",
 	}
 	assert.Equal(t, "toml: foo", e.Error())
 	r, c := e.Position()
 	assert.Equal(t, 1, r)
 	assert.Equal(t, 2, c)
 	assert.Equal(t, Key{"one", "two"}, e.Key())
 	assert.Equal(t, "bar", e.String())
 }
 func TestDecodeError_DuplicateContent(t *testing.T) {
 	// This test verifies that when the same content appears multiple times
 	// in the document, the error correctly points to the actual location
 	// of the error, not the first occurrence of the content.
 	//
 	// The document has "1__2" on line 1 and "3__4" on line 2.
 	// Both have "__" which is invalid, but we want to ensure errors
 	// on line 2 report line 2, not line 1.
 	doc := `a = 1
 b = 3__4`
 	var v map[string]int
 	err := Unmarshal([]byte(doc), &v)
 	var derr *DecodeError
 	if !errors.As(err, &derr) {
 		t.Fatal("error not in expected format")
 	}
 	row, col := derr.Position()
 	// The error should be on line 2 where "3__4" is
 	if row != 2 {
 		t.Errorf("expected error on row 2, got row %d", row)
 	}
 	// Column should point to the "__" part (after "3")
 	if col < 5 {
 		t.Errorf("expected error at column >= 5, got column %d", col)
 	}
 }
 func TestDecodeError_Position(t *testing.T) {
 	// Test that error positions are correctly reported for various error locations
 	examples := []struct {
 		name        string
 		doc         string
 		expectedRow int
 		minCol      int
 	}{
 		{
 			name:        "error on first line",
 			doc:         `a = 1__2`,
 			expectedRow: 1,
 			minCol:      5,
 		},
 		{
 			name:        "error on second line",
 			doc:         "a = 1\nb = 2__3",
 			expectedRow: 2,
 			minCol:      5,
 		},
 		{
 			name:        "error on third line",
 			doc:         "a = 1\nb = 2\nc = 3__4",
 			expectedRow: 3,
 			minCol:      5,
 		},
 	}
 	for _, e := range examples {
 		t.Run(e.name, func(t *testing.T) {
 			var v map[string]int
 			err := Unmarshal([]byte(e.doc), &v)
 			var derr *DecodeError
 			if !errors.As(err, &derr) {
 				t.Fatal("error not in expected format")
 			}
 			row, col := derr.Position()
 			assert.Equal(t, e.expectedRow, row)
 			if col < e.minCol {
 				t.Errorf("expected column >= %d, got %d", e.minCol, col)
 			}
 		})
 	}
 }
 func TestStrictErrorUnwrap(t *testing.T) {
 	fo := bytes.NewBufferString(`
 Missing = 1
 OtherMissing = 1
 `)
 	var out struct{}
 	err := NewDecoder(fo).DisallowUnknownFields().Decode(&out)
 	assert.Error(t, err)
 	strictErr := &StrictMissingError{}
 	assert.True(t, errors.As(err, &strictErr))
 	assert.Equal(t, 2, len(strictErr.Unwrap()))
 }
 func ExampleDecodeError() {
 	doc := `name = 123__456`
 	s := map[string]interface{}{}
 	err := Unmarshal([]byte(doc), &s)
 	fmt.Println(err)
 	var derr *DecodeError
 	if errors.As(err, &derr) {
 		fmt.Println(derr.String())
 		row, col := derr.Position()
 		fmt.Println("error occurred at row", row, "column", col)
 	}
 	// Output:
 	// toml: number must have at least one digit between underscores
 	// 1| name = 123__456
 	//  |           ~~ number must have at least one digit between underscores
 	// error occurred at row 1 column 11
 }
@@ -0,0 +1,37 @@
 package toml_test
 import (
 	"fmt"
 	"log"
 	"strconv"
 	"github.com/pelletier/go-toml/v2"
 )
 type customInt int
 func (i *customInt) UnmarshalText(b []byte) error {
 	x, err := strconv.ParseInt(string(b), 10, 32)
 	if err != nil {
 		return err
 	}
 	*i = customInt(x * 100)
 	return nil
 }
 type doc struct {
 	Value customInt
 }
 func ExampleUnmarshal_textUnmarshal() {
 	var x doc
 	data := []byte(`value  = "42"`)
 	err := toml.Unmarshal(data, &x)
 	if err != nil {
 		log.Fatal(err)
 	}
 	fmt.Println(x)
 	// Output:
 	// {4200}
 }
@@ -0,0 +1,107 @@
 package toml_test
 import (
 	"testing"
 	"github.com/pelletier/go-toml/v2"
 	"github.com/pelletier/go-toml/v2/internal/assert"
 )
 func TestFastSimpleInt(t *testing.T) {
 	m := map[string]int64{}
 	err := toml.Unmarshal([]byte(`a = 42`), &m)
 	assert.NoError(t, err)
 	assert.Equal(t, map[string]int64{"a": 42}, m)
 }
 func TestFastSimpleFloat(t *testing.T) {
 	m := map[string]float64{}
 	err := toml.Unmarshal([]byte("a = 42\nb = 1.1\nc = 12341234123412341234123412341234"), &m)
 	assert.NoError(t, err)
 	assert.Equal(t, map[string]float64{"a": 42, "b": 1.1, "c": 1.2341234123412342e+31}, m)
 }
 func TestFastSimpleString(t *testing.T) {
 	m := map[string]string{}
 	err := toml.Unmarshal([]byte(`a = "hello"`), &m)
 	assert.NoError(t, err)
 	assert.Equal(t, map[string]string{"a": "hello"}, m)
 }
 func TestFastSimpleInterface(t *testing.T) {
 	m := map[string]interface{}{}
 	err := toml.Unmarshal([]byte(`
 	a = "hello"
 	b = 42`), &m)
 	assert.NoError(t, err)
 	assert.Equal(t, map[string]interface{}{
 		"a": "hello",
 		"b": int64(42),
 	}, m)
 }
 func TestFastMultipartKeyInterface(t *testing.T) {
 	m := map[string]interface{}{}
 	err := toml.Unmarshal([]byte(`
 	a.interim = "test"
 	a.b.c = "hello"
 	b = 42`), &m)
 	assert.NoError(t, err)
 	assert.Equal(t, map[string]interface{}{
 		"a": map[string]interface{}{
 			"interim": "test",
 			"b": map[string]interface{}{
 				"c": "hello",
 			},
 		},
 		"b": int64(42),
 	}, m)
 }
 func TestFastExistingMap(t *testing.T) {
 	m := map[string]interface{}{
 		"ints": map[string]int{},
 	}
 	err := toml.Unmarshal([]byte(`
 	ints.one = 1
 	ints.two = 2
 	strings.yo = "hello"`), &m)
 	assert.NoError(t, err)
 	assert.Equal(t, map[string]interface{}{
 		"ints": map[string]interface{}{
 			"one": int64(1),
 			"two": int64(2),
 		},
 		"strings": map[string]interface{}{
 			"yo": "hello",
 		},
 	}, m)
 }
 func TestFastArrayTable(t *testing.T) {
 	b := []byte(`
 	[root]
 	[[root.nested]]
 	name = 'Bob'
 	[[root.nested]]
 	name = 'Alice'
 	`)
 	m := map[string]interface{}{}
 	err := toml.Unmarshal(b, &m)
 	assert.NoError(t, err)
 	assert.Equal(t, map[string]interface{}{
 		"root": map[string]interface{}{
 			"nested": []interface{}{
 				map[string]interface{}{
 					"name": "Bob",
 				},
 				map[string]interface{}{
 					"name": "Alice",
 				},
 			},
 		},
 	}, m)
 }
@@ -0,0 +1,53 @@
 package toml_test
 import (
 	"os"
 	"strings"
 	"testing"
 	"github.com/pelletier/go-toml/v2"
 	"github.com/pelletier/go-toml/v2/internal/assert"
 )
 func FuzzUnmarshal(f *testing.F) {
 	file, err := os.ReadFile("benchmark/benchmark.toml")
 	if err != nil {
 		f.Error(err)
 	}
 	f.Add(file)
 	f.Fuzz(func(t *testing.T, b []byte) {
 		if strings.Contains(string(b), "nan") {
 			// Current limitation of testify.
 			// https://github.com/stretchr/testify/issues/624
 			t.Skip("can't compare NaNs")
 		}
 		t.Log("INITIAL DOCUMENT ===========================")
 		t.Log(string(b))
 		var v interface{}
 		err := toml.Unmarshal(b, &v)
 		if err != nil {
 			return
 		}
 		t.Log("DECODED VALUE ===========================")
 		t.Logf("%#+v", v)
 		encoded, err := toml.Marshal(v)
 		if err != nil {
 			t.Fatalf("cannot marshal unmarshaled document: %s", err)
 		}
 		t.Log("ENCODED DOCUMENT ===========================")
 		t.Log(string(encoded))
 		var v2 interface{}
 		err = toml.Unmarshal(encoded, &v2)
 		if err != nil {
 			t.Fatalf("failed round trip: %s", err)
 		}
 		assert.Equal(t, v, v2)
 	})
 }
@@ -1,5 +1,3 @@
 module github.com/pelletier/go-toml/v2
-go 1.15
+go 1.21.0
 require github.com/stretchr/testify v1.7.0
@@ -1,11 +0,0 @@
 github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
@@ -0,0 +1,141 @@
 // Package assert provides assertion functions for unit testing.
 package assert
 import (
 	"bytes"
 	"fmt"
 	"reflect"
 	"strings"
 	"testing"
 )
 // True asserts that an expression is true.
 func True(tb testing.TB, ok bool, msgAndArgs ...any) {
 	tb.Helper()
 	if ok {
 		return
 	}
 	tb.Fatal(formatMsgAndArgs("Expected expression to be true", msgAndArgs...))
 }
 // False asserts that an expression is false.
 func False(tb testing.TB, ok bool, msgAndArgs ...any) {
 	tb.Helper()
 	if !ok {
 		return
 	}
 	tb.Fatal(formatMsgAndArgs("Expected expression to be false", msgAndArgs...))
 }
 // Equal asserts that "expected" and "actual" are equal.
 func Equal[T any](tb testing.TB, expected, actual T, msgAndArgs ...any) {
 	tb.Helper()
 	if objectsAreEqual(expected, actual) {
 		return
 	}
 	msg := formatMsgAndArgs("Expected values to be equal:", msgAndArgs...)
 	tb.Fatalf("%s\n%s", msg, diff(expected, actual))
 }
 // Error asserts that an error is not nil.
 func Error(tb testing.TB, err error, msgAndArgs ...any) {
 	tb.Helper()
 	if err != nil {
 		return
 	}
 	tb.Fatal(formatMsgAndArgs("Expected an error", msgAndArgs...))
 }
 // NoError asserts that an error is nil.
 func NoError(tb testing.TB, err error, msgAndArgs ...any) {
 	tb.Helper()
 	if err == nil {
 		return
 	}
 	msg := formatMsgAndArgs("Unexpected error:", msgAndArgs...)
 	tb.Fatalf("%s\n%+v", msg, err)
 }
 // Panics asserts that the given function panics.
 func Panics(tb testing.TB, fn func(), msgAndArgs ...any) {
 	tb.Helper()
 	defer func() {
 		if recover() == nil {
 			msg := formatMsgAndArgs("Expected function to panic", msgAndArgs...)
 			tb.Fatal(msg)
 		}
 	}()
 	fn()
 }
 // Zero asserts that a value is its zero value.
 func Zero[T any](tb testing.TB, value T, msgAndArgs ...any) {
 	tb.Helper()
 	var zero T
 	if objectsAreEqual(value, zero) {
 		return
 	}
 	val := reflect.ValueOf(value)
 	if (val.Kind() == reflect.Slice || val.Kind() == reflect.Map || val.Kind() == reflect.Array) && val.Len() == 0 {
 		return
 	}
 	msg := formatMsgAndArgs("Expected zero value but got:", msgAndArgs...)
 	tb.Fatalf("%s\n%v", msg, value)
 }
 func NotZero[T any](tb testing.TB, value T, msgAndArgs ...any) {
 	tb.Helper()
 	var zero T
 	if !objectsAreEqual(value, zero) {
 		val := reflect.ValueOf(value)
 		switch val.Kind() {
 		case reflect.Slice, reflect.Map, reflect.Array:
 			if val.Len() > 0 {
 				return
 			}
 		default:
 			return
 		}
 	}
 	msg := formatMsgAndArgs("Unexpected zero value:", msgAndArgs...)
 	tb.Fatalf("%s\n%v", msg, value)
 }
 func formatMsgAndArgs(msg string, args ...any) string {
 	if len(args) == 0 {
 		return msg
 	}
 	format, ok := args[0].(string)
 	if !ok {
 		panic("message argument must be a fmt string")
 	}
 	return fmt.Sprintf(format, args[1:]...)
 }
 func diff(expected, actual any) string {
 	lines := []string{
 		"expected:",
 		fmt.Sprintf("%v", expected),
 		"actual:",
 		fmt.Sprintf("%v", actual),
 	}
 	return strings.Join(lines, "\n")
 }
 func objectsAreEqual(expected, actual any) bool {
 	if expected == nil || actual == nil {
 		return expected == actual
 	}
 	if exp, eok := expected.([]byte); eok {
 		if act, aok := actual.([]byte); aok {
 			return bytes.Equal(exp, act)
 		}
 	}
 	if exp, eok := expected.(string); eok {
 		if act, aok := actual.(string); aok {
 			return exp == act
 		}
 	}
 	return reflect.DeepEqual(expected, actual)
 }
@@ -0,0 +1,217 @@
 package assert
 import (
 	"errors"
 	"fmt"
 	"testing"
 )
 type Data struct {
 	Label string
 	Value int64
 }
 func TestBadMessage(t *testing.T) {
 	invalidMessage := func() { True(t, false, 1234) }
 	assertOk(t, "Non-fmt message value", func(tb testing.TB) {
 		tb.Helper()
 		Panics(tb, invalidMessage)
 	})
 	assertFail(t, "Non-fmt message value", func(tb testing.TB) {
 		tb.Helper()
 		True(tb, false, "example %s", "message")
 	})
 }
 func TestTrue(t *testing.T) {
 	assertOk(t, "Succeed", func(tb testing.TB) {
 		tb.Helper()
 		True(tb, 1 > 0)
 	})
 	assertFail(t, "Fail", func(tb testing.TB) {
 		tb.Helper()
 		True(tb, 1 < 0)
 	})
 }
 func TestFalse(t *testing.T) {
 	assertOk(t, "Succeed", func(tb testing.TB) {
 		tb.Helper()
 		False(tb, 1 < 0)
 	})
 	assertFail(t, "Fail", func(tb testing.TB) {
 		tb.Helper()
 		False(tb, 1 > 0)
 	})
 }
 func TestEqual(t *testing.T) {
 	assertOk(t, "Nil", func(tb testing.TB) {
 		tb.Helper()
 		Equal(tb, interface{}(nil), interface{}(nil))
 	})
 	assertOk(t, "Identical structs", func(tb testing.TB) {
 		tb.Helper()
 		Equal(tb, Data{"expected", 1234}, Data{"expected", 1234})
 	})
 	assertFail(t, "Different structs", func(tb testing.TB) {
 		tb.Helper()
 		Equal(tb, Data{"expected", 1234}, Data{"actual", 1234})
 	})
 	assertOk(t, "Identical numbers", func(tb testing.TB) {
 		tb.Helper()
 		Equal(tb, 1234, 1234)
 	})
 	assertFail(t, "Identical numbers", func(tb testing.TB) {
 		tb.Helper()
 		Equal(tb, 1234, 1324)
 	})
 	assertOk(t, "Zero-length byte arrays", func(tb testing.TB) {
 		tb.Helper()
 		Equal(tb, []byte(nil), []byte(""))
 	})
 	assertOk(t, "Identical byte arrays", func(tb testing.TB) {
 		tb.Helper()
 		Equal(tb, []byte{1, 2, 3, 4}, []byte{1, 2, 3, 4})
 	})
 	assertFail(t, "Different byte arrays", func(tb testing.TB) {
 		tb.Helper()
 		Equal(tb, []byte{1, 2, 3, 4}, []byte{1, 3, 2, 4})
 	})
 	assertOk(t, "Identical strings", func(tb testing.TB) {
 		tb.Helper()
 		Equal(tb, "example", "example")
 	})
 	assertFail(t, "Identical strings", func(tb testing.TB) {
 		tb.Helper()
 		Equal(tb, "example", "elpmaxe")
 	})
 }
 func TestError(t *testing.T) {
 	assertOk(t, "Error", func(tb testing.TB) {
 		tb.Helper()
 		Error(tb, errors.New("example"))
 	})
 	assertFail(t, "Nil", func(tb testing.TB) {
 		tb.Helper()
 		Error(tb, nil)
 	})
 }
 func TestNoError(t *testing.T) {
 	assertFail(t, "Error", func(tb testing.TB) {
 		tb.Helper()
 		NoError(tb, errors.New("example"))
 	})
 	assertOk(t, "Nil", func(tb testing.TB) {
 		tb.Helper()
 		NoError(tb, nil)
 	})
 }
 func TestPanics(t *testing.T) {
 	willPanic := func() { panic("example") }
 	wontPanic := func() {}
 	assertOk(t, "Will panic", func(tb testing.TB) {
 		tb.Helper()
 		Panics(tb, willPanic)
 	})
 	assertFail(t, "Won't panic", func(tb testing.TB) {
 		tb.Helper()
 		Panics(tb, wontPanic)
 	})
 }
 func TestZero(t *testing.T) {
 	assertOk(t, "Empty struct", func(tb testing.TB) {
 		tb.Helper()
 		Zero(tb, Data{})
 	})
 	assertFail(t, "Non-empty struct", func(tb testing.TB) {
 		tb.Helper()
 		Zero(tb, Data{Label: "example"})
 	})
 	assertOk(t, "Nil slice", func(tb testing.TB) {
 		tb.Helper()
 		var slice []int
 		Zero(tb, slice)
 	})
 	assertFail(t, "Non-empty slice", func(tb testing.TB) {
 		tb.Helper()
 		slice := []int{1, 2, 3, 4}
 		Zero(tb, slice)
 	})
 	assertOk(t, "Zero-length slice", func(tb testing.TB) {
 		tb.Helper()
 		slice := []int{}
 		Zero(tb, slice)
 	})
 }
 func TestNotZero(t *testing.T) {
 	assertFail(t, "Empty struct", func(tb testing.TB) {
 		tb.Helper()
 		zero := Data{}
 		NotZero(tb, zero)
 	})
 	assertOk(t, "Non-empty struct", func(tb testing.TB) {
 		tb.Helper()
 		notZero := Data{Label: "example"}
 		NotZero(tb, notZero)
 	})
 	assertFail(t, "Nil slice", func(tb testing.TB) {
 		tb.Helper()
 		var slice []int
 		NotZero(tb, slice)
 	})
 	assertFail(t, "Zero-length slice", func(tb testing.TB) {
 		tb.Helper()
 		slice := []int{}
 		NotZero(tb, slice)
 	})
 	assertOk(t, "Non-empty slice", func(tb testing.TB) {
 		tb.Helper()
 		slice := []int{1, 2, 3, 4}
 		NotZero(tb, slice)
 	})
 }
 type testCase struct {
 	*testing.T
 	failed string
 }
 func (t *testCase) Fatal(args ...interface{}) {
 	t.failed = fmt.Sprint(args...)
 }
 func (t *testCase) Fatalf(message string, args ...interface{}) {
 	t.failed = fmt.Sprintf(message, args...)
 }
 func assertFail(t *testing.T, name string, fn func(testing.TB)) {
 	t.Helper()
 	t.Run(name, func(t *testing.T) {
 		t.Helper()
 		test := &testCase{T: t}
 		fn(test)
 		if test.failed == "" {
 			t.Fatal("Test expected to fail but did not")
 		} else {
 			t.Log(test.failed)
 		}
 	})
 }
 func assertOk(t *testing.T, name string, fn func(testing.TB)) {
 	t.Helper()
 	t.Run(name, func(t *testing.T) {
 		t.Helper()
 		test := &testCase{T: t}
 		fn(test)
 		if test.failed != "" {
 			t.Fatal("Test expected to succeed but did not:\n", test.failed)
 		}
 	})
 }
@@ -1,138 +0,0 @@
 package ast
 import (
 	"fmt"
 )
 // Iterator starts uninitialized, you need to call Next() first.
 //
 // For example:
 //
 // it := n.Children()
 // for it.Next() {
 // 		it.Node()
 // }
 type Iterator struct {
 	started bool
 	node    Node
 }
 // Next moves the iterator forward and returns true if points to a node, false
 // otherwise.
 func (c *Iterator) Next() bool {
 	if !c.started {
 		c.started = true
 	} else if c.node.Valid() {
 		c.node = c.node.Next()
 	}
 	return c.node.Valid()
 }
 // Node returns a copy of the node pointed at by the iterator.
 func (c *Iterator) Node() Node {
 	return c.node
 }
 // Root contains a full AST.
 //
 // It is immutable once constructed with Builder.
 type Root struct {
 	nodes []Node
 }
 // Iterator over the top level nodes.
 func (r *Root) Iterator() Iterator {
 	it := Iterator{}
 	if len(r.nodes) > 0 {
 		it.node = r.nodes[0]
 	}
 	return it
 }
 func (r *Root) at(idx int) Node {
 	// TODO: unsafe to point to the node directly
 	return r.nodes[idx]
 }
 // Arrays have one child per element in the array.
 // InlineTables have one child per key-value pair in the table.
 // KeyValues have at least two children. The first one is the value. The
 // rest make a potentially dotted key.
 // Table and Array table have one child per element of the key they
 // represent (same as KeyValue, but without the last node being the value).
 // children []Node
 type Node struct {
 	Kind Kind
 	Data []byte // Raw bytes from the input
 	// next idx (in the root array). 0 if last of the collection.
 	next int
 	// child idx (in the root array). 0 if no child.
 	child int
 	// pointer to the root array
 	root *Root
 }
 // Next returns a copy of the next node, or an invalid Node if there is no
 // next node.
 func (n Node) Next() Node {
 	if n.next <= 0 {
 		return noNode
 	}
 	return n.root.at(n.next)
 }
 // Child returns a copy of the first child node of this node. Other children
 // can be accessed calling Next on the first child.
 // Returns an invalid Node if there is none.
 func (n Node) Child() Node {
 	if n.child <= 0 {
 		return noNode
 	}
 	return n.root.at(n.child)
 }
 // Valid returns true if the node's kind is set (not to Invalid).
 func (n Node) Valid() bool {
 	return n.Kind != Invalid
 }
 var noNode = Node{}
 // Key returns the child nodes making the Key on a supported node. Panics
 // otherwise.
 // They are guaranteed to be all be of the Kind Key. A simple key would return
 // just one element.
 func (n *Node) Key() Iterator {
 	switch n.Kind {
 	case KeyValue:
 		value := n.Child()
 		if !value.Valid() {
 			panic(fmt.Errorf("KeyValue should have at least two children"))
 		}
 		return Iterator{node: value.Next()}
 	case Table, ArrayTable:
 		return Iterator{node: n.Child()}
 	default:
 		panic(fmt.Errorf("Key() is not supported on a %s", n.Kind))
 	}
 }
 // Value returns a pointer to the value node of a KeyValue.
 // Guaranteed to be non-nil.
 // Panics if not called on a KeyValue node, or if the Children are malformed.
 func (n Node) Value() Node {
 	assertKind(KeyValue, n)
 	return n.Child()
 }
 // Children returns an iterator over a node's children.
 func (n Node) Children() Iterator {
 	return Iterator{node: n.Child()}
 }
 func assertKind(k Kind, n Node) {
 	if n.Kind != k {
 		panic(fmt.Errorf("method was expecting a %s, not a %s", k, n.Kind))
 	}
 }
@@ -1,60 +0,0 @@
 package ast
 type Reference struct {
 	idx int
 	set bool
 }
 func (r Reference) Valid() bool {
 	return r.set
 }
 type Builder struct {
 	tree    Root
 	lastIdx int
 }
 func (b *Builder) Tree() *Root {
 	return &b.tree
 }
 func (b *Builder) NodeAt(ref Reference) Node {
 	return b.tree.at(ref.idx)
 }
 func (b *Builder) Reset() {
 	b.tree.nodes = b.tree.nodes[:0]
 	b.lastIdx = 0
 }
 func (b *Builder) Push(n Node) Reference {
 	n.root = &b.tree
 	b.lastIdx = len(b.tree.nodes)
 	b.tree.nodes = append(b.tree.nodes, n)
 	return Reference{
 		idx: b.lastIdx,
 		set: true,
 	}
 }
 func (b *Builder) PushAndChain(n Node) Reference {
 	n.root = &b.tree
 	newIdx := len(b.tree.nodes)
 	b.tree.nodes = append(b.tree.nodes, n)
 	if b.lastIdx >= 0 {
 		b.tree.nodes[b.lastIdx].next = newIdx
 	}
 	b.lastIdx = newIdx
 	return Reference{
 		idx: b.lastIdx,
 		set: true,
 	}
 }
 func (b *Builder) AttachChild(parent Reference, child Reference) {
 	b.tree.nodes[parent.idx].child = child.idx
 }
 func (b *Builder) Chain(from Reference, to Reference) {
 	b.tree.nodes[from.idx].next = to.idx
 }
@@ -1,69 +0,0 @@
 package ast
 import "fmt"
 type Kind int
 const (
 	// meta
 	Invalid Kind = iota
 	Comment
 	Key
 	// top level structures
 	Table
 	ArrayTable
 	KeyValue
 	// containers values
 	Array
 	InlineTable
 	// values
 	String
 	Bool
 	Float
 	Integer
 	LocalDate
 	LocalDateTime
 	DateTime
 	Time
 )
 func (k Kind) String() string {
 	switch k {
 	case Invalid:
 		return "Invalid"
 	case Comment:
 		return "Comment"
 	case Key:
 		return "Key"
 	case Table:
 		return "Table"
 	case ArrayTable:
 		return "ArrayTable"
 	case KeyValue:
 		return "KeyValue"
 	case Array:
 		return "Array"
 	case InlineTable:
 		return "InlineTable"
 	case String:
 		return "String"
 	case Bool:
 		return "Bool"
 	case Float:
 		return "Float"
 	case Integer:
 		return "Integer"
 	case LocalDate:
 		return "LocalDate"
 	case LocalDateTime:
 		return "LocalDateTime"
 	case DateTime:
 		return "DateTime"
 	case Time:
 		return "Time"
 	}
 	panic(fmt.Errorf("Kind.String() not implemented for '%d'", k))
 }
@@ -0,0 +1,42 @@
 package characters
 var invalidASCIITable = [256]bool{
 	0x00: true,
 	0x01: true,
 	0x02: true,
 	0x03: true,
 	0x04: true,
 	0x05: true,
 	0x06: true,
 	0x07: true,
 	0x08: true,
 	// 0x09 TAB
 	// 0x0A LF
 	0x0B: true,
 	0x0C: true,
 	// 0x0D CR
 	0x0E: true,
 	0x0F: true,
 	0x10: true,
 	0x11: true,
 	0x12: true,
 	0x13: true,
 	0x14: true,
 	0x15: true,
 	0x16: true,
 	0x17: true,
 	0x18: true,
 	0x19: true,
 	0x1A: true,
 	0x1B: true,
 	0x1C: true,
 	0x1D: true,
 	0x1E: true,
 	0x1F: true,
 	// 0x20 - 0x7E Printable ASCII characters
 	0x7F: true,
 }
 func InvalidASCII(b byte) bool {
 	return invalidASCIITable[b]
 }
@@ -0,0 +1,175 @@
 // Package characters provides functions for working with string encodings.
 package characters
 import (
 	"unicode/utf8"
 )
 // Utf8TomlValidAlreadyEscaped verifies that a given string is only made of
 // valid UTF-8 characters allowed by the TOML spec:
 //
 // Any Unicode character may be used except those that must be escaped:
 // quotation mark, backslash, and the control characters other than tab (U+0000
 // to U+0008, U+000A to U+001F, U+007F).
 //
 // It is a copy of the Go 1.17 utf8.Valid implementation, tweaked to exit early
 // when a character is not allowed.
 //
 // The returned slice is empty if the string is valid, or contains the bytes
 // of the invalid character.
 //
 // quotation mark => already checked
 // backslash => already checked
 // 0-0x8 => invalid
 // 0x9 => tab, ok
 // 0xA - 0x1F => invalid
 // 0x7F => invalid
 func Utf8TomlValidAlreadyEscaped(p []byte) []byte {
 	// Fast path. Check for and skip 8 bytes of ASCII characters per iteration.
 	for len(p) >= 8 {
 		// Combining two 32 bit loads allows the same code to be used
 		// for 32 and 64 bit platforms.
 		// The compiler can generate a 32bit load for first32 and second32
 		// on many platforms. See test/codegen/memcombine.go.
 		first32 := uint32(p[0]) | uint32(p[1])<<8 | uint32(p[2])<<16 | uint32(p[3])<<24
 		second32 := uint32(p[4]) | uint32(p[5])<<8 | uint32(p[6])<<16 | uint32(p[7])<<24
 		if (first32|second32)&0x80808080 != 0 {
 			// Found a non ASCII byte (>= RuneSelf).
 			break
 		}
 		for i, b := range p[:8] {
 			if InvalidASCII(b) {
 				return p[i : i+1]
 			}
 		}
 		p = p[8:]
 	}
 	n := len(p)
 	for i := 0; i < n; {
 		pi := p[i]
 		if pi < utf8.RuneSelf {
 			if InvalidASCII(pi) {
 				return p[i : i+1]
 			}
 			i++
 			continue
 		}
 		x := first[pi]
 		if x == xx {
 			// Illegal starter byte.
 			return p[i : i+1]
 		}
 		size := int(x & 7)
 		if i+size > n {
 			// Short or invalid.
 			return p[i:n]
 		}
 		accept := acceptRanges[x>>4]
 		if c := p[i+1]; c < accept.lo || accept.hi < c {
 			return p[i : i+2]
 		} else if size == 2 { //revive:disable:empty-block
 		} else if c := p[i+2]; c < locb || hicb < c {
 			return p[i : i+3]
 		} else if size == 3 { //revive:disable:empty-block
 		} else if c := p[i+3]; c < locb || hicb < c {
 			return p[i : i+4]
 		}
 		i += size
 	}
 	return nil
 }
 // Utf8ValidNext returns the size of the next rune if valid, 0 otherwise.
 func Utf8ValidNext(p []byte) int {
 	c := p[0]
 	if c < utf8.RuneSelf {
 		if InvalidASCII(c) {
 			return 0
 		}
 		return 1
 	}
 	x := first[c]
 	if x == xx {
 		// Illegal starter byte.
 		return 0
 	}
 	size := int(x & 7)
 	if size > len(p) {
 		// Short or invalid.
 		return 0
 	}
 	accept := acceptRanges[x>>4]
 	if c := p[1]; c < accept.lo || accept.hi < c {
 		return 0
 	} else if size == 2 { //nolint:revive
 	} else if c := p[2]; c < locb || hicb < c {
 		return 0
 	} else if size == 3 { //nolint:revive
 	} else if c := p[3]; c < locb || hicb < c {
 		return 0
 	}
 	return size
 }
 // acceptRange gives the range of valid values for the second byte in a UTF-8
 // sequence.
 type acceptRange struct {
 	lo uint8 // lowest value for second byte.
 	hi uint8 // highest value for second byte.
 }
 // acceptRanges has size 16 to avoid bounds checks in the code that uses it.
 var acceptRanges = [16]acceptRange{
 	0: {locb, hicb},
 	1: {0xA0, hicb},
 	2: {locb, 0x9F},
 	3: {0x90, hicb},
 	4: {locb, 0x8F},
 }
 // first is information about the first byte in a UTF-8 sequence.
 var first = [256]uint8{
 	//   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
 	as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x00-0x0F
 	as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x10-0x1F
 	as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x20-0x2F
 	as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x30-0x3F
 	as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x40-0x4F
 	as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x50-0x5F
 	as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x60-0x6F
 	as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x70-0x7F
 	//   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
 	xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0x80-0x8F
 	xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0x90-0x9F
 	xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0xA0-0xAF
 	xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0xB0-0xBF
 	xx, xx, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, // 0xC0-0xCF
 	s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, // 0xD0-0xDF
 	s2, s3, s3, s3, s3, s3, s3, s3, s3, s3, s3, s3, s3, s4, s3, s3, // 0xE0-0xEF
 	s5, s6, s6, s6, s7, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0xF0-0xFF
 }
 const (
 	// The default lowest and highest continuation byte.
 	locb = 0b10000000
 	hicb = 0b10111111
 	// These names of these constants are chosen to give nice alignment in the
 	// table below. The first nibble is an index into acceptRanges or F for
 	// special one-byte cases. The second nibble is the Rune length or the
 	// Status for the special one-byte case.
 	xx = 0xF1 // invalid: size 1
 	as = 0xF0 // ASCII: size 1
 	s1 = 0x02 // accept 0, size 2
 	s2 = 0x13 // accept 1, size 3
 	s3 = 0x03 // accept 0, size 3
 	s4 = 0x23 // accept 2, size 3
 	s5 = 0x34 // accept 3, size 4
 	s6 = 0x04 // accept 0, size 4
 	s7 = 0x44 // accept 4, size 4
 )
@@ -0,0 +1,87 @@
 // Package cli provides common functions for command-line programs.
 package cli
 import (
 	"bytes"
 	"errors"
 	"flag"
 	"fmt"
 	"io"
 	"os"
 	"github.com/pelletier/go-toml/v2"
 )
 type ConvertFn func(r io.Reader, w io.Writer) error
 type Program struct {
 	Usage string
 	Fn    ConvertFn
 	// Inplace allows the command to take more than one file as argument and
 	// perform conversion in place on each provided file.
 	Inplace bool
 }
 func (p *Program) Execute() {
 	flag.Usage = func() { fmt.Fprint(os.Stderr, p.Usage) }
 	flag.Parse()
 	os.Exit(p.main(flag.Args(), os.Stdin, os.Stdout, os.Stderr))
 }
 func (p *Program) main(files []string, input io.Reader, output, stderr io.Writer) int {
 	err := p.run(files, input, output)
 	if err != nil {
 		var derr *toml.DecodeError
 		if errors.As(err, &derr) {
 			_, _ = fmt.Fprintln(stderr, derr.String())
 			row, col := derr.Position()
 			_, _ = fmt.Fprintln(stderr, "error occurred at row", row, "column", col)
 		} else {
 			_, _ = fmt.Fprintln(stderr, err.Error())
 		}
 		return -1
 	}
 	return 0
 }
 func (p *Program) run(files []string, input io.Reader, output io.Writer) error {
 	if len(files) > 0 {
 		if p.Inplace {
 			return p.runAllFilesInPlace(files)
 		}
 		f, err := os.Open(files[0])
 		if err != nil {
 			return err
 		}
 		defer func() { _ = f.Close() }()
 		input = f
 	}
 	return p.Fn(input, output)
 }
 func (p *Program) runAllFilesInPlace(files []string) error {
 	for _, path := range files {
 		err := p.runFileInPlace(path)
 		if err != nil {
 			return err
 		}
 	}
 	return nil
 }
 func (p *Program) runFileInPlace(path string) error {
 	in, err := os.ReadFile(path) // #nosec G304
 	if err != nil {
 		return err
 	}
 	out := new(bytes.Buffer)
 	err = p.Fn(bytes.NewReader(in), out)
 	if err != nil {
 		return err
 	}
 	return os.WriteFile(path, out.Bytes(), 0o600)
 }
@@ -0,0 +1,166 @@
 package cli
 import (
 	"bytes"
 	"errors"
 	"io"
 	"os"
 	"path"
 	"strings"
 	"testing"
 	"github.com/pelletier/go-toml/v2"
 	"github.com/pelletier/go-toml/v2/internal/assert"
 )
 func processMain(args []string, input io.Reader, stdout, stderr io.Writer, f ConvertFn) int {
 	p := Program{Fn: f}
 	return p.main(args, input, stdout, stderr)
 }
 func TestProcessMainStdin(t *testing.T) {
 	stdout := new(bytes.Buffer)
 	stderr := new(bytes.Buffer)
 	input := strings.NewReader("this is the input")
 	exit := processMain([]string{}, input, stdout, stderr, func(io.Reader, io.Writer) error {
 		return nil
 	})
 	assert.Equal(t, 0, exit)
 	assert.Zero(t, stdout.String())
 	assert.Zero(t, stderr.String())
 }
 func TestProcessMainStdinErr(t *testing.T) {
 	stdout := new(bytes.Buffer)
 	stderr := new(bytes.Buffer)
 	input := strings.NewReader("this is the input")
 	exit := processMain([]string{}, input, stdout, stderr, func(io.Reader, io.Writer) error {
 		return errors.New("something bad")
 	})
 	assert.Equal(t, -1, exit)
 	assert.Zero(t, stdout.String())
 	assert.NotZero(t, stderr.String())
 }
 func TestProcessMainStdinDecodeErr(t *testing.T) {
 	stdout := new(bytes.Buffer)
 	stderr := new(bytes.Buffer)
 	input := strings.NewReader("this is the input")
 	exit := processMain([]string{}, input, stdout, stderr, func(io.Reader, io.Writer) error {
 		var v interface{}
 		return toml.Unmarshal([]byte(`qwe = 001`), &v)
 	})
 	assert.Equal(t, -1, exit)
 	assert.Zero(t, stdout.String())
 	assert.True(t, strings.Contains(stderr.String(), "error occurred at"))
 }
 func TestProcessMainFileExists(t *testing.T) {
 	tmpfile, err := os.CreateTemp(t.TempDir(), "example")
 	assert.NoError(t, err)
 	_, err = tmpfile.WriteString(`some data`)
 	assert.NoError(t, err)
 	assert.NoError(t, tmpfile.Close())
 	stdout := new(bytes.Buffer)
 	stderr := new(bytes.Buffer)
 	exit := processMain([]string{tmpfile.Name()}, nil, stdout, stderr, func(io.Reader, io.Writer) error {
 		return nil
 	})
 	assert.Equal(t, 0, exit)
 	assert.Zero(t, stdout.String())
 	assert.Zero(t, stderr.String())
 }
 func TestProcessMainFileDoesNotExist(t *testing.T) {
 	stdout := new(bytes.Buffer)
 	stderr := new(bytes.Buffer)
 	exit := processMain([]string{"/lets/hope/this/does/not/exist"}, nil, stdout, stderr, func(io.Reader, io.Writer) error {
 		return nil
 	})
 	assert.Equal(t, -1, exit)
 	assert.Zero(t, stdout.String())
 	assert.NotZero(t, stderr.String())
 }
 func TestProcessMainFilesInPlace(t *testing.T) {
 	dir := t.TempDir()
 	path1 := path.Join(dir, "file1")
 	path2 := path.Join(dir, "file2")
 	err := os.WriteFile(path1, []byte("content 1"), 0o600)
 	assert.NoError(t, err)
 	err = os.WriteFile(path2, []byte("content 2"), 0o600)
 	assert.NoError(t, err)
 	p := Program{
 		Fn:      dummyFileFn,
 		Inplace: true,
 	}
 	exit := p.main([]string{path1, path2}, os.Stdin, os.Stdout, os.Stderr)
 	assert.Equal(t, 0, exit)
 	v1, err := os.ReadFile(path1)
 	assert.NoError(t, err)
 	assert.Equal(t, "1", string(v1))
 	v2, err := os.ReadFile(path2)
 	assert.NoError(t, err)
 	assert.Equal(t, "2", string(v2))
 }
 func TestProcessMainFilesInPlaceErrRead(t *testing.T) {
 	p := Program{
 		Fn:      dummyFileFn,
 		Inplace: true,
 	}
 	exit := p.main([]string{"/this/path/is/invalid"}, os.Stdin, os.Stdout, os.Stderr)
 	assert.Equal(t, -1, exit)
 }
 func TestProcessMainFilesInPlaceFailFn(t *testing.T) {
 	dir := t.TempDir()
 	path1 := path.Join(dir, "file1")
 	err := os.WriteFile(path1, []byte("content 1"), 0o600)
 	assert.NoError(t, err)
 	p := Program{
 		Fn:      func(io.Reader, io.Writer) error { return errors.New("oh no") },
 		Inplace: true,
 	}
 	exit := p.main([]string{path1}, os.Stdin, os.Stdout, os.Stderr)
 	assert.Equal(t, -1, exit)
 	v1, err := os.ReadFile(path1)
 	assert.NoError(t, err)
 	assert.Equal(t, "content 1", string(v1))
 }
 func dummyFileFn(r io.Reader, w io.Writer) error {
 	b, err := io.ReadAll(r)
 	if err != nil {
 		return err
 	}
 	v := strings.SplitN(string(b), " ", 2)[1]
 	_, err = w.Write([]byte(v))
 	return err
 }
@@ -1,14 +1,15 @@
-package imported_tests
+package imported_tests //revive:disable:var-naming
 // Those tests have been imported from v1, but adjust to match the new
 // defaults of v2.
 import (
 	"fmt"
 	"testing"
 	"time"
 	"github.com/pelletier/go-toml/v2"
-	"github.com/stretchr/testify/require"
+	"github.com/pelletier/go-toml/v2/internal/assert"
 )
 func TestDocMarshal(t *testing.T) {
@@ -20,12 +21,12 @@ func TestDocMarshal(t *testing.T) {
 		Subdocs     testDocSubs       `toml:"subdoc"`
 		Basics      testDocBasics     `toml:"basic"`
 		SubDocList  []testSubDoc      `toml:"subdoclist"`
-		err         int               `toml:"shouldntBeHere"`
+		err         int               `toml:"shouldntBeHere"` //nolint:unused
 		unexported  int               `toml:"shouldntBeHere"`
 		Unexported2 int               `toml:"-"`
 	}
-	var docData = testDoc{
+	docData := testDoc{
 		Title:       "TOML Marshal Testing",
 		unexported:  0,
 		Unexported2: 0,
@@ -66,6 +67,7 @@ func TestDocMarshal(t *testing.T) {
 	}
 	marshalTestToml := `title = 'TOML Marshal Testing'
 [basic_lists]
 floats = [12.3, 45.6, 78.9]
 bools = [true, false, true]
@@ -88,7 +90,6 @@ name = 'Second'
 [subdoc.first]
 name = 'First'
 [basic]
 uint = 5001
 bool = true
@@ -100,34 +101,34 @@ date = 1979-05-27T07:32:00Z
 [[subdoclist]]
 name = 'List.First'
 [[subdoclist]]
 name = 'List.Second'
 `
 	result, err := toml.Marshal(docData)
-	require.NoError(t, err)
+	assert.NoError(t, err)
-	require.Equal(t, marshalTestToml, string(result))
+	assert.Equal(t, marshalTestToml, string(result))
 }
 func TestBasicMarshalQuotedKey(t *testing.T) {
 	result, err := toml.Marshal(quotedKeyMarshalTestData)
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	expected := `'Z.string-àéù' = 'Hello'
 'Yfloat-𝟘' = 3.5
 ['Xsubdoc-àéù']
 String2 = 'One'
 [['W.sublist-𝟘']]
 String2 = 'Two'
 [['W.sublist-𝟘']]
 String2 = 'Three'
 `
-	require.Equal(t, string(expected), string(result))
+	assert.Equal(t, expected, string(result))
 }
 func TestEmptyMarshal(t *testing.T) {
@@ -151,16 +152,47 @@ func TestEmptyMarshal(t *testing.T) {
 		Map:        map[string]string{},
 	}
 	result, err := toml.Marshal(doc)
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	expected := `title = 'Placeholder'
 bool = false
 int = 0
 string = ''
 stringlist = []
 [map]
 [map]
 `
-	require.Equal(t, string(expected), string(result))
+	assert.Equal(t, expected, string(result))
 }
 type textMarshaler struct {
 	FirstName string
 	LastName  string
 }
 func (m textMarshaler) MarshalText() ([]byte, error) {
 	fullName := fmt.Sprintf("%s %s", m.FirstName, m.LastName)
 	return []byte(fullName), nil
 }
 func TestTextMarshaler(t *testing.T) {
 	type wrap struct {
 		TM textMarshaler
 	}
 	m := textMarshaler{FirstName: "Sally", LastName: "Fields"}
 	t.Run("at root", func(t *testing.T) {
 		_, err := toml.Marshal(m)
 		// in v2 we do not allow TextMarshaler at root
 		assert.Error(t, err)
 	})
 	t.Run("leaf", func(t *testing.T) {
 		res, err := toml.Marshal(wrap{m})
 		assert.NoError(t, err)
 		assert.Equal(t, "TM = 'Sally Fields'\n", string(res))
 	})
 }
@@ -0,0 +1,75 @@
 package testsuite
 import (
 	"fmt"
 	"math"
 	"strconv"
 	"time"
 	"github.com/pelletier/go-toml/v2"
 )
 // addTag adds JSON tags to a data structure as expected by toml-test.
 func addTag(tomlData interface{}) interface{} {
 	// Switch on the data type.
 	switch orig := tomlData.(type) {
 	default:
 		// return map[string]interface{}{}
 		panic(fmt.Sprintf("Unknown type: %T", tomlData))
 	// A table: we don't need to add any tags, just recurse for every table
 	// entry.
 	case map[string]interface{}:
 		typed := make(map[string]interface{}, len(orig))
 		for k, v := range orig {
 			typed[k] = addTag(v)
 		}
 		return typed
 	// An array: we don't need to add any tags, just recurse for every table
 	// entry.
 	case []map[string]interface{}:
 		typed := make([]map[string]interface{}, len(orig))
 		for i, v := range orig {
 			typed[i] = addTag(v).(map[string]interface{})
 		}
 		return typed
 	case []interface{}:
 		typed := make([]interface{}, len(orig))
 		for i, v := range orig {
 			typed[i] = addTag(v)
 		}
 		return typed
 	// Datetime: tag as datetime.
 	case toml.LocalTime:
 		return tag("time-local", orig.String())
 	case toml.LocalDate:
 		return tag("date-local", orig.String())
 	case toml.LocalDateTime:
 		return tag("datetime-local", orig.String())
 	case time.Time:
 		return tag("datetime", orig.Format("2006-01-02T15:04:05.999999999Z07:00"))
 	// Tag primitive values: bool, string, int, and float64.
 	case bool:
 		return tag("bool", strconv.FormatBool(orig))
 	case string:
 		return tag("string", orig)
 	case int64:
 		return tag("integer", strconv.FormatInt(orig, 10))
 	case float64:
 		// Special case for nan since NaN == NaN is false.
 		if math.IsNaN(orig) {
 			return tag("float", "nan")
 		}
 		return tag("float", fmt.Sprintf("%v", orig))
 	}
 }
 func tag(typeName string, data interface{}) map[string]interface{} {
 	return map[string]interface{}{
 		"type":  typeName,
 		"value": data,
 	}
 }
@@ -0,0 +1,244 @@
 package testsuite
 import (
 	"fmt"
 	"strconv"
 	"strings"
 	"testing"
 	"time"
 )
 func CmpJSON(t *testing.T, key string, want, have interface{}) {
 	t.Helper()
 	switch w := want.(type) {
 	case map[string]interface{}:
 		cmpJSONMaps(t, key, w, have)
 	case []interface{}:
 		cmpJSONArrays(t, key, w, have)
 	default:
 		t.Errorf(
 			"Key '%s' in expected output should be a map or a list of maps, but it's a %T",
 			key, want)
 	}
 }
 func cmpJSONMaps(t *testing.T, key string, want map[string]interface{}, have interface{}) {
 	t.Helper()
 	haveMap, ok := have.(map[string]interface{})
 	if !ok {
 		mismatch(t, key, "table", want, haveMap)
 		return
 	}
 	// Check to make sure both or neither are values.
 	if isValue(want) && !isValue(haveMap) {
 		t.Fatalf("Key '%s' is supposed to be a value, but the parser reports it as a table", key)
 	}
 	if !isValue(want) && isValue(haveMap) {
 		t.Fatalf("Key '%s' is supposed to be a table, but the parser reports it as a value", key)
 	}
 	if isValue(want) && isValue(haveMap) {
 		cmpJSONValues(t, key, want, haveMap)
 		return
 	}
 	// Check that the keys of each map are equivalent.
 	for k := range want {
 		if _, ok := haveMap[k]; !ok {
 			bunk := kjoin(key, k)
 			t.Fatalf("Could not find key '%s' in parser output.", bunk)
 		}
 	}
 	for k := range haveMap {
 		if _, ok := want[k]; !ok {
 			bunk := kjoin(key, k)
 			t.Fatalf("Could not find key '%s' in expected output.", bunk)
 		}
 	}
 	// Okay, now make sure that each value is equivalent.
 	for k := range want {
 		CmpJSON(t, kjoin(key, k), want[k], haveMap[k])
 	}
 }
 func cmpJSONArrays(t *testing.T, key string, want, have interface{}) {
 	t.Helper()
 	wantSlice, ok := want.([]interface{})
 	if !ok {
 		panic(fmt.Sprintf("'value' should be a JSON array when 'type=array', but it is a %T", want))
 	}
 	haveSlice, ok := have.([]interface{})
 	if !ok {
 		t.Fatalf("Malformed output from your encoder: 'value' is not a JSON array: %T", have)
 	}
 	if len(wantSlice) != len(haveSlice) {
 		t.Fatalf("Array lengths differ for key '%s':\n"+
 			"  Expected:     %d\n"+
 			"  Your encoder: %d",
 			key, len(wantSlice), len(haveSlice))
 	}
 	for i := 0; i < len(wantSlice); i++ {
 		CmpJSON(t, key, wantSlice[i], haveSlice[i])
 	}
 }
 func cmpJSONValues(t *testing.T, key string, want, have map[string]interface{}) {
 	t.Helper()
 	wantType, ok := want["type"].(string)
 	if !ok {
 		panic(fmt.Sprintf("'type' should be a string, but it is a %T", want["type"]))
 	}
 	haveType, ok := have["type"].(string)
 	if !ok {
 		t.Fatalf("Malformed output from your encoder: 'type' is not a string: %T", have["type"])
 	}
 	if wantType != haveType {
 		valMismatch(t, key, wantType, haveType, want, have)
 	}
 	// If this is an array, then we've got to do some work to check equality.
 	if wantType == "array" {
 		cmpJSONArrays(t, key, want, have)
 		return
 	}
 	// Atomic values are always strings
 	wantVal, ok := want["value"].(string)
 	if !ok {
 		panic(fmt.Sprintf("'value' %v should be a string, but it is a %[1]T", want["value"]))
 	}
 	haveVal, ok := have["value"].(string)
 	if !ok {
 		panic(fmt.Sprintf("Malformed output from your encoder: %T is not a string", have["value"]))
 	}
 	// Excepting floats and datetimes, other values can be compared as strings.
 	switch wantType {
 	case "float":
 		cmpFloats(t, key, wantVal, haveVal)
 	case "datetime", "datetime-local", "date-local", "time-local":
 		cmpAsDatetimes(t, key, wantType, wantVal, haveVal)
 	default:
 		cmpAsStrings(t, key, wantVal, haveVal)
 	}
 }
 func cmpAsStrings(t *testing.T, key string, want, have string) {
 	t.Helper()
 	if want != have {
 		t.Fatalf("Values for key '%s' don't match:\n"+
 			"  Expected:     %s\n"+
 			"  Your encoder: %s",
 			key, want, have)
 	}
 }
 func cmpFloats(t *testing.T, key string, want, have string) {
 	t.Helper()
 	// Special case for NaN, since NaN != NaN.
 	if strings.HasSuffix(want, "nan") || strings.HasSuffix(have, "nan") {
 		if want != have {
 			t.Fatalf("Values for key '%s' don't match:\n"+
 				"  Expected:     %v\n"+
 				"  Your encoder: %v",
 				key, want, have)
 		}
 		return
 	}
 	wantF, err := strconv.ParseFloat(want, 64)
 	if err != nil {
 		panic(fmt.Sprintf("Could not read '%s' as a float value for key '%s'", want, key))
 	}
 	haveF, err := strconv.ParseFloat(have, 64)
 	if err != nil {
 		panic(fmt.Sprintf("Malformed output from your encoder: key '%s' is not a float: '%s'", key, have))
 	}
 	if wantF != haveF {
 		t.Fatalf("Values for key '%s' don't match:\n"+
 			"  Expected:     %v\n"+
 			"  Your encoder: %v",
 			key, wantF, haveF)
 	}
 }
 var datetimeRepl = strings.NewReplacer(
 	" ", "T",
 	"t", "T",
 	"z", "Z")
 var layouts = map[string]string{
 	"datetime":       time.RFC3339Nano,
 	"datetime-local": "2006-01-02T15:04:05.999999999",
 	"date-local":     "2006-01-02",
 	"time-local":     "15:04:05",
 }
 func cmpAsDatetimes(t *testing.T, key string, kind, want, have string) {
 	t.Helper()
 	layout, ok := layouts[kind]
 	if !ok {
 		panic("should never happen")
 	}
 	wantT, err := time.Parse(layout, datetimeRepl.Replace(want))
 	if err != nil {
 		panic(fmt.Sprintf("Could not read '%s' as a datetime value for key '%s'", want, key))
 	}
 	haveT, err := time.Parse(layout, datetimeRepl.Replace(want))
 	if err != nil {
 		t.Fatalf("Malformed output from your encoder: key '%s' is not a datetime: '%s'", key, have)
 		return
 	}
 	if !wantT.Equal(haveT) {
 		t.Fatalf("Values for key '%s' don't match:\n"+
 			"  Expected:     %v\n"+
 			"  Your encoder: %v",
 			key, wantT, haveT)
 	}
 }
 func kjoin(old, key string) string {
 	if len(old) == 0 {
 		return key
 	}
 	return old + "." + key
 }
 func isValue(m map[string]interface{}) bool {
 	if len(m) != 2 {
 		return false
 	}
 	if _, ok := m["type"]; !ok {
 		return false
 	}
 	if _, ok := m["value"]; !ok {
 		return false
 	}
 	return true
 }
 func mismatch(t *testing.T, key string, wantType string, want, have interface{}) {
 	t.Helper()
 	t.Fatalf("Key '%s' is not an %s but %[4]T:\n"+
 		"  Expected:     %#[3]v\n"+
 		"  Your encoder: %#[4]v",
 		key, wantType, want, have)
 }
 func valMismatch(t *testing.T, key string, wantType, haveType string, want, have interface{}) {
 	t.Helper()
 	t.Fatalf("Key '%s' is not an %s but %s:\n"+
 		"  Expected:     %#[3]v\n"+
 		"  Your encoder: %#[4]v",
 		key, wantType, haveType, want, have)
 }
@@ -0,0 +1,116 @@
 package testsuite
 import (
 	"fmt"
 	"strconv"
 	"time"
 	"github.com/pelletier/go-toml/v2"
 )
 // Remove JSON tags to a data structure as returned by toml-test.
 func rmTag(typedJSON interface{}) (interface{}, error) {
 	// Check if key is in the table m.
 	in := func(key string, m map[string]interface{}) bool {
 		_, ok := m[key]
 		return ok
 	}
 	// Switch on the data type.
 	switch v := typedJSON.(type) {
 	// Object: this can either be a TOML table or a primitive with tags.
 	case map[string]interface{}:
 		// This value represents a primitive: remove the tags and return just
 		// the primitive value.
 		if len(v) == 2 && in("type", v) && in("value", v) {
 			ut, err := untag(v)
 			if err != nil {
 				return ut, fmt.Errorf("tag.Remove: %w", err)
 			}
 			return ut, nil
 		}
 		// Table: remove tags on all children.
 		m := make(map[string]interface{}, len(v))
 		for k, v2 := range v {
 			var err error
 			m[k], err = rmTag(v2)
 			if err != nil {
 				return nil, err
 			}
 		}
 		return m, nil
 	// Array: remove tags from all items.
 	case []interface{}:
 		a := make([]interface{}, len(v))
 		for i := range v {
 			var err error
 			a[i], err = rmTag(v[i])
 			if err != nil {
 				return nil, err
 			}
 		}
 		return a, nil
 	}
 	// The top level must be an object or array.
 	return nil, fmt.Errorf("unrecognized JSON format '%T'", typedJSON)
 }
 // Return a primitive: read the "type" and convert the "value" to that.
 func untag(typed map[string]interface{}) (interface{}, error) {
 	t := typed["type"].(string)
 	v := typed["value"].(string)
 	switch t {
 	case "string":
 		return v, nil
 	case "integer":
 		n, err := strconv.ParseInt(v, 10, 64)
 		if err != nil {
 			return nil, fmt.Errorf("untag: %w", err)
 		}
 		return n, nil
 	case "float":
 		f, err := strconv.ParseFloat(v, 64)
 		if err != nil {
 			return nil, fmt.Errorf("untag: %w", err)
 		}
 		return f, nil
 		// toml.LocalDate{Year:2020, Month:12, Day:12}
 	case "datetime":
 		return time.Parse("2006-01-02T15:04:05.999999999Z07:00", v)
 	case "datetime-local":
 		var t toml.LocalDateTime
 		err := t.UnmarshalText([]byte(v))
 		if err != nil {
 			return nil, fmt.Errorf("untag: %w", err)
 		}
 		return t, nil
 	case "date-local":
 		var t toml.LocalDate
 		err := t.UnmarshalText([]byte(v))
 		if err != nil {
 			return nil, fmt.Errorf("untag: %w", err)
 		}
 		return t, nil
 	case "time-local":
 		var t toml.LocalTime
 		err := t.UnmarshalText([]byte(v))
 		if err != nil {
 			return nil, fmt.Errorf("untag: %w", err)
 		}
 		return t, nil
 	case "bool":
 		switch v {
 		case "true":
 			return true, nil
 		case "false":
 			return false, nil
 		}
 		return nil, fmt.Errorf("untag: could not parse %q as a boolean", v)
 	}
 	return nil, fmt.Errorf("untag: unrecognized tag type %q", t)
 }
@@ -0,0 +1,68 @@
 // Package testsuite provides helper functions for interoperating with the
 // language-agnostic TOML test suite at github.com/BurntSushi/toml-test.
 package testsuite
 import (
 	"encoding/json"
 	"fmt"
 	"os"
 	"github.com/pelletier/go-toml/v2"
 )
 // Marshal is a helper function for calling toml.Marshal
 //
 // Only needed to avoid package import loops.
 func Marshal(v interface{}) ([]byte, error) {
 	return toml.Marshal(v)
 }
 // Unmarshal is a helper function for calling toml.Unmarshal.
 //
 // Only needed to avoid package import loops.
 func Unmarshal(data []byte, v interface{}) error {
 	return toml.Unmarshal(data, v)
 }
 // ValueToTaggedJSON takes a data structure and returns the tagged JSON
 // representation.
 func ValueToTaggedJSON(doc interface{}) ([]byte, error) {
 	return json.MarshalIndent(addTag(doc), "", "  ")
 }
 // DecodeStdin is a helper function for the toml-test binary interface.  TOML input
 // is read from STDIN and a resulting tagged JSON representation is written to
 // STDOUT.
 func DecodeStdin() error {
 	var decoded map[string]interface{}
 	if err := toml.NewDecoder(os.Stdin).Decode(&decoded); err != nil {
 		return fmt.Errorf("error decoding TOML: %w", err)
 	}
 	j := json.NewEncoder(os.Stdout)
 	j.SetIndent("", "  ")
 	if err := j.Encode(addTag(decoded)); err != nil {
 		return fmt.Errorf("error encoding JSON: %w", err)
 	}
 	return nil
 }
 // EncodeStdin is a helper function for the toml-test binary interface.  Tagged
 // JSON is read from STDIN and a resulting TOML representation is written to
 // STDOUT.
 func EncodeStdin() error {
 	var j interface{}
 	err := json.NewDecoder(os.Stdin).Decode(&j)
 	if err != nil {
 		return err
 	}
 	rm, err := rmTag(j)
 	if err != nil {
 		return fmt.Errorf("removing tags: %w", err)
 	}
 	return toml.NewEncoder(os.Stdout).Encode(rm)
 }
@@ -1,8 +1,6 @@
 package tracker
-import (
+import "github.com/pelletier/go-toml/v2/unstable"
 	"github.com/pelletier/go-toml/v2/internal/ast"
 )
 // KeyTracker is a tracker that keeps track of the current Key as the AST is
 // walked.
@@ -11,19 +9,19 @@ type KeyTracker struct {
 }
 // UpdateTable sets the state of the tracker with the AST table node.
-func (t *KeyTracker) UpdateTable(node ast.Node) {
+func (t *KeyTracker) UpdateTable(node *unstable.Node) {
 	t.reset()
 	t.Push(node)
 }
 // UpdateArrayTable sets the state of the tracker with the AST array table node.
-func (t *KeyTracker) UpdateArrayTable(node ast.Node) {
+func (t *KeyTracker) UpdateArrayTable(node *unstable.Node) {
 	t.reset()
 	t.Push(node)
 }
 // Push the given key on the stack.
-func (t *KeyTracker) Push(node ast.Node) {
+func (t *KeyTracker) Push(node *unstable.Node) {
 	it := node.Key()
 	for it.Next() {
 		t.k = append(t.k, string(it.Node().Data))
@@ -31,14 +29,14 @@ func (t *KeyTracker) Push(node ast.Node) {
 }
 // Pop key from stack.
-func (t *KeyTracker) Pop(node ast.Node) {
+func (t *KeyTracker) Pop(node *unstable.Node) {
 	it := node.Key()
 	for it.Next() {
 		t.k = t.k[:len(t.k)-1]
 	}
 }
-// Key returns the current key
+// Key returns the current key.
 func (t *KeyTracker) Key() []string {
 	k := make([]string, len(t.k))
 	copy(k, t.k)
@@ -1,9 +1,11 @@
 package tracker
 import (
 	"bytes"
 	"fmt"
 	"sync"
-	"github.com/pelletier/go-toml/v2/internal/ast"
+	"github.com/pelletier/go-toml/v2/unstable"
 )
 type keyKind uint8
@@ -29,172 +31,329 @@ func (k keyKind) String() string {
 	panic("missing keyKind string mapping")
 }
-// SeenTracker tracks which keys have been seen with which TOML type to flag duplicates
+// SeenTracker tracks which keys have been seen with which TOML type to flag
-// and mismatches according to the spec.
+// duplicates and mismatches according to the spec.
 //
 // Each node in the visited tree is represented by an entry. Each entry has an
 // identifier, which is provided by a counter. Entries are stored in the array
 // entries. As new nodes are discovered (referenced for the first time in the
 // TOML document), entries are created and appended to the array. An entry
 // points to its parent using its id.
 //
 // To find whether a given key (sequence of []byte) has already been visited,
 // the entries are linearly searched, looking for one with the right name and
 // parent id.
 //
 // Given that all keys appear in the document after their parent, it is
 // guaranteed that all descendants of a node are stored after the node, this
 // speeds up the search process.
 //
 // When encountering [[array tables]], the descendants of that node are removed
 // to allow that branch of the tree to be "rediscovered". To maintain the
 // invariant above, the deletion process needs to keep the order of entries.
 // This results in more copies in that case.
 type SeenTracker struct {
-	root    *info
+	entries    []entry
-	current *info
+	currentIdx int
 }
-type info struct {
+var pool = sync.Pool{
-	parent   *info
+	New: func() interface{} {
 		return &SeenTracker{}
 	},
 }
 func (s *SeenTracker) reset() {
 	// Always contains a root element at index 0.
 	s.currentIdx = 0
 	if len(s.entries) == 0 {
 		s.entries = make([]entry, 1, 2)
 	} else {
 		s.entries = s.entries[:1]
 	}
 	s.entries[0].child = -1
 	s.entries[0].next = -1
 }
 type entry struct {
 	// Use -1 to indicate no child or no sibling.
 	child int
 	next  int
 	name     []byte
 	kind     keyKind
 	children map[string]*info
 	explicit bool
 	kv       bool
 }
-func (i *info) Clear() {
+// Find the index of the child of parentIdx with key k. Returns -1 if
-	i.children = nil
+// it does not exist.
 func (s *SeenTracker) find(parentIdx int, k []byte) int {
 	for i := s.entries[parentIdx].child; i >= 0; i = s.entries[i].next {
 		if bytes.Equal(s.entries[i].name, k) {
 			return i
 		}
 	}
 	return -1
 }
-func (i *info) Has(k string) (*info, bool) {
+// Remove all descendants of node at position idx.
-	c, ok := i.children[k]
+func (s *SeenTracker) clear(idx int) {
-	return c, ok
+	if idx >= len(s.entries) {
-}
+		return
 func (i *info) SetKind(kind keyKind) {
 	i.kind = kind
 }
 func (i *info) CreateTable(k string, explicit bool) *info {
 	return i.createChild(k, tableKind, explicit)
 }
 func (i *info) CreateArrayTable(k string, explicit bool) *info {
 	return i.createChild(k, arrayTableKind, explicit)
 }
 func (i *info) createChild(k string, kind keyKind, explicit bool) *info {
 	if i.children == nil {
 		i.children = make(map[string]*info, 1)
 	}
-	x := &info{
+	for i := s.entries[idx].child; i >= 0; {
-		parent:   i,
+		next := s.entries[i].next
 		n := s.entries[0].next
 		s.entries[0].next = i
 		s.entries[i].next = n
 		s.entries[i].name = nil
 		s.clear(i)
 		i = next
 	}
 	s.entries[idx].child = -1
 }
 func (s *SeenTracker) create(parentIdx int, name []byte, kind keyKind, explicit bool, kv bool) int {
 	e := entry{
 		child: -1,
 		next:  s.entries[parentIdx].child,
 		name:     name,
 		kind:     kind,
 		explicit: explicit,
 		kv:       kv,
 	}
-	i.children[k] = x
+	var idx int
-	return x
+	if s.entries[0].next >= 0 {
 		idx = s.entries[0].next
 		s.entries[0].next = s.entries[idx].next
 		s.entries[idx] = e
 	} else {
 		idx = len(s.entries)
 		s.entries = append(s.entries, e)
 	}
 	s.entries[parentIdx].child = idx
 	return idx
 }
-// CheckExpression takes a top-level node and checks that it does not contain keys
+func (s *SeenTracker) setExplicitFlag(parentIdx int) {
-// that have been seen in previous calls, and validates that types are consistent.
+	for i := s.entries[parentIdx].child; i >= 0; i = s.entries[i].next {
-func (s *SeenTracker) CheckExpression(node ast.Node) error {
+		if s.entries[i].kv {
-	if s.root == nil {
+			s.entries[i].explicit = true
-		s.root = &info{
+			s.entries[i].kv = false
 			kind: tableKind,
 		}
-		s.current = s.root
+		s.setExplicitFlag(i)
 	}
 }
 // CheckExpression takes a top-level node and checks that it does not contain
 // keys that have been seen in previous calls, and validates that types are
 // consistent. It returns true if it is the first time this node's key is seen.
 // Useful to clear array tables on first use.
 func (s *SeenTracker) CheckExpression(node *unstable.Node) (bool, error) {
 	if s.entries == nil {
 		s.reset()
 	}
 	switch node.Kind {
-	case ast.KeyValue:
+	case unstable.KeyValue:
-		return s.checkKeyValue(s.current, node)
+		return s.checkKeyValue(node)
-	case ast.Table:
+	case unstable.Table:
 		return s.checkTable(node)
-	case ast.ArrayTable:
+	case unstable.ArrayTable:
 		return s.checkArrayTable(node)
 	default:
 		panic(fmt.Errorf("this should not be a top level node type: %s", node.Kind))
 	}
 }
-func (s *SeenTracker) checkTable(node ast.Node) error {
+
-	s.current = s.root
+func (s *SeenTracker) checkTable(node *unstable.Node) (bool, error) {
 	if s.currentIdx >= 0 {
 		s.setExplicitFlag(s.currentIdx)
 	}
 	it := node.Key()
-	// handle the first parts of the key, excluding the last one
+
 	parentIdx := 0
 	// This code is duplicated in checkArrayTable. This is because factoring
 	// it in a function requires to copy the iterator, or allocate it to the
 	// heap, which is not cheap.
 	for it.Next() {
-		if !it.Node().Next().Valid() {
+		if it.IsLast() {
 			break
 		}
-		k := string(it.Node().Data)
+		k := it.Node().Data
 		child, found := s.current.Has(k)
 		if !found {
 			child = s.current.CreateTable(k, false)
 		}
 		s.current = child
 	}
-	// handle the last part of the key
+		idx := s.find(parentIdx, k)
 	k := string(it.Node().Data)
-	i, found := s.current.Has(k)
+		if idx < 0 {
-	if found {
+			idx = s.create(parentIdx, k, tableKind, false, false)
 		if i.kind != tableKind {
 			return fmt.Errorf("key %s should be a table", k)
 		}
 		if i.explicit {
 			return fmt.Errorf("table %s already exists", k)
 		}
 		i.explicit = true
 		s.current = i
 	} else {
 		s.current = s.current.CreateTable(k, true)
 	}
 	return nil
 }
 func (s *SeenTracker) checkArrayTable(node ast.Node) error {
 	s.current = s.root
 	it := node.Key()
 	// handle the first parts of the key, excluding the last one
 	for it.Next() {
 		if !it.Node().Next().Valid() {
 			break
 		}
 		k := string(it.Node().Data)
 		child, found := s.current.Has(k)
 		if !found {
 			child = s.current.CreateTable(k, false)
 		}
 		s.current = child
 	}
 	// handle the last part of the key
 	k := string(it.Node().Data)
 	info, found := s.current.Has(k)
 	if found {
 		if info.kind != arrayTableKind {
 			return fmt.Errorf("key %s already exists but is not an array table", k)
 		}
 		info.Clear()
 	} else {
 		info = s.current.CreateArrayTable(k, true)
 	}
 	s.current = info
 	return nil
 }
 func (s *SeenTracker) checkKeyValue(context *info, node ast.Node) error {
 	it := node.Key()
 	// handle the first parts of the key, excluding the last one
 	for it.Next() {
 		k := string(it.Node().Data)
 		child, found := context.Has(k)
 		if found {
 			if child.kind != tableKind {
 				return fmt.Errorf("expected %s to be a table, not a %s", k, child.kind)
 			}
 		} else {
-			child = context.CreateTable(k, false)
+			entry := s.entries[idx]
 			if entry.kind == valueKind {
 				return false, fmt.Errorf("toml: expected %s to be a table, not a %s", string(k), entry.kind)
 			}
 		}
-		context = child
+		parentIdx = idx
 	}
-	if node.Value().Kind == ast.InlineTable {
+	k := it.Node().Data
-		context.SetKind(tableKind)
+	idx := s.find(parentIdx, k)
 	first := false
 	if idx >= 0 {
 		kind := s.entries[idx].kind
 		if kind != tableKind {
 			return false, fmt.Errorf("toml: key %s should be a table, not a %s", string(k), kind)
 		}
 		if s.entries[idx].explicit {
 			return false, fmt.Errorf("toml: table %s already exists", string(k))
 		}
 		s.entries[idx].explicit = true
 	} else {
-		context.SetKind(valueKind)
+		idx = s.create(parentIdx, k, tableKind, true, false)
 		first = true
 	}
-	return nil
+	s.currentIdx = idx
 	return first, nil
 }
 func (s *SeenTracker) checkArrayTable(node *unstable.Node) (bool, error) {
 	if s.currentIdx >= 0 {
 		s.setExplicitFlag(s.currentIdx)
 	}
 	it := node.Key()
 	parentIdx := 0
 	for it.Next() {
 		if it.IsLast() {
 			break
 		}
 		k := it.Node().Data
 		idx := s.find(parentIdx, k)
 		if idx < 0 {
 			idx = s.create(parentIdx, k, tableKind, false, false)
 		} else {
 			entry := s.entries[idx]
 			if entry.kind == valueKind {
 				return false, fmt.Errorf("toml: expected %s to be a table, not a %s", string(k), entry.kind)
 			}
 		}
 		parentIdx = idx
 	}
 	k := it.Node().Data
 	idx := s.find(parentIdx, k)
 	firstTime := idx < 0
 	if firstTime {
 		idx = s.create(parentIdx, k, arrayTableKind, true, false)
 	} else {
 		kind := s.entries[idx].kind
 		if kind != arrayTableKind {
 			return false, fmt.Errorf("toml: key %s already exists as a %s,  but should be an array table", kind, string(k))
 		}
 		s.clear(idx)
 	}
 	s.currentIdx = idx
 	return firstTime, nil
 }
 func (s *SeenTracker) checkKeyValue(node *unstable.Node) (bool, error) {
 	parentIdx := s.currentIdx
 	it := node.Key()
 	for it.Next() {
 		k := it.Node().Data
 		idx := s.find(parentIdx, k)
 		if idx < 0 {
 			idx = s.create(parentIdx, k, tableKind, false, true)
 		} else {
 			entry := s.entries[idx]
 			switch {
 			case it.IsLast():
 				return false, fmt.Errorf("toml: key %s is already defined", string(k))
 			case entry.kind != tableKind:
 				return false, fmt.Errorf("toml: expected %s to be a table, not a %s", string(k), entry.kind)
 			case entry.explicit:
 				return false, fmt.Errorf("toml: cannot redefine table %s that has already been explicitly defined", string(k))
 			}
 		}
 		parentIdx = idx
 	}
 	s.entries[parentIdx].kind = valueKind
 	value := node.Value()
 	switch value.Kind {
 	case unstable.InlineTable:
 		return s.checkInlineTable(value)
 	case unstable.Array:
 		return s.checkArray(value)
 	default:
 		return false, nil
 	}
 }
 func (s *SeenTracker) checkArray(node *unstable.Node) (first bool, err error) {
 	it := node.Children()
 	for it.Next() {
 		n := it.Node()
 		switch n.Kind { //nolint:exhaustive
 		case unstable.InlineTable:
 			first, err = s.checkInlineTable(n)
 			if err != nil {
 				return false, err
 			}
 		case unstable.Array:
 			first, err = s.checkArray(n)
 			if err != nil {
 				return false, err
 			}
 		}
 	}
 	return first, nil
 }
 func (s *SeenTracker) checkInlineTable(node *unstable.Node) (first bool, err error) {
 	s = pool.Get().(*SeenTracker)
 	s.reset()
 	it := node.Children()
 	for it.Next() {
 		n := it.Node()
 		first, err = s.checkKeyValue(n)
 		if err != nil {
 			return false, err
 		}
 	}
 	// As inline tables are self-contained, the tracker does not
 	// need to retain the details of what they contain. The
 	// keyValue element that creates the inline table is kept to
 	// mark the presence of the inline table and prevent
 	// redefinition of its keys: check* functions cannot walk into
 	// a value.
 	pool.Put(s)
 	return first, nil
 }
@@ -0,0 +1,21 @@
 package tracker
 import (
 	"reflect"
 	"testing"
 	"github.com/pelletier/go-toml/v2/internal/assert"
 )
 func TestEntrySize(t *testing.T) {
 	// Validate no regression on the size of entry{}. This is a critical bit for
 	// performance of unmarshaling documents. Should only be increased with care
 	// and a very good reason.
 	maxExpectedEntrySize := 48
 	entrySize := int(reflect.TypeOf(entry{}).Size())
 	assert.True(t,
 		entrySize <= maxExpectedEntrySize,
 		"Expected entry to be less than or equal to %d, got: %d",
 		maxExpectedEntrySize, entrySize,
 	)
 }
@@ -1 +1,2 @@
 // Package tracker provides functions for keeping track of AST nodes.
 package tracker
@@ -1,59 +0,0 @@
 package unsafe
 import (
 	"fmt"
 	"reflect"
 	"unsafe"
 )
 const maxInt = uintptr(int(^uint(0) >> 1))
 func SubsliceOffset(data []byte, subslice []byte) int {
 	datap := (*reflect.SliceHeader)(unsafe.Pointer(&data))
 	hlp := (*reflect.SliceHeader)(unsafe.Pointer(&subslice))
 	if hlp.Data < datap.Data {
 		panic(fmt.Errorf("subslice address (%d) is before data address (%d)", hlp.Data, datap.Data))
 	}
 	offset := hlp.Data - datap.Data
 	if offset > maxInt {
 		panic(fmt.Errorf("slice offset larger than int (%d)", offset))
 	}
 	intoffset := int(offset)
 	if intoffset > datap.Len {
 		panic(fmt.Errorf("slice offset (%d) is farther than data length (%d)", intoffset, datap.Len))
 	}
 	if intoffset+hlp.Len > datap.Len {
 		panic(fmt.Errorf("slice ends (%d+%d) is farther than data length (%d)", intoffset, hlp.Len, datap.Len))
 	}
 	return intoffset
 }
 func BytesRange(start []byte, end []byte) []byte {
 	if start == nil || end == nil {
 		panic("cannot call BytesRange with nil")
 	}
 	startp := (*reflect.SliceHeader)(unsafe.Pointer(&start))
 	endp := (*reflect.SliceHeader)(unsafe.Pointer(&end))
 	if startp.Data > endp.Data {
 		panic(fmt.Errorf("start pointer address (%d) is after end pointer address (%d)", startp.Data, endp.Data))
 	}
 	l := startp.Len
 	endLen := int(endp.Data-startp.Data) + endp.Len
 	if endLen > l {
 		l = endLen
 	}
 	if l > startp.Cap {
 		panic(fmt.Errorf("range length is larger than capacity"))
 	}
 	return start[:l]
 }
@@ -1,168 +0,0 @@
 package unsafe_test
 import (
 	"testing"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/pelletier/go-toml/v2/internal/unsafe"
 )
 func TestUnsafeSubsliceOffsetValid(t *testing.T) {
 	examples := []struct {
 		desc   string
 		test   func() ([]byte, []byte)
 		offset int
 	}{
 		{
 			desc: "simple",
 			test: func() ([]byte, []byte) {
 				data := []byte("hello")
 				return data, data[1:]
 			},
 			offset: 1,
 		},
 	}
 	for _, e := range examples {
 		t.Run(e.desc, func(t *testing.T) {
 			d, s := e.test()
 			offset := unsafe.SubsliceOffset(d, s)
 			assert.Equal(t, e.offset, offset)
 		})
 	}
 }
 func TestUnsafeSubsliceOffsetInvalid(t *testing.T) {
 	examples := []struct {
 		desc string
 		test func() ([]byte, []byte)
 	}{
 		{
 			desc: "unrelated arrays",
 			test: func() ([]byte, []byte) {
 				return []byte("one"), []byte("two")
 			},
 		},
 		{
 			desc: "slice starts before data",
 			test: func() ([]byte, []byte) {
 				full := []byte("hello world")
 				return full[5:], full[1:]
 			},
 		},
 		{
 			desc: "slice starts after data",
 			test: func() ([]byte, []byte) {
 				full := []byte("hello world")
 				return full[:3], full[5:]
 			},
 		},
 		{
 			desc: "slice ends after data",
 			test: func() ([]byte, []byte) {
 				full := []byte("hello world")
 				return full[:5], full[3:8]
 			},
 		},
 	}
 	for _, e := range examples {
 		t.Run(e.desc, func(t *testing.T) {
 			d, s := e.test()
 			require.Panics(t, func() {
 				unsafe.SubsliceOffset(d, s)
 			})
 		})
 	}
 }
 func TestUnsafeBytesRange(t *testing.T) {
 	type fn = func() ([]byte, []byte)
 	examples := []struct {
 		desc     string
 		test     fn
 		expected []byte
 	}{
 		{
 			desc: "simple",
 			test: func() ([]byte, []byte) {
 				full := []byte("hello world")
 				return full[1:3], full[6:8]
 			},
 			expected: []byte("ello wo"),
 		},
 		{
 			desc: "full",
 			test: func() ([]byte, []byte) {
 				full := []byte("hello world")
 				return full[0:1], full[len(full)-1:]
 			},
 			expected: []byte("hello world"),
 		},
 		{
 			desc: "end before start",
 			test: func() ([]byte, []byte) {
 				full := []byte("hello world")
 				return full[len(full)-1:], full[0:1]
 			},
 		},
 		{
 			desc: "nils",
 			test: func() ([]byte, []byte) {
 				return nil, nil
 			},
 		},
 		{
 			desc: "nils start",
 			test: func() ([]byte, []byte) {
 				return nil, []byte("foo")
 			},
 		},
 		{
 			desc: "nils end",
 			test: func() ([]byte, []byte) {
 				return []byte("foo"), nil
 			},
 		},
 		{
 			desc: "start is end",
 			test: func() ([]byte, []byte) {
 				full := []byte("hello world")
 				return full[1:3], full[1:3]
 			},
 			expected: []byte("el"),
 		},
 		{
 			desc: "end contained in start",
 			test: func() ([]byte, []byte) {
 				full := []byte("hello world")
 				return full[1:7], full[2:4]
 			},
 			expected: []byte("ello w"),
 		},
 		{
 			desc: "different backing arrays",
 			test: func() ([]byte, []byte) {
 				one := []byte("hello world")
 				two := []byte("hello world")
 				return one, two
 			},
 		},
 	}
 	for _, e := range examples {
 		t.Run(e.desc, func(t *testing.T) {
 			start, end := e.test()
 			if e.expected == nil {
 				require.Panics(t, func() {
 					unsafe.BytesRange(start, end)
 				})
 			} else {
 				res := unsafe.BytesRange(start, end)
 				require.Equal(t, e.expected, res)
 			}
 		})
 	}
 }
@@ -1,300 +1,122 @@
 // Implementation of TOML's local date/time.
 // Copied over from https://github.com/googleapis/google-cloud-go/blob/master/civil/civil.go
 // to avoid pulling all the Google dependencies.
 //
 // Copyright 2016 Google LLC
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 // Package civil implements types for civil time, a time-zone-independent
 // representation of time that follows the rules of the proleptic
 // Gregorian calendar with exactly 24-hour days, 60-minute hours, and 60-second
 // minutes.
 //
 // Because they lack location information, these types do not represent unique
 // moments or intervals of time. Use time.Time for that purpose.
 package toml
 import (
 	"fmt"
 	"strings"
 	"time"
 	"github.com/pelletier/go-toml/v2/unstable"
 )
-// A LocalDate represents a date (year, month, day).
+// LocalDate represents a calendar day in no specific timezone.
 //
 // This type does not include location information, and therefore does not
 // describe a unique 24-hour timespan.
 type LocalDate struct {
-	Year  int        // Year (e.g., 2014).
+	Year  int
-	Month time.Month // Month of the year (January = 1, ...).
+	Month int
-	Day   int        // Day of the month, starting at 1.
+	Day   int
 }
-// LocalDateOf returns the LocalDate in which a time occurs in that time's location.
+// AsTime converts d into a specific time instance at midnight in zone.
-func LocalDateOf(t time.Time) LocalDate {
+func (d LocalDate) AsTime(zone *time.Location) time.Time {
-	var d LocalDate
+	return time.Date(d.Year, time.Month(d.Month), d.Day, 0, 0, 0, 0, zone)
 	d.Year, d.Month, d.Day = t.Date()
 	return d
 }
-// ParseLocalDate parses a string in RFC3339 full-date format and returns the date value it represents.
+// String returns RFC 3339 representation of d.
 func ParseLocalDate(s string) (LocalDate, error) {
 	t, err := time.Parse("2006-01-02", s)
 	if err != nil {
 		return LocalDate{}, fmt.Errorf("ParseLocalDate: %w", err)
 	}
 	return LocalDateOf(t), nil
 }
 // String returns the date in RFC3339 full-date format.
 func (d LocalDate) String() string {
 	return fmt.Sprintf("%04d-%02d-%02d", d.Year, d.Month, d.Day)
 }
-// IsValid reports whether the date is valid.
+// MarshalText returns RFC 3339 representation of d.
 func (d LocalDate) IsValid() bool {
 	return LocalDateOf(d.In(time.UTC)) == d
 }
 // In returns the time corresponding to time 00:00:00 of the date in the location.
 //
 // In is always consistent with time.LocalDate, even when time.LocalDate returns a time
 // on a different day. For example, if loc is America/Indiana/Vincennes, then both
 //     time.LocalDate(1955, time.May, 1, 0, 0, 0, 0, loc)
 // and
 //     civil.LocalDate{Year: 1955, Month: time.May, Day: 1}.In(loc)
 // return 23:00:00 on April 30, 1955.
 //
 // In panics if loc is nil.
 func (d LocalDate) In(loc *time.Location) time.Time {
 	return time.Date(d.Year, d.Month, d.Day, 0, 0, 0, 0, loc)
 }
 // AddDays returns the date that is n days in the future.
 // n can also be negative to go into the past.
 func (d LocalDate) AddDays(n int) LocalDate {
 	return LocalDateOf(d.In(time.UTC).AddDate(0, 0, n))
 }
 // DaysSince returns the signed number of days between the date and s, not including the end day.
 // This is the inverse operation to AddDays.
 func (d LocalDate) DaysSince(s LocalDate) (days int) {
 	// We convert to Unix time so we do not have to worry about leap seconds:
 	// Unix time increases by exactly 86400 seconds per day.
 	deltaUnix := d.In(time.UTC).Unix() - s.In(time.UTC).Unix()
 	const secondsInADay = 86400
 	return int(deltaUnix / secondsInADay)
 }
 // Before reports whether d1 occurs before future date.
 func (d LocalDate) Before(future LocalDate) bool {
 	if d.Year != future.Year {
 		return d.Year < future.Year
 	}
 	if d.Month != future.Month {
 		return d.Month < future.Month
 	}
 	return d.Day < future.Day
 }
 // After reports whether d1 occurs after past date.
 func (d LocalDate) After(past LocalDate) bool {
 	return past.Before(d)
 }
 // MarshalText implements the encoding.TextMarshaler interface.
 // The output is the result of d.String().
 func (d LocalDate) MarshalText() ([]byte, error) {
 	return []byte(d.String()), nil
 }
-// UnmarshalText implements the encoding.TextUnmarshaler interface.
+// UnmarshalText parses b using RFC 3339 to fill d.
-// The date is expected to be a string in a format accepted by ParseLocalDate.
+func (d *LocalDate) UnmarshalText(b []byte) error {
-func (d *LocalDate) UnmarshalText(data []byte) error {
+	res, err := parseLocalDate(b)
-	var err error
+	if err != nil {
-	*d, err = ParseLocalDate(string(data))
+		return err
-
+	}
-	return err
+	*d = res
 	return nil
 }
-// A LocalTime represents a time with nanosecond precision.
+// LocalTime represents a time of day of no specific day in no specific
-//
+// timezone.
 // This type does not include location information, and therefore does not
 // describe a unique moment in time.
 //
 // This type exists to represent the TIME type in storage-based APIs like BigQuery.
 // Most operations on Times are unlikely to be meaningful. Prefer the LocalDateTime type.
 type LocalTime struct {
-	Hour       int // The hour of the day in 24-hour format; range [0-23]
+	Hour       int // Hour of the day: [0; 24[
-	Minute     int // The minute of the hour; range [0-59]
+	Minute     int // Minute of the hour: [0; 60[
-	Second     int // The second of the minute; range [0-59]
+	Second     int // Second of the minute: [0; 59]
-	Nanosecond int // The nanosecond of the second; range [0-999999999]
+	Nanosecond int // Nanoseconds within the second:  [0, 1000000000[
 	Precision  int // Number of digits to display for Nanosecond.
 }
-// LocalTimeOf returns the LocalTime representing the time of day in which a time occurs
+// String returns RFC 3339 representation of d.
-// in that time's location. It ignores the date.
+// If d.Nanosecond and d.Precision are zero, the time won't have a nanosecond
-func LocalTimeOf(t time.Time) LocalTime {
+// component. If d.Nanosecond > 0 but d.Precision = 0, then the minimum number
-	var tm LocalTime
+// of digits for nanoseconds is provided.
-	tm.Hour, tm.Minute, tm.Second = t.Clock()
+func (d LocalTime) String() string {
-	tm.Nanosecond = t.Nanosecond()
+	s := fmt.Sprintf("%02d:%02d:%02d", d.Hour, d.Minute, d.Second)
-	return tm
+	if d.Precision > 0 {
 		s += fmt.Sprintf(".%09d", d.Nanosecond)[:d.Precision+1]
 	} else if d.Nanosecond > 0 {
 		// Nanoseconds are specified, but precision is not provided. Use the
 		// minimum.
 		s += strings.Trim(fmt.Sprintf(".%09d", d.Nanosecond), "0")
 	}
 	return s
 }
-// ParseLocalTime parses a string and returns the time value it represents.
+// MarshalText returns RFC 3339 representation of d.
-// ParseLocalTime accepts an extended form of the RFC3339 partial-time format. After
+func (d LocalTime) MarshalText() ([]byte, error) {
-// the HH:MM:SS part of the string, an optional fractional part may appear,
+	return []byte(d.String()), nil
-// consisting of a decimal point followed by one to nine decimal digits.
+}
-// (RFC3339 admits only one digit after the decimal point).
+
-func ParseLocalTime(s string) (LocalTime, error) {
+// UnmarshalText parses b using RFC 3339 to fill d.
-	t, err := time.Parse("15:04:05.999999999", s)
+func (d *LocalTime) UnmarshalText(b []byte) error {
 	res, left, err := parseLocalTime(b)
 	if err == nil && len(left) != 0 {
 		err = unstable.NewParserError(left, "extra characters")
 	}
 	if err != nil {
-		return LocalTime{}, fmt.Errorf("ParseLocalTime: %w", err)
+		return err
 	}
-
+	*d = res
-	return LocalTimeOf(t), nil
+	return nil
 }
-// String returns the date in the format described in ParseLocalTime. If Nanoseconds
+// LocalDateTime represents a time of a specific day in no specific timezone.
 // is zero, no fractional part will be generated. Otherwise, the result will
 // end with a fractional part consisting of a decimal point and nine digits.
 func (t LocalTime) String() string {
 	s := fmt.Sprintf("%02d:%02d:%02d", t.Hour, t.Minute, t.Second)
 	if t.Nanosecond == 0 {
 		return s
 	}
 	return s + fmt.Sprintf(".%09d", t.Nanosecond)
 }
 // IsValid reports whether the time is valid.
 func (t LocalTime) IsValid() bool {
 	// Construct a non-zero time.
 	tm := time.Date(2, 2, 2, t.Hour, t.Minute, t.Second, t.Nanosecond, time.UTC)
 	return LocalTimeOf(tm) == t
 }
 // MarshalText implements the encoding.TextMarshaler interface.
 // The output is the result of t.String().
 func (t LocalTime) MarshalText() ([]byte, error) {
 	return []byte(t.String()), nil
 }
 // UnmarshalText implements the encoding.TextUnmarshaler interface.
 // The time is expected to be a string in a format accepted by ParseLocalTime.
 func (t *LocalTime) UnmarshalText(data []byte) error {
 	var err error
 	*t, err = ParseLocalTime(string(data))
 	return err
 }
 // A LocalDateTime represents a date and time.
 //
 // This type does not include location information, and therefore does not
 // describe a unique moment in time.
 type LocalDateTime struct {
-	Date LocalDate
+	LocalDate
-	Time LocalTime
+	LocalTime
 }
-// Note: We deliberately do not embed LocalDate into LocalDateTime, to avoid promoting AddDays and Sub.
+// AsTime converts d into a specific time instance in zone.
 func (d LocalDateTime) AsTime(zone *time.Location) time.Time {
 	return time.Date(d.Year, time.Month(d.Month), d.Day, d.Hour, d.Minute, d.Second, d.Nanosecond, zone)
 }
-// LocalDateTimeOf returns the LocalDateTime in which a time occurs in that time's location.
+// String returns RFC 3339 representation of d.
-func LocalDateTimeOf(t time.Time) LocalDateTime {
+func (d LocalDateTime) String() string {
-	return LocalDateTime{
+	return d.LocalDate.String() + "T" + d.LocalTime.String()
-		Date: LocalDateOf(t),
+}
-		Time: LocalTimeOf(t),
+
 // MarshalText returns RFC 3339 representation of d.
 func (d LocalDateTime) MarshalText() ([]byte, error) {
 	return []byte(d.String()), nil
 }
 // UnmarshalText parses b using RFC 3339 to fill d.
 func (d *LocalDateTime) UnmarshalText(data []byte) error {
 	res, left, err := parseLocalDateTime(data)
 	if err == nil && len(left) != 0 {
 		err = unstable.NewParserError(left, "extra characters")
 	}
 }
 // ParseLocalDateTime parses a string and returns the LocalDateTime it represents.
 // ParseLocalDateTime accepts a variant of the RFC3339 date-time format that omits
 // the time offset but includes an optional fractional time, as described in
 // ParseLocalTime. Informally, the accepted format is
 //     YYYY-MM-DDTHH:MM:SS[.FFFFFFFFF]
 // where the 'T' may be a lower-case 't'.
 func ParseLocalDateTime(s string) (LocalDateTime, error) {
 	t, err := time.Parse("2006-01-02T15:04:05.999999999", s)
 	if err != nil {
-		t, err = time.Parse("2006-01-02t15:04:05.999999999", s)
+		return err
 		if err != nil {
 			return LocalDateTime{}, fmt.Errorf("ParseLocalDateTime: %w", err)
 		}
 	}
-	return LocalDateTimeOf(t), nil
+	*d = res
-}
+	return nil
 // String returns the date in the format described in ParseLocalDate.
 func (dt LocalDateTime) String() string {
 	return dt.Date.String() + "T" + dt.Time.String()
 }
 // IsValid reports whether the datetime is valid.
 func (dt LocalDateTime) IsValid() bool {
 	return dt.Date.IsValid() && dt.Time.IsValid()
 }
 // In returns the time corresponding to the LocalDateTime in the given location.
 //
 // If the time is missing or ambigous at the location, In returns the same
 // result as time.LocalDate. For example, if loc is America/Indiana/Vincennes, then
 // both
 //     time.LocalDate(1955, time.May, 1, 0, 30, 0, 0, loc)
 // and
 //     civil.LocalDateTime{
 //         civil.LocalDate{Year: 1955, Month: time.May, Day: 1}},
 //         civil.LocalTime{Minute: 30}}.In(loc)
 // return 23:30:00 on April 30, 1955.
 //
 // In panics if loc is nil.
 func (dt LocalDateTime) In(loc *time.Location) time.Time {
 	return time.Date(
 		dt.Date.Year, dt.Date.Month, dt.Date.Day,
 		dt.Time.Hour, dt.Time.Minute, dt.Time.Second, dt.Time.Nanosecond, loc,
 	)
 }
 // Before reports whether dt occurs before future.
 func (dt LocalDateTime) Before(future LocalDateTime) bool {
 	return dt.In(time.UTC).Before(future.In(time.UTC))
 }
 // After reports whether dt occurs after past.
 func (dt LocalDateTime) After(past LocalDateTime) bool {
 	return past.Before(dt)
 }
 // MarshalText implements the encoding.TextMarshaler interface.
 // The output is the result of dt.String().
 func (dt LocalDateTime) MarshalText() ([]byte, error) {
 	return []byte(dt.String()), nil
 }
 // UnmarshalText implements the encoding.TextUnmarshaler interface.
 // The datetime is expected to be a string in a format accepted by ParseLocalDateTime.
 func (dt *LocalDateTime) UnmarshalText(data []byte) error {
 	var err error
 	*dt, err = ParseLocalDateTime(string(data))
 	return err
 }
@@ -1,489 +1,118 @@
-// Copyright 2016 Google LLC
+package toml_test
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 package toml
 import (
 	"encoding/json"
 	"reflect"
 	"testing"
 	"time"
 	"github.com/pelletier/go-toml/v2"
 	"github.com/pelletier/go-toml/v2/internal/assert"
 )
-func cmpEqual(x, y interface{}) bool {
+func TestLocalDate_AsTime(t *testing.T) {
-	return reflect.DeepEqual(x, y)
+	d := toml.LocalDate{2021, 6, 8}
 	cast := d.AsTime(time.UTC)
 	assert.Equal(t, time.Date(2021, time.June, 8, 0, 0, 0, 0, time.UTC), cast)
 }
-func TestDates(t *testing.T) {
+func TestLocalDate_String(t *testing.T) {
-	t.Parallel()
+	d := toml.LocalDate{2021, 6, 8}
-
+	assert.Equal(t, "2021-06-08", d.String())
 	for _, test := range []struct {
 		date     LocalDate
 		loc      *time.Location
 		wantStr  string
 		wantTime time.Time
 	}{
 		{
 			date:     LocalDate{2014, 7, 29},
 			loc:      time.Local,
 			wantStr:  "2014-07-29",
 			wantTime: time.Date(2014, time.July, 29, 0, 0, 0, 0, time.Local),
 		},
 		{
 			date:     LocalDateOf(time.Date(2014, 8, 20, 15, 8, 43, 1, time.Local)),
 			loc:      time.UTC,
 			wantStr:  "2014-08-20",
 			wantTime: time.Date(2014, 8, 20, 0, 0, 0, 0, time.UTC),
 		},
 		{
 			date:     LocalDateOf(time.Date(999, time.January, 26, 0, 0, 0, 0, time.Local)),
 			loc:      time.UTC,
 			wantStr:  "0999-01-26",
 			wantTime: time.Date(999, 1, 26, 0, 0, 0, 0, time.UTC),
 		},
 	} {
 		if got := test.date.String(); got != test.wantStr {
 			t.Errorf("%#v.String() = %q, want %q", test.date, got, test.wantStr)
 		}
 		if got := test.date.In(test.loc); !got.Equal(test.wantTime) {
 			t.Errorf("%#v.In(%v) = %v, want %v", test.date, test.loc, got, test.wantTime)
 		}
 	}
 }
-func TestDateIsValid(t *testing.T) {
+func TestLocalDate_MarshalText(t *testing.T) {
-	t.Parallel()
+	d := toml.LocalDate{2021, 6, 8}
-
+	b, err := d.MarshalText()
-	for _, test := range []struct {
+	assert.NoError(t, err)
-		date LocalDate
+	assert.Equal(t, []byte("2021-06-08"), b)
 		want bool
 	}{
 		{LocalDate{2014, 7, 29}, true},
 		{LocalDate{2000, 2, 29}, true},
 		{LocalDate{10000, 12, 31}, true},
 		{LocalDate{1, 1, 1}, true},
 		{LocalDate{0, 1, 1}, true},  // year zero is OK
 		{LocalDate{-1, 1, 1}, true}, // negative year is OK
 		{LocalDate{1, 0, 1}, false},
 		{LocalDate{1, 1, 0}, false},
 		{LocalDate{2016, 1, 32}, false},
 		{LocalDate{2016, 13, 1}, false},
 		{LocalDate{1, -1, 1}, false},
 		{LocalDate{1, 1, -1}, false},
 	} {
 		got := test.date.IsValid()
 		if got != test.want {
 			t.Errorf("%#v: got %t, want %t", test.date, got, test.want)
 		}
 	}
 }
-func TestParseDate(t *testing.T) {
+func TestLocalDate_UnmarshalMarshalText(t *testing.T) {
-	t.Parallel()
+	d := toml.LocalDate{}
 	err := d.UnmarshalText([]byte("2021-06-08"))
 	assert.NoError(t, err)
 	assert.Equal(t, toml.LocalDate{2021, 6, 8}, d)
-	var emptyDate LocalDate
+	err = d.UnmarshalText([]byte("what"))
-
+	assert.Error(t, err)
 	for _, test := range []struct {
 		str  string
 		want LocalDate // if empty, expect an error
 	}{
 		{"2016-01-02", LocalDate{2016, 1, 2}},
 		{"2016-12-31", LocalDate{2016, 12, 31}},
 		{"0003-02-04", LocalDate{3, 2, 4}},
 		{"999-01-26", emptyDate},
 		{"", emptyDate},
 		{"2016-01-02x", emptyDate},
 	} {
 		got, err := ParseLocalDate(test.str)
 		if got != test.want {
 			t.Errorf("ParseLocalDate(%q) = %+v, want %+v", test.str, got, test.want)
 		}
 		if err != nil && test.want != (emptyDate) {
 			t.Errorf("Unexpected error %v from ParseLocalDate(%q)", err, test.str)
 		}
 	}
 }
-func TestDateArithmetic(t *testing.T) {
+func TestLocalTime_String(t *testing.T) {
-	t.Parallel()
+	d := toml.LocalTime{20, 12, 1, 2, 9}
-
+	assert.Equal(t, "20:12:01.000000002", d.String())
-	for _, test := range []struct {
+	d = toml.LocalTime{20, 12, 1, 0, 0}
-		desc  string
+	assert.Equal(t, "20:12:01", d.String())
-		start LocalDate
+	d = toml.LocalTime{20, 12, 1, 0, 9}
-		end   LocalDate
+	assert.Equal(t, "20:12:01.000000000", d.String())
-		days  int
+	d = toml.LocalTime{20, 12, 1, 100, 0}
-	}{
+	assert.Equal(t, "20:12:01.0000001", d.String())
 		{
 			desc:  "zero days noop",
 			start: LocalDate{2014, 5, 9},
 			end:   LocalDate{2014, 5, 9},
 			days:  0,
 		},
 		{
 			desc:  "crossing a year boundary",
 			start: LocalDate{2014, 12, 31},
 			end:   LocalDate{2015, 1, 1},
 			days:  1,
 		},
 		{
 			desc:  "negative number of days",
 			start: LocalDate{2015, 1, 1},
 			end:   LocalDate{2014, 12, 31},
 			days:  -1,
 		},
 		{
 			desc:  "full leap year",
 			start: LocalDate{2004, 1, 1},
 			end:   LocalDate{2005, 1, 1},
 			days:  366,
 		},
 		{
 			desc:  "full non-leap year",
 			start: LocalDate{2001, 1, 1},
 			end:   LocalDate{2002, 1, 1},
 			days:  365,
 		},
 		{
 			desc:  "crossing a leap second",
 			start: LocalDate{1972, 6, 30},
 			end:   LocalDate{1972, 7, 1},
 			days:  1,
 		},
 		{
 			desc:  "dates before the unix epoch",
 			start: LocalDate{101, 1, 1},
 			end:   LocalDate{102, 1, 1},
 			days:  365,
 		},
 	} {
 		if got := test.start.AddDays(test.days); got != test.end {
 			t.Errorf("[%s] %#v.AddDays(%v) = %#v, want %#v", test.desc, test.start, test.days, got, test.end)
 		}
 		if got := test.end.DaysSince(test.start); got != test.days {
 			t.Errorf("[%s] %#v.Sub(%#v) = %v, want %v", test.desc, test.end, test.start, got, test.days)
 		}
 	}
 }
-func TestDateBefore(t *testing.T) {
+func TestLocalTime_MarshalText(t *testing.T) {
-	t.Parallel()
+	d := toml.LocalTime{20, 12, 1, 2, 9}
-
+	b, err := d.MarshalText()
-	for _, test := range []struct {
+	assert.NoError(t, err)
-		d1, d2 LocalDate
+	assert.Equal(t, []byte("20:12:01.000000002"), b)
 		want   bool
 	}{
 		{LocalDate{2016, 12, 31}, LocalDate{2017, 1, 1}, true},
 		{LocalDate{2016, 1, 1}, LocalDate{2016, 1, 1}, false},
 		{LocalDate{2016, 12, 30}, LocalDate{2016, 12, 31}, true},
 		{LocalDate{2016, 1, 30}, LocalDate{2016, 12, 31}, true},
 	} {
 		if got := test.d1.Before(test.d2); got != test.want {
 			t.Errorf("%v.Before(%v): got %t, want %t", test.d1, test.d2, got, test.want)
 		}
 	}
 }
-func TestDateAfter(t *testing.T) {
+func TestLocalTime_UnmarshalMarshalText(t *testing.T) {
-	t.Parallel()
+	d := toml.LocalTime{}
 	err := d.UnmarshalText([]byte("20:12:01.000000002"))
 	assert.NoError(t, err)
 	assert.Equal(t, toml.LocalTime{20, 12, 1, 2, 9}, d)
-	for _, test := range []struct {
+	err = d.UnmarshalText([]byte("what"))
-		d1, d2 LocalDate
+	assert.Error(t, err)
-		want   bool
+
-	}{
+	err = d.UnmarshalText([]byte("20:12:01.000000002 bad"))
-		{LocalDate{2016, 12, 31}, LocalDate{2017, 1, 1}, false},
+	assert.Error(t, err)
 		{LocalDate{2016, 1, 1}, LocalDate{2016, 1, 1}, false},
 		{LocalDate{2016, 12, 30}, LocalDate{2016, 12, 31}, false},
 	} {
 		if got := test.d1.After(test.d2); got != test.want {
 			t.Errorf("%v.After(%v): got %t, want %t", test.d1, test.d2, got, test.want)
 		}
 	}
 }
-func TestTimeToString(t *testing.T) {
+func TestLocalTime_RoundTrip(t *testing.T) {
-	t.Parallel()
+	var d struct{ A toml.LocalTime }
-
+	err := toml.Unmarshal([]byte("a=20:12:01.500"), &d)
-	for _, test := range []struct {
+	assert.NoError(t, err)
-		str       string
+	assert.Equal(t, "20:12:01.500", d.A.String())
 		time      LocalTime
 		roundTrip bool // ParseLocalTime(str).String() == str?
 	}{
 		{"13:26:33", LocalTime{13, 26, 33, 0}, true},
 		{"01:02:03.000023456", LocalTime{1, 2, 3, 23456}, true},
 		{"00:00:00.000000001", LocalTime{0, 0, 0, 1}, true},
 		{"13:26:03.1", LocalTime{13, 26, 3, 100000000}, false},
 		{"13:26:33.0000003", LocalTime{13, 26, 33, 300}, false},
 	} {
 		gotTime, err := ParseLocalTime(test.str)
 		if err != nil {
 			t.Errorf("ParseLocalTime(%q): got error: %v", test.str, err)
 			continue
 		}
 		if gotTime != test.time {
 			t.Errorf("ParseLocalTime(%q) = %+v, want %+v", test.str, gotTime, test.time)
 		}
 		if test.roundTrip {
 			gotStr := test.time.String()
 			if gotStr != test.str {
 				t.Errorf("%#v.String() = %q, want %q", test.time, gotStr, test.str)
 			}
 		}
 	}
 }
-func TestTimeOf(t *testing.T) {
+func TestLocalDateTime_AsTime(t *testing.T) {
-	t.Parallel()
+	d := toml.LocalDateTime{
-
+		toml.LocalDate{2021, 6, 8},
-	for _, test := range []struct {
+		toml.LocalTime{20, 12, 1, 2, 9},
 		time time.Time
 		want LocalTime
 	}{
 		{time.Date(2014, 8, 20, 15, 8, 43, 1, time.Local), LocalTime{15, 8, 43, 1}},
 		{time.Date(1, 1, 1, 0, 0, 0, 0, time.UTC), LocalTime{0, 0, 0, 0}},
 	} {
 		if got := LocalTimeOf(test.time); got != test.want {
 			t.Errorf("LocalTimeOf(%v) = %+v, want %+v", test.time, got, test.want)
 		}
 	}
 	cast := d.AsTime(time.UTC)
 	assert.Equal(t, time.Date(2021, time.June, 8, 20, 12, 1, 2, time.UTC), cast)
 }
-func TestTimeIsValid(t *testing.T) {
+func TestLocalDateTime_String(t *testing.T) {
-	t.Parallel()
+	d := toml.LocalDateTime{
-
+		toml.LocalDate{2021, 6, 8},
-	for _, test := range []struct {
+		toml.LocalTime{20, 12, 1, 2, 9},
 		time LocalTime
 		want bool
 	}{
 		{LocalTime{0, 0, 0, 0}, true},
 		{LocalTime{23, 0, 0, 0}, true},
 		{LocalTime{23, 59, 59, 999999999}, true},
 		{LocalTime{24, 59, 59, 999999999}, false},
 		{LocalTime{23, 60, 59, 999999999}, false},
 		{LocalTime{23, 59, 60, 999999999}, false},
 		{LocalTime{23, 59, 59, 1000000000}, false},
 		{LocalTime{-1, 0, 0, 0}, false},
 		{LocalTime{0, -1, 0, 0}, false},
 		{LocalTime{0, 0, -1, 0}, false},
 		{LocalTime{0, 0, 0, -1}, false},
 	} {
 		got := test.time.IsValid()
 		if got != test.want {
 			t.Errorf("%#v: got %t, want %t", test.time, got, test.want)
 		}
 	}
 	assert.Equal(t, "2021-06-08T20:12:01.000000002", d.String())
 }
-func TestDateTimeToString(t *testing.T) {
+func TestLocalDateTime_MarshalText(t *testing.T) {
-	t.Parallel()
+	d := toml.LocalDateTime{
-
+		toml.LocalDate{2021, 6, 8},
-	for _, test := range []struct {
+		toml.LocalTime{20, 12, 1, 2, 9},
 		str       string
 		dateTime  LocalDateTime
 		roundTrip bool // ParseLocalDateTime(str).String() == str?
 	}{
 		{"2016-03-22T13:26:33", LocalDateTime{LocalDate{2016, 03, 22}, LocalTime{13, 26, 33, 0}}, true},
 		{"2016-03-22T13:26:33.000000600", LocalDateTime{LocalDate{2016, 03, 22}, LocalTime{13, 26, 33, 600}}, true},
 		{"2016-03-22t13:26:33", LocalDateTime{LocalDate{2016, 03, 22}, LocalTime{13, 26, 33, 0}}, false},
 	} {
 		gotDateTime, err := ParseLocalDateTime(test.str)
 		if err != nil {
 			t.Errorf("ParseLocalDateTime(%q): got error: %v", test.str, err)
 			continue
 		}
 		if gotDateTime != test.dateTime {
 			t.Errorf("ParseLocalDateTime(%q) = %+v, want %+v", test.str, gotDateTime, test.dateTime)
 		}
 		if test.roundTrip {
 			gotStr := test.dateTime.String()
 			if gotStr != test.str {
 				t.Errorf("%#v.String() = %q, want %q", test.dateTime, gotStr, test.str)
 			}
 		}
 	}
 	b, err := d.MarshalText()
 	assert.NoError(t, err)
 	assert.Equal(t, []byte("2021-06-08T20:12:01.000000002"), b)
 }
-func TestParseDateTimeErrors(t *testing.T) {
+func TestLocalDateTime_UnmarshalMarshalText(t *testing.T) {
-	t.Parallel()
+	d := toml.LocalDateTime{}
 	err := d.UnmarshalText([]byte("2021-06-08 20:12:01.000000002"))
 	assert.NoError(t, err)
 	assert.Equal(t, toml.LocalDateTime{
 		toml.LocalDate{2021, 6, 8},
 		toml.LocalTime{20, 12, 1, 2, 9},
 	}, d)
-	for _, str := range []string{
+	err = d.UnmarshalText([]byte("what"))
-		"",
+	assert.Error(t, err)
-		"2016-03-22",           // just a date
+
-		"13:26:33",             // just a time
+	err = d.UnmarshalText([]byte("2021-06-08 20:12:01.000000002 bad"))
-		"2016-03-22 13:26:33",  // wrong separating character
+	assert.Error(t, err)
 		"2016-03-22T13:26:33x", // extra at end
 	} {
 		if _, err := ParseLocalDateTime(str); err == nil {
 			t.Errorf("ParseLocalDateTime(%q) succeeded, want error", str)
 		}
 	}
 }
 func TestDateTimeOf(t *testing.T) {
 	t.Parallel()
 	for _, test := range []struct {
 		time time.Time
 		want LocalDateTime
 	}{
 		{time.Date(2014, 8, 20, 15, 8, 43, 1, time.Local),
 			LocalDateTime{LocalDate{2014, 8, 20}, LocalTime{15, 8, 43, 1}}},
 		{time.Date(1, 1, 1, 0, 0, 0, 0, time.UTC),
 			LocalDateTime{LocalDate{1, 1, 1}, LocalTime{0, 0, 0, 0}}},
 	} {
 		if got := LocalDateTimeOf(test.time); got != test.want {
 			t.Errorf("LocalDateTimeOf(%v) = %+v, want %+v", test.time, got, test.want)
 		}
 	}
 }
 func TestDateTimeIsValid(t *testing.T) {
 	t.Parallel()
 	// No need to be exhaustive here; it's just LocalDate.IsValid && LocalTime.IsValid.
 	for _, test := range []struct {
 		dt   LocalDateTime
 		want bool
 	}{
 		{LocalDateTime{LocalDate{2016, 3, 20}, LocalTime{0, 0, 0, 0}}, true},
 		{LocalDateTime{LocalDate{2016, -3, 20}, LocalTime{0, 0, 0, 0}}, false},
 		{LocalDateTime{LocalDate{2016, 3, 20}, LocalTime{24, 0, 0, 0}}, false},
 	} {
 		got := test.dt.IsValid()
 		if got != test.want {
 			t.Errorf("%#v: got %t, want %t", test.dt, got, test.want)
 		}
 	}
 }
 func TestDateTimeIn(t *testing.T) {
 	t.Parallel()
 	dt := LocalDateTime{LocalDate{2016, 1, 2}, LocalTime{3, 4, 5, 6}}
 	want := time.Date(2016, 1, 2, 3, 4, 5, 6, time.UTC)
 	if got := dt.In(time.UTC); !got.Equal(want) {
 		t.Errorf("got %v, want %v", got, want)
 	}
 }
 func TestDateTimeBefore(t *testing.T) {
 	t.Parallel()
 	d1 := LocalDate{2016, 12, 31}
 	d2 := LocalDate{2017, 1, 1}
 	t1 := LocalTime{5, 6, 7, 8}
 	t2 := LocalTime{5, 6, 7, 9}
 	for _, test := range []struct {
 		dt1, dt2 LocalDateTime
 		want     bool
 	}{
 		{LocalDateTime{d1, t1}, LocalDateTime{d2, t1}, true},
 		{LocalDateTime{d1, t1}, LocalDateTime{d1, t2}, true},
 		{LocalDateTime{d2, t1}, LocalDateTime{d1, t1}, false},
 		{LocalDateTime{d2, t1}, LocalDateTime{d2, t1}, false},
 	} {
 		if got := test.dt1.Before(test.dt2); got != test.want {
 			t.Errorf("%v.Before(%v): got %t, want %t", test.dt1, test.dt2, got, test.want)
 		}
 	}
 }
 func TestDateTimeAfter(t *testing.T) {
 	t.Parallel()
 	d1 := LocalDate{2016, 12, 31}
 	d2 := LocalDate{2017, 1, 1}
 	t1 := LocalTime{5, 6, 7, 8}
 	t2 := LocalTime{5, 6, 7, 9}
 	for _, test := range []struct {
 		dt1, dt2 LocalDateTime
 		want     bool
 	}{
 		{LocalDateTime{d1, t1}, LocalDateTime{d2, t1}, false},
 		{LocalDateTime{d1, t1}, LocalDateTime{d1, t2}, false},
 		{LocalDateTime{d2, t1}, LocalDateTime{d1, t1}, true},
 		{LocalDateTime{d2, t1}, LocalDateTime{d2, t1}, false},
 	} {
 		if got := test.dt1.After(test.dt2); got != test.want {
 			t.Errorf("%v.After(%v): got %t, want %t", test.dt1, test.dt2, got, test.want)
 		}
 	}
 }
 func TestMarshalJSON(t *testing.T) {
 	t.Parallel()
 	for _, test := range []struct {
 		value interface{}
 		want  string
 	}{
 		{LocalDate{1987, 4, 15}, `"1987-04-15"`},
 		{LocalTime{18, 54, 2, 0}, `"18:54:02"`},
 		{LocalDateTime{LocalDate{1987, 4, 15}, LocalTime{18, 54, 2, 0}}, `"1987-04-15T18:54:02"`},
 	} {
 		bgot, err := json.Marshal(test.value)
 		if err != nil {
 			t.Fatal(err)
 		}
 		if got := string(bgot); got != test.want {
 			t.Errorf("%#v: got %s, want %s", test.value, got, test.want)
 		}
 	}
 }
 func TestUnmarshalJSON(t *testing.T) {
 	t.Parallel()
 	var d LocalDate
 	var tm LocalTime
 	var dt LocalDateTime
 	for _, test := range []struct {
 		data string
 		ptr  interface{}
 		want interface{}
 	}{
 		{`"1987-04-15"`, &d, &LocalDate{1987, 4, 15}},
 		{`"1987-04-\u0031\u0035"`, &d, &LocalDate{1987, 4, 15}},
 		{`"18:54:02"`, &tm, &LocalTime{18, 54, 2, 0}},
 		{`"1987-04-15T18:54:02"`, &dt, &LocalDateTime{LocalDate{1987, 4, 15}, LocalTime{18, 54, 2, 0}}},
 	} {
 		if err := json.Unmarshal([]byte(test.data), test.ptr); err != nil {
 			t.Fatalf("%s: %v", test.data, err)
 		}
 		if !cmpEqual(test.ptr, test.want) {
 			t.Errorf("%s: got %#v, want %#v", test.data, test.ptr, test.want)
 		}
 	}
 	for _, bad := range []string{"", `""`, `"bad"`, `"1987-04-15x"`,
 		`19870415`,     // a JSON number
 		`11987-04-15x`, // not a JSON string
 	} {
 		if json.Unmarshal([]byte(bad), &d) == nil {
 			t.Errorf("%q, LocalDate: got nil, want error", bad)
 		}
 		if json.Unmarshal([]byte(bad), &tm) == nil {
 			t.Errorf("%q, LocalTime: got nil, want error", bad)
 		}
 		if json.Unmarshal([]byte(bad), &dt) == nil {
 			t.Errorf("%q, LocalDateTime: got nil, want error", bad)
 		}
 	}
 }
@@ -0,0 +1,44 @@
 // Package ossfuzz provides a fuzzing target for OSS-Fuzz.
 package ossfuzz
 import (
 	"fmt"
 	"reflect"
 	"strings"
 	"github.com/pelletier/go-toml/v2"
 )
 // FuzzToml is the fuzzing target.
 func FuzzToml(data []byte) int {
 	if len(data) >= 2048 {
 		return 0
 	}
 	if strings.Contains(string(data), "nan") {
 		return 0
 	}
 	var v interface{}
 	err := toml.Unmarshal(data, &v)
 	if err != nil {
 		return 0
 	}
 	encoded, err := toml.Marshal(v)
 	if err != nil {
 		panic(fmt.Sprintf("failed to marshal unmarshaled document: %s", err))
 	}
 	var v2 interface{}
 	err = toml.Unmarshal(encoded, &v2)
 	if err != nil {
 		panic(fmt.Sprintf("failed round trip: %s", err))
 	}
 	if !reflect.DeepEqual(v, v2) {
 		panic(fmt.Sprintf("not equal: %#+v %#+v", v, v2))
 	}
 	return 1
 }
@@ -1,920 +0,0 @@
 package toml
 import (
 	"bytes"
 	"fmt"
 	"strconv"
 	"github.com/pelletier/go-toml/v2/internal/ast"
 )
 type parser struct {
 	builder ast.Builder
 	ref     ast.Reference
 	data    []byte
 	left    []byte
 	err     error
 	first   bool
 }
 func (p *parser) Reset(b []byte) {
 	p.builder.Reset()
 	p.ref = ast.Reference{}
 	p.data = b
 	p.left = b
 	p.err = nil
 	p.first = true
 }
 func (p *parser) NextExpression() bool {
 	if len(p.left) == 0 || p.err != nil {
 		return false
 	}
 	p.builder.Reset()
 	p.ref = ast.Reference{}
 	for {
 		if len(p.left) == 0 || p.err != nil {
 			return false
 		}
 		if !p.first {
 			p.left, p.err = p.parseNewline(p.left)
 		}
 		if len(p.left) == 0 || p.err != nil {
 			return false
 		}
 		p.ref, p.left, p.err = p.parseExpression(p.left)
 		if p.err != nil {
 			return false
 		}
 		if p.ref.Valid() {
 			return true
 		}
 		p.first = false
 	}
 }
 func (p *parser) Expression() ast.Node {
 	return p.builder.NodeAt(p.ref)
 }
 func (p *parser) Error() error {
 	return p.err
 }
 func (p *parser) parseNewline(b []byte) ([]byte, error) {
 	if b[0] == '\n' {
 		return b[1:], nil
 	}
 	if b[0] == '\r' {
 		_, rest, err := scanWindowsNewline(b)
 		return rest, err
 	}
 	return nil, fmt.Errorf("expected newline but got %#U", b[0])
 }
 func (p *parser) parseExpression(b []byte) (ast.Reference, []byte, error) {
 	//expression =  ws [ comment ]
 	//expression =/ ws keyval ws [ comment ]
 	//expression =/ ws table ws [ comment ]
 	var ref ast.Reference
 	b = p.parseWhitespace(b)
 	if len(b) == 0 {
 		return ref, b, nil
 	}
 	if b[0] == '#' {
 		_, rest, err := scanComment(b)
 		return ref, rest, err
 	}
 	if b[0] == '\n' || b[0] == '\r' {
 		return ref, b, nil
 	}
 	var err error
 	if b[0] == '[' {
 		ref, b, err = p.parseTable(b)
 	} else {
 		ref, b, err = p.parseKeyval(b)
 	}
 	if err != nil {
 		return ref, nil, err
 	}
 	b = p.parseWhitespace(b)
 	if len(b) > 0 && b[0] == '#' {
 		_, rest, err := scanComment(b)
 		return ref, rest, err
 	}
 	return ref, b, nil
 }
 func (p *parser) parseTable(b []byte) (ast.Reference, []byte, error) {
 	//table = std-table / array-table
 	if len(b) > 1 && b[1] == '[' {
 		return p.parseArrayTable(b)
 	}
 	return p.parseStdTable(b)
 }
 func (p *parser) parseArrayTable(b []byte) (ast.Reference, []byte, error) {
 	//array-table = array-table-open key array-table-close
 	//array-table-open  = %x5B.5B ws  ; [[ Double left square bracket
 	//array-table-close = ws %x5D.5D  ; ]] Double right square bracket
 	ref := p.builder.Push(ast.Node{
 		Kind: ast.ArrayTable,
 	})
 	b = b[2:]
 	b = p.parseWhitespace(b)
 	k, b, err := p.parseKey(b)
 	if err != nil {
 		return ref, nil, err
 	}
 	p.builder.AttachChild(ref, k)
 	b = p.parseWhitespace(b)
 	b, err = expect(']', b)
 	if err != nil {
 		return ref, nil, err
 	}
 	b, err = expect(']', b)
 	return ref, b, err
 }
 func (p *parser) parseStdTable(b []byte) (ast.Reference, []byte, error) {
 	//std-table = std-table-open key std-table-close
 	//std-table-open  = %x5B ws     ; [ Left square bracket
 	//std-table-close = ws %x5D     ; ] Right square bracket
 	ref := p.builder.Push(ast.Node{
 		Kind: ast.Table,
 	})
 	b = b[1:]
 	b = p.parseWhitespace(b)
 	key, b, err := p.parseKey(b)
 	if err != nil {
 		return ref, nil, err
 	}
 	p.builder.AttachChild(ref, key)
 	b = p.parseWhitespace(b)
 	b, err = expect(']', b)
 	return ref, b, err
 }
 func (p *parser) parseKeyval(b []byte) (ast.Reference, []byte, error) {
 	//keyval = key keyval-sep val
 	ref := p.builder.Push(ast.Node{
 		Kind: ast.KeyValue,
 	})
 	key, b, err := p.parseKey(b)
 	if err != nil {
 		return ast.Reference{}, nil, err
 	}
 	//keyval-sep = ws %x3D ws ; =
 	b = p.parseWhitespace(b)
 	b, err = expect('=', b)
 	if err != nil {
 		return ast.Reference{}, nil, err
 	}
 	b = p.parseWhitespace(b)
 	valRef, b, err := p.parseVal(b)
 	if err != nil {
 		return ref, b, err
 	}
 	p.builder.Chain(valRef, key)
 	p.builder.AttachChild(ref, valRef)
 	return ref, b, err
 }
 func (p *parser) parseVal(b []byte) (ast.Reference, []byte, error) {
 	// val = string / boolean / array / inline-table / date-time / float / integer
 	var ref ast.Reference
 	if len(b) == 0 {
 		return ref, nil, fmt.Errorf("expected value, not eof")
 	}
 	var err error
 	c := b[0]
 	switch c {
 	case '"':
 		var v []byte
 		if scanFollowsMultilineBasicStringDelimiter(b) {
 			v, b, err = p.parseMultilineBasicString(b)
 		} else {
 			v, b, err = p.parseBasicString(b)
 		}
 		if err == nil {
 			ref = p.builder.Push(ast.Node{
 				Kind: ast.String,
 				Data: v,
 			})
 		}
 		return ref, b, err
 	case '\'':
 		var v []byte
 		if scanFollowsMultilineLiteralStringDelimiter(b) {
 			v, b, err = p.parseMultilineLiteralString(b)
 		} else {
 			v, b, err = p.parseLiteralString(b)
 		}
 		if err == nil {
 			ref = p.builder.Push(ast.Node{
 				Kind: ast.String,
 				Data: v,
 			})
 		}
 		return ref, b, err
 	case 't':
 		if !scanFollowsTrue(b) {
 			return ref, nil, fmt.Errorf("expected 'true'")
 		}
 		ref = p.builder.Push(ast.Node{
 			Kind: ast.Bool,
 			Data: b[:4],
 		})
 		return ref, b[4:], nil
 	case 'f':
 		if !scanFollowsFalse(b) {
 			return ast.Reference{}, nil, fmt.Errorf("expected 'false'")
 		}
 		ref = p.builder.Push(ast.Node{
 			Kind: ast.Bool,
 			Data: b[:5],
 		})
 		return ref, b[5:], nil
 	case '[':
 		return p.parseValArray(b)
 	case '{':
 		return p.parseInlineTable(b)
 	default:
 		return p.parseIntOrFloatOrDateTime(b)
 	}
 }
 func (p *parser) parseLiteralString(b []byte) ([]byte, []byte, error) {
 	v, rest, err := scanLiteralString(b)
 	if err != nil {
 		return nil, nil, err
 	}
 	return v[1 : len(v)-1], rest, nil
 }
 func (p *parser) parseInlineTable(b []byte) (ast.Reference, []byte, error) {
 	//inline-table = inline-table-open [ inline-table-keyvals ] inline-table-close
 	//inline-table-open  = %x7B ws     ; {
 	//inline-table-close = ws %x7D     ; }
 	//inline-table-sep   = ws %x2C ws  ; , Comma
 	//inline-table-keyvals = keyval [ inline-table-sep inline-table-keyvals ]
 	parent := p.builder.Push(ast.Node{
 		Kind: ast.InlineTable,
 	})
 	first := true
 	var child ast.Reference
 	b = b[1:]
 	var err error
 	for len(b) > 0 {
 		b = p.parseWhitespace(b)
 		if b[0] == '}' {
 			break
 		}
 		if !first {
 			b, err = expect(',', b)
 			if err != nil {
 				return parent, nil, err
 			}
 			b = p.parseWhitespace(b)
 		}
 		var kv ast.Reference
 		kv, b, err = p.parseKeyval(b)
 		if err != nil {
 			return parent, nil, err
 		}
 		if first {
 			p.builder.AttachChild(parent, kv)
 			first = false
 		} else {
 			p.builder.Chain(child, kv)
 		}
 		child = kv
 		first = false
 	}
 	rest, err := expect('}', b)
 	return parent, rest, err
 }
 func (p *parser) parseValArray(b []byte) (ast.Reference, []byte, error) {
 	//array = array-open [ array-values ] ws-comment-newline array-close
 	//array-open =  %x5B ; [
 	//array-close = %x5D ; ]
 	//array-values =  ws-comment-newline val ws-comment-newline array-sep array-values
 	//array-values =/ ws-comment-newline val ws-comment-newline [ array-sep ]
 	//array-sep = %x2C  ; , Comma
 	//ws-comment-newline = *( wschar / [ comment ] newline )
 	b = b[1:]
 	parent := p.builder.Push(ast.Node{
 		Kind: ast.Array,
 	})
 	first := true
 	var lastChild ast.Reference
 	var err error
 	for len(b) > 0 {
 		b, err = p.parseOptionalWhitespaceCommentNewline(b)
 		if err != nil {
 			return parent, nil, err
 		}
 		if len(b) == 0 {
 			return parent, nil, unexpectedCharacter{b: b} // TODO: should be unexpected EOF
 		}
 		if b[0] == ']' {
 			break
 		}
 		if b[0] == ',' {
 			if first {
 				return parent, nil, fmt.Errorf("array cannot start with comma")
 			}
 			b = b[1:]
 			b, err = p.parseOptionalWhitespaceCommentNewline(b)
 			if err != nil {
 				return parent, nil, err
 			}
 		}
 		// TOML allows trailing commas in arrays.
 		if len(b) > 0 && b[0] == ']' {
 			break
 		}
 		var valueRef ast.Reference
 		valueRef, b, err = p.parseVal(b)
 		if err != nil {
 			return parent, nil, err
 		}
 		if first {
 			p.builder.AttachChild(parent, valueRef)
 			first = false
 		} else {
 			p.builder.Chain(lastChild, valueRef)
 		}
 		lastChild = valueRef
 		b, err = p.parseOptionalWhitespaceCommentNewline(b)
 		if err != nil {
 			return parent, nil, err
 		}
 		first = false
 	}
 	rest, err := expect(']', b)
 	return parent, rest, err
 }
 func (p *parser) parseOptionalWhitespaceCommentNewline(b []byte) ([]byte, error) {
 	for len(b) > 0 {
 		var err error
 		b = p.parseWhitespace(b)
 		if len(b) > 0 && b[0] == '#' {
 			_, b, err = scanComment(b)
 			if err != nil {
 				return nil, err
 			}
 		}
 		if len(b) == 0 {
 			break
 		}
 		if b[0] == '\n' || b[0] == '\r' {
 			b, err = p.parseNewline(b)
 			if err != nil {
 				return nil, err
 			}
 		} else {
 			break
 		}
 	}
 	return b, nil
 }
 func (p *parser) parseMultilineLiteralString(b []byte) ([]byte, []byte, error) {
 	token, rest, err := scanMultilineLiteralString(b)
 	if err != nil {
 		return nil, nil, err
 	}
 	i := 3
 	// skip the immediate new line
 	if token[i] == '\n' {
 		i++
 	} else if token[i] == '\r' && token[i+1] == '\n' {
 		i += 2
 	}
 	return token[i : len(token)-3], rest, err
 }
 func (p *parser) parseMultilineBasicString(b []byte) ([]byte, []byte, error) {
 	//ml-basic-string = ml-basic-string-delim [ newline ] ml-basic-body
 	//ml-basic-string-delim
 	//ml-basic-string-delim = 3quotation-mark
 	//ml-basic-body = *mlb-content *( mlb-quotes 1*mlb-content ) [ mlb-quotes ]
 	//
 	//mlb-content = mlb-char / newline / mlb-escaped-nl
 	//mlb-char = mlb-unescaped / escaped
 	//mlb-quotes = 1*2quotation-mark
 	//mlb-unescaped = wschar / %x21 / %x23-5B / %x5D-7E / non-ascii
 	//mlb-escaped-nl = escape ws newline *( wschar / newline )
 	token, rest, err := scanMultilineBasicString(b)
 	if err != nil {
 		return nil, nil, err
 	}
 	var builder bytes.Buffer
 	i := 3
 	// skip the immediate new line
 	if token[i] == '\n' {
 		i++
 	} else if token[i] == '\r' && token[i+1] == '\n' {
 		i += 2
 	}
 	// The scanner ensures that the token starts and ends with quotes and that
 	// escapes are balanced.
 	for ; i < len(token)-3; i++ {
 		c := token[i]
 		if c == '\\' {
 			// When the last non-whitespace character on a line is an unescaped \,
 			// it will be trimmed along with all whitespace (including newlines) up
 			// to the next non-whitespace character or closing delimiter.
 			if token[i+1] == '\n' || (token[i+1] == '\r' && token[i+2] == '\n') {
 				i++ // skip the \
 				for ; i < len(token)-3; i++ {
 					c := token[i]
 					if !(c == '\n' || c == '\r' || c == ' ' || c == '\t') {
 						i--
 						break
 					}
 				}
 				continue
 			}
 			// handle escaping
 			i++
 			c = token[i]
 			switch c {
 			case '"', '\\':
 				builder.WriteByte(c)
 			case 'b':
 				builder.WriteByte('\b')
 			case 'f':
 				builder.WriteByte('\f')
 			case 'n':
 				builder.WriteByte('\n')
 			case 'r':
 				builder.WriteByte('\r')
 			case 't':
 				builder.WriteByte('\t')
 			case 'u':
 				x, err := hexToString(token[i+3:len(token)-3], 4)
 				if err != nil {
 					return nil, nil, err
 				}
 				builder.WriteString(x)
 				i += 4
 			case 'U':
 				x, err := hexToString(token[i+3:len(token)-3], 8)
 				if err != nil {
 					return nil, nil, err
 				}
 				builder.WriteString(x)
 				i += 8
 			default:
 				return nil, nil, fmt.Errorf("invalid escaped character: %#U", c)
 			}
 		} else {
 			builder.WriteByte(c)
 		}
 	}
 	return builder.Bytes(), rest, nil
 }
 func (p *parser) parseKey(b []byte) (ast.Reference, []byte, error) {
 	//key = simple-key / dotted-key
 	//simple-key = quoted-key / unquoted-key
 	//
 	//unquoted-key = 1*( ALPHA / DIGIT / %x2D / %x5F ) ; A-Z / a-z / 0-9 / - / _
 	//quoted-key = basic-string / literal-string
 	//dotted-key = simple-key 1*( dot-sep simple-key )
 	//
 	//dot-sep   = ws %x2E ws  ; . Period
 	key, b, err := p.parseSimpleKey(b)
 	if err != nil {
 		return ast.Reference{}, nil, err
 	}
 	ref := p.builder.Push(ast.Node{
 		Kind: ast.Key,
 		Data: key,
 	})
 	for {
 		b = p.parseWhitespace(b)
 		if len(b) > 0 && b[0] == '.' {
 			b, err = expect('.', b)
 			if err != nil {
 				return ref, nil, err
 			}
 			b = p.parseWhitespace(b)
 			key, b, err = p.parseSimpleKey(b)
 			if err != nil {
 				return ref, nil, err
 			}
 			p.builder.PushAndChain(ast.Node{
 				Kind: ast.Key,
 				Data: key,
 			})
 		} else {
 			break
 		}
 	}
 	return ref, b, nil
 }
 func (p *parser) parseSimpleKey(b []byte) (key, rest []byte, err error) {
 	//simple-key = quoted-key / unquoted-key
 	//unquoted-key = 1*( ALPHA / DIGIT / %x2D / %x5F ) ; A-Z / a-z / 0-9 / - / _
 	//quoted-key = basic-string / literal-string
 	if len(b) == 0 {
 		return nil, nil, unexpectedCharacter{b: b} // TODO: should be unexpected EOF
 	}
 	if b[0] == '\'' {
 		key, rest, err = p.parseLiteralString(b)
 	} else if b[0] == '"' {
 		key, rest, err = p.parseBasicString(b)
 	} else if isUnquotedKeyChar(b[0]) {
 		key, rest, err = scanUnquotedKey(b)
 	} else {
 		err = unexpectedCharacter{b: b} // TODO: should contain expected characters
 	}
 	return
 }
 func (p *parser) parseBasicString(b []byte) ([]byte, []byte, error) {
 	//basic-string = quotation-mark *basic-char quotation-mark
 	//quotation-mark = %x22            ; "
 	//basic-char = basic-unescaped / escaped
 	//basic-unescaped = wschar / %x21 / %x23-5B / %x5D-7E / non-ascii
 	//escaped = escape escape-seq-char
 	//escape-seq-char =  %x22         ; "    quotation mark  U+0022
 	//escape-seq-char =/ %x5C         ; \    reverse solidus U+005C
 	//escape-seq-char =/ %x62         ; b    backspace       U+0008
 	//escape-seq-char =/ %x66         ; f    form feed       U+000C
 	//escape-seq-char =/ %x6E         ; n    line feed       U+000A
 	//escape-seq-char =/ %x72         ; r    carriage return U+000D
 	//escape-seq-char =/ %x74         ; t    tab             U+0009
 	//escape-seq-char =/ %x75 4HEXDIG ; uXXXX                U+XXXX
 	//escape-seq-char =/ %x55 8HEXDIG ; UXXXXXXXX            U+XXXXXXXX
 	token, rest, err := scanBasicString(b)
 	if err != nil {
 		return nil, nil, err
 	}
 	var builder bytes.Buffer
 	// The scanner ensures that the token starts and ends with quotes and that
 	// escapes are balanced.
 	for i := 1; i < len(token)-1; i++ {
 		c := token[i]
 		if c == '\\' {
 			i++
 			c = token[i]
 			switch c {
 			case '"', '\\':
 				builder.WriteByte(c)
 			case 'b':
 				builder.WriteByte('\b')
 			case 'f':
 				builder.WriteByte('\f')
 			case 'n':
 				builder.WriteByte('\n')
 			case 'r':
 				builder.WriteByte('\r')
 			case 't':
 				builder.WriteByte('\t')
 			case 'u':
 				x, err := hexToString(token[i+1:len(token)-1], 4)
 				if err != nil {
 					return nil, nil, err
 				}
 				builder.WriteString(x)
 				i += 4
 			case 'U':
 				x, err := hexToString(token[i+1:len(token)-1], 8)
 				if err != nil {
 					return nil, nil, err
 				}
 				builder.WriteString(x)
 				i += 8
 			default:
 				return nil, nil, fmt.Errorf("invalid escaped character: %#U", c)
 			}
 		} else {
 			builder.WriteByte(c)
 		}
 	}
 	return builder.Bytes(), rest, nil
 }
 func hexToString(b []byte, length int) (string, error) {
 	if len(b) < length {
 		return "", fmt.Errorf("unicode point needs %d hex characters", length)
 	}
 	// TODO: slow
 	intcode, err := strconv.ParseInt(string(b[:length]), 16, 32)
 	if err != nil {
 		return "", err
 	}
 	return string(rune(intcode)), nil
 }
 func (p *parser) parseWhitespace(b []byte) []byte {
 	//ws = *wschar
 	//wschar =  %x20  ; Space
 	//wschar =/ %x09  ; Horizontal tab
 	_, rest := scanWhitespace(b)
 	return rest
 }
 func (p *parser) parseIntOrFloatOrDateTime(b []byte) (ast.Reference, []byte, error) {
 	switch b[0] {
 	case 'i':
 		if !scanFollowsInf(b) {
 			return ast.Reference{}, nil, fmt.Errorf("expected 'inf'")
 		}
 		return p.builder.Push(ast.Node{
 			Kind: ast.Float,
 			Data: b[:3],
 		}), b[3:], nil
 	case 'n':
 		if !scanFollowsNan(b) {
 			return ast.Reference{}, nil, fmt.Errorf("expected 'nan'")
 		}
 		return p.builder.Push(ast.Node{
 			Kind: ast.Float,
 			Data: b[:3],
 		}), b[3:], nil
 	case '+', '-':
 		return p.scanIntOrFloat(b)
 	}
 	if len(b) < 3 {
 		return p.scanIntOrFloat(b)
 	}
 	s := 5
 	if len(b) < s {
 		s = len(b)
 	}
 	for idx, c := range b[:s] {
 		if isDigit(c) {
 			continue
 		}
 		if idx == 2 && c == ':' || (idx == 4 && c == '-') {
 			return p.scanDateTime(b)
 		}
 	}
 	return p.scanIntOrFloat(b)
 }
 func digitsToInt(b []byte) int {
 	x := 0
 	for _, d := range b {
 		x *= 10
 		x += int(d - '0')
 	}
 	return x
 }
 func (p *parser) scanDateTime(b []byte) (ast.Reference, []byte, error) {
 	// scans for contiguous characters in [0-9T:Z.+-], and up to one space if
 	// followed by a digit.
 	hasTime := false
 	hasTz := false
 	seenSpace := false
 	i := 0
 	for ; i < len(b); i++ {
 		c := b[i]
 		if isDigit(c) || c == '-' {
 		} else if c == 'T' || c == ':' || c == '.' {
 			hasTime = true
 			continue
 		} else if c == '+' || c == '-' || c == 'Z' {
 			hasTz = true
 		} else if c == ' ' {
 			if !seenSpace && i+1 < len(b) && isDigit(b[i+1]) {
 				i += 2
 				seenSpace = true
 				hasTime = true
 			} else {
 				break
 			}
 		} else {
 			break
 		}
 	}
 	var kind ast.Kind
 	if hasTime {
 		if hasTz {
 			kind = ast.DateTime
 		} else {
 			kind = ast.LocalDateTime
 		}
 	} else {
 		if hasTz {
 			return ast.Reference{}, nil, fmt.Errorf("possible DateTime cannot have a timezone but no time component")
 		}
 		kind = ast.LocalDate
 	}
 	return p.builder.Push(ast.Node{
 		Kind: kind,
 		Data: b[:i],
 	}), b[i:], nil
 }
 func (p *parser) scanIntOrFloat(b []byte) (ast.Reference, []byte, error) {
 	i := 0
 	if len(b) > 2 && b[0] == '0' && b[1] != '.' {
 		var isValidRune validRuneFn
 		switch b[1] {
 		case 'x':
 			isValidRune = isValidHexRune
 		case 'o':
 			isValidRune = isValidOctalRune
 		case 'b':
 			isValidRune = isValidBinaryRune
 		default:
 			i++
 		}
 		if isValidRune != nil {
 			i += 2
 			for ; i < len(b); i++ {
 				if !isValidRune(b[i]) {
 					break
 				}
 			}
 		}
 		return p.builder.Push(ast.Node{
 			Kind: ast.Integer,
 			Data: b[:i],
 		}), b[i:], nil
 	}
 	isFloat := false
 	for ; i < len(b); i++ {
 		c := b[i]
 		if c >= '0' && c <= '9' || c == '+' || c == '-' || c == '_' {
 			continue
 		}
 		if c == '.' || c == 'e' || c == 'E' {
 			isFloat = true
 			continue
 		}
 		if c == 'i' {
 			if scanFollowsInf(b[i:]) {
 				return p.builder.Push(ast.Node{
 					Kind: ast.Float,
 					Data: b[:i+3],
 				}), b[i+3:], nil
 			}
 			return ast.Reference{}, nil, fmt.Errorf("unexpected character i while scanning for a number")
 		}
 		if c == 'n' {
 			if scanFollowsNan(b[i:]) {
 				return p.builder.Push(ast.Node{
 					Kind: ast.Float,
 					Data: b[:i+3],
 				}), b[i+3:], nil
 			}
 			return ast.Reference{}, nil, fmt.Errorf("unexpected character n while scanning for a number")
 		}
 		break
 	}
 	if i == 0 {
 		return ast.Reference{}, b, fmt.Errorf("expected integer or float")
 	}
 	kind := ast.Integer
 	if isFloat {
 		kind = ast.Float
 	}
 	return p.builder.Push(ast.Node{
 		Kind: kind,
 		Data: b[:i],
 	}), b[i:], nil
 }
 func isDigit(r byte) bool {
 	return r >= '0' && r <= '9'
 }
 type validRuneFn func(r byte) bool
 func isValidHexRune(r byte) bool {
 	return r >= 'a' && r <= 'f' ||
 		r >= 'A' && r <= 'F' ||
 		r >= '0' && r <= '9' ||
 		r == '_'
 }
 func isValidOctalRune(r byte) bool {
 	return r >= '0' && r <= '7' || r == '_'
 }
 func isValidBinaryRune(r byte) bool {
 	return r == '0' || r == '1' || r == '_'
 }
 func expect(x byte, b []byte) ([]byte, error) {
 	if len(b) == 0 {
 		return nil, newDecodeError(b[:0], "expecting %#U", x)
 	}
 	if b[0] != x {
 		return nil, newDecodeError(b[0:1], "expected character %U", x)
 	}
 	return b[1:], nil
 }
 type unexpectedCharacter struct {
 	r byte
 	b []byte
 }
 func (u unexpectedCharacter) Error() string {
 	if len(u.b) == 0 {
 		return fmt.Sprintf("expected %#U, not EOF", u.r)
 	}
 	return fmt.Sprintf("expected %#U, not %#U", u.r, u.b[0])
 }
@@ -1,400 +0,0 @@
 package toml
 import (
 	"testing"
 	"github.com/pelletier/go-toml/v2/internal/ast"
 	"github.com/stretchr/testify/require"
 )
 func TestParser_AST_Numbers(t *testing.T) {
 	examples := []struct {
 		desc  string
 		input string
 		kind  ast.Kind
 		err   bool
 	}{
 		{
 			desc:  "integer just digits",
 			input: `1234`,
 			kind:  ast.Integer,
 		},
 		{
 			desc:  "integer zero",
 			input: `0`,
 			kind:  ast.Integer,
 		},
 		{
 			desc:  "integer sign",
 			input: `+99`,
 			kind:  ast.Integer,
 		},
 		{
 			desc:  "integer hex uppercase",
 			input: `0xDEADBEEF`,
 			kind:  ast.Integer,
 		},
 		{
 			desc:  "integer hex lowercase",
 			input: `0xdead_beef`,
 			kind:  ast.Integer,
 		},
 		{
 			desc:  "integer octal",
 			input: `0o01234567`,
 			kind:  ast.Integer,
 		},
 		{
 			desc:  "integer binary",
 			input: `0b11010110`,
 			kind:  ast.Integer,
 		},
 		{
 			desc:  "float zero",
 			input: `0.0`,
 			kind:  ast.Float,
 		},
 		{
 			desc:  "float positive zero",
 			input: `+0.0`,
 			kind:  ast.Float,
 		},
 		{
 			desc:  "float negative zero",
 			input: `-0.0`,
 			kind:  ast.Float,
 		},
 		{
 			desc:  "float pi",
 			input: `3.1415`,
 			kind:  ast.Float,
 		},
 		{
 			desc:  "float negative",
 			input: `-0.01`,
 			kind:  ast.Float,
 		},
 		{
 			desc:  "float signed exponent",
 			input: `5e+22`,
 			kind:  ast.Float,
 		},
 		{
 			desc:  "float exponent lowercase",
 			input: `1e06`,
 			kind:  ast.Float,
 		},
 		{
 			desc:  "float exponent uppercase",
 			input: `-2E-2`,
 			kind:  ast.Float,
 		},
 		{
 			desc:  "float fractional with exponent",
 			input: `6.626e-34`,
 			kind:  ast.Float,
 		},
 		{
 			desc:  "float underscores",
 			input: `224_617.445_991_228`,
 			kind:  ast.Float,
 		},
 		{
 			desc:  "inf",
 			input: `inf`,
 			kind:  ast.Float,
 		},
 		{
 			desc:  "inf negative",
 			input: `-inf`,
 			kind:  ast.Float,
 		},
 		{
 			desc:  "inf positive",
 			input: `+inf`,
 			kind:  ast.Float,
 		},
 		{
 			desc:  "nan",
 			input: `nan`,
 			kind:  ast.Float,
 		},
 		{
 			desc:  "nan negative",
 			input: `-nan`,
 			kind:  ast.Float,
 		},
 		{
 			desc:  "nan positive",
 			input: `+nan`,
 			kind:  ast.Float,
 		},
 	}
 	for _, e := range examples {
 		t.Run(e.desc, func(t *testing.T) {
 			p := parser{}
 			p.Reset([]byte(`A = ` + e.input))
 			p.NextExpression()
 			err := p.Error()
 			if e.err {
 				require.Error(t, err)
 			} else {
 				require.NoError(t, err)
 				expected := astNode{
 					Kind: ast.KeyValue,
 					Children: []astNode{
 						{Kind: e.kind, Data: []byte(e.input)},
 						{Kind: ast.Key, Data: []byte(`A`)},
 					},
 				}
 				compareNode(t, expected, p.Expression())
 			}
 		})
 	}
 }
 type (
 	astRoot []astNode
 	astNode struct {
 		Kind     ast.Kind
 		Data     []byte
 		Children []astNode
 	}
 )
 func compareAST(t *testing.T, expected astRoot, actual *ast.Root) {
 	it := actual.Iterator()
 	compareIterator(t, expected, it)
 }
 func compareNode(t *testing.T, e astNode, n ast.Node) {
 	t.Helper()
 	require.Equal(t, e.Kind, n.Kind)
 	require.Equal(t, e.Data, n.Data)
 	compareIterator(t, e.Children, n.Children())
 }
 func compareIterator(t *testing.T, expected []astNode, actual ast.Iterator) {
 	t.Helper()
 	idx := 0
 	for actual.Next() {
 		n := actual.Node()
 		if idx >= len(expected) {
 			t.Fatal("extra child in actual tree")
 		}
 		e := expected[idx]
 		compareNode(t, e, n)
 		idx++
 	}
 	if idx < len(expected) {
 		t.Fatal("missing children in actual", "idx =", idx, "expected =", len(expected))
 	}
 }
 func (r astRoot) toOrig() *ast.Root {
 	builder := &ast.Builder{}
 	var last ast.Reference
 	for i, n := range r {
 		ref := builder.Push(ast.Node{
 			Kind: n.Kind,
 			Data: n.Data,
 		})
 		if i > 0 {
 			builder.Chain(last, ref)
 		}
 		last = ref
 		if len(n.Children) > 0 {
 			c := childrenToOrig(builder, n.Children)
 			builder.AttachChild(ref, c)
 		}
 	}
 	return builder.Tree()
 }
 func childrenToOrig(b *ast.Builder, nodes []astNode) ast.Reference {
 	var first ast.Reference
 	var last ast.Reference
 	for i, n := range nodes {
 		ref := b.Push(ast.Node{
 			Kind: n.Kind,
 			Data: n.Data,
 		})
 		if i == 0 {
 			first = ref
 		} else {
 			b.Chain(last, ref)
 		}
 		last = ref
 		if len(n.Children) > 0 {
 			c := childrenToOrig(b, n.Children)
 			b.AttachChild(ref, c)
 		}
 	}
 	return first
 }
 func TestParser_AST(t *testing.T) {
 	examples := []struct {
 		desc  string
 		input string
 		ast   astNode
 		err   bool
 	}{
 		{
 			desc:  "simple string assignment",
 			input: `A = "hello"`,
 			ast: astNode{
 				Kind: ast.KeyValue,
 				Children: []astNode{
 					{
 						Kind: ast.String,
 						Data: []byte(`hello`),
 					},
 					{
 						Kind: ast.Key,
 						Data: []byte(`A`),
 					},
 				},
 			},
 		},
 		{
 			desc:  "simple bool assignment",
 			input: `A = true`,
 			ast: astNode{
 				Kind: ast.KeyValue,
 				Children: []astNode{
 					{
 						Kind: ast.Bool,
 						Data: []byte(`true`),
 					},
 					{
 						Kind: ast.Key,
 						Data: []byte(`A`),
 					},
 				},
 			},
 		},
 		{
 			desc:  "array of strings",
 			input: `A = ["hello", ["world", "again"]]`,
 			ast: astNode{
 				Kind: ast.KeyValue,
 				Children: []astNode{
 					{
 						Kind: ast.Array,
 						Children: []astNode{
 							{
 								Kind: ast.String,
 								Data: []byte(`hello`),
 							},
 							{
 								Kind: ast.Array,
 								Children: []astNode{
 									{
 										Kind: ast.String,
 										Data: []byte(`world`),
 									},
 									{
 										Kind: ast.String,
 										Data: []byte(`again`),
 									},
 								},
 							},
 						},
 					},
 					{
 						Kind: ast.Key,
 						Data: []byte(`A`),
 					},
 				},
 			},
 		},
 		{
 			desc:  "array of arrays of strings",
 			input: `A = ["hello", "world"]`,
 			ast: astNode{
 				Kind: ast.KeyValue,
 				Children: []astNode{
 					{
 						Kind: ast.Array,
 						Children: []astNode{
 							{
 								Kind: ast.String,
 								Data: []byte(`hello`),
 							},
 							{
 								Kind: ast.String,
 								Data: []byte(`world`),
 							},
 						},
 					},
 					{
 						Kind: ast.Key,
 						Data: []byte(`A`),
 					},
 				},
 			},
 		},
 		{
 			desc:  "inline table",
 			input: `name = { first = "Tom", last = "Preston-Werner" }`,
 			ast: astNode{
 				Kind: ast.KeyValue,
 				Children: []astNode{
 					{
 						Kind: ast.InlineTable,
 						Children: []astNode{
 							{
 								Kind: ast.KeyValue,
 								Children: []astNode{
 									{Kind: ast.String, Data: []byte(`Tom`)},
 									{Kind: ast.Key, Data: []byte(`first`)},
 								},
 							},
 							{
 								Kind: ast.KeyValue,
 								Children: []astNode{
 									{Kind: ast.String, Data: []byte(`Preston-Werner`)},
 									{Kind: ast.Key, Data: []byte(`last`)},
 								},
 							},
 						},
 					},
 					{
 						Kind: ast.Key,
 						Data: []byte(`name`),
 					},
 				},
 			},
 		},
 	}
 	for _, e := range examples {
 		t.Run(e.desc, func(t *testing.T) {
 			p := parser{}
 			p.Reset([]byte(e.input))
 			p.NextExpression()
 			err := p.Error()
 			if e.err {
 				require.Error(t, err)
 			} else {
 				require.NoError(t, err)
 				compareNode(t, e.ast, p.Expression())
 			}
 		})
 	}
 }
@@ -1,176 +0,0 @@
 package toml
 import "fmt"
 func scanFollows(b []byte, pattern string) bool {
 	n := len(pattern)
 	return len(b) >= n && string(b[:n]) == pattern
 }
 func scanFollowsMultilineBasicStringDelimiter(b []byte) bool {
 	return scanFollows(b, `"""`)
 }
 func scanFollowsMultilineLiteralStringDelimiter(b []byte) bool {
 	return scanFollows(b, `'''`)
 }
 func scanFollowsTrue(b []byte) bool {
 	return scanFollows(b, `true`)
 }
 func scanFollowsFalse(b []byte) bool {
 	return scanFollows(b, `false`)
 }
 func scanFollowsInf(b []byte) bool {
 	return scanFollows(b, `inf`)
 }
 func scanFollowsNan(b []byte) bool {
 	return scanFollows(b, `nan`)
 }
 func scanUnquotedKey(b []byte) ([]byte, []byte, error) {
 	// unquoted-key = 1*( ALPHA / DIGIT / %x2D / %x5F ) ; A-Z / a-z / 0-9 / - / _
 	for i := 0; i < len(b); i++ {
 		if !isUnquotedKeyChar(b[i]) {
 			return b[:i], b[i:], nil
 		}
 	}
 	return b, b[len(b):], nil
 }
 func isUnquotedKeyChar(r byte) bool {
 	return (r >= 'A' && r <= 'Z') || (r >= 'a' && r <= 'z') || (r >= '0' && r <= '9') || r == '-' || r == '_'
 }
 func scanLiteralString(b []byte) ([]byte, []byte, error) {
 	// literal-string = apostrophe *literal-char apostrophe
 	// apostrophe = %x27 ; ' apostrophe
 	// literal-char = %x09 / %x20-26 / %x28-7E / non-ascii
 	for i := 1; i < len(b); i++ {
 		switch b[i] {
 		case '\'':
 			return b[:i+1], b[i+1:], nil
 		case '\n':
 			return nil, nil, newDecodeError(b[i:i+1], "literal strings cannot have new lines")
 		}
 	}
 	return nil, nil, newDecodeError(b[len(b):], "unterminated literal string")
 }
 func scanMultilineLiteralString(b []byte) ([]byte, []byte, error) {
 	//ml-literal-string = ml-literal-string-delim [ newline ] ml-literal-body
 	//ml-literal-string-delim
 	//ml-literal-string-delim = 3apostrophe
 	//ml-literal-body = *mll-content *( mll-quotes 1*mll-content ) [ mll-quotes ]
 	//
 	//mll-content = mll-char / newline
 	//mll-char = %x09 / %x20-26 / %x28-7E / non-ascii
 	//mll-quotes = 1*2apostrophe
 	for i := 3; i < len(b); i++ {
 		switch b[i] {
 		case '\'':
 			if scanFollowsMultilineLiteralStringDelimiter(b[i:]) {
 				return b[:i+3], b[i+3:], nil
 			}
 		}
 	}
 	return nil, nil, newDecodeError(b[len(b):], `multiline literal string not terminated by '''`)
 }
 func scanWindowsNewline(b []byte) ([]byte, []byte, error) {
 	if len(b) < 2 {
 		return nil, nil, fmt.Errorf(`windows new line missing \n`)
 	}
 	if b[1] != '\n' {
 		return nil, nil, fmt.Errorf(`windows new line should be \r\n`)
 	}
 	return b[:2], b[2:], nil
 }
 func scanWhitespace(b []byte) ([]byte, []byte) {
 	for i := 0; i < len(b); i++ {
 		switch b[i] {
 		case ' ', '\t':
 			continue
 		default:
 			return b[:i], b[i:]
 		}
 	}
 	return b, b[len(b):]
 }
 func scanComment(b []byte) ([]byte, []byte, error) {
 	//;; Comment
 	//
 	//comment-start-symbol = %x23 ; #
 	//non-ascii = %x80-D7FF / %xE000-10FFFF
 	//non-eol = %x09 / %x20-7F / non-ascii
 	//
 	//comment = comment-start-symbol *non-eol
 	for i := 1; i < len(b); i++ {
 		switch b[i] {
 		case '\n':
 			return b[:i], b[i:], nil
 		}
 	}
 	return b, nil, nil
 }
 // TODO perform validation on the string?
 func scanBasicString(b []byte) ([]byte, []byte, error) {
 	// basic-string = quotation-mark *basic-char quotation-mark
 	// quotation-mark = %x22            ; "
 	// basic-char = basic-unescaped / escaped
 	// basic-unescaped = wschar / %x21 / %x23-5B / %x5D-7E / non-ascii
 	// escaped = escape escape-seq-char
 	for i := 1; i < len(b); i++ {
 		switch b[i] {
 		case '"':
 			return b[:i+1], b[i+1:], nil
 		case '\n':
 			return nil, nil, newDecodeError(b[i:i+1], "basic strings cannot have new lines")
 		case '\\':
 			if len(b) < i+2 {
 				return nil, nil, newDecodeError(b[i:i+1], "need a character after \\")
 			}
 			i++ // skip the next character
 		}
 	}
 	return nil, nil, fmt.Errorf(`basic string not terminated by "`)
 }
 // TODO perform validation on the string?
 func scanMultilineBasicString(b []byte) ([]byte, []byte, error) {
 	//ml-basic-string = ml-basic-string-delim [ newline ] ml-basic-body
 	//ml-basic-string-delim
 	//ml-basic-string-delim = 3quotation-mark
 	//ml-basic-body = *mlb-content *( mlb-quotes 1*mlb-content ) [ mlb-quotes ]
 	//
 	//mlb-content = mlb-char / newline / mlb-escaped-nl
 	//mlb-char = mlb-unescaped / escaped
 	//mlb-quotes = 1*2quotation-mark
 	//mlb-unescaped = wschar / %x21 / %x23-5B / %x5D-7E / non-ascii
 	//mlb-escaped-nl = escape ws newline *( wschar / newline )
 	for i := 3; i < len(b); i++ {
 		switch b[i] {
 		case '"':
 			if scanFollowsMultilineBasicStringDelimiter(b[i:]) {
 				return b[:i+3], b[i+3:], nil
 			}
 		case '\\':
 			if len(b) < i+2 {
 				return nil, nil, newDecodeError(b[len(b):], "need a character after \\")
 			}
 			i++ // skip the next character
 		}
 	}
 	return nil, nil, newDecodeError(b[len(b):], `multiline basic string not terminated by """`)
 }
@@ -1,8 +1,8 @@
 package toml
 import (
 	"github.com/pelletier/go-toml/v2/internal/ast"
 	"github.com/pelletier/go-toml/v2/internal/tracker"
 	"github.com/pelletier/go-toml/v2/unstable"
 )
 type strict struct {
@@ -11,56 +11,65 @@ type strict struct {
 	// Tracks the current key being processed.
 	key tracker.KeyTracker
-	missing []decodeError
+	missing []unstable.ParserError
 	// Reference to the document for computing key ranges.
 	doc []byte
 }
-func (s *strict) EnterTable(node ast.Node) {
+func (s *strict) EnterTable(node *unstable.Node) {
 	if !s.Enabled {
 		return
 	}
 	s.key.UpdateTable(node)
 }
-func (s *strict) EnterArrayTable(node ast.Node) {
+func (s *strict) EnterArrayTable(node *unstable.Node) {
 	if !s.Enabled {
 		return
 	}
 	s.key.UpdateArrayTable(node)
 }
-func (s *strict) EnterKeyValue(node ast.Node) {
+func (s *strict) EnterKeyValue(node *unstable.Node) {
 	if !s.Enabled {
 		return
 	}
 	s.key.Push(node)
 }
-func (s *strict) ExitKeyValue(node ast.Node) {
+func (s *strict) ExitKeyValue(node *unstable.Node) {
 	if !s.Enabled {
 		return
 	}
 	s.key.Pop(node)
 }
-func (s *strict) MissingTable(node ast.Node) {
+func (s *strict) MissingTable(node *unstable.Node) {
 	if !s.Enabled {
 		return
 	}
-	s.missing = append(s.missing, decodeError{
+
-		highlight: keyLocation(node),
+	s.missing = append(s.missing, unstable.ParserError{
-		message:   "missing table",
+		Highlight: s.keyLocation(node),
-		key:       s.key.Key(),
+		Message:   "missing table",
 		Key:       s.key.Key(),
 	})
 }
-func (s *strict) MissingField(node ast.Node) {
+func (s *strict) MissingField(node *unstable.Node) {
 	if !s.Enabled {
 		return
 	}
-	s.missing = append(s.missing, decodeError{
+
-		highlight: keyLocation(node),
+	s.missing = append(s.missing, unstable.ParserError{
-		message:   "missing field",
+		Highlight: s.keyLocation(node),
-		key:       s.key.Key(),
+		Message:   "missing field",
 		Key:       s.key.Key(),
 	})
 }
@@ -72,8 +81,34 @@ func (s *strict) Error(doc []byte) error {
 	err := &StrictMissingError{
 		Errors: make([]DecodeError, 0, len(s.missing)),
 	}
 	for _, derr := range s.missing {
 		derr := derr
 		err.Errors = append(err.Errors, *wrapDecodeError(doc, &derr))
 	}
 	return err
 }
 func (s *strict) keyLocation(node *unstable.Node) []byte {
 	k := node.Key()
 	hasOne := k.Next()
 	if !hasOne {
 		panic("should not be called with empty key")
 	}
 	// Get the range from the first key to the last key.
 	firstRaw := k.Node().Raw
 	lastRaw := firstRaw
 	for k.Next() {
 		lastRaw = k.Node().Raw
 	}
 	// Compute the slice from the document using the ranges.
 	start := firstRaw.Offset
 	end := lastRaw.Offset + lastRaw.Length
 	return s.doc[start:end]
 }
@@ -1,553 +0,0 @@
 package toml
 import (
 	"fmt"
 	"math"
 	"reflect"
 	"strings"
 	"sync"
 )
 type target interface {
 	// Dereferences the target.
 	get() reflect.Value
 	// Store a string at the target.
 	setString(v string) error
 	// Store a boolean at the target
 	setBool(v bool) error
 	// Store an int64 at the target
 	setInt64(v int64) error
 	// Store a float64 at the target
 	setFloat64(v float64) error
 	// Stores any value at the target
 	set(v reflect.Value) error
 }
 // valueTarget just contains a reflect.Value that can be set.
 // It is used for struct fields.
 type valueTarget reflect.Value
 func (t valueTarget) get() reflect.Value {
 	return reflect.Value(t)
 }
 func (t valueTarget) set(v reflect.Value) error {
 	reflect.Value(t).Set(v)
 	return nil
 }
 func (t valueTarget) setString(v string) error {
 	t.get().SetString(v)
 	return nil
 }
 func (t valueTarget) setBool(v bool) error {
 	t.get().SetBool(v)
 	return nil
 }
 func (t valueTarget) setInt64(v int64) error {
 	t.get().SetInt(v)
 	return nil
 }
 func (t valueTarget) setFloat64(v float64) error {
 	t.get().SetFloat(v)
 	return nil
 }
 // interfaceTarget wraps an other target to dereference on get.
 type interfaceTarget struct {
 	x target
 }
 func (t interfaceTarget) get() reflect.Value {
 	return t.x.get().Elem()
 }
 func (t interfaceTarget) set(v reflect.Value) error {
 	return t.x.set(v)
 }
 func (t interfaceTarget) setString(v string) error {
 	return t.x.setString(v)
 }
 func (t interfaceTarget) setBool(v bool) error {
 	return t.x.setBool(v)
 }
 func (t interfaceTarget) setInt64(v int64) error {
 	return t.x.setInt64(v)
 }
 func (t interfaceTarget) setFloat64(v float64) error {
 	return t.x.setFloat64(v)
 }
 // mapTarget targets a specific key of a map.
 type mapTarget struct {
 	v reflect.Value
 	k reflect.Value
 }
 func (t mapTarget) get() reflect.Value {
 	return t.v.MapIndex(t.k)
 }
 func (t mapTarget) set(v reflect.Value) error {
 	t.v.SetMapIndex(t.k, v)
 	return nil
 }
 func (t mapTarget) setString(v string) error {
 	return t.set(reflect.ValueOf(v))
 }
 func (t mapTarget) setBool(v bool) error {
 	return t.set(reflect.ValueOf(v))
 }
 func (t mapTarget) setInt64(v int64) error {
 	return t.set(reflect.ValueOf(v))
 }
 func (t mapTarget) setFloat64(v float64) error {
 	return t.set(reflect.ValueOf(v))
 }
 // makes sure that the value pointed at by t is indexable (Slice, Array), or
 // dereferences to an indexable (Ptr, Interface).
 func ensureValueIndexable(t target) error {
 	f := t.get()
 	switch f.Type().Kind() {
 	case reflect.Slice:
 		if f.IsNil() {
 			return t.set(reflect.MakeSlice(f.Type(), 0, 0))
 		}
 	case reflect.Interface:
 		if f.IsNil() || f.Elem().Type() != sliceInterfaceType {
 			return t.set(reflect.MakeSlice(sliceInterfaceType, 0, 0))
 		}
 		if f.Elem().Type().Kind() != reflect.Slice {
 			return fmt.Errorf("interface is pointing to a %s, not a slice", f.Kind())
 		}
 	case reflect.Ptr:
 		if f.IsNil() {
 			ptr := reflect.New(f.Type().Elem())
 			err := t.set(ptr)
 			if err != nil {
 				return err
 			}
 			f = t.get()
 		}
 		return ensureValueIndexable(valueTarget(f.Elem()))
 	case reflect.Array:
 		// arrays are always initialized.
 	default:
 		return fmt.Errorf("cannot initialize a slice in %s", f.Kind())
 	}
 	return nil
 }
 var sliceInterfaceType = reflect.TypeOf([]interface{}{})
 var mapStringInterfaceType = reflect.TypeOf(map[string]interface{}{})
 func ensureMapIfInterface(x target) {
 	v := x.get()
 	if v.Kind() == reflect.Interface && v.IsNil() {
 		newElement := reflect.MakeMap(mapStringInterfaceType)
 		x.set(newElement)
 	}
 }
 func setString(t target, v string) error {
 	f := t.get()
 	switch f.Kind() {
 	case reflect.String:
 		return t.setString(v)
 	case reflect.Interface:
 		return t.set(reflect.ValueOf(v))
 	default:
 		return fmt.Errorf("cannot assign string to a %s", f.Kind())
 	}
 }
 func setBool(t target, v bool) error {
 	f := t.get()
 	switch f.Kind() {
 	case reflect.Bool:
 		return t.setBool(v)
 	case reflect.Interface:
 		return t.set(reflect.ValueOf(v))
 	default:
 		return fmt.Errorf("cannot assign bool to a %s", f.String())
 	}
 }
 const maxInt = int64(^uint(0) >> 1)
 const minInt = -maxInt - 1
 func setInt64(t target, v int64) error {
 	f := t.get()
 	switch f.Kind() {
 	case reflect.Int64:
 		return t.setInt64(v)
 	case reflect.Int32:
 		if v < math.MinInt32 || v > math.MaxInt32 {
 			return fmt.Errorf("integer %d does not fit in an int32", v)
 		}
 		return t.set(reflect.ValueOf(int32(v)))
 	case reflect.Int16:
 		if v < math.MinInt16 || v > math.MaxInt16 {
 			return fmt.Errorf("integer %d does not fit in an int16", v)
 		}
 		return t.set(reflect.ValueOf(int16(v)))
 	case reflect.Int8:
 		if v < math.MinInt8 || v > math.MaxInt8 {
 			return fmt.Errorf("integer %d does not fit in an int8", v)
 		}
 		return t.set(reflect.ValueOf(int8(v)))
 	case reflect.Int:
 		if v < minInt || v > maxInt {
 			return fmt.Errorf("integer %d does not fit in an int", v)
 		}
 		return t.set(reflect.ValueOf(int(v)))
 	case reflect.Uint64:
 		if v < 0 {
 			return fmt.Errorf("negative integer %d cannot be stored in an uint64", v)
 		}
 		return t.set(reflect.ValueOf(uint64(v)))
 	case reflect.Uint32:
 		if v < 0 {
 			return fmt.Errorf("negative integer %d cannot be stored in an uint32", v)
 		}
 		if v > math.MaxUint32 {
 			return fmt.Errorf("integer %d cannot be stored in an uint32", v)
 		}
 		return t.set(reflect.ValueOf(uint32(v)))
 	case reflect.Uint16:
 		if v < 0 {
 			return fmt.Errorf("negative integer %d cannot be stored in an uint16", v)
 		}
 		if v > math.MaxUint16 {
 			return fmt.Errorf("integer %d cannot be stored in an uint16", v)
 		}
 		return t.set(reflect.ValueOf(uint16(v)))
 	case reflect.Uint8:
 		if v < 0 {
 			return fmt.Errorf("negative integer %d cannot be stored in an uint8", v)
 		}
 		if v > math.MaxUint8 {
 			return fmt.Errorf("integer %d cannot be stored in an uint8", v)
 		}
 		return t.set(reflect.ValueOf(uint8(v)))
 	case reflect.Uint:
 		if v < 0 {
 			return fmt.Errorf("negative integer %d cannot be stored in an uint", v)
 		}
 		return t.set(reflect.ValueOf(uint(v)))
 	case reflect.Interface:
 		return t.set(reflect.ValueOf(v))
 	default:
 		return fmt.Errorf("cannot assign int64 to a %s", f.String())
 	}
 }
 func setFloat64(t target, v float64) error {
 	f := t.get()
 	switch f.Kind() {
 	case reflect.Float64:
 		return t.setFloat64(v)
 	case reflect.Float32:
 		if v > math.MaxFloat32 {
 			return fmt.Errorf("float %f cannot be stored in a float32", v)
 		}
 		return t.set(reflect.ValueOf(float32(v)))
 	case reflect.Interface:
 		return t.set(reflect.ValueOf(v))
 	default:
 		return fmt.Errorf("cannot assign float64 to a %s", f.String())
 	}
 }
 // Returns the element at idx of the value pointed at by target, or an error if
 // t does not point to an indexable.
 // If the target points to an Array and idx is out of bounds, it returns
 // (nil, nil) as this is not a fatal error (the unmarshaler will skip).
 func elementAt(t target, idx int) (target, error) {
 	f := t.get()
 	switch f.Kind() {
 	case reflect.Slice:
 		// TODO: use the idx function argument and avoid alloc if possible.
 		idx := f.Len()
 		err := t.set(reflect.Append(f, reflect.New(f.Type().Elem()).Elem()))
 		if err != nil {
 			return nil, err
 		}
 		return valueTarget(t.get().Index(idx)), nil
 	case reflect.Array:
 		if idx >= f.Len() {
 			return nil, nil
 		}
 		return valueTarget(f.Index(idx)), nil
 	case reflect.Interface:
 		if f.IsNil() {
 			panic("interface should have been initialized")
 		}
 		ifaceElem := f.Elem()
 		if ifaceElem.Kind() != reflect.Slice {
 			return nil, fmt.Errorf("cannot elementAt on a %s", f.Kind())
 		}
 		idx := ifaceElem.Len()
 		newElem := reflect.New(ifaceElem.Type().Elem()).Elem()
 		newSlice := reflect.Append(ifaceElem, newElem)
 		err := t.set(newSlice)
 		if err != nil {
 			return nil, err
 		}
 		return valueTarget(t.get().Elem().Index(idx)), nil
 	case reflect.Ptr:
 		return elementAt(valueTarget(f.Elem()), idx)
 	default:
 		return nil, fmt.Errorf("cannot elementAt on a %s", f.Kind())
 	}
 }
 func (d *decoder) scopeTableTarget(append bool, t target, name string) (target, bool, error) {
 	x := t.get()
 	switch x.Kind() {
 	// Kinds that need to recurse
 	case reflect.Interface:
 		t, err := scopeInterface(append, t)
 		if err != nil {
 			return t, false, err
 		}
 		return d.scopeTableTarget(append, t, name)
 	case reflect.Ptr:
 		t, err := scopePtr(t)
 		if err != nil {
 			return t, false, err
 		}
 		return d.scopeTableTarget(append, t, name)
 	case reflect.Slice:
 		t, err := scopeSlice(append, t)
 		if err != nil {
 			return t, false, err
 		}
 		append = false
 		return d.scopeTableTarget(append, t, name)
 	case reflect.Array:
 		t, err := d.scopeArray(append, t)
 		if err != nil {
 			return t, false, err
 		}
 		append = false
 		return d.scopeTableTarget(append, t, name)
 	// Terminal kinds
 	case reflect.Struct:
 		return scopeStruct(x, name)
 	case reflect.Map:
 		if x.IsNil() {
 			t.set(reflect.MakeMap(x.Type()))
 			x = t.get()
 		}
 		return scopeMap(x, name)
 	default:
 		panic(fmt.Errorf("can't scope on a %s", x.Kind()))
 	}
 }
 func scopeInterface(append bool, t target) (target, error) {
 	err := initInterface(append, t)
 	if err != nil {
 		return t, err
 	}
 	return interfaceTarget{t}, nil
 }
 func scopePtr(t target) (target, error) {
 	err := initPtr(t)
 	if err != nil {
 		return t, err
 	}
 	return valueTarget(t.get().Elem()), nil
 }
 func initPtr(t target) error {
 	x := t.get()
 	if !x.IsNil() {
 		return nil
 	}
 	return t.set(reflect.New(x.Type().Elem()))
 }
 // initInterface makes sure that the interface pointed at by the target is not
 // nil.
 // Returns the target to the initialized value of the target.
 func initInterface(append bool, t target) error {
 	x := t.get()
 	if x.Kind() != reflect.Interface {
 		panic("this should only be called on interfaces")
 	}
 	if !x.IsNil() && (x.Elem().Type() == sliceInterfaceType || x.Elem().Type() == mapStringInterfaceType) {
 		return nil
 	}
 	var newElement reflect.Value
 	if append {
 		newElement = reflect.MakeSlice(sliceInterfaceType, 0, 0)
 	} else {
 		newElement = reflect.MakeMap(mapStringInterfaceType)
 	}
 	err := t.set(newElement)
 	if err != nil {
 		return err
 	}
 	return nil
 }
 func scopeSlice(append bool, t target) (target, error) {
 	v := t.get()
 	if append {
 		newElem := reflect.New(v.Type().Elem())
 		newSlice := reflect.Append(v, newElem.Elem())
 		err := t.set(newSlice)
 		if err != nil {
 			return t, err
 		}
 		v = t.get()
 	}
 	return valueTarget(v.Index(v.Len() - 1)), nil
 }
 func (d *decoder) scopeArray(append bool, t target) (target, error) {
 	v := t.get()
 	idx := d.arrayIndex(append, v)
 	if idx >= v.Len() {
 		return nil, fmt.Errorf("not enough space in the array")
 	}
 	return valueTarget(v.Index(idx)), nil
 }
 func scopeMap(v reflect.Value, name string) (target, bool, error) {
 	k := reflect.ValueOf(name)
 	keyType := v.Type().Key()
 	if !k.Type().AssignableTo(keyType) {
 		if !k.Type().ConvertibleTo(keyType) {
 			return nil, false, fmt.Errorf("cannot convert string into map key type %s", keyType)
 		}
 		k = k.Convert(keyType)
 	}
 	if !v.MapIndex(k).IsValid() {
 		newElem := reflect.New(v.Type().Elem())
 		v.SetMapIndex(k, newElem.Elem())
 	}
 	return mapTarget{
 		v: v,
 		k: k,
 	}, true, nil
 }
 type fieldPathsMap = map[string][]int
 type fieldPathsCache struct {
 	m map[reflect.Type]fieldPathsMap
 	l sync.RWMutex
 }
 func (c *fieldPathsCache) get(t reflect.Type) (fieldPathsMap, bool) {
 	c.l.RLock()
 	paths, ok := c.m[t]
 	c.l.RUnlock()
 	return paths, ok
 }
 func (c *fieldPathsCache) set(t reflect.Type, m fieldPathsMap) {
 	c.l.Lock()
 	c.m[t] = m
 	c.l.Unlock()
 }
 var globalFieldPathsCache = fieldPathsCache{
 	m: map[reflect.Type]fieldPathsMap{},
 	l: sync.RWMutex{},
 }
 func scopeStruct(v reflect.Value, name string) (target, bool, error) {
 	// TODO: cache this, and reduce allocations
 	fieldPaths, ok := globalFieldPathsCache.get(v.Type())
 	if !ok {
 		fieldPaths = map[string][]int{}
 		path := make([]int, 0, 16)
 		var walk func(reflect.Value)
 		walk = func(v reflect.Value) {
 			t := v.Type()
 			for i := 0; i < t.NumField(); i++ {
 				l := len(path)
 				path = append(path, i)
 				f := t.Field(i)
 				if f.Anonymous {
 					walk(v.Field(i))
 				} else if f.PkgPath == "" {
 					// only consider exported fields
 					fieldName, ok := f.Tag.Lookup("toml")
 					if !ok {
 						fieldName = f.Name
 					}
 					pathCopy := make([]int, len(path))
 					copy(pathCopy, path)
 					fieldPaths[fieldName] = pathCopy
 					// extra copy for the case-insensitive match
 					fieldPaths[strings.ToLower(fieldName)] = pathCopy
 				}
 				path = path[:l]
 			}
 		}
 		walk(v)
 		globalFieldPathsCache.set(v.Type(), fieldPaths)
 	}
 	path, ok := fieldPaths[name]
 	if !ok {
 		path, ok = fieldPaths[strings.ToLower(name)]
 	}
 	if !ok {
 		return nil, false, nil
 	}
 	return valueTarget(v.FieldByIndex(path)), true, nil
 }
@@ -1,184 +0,0 @@
 package toml
 import (
 	"reflect"
 	"testing"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 func TestStructTarget_Ensure(t *testing.T) {
 	examples := []struct {
 		desc  string
 		input reflect.Value
 		name  string
 		test  func(v reflect.Value, err error)
 	}{
 		{
 			desc:  "handle a nil slice of string",
 			input: reflect.ValueOf(&struct{ A []string }{}).Elem(),
 			name:  "A",
 			test: func(v reflect.Value, err error) {
 				assert.NoError(t, err)
 				assert.False(t, v.IsNil())
 			},
 		},
 		{
 			desc:  "handle an existing slice of string",
 			input: reflect.ValueOf(&struct{ A []string }{A: []string{"foo"}}).Elem(),
 			name:  "A",
 			test: func(v reflect.Value, err error) {
 				assert.NoError(t, err)
 				require.False(t, v.IsNil())
 				s := v.Interface().([]string)
 				assert.Equal(t, []string{"foo"}, s)
 			},
 		},
 	}
 	for _, e := range examples {
 		t.Run(e.desc, func(t *testing.T) {
 			d := decoder{}
 			target, _, err := d.scopeTableTarget(false, valueTarget(e.input), e.name)
 			require.NoError(t, err)
 			err = ensureValueIndexable(target)
 			v := target.get()
 			e.test(v, err)
 		})
 	}
 }
 func TestStructTarget_SetString(t *testing.T) {
 	str := "value"
 	examples := []struct {
 		desc  string
 		input reflect.Value
 		name  string
 		test  func(v reflect.Value, err error)
 	}{
 		{
 			desc:  "sets a string",
 			input: reflect.ValueOf(&struct{ A string }{}).Elem(),
 			name:  "A",
 			test: func(v reflect.Value, err error) {
 				assert.NoError(t, err)
 				assert.Equal(t, str, v.String())
 			},
 		},
 		{
 			desc:  "fails on a float",
 			input: reflect.ValueOf(&struct{ A float64 }{}).Elem(),
 			name:  "A",
 			test: func(v reflect.Value, err error) {
 				assert.Error(t, err)
 			},
 		},
 		{
 			desc:  "fails on a slice",
 			input: reflect.ValueOf(&struct{ A []string }{}).Elem(),
 			name:  "A",
 			test: func(v reflect.Value, err error) {
 				assert.Error(t, err)
 			},
 		},
 	}
 	for _, e := range examples {
 		t.Run(e.desc, func(t *testing.T) {
 			d := decoder{}
 			target, _, err := d.scopeTableTarget(false, valueTarget(e.input), e.name)
 			require.NoError(t, err)
 			err = setString(target, str)
 			v := target.get()
 			e.test(v, err)
 		})
 	}
 }
 func TestPushNew(t *testing.T) {
 	t.Run("slice of strings", func(t *testing.T) {
 		type Doc struct {
 			A []string
 		}
 		d := Doc{}
 		dec := decoder{}
 		x, _, err := dec.scopeTableTarget(false, valueTarget(reflect.ValueOf(&d).Elem()), "A")
 		require.NoError(t, err)
 		n, err := elementAt(x, 0)
 		require.NoError(t, err)
 		require.NoError(t, n.setString("hello"))
 		require.Equal(t, []string{"hello"}, d.A)
 		n, err = elementAt(x, 1)
 		require.NoError(t, err)
 		require.NoError(t, n.setString("world"))
 		require.Equal(t, []string{"hello", "world"}, d.A)
 	})
 	t.Run("slice of interfaces", func(t *testing.T) {
 		type Doc struct {
 			A []interface{}
 		}
 		d := Doc{}
 		dec := decoder{}
 		x, _, err := dec.scopeTableTarget(false, valueTarget(reflect.ValueOf(&d).Elem()), "A")
 		require.NoError(t, err)
 		n, err := elementAt(x, 0)
 		require.NoError(t, err)
 		require.NoError(t, setString(n, "hello"))
 		require.Equal(t, []interface{}{"hello"}, d.A)
 		n, err = elementAt(x, 1)
 		require.NoError(t, err)
 		require.NoError(t, setString(n, "world"))
 		require.Equal(t, []interface{}{"hello", "world"}, d.A)
 	})
 }
 func TestScope_Struct(t *testing.T) {
 	examples := []struct {
 		desc  string
 		input reflect.Value
 		name  string
 		err   bool
 		found bool
 		idx   []int
 	}{
 		{
 			desc:  "simple field",
 			input: reflect.ValueOf(&struct{ A string }{}).Elem(),
 			name:  "A",
 			idx:   []int{0},
 			found: true,
 		},
 		{
 			desc:  "fails not-exported field",
 			input: reflect.ValueOf(&struct{ a string }{}).Elem(),
 			name:  "a",
 			err:   false,
 			found: false,
 		},
 	}
 	for _, e := range examples {
 		t.Run(e.desc, func(t *testing.T) {
 			dec := decoder{}
 			x, found, err := dec.scopeTableTarget(false, valueTarget(e.input), e.name)
 			assert.Equal(t, e.found, found)
 			if e.err {
 				assert.Error(t, err)
 			}
 			if found {
 				x2, ok := x.(valueTarget)
 				require.True(t, ok)
 				x2.get()
 			}
 		})
 	}
 }
@@ -0,0 +1,596 @@
 #!/usr/bin/env bash
 set -uo pipefail
 # Colors for output
 RED='\033[0;31m'
 GREEN='\033[0;32m'
 YELLOW='\033[1;33m'
 BLUE='\033[0;34m'
 NC='\033[0m' # No Color
 # Go versions to test (1.11 through 1.25)
 GO_VERSIONS=(
    "1.11"
    "1.12"
    "1.13"
    "1.14"
    "1.15"
    "1.16"
    "1.17"
    "1.18"
    "1.19"
    "1.20"
    "1.21"
    "1.22"
    "1.23"
    "1.24"
    "1.25"
 )
 # Default values
 PARALLEL=true
 VERBOSE=false
 OUTPUT_DIR="test-results"
 DOCKER_TIMEOUT="10m"
 usage() {
    cat << EOF
 Usage: $0 [OPTIONS] [GO_VERSIONS...]
 Test go-toml across multiple Go versions using Docker containers.
 The script reports the lowest continuous supported Go version (where all subsequent 
 versions pass) and only exits with non-zero status if either of the two most recent 
 Go versions fail, indicating immediate attention is needed.
 Note: For Go versions < 1.21, the script automatically updates go.mod to match the 
 target version, but older versions may still fail due to missing standard library 
 features (e.g., the 'slices' package introduced in Go 1.21).
 OPTIONS:
    -h, --help          Show this help message
    -s, --sequential    Run tests sequentially instead of in parallel
    -v, --verbose       Enable verbose output
    -o, --output DIR    Output directory for test results (default: test-results)
    -t, --timeout TIME  Docker timeout for each test (default: 10m)
    --list              List available Go versions and exit
 ARGUMENTS:
    GO_VERSIONS         Specific Go versions to test (default: all supported versions)
                        Examples: 1.21 1.22 1.23
 EXAMPLES:
    $0                          # Test all Go versions in parallel
    $0 --sequential             # Test all Go versions sequentially
    $0 1.21 1.22 1.23          # Test specific versions
    $0 --verbose --output ./results 1.24 1.25  # Verbose output to custom directory
 EXIT CODES:
    0                   Recent Go versions pass (good compatibility)
    1                   Recent Go versions fail (needs attention) or script error
 EOF
 }
 log() {
    echo -e "${BLUE}[$(date +'%H:%M:%S')]${NC} $*" >&2
 }
 log_success() {
    echo -e "${GREEN}[$(date +'%H:%M:%S')] ✓${NC} $*" >&2
 }
 log_error() {
    echo -e "${RED}[$(date +'%H:%M:%S')] ✗${NC} $*" >&2
 }
 log_warning() {
    echo -e "${YELLOW}[$(date +'%H:%M:%S')] ⚠${NC} $*" >&2
 }
 # Parse command line arguments
 while [[ $# -gt 0 ]]; do
    case $1 in
        -h|--help)
            usage
            exit 0
            ;;
        -s|--sequential)
            PARALLEL=false
            shift
            ;;
        -v|--verbose)
            VERBOSE=true
            shift
            ;;
        -o|--output)
            OUTPUT_DIR="$2"
            shift 2
            ;;
        -t|--timeout)
            DOCKER_TIMEOUT="$2"
            shift 2
            ;;
        --list)
            echo "Available Go versions:"
            printf '%s\n' "${GO_VERSIONS[@]}"
            exit 0
            ;;
        -*)
            echo "Unknown option: $1" >&2
            usage
            exit 1
            ;;
        *)
            # Remaining arguments are Go versions
            break
            ;;
    esac
 done
 # If specific versions provided, use those instead of defaults
 if [[ $# -gt 0 ]]; then
    GO_VERSIONS=("$@")
 fi
 # Validate Go versions
 for version in "${GO_VERSIONS[@]}"; do
    if ! [[ "$version" =~ ^1\.(1[1-9]|2[0-5])$ ]]; then
        log_error "Invalid Go version: $version. Supported versions: 1.11-1.25"
        exit 1
    fi
 done
 # Check if Docker is available
 if ! command -v docker &> /dev/null; then
    log_error "Docker is required but not installed or not in PATH"
    exit 1
 fi
 # Check if Docker daemon is running
 if ! docker info &> /dev/null; then
    log_error "Docker daemon is not running"
    exit 1
 fi
 # Create output directory
 mkdir -p "$OUTPUT_DIR"
 # Function to test a single Go version
 test_go_version() {
    local go_version="$1"
    local container_name="go-toml-test-${go_version}"
    local result_file="${OUTPUT_DIR}/go-${go_version}.txt"
    local dockerfile_content
    log "Testing Go $go_version..."
    # Create a temporary Dockerfile for this version
    # For Go versions < 1.21, we need to update go.mod to match the Go version
    local needs_go_mod_update=false
    if [[ $(echo "$go_version 1.21" | tr ' ' '\n' | sort -V | head -n1) == "$go_version" && "$go_version" != "1.21" ]]; then
        needs_go_mod_update=true
    fi
    dockerfile_content="FROM golang:${go_version}-alpine
 # Install git (required for go mod)
 RUN apk add --no-cache git
 # Set working directory
 WORKDIR /app
 # Copy source code
 COPY . ."
    # Add go.mod update step for older Go versions
    if [[ "$needs_go_mod_update" == true ]]; then
        dockerfile_content="$dockerfile_content
 # Update go.mod to match Go version (required for Go < 1.21)
 RUN if [ -f go.mod ]; then sed -i 's/^go [0-9]\\+\\.[0-9]\\+\\(\\.[0-9]\\+\\)\\?/go $go_version/' go.mod; fi
 # Note: Go versions < 1.21 may fail due to missing standard library packages (e.g., slices)
 # This is expected for projects that use Go 1.21+ features"
    fi
    dockerfile_content="$dockerfile_content
 # Run tests
 CMD [\"sh\", \"-c\", \"go version && echo '--- Running go test ./... ---' && go test ./...\"]"
    # Create temporary directory for this test
    local temp_dir
    temp_dir=$(mktemp -d)
    # Copy source to temp directory (excluding test results and git)
    rsync -a --exclude="$OUTPUT_DIR" --exclude=".git" --exclude="*.test" . "$temp_dir/"
    # Create Dockerfile in temp directory
    echo "$dockerfile_content" > "$temp_dir/Dockerfile"
    # Build and run container
    local exit_code=0
    local output
    if $VERBOSE; then
        log "Building Docker image for Go $go_version..."
    fi
    # Capture both stdout and stderr, and the exit code
    if output=$(cd "$temp_dir" && timeout "$DOCKER_TIMEOUT" docker build -t "$container_name" . 2>&1 && \
                timeout "$DOCKER_TIMEOUT" docker run --rm "$container_name" 2>&1); then
        log_success "Go $go_version: PASSED"
        echo "PASSED" > "${result_file}.status"
    else
        exit_code=$?
        log_error "Go $go_version: FAILED (exit code: $exit_code)"
        echo "FAILED" > "${result_file}.status"
    fi
    # Save full output
    echo "$output" > "$result_file"
    # Clean up
    docker rmi "$container_name" &> /dev/null || true
    rm -rf "$temp_dir"
    if $VERBOSE; then
        echo "--- Go $go_version output ---"
        echo "$output"
        echo "--- End Go $go_version output ---"
    fi
    return $exit_code
 }
 # Function to run tests in parallel
 run_parallel() {
    local pids=()
    local failed_versions=()
    log "Starting parallel tests for ${#GO_VERSIONS[@]} Go versions..."
    # Start all tests in background
    for version in "${GO_VERSIONS[@]}"; do
        test_go_version "$version" &
        pids+=($!)
    done
    # Wait for all tests to complete
    for i in "${!pids[@]}"; do
        local pid=${pids[$i]}
        local version=${GO_VERSIONS[$i]}
        if ! wait $pid; then
            failed_versions+=("$version")
        fi
    done
    return ${#failed_versions[@]}
 }
 # Function to run tests sequentially
 run_sequential() {
    local failed_versions=()
    log "Starting sequential tests for ${#GO_VERSIONS[@]} Go versions..."
    for version in "${GO_VERSIONS[@]}"; do
        if ! test_go_version "$version"; then
            failed_versions+=("$version")
        fi
    done
    return ${#failed_versions[@]}
 }
 # Main execution
 main() {
    local start_time
    start_time=$(date +%s)
    log "Starting Go version compatibility tests..."
    log "Testing versions: ${GO_VERSIONS[*]}"
    log "Output directory: $OUTPUT_DIR"
    log "Parallel execution: $PARALLEL"
    local failed_count
    if $PARALLEL; then
        run_parallel
        failed_count=$?
    else
        run_sequential
        failed_count=$?
    fi
    local end_time
    end_time=$(date +%s)
    local duration=$((end_time - start_time))
    # Collect results for display
    local passed_versions=()
    local failed_versions=()
    local unknown_versions=()
    local passed_count=0
    for version in "${GO_VERSIONS[@]}"; do
        local status_file="${OUTPUT_DIR}/go-${version}.txt.status"
        if [[ -f "$status_file" ]]; then
            local status
            status=$(cat "$status_file")
            if [[ "$status" == "PASSED" ]]; then
                passed_versions+=("$version")
                ((passed_count++))
            else
                failed_versions+=("$version")
            fi
        else
            unknown_versions+=("$version")
        fi
    done
    # Generate summary report
    local summary_file="${OUTPUT_DIR}/summary.txt"
    {
        echo "Go Version Compatibility Test Summary"
        echo "====================================="
        echo "Date: $(date)"
        echo "Duration: ${duration}s"
        echo "Parallel: $PARALLEL"
        echo ""
        echo "Results:"
        for version in "${GO_VERSIONS[@]}"; do
            local status_file="${OUTPUT_DIR}/go-${version}.txt.status"
            if [[ -f "$status_file" ]]; then
                local status
                status=$(cat "$status_file")
                if [[ "$status" == "PASSED" ]]; then
                    echo "  Go $version: ✓ PASSED"
                else
                    echo "  Go $version: ✗ FAILED"
                fi
            else
                echo "  Go $version: ? UNKNOWN (no status file)"
            fi
        done
        echo ""
        echo "Summary: $passed_count/${#GO_VERSIONS[@]} versions passed"
        if [[ $failed_count -gt 0 ]]; then
            echo ""
            echo "Failed versions details:"
            for version in "${failed_versions[@]}"; do
                echo ""
                echo "--- Go $version (FAILED) ---"
                local result_file="${OUTPUT_DIR}/go-${version}.txt"
                if [[ -f "$result_file" ]]; then
                    tail -n 30 "$result_file"
                fi
            done
        fi
    } > "$summary_file"
        # Find lowest continuous supported version and check recent versions
    local lowest_continuous_version=""
    local recent_versions_failed=false
    # Sort versions to ensure proper order
    local sorted_versions=()
    for version in "${GO_VERSIONS[@]}"; do
        sorted_versions+=("$version")
    done
    # Sort versions numerically (1.11, 1.12, ..., 1.25)
    IFS=$'\n' sorted_versions=($(sort -V <<< "${sorted_versions[*]}"))
    # Find lowest continuous supported version (all versions from this point onwards pass)
    for version in "${sorted_versions[@]}"; do
        local status_file="${OUTPUT_DIR}/go-${version}.txt.status"
        local all_subsequent_pass=true
        # Check if this version and all subsequent versions pass
        local found_current=false
        for check_version in "${sorted_versions[@]}"; do
            if [[ "$check_version" == "$version" ]]; then
                found_current=true
            fi
            if [[ "$found_current" == true ]]; then
                local check_status_file="${OUTPUT_DIR}/go-${check_version}.txt.status"
                if [[ -f "$check_status_file" ]]; then
                    local status
                    status=$(cat "$check_status_file")
                    if [[ "$status" != "PASSED" ]]; then
                        all_subsequent_pass=false
                        break
                    fi
                else
                    all_subsequent_pass=false
                    break
                fi
            fi
        done
        if [[ "$all_subsequent_pass" == true ]]; then
            lowest_continuous_version="$version"
            break
        fi
    done
    # Check if the two most recent versions failed
    local num_versions=${#sorted_versions[@]}
    if [[ $num_versions -ge 2 ]]; then
        local second_recent="${sorted_versions[$((num_versions-2))]}"
        local most_recent="${sorted_versions[$((num_versions-1))]}"
        local second_recent_status_file="${OUTPUT_DIR}/go-${second_recent}.txt.status"
        local most_recent_status_file="${OUTPUT_DIR}/go-${most_recent}.txt.status"
        local second_recent_failed=false
        local most_recent_failed=false
        if [[ -f "$second_recent_status_file" ]]; then
            local status
            status=$(cat "$second_recent_status_file")
            if [[ "$status" != "PASSED" ]]; then
                second_recent_failed=true
            fi
        else
            second_recent_failed=true
        fi
        if [[ -f "$most_recent_status_file" ]]; then
            local status
            status=$(cat "$most_recent_status_file")
            if [[ "$status" != "PASSED" ]]; then
                most_recent_failed=true
            fi
        else
            most_recent_failed=true
        fi
        if [[ "$second_recent_failed" == true || "$most_recent_failed" == true ]]; then
            recent_versions_failed=true
        fi
    elif [[ $num_versions -eq 1 ]]; then
        # Only one version tested, check if it's the most recent and failed
        local only_version="${sorted_versions[0]}"
        local only_status_file="${OUTPUT_DIR}/go-${only_version}.txt.status"
        if [[ -f "$only_status_file" ]]; then
            local status
            status=$(cat "$only_status_file")
            if [[ "$status" != "PASSED" ]]; then
                recent_versions_failed=true
            fi
        else
            recent_versions_failed=true
        fi
    fi
    # Display summary
    echo ""
    log "Test completed in ${duration}s"
    log "Summary report: $summary_file"
    echo ""
    echo "========================================"
    echo "           FINAL RESULTS"
    echo "========================================"
    echo ""
    # Display passed versions
    if [[ ${#passed_versions[@]} -gt 0 ]]; then
        log_success "PASSED (${#passed_versions[@]}/${#GO_VERSIONS[@]}):"
        # Sort passed versions for display
        local sorted_passed=()
        for version in "${sorted_versions[@]}"; do
            for passed_version in "${passed_versions[@]}"; do
                if [[ "$version" == "$passed_version" ]]; then
                    sorted_passed+=("$version")
                    break
                fi
            done
        done
        for version in "${sorted_passed[@]}"; do
            echo -e "  ${GREEN}✓${NC} Go $version"
        done
        echo ""
    fi
    # Display failed versions
    if [[ ${#failed_versions[@]} -gt 0 ]]; then
        log_error "FAILED (${#failed_versions[@]}/${#GO_VERSIONS[@]}):"
        # Sort failed versions for display
        local sorted_failed=()
        for version in "${sorted_versions[@]}"; do
            for failed_version in "${failed_versions[@]}"; do
                if [[ "$version" == "$failed_version" ]]; then
                    sorted_failed+=("$version")
                    break
                fi
            done
        done
        for version in "${sorted_failed[@]}"; do
            echo -e "  ${RED}✗${NC} Go $version"
        done
        echo ""
        # Show failure details
        echo "========================================"
        echo "         FAILURE DETAILS"
        echo "========================================"
        echo ""
        for version in "${sorted_failed[@]}"; do
            echo -e "${RED}--- Go $version FAILURE LOGS (last 30 lines) ---${NC}"
            local result_file="${OUTPUT_DIR}/go-${version}.txt"
            if [[ -f "$result_file" ]]; then
                tail -n 30 "$result_file" | sed 's/^/  /'
            else
                echo "  No log file found: $result_file"
            fi
            echo ""
        done
    fi
    # Display unknown versions
    if [[ ${#unknown_versions[@]} -gt 0 ]]; then
        log_warning "UNKNOWN (${#unknown_versions[@]}/${#GO_VERSIONS[@]}):"
        for version in "${unknown_versions[@]}"; do
            echo -e "  ${YELLOW}?${NC} Go $version (no status file)"
        done
        echo ""
    fi
    echo "========================================"
    echo "         COMPATIBILITY SUMMARY"
    echo "========================================"
    echo ""
    if [[ -n "$lowest_continuous_version" ]]; then
        log_success "Lowest continuous supported version: Go $lowest_continuous_version"
        echo "  (All versions from Go $lowest_continuous_version onwards pass)"
    else
        log_error "No continuous version support found"
        echo "  (No version has all subsequent versions passing)"
    fi
    echo ""
    echo "========================================"
    echo "Full detailed logs available in: $OUTPUT_DIR"
    echo "========================================"
    # Determine exit code based on recent versions
    if [[ "$recent_versions_failed" == true ]]; then
        log_error "OVERALL RESULT: Recent Go versions failed - this needs attention!"
        if [[ -n "$lowest_continuous_version" ]]; then
            echo "Note: Continuous support starts from Go $lowest_continuous_version"
        fi
        exit 1
    else
        log_success "OVERALL RESULT: Recent Go versions pass - compatibility looks good!"
        if [[ -n "$lowest_continuous_version" ]]; then
            echo "Continuous support starts from Go $lowest_continuous_version"
        fi
        exit 0
    fi
 }
 # Trap to clean up on exit
 cleanup() {
    # Kill any remaining background processes
    jobs -p | xargs -r kill 2>/dev/null || true
    # Clean up any remaining Docker containers
    docker ps -q --filter "name=go-toml-test-" | xargs -r docker stop 2>/dev/null || true
    docker images -q --filter "reference=go-toml-test-*" | xargs -r docker rmi 2>/dev/null || true
 }
 trap cleanup EXIT
 # Run main function
 main
@@ -0,0 +1,2 @@
 go test fuzz v1
 []byte("0=0000-01-01 00:00:00")
@@ -0,0 +1,2 @@
 go test fuzz v1
 []byte("\"\\n\"=\"\"")
@@ -0,0 +1,2 @@
 go test fuzz v1
 []byte("''=0")
@@ -0,0 +1,2 @@
 go test fuzz v1
 []byte("0=0000-01-01")
@@ -0,0 +1,2 @@
 go test fuzz v1
 []byte("0=\"\"\"\\U00000000\"\"\"")
@@ -0,0 +1,2 @@
 go test fuzz v1
 []byte("0=[[{}]]")
@@ -0,0 +1,2 @@
 go test fuzz v1
 []byte("\"\\b\"=\"\"")
@@ -0,0 +1,2 @@
 go test fuzz v1
 []byte("0=inf")
@@ -0,0 +1,2 @@
 go test fuzz v1
 []byte("0=0000-01-01 00:00:00+00:00")
@@ -0,0 +1,2 @@
 go test fuzz v1
 []byte("0=[{}]")
@@ -0,0 +1,2 @@
 go test fuzz v1
 []byte("0=nan")
@@ -1,15 +1,16 @@
-// This is a support file for toml_testgen_test.go
+//go:generate go run github.com/toml-lang/toml-test/cmd/toml-test@v1.6.0 -copy ./tests
 //go:generate go run ./cmd/tomltestgen/main.go -r v1.6.0 -o toml_testgen_test.go
 package toml_test
 import (
 	"encoding/json"
-	"fmt"
+	"errors"
 	"strconv"
 	"testing"
 	"time"
 	"github.com/pelletier/go-toml/v2"
-	"github.com/stretchr/testify/require"
+	"github.com/pelletier/go-toml/v2/internal/assert"
 	"github.com/pelletier/go-toml/v2/internal/testsuite"
 )
 func testgenInvalid(t *testing.T, input string) {
@@ -17,10 +18,14 @@ func testgenInvalid(t *testing.T, input string) {
 	t.Logf("Input TOML:\n%s", input)
 	doc := map[string]interface{}{}
-	err := toml.Unmarshal([]byte(input), &doc)
+	err := testsuite.Unmarshal([]byte(input), &doc)
 	if err == nil {
-		t.Log(json.Marshal(doc))
+		out, err := json.Marshal(doc)
 		if err != nil {
 			panic("could not marshal map to json")
 		}
 		t.Log("JSON output from unmarshal:", string(out))
 		t.Fatalf("test did not fail")
 	}
 }
@@ -29,110 +34,27 @@ func testgenValid(t *testing.T, input string, jsonRef string) {
 	t.Helper()
 	t.Logf("Input TOML:\n%s", input)
-	doc := map[string]interface{}{}
+	// TODO: change this to interface{}
-	err := toml.Unmarshal([]byte(input), &doc)
+	var doc map[string]interface{}
 	err := testsuite.Unmarshal([]byte(input), &doc)
 	if err != nil {
 		de := &toml.DecodeError{}
 		if errors.As(err, &de) {
 			t.Logf("%s\n%s", err, de)
 		}
 		t.Fatalf("failed parsing toml: %s", err)
 	}
 	j, err := testsuite.ValueToTaggedJSON(doc)
 	assert.NoError(t, err)
-	refDoc := testgenBuildRefDoc(jsonRef)
+	var ref interface{}
 	err = json.Unmarshal([]byte(jsonRef), &ref)
 	assert.NoError(t, err)
-	require.Equal(t, refDoc, doc)
+	var actual interface{}
 	err = json.Unmarshal(j, &actual)
 	assert.NoError(t, err)
-	out, err := toml.Marshal(doc)
+	testsuite.CmpJSON(t, "", ref, actual)
 	require.NoError(t, err)
 	doc2 := map[string]interface{}{}
 	err = toml.Unmarshal(out, &doc2)
 	require.NoError(t, err)
 	require.Equal(t, refDoc, doc2)
 }
 type testGenDescNode struct {
 	Type  string
 	Value interface{}
 }
 func testgenBuildRefDoc(jsonRef string) map[string]interface{} {
 	descTree := map[string]interface{}{}
 	err := json.Unmarshal([]byte(jsonRef), &descTree)
 	if err != nil {
 		panic(fmt.Errorf("reference doc should be valid JSON: %s", err))
 	}
 	doc := testGenTranslateDesc(descTree)
 	if doc == nil {
 		return map[string]interface{}{}
 	}
 	return doc.(map[string]interface{})
 }
 func testGenTranslateDesc(input interface{}) interface{} {
 	a, ok := input.([]interface{})
 	if ok {
 		xs := make([]interface{}, len(a))
 		for i, v := range a {
 			xs[i] = testGenTranslateDesc(v)
 		}
 		return xs
 	}
 	d := input.(map[string]interface{})
 	var dtype string
 	var dvalue interface{}
 	if len(d) == 2 {
 		dtypeiface, ok := d["type"]
 		if ok {
 			dvalue, ok = d["value"]
 			if ok {
 				dtype = dtypeiface.(string)
 				switch dtype {
 				case "string":
 					return dvalue.(string)
 				case "float":
 					v, err := strconv.ParseFloat(dvalue.(string), 64)
 					if err != nil {
 						panic(fmt.Errorf("invalid float '%s': %s", dvalue, err))
 					}
 					return v
 				case "integer":
 					v, err := strconv.ParseInt(dvalue.(string), 10, 64)
 					if err != nil {
 						panic(fmt.Errorf("invalid int '%s': %s", dvalue, err))
 					}
 					return v
 				case "bool":
 					return dvalue.(string) == "true"
 				case "datetime":
 					dt, err := time.Parse("2006-01-02T15:04:05Z", dvalue.(string))
 					if err != nil {
 						panic(fmt.Errorf("invalid datetime '%s': %s", dvalue, err))
 					}
 					return dt
 				case "array":
 					if dvalue == nil {
 						return nil
 					}
 					a := dvalue.([]interface{})
 					xs := make([]interface{}, len(a))
 					for i, v := range a {
 						xs[i] = testGenTranslateDesc(v)
 					}
 					return xs
 				}
 				panic(fmt.Errorf("unknown type: %s", dtype))
 			}
 		}
 	}
 	dest := map[string]interface{}{}
 	for k, v := range d {
 		dest[k] = testGenTranslateDesc(v)
 	}
 	return dest
 }
@@ -0,0 +1,23 @@
 package toml
 import (
 	"encoding"
 	"reflect"
 	"time"
 )
 // isZeroer is used to check if a type has a custom IsZero method.
 // This allows custom types to define their own zero-value semantics.
 type isZeroer interface {
 	IsZero() bool
 }
 var (
 	timeType               = reflect.TypeOf((*time.Time)(nil)).Elem()
 	textMarshalerType      = reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem()
 	textUnmarshalerType    = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem()
 	isZeroerType           = reflect.TypeOf((*isZeroer)(nil)).Elem()
 	mapStringInterfaceType = reflect.TypeOf(map[string]interface{}(nil))
 	sliceInterfaceType     = reflect.TypeOf([]interface{}(nil))
 	stringType             = reflect.TypeOf("")
 )
@@ -0,0 +1,145 @@
 package unstable
 import (
 	"errors"
 	"fmt"
 )
 // Iterator over a sequence of nodes.
 //
 // Starts uninitialized, you need to call Next() first.
 //
 // For example:
 //
 //	it := n.Children()
 //	for it.Next() {
 //		n := it.Node()
 //		// do something with n
 //	}
 type Iterator struct {
 	nodes   *[]Node
 	idx     int32
 	started bool
 }
 // Next moves the iterator forward and returns true if points to a
 // node, false otherwise.
 func (c *Iterator) Next() bool {
 	if c.nodes == nil {
 		return false
 	}
 	if !c.started {
 		c.started = true
 	} else if c.idx >= 0 {
 		c.idx = (*c.nodes)[c.idx].next
 	}
 	return c.idx >= 0 && int(c.idx) < len(*c.nodes)
 }
 // IsLast returns true if the current node of the iterator is the last
 // one.  Subsequent calls to Next() will return false.
 func (c *Iterator) IsLast() bool {
 	return c.nodes == nil || c.idx < 0 || (*c.nodes)[c.idx].next < 0
 }
 // Node returns a pointer to the node pointed at by the iterator.
 func (c *Iterator) Node() *Node {
 	if c.nodes == nil || c.idx < 0 {
 		return nil
 	}
 	n := &(*c.nodes)[c.idx]
 	n.nodes = c.nodes
 	return n
 }
 // Node in a TOML expression AST.
 //
 // Depending on Kind, its sequence of children should be interpreted
 // differently.
 //
 //   - Array have one child per element in the array.
 //   - InlineTable have one child per key-value in the table (each of kind
 //     InlineTable).
 //   - KeyValue have at least two children. The first one is the value. The rest
 //     make a potentially dotted key.
 //   - Table and ArrayTable's children represent a dotted key (same as
 //     KeyValue, but without the first node being the value).
 //
 // When relevant, Raw describes the range of bytes this node is referring to in
 // the input document. Use Parser.Raw() to retrieve the actual bytes.
 type Node struct {
 	Kind Kind
 	Raw  Range  // Raw bytes from the input.
 	Data []byte // Node value (either allocated or referencing the input).
 	// Absolute indices into the backing nodes slice. -1 means none.
 	next  int32
 	child int32
 	// Reference to the backing nodes slice for navigation.
 	nodes *[]Node
 }
 // Range of bytes in the document.
 type Range struct {
 	Offset uint32
 	Length uint32
 }
 // Next returns a pointer to the next node, or nil if there is no next node.
 func (n *Node) Next() *Node {
 	if n.next < 0 {
 		return nil
 	}
 	next := &(*n.nodes)[n.next]
 	next.nodes = n.nodes
 	return next
 }
 // Child returns a pointer to the first child node of this node. Other children
 // can be accessed calling Next on the first child.  Returns nil if this Node
 // has no child.
 func (n *Node) Child() *Node {
 	if n.child < 0 {
 		return nil
 	}
 	child := &(*n.nodes)[n.child]
 	child.nodes = n.nodes
 	return child
 }
 // Valid returns true if the node's kind is set (not to Invalid).
 func (n *Node) Valid() bool {
 	return n != nil
 }
 // Key returns the children nodes making the Key on a supported node. Panics
 // otherwise.  They are guaranteed to be all be of the Kind Key. A simple key
 // would return just one element.
 func (n *Node) Key() Iterator {
 	switch n.Kind {
 	case KeyValue:
 		child := n.child
 		if child < 0 {
 			panic(errors.New("KeyValue should have at least two children"))
 		}
 		valueNode := &(*n.nodes)[child]
 		return Iterator{nodes: n.nodes, idx: valueNode.next}
 	case Table, ArrayTable:
 		return Iterator{nodes: n.nodes, idx: n.child}
 	default:
 		panic(fmt.Errorf("Key() is not supported on a %s", n.Kind))
 	}
 }
 // Value returns a pointer to the value node of a KeyValue.
 // Guaranteed to be non-nil.  Panics if not called on a KeyValue node,
 // or if the Children are malformed.
 func (n *Node) Value() *Node {
 	return n.Child()
 }
 // Children returns an iterator over a node's children.
 func (n *Node) Children() Iterator {
 	return Iterator{nodes: n.nodes, idx: n.child}
 }
@@ -0,0 +1,73 @@
 package unstable
 import (
 	"bytes"
 	"testing"
 )
 var (
 	valid10ASCII = []byte("1234567890")
 	valid10Utf8  = []byte("日本語a")
 	valid1kUtf8  = bytes.Repeat([]byte("0123456789日本語日本語日本語日abcdefghijklmnopqrstuvwx"), 16)
 	valid1MUtf8  = bytes.Repeat(valid1kUtf8, 1024)
 	valid1kASCII = bytes.Repeat([]byte("012345678998jhjklasDJKLAAdjdfjsdklfjdslkabcdefghijklmnopqrstuvwx"), 16)
 	valid1MASCII = bytes.Repeat(valid1kASCII, 1024)
 )
 func BenchmarkScanComments(b *testing.B) {
 	wrap := func(x []byte) []byte {
 		return []byte("# " + string(x) + "\n")
 	}
 	inputs := map[string][]byte{
 		"10Valid":     wrap(valid10ASCII),
 		"1kValid":     wrap(valid1kASCII),
 		"1MValid":     wrap(valid1MASCII),
 		"10ValidUtf8": wrap(valid10Utf8),
 		"1kValidUtf8": wrap(valid1kUtf8),
 		"1MValidUtf8": wrap(valid1MUtf8),
 	}
 	for name, input := range inputs {
 		b.Run(name, func(b *testing.B) {
 			b.SetBytes(int64(len(input)))
 			b.ReportAllocs()
 			b.ResetTimer()
 			for i := 0; i < b.N; i++ {
 				_, _, _ = scanComment(input)
 			}
 		})
 	}
 }
 func BenchmarkParseLiteralStringValid(b *testing.B) {
 	wrap := func(x []byte) []byte {
 		return []byte("'" + string(x) + "'")
 	}
 	inputs := map[string][]byte{
 		"10Valid":     wrap(valid10ASCII),
 		"1kValid":     wrap(valid1kASCII),
 		"1MValid":     wrap(valid1MASCII),
 		"10ValidUtf8": wrap(valid10Utf8),
 		"1kValidUtf8": wrap(valid1kUtf8),
 		"1MValidUtf8": wrap(valid1MUtf8),
 	}
 	for name, input := range inputs {
 		b.Run(name, func(b *testing.B) {
 			p := Parser{}
 			b.SetBytes(int64(len(input)))
 			b.ReportAllocs()
 			b.ResetTimer()
 			for i := 0; i < b.N; i++ {
 				_, _, _, err := p.parseLiteralString(input)
 				if err != nil {
 					b.Error(err)
 				}
 			}
 		})
 	}
 }
@@ -0,0 +1,64 @@
 package unstable
 // root contains a full AST.
 //
 // It is immutable once constructed with Builder.
 type root struct {
 	nodes []Node
 }
 func (r *root) at(idx reference) *Node {
 	return &r.nodes[idx]
 }
 type reference int
 const invalidReference reference = -1
 func (r reference) Valid() bool {
 	return r != invalidReference
 }
 type builder struct {
 	tree    root
 	lastIdx int
 }
 func (b *builder) NodeAt(ref reference) *Node {
 	n := b.tree.at(ref)
 	n.nodes = &b.tree.nodes
 	return n
 }
 func (b *builder) Reset() {
 	b.tree.nodes = b.tree.nodes[:0]
 	b.lastIdx = 0
 }
 func (b *builder) Push(n Node) reference {
 	b.lastIdx = len(b.tree.nodes)
 	n.next = -1
 	n.child = -1
 	b.tree.nodes = append(b.tree.nodes, n)
 	return reference(b.lastIdx)
 }
 func (b *builder) PushAndChain(n Node) reference {
 	newIdx := len(b.tree.nodes)
 	n.next = -1
 	n.child = -1
 	b.tree.nodes = append(b.tree.nodes, n)
 	if b.lastIdx >= 0 {
 		b.tree.nodes[b.lastIdx].next = int32(newIdx) //nolint:gosec // TOML ASTs are small
 	}
 	b.lastIdx = newIdx
 	return reference(b.lastIdx)
 }
 func (b *builder) AttachChild(parent reference, child reference) {
 	b.tree.nodes[parent].child = int32(child) //nolint:gosec // TOML ASTs are small
 }
 func (b *builder) Chain(from reference, to reference) {
 	b.tree.nodes[from].next = int32(to) //nolint:gosec // TOML ASTs are small
 }
@@ -0,0 +1,3 @@
 // Package unstable provides APIs that do not meet the backward compatibility
 // guarantees yet.
 package unstable
@@ -0,0 +1,83 @@
 package unstable
 import "fmt"
 // Kind represents the type of TOML structure contained in a given Node.
 type Kind int
 const (
 	// Invalid represents an invalid meta node.
 	Invalid Kind = iota
 	// Comment represents a comment meta node.
 	Comment
 	// Key represents a key meta node.
 	Key
 	// Table represents a top-level table.
 	Table
 	// ArrayTable represents a top-level array table.
 	ArrayTable
 	// KeyValue represents a top-level key value.
 	KeyValue
 	// Array represents an array container value.
 	Array
 	// InlineTable represents an inline table container value.
 	InlineTable
 	// String represents a string value.
 	String
 	// Bool represents a boolean value.
 	Bool
 	// Float represents a floating point value.
 	Float
 	// Integer represents an integer value.
 	Integer
 	// LocalDate represents a a local date value.
 	LocalDate
 	// LocalTime represents a local time value.
 	LocalTime
 	// LocalDateTime represents a local date/time value.
 	LocalDateTime
 	// DateTime represents a data/time value.
 	DateTime
 )
 // String implementation of fmt.Stringer.
 func (k Kind) String() string {
 	switch k {
 	case Invalid:
 		return "Invalid"
 	case Comment:
 		return "Comment"
 	case Key:
 		return "Key"
 	case Table:
 		return "Table"
 	case ArrayTable:
 		return "ArrayTable"
 	case KeyValue:
 		return "KeyValue"
 	case Array:
 		return "Array"
 	case InlineTable:
 		return "InlineTable"
 	case String:
 		return "String"
 	case Bool:
 		return "Bool"
 	case Float:
 		return "Float"
 	case Integer:
 		return "Integer"
 	case LocalDate:
 		return "LocalDate"
 	case LocalTime:
 		return "LocalTime"
 	case LocalDateTime:
 		return "LocalDateTime"
 	case DateTime:
 		return "DateTime"
 	}
 	panic(fmt.Errorf("Kind.String() not implemented for '%d'", k))
 }
@@ -0,0 +1,697 @@
 package unstable
 import (
 	"fmt"
 	"strconv"
 	"strings"
 	"testing"
 	"github.com/pelletier/go-toml/v2/internal/assert"
 )
 func TestParser_AST_Numbers(t *testing.T) {
 	examples := []struct {
 		desc  string
 		input string
 		kind  Kind
 		err   bool
 	}{
 		{
 			desc:  "integer just digits",
 			input: `1234`,
 			kind:  Integer,
 		},
 		{
 			desc:  "integer zero",
 			input: `0`,
 			kind:  Integer,
 		},
 		{
 			desc:  "integer sign",
 			input: `+99`,
 			kind:  Integer,
 		},
 		{
 			desc:  "integer hex uppercase",
 			input: `0xDEADBEEF`,
 			kind:  Integer,
 		},
 		{
 			desc:  "integer hex lowercase",
 			input: `0xdead_beef`,
 			kind:  Integer,
 		},
 		{
 			desc:  "integer octal",
 			input: `0o01234567`,
 			kind:  Integer,
 		},
 		{
 			desc:  "integer binary",
 			input: `0b11010110`,
 			kind:  Integer,
 		},
 		{
 			desc:  "float zero",
 			input: `0.0`,
 			kind:  Float,
 		},
 		{
 			desc:  "float positive zero",
 			input: `+0.0`,
 			kind:  Float,
 		},
 		{
 			desc:  "float negative zero",
 			input: `-0.0`,
 			kind:  Float,
 		},
 		{
 			desc:  "float pi",
 			input: `3.1415`,
 			kind:  Float,
 		},
 		{
 			desc:  "float negative",
 			input: `-0.01`,
 			kind:  Float,
 		},
 		{
 			desc:  "float signed exponent",
 			input: `5e+22`,
 			kind:  Float,
 		},
 		{
 			desc:  "float exponent lowercase",
 			input: `1e06`,
 			kind:  Float,
 		},
 		{
 			desc:  "float exponent uppercase",
 			input: `-2E-2`,
 			kind:  Float,
 		},
 		{
 			desc:  "float fractional with exponent",
 			input: `6.626e-34`,
 			kind:  Float,
 		},
 		{
 			desc:  "float underscores",
 			input: `224_617.445_991_228`,
 			kind:  Float,
 		},
 		{
 			desc:  "inf",
 			input: `inf`,
 			kind:  Float,
 		},
 		{
 			desc:  "inf negative",
 			input: `-inf`,
 			kind:  Float,
 		},
 		{
 			desc:  "inf positive",
 			input: `+inf`,
 			kind:  Float,
 		},
 		{
 			desc:  "nan",
 			input: `nan`,
 			kind:  Float,
 		},
 		{
 			desc:  "nan negative",
 			input: `-nan`,
 			kind:  Float,
 		},
 		{
 			desc:  "nan positive",
 			input: `+nan`,
 			kind:  Float,
 		},
 	}
 	for _, e := range examples {
 		e := e
 		t.Run(e.desc, func(t *testing.T) {
 			p := Parser{}
 			p.Reset([]byte(`A = ` + e.input))
 			p.NextExpression()
 			err := p.Error()
 			if e.err {
 				assert.Error(t, err)
 			} else {
 				assert.NoError(t, err)
 				expected := astNode{
 					Kind: KeyValue,
 					Children: []astNode{
 						{Kind: e.kind, Data: []byte(e.input)},
 						{Kind: Key, Data: []byte(`A`)},
 					},
 				}
 				compareNode(t, expected, p.Expression())
 			}
 		})
 	}
 }
 type (
 	astNode struct {
 		Kind     Kind
 		Data     []byte
 		Children []astNode
 	}
 )
 func compareNode(t *testing.T, e astNode, n *Node) {
 	t.Helper()
 	assert.Equal(t, e.Kind, n.Kind)
 	assert.Equal(t, e.Data, n.Data)
 	compareIterator(t, e.Children, n.Children())
 }
 func compareIterator(t *testing.T, expected []astNode, actual Iterator) {
 	t.Helper()
 	idx := 0
 	for actual.Next() {
 		n := actual.Node()
 		if idx >= len(expected) {
 			t.Fatal("extra child in actual tree")
 		}
 		e := expected[idx]
 		compareNode(t, e, n)
 		idx++
 	}
 	if idx < len(expected) {
 		t.Fatal("missing children in actual", "idx =", idx, "expected =", len(expected))
 	}
 }
 //nolint:funlen
 func TestParser_AST(t *testing.T) {
 	examples := []struct {
 		desc  string
 		input string
 		ast   astNode
 		err   bool
 	}{
 		{
 			desc:  "simple string assignment",
 			input: `A = "hello"`,
 			ast: astNode{
 				Kind: KeyValue,
 				Children: []astNode{
 					{
 						Kind: String,
 						Data: []byte(`hello`),
 					},
 					{
 						Kind: Key,
 						Data: []byte(`A`),
 					},
 				},
 			},
 		},
 		{
 			desc:  "simple bool assignment",
 			input: `A = true`,
 			ast: astNode{
 				Kind: KeyValue,
 				Children: []astNode{
 					{
 						Kind: Bool,
 						Data: []byte(`true`),
 					},
 					{
 						Kind: Key,
 						Data: []byte(`A`),
 					},
 				},
 			},
 		},
 		{
 			desc:  "array of strings",
 			input: `A = ["hello", ["world", "again"]]`,
 			ast: astNode{
 				Kind: KeyValue,
 				Children: []astNode{
 					{
 						Kind: Array,
 						Children: []astNode{
 							{
 								Kind: String,
 								Data: []byte(`hello`),
 							},
 							{
 								Kind: Array,
 								Children: []astNode{
 									{
 										Kind: String,
 										Data: []byte(`world`),
 									},
 									{
 										Kind: String,
 										Data: []byte(`again`),
 									},
 								},
 							},
 						},
 					},
 					{
 						Kind: Key,
 						Data: []byte(`A`),
 					},
 				},
 			},
 		},
 		{
 			desc:  "array of arrays of strings",
 			input: `A = ["hello", "world"]`,
 			ast: astNode{
 				Kind: KeyValue,
 				Children: []astNode{
 					{
 						Kind: Array,
 						Children: []astNode{
 							{
 								Kind: String,
 								Data: []byte(`hello`),
 							},
 							{
 								Kind: String,
 								Data: []byte(`world`),
 							},
 						},
 					},
 					{
 						Kind: Key,
 						Data: []byte(`A`),
 					},
 				},
 			},
 		},
 		{
 			desc:  "inline table",
 			input: `name = { first = "Tom", last = "Preston-Werner" }`,
 			ast: astNode{
 				Kind: KeyValue,
 				Children: []astNode{
 					{
 						Kind: InlineTable,
 						Children: []astNode{
 							{
 								Kind: KeyValue,
 								Children: []astNode{
 									{Kind: String, Data: []byte(`Tom`)},
 									{Kind: Key, Data: []byte(`first`)},
 								},
 							},
 							{
 								Kind: KeyValue,
 								Children: []astNode{
 									{Kind: String, Data: []byte(`Preston-Werner`)},
 									{Kind: Key, Data: []byte(`last`)},
 								},
 							},
 						},
 					},
 					{
 						Kind: Key,
 						Data: []byte(`name`),
 					},
 				},
 			},
 		},
 	}
 	for _, e := range examples {
 		e := e
 		t.Run(e.desc, func(t *testing.T) {
 			p := Parser{}
 			p.Reset([]byte(e.input))
 			p.NextExpression()
 			err := p.Error()
 			if e.err {
 				assert.Error(t, err)
 			} else {
 				assert.NoError(t, err)
 				compareNode(t, e.ast, p.Expression())
 			}
 		})
 	}
 }
 func BenchmarkParseBasicStringWithUnicode(b *testing.B) {
 	p := &Parser{}
 	b.Run("4", func(b *testing.B) {
 		input := []byte(`"\u1234\u5678\u9ABC\u1234\u5678\u9ABC"`)
 		b.ReportAllocs()
 		b.SetBytes(int64(len(input)))
 		for i := 0; i < b.N; i++ {
 			_, _, _, _ = p.parseBasicString(input)
 		}
 	})
 	b.Run("8", func(b *testing.B) {
 		input := []byte(`"\u12345678\u9ABCDEF0\u12345678\u9ABCDEF0"`)
 		b.ReportAllocs()
 		b.SetBytes(int64(len(input)))
 		for i := 0; i < b.N; i++ {
 			_, _, _, _ = p.parseBasicString(input)
 		}
 	})
 }
 func BenchmarkParseBasicStringsEasy(b *testing.B) {
 	p := &Parser{}
 	for _, size := range []int{1, 4, 8, 16, 21} {
 		b.Run(strconv.Itoa(size), func(b *testing.B) {
 			input := []byte(`"` + strings.Repeat("A", size) + `"`)
 			b.ReportAllocs()
 			b.SetBytes(int64(len(input)))
 			for i := 0; i < b.N; i++ {
 				_, _, _, _ = p.parseBasicString(input)
 			}
 		})
 	}
 }
 func TestParser_AST_DateTimes(t *testing.T) {
 	examples := []struct {
 		desc  string
 		input string
 		kind  Kind
 		err   bool
 	}{
 		{
 			desc:  "offset-date-time with delim 'T' and UTC offset",
 			input: `2021-07-21T12:08:05Z`,
 			kind:  DateTime,
 		},
 		{
 			desc:  "offset-date-time with space delim and +8hours offset",
 			input: `2021-07-21 12:08:05+08:00`,
 			kind:  DateTime,
 		},
 		{
 			desc:  "local-date-time with nano second",
 			input: `2021-07-21T12:08:05.666666666`,
 			kind:  LocalDateTime,
 		},
 		{
 			desc:  "local-date-time",
 			input: `2021-07-21T12:08:05`,
 			kind:  LocalDateTime,
 		},
 		{
 			desc:  "local-date",
 			input: `2021-07-21`,
 			kind:  LocalDate,
 		},
 	}
 	for _, e := range examples {
 		e := e
 		t.Run(e.desc, func(t *testing.T) {
 			p := Parser{}
 			p.Reset([]byte(`A = ` + e.input))
 			p.NextExpression()
 			err := p.Error()
 			if e.err {
 				assert.Error(t, err)
 			} else {
 				assert.NoError(t, err)
 				expected := astNode{
 					Kind: KeyValue,
 					Children: []astNode{
 						{Kind: e.kind, Data: []byte(e.input)},
 						{Kind: Key, Data: []byte(`A`)},
 					},
 				}
 				compareNode(t, expected, p.Expression())
 			}
 		})
 	}
 }
 // This example demonstrates how to parse a TOML document and preserving
 // comments.  Comments are stored in the AST as Comment nodes. This example
 // displays the structure of the full AST generated by the parser using the
 // following structure:
 //
 //  1. Each root-level expression is separated by three dashes.
 //  2. Bytes associated to a node are displayed in square brackets.
 //  3. Siblings have the same indentation.
 //  4. Children of a node are indented one level.
 func ExampleParser_comments() {
 	doc := `# Top of the document comment.
 # Optional, any amount of lines.
 # Above table.
 [table] # Next to table.
 # Above simple value.
 key = "value" # Next to simple value.
 # Below simple value.
 # Some comment alone.
 # Multiple comments, on multiple lines.
 # Above inline table.
 name = { first = "Tom", last = "Preston-Werner" } # Next to inline table.
 # Below inline table.
 # Above array.
 array = [ 1, 2, 3 ] # Next to one-line array.
 # Below array.
 # Above multi-line array.
 key5 = [ # Next to start of inline array.
  # Second line before array content.
  1, # Next to first element.
  # After first element.
  # Before second element.
  2,
  3, # Next to last element
  # After last element.
 ] # Next to end of array.
 # Below multi-line array.
 # Before array table.
 [[products]] # Next to array table.
 # After array table.
 `
 	var printGeneric func(*Parser, int, *Node)
 	printGeneric = func(p *Parser, indent int, e *Node) {
 		if e == nil {
 			return
 		}
 		s := p.Shape(e.Raw)
 		x := fmt.Sprintf("%d:%d->%d:%d (%d->%d)", s.Start.Line, s.Start.Column, s.End.Line, s.End.Column, s.Start.Offset, s.End.Offset)
 		fmt.Printf("%-25s | %s%s [%s]\n", x, strings.Repeat("  ", indent), e.Kind, e.Data)
 		printGeneric(p, indent+1, e.Child())
 		printGeneric(p, indent, e.Next())
 	}
 	printTree := func(p *Parser) {
 		for p.NextExpression() {
 			e := p.Expression()
 			fmt.Println("---")
 			printGeneric(p, 0, e)
 		}
 		if err := p.Error(); err != nil {
 			panic(err)
 		}
 	}
 	p := &Parser{
 		KeepComments: true,
 	}
 	p.Reset([]byte(doc))
 	printTree(p)
 	// Output:
 	// ---
 	// 1:1->1:31 (0->30)         | Comment [# Top of the document comment.]
 	// ---
 	// 2:1->2:33 (31->63)        | Comment [# Optional, any amount of lines.]
 	// ---
 	// 4:1->4:15 (65->79)        | Comment [# Above table.]
 	// ---
 	// 1:1->1:1 (0->0)           | Table []
 	// 5:2->5:7 (81->86)         |   Key [table]
 	// 5:9->5:25 (88->104)       | Comment [# Next to table.]
 	// ---
 	// 6:1->6:22 (105->126)      | Comment [# Above simple value.]
 	// ---
 	// 7:1->7:14 (127->140)      | KeyValue []
 	// 7:7->7:14 (133->140)      |   String [value]
 	// 7:1->7:4 (127->130)       |   Key [key]
 	// 7:15->7:38 (141->164)     | Comment [# Next to simple value.]
 	// ---
 	// 8:1->8:22 (165->186)      | Comment [# Below simple value.]
 	// ---
 	// 10:1->10:22 (188->209)    | Comment [# Some comment alone.]
 	// ---
 	// 12:1->12:40 (211->250)    | Comment [# Multiple comments, on multiple lines.]
 	// ---
 	// 14:1->14:22 (252->273)    | Comment [# Above inline table.]
 	// ---
 	// 15:1->15:50 (274->323)    | KeyValue []
 	// 15:8->15:9 (281->282)     |   InlineTable []
 	// 15:10->15:23 (283->296)   |     KeyValue []
 	// 15:18->15:23 (291->296)   |       String [Tom]
 	// 15:10->15:15 (283->288)   |       Key [first]
 	// 15:25->15:48 (298->321)   |     KeyValue []
 	// 15:32->15:48 (305->321)   |       String [Preston-Werner]
 	// 15:25->15:29 (298->302)   |       Key [last]
 	// 15:1->15:5 (274->278)     |   Key [name]
 	// 15:51->15:74 (324->347)   | Comment [# Next to inline table.]
 	// ---
 	// 16:1->16:22 (348->369)    | Comment [# Below inline table.]
 	// ---
 	// 18:1->18:15 (371->385)    | Comment [# Above array.]
 	// ---
 	// 19:1->19:20 (386->405)    | KeyValue []
 	// 1:1->1:1 (0->0)           |   Array []
 	// 19:11->19:12 (396->397)   |     Integer [1]
 	// 19:14->19:15 (399->400)   |     Integer [2]
 	// 19:17->19:18 (402->403)   |     Integer [3]
 	// 19:1->19:6 (386->391)     |   Key [array]
 	// 19:21->19:46 (406->431)   | Comment [# Next to one-line array.]
 	// ---
 	// 20:1->20:15 (432->446)    | Comment [# Below array.]
 	// ---
 	// 22:1->22:26 (448->473)    | Comment [# Above multi-line array.]
 	// ---
 	// 23:1->31:2 (474->694)     | KeyValue []
 	// 1:1->1:1 (0->0)           |   Array []
 	// 23:10->23:42 (483->515)   |     Comment [# Next to start of inline array.]
 	// 24:3->24:38 (518->553)    |       Comment [# Second line before array content.]
 	// 25:3->25:4 (556->557)     |     Integer [1]
 	// 25:6->25:30 (559->583)    |     Comment [# Next to first element.]
 	// 26:3->26:25 (586->608)    |       Comment [# After first element.]
 	// 27:3->27:27 (611->635)    |       Comment [# Before second element.]
 	// 28:3->28:4 (638->639)     |     Integer [2]
 	// 29:3->29:4 (643->644)     |     Integer [3]
 	// 29:6->29:28 (646->668)    |     Comment [# Next to last element]
 	// 30:3->30:24 (671->692)    |       Comment [# After last element.]
 	// 23:1->23:5 (474->478)     |   Key [key5]
 	// 31:3->31:26 (695->718)    | Comment [# Next to end of array.]
 	// ---
 	// 32:1->32:26 (719->744)    | Comment [# Below multi-line array.]
 	// ---
 	// 34:1->34:22 (746->767)    | Comment [# Before array table.]
 	// ---
 	// 1:1->1:1 (0->0)           | ArrayTable []
 	// 35:3->35:11 (770->778)    |   Key [products]
 	// 35:14->35:36 (781->803)   | Comment [# Next to array table.]
 	// ---
 	// 36:1->36:21 (804->824)    | Comment [# After array table.]
 }
 func TestIterator_IsLast(t *testing.T) {
 	// Test IsLast on an iterator with multiple elements using public Parser API
 	doc := `array = [1, 2, 3]`
 	p := Parser{}
 	p.Reset([]byte(doc))
 	p.NextExpression()
 	e := p.Expression()
 	arr := e.Value() // The array node
 	it := arr.Children()
 	count := 0
 	lastCount := 0
 	for it.Next() {
 		count++
 		if it.IsLast() {
 			lastCount++
 		}
 	}
 	assert.Equal(t, 3, count)
 	assert.Equal(t, 1, lastCount)
 }
 func TestNodeChaining(t *testing.T) {
 	// Test that sibling nodes are correctly chained via Next()
 	// This exercises the internal PushAndChain functionality through public APIs
 	doc := `a.b.c = 1`
 	p := Parser{}
 	p.Reset([]byte(doc))
 	p.NextExpression()
 	e := p.Expression()
 	// KeyValue has children: value, then key parts (a, b, c)
 	keyIt := e.Key()
 	// Collect all key parts by following the iterator
 	var keys []string
 	for keyIt.Next() {
 		keys = append(keys, string(keyIt.Node().Data))
 	}
 	assert.Equal(t, []string{"a", "b", "c"}, keys)
 }
 func TestMultipleExpressions(t *testing.T) {
 	// Test parsing multiple top-level expressions
 	// This exercises root iteration through public APIs
 	doc := `
 key1 = "value1"
 key2 = "value2"
 key3 = "value3"
 `
 	p := Parser{}
 	p.Reset([]byte(doc))
 	var keys []string
 	for p.NextExpression() {
 		e := p.Expression()
 		keyIt := e.Key()
 		keyIt.Next()
 		keys = append(keys, string(keyIt.Node().Data))
 	}
 	assert.NoError(t, p.Error())
 	assert.Equal(t, []string{"key1", "key2", "key3"}, keys)
 }
 func ExampleParser() {
 	doc := `
 	hello = "world"
 	value = 42
 	`
 	p := Parser{}
 	p.Reset([]byte(doc))
 	for p.NextExpression() {
 		e := p.Expression()
 		fmt.Printf("Expression: %s\n", e.Kind)
 		value := e.Value()
 		it := e.Key()
 		k := it.Node() // shortcut: we know there is no dotted key in the example
 		fmt.Printf("%s -> (%s) %s\n", k.Data, value.Kind, value.Data)
 	}
 	// Output:
 	// Expression: KeyValue
 	// hello -> (String) world
 	// Expression: KeyValue
 	// value -> (Integer) 42
 }
--- a/Show More
+++ b/Show More
		`@@ -0,0 +1,2 @@`
							`// Package toml is a library to read and write TOML documents.`
							`package toml`
`@@ -1 +1,2 @@`
		`// Package tracker provides functions for keeping track of AST nodes.`
	`package tracker`	`package tracker`
		`@@ -0,0 +1,2 @@`
							`go test fuzz v1`
							`[]byte("0=0000-01-01 00:00:00")`
		`@@ -0,0 +1,2 @@`
							`go test fuzz v1`
							`[]byte("0=\"\"\"\\U00000000\"\"\"")`
		`@@ -0,0 +1,2 @@`
							`go test fuzz v1`
							`[]byte("0=0000-01-01 00:00:00+00:00")`