Specialize map[string]iface when unmarshaling kvs

name old time/op new time/op delta UnmarshalDataset/config-8 12.3ms ± 0% 10.9ms ± 0% -11.36% (p=0.008 n=5+5) UnmarshalDataset/canada-8 55.2ms ± 0% 55.4ms ± 1% ~ (p=0.690 n=5+5) UnmarshalDataset/citm_catalog-8 16.5ms ± 1% 15.7ms ± 0% -4.43% (p=0.008 n=5+5) UnmarshalDataset/twitter-8 7.01ms ± 1% 6.63ms ± 0% -5.34% (p=0.008 n=5+5) UnmarshalDataset/code-8 52.0ms ± 0% 48.7ms ± 2% -6.43% (p=0.008 n=5+5) UnmarshalDataset/example-8 119µs ± 0% 110µs ± 3% -6.81% (p=0.008 n=5+5) Unmarshal/SimpleDocument/struct-8 432ns ± 1% 431ns ± 1% ~ (p=0.222 n=5+5) Unmarshal/SimpleDocument/map-8 573ns ± 1% 540ns ± 1% -5.64% (p=0.008 n=5+5) Unmarshal/ReferenceFile/struct-8 33.7µs ± 0% 33.6µs ± 0% ~ (p=0.310 n=5+5) Unmarshal/ReferenceFile/map-8 44.2µs ± 1% 41.7µs ± 1% -5.63% (p=0.008 n=5+5) Unmarshal/HugoFrontMatter-8 7.28µs ± 1% 6.74µs ± 1% -7.42% (p=0.008 n=5+5) [Geo mean] 292µs 277µs -4.91% name old speed new speed delta UnmarshalDataset/config-8 85.2MB/s ± 0% 96.1MB/s ± 0% +12.82% (p=0.008 n=5+5) UnmarshalDataset/canada-8 39.9MB/s ± 0% 39.8MB/s ± 1% ~ (p=0.690 n=5+5) UnmarshalDataset/citm_catalog-8 33.9MB/s ± 1% 35.5MB/s ± 0% +4.64% (p=0.008 n=5+5) UnmarshalDataset/twitter-8 63.1MB/s ± 1% 66.6MB/s ± 0% +5.65% (p=0.008 n=5+5) UnmarshalDataset/code-8 51.6MB/s ± 0% 55.1MB/s ± 2% +6.88% (p=0.008 n=5+5) UnmarshalDataset/example-8 68.3MB/s ± 0% 73.4MB/s ± 3% +7.34% (p=0.008 n=5+5) Unmarshal/SimpleDocument/struct-8 25.4MB/s ± 1% 25.5MB/s ± 1% ~ (p=0.246 n=5+5) Unmarshal/SimpleDocument/map-8 19.2MB/s ± 1% 20.4MB/s ± 1% +5.99% (p=0.008 n=5+5) Unmarshal/ReferenceFile/struct-8 156MB/s ± 0% 156MB/s ± 0% ~ (p=0.310 n=5+5) Unmarshal/ReferenceFile/map-8 119MB/s ± 1% 126MB/s ± 1% +5.97% (p=0.008 n=5+5) Unmarshal/HugoFrontMatter-8 75.0MB/s ± 1% 81.0MB/s ± 1% +8.01% (p=0.008 n=5+5) [Geo mean] 56.1MB/s 59.0MB/s +5.17% name old alloc/op new alloc/op delta UnmarshalDataset/config-8 5.26MB ± 0% 4.75MB ± 0% -9.66% (p=0.008 n=5+5) UnmarshalDataset/canada-8 83.0MB ± 0% 83.0MB ± 0% -0.00% (p=0.008 n=5+5) UnmarshalDataset/citm_catalog-8 34.7MB ± 0% 34.3MB ± 0% -1.13% (p=0.008 n=5+5) UnmarshalDataset/twitter-8 12.7MB ± 0% 12.5MB ± 0% -1.44% (p=0.008 n=5+5) UnmarshalDataset/code-8 15.3MB ± 0% 13.9MB ± 0% -9.27% (p=0.008 n=5+5) UnmarshalDataset/example-8 186kB ± 0% 182kB ± 0% -2.20% (p=0.008 n=5+5) Unmarshal/SimpleDocument/struct-8 805B ± 0% 805B ± 0% ~ (all equal) Unmarshal/SimpleDocument/map-8 1.13kB ± 0% 1.12kB ± 0% -1.41% (p=0.008 n=5+5) Unmarshal/ReferenceFile/struct-8 20.9kB ± 0% 20.9kB ± 0% ~ (all equal) Unmarshal/ReferenceFile/map-8 36.4kB ± 0% 35.4kB ± 0% ~ (p=0.079 n=4+5) Unmarshal/HugoFrontMatter-8 7.20kB ± 0% 6.98kB ± 0% -3.11% (p=0.008 n=5+5) [Geo mean] 312kB 303kB -2.86% name old allocs/op new allocs/op delta UnmarshalDataset/config-8 189k ± 0% 157k ± 0% -16.80% (p=0.029 n=4+4) UnmarshalDataset/canada-8 782k ± 0% 782k ± 0% -0.00% (p=0.008 n=5+5) UnmarshalDataset/citm_catalog-8 191k ± 0% 167k ± 0% -12.75% (p=0.000 n=4+5) UnmarshalDataset/twitter-8 56.9k ± 0% 45.5k ± 0% -20.02% (p=0.016 n=5+4) UnmarshalDataset/code-8 626k ± 0% 537k ± 0% -14.22% (p=0.008 n=5+5) UnmarshalDataset/example-8 1.36k ± 0% 1.11k ± 0% -18.53% (p=0.008 n=5+5) Unmarshal/SimpleDocument/struct-8 9.00 ± 0% 9.00 ± 0% ~ (all equal) Unmarshal/SimpleDocument/map-8 13.0 ± 0% 12.0 ± 0% -7.69% (p=0.008 n=5+5) Unmarshal/ReferenceFile/struct-8 183 ± 0% 183 ± 0% ~ (all equal) Unmarshal/ReferenceFile/map-8 526 ± 0% 466 ± 0% -11.41% (p=0.008 n=5+5) Unmarshal/HugoFrontMatter-8 126 ± 0% 112 ± 0% -11.11% (p=0.008 n=5+5) [Geo mean] 3.73k 3.34k -10.51%
Specialize navigating map[string]interface{}
2022-04-15 17:41:18 -04:00 · 2022-04-15 17:20:24 -04:00
82 changed files with 3410 additions and 9558 deletions
@@ -1,25 +0,0 @@
-name: capabilities
-on:
-  push:
-    branches:
-      - v2
-  pull_request:
-    branches:
-      - v2
-
-jobs:
-  check:
-    name: check capabilities
-    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.26"
-      - name: Install capslock
-        run: go install github.com/google/capslock/cmd/capslock@latest
-      - name: Check for new capabilities
-        run: ./caps.sh check
@@ -1,26 +0,0 @@
-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@v7
-      if: failure() && steps.build.outcome == 'success'
-      with:
-        name: artifacts
-        path: ./out/artifacts
@@ -35,11 +35,11 @@ jobs:

    steps:
    - name: Checkout repository
-      uses: actions/checkout@v6
+      uses: actions/checkout@v2

    # Initializes the CodeQL tools for scanning.
    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v4
+      uses: github/codeql-action/init@v1
      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@v4
+      uses: github/codeql-action/autobuild@v1

    # ℹ️ 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@v4
+      uses: github/codeql-action/analyze@v1
@@ -9,12 +9,12 @@ jobs:
    runs-on: "ubuntu-latest"
    name: report
    steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@master
        with:
          fetch-depth: 0
      - name: Setup go
-        uses: actions/setup-go@v6
+        uses: actions/setup-go@master
        with:
-          go-version: "1.26"
+          go-version: 1.18
      - name: Run tests with coverage
        run: ./ci.sh coverage -d "${GITHUB_BASE_REF-HEAD}"
@@ -1,36 +0,0 @@
-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@v4
-
-      - 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@v7
-        with:
-          name: go-versions-test-results
-          path: |
-            test-results/
-          retention-days: 30
@@ -1,22 +0,0 @@
-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.26"
-      - name: Run golangci-lint
-        uses: golangci/golangci-lint-action@v9
-        with:
-          version: v2.8.0
@@ -16,24 +16,24 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v2
        with:
          fetch-depth: 0
      - name: Set up Go
-        uses: actions/setup-go@v6
+        uses: actions/setup-go@v2
        with:
-          go-version: "1.26"
+          go-version: 1.18
      - name: Login to GitHub Container Registry
-        uses: docker/login-action@v4
+        uses: docker/login-action@v1
        with:
          registry: ghcr.io
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}
      - name: Run GoReleaser
-        uses: goreleaser/goreleaser-action@v7
+        uses: goreleaser/goreleaser-action@v2
        with:
          distribution: goreleaser
-          version: '~> v2'
-          args: release ${{ inputs.args }} --clean
+          version: latest
+          args: release ${{ inputs.args }} --rm-dist
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -10,24 +10,23 @@ on:
 jobs:
  build:
    strategy:
-      fail-fast: false
      matrix:
-        os: [ 'ubuntu-latest', 'windows-latest', 'macos-latest', 'macos-14' ]
-        go: [ '1.25', '1.26' ]
+        os: [ 'ubuntu-latest', 'windows-latest', 'macos-latest']
+        go: [ '1.17', '1.18' ]
    runs-on: ${{ matrix.os }}
    name: ${{ matrix.go }}/${{ matrix.os }}
    steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@master
        with:
          fetch-depth: 0
      - name: Setup go ${{ matrix.go }}
-        uses: actions/setup-go@v6
+        uses: actions/setup-go@master
        with:
          go-version: ${{ matrix.go }}
      - name: Run unit tests
        run: go test -race ./...
  release-check:
    if: ${{ github.ref != 'refs/heads/v2' }}
-    uses: ./.github/workflows/release.yml
+    uses: pelletier/go-toml/.github/workflows/release.yml@v2
    with:
      args: --snapshot
@@ -3,6 +3,4 @@ fuzz/
 cmd/tomll/tomll
 cmd/tomljson/tomljson
 cmd/tomltestgen/tomltestgen
-dist
-tests/
-test-results
+dist
@@ -1,76 +1,84 @@
-version = "2"
+[service]
+golangci-lint-version =  "1.39.0"
+
+[linters-settings.wsl]
+allow-assign-and-anything = true
+
+[linters-settings.exhaustive]
+default-signifies-exhaustive = true

 [linters]
-default = "none"
+disable-all = true
 enable = [
    "asciicheck",
    "bodyclose",
+    "cyclop",
+    "deadcode",
+    "depguard",
    "dogsled",
    "dupl",
    "durationcheck",
    "errcheck",
    "errorlint",
    "exhaustive",
+    # "exhaustivestruct",
+    "exportloopref",
    "forbidigo",
+    # "forcetypeassert",
+    "funlen",
+    "gci",
+    # "gochecknoglobals",
    "gochecknoinits",
+    "gocognit",
    "goconst",
    "gocritic",
-    "godoclint",
+    "gocyclo",
+    "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",
-    "perfsprint",
+    #"paralleltest",
    "prealloc",
    "predeclared",
    "revive",
    "rowserrcheck",
    "sqlclosecheck",
    "staticcheck",
+    "structcheck",
+    "stylecheck",
+    # "testpackage",
    "thelper",
    "tparallel",
+    "typecheck",
    "unconvert",
    "unparam",
    "unused",
-    "usetesting",
+    "varcheck",
    "wastedassign",
    "whitespace",
-]
-
-[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",
+    # "wrapcheck",
+    # "wsl"
 ]
@@ -1,4 +1,3 @@
-version: 2
 before:
  hooks:
    - go mod tidy
@@ -17,11 +16,7 @@ builds:
    mod_timestamp: '{{ .CommitTimestamp }}'
    targets:
      - linux_amd64
-      - linux_arm64
-      - linux_arm
-      - linux_riscv64
      - windows_amd64
-      - windows_arm64
      - darwin_amd64
      - darwin_arm64
  - id: tomljson
@@ -36,11 +31,7 @@ builds:
    mod_timestamp: '{{ .CommitTimestamp }}'
    targets:
      - linux_amd64
-      - linux_arm64
-      - linux_arm
-      - linux_riscv64
      - windows_amd64
-      - windows_arm64
      - darwin_amd64
      - darwin_arm64
  - id: jsontoml
@@ -55,11 +46,7 @@ builds:
    mod_timestamp: '{{ .CommitTimestamp }}'
    targets:
      - linux_amd64
-      - linux_arm64
-      - linux_riscv64
-      - linux_arm
      - windows_amd64
-      - windows_arm64
      - darwin_amd64
      - darwin_arm64
 universal_binaries:
@@ -110,7 +97,7 @@ dockers:
 checksum:
  name_template: 'sha256sums.txt'
 snapshot:
-  version_template: "{{ incpatch .Version }}-next"
+  name_template: "{{ incpatch .Version }}-next"
 release:
  github:
    owner: pelletier
@@ -1,73 +0,0 @@
-# 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
-
-### Capabilities
-
-go-toml tracks system-level capabilities using [capslock](https://github.com/google/capslock). The baseline is in `capability_baseline.txt` and CI enforces that it does not grow.
-
- **Do not introduce new capabilities.** PRs that increase the capability set (e.g., adding network access, subprocess execution, syscalls) are unlikely to be accepted.
- If a change causes the capabilities check to fail, do not update the baseline to make it pass. Instead, rethink the approach to avoid requiring new capabilities.
- To check locally: `./caps.sh check` (requires `capslock` installed via `go install github.com/google/capslock/cmd/capslock@latest`)
-
-## 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. Capabilities are not increasing (`./caps.sh check`)
-6. Title is clear and understandable for changelog
@@ -33,7 +33,7 @@ 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
+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.

@@ -92,48 +92,6 @@ However, given GitHub's new policy to _not_ run Actions on pull requests until a
 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
@@ -153,7 +111,7 @@ code lowers the coverage.

 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
+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:

@@ -180,25 +138,6 @@ description. Pull requests that lower performance will receive more scrutiny.

 [benchstat]: https://pkg.go.dev/golang.org/x/perf/cmd/benchstat

-### Capabilities
-
-We use [capslock](https://github.com/google/capslock) to track what
-system-level capabilities (file access, network, syscalls, etc.) each package
-requires. The current baseline is in `capability_baseline.txt`. CI will fail if
-a change introduces a new capability.
-
-**Pull requests that increase the set of capabilities are unlikely to be
-accepted.** go-toml is a parsing library and should not need network access,
-subprocess execution, or other capabilities beyond what it already uses.
-
-If you believe a new capability is genuinely needed, discuss it in an issue
-first. To update the baseline after approval:
-
-```bash
-go install github.com/google/capslock/cmd/capslock@latest
-./caps.sh generate
-```
-
 ### Style

 Try to look around and follow the same format and structure as the rest of the
@@ -226,22 +165,25 @@ Checklist:

 ### 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. Decide on the next version number. Use semver.
+2. Generate release notes using [`gh`][gh]. Example:
+```
+$ gh api -X POST \
+  -F tag_name='v2.0.0-beta.5' \
+  -F target_commitish='v2' \
+  -F previous_tag_name='v2.0.0-beta.4' \
+  --jq '.body' \
+  repos/pelletier/go-toml/releases/generate-notes
+```
+3. 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. [Draft new release][new-release].
+5. Fill tag and target with the same value used to generate the changelog.
+6. Set title to the new tag value.
+7. Paste the generated changelog.
+8. Check "create discussion", in the "Releases" category.
+9. Check pre-release if new version is an alpha or beta.

 [issues-tracker]: https://github.com/pelletier/go-toml/issues
 [bug-report]: https://github.com/pelletier/go-toml/issues/new?template=bug_report.md
@@ -1,7 +1,6 @@
 The MIT License (MIT)

-go-toml v2
-Copyright (c) 2021 - 2023 Thomas Pelletier
+Copyright (c) 2013 - 2021 Thomas Pelletier, Eric Anderton

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -4,6 +4,17 @@ Go library for the [TOML](https://toml.io/en/) format.

 This library supports [TOML v1.0.0](https://toml.io/en/v1.0.0).

+## Development status
+
+This is the upcoming major version of go-toml. It is currently in active
+development. As of release v2.0.0-beta.1, the library has reached feature parity
+with v1, and fixes a lot known bugs and performance issues along the way.
+
+If you do not need the advanced document editing features of v1, you are
+encouraged to try out this version.
+
+[👉 Roadmap for v2](https://github.com/pelletier/go-toml/discussions/506)
+
 [🐞 Bug Reports](https://github.com/pelletier/go-toml/issues)

 [💬 Anything else](https://github.com/pelletier/go-toml/discussions)
@@ -38,22 +49,23 @@ 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
+the TOML document was not prevent 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],
+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
+2| key1 = "value1"
+3| key2 = "missing2"
+ | ~~~~ missing field
+4| key3 = "missing3"
+5| key4 = "value4"
 ```

 [decode-err]: https://pkg.go.dev/github.com/pelletier/go-toml/v2#DecodeError
@@ -72,46 +84,22 @@ representation.
 [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
+      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:
+content. For example:

 ```go
 doc := `
@@ -123,7 +111,7 @@ tags = ["go", "toml"]
 var cfg MyConfig
 err := toml.Unmarshal([]byte(doc), &cfg)
 if err != nil {
-	panic(err)
+      panic(err)
 }
 fmt.Println("version:", cfg.Version)
 fmt.Println("name:", cfg.Name)
@@ -137,62 +125,6 @@ fmt.Println("tags:", cfg.Tags)

 [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
@@ -200,14 +132,14 @@ as a TOML document:

 ```go
 cfg := MyConfig{
-	Version: 2,
-	Name:    "go-toml",
-	Tags:    []string{"go", "toml"},
+      Version: 2,
+      Name:    "go-toml",
+      Tags:    []string{"go", "toml"},
 }

 b, err := toml.Marshal(cfg)
 if err != nil {
-	panic(err)
+      panic(err)
 }
 fmt.Println(string(b))

@@ -219,33 +151,22 @@ fmt.Println(string(b))

 [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>
+    <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>1.9x</td></tr>
+        <tr><td>Marshal/ReferenceFile/map-2</td><td>1.7x</td><td>1.8x</td></tr>
+        <tr><td>Marshal/ReferenceFile/struct-2</td><td>2.2x</td><td>2.5x</td></tr>
+        <tr><td>Unmarshal/HugoFrontMatter-2</td><td>2.9x</td><td>2.9x</td></tr>
+        <tr><td>Unmarshal/ReferenceFile/map-2</td><td>2.6x</td><td>2.9x</td></tr>
+        <tr><td>Unmarshal/ReferenceFile/struct-2</td><td>4.4x</td><td>5.3x</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
@@ -253,22 +174,22 @@ 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>
+    <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.9x</td></tr>
+        <tr><td>Marshal/SimpleDocument/struct-2</td><td>2.7x</td><td>4.2x</td></tr>
+        <tr><td>Unmarshal/SimpleDocument/map-2</td><td>4.5x</td><td>3.1x</td></tr>
+        <tr><td>Unmarshal/SimpleDocument/struct-2</td><td>6.2x</td><td>3.9x</td></tr>
+        <tr><td>UnmarshalDataset/example-2</td><td>3.1x</td><td>3.5x</td></tr>
+        <tr><td>UnmarshalDataset/code-2</td><td>2.3x</td><td>3.1x</td></tr>
+        <tr><td>UnmarshalDataset/twitter-2</td><td>2.5x</td><td>2.6x</td></tr>
+        <tr><td>UnmarshalDataset/citm_catalog-2</td><td>2.1x</td><td>2.2x</td></tr>
+        <tr><td>UnmarshalDataset/canada-2</td><td>1.6x</td><td>1.3x</td></tr>
+        <tr><td>UnmarshalDataset/config-2</td><td>4.3x</td><td>3.2x</td></tr>
+        <tr><td>[Geo mean]</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>
@@ -293,24 +214,24 @@ 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
-	```
+    ```
+    $ 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
-	```
+    ```
+    $ 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
-	```
+    ```
+    $ go install github.com/pelletier/go-toml/v2/cmd/tomll@latest
+    $ tomll --help
+    ```

 ### Docker image

@@ -321,7 +242,7 @@ Those tools are also available as a [Docker image][docker]. For example, to use
 docker run -i ghcr.io/pelletier/go-toml:v2 tomljson < example.toml
 ```

-Multiple versions are available on [ghcr.io][docker].
+Multiple versions are availble on [ghcr.io][docker].

 [docker]: https://github.com/pelletier/go-toml/pkgs/container/go-toml

@@ -353,16 +274,16 @@ element in the interface to decode the object. For example:

 ```go
 type inner struct {
-	B interface{}
+  B interface{}
 }
 type doc struct {
-	A interface{}
+  A interface{}
 }

 d := doc{
-	A: inner{
-		B: "Before",
-	},
+  A: inner{
+    B: "Before",
+  },
 }

 data := `
@@ -401,7 +322,7 @@ contained in the doc is superior to the capacity of the array. For example:

 ```go
 type doc struct {
-	A [2]string
+  A [2]string
 }
 d := doc{}
 err := toml.Unmarshal([]byte(`A = ["one", "two", "many"]`), &d)
@@ -576,20 +497,27 @@ is not necessary anymore.

 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:
+`toml`, `multiline`, and `omitempty`. For example:

 ```go
 type doc struct {
 	// v1
-	F string `toml:"field" multiline:"true" omitempty:"true" commented:"true"`
+	F string `toml:"field" multiline:"true" omitempty:"true"`
 	// v2
-	F string `toml:"field,multiline,omitempty,commented"`
+	F string `toml:"field,multiline,omitempty"`
 }
 ```

 Has a result, the `Encoder.SetTag*` methods have been removed, as there is just
 one tag now.

+
+#### `commented` tag has been removed
+
+There is no replacement for the `commented` tag. This feature would be better
+suited in a proper document model for go-toml v2, which has been [cut from
+scope][nodoc] at the moment.
+
 #### `Encoder.ArraysWithOneElementPerLine` has been renamed

 The new name is `Encoder.SetArraysMultiline`. The behavior should be the same.
@@ -623,14 +551,6 @@ 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

 The MIT License (MIT). Read [LICENSE](LICENSE).
@@ -2,6 +2,9 @@

 ## Supported Versions

+Use this section to tell people about which versions of your project are
+currently being supported with security updates.
+
 | Version    | Supported          |
 | ---------- | ------------------ |
 | Latest 2.x | :white_check_mark: |
@@ -3,16 +3,16 @@ package benchmark_test
 import (
 	"compress/gzip"
 	"encoding/json"
-	"io"
+	"io/ioutil"
 	"os"
 	"path/filepath"
 	"testing"

 	"github.com/pelletier/go-toml/v2"
-	"github.com/pelletier/go-toml/v2/internal/assert"
+	"github.com/stretchr/testify/require"
 )

-var benchInputs = []struct {
+var bench_inputs = []struct {
 	name    string
 	jsonLen int
 }{
@@ -30,22 +30,22 @@ var benchInputs = []struct {
 }

 func TestUnmarshalDatasetCode(t *testing.T) {
-	for _, tc := range benchInputs {
+	for _, tc := range bench_inputs {
 		t.Run(tc.name, func(t *testing.T) {
 			buf := fixture(t, tc.name)

 			var v interface{}
-			assert.NoError(t, toml.Unmarshal(buf, &v))
+			require.NoError(t, toml.Unmarshal(buf, &v))

 			b, err := json.Marshal(v)
-			assert.NoError(t, err)
-			assert.Equal(t, len(b), tc.jsonLen)
+			require.NoError(t, err)
+			require.Equal(t, len(b), tc.jsonLen)
 		})
 	}
 }

 func BenchmarkUnmarshalDataset(b *testing.B) {
-	for _, tc := range benchInputs {
+	for _, tc := range bench_inputs {
 		b.Run(tc.name, func(b *testing.B) {
 			buf := fixture(b, tc.name)
 			b.SetBytes(int64(len(buf)))
@@ -53,7 +53,7 @@ func BenchmarkUnmarshalDataset(b *testing.B) {
 			b.ResetTimer()
 			for i := 0; i < b.N; i++ {
 				var v interface{}
-				assert.NoError(b, toml.Unmarshal(buf, &v))
+				require.NoError(b, toml.Unmarshal(buf, &v))
 			}
 		})
 	}
@@ -68,13 +68,13 @@ func fixture(tb testing.TB, path string) []byte {
 	if os.IsNotExist(err) {
 		tb.Skip("benchmark fixture not found:", file)
 	}
-	assert.NoError(tb, err)
-	defer func() { _ = f.Close() }()
+	require.NoError(tb, err)
+	defer f.Close()

 	gz, err := gzip.NewReader(f)
-	assert.NoError(tb, err)
+	require.NoError(tb, err)

-	buf, err := io.ReadAll(gz)
-	assert.NoError(tb, err)
+	buf, err := ioutil.ReadAll(gz)
+	require.NoError(tb, err)
 	return buf
 }
@@ -2,12 +2,12 @@ package benchmark_test

 import (
 	"bytes"
-	"os"
+	"io/ioutil"
 	"testing"
 	"time"

 	"github.com/pelletier/go-toml/v2"
-	"github.com/pelletier/go-toml/v2/internal/assert"
+	"github.com/stretchr/testify/require"
 )

 func TestUnmarshalSimple(t *testing.T) {
@@ -18,7 +18,7 @@ func TestUnmarshalSimple(t *testing.T) {

 	err := toml.Unmarshal(doc, &d)
 	if err != nil {
-		t.Error(err)
+		panic(err)
 	}
 }

@@ -38,7 +38,7 @@ func BenchmarkUnmarshal(b *testing.B) {

 				err := toml.Unmarshal(doc, &d)
 				if err != nil {
-					b.Error(err)
+					panic(err)
 				}
 			}
 		})
@@ -52,14 +52,14 @@ func BenchmarkUnmarshal(b *testing.B) {
 				d := map[string]interface{}{}
 				err := toml.Unmarshal(doc, &d)
 				if err != nil {
-					b.Error(err)
+					panic(err)
 				}
 			}
 		})
 	})

 	b.Run("ReferenceFile", func(b *testing.B) {
-		bytes, err := os.ReadFile("benchmark.toml")
+		bytes, err := ioutil.ReadFile("benchmark.toml")
 		if err != nil {
 			b.Fatal(err)
 		}
@@ -72,7 +72,7 @@ func BenchmarkUnmarshal(b *testing.B) {
 				d := benchmarkDoc{}
 				err := toml.Unmarshal(bytes, &d)
 				if err != nil {
-					b.Error(err)
+					panic(err)
 				}
 			}
 		})
@@ -85,7 +85,7 @@ func BenchmarkUnmarshal(b *testing.B) {
 				d := map[string]interface{}{}
 				err := toml.Unmarshal(bytes, &d)
 				if err != nil {
-					b.Error(err)
+					panic(err)
 				}
 			}
 		})
@@ -99,7 +99,7 @@ func BenchmarkUnmarshal(b *testing.B) {
 			d := map[string]interface{}{}
 			err := toml.Unmarshal(hugoFrontMatterbytes, &d)
 			if err != nil {
-				b.Error(err)
+				panic(err)
 			}
 		}
 	})
@@ -123,7 +123,7 @@ func BenchmarkMarshal(b *testing.B) {

 			err := toml.Unmarshal(doc, &d)
 			if err != nil {
-				b.Error(err)
+				panic(err)
 			}

 			b.ReportAllocs()
@@ -134,7 +134,7 @@ func BenchmarkMarshal(b *testing.B) {
 			for i := 0; i < b.N; i++ {
 				out, err = marshal(d)
 				if err != nil {
-					b.Error(err)
+					panic(err)
 				}
 			}

@@ -145,7 +145,7 @@ func BenchmarkMarshal(b *testing.B) {
 			d := map[string]interface{}{}
 			err := toml.Unmarshal(doc, &d)
 			if err != nil {
-				b.Error(err)
+				panic(err)
 			}

 			b.ReportAllocs()
@@ -156,7 +156,7 @@ func BenchmarkMarshal(b *testing.B) {
 			for i := 0; i < b.N; i++ {
 				out, err = marshal(d)
 				if err != nil {
-					b.Error(err)
+					panic(err)
 				}
 			}

@@ -165,7 +165,7 @@ func BenchmarkMarshal(b *testing.B) {
 	})

 	b.Run("ReferenceFile", func(b *testing.B) {
-		bytes, err := os.ReadFile("benchmark.toml")
+		bytes, err := ioutil.ReadFile("benchmark.toml")
 		if err != nil {
 			b.Fatal(err)
 		}
@@ -174,7 +174,7 @@ func BenchmarkMarshal(b *testing.B) {
 			d := benchmarkDoc{}
 			err := toml.Unmarshal(bytes, &d)
 			if err != nil {
-				b.Error(err)
+				panic(err)
 			}
 			b.ReportAllocs()
 			b.ResetTimer()
@@ -184,7 +184,7 @@ func BenchmarkMarshal(b *testing.B) {
 			for i := 0; i < b.N; i++ {
 				out, err = marshal(d)
 				if err != nil {
-					b.Error(err)
+					panic(err)
 				}
 			}

@@ -195,7 +195,7 @@ func BenchmarkMarshal(b *testing.B) {
 			d := map[string]interface{}{}
 			err := toml.Unmarshal(bytes, &d)
 			if err != nil {
-				b.Error(err)
+				panic(err)
 			}

 			b.ReportAllocs()
@@ -205,7 +205,7 @@ func BenchmarkMarshal(b *testing.B) {
 			for i := 0; i < b.N; i++ {
 				out, err = marshal(d)
 				if err != nil {
-					b.Error(err)
+					panic(err)
 				}
 			}

@@ -217,7 +217,7 @@ func BenchmarkMarshal(b *testing.B) {
 		d := map[string]interface{}{}
 		err := toml.Unmarshal(hugoFrontMatterbytes, &d)
 		if err != nil {
-			b.Error(err)
+			panic(err)
 		}

 		b.ReportAllocs()
@@ -228,7 +228,7 @@ func BenchmarkMarshal(b *testing.B) {
 		for i := 0; i < b.N; i++ {
 			out, err = marshal(d)
 			if err != nil {
-				b.Error(err)
+				panic(err)
 			}
 		}

@@ -344,11 +344,11 @@ type benchmarkDoc struct {
 }

 func TestUnmarshalReferenceFile(t *testing.T) {
-	bytes, err := os.ReadFile("benchmark.toml")
-	assert.NoError(t, err)
+	bytes, err := ioutil.ReadFile("benchmark.toml")
+	require.NoError(t, err)
 	d := benchmarkDoc{}
 	err = toml.Unmarshal(bytes, &d)
-	assert.NoError(t, err)
+	require.NoError(t, err)

 	expected := benchmarkDoc{
 		Table: struct {
@@ -627,7 +627,7 @@ trimmed in raw strings.
 		},
 	}

-	assert.Equal(t, expected, d)
+	require.Equal(t, expected, d)
 }

 var hugoFrontMatterbytes = []byte(`
@@ -1,18 +1,16 @@
-package unstable
+package toml

 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)
-)
+var valid10Ascii = []byte("1234567890")
+var valid10Utf8 = []byte("日本語a")
+var valid1kUtf8 = bytes.Repeat([]byte("0123456789日本語日本語日本語日abcdefghijklmnopqrstuvwx"), 16)
+var valid1MUtf8 = bytes.Repeat(valid1kUtf8, 1024)
+var valid1kAscii = bytes.Repeat([]byte("012345678998jhjklasDJKLAAdjdfjsdklfjdslkabcdefghijklmnopqrstuvwx"), 16)
+var valid1MAscii = bytes.Repeat(valid1kAscii, 1024)

 func BenchmarkScanComments(b *testing.B) {
 	wrap := func(x []byte) []byte {
@@ -20,9 +18,9 @@ func BenchmarkScanComments(b *testing.B) {
 	}

 	inputs := map[string][]byte{
-		"10Valid":     wrap(valid10ASCII),
-		"1kValid":     wrap(valid1kASCII),
-		"1MValid":     wrap(valid1MASCII),
+		"10Valid":     wrap(valid10Ascii),
+		"1kValid":     wrap(valid1kAscii),
+		"1MValid":     wrap(valid1MAscii),
 		"10ValidUtf8": wrap(valid10Utf8),
 		"1kValidUtf8": wrap(valid1kUtf8),
 		"1MValidUtf8": wrap(valid1MUtf8),
@@ -35,7 +33,7 @@ func BenchmarkScanComments(b *testing.B) {
 			b.ResetTimer()

 			for i := 0; i < b.N; i++ {
-				_, _, _ = scanComment(input)
+				scanComment(input)
 			}
 		})
 	}
@@ -47,9 +45,9 @@ func BenchmarkParseLiteralStringValid(b *testing.B) {
 	}

 	inputs := map[string][]byte{
-		"10Valid":     wrap(valid10ASCII),
-		"1kValid":     wrap(valid1kASCII),
-		"1MValid":     wrap(valid1MASCII),
+		"10Valid":     wrap(valid10Ascii),
+		"1kValid":     wrap(valid1kAscii),
+		"1MValid":     wrap(valid1MAscii),
 		"10ValidUtf8": wrap(valid10Utf8),
 		"1kValidUtf8": wrap(valid1kUtf8),
 		"1MValidUtf8": wrap(valid1MUtf8),
@@ -57,7 +55,7 @@ func BenchmarkParseLiteralStringValid(b *testing.B) {

 	for name, input := range inputs {
 		b.Run(name, func(b *testing.B) {
-			p := Parser{}
+			p := parser{}
 			b.SetBytes(int64(len(input)))
 			b.ReportAllocs()
 			b.ResetTimer()
@@ -65,7 +63,7 @@ func BenchmarkParseLiteralStringValid(b *testing.B) {
 			for i := 0; i < b.N; i++ {
 				_, _, _, err := p.parseLiteralString(input)
 				if err != nil {
-					b.Error(err)
+					panic(err)
 				}
 			}
 		})
@@ -1 +0,0 @@
-github.com/pelletier/go-toml/v2: CAPABILITY_REFLECT, CAPABILITY_UNANALYZED, CAPABILITY_UNSAFE_POINTER
@@ -1,101 +0,0 @@
-#!/usr/bin/env bash
-#
-# Generates or checks the capability baseline for go-toml.
-#
-# Usage:
-#   ./caps.sh generate   # regenerate capability_baseline.txt
-#   ./caps.sh check      # check that capabilities haven't grown
-#
-# Requires: go, capslock (go install github.com/google/capslock/cmd/capslock@latest)
-
-set -euo pipefail
-
-BASELINE="capability_baseline.txt"
-CAPSLOCK="${CAPSLOCK:-capslock}"
-
-# Capabilities that must never appear in any package.
-FORBIDDEN_CAPS=(
-    CAPABILITY_NETWORK
-    CAPABILITY_CGO
-    CAPABILITY_EXEC
-)
-
-capslock_to_baseline() {
-    "$CAPSLOCK" -packages=. -output=package -granularity=package \
-        | jq -r 'to_entries | sort_by(.key) | .[] | .key + ": " + (.value | sort | join(", "))'
-}
-
-generate() {
-    capslock_to_baseline > "$BASELINE"
-    echo "Wrote $BASELINE"
-}
-
-check() {
-    if [ ! -f "$BASELINE" ]; then
-        echo "ERROR: $BASELINE not found. Run '$0 generate' first."
-        exit 1
-    fi
-
-    current=$(mktemp)
-    trap 'rm -f "$current"' EXIT
-
-    capslock_to_baseline > "$current"
-
-    failed=0
-
-    # Check for forbidden capabilities in current output.
-    for cap in "${FORBIDDEN_CAPS[@]}"; do
-        if grep -q "$cap" "$current"; then
-            echo "FORBIDDEN capability found: $cap"
-            grep "$cap" "$current"
-            failed=1
-        fi
-    done
-
-    # Extract all unique capability names from baseline and current.
-    baseline_caps=$(grep -oE 'CAPABILITY_[A-Z_]+' "$BASELINE" | sort -u)
-    current_caps=$(grep -oE 'CAPABILITY_[A-Z_]+' "$current" | sort -u)
-
-    # Check for new capability names not in the baseline.
-    new_caps=$(comm -13 <(echo "$baseline_caps") <(echo "$current_caps"))
-    if [ -n "$new_caps" ]; then
-        echo "NEW capabilities detected (not in baseline):"
-        echo "$new_caps"
-        failed=1
-    fi
-
-    # Check for new per-package capabilities (a package gained a capability it didn't have before).
-    while IFS=': ' read -r pkg caps; do
-        baseline_pkg_caps=$(grep "^${pkg}:" "$BASELINE" 2>/dev/null | sed 's/^[^:]*: //' || true)
-        if [ -z "$baseline_pkg_caps" ]; then
-            echo "NEW package with capabilities: $pkg: $caps"
-            failed=1
-            continue
-        fi
-        # Check each capability in current for this package
-        for cap in $(echo "$caps" | tr ', ' '\n' | grep -v '^$'); do
-            if ! echo "$baseline_pkg_caps" | grep -q "$cap"; then
-                echo "NEW capability for $pkg: $cap"
-                failed=1
-            fi
-        done
-    done < "$current"
-
-    if [ "$failed" -eq 1 ]; then
-        echo ""
-        echo "FAILED: capabilities have grown."
-        echo "If this is intentional, run '$0 generate' and commit the updated $BASELINE."
-        exit 1
-    fi
-
-    echo "OK: no new capabilities detected."
-}
-
-case "${1:-}" in
-    generate) generate ;;
-    check)    check ;;
-    *)
-        echo "Usage: $0 {generate|check}"
-        exit 1
-        ;;
-esac
@@ -77,9 +77,8 @@ cover() {

    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
+    cat coverage.out.tmp | grep -v testsuite | grep -v tomltestgen | grep -v gotoml-test-decoder > coverage.out
    go tool cover -func=coverage.out
-    echo "Coverage profile for ${branch}: ${dir}/coverage.out" >&2
    popd

    if [ "${branch}" != "HEAD" ]; then
@@ -152,7 +151,7 @@ bench() {
    fi

    export GOMAXPROCS=2
-    go test '-bench=^Benchmark(Un)?[mM]arshal' -count=10 -run=Nothing ./... | tee "${out}"
+    nice -n -19 taskset --cpu-list 0,1 go test '-bench=^Benchmark(Un)?[mM]arshal' -count=5 -run=Nothing ./... | tee "${out}"
    popd

    if [ "${branch}" != "HEAD" ]; then
@@ -161,12 +160,10 @@ bench() {
 }

 fmktemp() {
-    if mktemp --version &> /dev/null; then
-	# GNU
-        mktemp --suffix=-$1
+    if mktemp --version|grep GNU >/dev/null; then
+        mktemp --suffix=-$1;
    else
-	# BSD
-	mktemp -t $1
+        mktemp -t $1;
    fi
 }

@@ -186,14 +183,12 @@ with open(sys.argv[1]) as f:
            lines.append(line.split(','))

 results = []
-for line in reversed(lines[2:]):
-    if len(line) < 8 or line[0] == "":
-        continue
+for line in reversed(lines[1:]):
    v2 = float(line[1])
    results.append([
        line[0].replace("-32", ""),
        "%.1fx" % (float(line[3])/v2),  # v1
-        "%.1fx" % (float(line[7])/v2),  # bs
+        "%.1fx" % (float(line[5])/v2),  # bs
    ])
 # move geomean to the end
 results.append(results[0])
@@ -264,10 +259,10 @@ benchmark() {

        if [ "$1" = "-html" ]; then
            tmpcsv=`fmktemp csv`
-            benchstat -format csv go-toml-v2.txt go-toml-v1.txt bs-toml.txt > $tmpcsv
+            benchstat -csv -geomean 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
+            benchstat -geomean 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
@@ -1,4 +1,3 @@
-// Package gotoml-test-decoder is a minimal decoder program used to compare this library with other TOML implementations.
 package main

 import (
@@ -1,31 +0,0 @@
-// 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)
-}
@@ -1,25 +1,24 @@
 // Package jsontoml is a program that converts JSON to TOML.
 //
-// # Usage
+// Usage
 //
 // Reading from stdin:
 //
-//	cat file.json | jsontoml > file.toml
+//   cat file.json | jsontoml > file.toml
 //
 // Reading from a file:
 //
-//	jsontoml file.json > file.toml
+//   jsontoml file.json > file.toml
 //
-// # Installation
+// Installation
 //
 // Using Go:
 //
-//	go install github.com/pelletier/go-toml/v2/cmd/jsontoml@latest
+//   go install github.com/pelletier/go-toml/v2/cmd/jsontoml@latest
 package main

 import (
 	"encoding/json"
-	"flag"
 	"io"

 	"github.com/pelletier/go-toml/v2"
@@ -34,11 +33,7 @@ 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,
@@ -50,17 +45,11 @@ 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
 	}

+	e := toml.NewEncoder(w)
 	return e.Encode(v)
 }
@@ -5,16 +5,16 @@ import (
 	"strings"
 	"testing"

-	"github.com/pelletier/go-toml/v2/internal/assert"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )

 func TestConvert(t *testing.T) {
 	examples := []struct {
-		name          string
-		input         string
-		expected      string
-		errors        bool
-		useJSONNumber bool
+		name     string
+		input    string
+		expected string
+		errors   bool
 	}{
 		{
 			name: "valid json",
@@ -26,19 +26,7 @@ func TestConvert(t *testing.T) {
 }`,
 			expected: `[mytoml]
 a = 42.0
-`,
-		},
-		{
-			name:          "use json number",
-			useJSONNumber: true,
-			input: `
-{
-  "mytoml": {
-    "a": 42
-  }
-}`,
-			expected: `[mytoml]
-a = 42
+
 `,
 		},
 		{
@@ -50,10 +38,9 @@ a = 42

 	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)
+			require.Error(t, err)
 		} else {
 			assert.NoError(t, err)
 			assert.Equal(t, e.expected, b.String())
@@ -1,20 +1,20 @@
 // Package tomljson is a program that converts TOML to JSON.
 //
-// # Usage
+// Usage
 //
 // Reading from stdin:
 //
-//	cat file.toml | tomljson > file.json
+//   cat file.toml | tomljson > file.json
 //
 // Reading from a file:
 //
-//	tomljson file.toml > file.json
+//   tomljson file.toml > file.json
 //
-// # Installation
+// Installation
 //
 // Using Go:
 //
-//	go install github.com/pelletier/go-toml/v2/cmd/tomljson@latest
+//   go install github.com/pelletier/go-toml/v2/cmd/tomljson@latest
 package main

 import (
@@ -2,12 +2,13 @@ package main

 import (
 	"bytes"
-	"errors"
+	"fmt"
 	"io"
 	"strings"
 	"testing"

-	"github.com/pelletier/go-toml/v2/internal/assert"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )

 func TestConvert(t *testing.T) {
@@ -45,7 +46,7 @@ a = 42`),
 		b := new(bytes.Buffer)
 		err := convert(e.input, b)
 		if e.errors {
-			assert.Error(t, err)
+			require.Error(t, err)
 		} else {
 			assert.NoError(t, err)
 			assert.Equal(t, e.expected, b.String())
@@ -56,5 +57,5 @@ a = 42`),
 type badReader struct{}

 func (r *badReader) Read([]byte) (int, error) {
-	return 0, errors.New("reader failed on purpose")
+	return 0, fmt.Errorf("reader failed on purpose")
 }
@@ -1,20 +1,20 @@
 // Package tomll is a linter program for TOML.
 //
-// # Usage
+// Usage
 //
 // Reading from stdin, writing to stdout:
 //
-//	cat file.toml | tomll
+//   cat file.toml | tomll
 //
 // Reading and updating a list of files in place:
 //
-//	tomll a.toml b.toml c.toml
+//   tomll a.toml b.toml c.toml
 //
-// # Installation
+// Installation
 //
 // Using Go:
 //
-//	go install github.com/pelletier/go-toml/v2/cmd/tomll@latest
+//   go install github.com/pelletier/go-toml/v2/cmd/tomll@latest
 package main

 import (
@@ -5,7 +5,8 @@ import (
 	"strings"
 	"testing"

-	"github.com/pelletier/go-toml/v2/internal/assert"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )

 func TestConvert(t *testing.T) {
@@ -22,6 +23,7 @@ mytoml.a = 42.0
 `,
 			expected: `[mytoml]
 a = 42.0
+
 `,
 		},
 		{
@@ -35,7 +37,7 @@ a = 42.0
 		b := new(bytes.Buffer)
 		err := convert(strings.NewReader(e.input), b)
 		if e.errors {
-			assert.Error(t, err)
+			require.Error(t, err)
 		} else {
 			assert.NoError(t, err)
 			assert.Equal(t, e.expected, b.String())
@@ -3,22 +3,25 @@
 //
 // Within the go-toml package, run `go generate`.  Otherwise, use:
 //
-//	go run github.com/pelletier/go-toml/cmd/tomltestgen -o toml_testgen_test.go
+//     go run github.com/pelletier/go-toml/cmd/tomltestgen -o toml_testgen_test.go
 package main

 import (
+	"archive/zip"
 	"bytes"
 	"flag"
 	"fmt"
 	"go/format"
+	"io"
+	"io/ioutil"
 	"log"
+	"net/http"
 	"os"
-	"path/filepath"
+	"regexp"
 	"strconv"
 	"strings"
 	"text/template"
 	"time"
-	"unicode"
 )

 type invalid struct {
@@ -29,7 +32,7 @@ type invalid struct {
 type valid struct {
 	Name    string
 	Input   string
-	JSONRef string
+	JsonRef string
 }

 type testsCollection struct {
@@ -40,11 +43,12 @@ type testsCollection struct {
 	Count     int
 }

-const srcTemplate = "// Code generated by tomltestgen for toml-test ref {{.Ref}} on {{.Timestamp}}. DO NOT EDIT.\n" +
+const srcTemplate = "// Generated by tomltestgen for toml-test ref {{.Ref}} on {{.Timestamp}}\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" +
@@ -55,31 +59,65 @@ const srcTemplate = "// Code generated by tomltestgen for toml-test ref {{.Ref}}
 	"{{range .Valid}}\n" +
 	"func TestTOMLTest_Valid_{{.Name}}(t *testing.T) {\n" +
 	"   input := {{.Input|gostr}}\n" +
-	"   jsonRef := {{.JSONRef|gostr}}\n" +
+	"   jsonRef := {{.JsonRef|gostr}}\n" +
 	"   testgenValid(t, input, jsonRef)\n" +
 	"}\n" +
 	"{{end}}\n"

+func downloadTmpFile(url string) string {
+	log.Println("starting to download file from", url)
+	resp, err := http.Get(url)
+	if err != nil {
+		panic(err)
+	}
+	defer resp.Body.Close()
+
+	tmpfile, err := ioutil.TempFile("", "toml-test-*.zip")
+	if err != nil {
+		panic(err)
+	}
+	defer tmpfile.Close()
+
+	copiedLen, err := io.Copy(tmpfile, resp.Body)
+	if err != nil {
+		panic(err)
+	}
+	if resp.ContentLength > 0 && copiedLen != resp.ContentLength {
+		panic(fmt.Errorf("copied %d bytes, request body had %d", copiedLen, resp.ContentLength))
+	}
+	return tmpfile.Name()
+}
+
 func kebabToCamel(kebab string) string {
-	var buf strings.Builder
+	camel := ""
 	nextUpper := true
 	for _, c := range kebab {
 		if nextUpper {
-			buf.WriteRune(unicode.ToUpper(c))
+			camel += strings.ToUpper(string(c))
 			nextUpper = false
+		} else if c == '-' {
+			nextUpper = true
+		} else if c == '/' {
+			nextUpper = true
+			camel += "_"
 		} else {
-			switch c {
-			case '-':
-				nextUpper = true
-			case '/':
-				nextUpper = true
-				buf.WriteByte('_')
-			default:
-				buf.WriteRune(c)
-			}
+			camel += string(c)
 		}
 	}
-	return buf.String()
+	return camel
+}
+
+func readFileFromZip(f *zip.File) string {
+	reader, err := f.Open()
+	if err != nil {
+		panic(err)
+	}
+	defer reader.Close()
+	bytes, err := ioutil.ReadAll(reader)
+	if err != nil {
+		panic(err)
+	}
+	return string(bytes)
 }

 func templateGoStr(input string) string {
@@ -100,59 +138,61 @@ func main() {
 	flag.Usage = usage
 	flag.Parse()

+	url := "https://codeload.github.com/BurntSushi/toml-test/zip/" + *ref
+	resultFile := downloadTmpFile(url)
+	defer os.Remove(resultFile)
+	log.Println("file written to", resultFile)
+
+	zipReader, err := zip.OpenReader(resultFile)
+	if err != nil {
+		panic(err)
+	}
+	defer zipReader.Close()
+
 	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, ".", "_")
+	zipFilesMap := map[string]*zip.File{}

-		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++
+	for _, f := range zipReader.File {
+		zipFilesMap[f.Name] = f
 	}

-	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, ".", "_")
+	testFileRegexp := regexp.MustCompile(`([^/]+/tests/(valid|invalid)/(.+))\.(toml)`)
+	for _, f := range zipReader.File {
+		groups := testFileRegexp.FindStringSubmatch(f.Name)
+		if len(groups) > 0 {
+			name := kebabToCamel(groups[3])
+			testType := groups[2]

-		log.Printf("> [%s] %s\n", "valid", name)
+			log.Printf("> [%s] %s\n", testType, name)

-		tomlContent, err := os.ReadFile(f) // #nosec G304
-		if err != nil {
-			fmt.Printf("failed reading test file: %s\n", err)
-			os.Exit(1)
+			tomlContent := readFileFromZip(f)
+
+			switch testType {
+			case "invalid":
+				collection.Invalid = append(collection.Invalid, invalid{
+					Name:  name,
+					Input: tomlContent,
+				})
+				collection.Count++
+			case "valid":
+				baseFilePath := groups[1]
+				jsonFilePath := baseFilePath + ".json"
+				jsonContent := readFileFromZip(zipFilesMap[jsonFilePath])
+
+				collection.Valid = append(collection.Valid, valid{
+					Name:    name,
+					Input:   tomlContent,
+					JsonRef: jsonContent,
+				})
+				collection.Count++
+			default:
+				panic(fmt.Sprintf("unknown test type: %s", testType))
+			}
 		}
-
-		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)
@@ -162,7 +202,7 @@ func main() {
 	}
 	t := template.Must(template.New("src").Funcs(funcMap).Parse(srcTemplate))
 	buf := new(bytes.Buffer)
-	err := t.Execute(buf, collection)
+	err = t.Execute(buf, collection)
 	if err != nil {
 		panic(err)
 	}
@@ -176,7 +216,7 @@ func main() {
 		return
 	}

-	err = os.WriteFile(*out, outputBytes, 0o600)
+	err = os.WriteFile(*out, outputBytes, 0644)
 	if err != nil {
 		panic(err)
 	}
@@ -5,8 +5,6 @@ import (
 	"math"
 	"strconv"
 	"time"
-
-	"github.com/pelletier/go-toml/v2/unstable"
 )

 func parseInteger(b []byte) (int64, error) {
@@ -34,7 +32,7 @@ func parseLocalDate(b []byte) (LocalDate, error) {
 	var date LocalDate

 	if len(b) != 10 || b[4] != '-' || b[7] != '-' {
-		return date, unstable.NewParserError(b, "dates are expected to have the format YYYY-MM-DD")
+		return date, newDecodeError(b, "dates are expected to have the format YYYY-MM-DD")
 	}

 	var err error
@@ -55,7 +53,7 @@ func parseLocalDate(b []byte) (LocalDate, error) {
 	}

 	if !isValidDate(date.Year, date.Month, date.Day) {
-		return LocalDate{}, unstable.NewParserError(b, "impossible date")
+		return LocalDate{}, newDecodeError(b, "impossible date")
 	}

 	return date, nil
@@ -66,7 +64,7 @@ func parseDecimalDigits(b []byte) (int, error) {

 	for i, c := range b {
 		if c < '0' || c > '9' {
-			return 0, unstable.NewParserError(b[i:i+1], "expected digit (0-9)")
+			return 0, newDecodeError(b[i:i+1], "expected digit (0-9)")
 		}
 		v *= 10
 		v += int(c - '0')
@@ -99,7 +97,7 @@ func parseDateTime(b []byte) (time.Time, error) {
 	} else {
 		const dateTimeByteLen = 6
 		if len(b) != dateTimeByteLen {
-			return time.Time{}, unstable.NewParserError(b, "invalid date-time timezone")
+			return time.Time{}, newDecodeError(b, "invalid date-time timezone")
 		}
 		var direction int
 		switch b[0] {
@@ -108,11 +106,11 @@ func parseDateTime(b []byte) (time.Time, error) {
 		case '+':
 			direction = +1
 		default:
-			return time.Time{}, unstable.NewParserError(b[:1], "invalid timezone offset character")
+			return time.Time{}, newDecodeError(b[:1], "invalid timezone offset character")
 		}

 		if b[3] != ':' {
-			return time.Time{}, unstable.NewParserError(b[3:4], "expected a : separator")
+			return time.Time{}, newDecodeError(b[3:4], "expected a : separator")
 		}

 		hours, err := parseDecimalDigits(b[1:3])
@@ -120,7 +118,7 @@ func parseDateTime(b []byte) (time.Time, error) {
 			return time.Time{}, err
 		}
 		if hours > 23 {
-			return time.Time{}, unstable.NewParserError(b[:1], "invalid timezone offset hours")
+			return time.Time{}, newDecodeError(b[:1], "invalid timezone offset hours")
 		}

 		minutes, err := parseDecimalDigits(b[4:6])
@@ -128,7 +126,7 @@ func parseDateTime(b []byte) (time.Time, error) {
 			return time.Time{}, err
 		}
 		if minutes > 59 {
-			return time.Time{}, unstable.NewParserError(b[:1], "invalid timezone offset minutes")
+			return time.Time{}, newDecodeError(b[:1], "invalid timezone offset minutes")
 		}

 		seconds := direction * (hours*3600 + minutes*60)
@@ -141,7 +139,7 @@ func parseDateTime(b []byte) (time.Time, error) {
 	}

 	if len(b) > 0 {
-		return time.Time{}, unstable.NewParserError(b, "extra bytes at the end of the timezone")
+		return time.Time{}, newDecodeError(b, "extra bytes at the end of the timezone")
 	}

 	t := time.Date(
@@ -162,7 +160,7 @@ func parseLocalDateTime(b []byte) (LocalDateTime, []byte, error) {

 	const localDateTimeByteMinLen = 11
 	if len(b) < localDateTimeByteMinLen {
-		return dt, nil, unstable.NewParserError(b, "local datetimes are expected to have the format YYYY-MM-DDTHH:MM:SS[.NNNNNNNNN]")
+		return dt, nil, newDecodeError(b, "local datetimes are expected to have the format YYYY-MM-DDTHH:MM:SS[.NNNNNNNNN]")
 	}

 	date, err := parseLocalDate(b[:10])
@@ -173,7 +171,7 @@ func parseLocalDateTime(b []byte) (LocalDateTime, []byte, error) {

 	sep := b[10]
 	if sep != 'T' && sep != ' ' && sep != 't' {
-		return dt, nil, unstable.NewParserError(b[10:11], "datetime separator is expected to be T or a space")
+		return dt, nil, newDecodeError(b[10:11], "datetime separator is expected to be T or a space")
 	}

 	t, rest, err := parseLocalTime(b[11:])
@@ -197,7 +195,7 @@ func parseLocalTime(b []byte) (LocalTime, []byte, error) {
 	// check if b matches to have expected format HH:MM:SS[.NNNNNN]
 	const localTimeByteLen = 8
 	if len(b) < localTimeByteLen {
-		return t, nil, unstable.NewParserError(b, "times are expected to have the format HH:MM:SS[.NNNNNN]")
+		return t, nil, newDecodeError(b, "times are expected to have the format HH:MM:SS[.NNNNNN]")
 	}

 	var err error
@@ -208,10 +206,10 @@ func parseLocalTime(b []byte) (LocalTime, []byte, error) {
 	}

 	if t.Hour > 23 {
-		return t, nil, unstable.NewParserError(b[0:2], "hour cannot be greater 23")
+		return t, nil, newDecodeError(b[0:2], "hour cannot be greater 23")
 	}
 	if b[2] != ':' {
-		return t, nil, unstable.NewParserError(b[2:3], "expecting colon between hours and minutes")
+		return t, nil, newDecodeError(b[2:3], "expecting colon between hours and minutes")
 	}

 	t.Minute, err = parseDecimalDigits(b[3:5])
@@ -219,10 +217,10 @@ func parseLocalTime(b []byte) (LocalTime, []byte, error) {
 		return t, nil, err
 	}
 	if t.Minute > 59 {
-		return t, nil, unstable.NewParserError(b[3:5], "minutes cannot be greater 59")
+		return t, nil, newDecodeError(b[3:5], "minutes cannot be greater 59")
 	}
 	if b[5] != ':' {
-		return t, nil, unstable.NewParserError(b[5:6], "expecting colon between minutes and seconds")
+		return t, nil, newDecodeError(b[5:6], "expecting colon between minutes and seconds")
 	}

 	t.Second, err = parseDecimalDigits(b[6:8])
@@ -230,8 +228,8 @@ func parseLocalTime(b []byte) (LocalTime, []byte, error) {
 		return t, nil, err
 	}

-	if t.Second > 59 {
-		return t, nil, unstable.NewParserError(b[6:8], "seconds cannot be greater than 59")
+	if t.Second > 60 {
+		return t, nil, newDecodeError(b[6:8], "seconds cannot be greater 60")
 	}

 	b = b[8:]
@@ -244,7 +242,7 @@ func parseLocalTime(b []byte) (LocalTime, []byte, error) {
 		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")
+					return t, nil, newDecodeError(b[0:1], "need at least one digit after fraction point")
 				}
 				break
 			}
@@ -268,7 +266,7 @@ func parseLocalTime(b []byte) (LocalTime, []byte, error) {
 		}

 		if precision == 0 {
-			return t, nil, unstable.NewParserError(b[:1], "nanoseconds need at least one digit")
+			return t, nil, newDecodeError(b[:1], "nanoseconds need at least one digit")
 		}

 		t.Nanosecond = frac * nspow[precision]
@@ -279,6 +277,7 @@ func parseLocalTime(b []byte) (LocalTime, []byte, error) {
 	return t, b, nil
 }

+//nolint:cyclop
 func parseFloat(b []byte) (float64, error) {
 	if len(b) == 4 && (b[0] == '+' || b[0] == '-') && b[1] == 'n' && b[2] == 'a' && b[3] == 'n' {
 		return math.NaN(), nil
@@ -290,24 +289,24 @@ func parseFloat(b []byte) (float64, error) {
 	}

 	if cleaned[0] == '.' {
-		return 0, unstable.NewParserError(b, "float cannot start with a dot")
+		return 0, newDecodeError(b, "float cannot start with a dot")
 	}

 	if cleaned[len(cleaned)-1] == '.' {
-		return 0, unstable.NewParserError(b, "float cannot end with a dot")
+		return 0, newDecodeError(b, "float cannot end with a dot")
 	}

 	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")
+				return 0, newDecodeError(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")
+				return 0, newDecodeError(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")
+				return 0, newDecodeError(b[i:i+2], "float decimal point must be followed by a digit")
 			}
 			dotAlreadySeen = true
 		}
@@ -317,13 +316,13 @@ func parseFloat(b []byte) (float64, error) {
 	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")
+	if cleaned[start] == '0' && isDigit(cleaned[start+1]) {
+		return 0, newDecodeError(b, "float integer part cannot have leading zeroes")
 	}

 	f, err := strconv.ParseFloat(string(cleaned), 64)
 	if err != nil {
-		return 0, unstable.NewParserError(b, "unable to parse float: %w", err)
+		return 0, newDecodeError(b, "unable to parse float: %w", err)
 	}

 	return f, nil
@@ -337,7 +336,7 @@ func parseIntHex(b []byte) (int64, error) {

 	i, err := strconv.ParseInt(string(cleaned), 16, 64)
 	if err != nil {
-		return 0, unstable.NewParserError(b, "couldn't parse hexadecimal number: %w", err)
+		return 0, newDecodeError(b, "couldn't parse hexadecimal number: %w", err)
 	}

 	return i, nil
@@ -351,7 +350,7 @@ func parseIntOct(b []byte) (int64, error) {

 	i, err := strconv.ParseInt(string(cleaned), 8, 64)
 	if err != nil {
-		return 0, unstable.NewParserError(b, "couldn't parse octal number: %w", err)
+		return 0, newDecodeError(b, "couldn't parse octal number: %w", err)
 	}

 	return i, nil
@@ -365,7 +364,7 @@ func parseIntBin(b []byte) (int64, error) {

 	i, err := strconv.ParseInt(string(cleaned), 2, 64)
 	if err != nil {
-		return 0, unstable.NewParserError(b, "couldn't parse binary number: %w", err)
+		return 0, newDecodeError(b, "couldn't parse binary number: %w", err)
 	}

 	return i, nil
@@ -388,12 +387,12 @@ func parseIntDec(b []byte) (int64, error) {
 	}

 	if len(cleaned) > startIdx+1 && cleaned[startIdx] == '0' {
-		return 0, unstable.NewParserError(b, "leading zero not allowed on decimal number")
+		return 0, newDecodeError(b, "leading zero not allowed on decimal number")
 	}

 	i, err := strconv.ParseInt(string(cleaned), 10, 64)
 	if err != nil {
-		return 0, unstable.NewParserError(b, "couldn't parse decimal number: %w", err)
+		return 0, newDecodeError(b, "couldn't parse decimal number: %w", err)
 	}

 	return i, nil
@@ -410,11 +409,11 @@ func checkAndRemoveUnderscoresIntegers(b []byte) ([]byte, error) {
 	}

 	if b[start] == '_' {
-		return nil, unstable.NewParserError(b[start:start+1], "number cannot start with underscore")
+		return nil, newDecodeError(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")
+		return nil, newDecodeError(b[len(b)-1:], "number cannot end with underscore")
 	}

 	// fast path
@@ -436,7 +435,7 @@ func checkAndRemoveUnderscoresIntegers(b []byte) ([]byte, error) {
 		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")
+				return nil, newDecodeError(b[i-1:i+1], "number must have at least one digit between underscores")
 			}
 			before = false
 		} else {
@@ -450,11 +449,11 @@ func checkAndRemoveUnderscoresIntegers(b []byte) ([]byte, error) {

 func checkAndRemoveUnderscoresFloats(b []byte) ([]byte, error) {
 	if b[0] == '_' {
-		return nil, unstable.NewParserError(b[0:1], "number cannot start with underscore")
+		return nil, newDecodeError(b[0:1], "number cannot start with underscore")
 	}

 	if b[len(b)-1] == '_' {
-		return nil, unstable.NewParserError(b[len(b)-1:], "number cannot end with underscore")
+		return nil, newDecodeError(b[len(b)-1:], "number cannot end with underscore")
 	}

 	// fast path
@@ -477,10 +476,10 @@ func checkAndRemoveUnderscoresFloats(b []byte) ([]byte, error) {
 		switch c {
 		case '_':
 			if !before {
-				return nil, unstable.NewParserError(b[i-1:i+1], "number must have at least one digit between underscores")
+				return nil, newDecodeError(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")
+				return nil, newDecodeError(b[i+1:i+2], "cannot have underscore before exponent")
 			}
 			before = false
 		case '+', '-':
@@ -489,15 +488,15 @@ func checkAndRemoveUnderscoresFloats(b []byte) ([]byte, error) {
 			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")
+				return nil, newDecodeError(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")
+				return nil, newDecodeError(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")
+				return nil, newDecodeError(b[i-1:i], "cannot have underscore before decimal point")
 			}
 			cleaned = append(cleaned, c)
 		default:
@@ -543,7 +542,3 @@ func daysIn(m int, year int) int {
 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'
-}
@@ -2,11 +2,10 @@ package toml

 import (
 	"fmt"
-	"reflect"
 	"strconv"
 	"strings"

-	"github.com/pelletier/go-toml/v2/unstable"
+	"github.com/pelletier/go-toml/v2/internal/danger"
 )

 // DecodeError represents an error encountered during the parsing or decoding
@@ -54,19 +53,26 @@ func (s *StrictMissingError) String() string {
 	return buf.String()
 }

-// Unwrap returns wrapped decode errors
-//
-// Implements errors.Join() interface.
-func (s *StrictMissingError) Unwrap() []error {
-	errs := make([]error, len(s.Errors))
-	for i := range s.Errors {
-		errs[i] = &s.Errors[i]
-	}
-	return errs
+type Key []string
+
+// internal version of DecodeError that is used as the base to create a
+// DecodeError with full context.
+type decodeError struct {
+	highlight []byte
+	message   string
+	key       Key // optional
 }

-// Key represents a TOML key as a sequence of key parts.
-type Key []string
+func (de *decodeError) Error() string {
+	return de.message
+}
+
+func newDecodeError(highlight []byte, format string, args ...interface{}) error {
+	return &decodeError{
+		highlight: highlight,
+		message:   fmt.Errorf(format, args...).Error(),
+	}
+}

 // Error returns the error message contained in the DecodeError.
 func (e *DecodeError) Error() string {
@@ -90,21 +96,20 @@ func (e *DecodeError) Key() Key {
 	return e.key
 }

-// wrapDecodeError creates a DecodeError referencing a highlighted
+// decodeErrorFromHighlight 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 *unstable.ParserError) *DecodeError {
-	offset := subsliceOffset(document, de.Highlight)
+func wrapDecodeError(document []byte, de *decodeError) *DecodeError {
+	offset := danger.SubsliceOffset(document, de.highlight)

 	errMessage := de.Error()
 	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

@@ -134,7 +139,7 @@ func wrapDecodeError(document []byte, de *unstable.ParserError) *DecodeError {
 		buf.Write(before[0])
 	}

-	buf.Write(de.Highlight)
+	buf.Write(de.highlight)

 	if len(after) > 0 {
 		buf.Write(after[0])
@@ -152,7 +157,7 @@ func wrapDecodeError(document []byte, de *unstable.ParserError) *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(" ")
@@ -177,7 +182,7 @@ func wrapDecodeError(document []byte, de *unstable.ParserError) *DecodeError {
 		message: errMessage,
 		line:    errLine,
 		column:  errColumn,
-		key:     de.Key,
+		key:     de.key,
 		human:   buf.String(),
 	}
 }
@@ -260,24 +265,5 @@ func positionAtEnd(b []byte) (row int, column int) {
 		}
 	}

-	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
+	return
 }
@@ -7,12 +7,12 @@ import (
 	"strings"
 	"testing"

-	"github.com/pelletier/go-toml/v2/internal/assert"
-	"github.com/pelletier/go-toml/v2/unstable"
+	"github.com/stretchr/testify/assert"
 )

 //nolint:funlen
 func TestDecodeError(t *testing.T) {
+
 	examples := []struct {
 		desc     string
 		doc      [3]string
@@ -160,18 +160,19 @@ line 5`,
 	for _, e := range examples {
 		e := e
 		t.Run(e.desc, func(t *testing.T) {
+
 			b := bytes.Buffer{}
-			b.WriteString(e.doc[0])
+			b.Write([]byte(e.doc[0]))
 			start := b.Len()
-			b.WriteString(e.doc[1])
+			b.Write([]byte(e.doc[1]))
 			end := b.Len()
-			b.WriteString(e.doc[2])
+			b.Write([]byte(e.doc[2]))
 			doc := b.Bytes()
 			hl := doc[start:end]

-			err := wrapDecodeError(doc, &unstable.ParserError{
-				Highlight: hl,
-				Message:   e.msg,
+			err := wrapDecodeError(doc, &decodeError{
+				highlight: hl,
+				message:   e.msg,
 			})

 			var derr *DecodeError
@@ -187,6 +188,7 @@ line 5`,
 }

 func TestDecodeError_Accessors(t *testing.T) {
+
 	e := DecodeError{
 		message: "foo",
 		line:    1,
@@ -202,105 +204,6 @@ func TestDecodeError_Accessors(t *testing.T) {
 	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,
-		},
-		{
-			name:        "missing equals on last line without trailing newline",
-			doc:         "a = 1\nb = 2\nc",
-			expectedRow: 3,
-			minCol:      1,
-		},
-	}
-
-	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`

@@ -1,37 +0,0 @@
-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}
-}
@@ -4,28 +4,21 @@ import (
 	"testing"

 	"github.com/pelletier/go-toml/v2"
-	"github.com/pelletier/go-toml/v2/internal/assert"
+	"github.com/stretchr/testify/require"
 )

-func TestFastSimpleInt(t *testing.T) {
+func TestFastSimple(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)
+	require.NoError(t, err)
+	require.Equal(t, map[string]int64{"a": 42}, 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)
+	require.NoError(t, err)
+	require.Equal(t, map[string]string{"a": "hello"}, m)
 }

 func TestFastSimpleInterface(t *testing.T) {
@@ -33,8 +26,8 @@ func TestFastSimpleInterface(t *testing.T) {
 	err := toml.Unmarshal([]byte(`
 	a = "hello"
 	b = 42`), &m)
-	assert.NoError(t, err)
-	assert.Equal(t, map[string]interface{}{
+	require.NoError(t, err)
+	require.Equal(t, map[string]interface{}{
 		"a": "hello",
 		"b": int64(42),
 	}, m)
@@ -46,8 +39,8 @@ func TestFastMultipartKeyInterface(t *testing.T) {
 	a.interim = "test"
 	a.b.c = "hello"
 	b = 42`), &m)
-	assert.NoError(t, err)
-	assert.Equal(t, map[string]interface{}{
+	require.NoError(t, err)
+	require.Equal(t, map[string]interface{}{
 		"a": map[string]interface{}{
 			"interim": "test",
 			"b": map[string]interface{}{
@@ -66,8 +59,8 @@ func TestFastExistingMap(t *testing.T) {
 	ints.one = 1
 	ints.two = 2
 	strings.yo = "hello"`), &m)
-	assert.NoError(t, err)
-	assert.Equal(t, map[string]interface{}{
+	require.NoError(t, err)
+	require.Equal(t, map[string]interface{}{
 		"ints": map[string]interface{}{
 			"one": int64(1),
 			"two": int64(2),
@@ -90,9 +83,9 @@ func TestFastArrayTable(t *testing.T) {
 	m := map[string]interface{}{}

 	err := toml.Unmarshal(b, &m)
-	assert.NoError(t, err)
+	require.NoError(t, err)

-	assert.Equal(t, map[string]interface{}{
+	require.Equal(t, map[string]interface{}{
 		"root": map[string]interface{}{
 			"nested": []interface{}{
 				map[string]interface{}{
@@ -1,18 +1,21 @@
+//go:build go1.18
+// +build go1.18
+
 package toml_test

 import (
-	"os"
+	"io/ioutil"
 	"strings"
 	"testing"

 	"github.com/pelletier/go-toml/v2"
-	"github.com/pelletier/go-toml/v2/internal/assert"
+	"github.com/stretchr/testify/require"
 )

 func FuzzUnmarshal(f *testing.F) {
-	file, err := os.ReadFile("benchmark/benchmark.toml")
+	file, err := ioutil.ReadFile("benchmark/benchmark.toml")
 	if err != nil {
-		f.Error(err)
+		panic(err)
 	}
 	f.Add(file)

@@ -48,6 +51,6 @@ func FuzzUnmarshal(f *testing.F) {
 		if err != nil {
 			t.Fatalf("failed round trip: %s", err)
 		}
-		assert.Equal(t, v, v2)
+		require.Equal(t, v, v2)
 	})
 }
@@ -1,3 +1,5 @@
 module github.com/pelletier/go-toml/v2

-go 1.21.0
+go 1.16
+
+require github.com/stretchr/testify v1.7.1
@@ -0,0 +1,11 @@
+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.1 h1:5TQK59W5E3v0r2duFAb7P95B6hEeOyEnHRa8MjYSMTY=
+github.com/stretchr/testify v1.7.1/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=
@@ -1,141 +0,0 @@
-// 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)
-}
@@ -1,217 +0,0 @@
-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)
-		}
-	})
-}
@@ -0,0 +1,144 @@
+package ast
+
+import (
+	"fmt"
+	"unsafe"
+
+	"github.com/pelletier/go-toml/v2/internal/danger"
+)
+
+// 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()
+}
+
+// IsLast returns true if the current node of the iterator is the last
+// one.  Subsequent call to Next() will return false.
+func (c *Iterator) IsLast() bool {
+	return c.node.next == 0
+}
+
+// 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 Reference) *Node {
+	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).
+type Node struct {
+	Kind Kind
+	Raw  Range  // Raw bytes from the input.
+	Data []byte // Node value (either allocated or referencing the input).
+
+	// References to other nodes, as offsets in the backing array
+	// from this node. References can go backward, so those can be
+	// negative.
+	next  int // 0 if last element
+	child int // 0 if no child
+}
+
+type Range struct {
+	Offset uint32
+	Length uint32
+}
+
+// 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 nil
+	}
+	ptr := unsafe.Pointer(n)
+	size := unsafe.Sizeof(Node{})
+	return (*Node)(danger.Stride(ptr, size, 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 nil
+	}
+	ptr := unsafe.Pointer(n)
+	size := unsafe.Sizeof(Node{})
+	return (*Node)(danger.Stride(ptr, size, n.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 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 {
+	return n.Child()
+}
+
+// Children returns an iterator over a node's children.
+func (n *Node) Children() Iterator {
+	return Iterator{node: n.Child()}
+}
@@ -0,0 +1,51 @@
+package ast
+
+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) Tree() *Root {
+	return &b.tree
+}
+
+func (b *Builder) NodeAt(ref Reference) *Node {
+	return b.tree.at(ref)
+}
+
+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)
+	b.tree.nodes = append(b.tree.nodes, n)
+	return Reference(b.lastIdx)
+}
+
+func (b *Builder) PushAndChain(n Node) Reference {
+	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
+	}
+	b.lastIdx = newIdx
+	return Reference(b.lastIdx)
+}
+
+func (b *Builder) AttachChild(parent Reference, child Reference) {
+	b.tree.nodes[parent].child = int(child) - int(parent)
+}
+
+func (b *Builder) Chain(from Reference, to Reference) {
+	b.tree.nodes[from].next = int(to) - int(from)
+}
@@ -1,49 +1,35 @@
-package unstable
+package ast

 import "fmt"

-// Kind represents the type of TOML structure contained in a given Node.
 type Kind int

 const (
-	// Invalid represents an invalid meta node.
+	// meta
 	Invalid Kind = iota
-	// Comment represents a comment meta node.
 	Comment
-	// Key represents a key meta node.
 	Key

-	// Table represents a top-level table.
+	// top level structures
 	Table
-	// ArrayTable represents a top-level array table.
 	ArrayTable
-	// KeyValue represents a top-level key value.
 	KeyValue

-	// Array represents an array container value.
+	// containers values
 	Array
-	// InlineTable represents an inline table container value.
 	InlineTable

-	// String represents a string value.
+	// values
 	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:
@@ -1,42 +0,0 @@
-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]
-}
@@ -1,4 +1,3 @@
-// Package cli provides common functions for command-line programs.
 package cli

 import (
@@ -7,6 +6,7 @@ import (
 	"flag"
 	"fmt"
 	"io"
+	"io/ioutil"
 	"os"

 	"github.com/pelletier/go-toml/v2"
@@ -18,26 +18,27 @@ 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.
+	// perform convertion in place on each provided file.
 	Inplace bool
 }

 func (p *Program) Execute() {
-	flag.Usage = func() { fmt.Fprint(os.Stderr, p.Usage) }
+	flag.Usage = func() { fmt.Fprintf(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 {
+func (p *Program) main(files []string, input io.Reader, output, error 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())
+			fmt.Fprintln(error, derr.String())
 			row, col := derr.Position()
-			_, _ = fmt.Fprintln(stderr, "error occurred at row", row, "column", col)
+			fmt.Fprintln(error, "error occurred at row", row, "column", col)
 		} else {
-			_, _ = fmt.Fprintln(stderr, err.Error())
+			fmt.Fprintln(error, err.Error())
 		}

 		return -1
@@ -54,7 +55,7 @@ func (p *Program) run(files []string, input io.Reader, output io.Writer) error {
 		if err != nil {
 			return err
 		}
-		defer func() { _ = f.Close() }()
+		defer f.Close()
 		input = f
 	}
 	return p.Fn(input, output)
@@ -71,7 +72,7 @@ func (p *Program) runAllFilesInPlace(files []string) error {
 }

 func (p *Program) runFileInPlace(path string) error {
-	in, err := os.ReadFile(path) // #nosec G304
+	in, err := ioutil.ReadFile(path)
 	if err != nil {
 		return err
 	}
@@ -83,5 +84,5 @@ func (p *Program) runFileInPlace(path string) error {
 		return err
 	}

-	return os.WriteFile(path, out.Bytes(), 0o600)
+	return ioutil.WriteFile(path, out.Bytes(), 0600)
 }
@@ -2,15 +2,17 @@ package cli

 import (
 	"bytes"
-	"errors"
+	"fmt"
 	"io"
+	"io/ioutil"
 	"os"
 	"path"
 	"strings"
 	"testing"

 	"github.com/pelletier/go-toml/v2"
-	"github.com/pelletier/go-toml/v2/internal/assert"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )

 func processMain(args []string, input io.Reader, stdout, stderr io.Writer, f ConvertFn) int {
@@ -23,13 +25,13 @@ func TestProcessMainStdin(t *testing.T) {
 	stderr := new(bytes.Buffer)
 	input := strings.NewReader("this is the input")

-	exit := processMain([]string{}, input, stdout, stderr, func(io.Reader, io.Writer) error {
+	exit := processMain([]string{}, input, stdout, stderr, func(r io.Reader, w io.Writer) error {
 		return nil
 	})

 	assert.Equal(t, 0, exit)
-	assert.Zero(t, stdout.String())
-	assert.Zero(t, stderr.String())
+	assert.Empty(t, stdout.String())
+	assert.Empty(t, stderr.String())
 }

 func TestProcessMainStdinErr(t *testing.T) {
@@ -37,13 +39,13 @@ func TestProcessMainStdinErr(t *testing.T) {
 	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")
+	exit := processMain([]string{}, input, stdout, stderr, func(r io.Reader, w io.Writer) error {
+		return fmt.Errorf("something bad")
 	})

 	assert.Equal(t, -1, exit)
-	assert.Zero(t, stdout.String())
-	assert.NotZero(t, stderr.String())
+	assert.Empty(t, stdout.String())
+	assert.NotEmpty(t, stderr.String())
 }

 func TestProcessMainStdinDecodeErr(t *testing.T) {
@@ -51,58 +53,60 @@ func TestProcessMainStdinDecodeErr(t *testing.T) {
 	stderr := new(bytes.Buffer)
 	input := strings.NewReader("this is the input")

-	exit := processMain([]string{}, input, stdout, stderr, func(io.Reader, io.Writer) error {
+	exit := processMain([]string{}, input, stdout, stderr, func(r io.Reader, w 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"))
+	assert.Empty(t, stdout.String())
+	assert.Contains(t, 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())
+	tmpfile, err := ioutil.TempFile("", "example")
+	require.NoError(t, err)
+	defer os.Remove(tmpfile.Name())
+	_, err = tmpfile.Write([]byte(`some data`))
+	require.NoError(t, err)

 	stdout := new(bytes.Buffer)
 	stderr := new(bytes.Buffer)

-	exit := processMain([]string{tmpfile.Name()}, nil, stdout, stderr, func(io.Reader, io.Writer) error {
+	exit := processMain([]string{tmpfile.Name()}, nil, stdout, stderr, func(r io.Reader, w io.Writer) error {
 		return nil
 	})

 	assert.Equal(t, 0, exit)
-	assert.Zero(t, stdout.String())
-	assert.Zero(t, stderr.String())
+	assert.Empty(t, stdout.String())
+	assert.Empty(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 {
+	exit := processMain([]string{"/lets/hope/this/does/not/exist"}, nil, stdout, stderr, func(r io.Reader, w io.Writer) error {
 		return nil
 	})

 	assert.Equal(t, -1, exit)
-	assert.Zero(t, stdout.String())
-	assert.NotZero(t, stderr.String())
+	assert.Empty(t, stdout.String())
+	assert.NotEmpty(t, stderr.String())
 }

 func TestProcessMainFilesInPlace(t *testing.T) {
-	dir := t.TempDir()
+	dir, err := ioutil.TempDir("", "")
+	require.NoError(t, err)
+	defer os.RemoveAll(dir)

 	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)
+	err = ioutil.WriteFile(path1, []byte("content 1"), 0600)
+	require.NoError(t, err)
+	err = ioutil.WriteFile(path2, []byte("content 2"), 0600)
+	require.NoError(t, err)

 	p := Program{
 		Fn:      dummyFileFn,
@@ -111,15 +115,15 @@ func TestProcessMainFilesInPlace(t *testing.T) {

 	exit := p.main([]string{path1, path2}, os.Stdin, os.Stdout, os.Stderr)

-	assert.Equal(t, 0, exit)
+	require.Equal(t, 0, exit)

-	v1, err := os.ReadFile(path1)
-	assert.NoError(t, err)
-	assert.Equal(t, "1", string(v1))
+	v1, err := ioutil.ReadFile(path1)
+	require.NoError(t, err)
+	require.Equal(t, "1", string(v1))

-	v2, err := os.ReadFile(path2)
-	assert.NoError(t, err)
-	assert.Equal(t, "2", string(v2))
+	v2, err := ioutil.ReadFile(path2)
+	require.NoError(t, err)
+	require.Equal(t, "2", string(v2))
 }

 func TestProcessMainFilesInPlaceErrRead(t *testing.T) {
@@ -130,33 +134,35 @@ func TestProcessMainFilesInPlaceErrRead(t *testing.T) {

 	exit := p.main([]string{"/this/path/is/invalid"}, os.Stdin, os.Stdout, os.Stderr)

-	assert.Equal(t, -1, exit)
+	require.Equal(t, -1, exit)
 }

 func TestProcessMainFilesInPlaceFailFn(t *testing.T) {
-	dir := t.TempDir()
+	dir, err := ioutil.TempDir("", "")
+	require.NoError(t, err)
+	defer os.RemoveAll(dir)

 	path1 := path.Join(dir, "file1")

-	err := os.WriteFile(path1, []byte("content 1"), 0o600)
-	assert.NoError(t, err)
+	err = ioutil.WriteFile(path1, []byte("content 1"), 0600)
+	require.NoError(t, err)

 	p := Program{
-		Fn:      func(io.Reader, io.Writer) error { return errors.New("oh no") },
+		Fn:      func(io.Reader, io.Writer) error { return fmt.Errorf("oh no") },
 		Inplace: true,
 	}

 	exit := p.main([]string{path1}, os.Stdin, os.Stdout, os.Stderr)

-	assert.Equal(t, -1, exit)
+	require.Equal(t, -1, exit)

-	v1, err := os.ReadFile(path1)
-	assert.NoError(t, err)
-	assert.Equal(t, "content 1", string(v1))
+	v1, err := ioutil.ReadFile(path1)
+	require.NoError(t, err)
+	require.Equal(t, "content 1", string(v1))
 }

 func dummyFileFn(r io.Reader, w io.Writer) error {
-	b, err := io.ReadAll(r)
+	b, err := ioutil.ReadAll(r)
 	if err != nil {
 		return err
 	}
@@ -0,0 +1,65 @@
+package danger
+
+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]
+}
+
+func Stride(ptr unsafe.Pointer, size uintptr, offset int) unsafe.Pointer {
+	// TODO: replace with unsafe.Add when Go 1.17 is released
+	//   https://github.com/golang/go/issues/40481
+	return unsafe.Pointer(uintptr(ptr) + uintptr(int(size)*offset))
+}
@@ -0,0 +1,178 @@
+package danger_test
+
+import (
+	"testing"
+	"unsafe"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/pelletier/go-toml/v2/internal/danger"
+)
+
+func TestSubsliceOffsetValid(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 := danger.SubsliceOffset(d, s)
+			assert.Equal(t, e.offset, offset)
+		})
+	}
+}
+
+func TestSubsliceOffsetInvalid(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() {
+				danger.SubsliceOffset(d, s)
+			})
+		})
+	}
+}
+
+func TestStride(t *testing.T) {
+	a := []byte{1, 2, 3, 4}
+	x := &a[1]
+	n := (*byte)(danger.Stride(unsafe.Pointer(x), unsafe.Sizeof(byte(0)), 1))
+	require.Equal(t, &a[2], n)
+	n = (*byte)(danger.Stride(unsafe.Pointer(x), unsafe.Sizeof(byte(0)), -1))
+	require.Equal(t, &a[0], n)
+}
+
+func TestBytesRange(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() {
+					danger.BytesRange(start, end)
+				})
+			} else {
+				res := danger.BytesRange(start, end)
+				require.Equal(t, e.expected, res)
+			}
+		})
+	}
+}
@@ -0,0 +1,23 @@
+package danger
+
+import (
+	"reflect"
+	"unsafe"
+)
+
+// typeID is used as key in encoder and decoder caches to enable using
+// the optimize runtime.mapaccess2_fast64 function instead of the more
+// expensive lookup if we were to use reflect.Type as map key.
+//
+// typeID holds the pointer to the reflect.Type value, which is unique
+// in the program.
+//
+// https://github.com/segmentio/encoding/blob/master/json/codec.go#L59-L61
+type TypeID unsafe.Pointer
+
+func MakeTypeID(t reflect.Type) TypeID {
+	// reflect.Type has the fields:
+	// typ unsafe.Pointer
+	// ptr unsafe.Pointer
+	return TypeID((*[2]unsafe.Pointer)(unsafe.Pointer(&t))[1])
+}
@@ -1,4 +1,4 @@
-package imported_tests //revive:disable:var-naming
+package imported_tests

 // Those tests have been imported from v1, but adjust to match the new
 // defaults of v2.
@@ -9,7 +9,7 @@ import (
 	"time"

 	"github.com/pelletier/go-toml/v2"
-	"github.com/pelletier/go-toml/v2/internal/assert"
+	"github.com/stretchr/testify/require"
 )

 func TestDocMarshal(t *testing.T) {
@@ -21,12 +21,12 @@ func TestDocMarshal(t *testing.T) {
 		Subdocs     testDocSubs       `toml:"subdoc"`
 		Basics      testDocBasics     `toml:"basic"`
 		SubDocList  []testSubDoc      `toml:"subdoclist"`
-		err         int               `toml:"shouldntBeHere"` //nolint:unused
+		err         int               `toml:"shouldntBeHere"`
 		unexported  int               `toml:"shouldntBeHere"`
 		Unexported2 int               `toml:"-"`
 	}

-	docData := testDoc{
+	var docData = testDoc{
 		Title:       "TOML Marshal Testing",
 		unexported:  0,
 		Unexported2: 0,
@@ -67,7 +67,6 @@ func TestDocMarshal(t *testing.T) {
 	}

 	marshalTestToml := `title = 'TOML Marshal Testing'
-
 [basic_lists]
 floats = [12.3, 45.6, 78.9]
 bools = [true, false, true]
@@ -90,6 +89,7 @@ name = 'Second'
 [subdoc.first]
 name = 'First'

+
 [basic]
 uint = 5001
 bool = true
@@ -101,34 +101,34 @@ date = 1979-05-27T07:32:00Z

 [[subdoclist]]
 name = 'List.First'
-
 [[subdoclist]]
 name = 'List.Second'
+
 `

 	result, err := toml.Marshal(docData)
-	assert.NoError(t, err)
-	assert.Equal(t, marshalTestToml, string(result))
+	require.NoError(t, err)
+	require.Equal(t, marshalTestToml, string(result))
 }

 func TestBasicMarshalQuotedKey(t *testing.T) {
 	result, err := toml.Marshal(quotedKeyMarshalTestData)
-	assert.NoError(t, err)
+	require.NoError(t, err)

 	expected := `'Z.string-àéù' = 'Hello'
 'Yfloat-𝟘' = 3.5
-
 ['Xsubdoc-àéù']
 String2 = 'One'

 [['W.sublist-𝟘']]
 String2 = 'Two'
-
 [['W.sublist-𝟘']]
 String2 = 'Three'
+
 `

-	assert.Equal(t, expected, string(result))
+	require.Equal(t, string(expected), string(result))
+
 }

 func TestEmptyMarshal(t *testing.T) {
@@ -152,18 +152,18 @@ func TestEmptyMarshal(t *testing.T) {
 		Map:        map[string]string{},
 	}
 	result, err := toml.Marshal(doc)
-	assert.NoError(t, err)
+	require.NoError(t, err)

 	expected := `title = 'Placeholder'
 bool = false
 int = 0
 string = ''
 stringlist = []
-
 [map]
+
 `

-	assert.Equal(t, expected, string(result))
+	require.Equal(t, string(expected), string(result))
 }

 type textMarshaler struct {
@@ -186,13 +186,13 @@ func TestTextMarshaler(t *testing.T) {
 	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)
+		require.Error(t, err)
 	})

 	t.Run("leaf", func(t *testing.T) {
 		res, err := toml.Marshal(wrap{m})
-		assert.NoError(t, err)
+		require.NoError(t, err)

-		assert.Equal(t, "TM = 'Sally Fields'\n", string(res))
+		require.Equal(t, "TM = 'Sally Fields'\n", string(res))
 	})
 }
@@ -1,4 +1,4 @@
-package imported_tests //revive:disable:var-naming
+package imported_tests

 // Those tests were imported directly from go-toml v1
 // https://raw.githubusercontent.com/pelletier/go-toml/a2e52561804c6cd9392ebf0048ca64fe4af67a43/marshal_test.go
@@ -16,7 +16,8 @@ import (
 	"time"

 	"github.com/pelletier/go-toml/v2"
-	"github.com/pelletier/go-toml/v2/internal/assert"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )

 type basicMarshalTestStruct struct {
@@ -122,7 +123,7 @@ func TestInterface(t *testing.T) {
 	var config Conf
 	config.Inter = &NestedStruct{}
 	err := toml.Unmarshal(doc, &config)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	expected := Conf{
 		Name: "rui",
 		Age:  18,
@@ -138,8 +139,8 @@ func TestInterface(t *testing.T) {
 func TestBasicUnmarshal(t *testing.T) {
 	result := basicMarshalTestStruct{}
 	err := toml.Unmarshal(basicTestToml, &result)
-	assert.NoError(t, err)
-	assert.Equal(t, basicTestData, result)
+	require.NoError(t, err)
+	require.Equal(t, basicTestData, result)
 }

 type quotedKeyMarshalTestStruct struct {
@@ -149,6 +150,8 @@ type quotedKeyMarshalTestStruct struct {
 	SubList []basicMarshalTestSubStruct `toml:"W.sublist-𝟘"`
 }

+// TODO: Remove nolint once var is used by a test
+//nolint:deadcode,unused,varcheck
 var quotedKeyMarshalTestData = quotedKeyMarshalTestStruct{
 	String:  "Hello",
 	Float:   3.5,
@@ -157,8 +160,7 @@ var quotedKeyMarshalTestData = quotedKeyMarshalTestStruct{
 }

 // TODO: Remove nolint once var is used by a test
-//
-//nolint:unused
+//nolint:deadcode,unused,varcheck
 var quotedKeyMarshalTestToml = []byte(`"Yfloat-𝟘" = 3.5
 "Z.string-àéù" = "Hello"

@@ -180,12 +182,11 @@ type testDoc struct {
 	Subdocs     testDocSubs       `toml:"subdoc"`
 	Basics      testDocBasics     `toml:"basic"`
 	SubDocList  []testSubDoc      `toml:"subdoclist"`
-	err         int               `toml:"shouldntBeHere"` //nolint:unused
+	err         int               `toml:"shouldntBeHere"` // nolint:structcheck,unused
 	unexported  int               `toml:"shouldntBeHere"`
 	Unexported2 int               `toml:"-"`
 }

-//nolint:unused
 type testMapDoc struct {
 	Title    string            `toml:"title"`
 	BasicMap map[string]string `toml:"basic_map"`
@@ -271,8 +272,7 @@ var docData = testDoc{
 }

 // TODO: Remove nolint once var is used by a test
-//
-//nolint:unused
+//nolint:deadcode,unused,varcheck
 var mapTestDoc = testMapDoc{
 	Title: "TOML Marshal Testing",
 	BasicMap: map[string]string{
@@ -297,7 +297,7 @@ func TestDocUnmarshal(t *testing.T) {
 	result := testDoc{}
 	err := toml.Unmarshal(marshalTestToml, &result)
 	expected := docData
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expected, result)
 }

@@ -337,7 +337,7 @@ shouldntBeHere = 2
 func TestUnexportedUnmarshal(t *testing.T) {
 	result := unexportedMarshalTestStruct{}
 	err := toml.Unmarshal(unexportedTestToml, &result)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, unexportedTestData, result)
 }

@@ -453,7 +453,7 @@ func TestEmptytomlUnmarshal(t *testing.T) {

 	result := emptyMarshalTestStruct{}
 	err := toml.Unmarshal(emptyTestToml, &result)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, emptyTestData, result)
 }

@@ -501,7 +501,7 @@ Str = "Hello"
 func TestPointerUnmarshal(t *testing.T) {
 	result := pointerMarshalTestStruct{}
 	err := toml.Unmarshal(pointerTestToml, &result)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, pointerTestData, result)
 }

@@ -537,47 +537,40 @@ StringPtr = [["Three", "Four"]]
 func TestNestedUnmarshal(t *testing.T) {
 	result := nestedMarshalTestStruct{}
 	err := toml.Unmarshal(nestedTestToml, &result)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, nestedTestData, result)
 }

-//nolint:unused
 type customMarshalerParent struct {
 	Self    customMarshaler   `toml:"me"`
 	Friends []customMarshaler `toml:"friends"`
 }

-//nolint:unused
 type customMarshaler struct {
 	FirstName string
 	LastName  string
 }

-//nolint:unused
 func (c customMarshaler) MarshalTOML() ([]byte, error) {
 	fullName := fmt.Sprintf("%s %s", c.FirstName, c.LastName)
 	return []byte(fullName), nil
 }

-//nolint:unused
 var customMarshalerData = customMarshaler{FirstName: "Sally", LastName: "Fields"}

 // TODO: Remove nolint once var is used by a test
-//
-//nolint:unused
+//nolint:deadcode,unused,varcheck
 var customMarshalerToml = []byte(`Sally Fields`)

 // TODO: Remove nolint once var is used by a test
-//
-//nolint:unused
+//nolint:deadcode,unused,varcheck
 var nestedCustomMarshalerData = customMarshalerParent{
 	Self:    customMarshaler{FirstName: "Maiku", LastName: "Suteda"},
 	Friends: []customMarshaler{customMarshalerData},
 }

 // TODO: Remove nolint once var is used by a test
-//
-//nolint:unused
+//nolint:deadcode,unused,varcheck
 var nestedCustomMarshalerToml = []byte(`friends = ["Sally Fields"]
 me = "Maiku Suteda"
 `)
@@ -592,7 +585,7 @@ func (x *IntOrString) MarshalTOML() ([]byte, error) {
 	s := *(*string)(x)
 	_, err := strconv.Atoi(s)
 	if err != nil {
-		return []byte(fmt.Sprintf(`"%s"`, s)), nil //nolint:nilerr
+		return []byte(fmt.Sprintf(`"%s"`, s)), nil
 	}
 	return []byte(s), nil
 }
@@ -618,7 +611,6 @@ func TestUnmarshalTextMarshaler(t *testing.T) {
 }

 // TODO: Remove nolint once type and methods are used by a test
-//
 //nolint:unused
 type precedentMarshaler struct {
 	FirstName string
@@ -637,7 +629,6 @@ func (m precedentMarshaler) MarshalTOML() ([]byte, error) {
 }

 // TODO: Remove nolint once type and method are used by a test
-//
 //nolint:unused
 type customPointerMarshaler struct {
 	FirstName string
@@ -650,7 +641,6 @@ func (m *customPointerMarshaler) MarshalTOML() ([]byte, error) {
 }

 // TODO: Remove nolint once type and method are used by a test
-//
 //nolint:unused
 type textPointerMarshaler struct {
 	FirstName string
@@ -663,8 +653,7 @@ func (m *textPointerMarshaler) MarshalText() ([]byte, error) {
 }

 // TODO: Remove nolint once var is used by a test
-//
-//nolint:unused
+//nolint:deadcode,unused,varcheck
 var commentTestToml = []byte(`
 # it's a comment on type
 [postgres]
@@ -689,7 +678,6 @@ var commentTestToml = []byte(`
    My = "Baar"
 `)

-//nolint:unused
 type mapsTestStruct struct {
 	Simple map[string]string
 	Paths  map[string]string
@@ -702,8 +690,7 @@ type mapsTestStruct struct {
 }

 // TODO: Remove nolint once var is used by a test
-//
-//nolint:unused
+//nolint:deadcode,unused,varcheck
 var mapsTestData = mapsTestStruct{
 	Simple: map[string]string{
 		"one plus one": "two",
@@ -726,8 +713,7 @@ var mapsTestData = mapsTestStruct{
 }

 // TODO: Remove nolint once var is used by a test
-//
-//nolint:unused
+//nolint:deadcode,unused,varcheck
 var mapsTestToml = []byte(`
 [Other]
  "testing" = 3.9999
@@ -749,8 +735,7 @@ var mapsTestToml = []byte(`
 `)

 // TODO: Remove nolint once type is used by a test
-//
-//nolint:unused
+//nolint:deadcode,unused
 type structArrayNoTag struct {
 	A struct {
 		B []int64
@@ -759,8 +744,7 @@ type structArrayNoTag struct {
 }

 // TODO: Remove nolint once var is used by a test
-//
-//nolint:unused
+//nolint:deadcode,unused,varcheck
 var customTagTestToml = []byte(`
 [postgres]
  password = "bvalue"
@@ -774,8 +758,7 @@ var customTagTestToml = []byte(`
 `)

 // TODO: Remove nolint once var is used by a test
-//
-//nolint:unused
+//nolint:deadcode,unused,varcheck
 var customCommentTagTestToml = []byte(`
 # db connection
 [postgres]
@@ -788,8 +771,7 @@ var customCommentTagTestToml = []byte(`
 `)

 // TODO: Remove nolint once var is used by a test
-//
-//nolint:unused
+//nolint:deadcode,unused,varcheck
 var customCommentedTagTestToml = []byte(`
 [postgres]
  # password = "bvalue"
@@ -836,15 +818,14 @@ func TestUnmarshalTabInStringAndQuotedKey(t *testing.T) {
 		t.Run(test.desc, func(t *testing.T) {
 			result := Test{}
 			err := toml.Unmarshal(test.input, &result)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.Equal(t, test.expected, result)
 		})
 	}
 }

 // TODO: Remove nolint once var is used by a test
-//
-//nolint:unused
+//nolint:deadcode,unused,varcheck
 var customMultilineTagTestToml = []byte(`int_slice = [
  1,
  2,
@@ -853,8 +834,7 @@ var customMultilineTagTestToml = []byte(`int_slice = [
 `)

 // TODO: Remove nolint once var is used by a test
-//
-//nolint:unused
+//nolint:deadcode,unused,varcheck
 var testDocBasicToml = []byte(`
 [document]
  bool_val = true
@@ -865,12 +845,14 @@ var testDocBasicToml = []byte(`
  uint_val = 5001
 `)

-//nolint:unused
+// TODO: Remove nolint once type is used by a test
+//nolint:deadcode
 type testDocCustomTag struct {
 	Doc testDocBasicsCustomTag `file:"document"`
 }

-//nolint:unused
+// TODO: Remove nolint once type is used by a test
+//nolint:deadcode
 type testDocBasicsCustomTag struct {
 	Bool       bool      `file:"bool_val"`
 	Date       time.Time `file:"date_val"`
@@ -881,7 +863,8 @@ type testDocBasicsCustomTag struct {
 	unexported int       `file:"shouldntBeHere"`
 }

-//nolint:unused
+// TODO: Remove nolint once var is used by a test
+//nolint:deadcode,varcheck
 var testDocCustomTagData = testDocCustomTag{
 	Doc: testDocBasicsCustomTag{
 		Bool:       true,
@@ -959,7 +942,7 @@ func TestUnmarshalTypeTableHeader(t *testing.T) {
 	}

 	expected := map[header]map[string]int{
-		"test": {"a": 1},
+		"test": map[string]int{"a": 1},
 	}

 	if !reflect.DeepEqual(result, expected) {
@@ -983,14 +966,13 @@ func TestUnmarshalInvalidPointerKind(t *testing.T) {
 }

 // TODO: Remove nolint once var is used by a test
-//
-//nolint:unused
+//nolint:deadcode,unused
 type testDuration struct {
 	Nanosec   time.Duration  `toml:"nanosec"`
 	Microsec1 time.Duration  `toml:"microsec1"`
 	Microsec2 *time.Duration `toml:"microsec2"`
 	Millisec  time.Duration  `toml:"millisec"`
-	Sec       time.Duration  `toml:"sec"` //nolint:staticcheck
+	Sec       time.Duration  `toml:"sec"`
 	Min       time.Duration  `toml:"min"`
 	Hour      time.Duration  `toml:"hour"`
 	Mixed     time.Duration  `toml:"mixed"`
@@ -998,8 +980,7 @@ type testDuration struct {
 }

 // TODO: Remove nolint once var is used by a test
-//
-//nolint:unused
+//nolint:deadcode,unused,varcheck
 var testDurationToml = []byte(`
 nanosec = "1ns"
 microsec1 = "1us"
@@ -1013,8 +994,7 @@ a_string = "15s"
 `)

 // TODO: Remove nolint once var is used by a test
-//
-//nolint:unused
+//nolint:deadcode,unused,varcheck
 var testDurationToml2 = []byte(`a_string = "15s"
 hour = "1h0m0s"
 microsec1 = "1µs"
@@ -1027,15 +1007,15 @@ sec = "1s"
 `)

 // TODO: Remove nolint once type is used by a test
-//
-//nolint:unused
+//nolint:deadcode,unused
 type testBadDuration struct {
 	Val time.Duration `toml:"val"`
 }

 // TODO: add back camelCase test
-var testCamelCaseKeyToml = []byte(`fooBar = 10`)
+var testCamelCaseKeyToml = []byte(`fooBar = 10`) //nolint:unused

+//nolint:unused
 func TestUnmarshalCamelCaseKey(t *testing.T) {
 	t.Skipf("don't know if it is a good idea to automatically convert like that yet")
 	var x struct {
@@ -1054,7 +1034,7 @@ func TestUnmarshalCamelCaseKey(t *testing.T) {

 func TestUnmarshalNegativeUint(t *testing.T) {
 	t.Skipf("not sure if we this should always error")
-	type check struct{ U uint }
+	type check struct{ U uint } // nolint:unused
 	err := toml.Unmarshal([]byte("U = -1"), &check{})
 	assert.Error(t, err)
 }
@@ -1080,12 +1060,16 @@ func TestUnmarshalCheckConversionFloatInt(t *testing.T) {
 			desc:  "int",
 			input: `I = 1e300`,
 		},
+		{
+			desc:  "float",
+			input: `F = 9223372036854775806`,
+		},
 	}

 	for _, test := range testCases {
 		t.Run(test.desc, func(t *testing.T) {
 			err := toml.Unmarshal([]byte(test.input), &conversionCheck{})
-			assert.Error(t, err)
+			require.Error(t, err)
 		})
 	}
 }
@@ -1120,7 +1104,7 @@ func TestUnmarshalOverflow(t *testing.T) {
 	for _, test := range testCases {
 		t.Run(test.desc, func(t *testing.T) {
 			err := toml.Unmarshal([]byte(test.input), &overflow{})
-			assert.Error(t, err)
+			require.Error(t, err)
 		})
 	}
 }
@@ -1531,7 +1515,7 @@ func TestUnmarshalLocalDateTime(t *testing.T) {
 	}

 	for i, example := range examples {
-		doc := "date = " + example.in
+		doc := fmt.Sprintf(`date = %s`, example.in)

 		t.Run(fmt.Sprintf("ToLocalDateTime_%d_%s", i, example.name), func(t *testing.T) {
 			type dateStruct struct {
@@ -1617,7 +1601,7 @@ func TestUnmarshalLocalTime(t *testing.T) {
 	}

 	for i, example := range examples {
-		doc := "Time = " + example.in
+		doc := fmt.Sprintf(`Time = %s`, example.in)

 		t.Run(fmt.Sprintf("ToLocalTime_%d_%s", i, example.name), func(t *testing.T) {
 			type dateStruct struct {
@@ -1740,7 +1724,7 @@ Age = 23
 	}
 	actual := OuterStruct{}
 	err := toml.Unmarshal(doc, &actual)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expected, actual)
 }

@@ -1825,7 +1809,7 @@ InnerField = "After4"
 	}

 	err := toml.Unmarshal(doc, &actual)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expected, actual)
 }

@@ -1874,7 +1858,7 @@ type arrayTooSmallStruct struct {
 func TestUnmarshalSlice(t *testing.T) {
 	var actual sliceStruct
 	err := toml.Unmarshal(sliceTomlDemo, &actual)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	expected := sliceStruct{
 		Slice:          []string{"Howdy", "Hey There"},
 		SlicePtr:       &[]string{"Howdy", "Hey There"},
@@ -1902,12 +1886,19 @@ func TestUnmarshalMixedTypeSlice(t *testing.T) {
 		ArrayField []interface{}
 	}

+	//doc := []byte(`ArrayField = [3.14,100,true,"hello world",{Field = "inner1"},[{Field = "inner2"},{Field = "inner3"}]]
+	//`)
+
 	doc := []byte(`ArrayField = [{Field = "inner1"},[{Field = "inner2"},{Field = "inner3"}]]
 `)

 	actual := TestStruct{}
 	expected := TestStruct{
 		ArrayField: []interface{}{
+			//3.14,
+			//int64(100),
+			//true,
+			//"hello world",
 			map[string]interface{}{
 				"Field": "inner1",
 			},
@@ -1918,7 +1909,7 @@ func TestUnmarshalMixedTypeSlice(t *testing.T) {
 		},
 	}
 	err := toml.Unmarshal(doc, &actual)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expected, actual)
 }

@@ -1927,7 +1918,7 @@ func TestUnmarshalArray(t *testing.T) {

 	var actual arrayStruct
 	err = toml.Unmarshal(sliceTomlDemo, &actual)
-	assert.NoError(t, err)
+	require.NoError(t, err)

 	expected := arrayStruct{
 		Slice:          [4]string{"Howdy", "Hey There"},
@@ -1986,17 +1977,11 @@ func TestDecoderStrict(t *testing.T) {
 	}

 	err := strictDecoder(input).Decode(&doc)
-	assert.Error(t, err)
+	require.Error(t, err)
+	require.IsType(t, &toml.StrictMissingError{}, err)
+	se := err.(*toml.StrictMissingError)

-	assert.Equal(t,
-		reflect.TypeOf(err), reflect.TypeOf(&toml.StrictMissingError{}),
-		"Expected a *toml.StrictMissingError, got: %v", reflect.TypeOf(err),
-	)
-
-	var se *toml.StrictMissingError
-	assert.True(t, errors.As(err, &se))
-
-	keys := make([]toml.Key, 0, len(se.Errors))
+	keys := []toml.Key{}

 	for _, e := range se.Errors {
 		keys = append(keys, e.Key())
@@ -2009,14 +1994,13 @@ func TestDecoderStrict(t *testing.T) {
 		{"undecoded", "array"},
 	}

-	assert.Equal(t, expectedKeys, keys)
+	require.Equal(t, expectedKeys, keys)

 	err = decoder(input).Decode(&doc)
-	assert.NoError(t, err)
+	require.NoError(t, err)

 	var m map[string]interface{}
 	err = decoder(input).Decode(&m)
-	assert.NoError(t, err)
 }

 func TestDecoderStrictValid(t *testing.T) {
@@ -2031,7 +2015,7 @@ func TestDecoderStrictValid(t *testing.T) {
 	}

 	err := strictDecoder(input).Decode(&doc)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }

 type docUnmarshalTOML struct {
@@ -2053,6 +2037,19 @@ func (d *docUnmarshalTOML) UnmarshalTOML(i interface{}) error {
 	return nil
 }

+func TestDecoderStrictCustomUnmarshal(t *testing.T) {
+	t.Skip()
+	//input := `key = "ok"`
+	//var doc docUnmarshalTOML
+	//err := NewDecoder(bytes.NewReader([]byte(input))).Strict(true).Decode(&doc)
+	//if err != nil {
+	//	t.Fatal("unexpected error:", err)
+	//}
+	//if doc.Decoded.Key != "ok" {
+	//	t.Errorf("Bad unmarshal: expected ok, got %v", doc.Decoded.Key)
+	//}
+}
+
 type parent struct {
 	Doc        docUnmarshalTOML
 	DocPointer *docUnmarshalTOML
@@ -2069,7 +2066,7 @@ func TestCustomUnmarshal(t *testing.T) {

 	var d parent
 	err := toml.Unmarshal([]byte(input), &d)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "ok1", d.Doc.Decoded.Key)
 	assert.Equal(t, "ok2", d.DocPointer.Decoded.Key)
 }
@@ -2135,7 +2132,7 @@ Int = 21
 Float = 2.0
 `
 	err := toml.Unmarshal([]byte(input), &doc)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, 12, doc.UnixTime.Value)
 	assert.Equal(t, 42, doc.Version.Value)
 	assert.Equal(t, 1, doc.Bool.Value)
@@ -2205,10 +2202,7 @@ func TestUnmarshalEmptyInterface(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	assert.Equal(t,
-		reflect.TypeOf(map[string]interface{}{}), reflect.TypeOf(v),
-		"Expected map[string]interface{}{} type, got: %v", reflect.TypeOf(v),
-	)
+	require.IsType(t, map[string]interface{}{}, v)

 	x := v.(map[string]interface{})
 	assert.Equal(t, "pelletier", x["User"])
@@ -2256,12 +2250,12 @@ type Custom struct {
 	v string
 }

-func (c *Custom) UnmarshalTOML(interface{}) error {
+func (c *Custom) UnmarshalTOML(v interface{}) error {
 	c.v = "called"
 	return nil
 }

-func TestGitHubIssue431(t *testing.T) {
+func TestGithubIssue431(t *testing.T) {
 	doc := `key = "value"`
 	var c Config
 	if err := toml.Unmarshal([]byte(doc), &c); err != nil {
@@ -2281,14 +2275,14 @@ type durationString struct {
 	time.Duration
 }

-func (d *durationString) UnmarshalTOML(interface{}) error {
+func (d *durationString) UnmarshalTOML(v interface{}) error {
 	d.Duration = 10 * time.Second
 	return nil
 }

 type config437Error struct{}

-func (e *config437Error) UnmarshalTOML(interface{}) error {
+func (e *config437Error) UnmarshalTOML(v interface{}) error {
 	return errors.New("expected")
 }

@@ -2299,7 +2293,7 @@ type config437 struct {
 	} `toml:"HTTP"`
 }

-func TestGitHubIssue437(t *testing.T) {
+func TestGithubIssue437(t *testing.T) {
 	t.Skipf("unmarshalTOML not implemented")
 	src := `
 [HTTP]
@@ -3,18 +3,17 @@ 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{} {
+func addTag(key string, tomlData interface{}) interface{} {
 	// Switch on the data type.
 	switch orig := tomlData.(type) {
 	default:
-		// return map[string]interface{}{}
+		//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
@@ -22,7 +21,7 @@ func addTag(tomlData interface{}) interface{} {
 	case map[string]interface{}:
 		typed := make(map[string]interface{}, len(orig))
 		for k, v := range orig {
-			typed[k] = addTag(v)
+			typed[k] = addTag(k, v)
 		}
 		return typed

@@ -31,13 +30,13 @@ func addTag(tomlData interface{}) interface{} {
 	case []map[string]interface{}:
 		typed := make([]map[string]interface{}, len(orig))
 		for i, v := range orig {
-			typed[i] = addTag(v).(map[string]interface{})
+			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)
+			typed[i] = addTag("", v)
 		}
 		return typed

@@ -53,11 +52,11 @@ func addTag(tomlData interface{}) interface{} {

 	// Tag primitive values: bool, string, int, and float64.
 	case bool:
-		return tag("bool", strconv.FormatBool(orig))
+		return tag("bool", fmt.Sprintf("%v", orig))
 	case string:
 		return tag("string", orig)
 	case int64:
-		return tag("integer", strconv.FormatInt(orig, 10))
+		return tag("integer", fmt.Sprintf("%d", orig))
 	case float64:
 		// Special case for nan since NaN == NaN is false.
 		if math.IsNaN(orig) {
@@ -9,7 +9,6 @@ import (
 )

 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)
@@ -23,7 +22,6 @@ func CmpJSON(t *testing.T, key string, want, have interface{}) {
 }

 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)
@@ -63,7 +61,6 @@ func cmpJSONMaps(t *testing.T, key string, want map[string]interface{}, have int
 }

 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))
@@ -86,7 +83,6 @@ func cmpJSONArrays(t *testing.T, key string, want, have interface{}) {
 }

 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"]))
@@ -130,7 +126,6 @@ func cmpJSONValues(t *testing.T, key string, want, have map[string]interface{})
 }

 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"+
@@ -140,7 +135,6 @@ func cmpAsStrings(t *testing.T, key string, want, have string) {
 }

 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 {
@@ -183,7 +177,6 @@ var layouts = map[string]string{
 }

 func cmpAsDatetimes(t *testing.T, key string, kind, want, have string) {
-	t.Helper()
 	layout, ok := layouts[kind]
 	if !ok {
 		panic("should never happen")
@@ -207,6 +200,15 @@ func cmpAsDatetimes(t *testing.T, key string, kind, want, have string) {
 	}
 }

+func cmpAsDatetimesLocal(t *testing.T, key string, want, have string) {
+	if datetimeRepl.Replace(want) != datetimeRepl.Replace(have) {
+		t.Fatalf("Values for key '%s' don't match:\n"+
+			"  Expected:     %v\n"+
+			"  Your encoder: %v",
+			key, want, have)
+	}
+}
+
 func kjoin(old, key string) string {
 	if len(old) == 0 {
 		return key
@@ -228,7 +230,6 @@ func isValue(m map[string]interface{}) bool {
 }

 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",
@@ -236,9 +237,8 @@ func mismatch(t *testing.T, key string, wantType string, want, have interface{})
 }

 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)
+		key, wantType, want, have)
 }
@@ -0,0 +1,69 @@
+package testsuite
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+
+	"github.com/pelletier/go-toml/v2"
+)
+
+type parser struct{}
+
+func (p parser) Decode(input string) (output string, outputIsError bool, retErr error) {
+	defer func() {
+		if r := recover(); r != nil {
+			switch rr := r.(type) {
+			case error:
+				retErr = rr
+			default:
+				retErr = fmt.Errorf("%s", rr)
+			}
+		}
+	}()
+
+	var v interface{}
+
+	if err := toml.Unmarshal([]byte(input), &v); err != nil {
+		return err.Error(), true, nil
+	}
+
+	j, err := json.MarshalIndent(addTag("", v), "", "  ")
+	if err != nil {
+		return "", false, retErr
+	}
+
+	return string(j), false, retErr
+}
+
+func (p parser) Encode(input string) (output string, outputIsError bool, retErr error) {
+	defer func() {
+		if r := recover(); r != nil {
+			switch rr := r.(type) {
+			case error:
+				retErr = rr
+			default:
+				retErr = fmt.Errorf("%s", rr)
+			}
+		}
+	}()
+
+	var tmp interface{}
+	err := json.Unmarshal([]byte(input), &tmp)
+	if err != nil {
+		return "", false, err
+	}
+
+	rm, err := rmTag(tmp)
+	if err != nil {
+		return err.Error(), true, retErr
+	}
+
+	buf := new(bytes.Buffer)
+	err = toml.NewEncoder(buf).Encode(rm)
+	if err != nil {
+		return err.Error(), true, retErr
+	}
+
+	return buf.String(), false, retErr
+}
@@ -4,12 +4,10 @@ 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) {
+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]
@@ -17,7 +15,8 @@ func rmTag(typedJSON interface{}) (interface{}, error) {
 	}

 	// Switch on the data type.
-	switch v := typedJSON.(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
@@ -41,7 +40,7 @@ func rmTag(typedJSON interface{}) (interface{}, error) {
 		}
 		return m, nil

-	// Array: remove tags from all items.
+	// Array: remove tags from all itenm.
 	case []interface{}:
 		a := make([]interface{}, len(v))
 		for i := range v {
@@ -55,7 +54,7 @@ func rmTag(typedJSON interface{}) (interface{}, error) {
 	}

 	// The top level must be an object or array.
-	return nil, fmt.Errorf("unrecognized JSON format '%T'", typedJSON)
+	return nil, fmt.Errorf("unrecognized JSON format '%T'", typedJson)
 }

 // Return a primitive: read the "type" and convert the "value" to that.
@@ -77,31 +76,14 @@ func untag(typed map[string]interface{}) (interface{}, error) {
 			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)
+		return parseTime(v, "2006-01-02T15:04:05.999999999Z07:00", false)
 	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
+		return parseTime(v, "2006-01-02T15:04:05.999999999", true)
 	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
+		return parseTime(v, "2006-01-02", true)
 	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
+		return parseTime(v, "15:04:05.999999999", true)
 	case "bool":
 		switch v {
 		case "true":
@@ -114,3 +96,15 @@ func untag(typed map[string]interface{}) (interface{}, error) {

 	return nil, fmt.Errorf("untag: unrecognized tag type %q", t)
 }
+
+func parseTime(v, format string, local bool) (t time.Time, err error) {
+	if local {
+		t, err = time.ParseInLocation(format, v, time.Local)
+	} else {
+		t, err = time.Parse(format, v)
+	}
+	if err != nil {
+		return time.Time{}, fmt.Errorf("Could not parse %q as a datetime: %w", v, err)
+	}
+	return t, nil
+}
@@ -10,7 +10,7 @@ import (
 	"github.com/pelletier/go-toml/v2"
 )

-// Marshal is a helper function for calling toml.Marshal
+// Marshal is a helpfer function for calling toml.Marshal
 //
 // Only needed to avoid package import loops.
 func Marshal(v interface{}) ([]byte, error) {
@@ -27,7 +27,7 @@ func Unmarshal(data []byte, v interface{}) error {
 // ValueToTaggedJSON takes a data structure and returns the tagged JSON
 // representation.
 func ValueToTaggedJSON(doc interface{}) ([]byte, error) {
-	return json.MarshalIndent(addTag(doc), "", "  ")
+	return json.MarshalIndent(addTag("", doc), "", "  ")
 }

 // DecodeStdin is a helper function for the toml-test binary interface.  TOML input
@@ -37,32 +37,14 @@ 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)
+		return fmt.Errorf("Error decoding TOML: %s", err)
 	}

 	j := json.NewEncoder(os.Stdout)
 	j.SetIndent("", "  ")
-	if err := j.Encode(addTag(decoded)); err != nil {
-		return fmt.Errorf("error encoding JSON: %w", err)
+	if err := j.Encode(addTag("", decoded)); err != nil {
+		return fmt.Errorf("Error encoding JSON: %s", 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,6 +1,8 @@
 package tracker

-import "github.com/pelletier/go-toml/v2/unstable"
+import (
+	"github.com/pelletier/go-toml/v2/internal/ast"
+)

 // KeyTracker is a tracker that keeps track of the current Key as the AST is
 // walked.
@@ -9,19 +11,19 @@ type KeyTracker struct {
 }

 // UpdateTable sets the state of the tracker with the AST table node.
-func (t *KeyTracker) UpdateTable(node *unstable.Node) {
+func (t *KeyTracker) UpdateTable(node *ast.Node) {
 	t.reset()
 	t.Push(node)
 }

 // UpdateArrayTable sets the state of the tracker with the AST array table node.
-func (t *KeyTracker) UpdateArrayTable(node *unstable.Node) {
+func (t *KeyTracker) UpdateArrayTable(node *ast.Node) {
 	t.reset()
 	t.Push(node)
 }

 // Push the given key on the stack.
-func (t *KeyTracker) Push(node *unstable.Node) {
+func (t *KeyTracker) Push(node *ast.Node) {
 	it := node.Key()
 	for it.Next() {
 		t.k = append(t.k, string(it.Node().Data))
@@ -29,14 +31,14 @@ func (t *KeyTracker) Push(node *unstable.Node) {
 }

 // Pop key from stack.
-func (t *KeyTracker) Pop(node *unstable.Node) {
+func (t *KeyTracker) Pop(node *ast.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)
@@ -5,7 +5,7 @@ import (
 	"fmt"
 	"sync"

-	"github.com/pelletier/go-toml/v2/unstable"
+	"github.com/pelletier/go-toml/v2/internal/ast"
 )

 type keyKind uint8
@@ -57,11 +57,7 @@ type SeenTracker struct {
 	currentIdx int
 }

-var pool = sync.Pool{
-	New: func() interface{} {
-		return &SeenTracker{}
-	},
-}
+var pool sync.Pool

 func (s *SeenTracker) reset() {
 	// Always contains a root element at index 0.
@@ -153,25 +149,24 @@ func (s *SeenTracker) setExplicitFlag(parentIdx int) {

 // 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) {
+// consistent.
+func (s *SeenTracker) CheckExpression(node *ast.Node) error {
 	if s.entries == nil {
 		s.reset()
 	}
 	switch node.Kind {
-	case unstable.KeyValue:
+	case ast.KeyValue:
 		return s.checkKeyValue(node)
-	case unstable.Table:
+	case ast.Table:
 		return s.checkTable(node)
-	case unstable.ArrayTable:
+	case ast.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 *unstable.Node) (bool, error) {
+func (s *SeenTracker) checkTable(node *ast.Node) error {
 	if s.currentIdx >= 0 {
 		s.setExplicitFlag(s.currentIdx)
 	}
@@ -197,7 +192,7 @@ func (s *SeenTracker) checkTable(node *unstable.Node) (bool, error) {
 		} 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)
+				return fmt.Errorf("toml: expected %s to be a table, not a %s", string(k), entry.kind)
 			}
 		}
 		parentIdx = idx
@@ -206,27 +201,25 @@ func (s *SeenTracker) checkTable(node *unstable.Node) (bool, error) {
 	k := it.Node().Data
 	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)
+			return 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))
+			return fmt.Errorf("toml: table %s already exists", string(k))
 		}
 		s.entries[idx].explicit = true
 	} else {
 		idx = s.create(parentIdx, k, tableKind, true, false)
-		first = true
 	}

 	s.currentIdx = idx

-	return first, nil
+	return nil
 }

-func (s *SeenTracker) checkArrayTable(node *unstable.Node) (bool, error) {
+func (s *SeenTracker) checkArrayTable(node *ast.Node) error {
 	if s.currentIdx >= 0 {
 		s.setExplicitFlag(s.currentIdx)
 	}
@@ -249,7 +242,7 @@ func (s *SeenTracker) checkArrayTable(node *unstable.Node) (bool, error) {
 		} 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)
+				return fmt.Errorf("toml: expected %s to be a table, not a %s", string(k), entry.kind)
 			}
 		}

@@ -259,23 +252,22 @@ func (s *SeenTracker) checkArrayTable(node *unstable.Node) (bool, error) {
 	k := it.Node().Data
 	idx := s.find(parentIdx, k)

-	firstTime := idx < 0
-	if firstTime {
-		idx = s.create(parentIdx, k, arrayTableKind, true, false)
-	} else {
+	if idx >= 0 {
 		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))
+			return fmt.Errorf("toml: key %s already exists as a %s,  but should be an array table", kind, string(k))
 		}
 		s.clear(idx)
+	} else {
+		idx = s.create(parentIdx, k, arrayTableKind, true, false)
 	}

 	s.currentIdx = idx

-	return firstTime, nil
+	return nil
 }

-func (s *SeenTracker) checkKeyValue(node *unstable.Node) (bool, error) {
+func (s *SeenTracker) checkKeyValue(node *ast.Node) error {
 	parentIdx := s.currentIdx
 	it := node.Key()

@@ -288,13 +280,12 @@ func (s *SeenTracker) checkKeyValue(node *unstable.Node) (bool, error) {
 			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))
+			if it.IsLast() {
+				return fmt.Errorf("toml: key %s is already defined", string(k))
+			} else if entry.kind != tableKind {
+				return fmt.Errorf("toml: expected %s to be a table, not a %s", string(k), entry.kind)
+			} else if entry.explicit {
+				return fmt.Errorf("toml: cannot redefine table %s that has already been explicitly defined", string(k))
 			}
 		}

@@ -306,45 +297,51 @@ func (s *SeenTracker) checkKeyValue(node *unstable.Node) (bool, error) {
 	value := node.Value()

 	switch value.Kind {
-	case unstable.InlineTable:
+	case ast.InlineTable:
 		return s.checkInlineTable(value)
-	case unstable.Array:
+	case ast.Array:
 		return s.checkArray(value)
-	default:
-		return false, nil
 	}
+
+	return nil
 }

-func (s *SeenTracker) checkArray(node *unstable.Node) (first bool, err error) {
+func (s *SeenTracker) checkArray(node *ast.Node) error {
 	it := node.Children()
 	for it.Next() {
 		n := it.Node()
-		switch n.Kind { //nolint:exhaustive
-		case unstable.InlineTable:
-			first, err = s.checkInlineTable(n)
+		switch n.Kind {
+		case ast.InlineTable:
+			err := s.checkInlineTable(n)
 			if err != nil {
-				return false, err
+				return err
 			}
-		case unstable.Array:
-			first, err = s.checkArray(n)
+		case ast.Array:
+			err := s.checkArray(n)
 			if err != nil {
-				return false, err
+				return err
 			}
 		}
 	}
-	return first, nil
+	return nil
 }

-func (s *SeenTracker) checkInlineTable(node *unstable.Node) (first bool, err error) {
+func (s *SeenTracker) checkInlineTable(node *ast.Node) error {
+	if pool.New == nil {
+		pool.New = func() interface{} {
+			return &SeenTracker{}
+		}
+	}
+
 	s = pool.Get().(*SeenTracker)
 	s.reset()

 	it := node.Children()
 	for it.Next() {
 		n := it.Node()
-		first, err = s.checkKeyValue(n)
+		err := s.checkKeyValue(n)
 		if err != nil {
-			return false, err
+			return err
 		}
 	}

@@ -355,5 +352,5 @@ func (s *SeenTracker) checkInlineTable(node *unstable.Node) (first bool, err err
 	// redefinition of its keys: check* functions cannot walk into
 	// a value.
 	pool.Put(s)
-	return first, nil
+	return nil
 }
@@ -1,21 +1,15 @@
 package tracker

 import (
-	"reflect"
 	"testing"
+	"unsafe"

-	"github.com/pelletier/go-toml/v2/internal/assert"
+	"github.com/stretchr/testify/require"
 )

 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,
-	)
+	require.LessOrEqual(t, 48, int(unsafe.Sizeof(entry{})))
 }
@@ -1,2 +1 @@
-// Package tracker provides functions for keeping track of AST nodes.
 package tracker
@@ -4,8 +4,6 @@ import (
 	"fmt"
 	"strings"
 	"time"
-
-	"github.com/pelletier/go-toml/v2/unstable"
 )

 // LocalDate represents a calendar day in no specific timezone.
@@ -45,7 +43,7 @@ func (d *LocalDate) UnmarshalText(b []byte) error {
 type LocalTime struct {
 	Hour       int // Hour of the day: [0; 24[
 	Minute     int // Minute of the hour: [0; 60[
-	Second     int // Second of the minute: [0; 59]
+	Second     int // Second of the minute: [0; 60[
 	Nanosecond int // Nanoseconds within the second:  [0, 1000000000[
 	Precision  int // Number of digits to display for Nanosecond.
 }
@@ -77,7 +75,7 @@ func (d LocalTime) MarshalText() ([]byte, error) {
 func (d *LocalTime) UnmarshalText(b []byte) error {
 	res, left, err := parseLocalTime(b)
 	if err == nil && len(left) != 0 {
-		err = unstable.NewParserError(left, "extra characters")
+		err = newDecodeError(left, "extra characters")
 	}
 	if err != nil {
 		return err
@@ -111,7 +109,7 @@ func (d LocalDateTime) MarshalText() ([]byte, error) {
 func (d *LocalDateTime) UnmarshalText(data []byte) error {
 	res, left, err := parseLocalDateTime(data)
 	if err == nil && len(left) != 0 {
-		err = unstable.NewParserError(left, "extra characters")
+		err = newDecodeError(left, "extra characters")
 	}
 	if err != nil {
 		return err
@@ -5,73 +5,73 @@ import (
 	"time"

 	"github.com/pelletier/go-toml/v2"
-	"github.com/pelletier/go-toml/v2/internal/assert"
+	"github.com/stretchr/testify/require"
 )

 func TestLocalDate_AsTime(t *testing.T) {
 	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)
+	require.Equal(t, time.Date(2021, time.June, 8, 0, 0, 0, 0, time.UTC), cast)
 }

 func TestLocalDate_String(t *testing.T) {
 	d := toml.LocalDate{2021, 6, 8}
-	assert.Equal(t, "2021-06-08", d.String())
+	require.Equal(t, "2021-06-08", d.String())
 }

 func TestLocalDate_MarshalText(t *testing.T) {
 	d := toml.LocalDate{2021, 6, 8}
 	b, err := d.MarshalText()
-	assert.NoError(t, err)
-	assert.Equal(t, []byte("2021-06-08"), b)
+	require.NoError(t, err)
+	require.Equal(t, []byte("2021-06-08"), b)
 }

 func TestLocalDate_UnmarshalMarshalText(t *testing.T) {
 	d := toml.LocalDate{}
 	err := d.UnmarshalText([]byte("2021-06-08"))
-	assert.NoError(t, err)
-	assert.Equal(t, toml.LocalDate{2021, 6, 8}, d)
+	require.NoError(t, err)
+	require.Equal(t, toml.LocalDate{2021, 6, 8}, d)

 	err = d.UnmarshalText([]byte("what"))
-	assert.Error(t, err)
+	require.Error(t, err)
 }

 func TestLocalTime_String(t *testing.T) {
 	d := toml.LocalTime{20, 12, 1, 2, 9}
-	assert.Equal(t, "20:12:01.000000002", d.String())
+	require.Equal(t, "20:12:01.000000002", d.String())
 	d = toml.LocalTime{20, 12, 1, 0, 0}
-	assert.Equal(t, "20:12:01", d.String())
+	require.Equal(t, "20:12:01", d.String())
 	d = toml.LocalTime{20, 12, 1, 0, 9}
-	assert.Equal(t, "20:12:01.000000000", d.String())
+	require.Equal(t, "20:12:01.000000000", d.String())
 	d = toml.LocalTime{20, 12, 1, 100, 0}
-	assert.Equal(t, "20:12:01.0000001", d.String())
+	require.Equal(t, "20:12:01.0000001", d.String())
 }

 func TestLocalTime_MarshalText(t *testing.T) {
 	d := toml.LocalTime{20, 12, 1, 2, 9}
 	b, err := d.MarshalText()
-	assert.NoError(t, err)
-	assert.Equal(t, []byte("20:12:01.000000002"), b)
+	require.NoError(t, err)
+	require.Equal(t, []byte("20:12:01.000000002"), b)
 }

 func TestLocalTime_UnmarshalMarshalText(t *testing.T) {
 	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)
+	require.NoError(t, err)
+	require.Equal(t, toml.LocalTime{20, 12, 1, 2, 9}, d)

 	err = d.UnmarshalText([]byte("what"))
-	assert.Error(t, err)
+	require.Error(t, err)

 	err = d.UnmarshalText([]byte("20:12:01.000000002 bad"))
-	assert.Error(t, err)
+	require.Error(t, err)
 }

 func TestLocalTime_RoundTrip(t *testing.T) {
 	var d struct{ A toml.LocalTime }
 	err := toml.Unmarshal([]byte("a=20:12:01.500"), &d)
-	assert.NoError(t, err)
-	assert.Equal(t, "20:12:01.500", d.A.String())
+	require.NoError(t, err)
+	require.Equal(t, "20:12:01.500", d.A.String())
 }

 func TestLocalDateTime_AsTime(t *testing.T) {
@@ -80,7 +80,7 @@ func TestLocalDateTime_AsTime(t *testing.T) {
 		toml.LocalTime{20, 12, 1, 2, 9},
 	}
 	cast := d.AsTime(time.UTC)
-	assert.Equal(t, time.Date(2021, time.June, 8, 20, 12, 1, 2, time.UTC), cast)
+	require.Equal(t, time.Date(2021, time.June, 8, 20, 12, 1, 2, time.UTC), cast)
 }

 func TestLocalDateTime_String(t *testing.T) {
@@ -88,7 +88,7 @@ func TestLocalDateTime_String(t *testing.T) {
 		toml.LocalDate{2021, 6, 8},
 		toml.LocalTime{20, 12, 1, 2, 9},
 	}
-	assert.Equal(t, "2021-06-08T20:12:01.000000002", d.String())
+	require.Equal(t, "2021-06-08T20:12:01.000000002", d.String())
 }

 func TestLocalDateTime_MarshalText(t *testing.T) {
@@ -97,22 +97,22 @@ func TestLocalDateTime_MarshalText(t *testing.T) {
 		toml.LocalTime{20, 12, 1, 2, 9},
 	}
 	b, err := d.MarshalText()
-	assert.NoError(t, err)
-	assert.Equal(t, []byte("2021-06-08T20:12:01.000000002"), b)
+	require.NoError(t, err)
+	require.Equal(t, []byte("2021-06-08T20:12:01.000000002"), b)
 }

 func TestLocalDateTime_UnmarshalMarshalText(t *testing.T) {
 	d := toml.LocalDateTime{}
 	err := d.UnmarshalText([]byte("2021-06-08 20:12:01.000000002"))
-	assert.NoError(t, err)
-	assert.Equal(t, toml.LocalDateTime{
+	require.NoError(t, err)
+	require.Equal(t, toml.LocalDateTime{
 		toml.LocalDate{2021, 6, 8},
 		toml.LocalTime{20, 12, 1, 2, 9},
 	}, d)

 	err = d.UnmarshalText([]byte("what"))
-	assert.Error(t, err)
+	require.Error(t, err)

 	err = d.UnmarshalText([]byte("2021-06-08 20:12:01.000000002 bad"))
-	assert.Error(t, err)
+	require.Error(t, err)
 }
@@ -3,19 +3,15 @@ package toml
 import (
 	"bytes"
 	"encoding"
-	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
 	"math"
 	"reflect"
-	"slices"
+	"sort"
 	"strconv"
 	"strings"
 	"time"
 	"unicode"
-
-	"github.com/pelletier/go-toml/v2/internal/characters"
 )

 // Marshal serializes a Go value as a TOML document.
@@ -39,11 +35,10 @@ type Encoder struct {
 	w io.Writer

 	// global settings
-	tablesInline       bool
-	arraysMultiline    bool
-	indentSymbol       string
-	indentTables       bool
-	marshalJSONNumbers bool
+	tablesInline    bool
+	arraysMultiline bool
+	indentSymbol    string
+	indentTables    bool
 }

 // NewEncoder returns a new Encoder that writes to w.
@@ -59,7 +54,7 @@ func NewEncoder(w io.Writer) *Encoder {
 // This behavior can be controlled on an individual struct field basis with the
 // inline tag:
 //
-//	MyField `toml:",inline"`
+//   MyField `inline:"true"`
 func (enc *Encoder) SetTablesInline(inline bool) *Encoder {
 	enc.tablesInline = inline
 	return enc
@@ -70,7 +65,7 @@ func (enc *Encoder) SetTablesInline(inline bool) *Encoder {
 //
 // This behavior can be controlled on an individual struct field basis with the multiline tag:
 //
-//	MyField `multiline:"true"`
+//   MyField `multiline:"true"`
 func (enc *Encoder) SetArraysMultiline(multiline bool) *Encoder {
 	enc.arraysMultiline = multiline
 	return enc
@@ -90,22 +85,11 @@ func (enc *Encoder) SetIndentTables(indent bool) *Encoder {
 	return enc
 }

-// SetMarshalJSONNumbers forces the encoder to serialize `json.Number` as a
-// float or integer instead of relying on TextMarshaler to emit a string.
-//
-// *Unstable:* This method does not follow the compatibility guarantees of
-// semver. It can be changed or removed without a new major version being
-// issued.
-func (enc *Encoder) SetMarshalJSONNumbers(indent bool) *Encoder {
-	enc.marshalJSONNumbers = indent
-	return enc
-}
-
 // Encode writes a TOML representation of v to the stream.
 //
 // If v cannot be represented to TOML it returns an error.
 //
-// # Encoding rules
+// Encoding rules
 //
 // A top level slice containing only maps or structs is encoded as [[table
 // array]].
@@ -123,30 +107,10 @@ func (enc *Encoder) SetMarshalJSONNumbers(indent bool) *Encoder {
 // a newline character or a single quote. In that case they are emitted as
 // quoted strings.
 //
-// Unsigned integers larger than math.MaxInt64 cannot be encoded. Doing so
-// results in an error. This rule exists because the TOML specification only
-// requires parsers to support at least the 64 bits integer range. Allowing
-// larger numbers would create non-standard TOML documents, which may not be
-// readable (at best) by other implementations. To encode such numbers, a
-// solution is a custom type that implements encoding.TextMarshaler.
-//
 // When encoding structs, fields are encoded in order of definition, with their
 // exact name.
 //
-// Tables and array tables are separated by empty lines. However, consecutive
-// subtables definitions are not. For example:
-//
-//	[top1]
-//
-//	[top2]
-//	[top2.child1]
-//
-//	[[array]]
-//
-//	[[array]]
-//	[array.child2]
-//
-// # Struct tags
+// Struct tags
 //
 // The encoding of each public struct field can be customized by the format
 // string in the "toml" key of the struct field's tag. This follows
@@ -162,15 +126,9 @@ func (enc *Encoder) SetMarshalJSONNumbers(indent bool) *Encoder {
 //
 // The "omitempty" option prevents empty values or groups from being emitted.
 //
-// The "omitzero" option prevents zero values or groups from being emitted.
-//
-// The "commented" option prefixes the value and all its children with a comment
-// symbol.
-//
 // In addition to the "toml" tag struct tag, a "comment" tag can be used to emit
 // a TOML comment before the value being annotated. Comments are ignored inside
-// inline tables. For array tables, the comment is only present before the first
-// element of the array.
+// inline tables.
 func (enc *Encoder) Encode(v interface{}) error {
 	var (
 		b   []byte
@@ -180,7 +138,7 @@ func (enc *Encoder) Encode(v interface{}) error {
 	ctx.inline = enc.tablesInline

 	if v == nil {
-		return errors.New("toml: cannot encode a nil interface")
+		return fmt.Errorf("toml: cannot encode a nil interface")
 	}

 	b, err := enc.encode(b, ctx, reflect.ValueOf(v))
@@ -199,8 +157,6 @@ func (enc *Encoder) Encode(v interface{}) error {
 type valueOptions struct {
 	multiline bool
 	omitempty bool
-	omitzero  bool
-	commented bool
 	comment   string
 }

@@ -226,9 +182,6 @@ type encoderCtx struct {
 	// Indentation level
 	indent int

-	// Prefix the current value with a comment.
-	commented bool
-
 	// Options coming from struct tags
 	options valueOptions
 }
@@ -269,21 +222,10 @@ func (enc *Encoder) encode(b []byte, ctx encoderCtx, v reflect.Value) ([]byte, e
 		return append(b, x.String()...), nil
 	case LocalDateTime:
 		return append(b, x.String()...), nil
-	case json.Number:
-		if enc.marshalJSONNumbers {
-			if x == "" { /// Useful zero value.
-				return append(b, "0"...), nil
-			} else if v, err := x.Int64(); err == nil {
-				return enc.encode(b, ctx, reflect.ValueOf(v))
-			} else if f, err := x.Float64(); err == nil {
-				return enc.encode(b, ctx, reflect.ValueOf(f))
-			}
-			return nil, fmt.Errorf("toml: unable to convert %q to int64 or float64", x)
-		}
 	}

 	hasTextMarshaler := v.Type().Implements(textMarshalerType)
-	if hasTextMarshaler || (v.CanAddr() && reflect.PointerTo(v.Type()).Implements(textMarshalerType)) {
+	if hasTextMarshaler || (v.CanAddr() && reflect.PtrTo(v.Type()).Implements(textMarshalerType)) {
 		if !hasTextMarshaler {
 			v = v.Addr()
 		}
@@ -308,11 +250,11 @@ func (enc *Encoder) encode(b []byte, ctx encoderCtx, v reflect.Value) ([]byte, e
 		return enc.encodeMap(b, ctx, v)
 	case reflect.Struct:
 		return enc.encodeStruct(b, ctx, v)
-	case reflect.Slice, reflect.Array:
+	case reflect.Slice:
 		return enc.encodeSlice(b, ctx, v)
 	case reflect.Interface:
 		if v.IsNil() {
-			return nil, errors.New("toml: encoding a nil interface is not supported")
+			return nil, fmt.Errorf("toml: encoding a nil interface is not supported")
 		}

 		return enc.encode(b, ctx, v.Elem())
@@ -329,30 +271,28 @@ func (enc *Encoder) encode(b []byte, ctx encoderCtx, v reflect.Value) ([]byte, e
 	case reflect.Float32:
 		f := v.Float()

-		switch {
-		case math.IsNaN(f):
+		if math.IsNaN(f) {
 			b = append(b, "nan"...)
-		case f > math.MaxFloat32:
+		} else if f > math.MaxFloat32 {
 			b = append(b, "inf"...)
-		case f < -math.MaxFloat32:
+		} else if f < -math.MaxFloat32 {
 			b = append(b, "-inf"...)
-		case math.Trunc(f) == f:
+		} else if math.Trunc(f) == f {
 			b = strconv.AppendFloat(b, f, 'f', 1, 32)
-		default:
+		} else {
 			b = strconv.AppendFloat(b, f, 'f', -1, 32)
 		}
 	case reflect.Float64:
 		f := v.Float()
-		switch {
-		case math.IsNaN(f):
+		if math.IsNaN(f) {
 			b = append(b, "nan"...)
-		case f > math.MaxFloat64:
+		} else if f > math.MaxFloat64 {
 			b = append(b, "inf"...)
-		case f < -math.MaxFloat64:
+		} else if f < -math.MaxFloat64 {
 			b = append(b, "-inf"...)
-		case math.Trunc(f) == f:
+		} else if math.Trunc(f) == f {
 			b = strconv.AppendFloat(b, f, 'f', 1, 64)
-		default:
+		} else {
 			b = strconv.AppendFloat(b, f, 'f', -1, 64)
 		}
 	case reflect.Bool:
@@ -362,11 +302,7 @@ func (enc *Encoder) encode(b []byte, ctx encoderCtx, v reflect.Value) ([]byte, e
 			b = append(b, "false"...)
 		}
 	case reflect.Uint64, reflect.Uint32, reflect.Uint16, reflect.Uint8, reflect.Uint:
-		x := v.Uint()
-		if x > uint64(math.MaxInt64) {
-			return nil, fmt.Errorf("toml: not encoding uint (%d) greater than max int64 (%d)", x, int64(math.MaxInt64))
-		}
-		b = strconv.AppendUint(b, x, 10)
+		b = strconv.AppendUint(b, v.Uint(), 10)
 	case reflect.Int64, reflect.Int32, reflect.Int16, reflect.Int8, reflect.Int:
 		b = strconv.AppendInt(b, v.Int(), 10)
 	default:
@@ -385,44 +321,18 @@ func isNil(v reflect.Value) bool {
 	}
 }

-func shouldOmitEmpty(options valueOptions, v reflect.Value) bool {
-	return options.omitempty && isEmptyValue(v)
-}
-
-func shouldOmitZero(options valueOptions, v reflect.Value) bool {
-	if !options.omitzero {
-		return false
-	}
-
-	// Check if the type implements isZeroer interface (has a custom IsZero method).
-	if v.Type().Implements(isZeroerType) {
-		return v.Interface().(isZeroer).IsZero()
-	}
-
-	// Check if pointer type implements isZeroer.
-	if reflect.PointerTo(v.Type()).Implements(isZeroerType) {
-		if v.CanAddr() {
-			return v.Addr().Interface().(isZeroer).IsZero()
-		}
-		// Create a temporary addressable copy to call the pointer receiver method.
-		pv := reflect.New(v.Type())
-		pv.Elem().Set(v)
-		return pv.Interface().(isZeroer).IsZero()
-	}
-
-	// Fall back to reflect's IsZero for types without custom IsZero method.
-	return v.IsZero()
-}
-
 func (enc *Encoder) encodeKv(b []byte, ctx encoderCtx, options valueOptions, v reflect.Value) ([]byte, error) {
 	var err error

-	if !ctx.inline {
-		b = enc.encodeComment(ctx.indent, options.comment, b)
-		b = enc.commented(ctx.commented, b)
-		b = enc.indent(ctx.indent, b)
+	if (ctx.options.omitempty || options.omitempty) && isEmptyValue(v) {
+		return b, nil
 	}

+	if !ctx.inline {
+		b = enc.encodeComment(ctx.indent, options.comment, b)
+	}
+
+	b = enc.indent(ctx.indent, b)
 	b = enc.encodeKey(b, ctx.key)
 	b = append(b, " = "...)

@@ -441,17 +351,8 @@ func (enc *Encoder) encodeKv(b []byte, ctx encoderCtx, options valueOptions, v r
 	return b, nil
 }

-func (enc *Encoder) commented(commented bool, b []byte) []byte {
-	if commented {
-		return append(b, "# "...)
-	}
-	return b
-}
-
 func isEmptyValue(v reflect.Value) bool {
 	switch v.Kind() {
-	case reflect.Struct:
-		return isEmptyStruct(v)
 	case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
 		return v.Len() == 0
 	case reflect.Bool:
@@ -464,37 +365,8 @@ func isEmptyValue(v reflect.Value) bool {
 		return v.Float() == 0
 	case reflect.Interface, reflect.Ptr:
 		return v.IsNil()
-	default:
-		return false
 	}
-}
-
-func isEmptyStruct(v reflect.Value) bool {
-	// TODO: merge with walkStruct and cache.
-	typ := v.Type()
-	for i := 0; i < typ.NumField(); i++ {
-		fieldType := typ.Field(i)
-
-		// only consider exported fields
-		if fieldType.PkgPath != "" {
-			continue
-		}
-
-		tag := fieldType.Tag.Get("toml")
-
-		// special field name to skip field
-		if tag == "-" {
-			continue
-		}
-
-		f := v.Field(i)
-
-		if !isEmptyValue(f) {
-			return false
-		}
-	}
-
-	return true
+	return false
 }

 const literalQuote = '\''
@@ -510,7 +382,7 @@ func (enc *Encoder) encodeString(b []byte, v string, options valueOptions) []byt
 func needsQuoting(v string) bool {
 	// TODO: vectorize
 	for _, b := range []byte(v) {
-		if b == '\'' || b == '\r' || b == '\n' || characters.InvalidASCII(b) {
+		if b == '\'' || b == '\r' || b == '\n' || invalidAscii(b) {
 			return true
 		}
 	}
@@ -526,6 +398,7 @@ func (enc *Encoder) encodeLiteralString(b []byte, v string) []byte {
 	return b
 }

+//nolint:cyclop
 func (enc *Encoder) encodeQuotedString(multiline bool, b []byte, v string) []byte {
 	stringQuote := `"`

@@ -548,26 +421,12 @@ func (enc *Encoder) encodeQuotedString(multiline bool, b []byte, v string) []byt
 		del = 0x7f
 	)

-	bv := []byte(v)
-	for i := 0; i < len(bv); i++ {
-		r := bv[i]
+	for _, r := range []byte(v) {
 		switch r {
 		case '\\':
 			b = append(b, `\\`...)
 		case '"':
-			if multiline {
-				// Quotation marks do not need to be quoted in multiline strings unless
-				// it contains 3 consecutive. If 3+ quotes appear, quote all of them
-				// because it's visually better
-				if i+2 > len(bv) || bv[i+1] != '"' || bv[i+2] != '"' {
-					b = append(b, r)
-				} else {
-					b = append(b, `\"\"\"`...)
-					i += 2
-				}
-			} else {
-				b = append(b, `\"`...)
-			}
+			b = append(b, `\"`...)
 		case '\b':
 			b = append(b, `\b`...)
 		case '\f':
@@ -604,15 +463,13 @@ func (enc *Encoder) encodeUnquotedKey(b []byte, v string) []byte {
 	return append(b, v...)
 }

-func (enc *Encoder) encodeTableHeader(ctx encoderCtx, b []byte) []byte {
+func (enc *Encoder) encodeTableHeader(ctx encoderCtx, b []byte) ([]byte, error) {
 	if len(ctx.parentKey) == 0 {
-		return b
+		return b, nil
 	}

 	b = enc.encodeComment(ctx.indent, ctx.options.comment, b)

-	b = enc.commented(ctx.commented, b)
-
 	b = enc.indent(ctx.indent, b)

 	b = append(b, '[')
@@ -626,9 +483,10 @@ func (enc *Encoder) encodeTableHeader(ctx encoderCtx, b []byte) []byte {

 	b = append(b, "]\n"...)

-	return b
+	return b, nil
 }

+//nolint:cyclop
 func (enc *Encoder) encodeKey(b []byte, k string) []byte {
 	needsQuotation := false
 	cannotUseLiteral := false
@@ -663,38 +521,11 @@ func (enc *Encoder) encodeKey(b []byte, k string) []byte {
 	}
 }

-func (enc *Encoder) keyToString(k reflect.Value) (string, error) {
-	keyType := k.Type()
-	if keyType.Implements(textMarshalerType) {
-		keyB, err := k.Interface().(encoding.TextMarshaler).MarshalText()
-		if err != nil {
-			return "", fmt.Errorf("toml: error marshalling key %v from text: %w", k, err)
-		}
-		return string(keyB), nil
-	}
-
-	switch keyType.Kind() {
-	case reflect.String:
-		return k.String(), nil
-
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		return strconv.FormatInt(k.Int(), 10), nil
-
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		return strconv.FormatUint(k.Uint(), 10), nil
-
-	case reflect.Float32:
-		return strconv.FormatFloat(k.Float(), 'f', -1, 32), nil
-
-	case reflect.Float64:
-		return strconv.FormatFloat(k.Float(), 'f', -1, 64), nil
-
-	default:
-		return "", fmt.Errorf("toml: type %s is not supported as a map key", keyType.Kind())
-	}
-}
-
 func (enc *Encoder) encodeMap(b []byte, ctx encoderCtx, v reflect.Value) ([]byte, error) {
+	if v.Type().Key().Kind() != reflect.String {
+		return nil, fmt.Errorf("toml: type %s is not supported as a map key", v.Type().Key().Kind())
+	}
+
 	var (
 		t                 table
 		emptyValueOptions valueOptions
@@ -702,22 +533,11 @@ func (enc *Encoder) encodeMap(b []byte, ctx encoderCtx, v reflect.Value) ([]byte

 	iter := v.MapRange()
 	for iter.Next() {
+		k := iter.Key().String()
 		v := iter.Value()

 		if isNil(v) {
-			// For nil pointers, convert to zero value of the element type.
-			// This allows round-trip marshaling of maps with nil pointer values.
-			// For nil interfaces and nil maps, skip since we can't derive a type.
-			if v.Kind() == reflect.Ptr {
-				v = reflect.Zero(v.Type().Elem())
-			} else {
-				continue
-			}
-		}
-
-		k, err := enc.keyToString(iter.Key())
-		if err != nil {
-			return nil, err
+			continue
 		}

 		if willConvertToTableOrArrayTable(ctx, v) {
@@ -734,8 +554,8 @@ func (enc *Encoder) encodeMap(b []byte, ctx encoderCtx, v reflect.Value) ([]byte
 }

 func sortEntriesByKey(e []entry) {
-	slices.SortFunc(e, func(a, b entry) int {
-		return strings.Compare(a.Key, b.Key)
+	sort.Slice(e, func(i, j int) bool {
+		return e[i].Key < e[j].Key
 	})
 }

@@ -798,12 +618,11 @@ func walkStruct(ctx encoderCtx, t *table, v reflect.Value) {
 			if fieldType.Anonymous {
 				if fieldType.Type.Kind() == reflect.Struct {
 					walkStruct(ctx, t, f)
-				} else if fieldType.Type.Kind() == reflect.Ptr && !f.IsNil() && f.Elem().Kind() == reflect.Struct {
-					walkStruct(ctx, t, f.Elem())
 				}
 				continue
+			} else {
+				k = fieldType.Name
 			}
-			k = fieldType.Name
 		}

 		if isNil(f) {
@@ -813,8 +632,6 @@ func walkStruct(ctx encoderCtx, t *table, v reflect.Value) {
 		options := valueOptions{
 			multiline: opts.multiline,
 			omitempty: opts.omitempty,
-			omitzero:  opts.omitzero,
-			commented: opts.commented,
 			comment:   fieldType.Tag.Get("comment"),
 		}

@@ -835,19 +652,10 @@ func (enc *Encoder) encodeStruct(b []byte, ctx encoderCtx, v reflect.Value) ([]b
 }

 func (enc *Encoder) encodeComment(indent int, comment string, b []byte) []byte {
-	for len(comment) > 0 {
-		var line string
-		idx := strings.IndexByte(comment, '\n')
-		if idx >= 0 {
-			line = comment[:idx]
-			comment = comment[idx+1:]
-		} else {
-			line = comment
-			comment = ""
-		}
+	if comment != "" {
 		b = enc.indent(indent, b)
 		b = append(b, "# "...)
-		b = append(b, line...)
+		b = append(b, comment...)
 		b = append(b, '\n')
 	}
 	return b
@@ -874,8 +682,6 @@ type tagOptions struct {
 	multiline bool
 	inline    bool
 	omitempty bool
-	omitzero  bool
-	commented bool
 }

 func parseTag(tag string) (string, tagOptions) {
@@ -887,7 +693,7 @@ func parseTag(tag string) (string, tagOptions) {
 	}

 	raw := tag[idx+1:]
-	tag = tag[:idx]
+	tag = string(tag[:idx])
 	for raw != "" {
 		var o string
 		i := strings.Index(raw, ",")
@@ -903,10 +709,6 @@ func parseTag(tag string) (string, tagOptions) {
 			opts.inline = true
 		case "omitempty":
 			opts.omitempty = true
-		case "omitzero":
-			opts.omitzero = true
-		case "commented":
-			opts.commented = true
 		}
 	}

@@ -923,7 +725,10 @@ func (enc *Encoder) encodeTable(b []byte, ctx encoderCtx, t table) ([]byte, erro
 	}

 	if !ctx.skipTableHeader {
-		b = enc.encodeTableHeader(ctx, b)
+		b, err = enc.encodeTableHeader(ctx, b)
+		if err != nil {
+			return nil, err
+		}

 		if enc.indentTables && len(ctx.parentKey) > 0 {
 			ctx.indent++
@@ -931,21 +736,10 @@ func (enc *Encoder) encodeTable(b []byte, ctx encoderCtx, t table) ([]byte, erro
 	}
 	ctx.skipTableHeader = false

-	hasNonEmptyKV := false
 	for _, kv := range t.kvs {
-		if shouldOmitEmpty(kv.Options, kv.Value) {
-			continue
-		}
-		if shouldOmitZero(kv.Options, kv.Value) {
-			continue
-		}
-		hasNonEmptyKV = true
-
 		ctx.setKey(kv.Key)
-		ctx2 := ctx
-		ctx2.commented = kv.Options.commented || ctx2.commented

-		b, err = enc.encodeKv(b, ctx2, kv.Options, kv.Value)
+		b, err = enc.encodeKv(b, ctx, kv.Options, kv.Value)
 		if err != nil {
 			return nil, err
 		}
@@ -953,33 +747,17 @@ func (enc *Encoder) encodeTable(b []byte, ctx encoderCtx, t table) ([]byte, erro
 		b = append(b, '\n')
 	}

-	first := true
 	for _, table := range t.tables {
-		if shouldOmitEmpty(table.Options, table.Value) {
-			continue
-		}
-		if shouldOmitZero(table.Options, table.Value) {
-			continue
-		}
-		if first {
-			first = false
-			if hasNonEmptyKV {
-				b = append(b, '\n')
-			}
-		} else {
-			b = append(b, "\n"...)
-		}
-
 		ctx.setKey(table.Key)

 		ctx.options = table.Options
-		ctx2 := ctx
-		ctx2.commented = ctx2.commented || ctx.options.commented

-		b, err = enc.encode(b, ctx2, table.Value)
+		b, err = enc.encode(b, ctx, table.Value)
 		if err != nil {
 			return nil, err
 		}
+
+		b = append(b, '\n')
 	}

 	return b, nil
@@ -992,13 +770,6 @@ func (enc *Encoder) encodeTableInline(b []byte, ctx encoderCtx, t table) ([]byte

 	first := true
 	for _, kv := range t.kvs {
-		if shouldOmitEmpty(kv.Options, kv.Value) {
-			continue
-		}
-		if shouldOmitZero(kv.Options, kv.Value) {
-			continue
-		}
-
 		if first {
 			first = false
 		} else {
@@ -1014,7 +785,7 @@ func (enc *Encoder) encodeTableInline(b []byte, ctx encoderCtx, t table) ([]byte
 	}

 	if len(t.tables) > 0 {
-		panic("inline table cannot contain nested tables, only key-values")
+		panic("inline table cannot contain nested tables, online key-values")
 	}

 	b = append(b, "}"...)
@@ -1026,14 +797,11 @@ func willConvertToTable(ctx encoderCtx, v reflect.Value) bool {
 	if !v.IsValid() {
 		return false
 	}
-	t := v.Type()
-	if t == timeType || t.Implements(textMarshalerType) {
-		return false
-	}
-	if v.Kind() != reflect.Ptr && v.CanAddr() && reflect.PointerTo(t).Implements(textMarshalerType) {
+	if v.Type() == timeType || v.Type().Implements(textMarshalerType) || (v.Kind() != reflect.Ptr && v.CanAddr() && reflect.PtrTo(v.Type()).Implements(textMarshalerType)) {
 		return false
 	}

+	t := v.Type()
 	switch t.Kind() {
 	case reflect.Map, reflect.Struct:
 		return !ctx.inline
@@ -1060,7 +828,7 @@ func willConvertToTableOrArrayTable(ctx encoderCtx, v reflect.Value) bool {
 		return willConvertToTableOrArrayTable(ctx, v.Elem())
 	}

-	if t.Kind() == reflect.Slice || t.Kind() == reflect.Array {
+	if t.Kind() == reflect.Slice {
 		if v.Len() == 0 {
 			// An empty slice should be a kv = [].
 			return false
@@ -1100,13 +868,6 @@ func (enc *Encoder) encodeSliceAsArrayTable(b []byte, ctx encoderCtx, v reflect.
 	ctx.shiftKey()

 	scratch := make([]byte, 0, 64)
-
-	scratch = enc.commented(ctx.commented, scratch)
-
-	if enc.indentTables {
-		scratch = enc.indent(ctx.indent, scratch)
-	}
-
 	scratch = append(scratch, "[["...)

 	for i, k := range ctx.parentKey {
@@ -1120,17 +881,7 @@ func (enc *Encoder) encodeSliceAsArrayTable(b []byte, ctx encoderCtx, v reflect.
 	scratch = append(scratch, "]]\n"...)
 	ctx.skipTableHeader = true

-	b = enc.encodeComment(ctx.indent, ctx.options.comment, b)
-
-	if enc.indentTables {
-		ctx.indent++
-	}
-
 	for i := 0; i < v.Len(); i++ {
-		if i != 0 {
-			b = append(b, "\n"...)
-		}
-
 		b = append(b, scratch...)

 		var err error
@@ -1,44 +0,0 @@
-// 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,122 +1,50 @@
-package unstable
+package toml

 import (
 	"bytes"
-	"fmt"
 	"unicode"

-	"github.com/pelletier/go-toml/v2/internal/characters"
+	"github.com/pelletier/go-toml/v2/internal/ast"
+	"github.com/pelletier/go-toml/v2/internal/danger"
 )

-// ParserError describes an error relative to the content of the document.
-//
-// It cannot outlive the instance of Parser it refers to, and may cause panics
-// if the parser is reset.
-type ParserError struct {
-	Highlight []byte
-	Message   string
-	Key       []string // optional
-}
-
-// Error is the implementation of the error interface.
-func (e *ParserError) Error() string {
-	return e.Message
-}
-
-// NewParserError is a convenience function to create a ParserError
-//
-// Warning: Highlight needs to be a subslice of Parser.data, so only slices
-// returned by Parser.Raw are valid candidates.
-func NewParserError(highlight []byte, format string, args ...interface{}) error {
-	return &ParserError{
-		Highlight: highlight,
-		Message:   fmt.Errorf(format, args...).Error(),
-	}
-}
-
-// Parser scans over a TOML-encoded document and generates an iterative AST.
-//
-// To prime the Parser, first reset it with the contents of a TOML document.
-// Then, process all top-level expressions sequentially. See Example.
-//
-// Don't forget to check Error() after you're done parsing.
-//
-// Each top-level expression needs to be fully processed before calling
-// NextExpression() again. Otherwise, calls to various Node methods may panic if
-// the parser has moved on the next expression.
-//
-// For performance reasons, go-toml doesn't make a copy of the input bytes to
-// the parser. Make sure to copy all the bytes you need to outlive the slice
-// given to the parser.
-type Parser struct {
+type parser struct {
+	builder ast.Builder
+	ref     ast.Reference
 	data    []byte
-	builder builder
-	ref     reference
 	left    []byte
 	err     error
 	first   bool
-
-	KeepComments bool
 }

-// Data returns the slice provided to the last call to Reset.
-func (p *Parser) Data() []byte {
-	return p.data
-}
-
-// Range returns a range description that corresponds to a given slice of the
-// input. If the argument is not a subslice of the parser input, this function
-// panics.
-func (p *Parser) Range(b []byte) Range {
-	return Range{
-		Offset: uint32(p.subsliceOffset(b)), //nolint:gosec // TOML documents are small
-		Length: uint32(len(b)),              //nolint:gosec // TOML documents are small
+func (p *parser) Range(b []byte) ast.Range {
+	return ast.Range{
+		Offset: uint32(danger.SubsliceOffset(p.data, b)),
+		Length: uint32(len(b)),
 	}
 }

-// rangeOfToken computes the Range of a token given the remaining bytes after the token.
-// This is used when the token was extracted from the beginning of some position,
-// and 'rest' is what remains after the token.
-func (p *Parser) rangeOfToken(token, rest []byte) Range {
-	offset := len(p.data) - len(token) - len(rest)
-	return Range{Offset: uint32(offset), Length: uint32(len(token))} //nolint:gosec // TOML documents are small
-}
-
-// subsliceOffset returns the byte offset of subslice b within p.data.
-// b must be a suffix (tail) of p.data.
-func (p *Parser) subsliceOffset(b []byte) int {
-	// b is a suffix of p.data, so its offset is len(p.data) - len(b)
-	return len(p.data) - len(b)
-}
-
-// Raw returns the slice corresponding to the bytes in the given range.
-func (p *Parser) Raw(raw Range) []byte {
+func (p *parser) Raw(raw ast.Range) []byte {
 	return p.data[raw.Offset : raw.Offset+raw.Length]
 }

-// Reset brings the parser to its initial state for a given input. It wipes an
-// reuses internal storage to reduce allocation.
-func (p *Parser) Reset(b []byte) {
+func (p *parser) Reset(b []byte) {
 	p.builder.Reset()
-	p.ref = invalidReference
+	p.ref = ast.InvalidReference
 	p.data = b
 	p.left = b
 	p.err = nil
 	p.first = true
 }

-// NextExpression parses the next top-level expression. If an expression was
-// successfully parsed, it returns true. If the parser is at the end of the
-// document or an error occurred, it returns false.
-//
-// Retrieve the parsed expression with Expression().
-func (p *Parser) NextExpression() bool {
+//nolint:cyclop
+func (p *parser) NextExpression() bool {
 	if len(p.left) == 0 || p.err != nil {
 		return false
 	}

 	p.builder.Reset()
-	p.ref = invalidReference
+	p.ref = ast.InvalidReference

 	for {
 		if len(p.left) == 0 || p.err != nil {
@@ -145,54 +73,15 @@ func (p *Parser) NextExpression() bool {
 	}
 }

-// Expression returns a pointer to the node representing the last successfully
-// parsed expression.
-func (p *Parser) Expression() *Node {
+func (p *parser) Expression() *ast.Node {
 	return p.builder.NodeAt(p.ref)
 }

-// Error returns any error that has occurred during parsing.
-func (p *Parser) Error() error {
+func (p *parser) Error() error {
 	return p.err
 }

-// Position describes a position in the input.
-type Position struct {
-	// Number of bytes from the beginning of the input.
-	Offset int
-	// Line number, starting at 1.
-	Line int
-	// Column number, starting at 1.
-	Column int
-}
-
-// Shape describes the position of a range in the input.
-type Shape struct {
-	Start Position
-	End   Position
-}
-
-// Shape returns the shape of the given range in the input.  Will
-// panic if the range is not a subslice of the input.
-func (p *Parser) Shape(r Range) Shape {
-	return Shape{
-		Start: p.positionAt(int(r.Offset)),
-		End:   p.positionAt(int(r.Offset + r.Length)),
-	}
-}
-
-// positionAt returns the position at the given byte offset in the document.
-func (p *Parser) positionAt(offset int) Position {
-	lead := p.data[:offset]
-
-	return Position{
-		Offset: offset,
-		Line:   bytes.Count(lead, []byte{'\n'}) + 1,
-		Column: len(lead) - bytes.LastIndex(lead, []byte{'\n'}),
-	}
-}
-
-func (p *Parser) parseNewline(b []byte) ([]byte, error) {
+func (p *parser) parseNewline(b []byte) ([]byte, error) {
 	if b[0] == '\n' {
 		return b[1:], nil
 	}
@@ -202,27 +91,14 @@ func (p *Parser) parseNewline(b []byte) ([]byte, error) {
 		return rest, err
 	}

-	return nil, NewParserError(b[0:1], "expected newline but got %#U", b[0])
+	return nil, newDecodeError(b[0:1], "expected newline but got %#U", b[0])
 }

-func (p *Parser) parseComment(b []byte) (reference, []byte, error) {
-	ref := invalidReference
-	data, rest, err := scanComment(b)
-	if p.KeepComments && err == nil {
-		ref = p.builder.Push(Node{
-			Kind: Comment,
-			Raw:  p.rangeOfToken(data, rest),
-			Data: data,
-		})
-	}
-	return ref, rest, err
-}
-
-func (p *Parser) parseExpression(b []byte) (reference, []byte, error) {
+func (p *parser) parseExpression(b []byte) (ast.Reference, []byte, error) {
 	// expression =  ws [ comment ]
 	// expression =/ ws keyval ws [ comment ]
 	// expression =/ ws table ws [ comment ]
-	ref := invalidReference
+	ref := ast.InvalidReference

 	b = p.parseWhitespace(b)

@@ -231,7 +107,7 @@ func (p *Parser) parseExpression(b []byte) (reference, []byte, error) {
 	}

 	if b[0] == '#' {
-		ref, rest, err := p.parseComment(b)
+		_, rest, err := scanComment(b)
 		return ref, rest, err
 	}

@@ -253,17 +129,14 @@ func (p *Parser) parseExpression(b []byte) (reference, []byte, error) {
 	b = p.parseWhitespace(b)

 	if len(b) > 0 && b[0] == '#' {
-		cref, rest, err := p.parseComment(b)
-		if cref != invalidReference {
-			p.builder.Chain(ref, cref)
-		}
+		_, rest, err := scanComment(b)
 		return ref, rest, err
 	}

 	return ref, b, nil
 }

-func (p *Parser) parseTable(b []byte) (reference, []byte, error) {
+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)
@@ -272,12 +145,12 @@ func (p *Parser) parseTable(b []byte) (reference, []byte, error) {
 	return p.parseStdTable(b)
 }

-func (p *Parser) parseArrayTable(b []byte) (reference, []byte, error) {
+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(Node{
-		Kind: ArrayTable,
+	ref := p.builder.Push(ast.Node{
+		Kind: ast.ArrayTable,
 	})

 	b = b[2:]
@@ -301,12 +174,12 @@ func (p *Parser) parseArrayTable(b []byte) (reference, []byte, error) {
 	return ref, b, err
 }

-func (p *Parser) parseStdTable(b []byte) (reference, []byte, error) {
+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(Node{
-		Kind: Table,
+	ref := p.builder.Push(ast.Node{
+		Kind: ast.Table,
 	})

 	b = b[1:]
@@ -326,18 +199,15 @@ func (p *Parser) parseStdTable(b []byte) (reference, []byte, error) {
 	return ref, b, err
 }

-func (p *Parser) parseKeyval(b []byte) (reference, []byte, error) {
+func (p *parser) parseKeyval(b []byte) (ast.Reference, []byte, error) {
 	// keyval = key keyval-sep val
-	// Track the start position for Raw range
-	startB := b
-
-	ref := p.builder.Push(Node{
-		Kind: KeyValue,
+	ref := p.builder.Push(ast.Node{
+		Kind: ast.KeyValue,
 	})

 	key, b, err := p.parseKey(b)
 	if err != nil {
-		return invalidReference, nil, err
+		return ast.InvalidReference, nil, err
 	}

 	// keyval-sep = ws %x3D ws ; =
@@ -345,12 +215,12 @@ func (p *Parser) parseKeyval(b []byte) (reference, []byte, error) {
 	b = p.parseWhitespace(b)

 	if len(b) == 0 {
-		return invalidReference, nil, NewParserError(startB[:len(startB)-len(b)], "expected = after a key, but the document ends there")
+		return ast.InvalidReference, nil, newDecodeError(b, "expected = after a key, but the document ends there")
 	}

 	b, err = expect('=', b)
 	if err != nil {
-		return invalidReference, nil, err
+		return ast.InvalidReference, nil, err
 	}

 	b = p.parseWhitespace(b)
@@ -363,20 +233,16 @@ func (p *Parser) parseKeyval(b []byte) (reference, []byte, error) {
 	p.builder.Chain(valRef, key)
 	p.builder.AttachChild(ref, valRef)

-	// Set Raw to span the entire key-value expression
-	node := p.builder.NodeAt(ref)
-	node.Raw = p.rangeOfToken(startB[:len(startB)-len(b)], b)
-
 	return ref, b, err
 }

 //nolint:cyclop,funlen
-func (p *Parser) parseVal(b []byte) (reference, []byte, error) {
+func (p *parser) parseVal(b []byte) (ast.Reference, []byte, error) {
 	// val = string / boolean / array / inline-table / date-time / float / integer
-	ref := invalidReference
+	ref := ast.InvalidReference

 	if len(b) == 0 {
-		return ref, nil, NewParserError(b, "expected value, not eof")
+		return ref, nil, newDecodeError(b, "expected value, not eof")
 	}

 	var err error
@@ -393,9 +259,9 @@ func (p *Parser) parseVal(b []byte) (reference, []byte, error) {
 		}

 		if err == nil {
-			ref = p.builder.Push(Node{
-				Kind: String,
-				Raw:  p.rangeOfToken(raw, b),
+			ref = p.builder.Push(ast.Node{
+				Kind: ast.String,
+				Raw:  p.Range(raw),
 				Data: v,
 			})
 		}
@@ -411,9 +277,9 @@ func (p *Parser) parseVal(b []byte) (reference, []byte, error) {
 		}

 		if err == nil {
-			ref = p.builder.Push(Node{
-				Kind: String,
-				Raw:  p.rangeOfToken(raw, b),
+			ref = p.builder.Push(ast.Node{
+				Kind: ast.String,
+				Raw:  p.Range(raw),
 				Data: v,
 			})
 		}
@@ -421,22 +287,22 @@ func (p *Parser) parseVal(b []byte) (reference, []byte, error) {
 		return ref, b, err
 	case 't':
 		if !scanFollowsTrue(b) {
-			return ref, nil, NewParserError(atmost(b, 4), "expected 'true'")
+			return ref, nil, newDecodeError(atmost(b, 4), "expected 'true'")
 		}

-		ref = p.builder.Push(Node{
-			Kind: Bool,
+		ref = p.builder.Push(ast.Node{
+			Kind: ast.Bool,
 			Data: b[:4],
 		})

 		return ref, b[4:], nil
 	case 'f':
 		if !scanFollowsFalse(b) {
-			return ref, nil, NewParserError(atmost(b, 5), "expected 'false'")
+			return ref, nil, newDecodeError(atmost(b, 5), "expected 'false'")
 		}

-		ref = p.builder.Push(Node{
-			Kind: Bool,
+		ref = p.builder.Push(ast.Node{
+			Kind: ast.Bool,
 			Data: b[:5],
 		})

@@ -458,7 +324,7 @@ func atmost(b []byte, n int) []byte {
 	return b[:n]
 }

-func (p *Parser) parseLiteralString(b []byte) ([]byte, []byte, []byte, error) {
+func (p *parser) parseLiteralString(b []byte) ([]byte, []byte, []byte, error) {
 	v, rest, err := scanLiteralString(b)
 	if err != nil {
 		return nil, nil, nil, err
@@ -467,20 +333,19 @@ func (p *Parser) parseLiteralString(b []byte) ([]byte, []byte, []byte, error) {
 	return v, v[1 : len(v)-1], rest, nil
 }

-func (p *Parser) parseInlineTable(b []byte) (reference, []byte, error) {
+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(Node{
-		Kind: InlineTable,
-		Raw:  p.rangeOfToken(b[:1], b[1:]),
+	parent := p.builder.Push(ast.Node{
+		Kind: ast.InlineTable,
 	})

 	first := true

-	var child reference
+	var child ast.Reference

 	b = b[1:]

@@ -491,7 +356,7 @@ func (p *Parser) parseInlineTable(b []byte) (reference, []byte, error) {
 		b = p.parseWhitespace(b)

 		if len(b) == 0 {
-			return parent, nil, NewParserError(previousB[:1], "inline table is incomplete")
+			return parent, nil, newDecodeError(previousB[:1], "inline table is incomplete")
 		}

 		if b[0] == '}' {
@@ -506,7 +371,7 @@ func (p *Parser) parseInlineTable(b []byte) (reference, []byte, error) {
 			b = p.parseWhitespace(b)
 		}

-		var kv reference
+		var kv ast.Reference

 		kv, b, err = p.parseKeyval(b)
 		if err != nil {
@@ -529,7 +394,7 @@ func (p *Parser) parseInlineTable(b []byte) (reference, []byte, error) {
 }

 //nolint:funlen,cyclop
-func (p *Parser) parseValArray(b []byte) (reference, []byte, error) {
+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 ; ]
@@ -540,39 +405,23 @@ func (p *Parser) parseValArray(b []byte) (reference, []byte, error) {
 	arrayStart := b
 	b = b[1:]

-	parent := p.builder.Push(Node{
-		Kind: Array,
+	parent := p.builder.Push(ast.Node{
+		Kind: ast.Array,
 	})

-	// First indicates whether the parser is looking for the first element
-	// (non-comment) of the array.
 	first := true

-	lastChild := invalidReference
-
-	addChild := func(valueRef reference) {
-		if lastChild == invalidReference {
-			p.builder.AttachChild(parent, valueRef)
-		} else {
-			p.builder.Chain(lastChild, valueRef)
-		}
-		lastChild = valueRef
-	}
+	var lastChild ast.Reference

 	var err error
 	for len(b) > 0 {
-		var cref reference
-		cref, b, err = p.parseOptionalWhitespaceCommentNewline(b)
+		b, err = p.parseOptionalWhitespaceCommentNewline(b)
 		if err != nil {
 			return parent, nil, err
 		}

-		if cref != invalidReference {
-			addChild(cref)
-		}
-
 		if len(b) == 0 {
-			return parent, nil, NewParserError(arrayStart[:1], "array is incomplete")
+			return parent, nil, newDecodeError(arrayStart[:1], "array is incomplete")
 		}

 		if b[0] == ']' {
@@ -581,19 +430,16 @@ func (p *Parser) parseValArray(b []byte) (reference, []byte, error) {

 		if b[0] == ',' {
 			if first {
-				return parent, nil, NewParserError(b[0:1], "array cannot start with comma")
+				return parent, nil, newDecodeError(b[0:1], "array cannot start with comma")
 			}
 			b = b[1:]

-			cref, b, err = p.parseOptionalWhitespaceCommentNewline(b)
+			b, err = p.parseOptionalWhitespaceCommentNewline(b)
 			if err != nil {
 				return parent, nil, err
 			}
-			if cref != invalidReference {
-				addChild(cref)
-			}
 		} else if !first {
-			return parent, nil, NewParserError(b[0:1], "array elements must be separated by commas")
+			return parent, nil, newDecodeError(b[0:1], "array elements must be separated by commas")
 		}

 		// TOML allows trailing commas in arrays.
@@ -601,22 +447,23 @@ func (p *Parser) parseValArray(b []byte) (reference, []byte, error) {
 			break
 		}

-		var valueRef reference
+		var valueRef ast.Reference
 		valueRef, b, err = p.parseVal(b)
 		if err != nil {
 			return parent, nil, err
 		}

-		addChild(valueRef)
+		if first {
+			p.builder.AttachChild(parent, valueRef)
+		} else {
+			p.builder.Chain(lastChild, valueRef)
+		}
+		lastChild = valueRef

-		cref, b, err = p.parseOptionalWhitespaceCommentNewline(b)
+		b, err = p.parseOptionalWhitespaceCommentNewline(b)
 		if err != nil {
 			return parent, nil, err
 		}
-		if cref != invalidReference {
-			addChild(cref)
-		}
-
 		first = false
 	}

@@ -625,35 +472,15 @@ func (p *Parser) parseValArray(b []byte) (reference, []byte, error) {
 	return parent, rest, err
 }

-func (p *Parser) parseOptionalWhitespaceCommentNewline(b []byte) (reference, []byte, error) {
-	rootCommentRef := invalidReference
-	latestCommentRef := invalidReference
-
-	addComment := func(ref reference) {
-		switch {
-		case rootCommentRef == invalidReference:
-			rootCommentRef = ref
-		case latestCommentRef == invalidReference:
-			p.builder.AttachChild(rootCommentRef, ref)
-			latestCommentRef = ref
-		default:
-			p.builder.Chain(latestCommentRef, ref)
-			latestCommentRef = ref
-		}
-	}
-
+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] == '#' {
-			var ref reference
-			ref, b, err = p.parseComment(b)
+			_, b, err = scanComment(b)
 			if err != nil {
-				return invalidReference, nil, err
-			}
-			if ref != invalidReference {
-				addComment(ref)
+				return nil, err
 			}
 		}

@@ -664,17 +491,17 @@ func (p *Parser) parseOptionalWhitespaceCommentNewline(b []byte) (reference, []b
 		if b[0] == '\n' || b[0] == '\r' {
 			b, err = p.parseNewline(b)
 			if err != nil {
-				return invalidReference, nil, err
+				return nil, err
 			}
 		} else {
 			break
 		}
 	}

-	return rootCommentRef, b, nil
+	return b, nil
 }

-func (p *Parser) parseMultilineLiteralString(b []byte) ([]byte, []byte, []byte, error) {
+func (p *parser) parseMultilineLiteralString(b []byte) ([]byte, []byte, []byte, error) {
 	token, rest, err := scanMultilineLiteralString(b)
 	if err != nil {
 		return nil, nil, nil, err
@@ -693,7 +520,7 @@ func (p *Parser) parseMultilineLiteralString(b []byte) ([]byte, []byte, []byte,
 }

 //nolint:funlen,gocognit,cyclop
-func (p *Parser) parseMultilineBasicString(b []byte) ([]byte, []byte, []byte, error) {
+func (p *parser) parseMultilineBasicString(b []byte) ([]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
@@ -724,11 +551,11 @@ func (p *Parser) parseMultilineBasicString(b []byte) ([]byte, []byte, []byte, er

 	if !escaped {
 		str := token[startIdx:endIdx]
-		highlight := characters.Utf8TomlValidAlreadyEscaped(str)
-		if len(highlight) == 0 {
+		verr := utf8TomlValidAlreadyEscaped(str)
+		if verr.Zero() {
 			return token, str, rest, nil
 		}
-		return nil, nil, nil, NewParserError(highlight, "invalid UTF-8")
+		return nil, nil, nil, newDecodeError(str[verr.Index:verr.Index+verr.Size], "invalid UTF-8")
 	}

 	var builder bytes.Buffer
@@ -764,7 +591,7 @@ func (p *Parser) parseMultilineBasicString(b []byte) ([]byte, []byte, []byte, er
 				i += j
 				for ; i < len(token)-3; i++ {
 					c := token[i]
-					if c != '\n' && c != '\r' && c != ' ' && c != '\t' {
+					if !(c == '\n' || c == '\r' || c == ' ' || c == '\t') {
 						i--
 						break
 					}
@@ -808,13 +635,13 @@ func (p *Parser) parseMultilineBasicString(b []byte) ([]byte, []byte, []byte, er
 				builder.WriteRune(x)
 				i += 8
 			default:
-				return nil, nil, nil, NewParserError(token[i:i+1], "invalid escaped character %#U", c)
+				return nil, nil, nil, newDecodeError(token[i:i+1], "invalid escaped character %#U", c)
 			}
 			i++
 		} else {
-			size := characters.Utf8ValidNext(token[i:])
+			size := utf8ValidNext(token[i:])
 			if size == 0 {
-				return nil, nil, nil, NewParserError(token[i:i+1], "invalid character %#U", c)
+				return nil, nil, nil, newDecodeError(token[i:i+1], "invalid character %#U", c)
 			}
 			builder.Write(token[i : i+size])
 			i += size
@@ -824,7 +651,7 @@ func (p *Parser) parseMultilineBasicString(b []byte) ([]byte, []byte, []byte, er
 	return token, builder.Bytes(), rest, nil
 }

-func (p *Parser) parseKey(b []byte) (reference, []byte, error) {
+func (p *parser) parseKey(b []byte) (ast.Reference, []byte, error) {
 	// key = simple-key / dotted-key
 	// simple-key = quoted-key / unquoted-key
 	//
@@ -835,12 +662,12 @@ func (p *Parser) parseKey(b []byte) (reference, []byte, error) {
 	// dot-sep   = ws %x2E ws  ; . Period
 	raw, key, b, err := p.parseSimpleKey(b)
 	if err != nil {
-		return invalidReference, nil, err
+		return ast.InvalidReference, nil, err
 	}

-	ref := p.builder.Push(Node{
-		Kind: Key,
-		Raw:  p.rangeOfToken(raw, b),
+	ref := p.builder.Push(ast.Node{
+		Kind: ast.Key,
+		Raw:  p.Range(raw),
 		Data: key,
 	})

@@ -854,9 +681,9 @@ func (p *Parser) parseKey(b []byte) (reference, []byte, error) {
 				return ref, nil, err
 			}

-			p.builder.PushAndChain(Node{
-				Kind: Key,
-				Raw:  p.rangeOfToken(raw, b),
+			p.builder.PushAndChain(ast.Node{
+				Kind: ast.Key,
+				Raw:  p.Range(raw),
 				Data: key,
 			})
 		} else {
@@ -867,9 +694,9 @@ func (p *Parser) parseKey(b []byte) (reference, []byte, error) {
 	return ref, b, nil
 }

-func (p *Parser) parseSimpleKey(b []byte) (raw, key, rest []byte, err error) {
+func (p *parser) parseSimpleKey(b []byte) (raw, key, rest []byte, err error) {
 	if len(b) == 0 {
-		return nil, nil, nil, NewParserError(b, "expected key but found none")
+		return nil, nil, nil, newDecodeError(b, "expected key but found none")
 	}

 	// simple-key = quoted-key / unquoted-key
@@ -884,12 +711,12 @@ func (p *Parser) parseSimpleKey(b []byte) (raw, key, rest []byte, err error) {
 		key, rest = scanUnquotedKey(b)
 		return key, key, rest, nil
 	default:
-		return nil, nil, nil, NewParserError(b[0:1], "invalid character at start of key: %c", b[0])
+		return nil, nil, nil, newDecodeError(b[0:1], "invalid character at start of key: %c", b[0])
 	}
 }

 //nolint:funlen,cyclop
-func (p *Parser) parseBasicString(b []byte) ([]byte, []byte, []byte, error) {
+func (p *parser) parseBasicString(b []byte) ([]byte, []byte, []byte, error) {
 	// basic-string = quotation-mark *basic-char quotation-mark
 	// quotation-mark = %x22            ; "
 	// basic-char = basic-unescaped / escaped
@@ -917,11 +744,11 @@ func (p *Parser) parseBasicString(b []byte) ([]byte, []byte, []byte, error) {
 	// validate the string and return a direct reference to the buffer.
 	if !escaped {
 		str := token[startIdx:endIdx]
-		highlight := characters.Utf8TomlValidAlreadyEscaped(str)
-		if len(highlight) == 0 {
+		verr := utf8TomlValidAlreadyEscaped(str)
+		if verr.Zero() {
 			return token, str, rest, nil
 		}
-		return nil, nil, nil, NewParserError(highlight, "invalid UTF-8")
+		return nil, nil, nil, newDecodeError(str[verr.Index:verr.Index+verr.Size], "invalid UTF-8")
 	}

 	i := startIdx
@@ -968,13 +795,13 @@ func (p *Parser) parseBasicString(b []byte) ([]byte, []byte, []byte, error) {
 				builder.WriteRune(x)
 				i += 8
 			default:
-				return nil, nil, nil, NewParserError(token[i:i+1], "invalid escaped character %#U", c)
+				return nil, nil, nil, newDecodeError(token[i:i+1], "invalid escaped character %#U", c)
 			}
 			i++
 		} else {
-			size := characters.Utf8ValidNext(token[i:])
+			size := utf8ValidNext(token[i:])
 			if size == 0 {
-				return nil, nil, nil, NewParserError(token[i:i+1], "invalid character %#U", c)
+				return nil, nil, nil, newDecodeError(token[i:i+1], "invalid character %#U", c)
 			}
 			builder.Write(token[i : i+size])
 			i += size
@@ -986,13 +813,13 @@ func (p *Parser) parseBasicString(b []byte) ([]byte, []byte, []byte, error) {

 func hexToRune(b []byte, length int) (rune, error) {
 	if len(b) < length {
-		return -1, NewParserError(b, "unicode point needs %d character, not %d", length, len(b))
+		return -1, newDecodeError(b, "unicode point needs %d character, not %d", length, len(b))
 	}
 	b = b[:length]

 	var r uint32
 	for i, c := range b {
-		var d uint32
+		d := uint32(0)
 		switch {
 		case '0' <= c && c <= '9':
 			d = uint32(c - '0')
@@ -1001,19 +828,19 @@ func hexToRune(b []byte, length int) (rune, error) {
 		case 'A' <= c && c <= 'F':
 			d = uint32(c - 'A' + 10)
 		default:
-			return -1, NewParserError(b[i:i+1], "non-hex character")
+			return -1, newDecodeError(b[i:i+1], "non-hex character")
 		}
 		r = r*16 + d
 	}

 	if r > unicode.MaxRune || 0xD800 <= r && r < 0xE000 {
-		return -1, NewParserError(b, "escape sequence is invalid Unicode code point")
+		return -1, newDecodeError(b, "escape sequence is invalid Unicode code point")
 	}

 	return rune(r), nil
 }

-func (p *Parser) parseWhitespace(b []byte) []byte {
+func (p *parser) parseWhitespace(b []byte) []byte {
 	// ws = *wschar
 	// wschar =  %x20  ; Space
 	// wschar =/ %x09  ; Horizontal tab
@@ -1023,27 +850,25 @@ func (p *Parser) parseWhitespace(b []byte) []byte {
 }

 //nolint:cyclop
-func (p *Parser) parseIntOrFloatOrDateTime(b []byte) (reference, []byte, error) {
+func (p *parser) parseIntOrFloatOrDateTime(b []byte) (ast.Reference, []byte, error) {
 	switch b[0] {
 	case 'i':
 		if !scanFollowsInf(b) {
-			return invalidReference, nil, NewParserError(atmost(b, 3), "expected 'inf'")
+			return ast.InvalidReference, nil, newDecodeError(atmost(b, 3), "expected 'inf'")
 		}

-		return p.builder.Push(Node{
-			Kind: Float,
+		return p.builder.Push(ast.Node{
+			Kind: ast.Float,
 			Data: b[:3],
-			Raw:  p.rangeOfToken(b[:3], b[3:]),
 		}), b[3:], nil
 	case 'n':
 		if !scanFollowsNan(b) {
-			return invalidReference, nil, NewParserError(atmost(b, 3), "expected 'nan'")
+			return ast.InvalidReference, nil, newDecodeError(atmost(b, 3), "expected 'nan'")
 		}

-		return p.builder.Push(Node{
-			Kind: Float,
+		return p.builder.Push(ast.Node{
+			Kind: ast.Float,
 			Data: b[:3],
-			Raw:  p.rangeOfToken(b[:3], b[3:]),
 		}), b[3:], nil
 	case '+', '-':
 		return p.scanIntOrFloat(b)
@@ -1073,7 +898,7 @@ func (p *Parser) parseIntOrFloatOrDateTime(b []byte) (reference, []byte, error)
 	return p.scanIntOrFloat(b)
 }

-func (p *Parser) scanDateTime(b []byte) (reference, []byte, error) {
+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.
 	hasDate := false
@@ -1096,7 +921,7 @@ byteLoop:
 			}
 		case c == 'T' || c == 't' || c == ':' || c == '.':
 			hasTime = true
-		case c == '+' || c == 'Z' || c == 'z':
+		case c == '+' || c == '-' || c == 'Z' || c == 'z':
 			hasTz = true
 		case c == ' ':
 			if !seenSpace && i+1 < len(b) && isDigit(b[i+1]) {
@@ -1116,30 +941,30 @@ byteLoop:
 		}
 	}

-	var kind Kind
+	var kind ast.Kind

 	if hasTime {
 		if hasDate {
 			if hasTz {
-				kind = DateTime
+				kind = ast.DateTime
 			} else {
-				kind = LocalDateTime
+				kind = ast.LocalDateTime
 			}
 		} else {
-			kind = LocalTime
+			kind = ast.LocalTime
 		}
 	} else {
-		kind = LocalDate
+		kind = ast.LocalDate
 	}

-	return p.builder.Push(Node{
+	return p.builder.Push(ast.Node{
 		Kind: kind,
 		Data: b[:i],
 	}), b[i:], nil
 }

 //nolint:funlen,gocognit,cyclop
-func (p *Parser) scanIntOrFloat(b []byte) (reference, []byte, error) {
+func (p *parser) scanIntOrFloat(b []byte) (ast.Reference, []byte, error) {
 	i := 0

 	if len(b) > 2 && b[0] == '0' && b[1] != '.' && b[1] != 'e' && b[1] != 'E' {
@@ -1165,10 +990,9 @@ func (p *Parser) scanIntOrFloat(b []byte) (reference, []byte, error) {
 			}
 		}

-		return p.builder.Push(Node{
-			Kind: Integer,
+		return p.builder.Push(ast.Node{
+			Kind: ast.Integer,
 			Data: b[:i],
-			Raw:  p.rangeOfToken(b[:i], b[i:]),
 		}), b[i:], nil
 	}

@@ -1189,45 +1013,42 @@ func (p *Parser) scanIntOrFloat(b []byte) (reference, []byte, error) {

 		if c == 'i' {
 			if scanFollowsInf(b[i:]) {
-				return p.builder.Push(Node{
-					Kind: Float,
+				return p.builder.Push(ast.Node{
+					Kind: ast.Float,
 					Data: b[:i+3],
-					Raw:  p.rangeOfToken(b[:i+3], b[i+3:]),
 				}), b[i+3:], nil
 			}

-			return invalidReference, nil, NewParserError(b[i:i+1], "unexpected character 'i' while scanning for a number")
+			return ast.InvalidReference, nil, newDecodeError(b[i:i+1], "unexpected character 'i' while scanning for a number")
 		}

 		if c == 'n' {
 			if scanFollowsNan(b[i:]) {
-				return p.builder.Push(Node{
-					Kind: Float,
+				return p.builder.Push(ast.Node{
+					Kind: ast.Float,
 					Data: b[:i+3],
-					Raw:  p.rangeOfToken(b[:i+3], b[i+3:]),
 				}), b[i+3:], nil
 			}

-			return invalidReference, nil, NewParserError(b[i:i+1], "unexpected character 'n' while scanning for a number")
+			return ast.InvalidReference, nil, newDecodeError(b[i:i+1], "unexpected character 'n' while scanning for a number")
 		}

 		break
 	}

 	if i == 0 {
-		return invalidReference, b, NewParserError(b, "incomplete number")
+		return ast.InvalidReference, b, newDecodeError(b, "incomplete number")
 	}

-	kind := Integer
+	kind := ast.Integer

 	if isFloat {
-		kind = Float
+		kind = ast.Float
 	}

-	return p.builder.Push(Node{
+	return p.builder.Push(ast.Node{
 		Kind: kind,
 		Data: b[:i],
-		Raw:  p.rangeOfToken(b[:i], b[i:]),
 	}), b[i:], nil
 }

@@ -1254,11 +1075,11 @@ func isValidBinaryRune(r byte) bool {

 func expect(x byte, b []byte) ([]byte, error) {
 	if len(b) == 0 {
-		return nil, NewParserError(b, "expected character %c but the document ended here", x)
+		return nil, newDecodeError(b, "expected character %c but the document ended here", x)
 	}

 	if b[0] != x {
-		return nil, NewParserError(b[0:1], "expected character %c", x)
+		return nil, newDecodeError(b[0:1], "expected character %c", x)
 	}

 	return b[1:], nil
@@ -0,0 +1,450 @@
+package toml
+
+import (
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/pelletier/go-toml/v2/internal/ast"
+	"github.com/stretchr/testify/require"
+)
+
+//nolint:funlen
+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 {
+		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 {
+				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 (
+	astNode struct {
+		Kind     ast.Kind
+		Data     []byte
+		Children []astNode
+	}
+)
+
+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))
+	}
+}
+
+//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: 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 {
+		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 {
+				require.Error(t, err)
+			} else {
+				require.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  ast.Kind
+		err   bool
+	}{
+		{
+			desc:  "offset-date-time with delim 'T' and UTC offset",
+			input: `2021-07-21T12:08:05Z`,
+			kind:  ast.DateTime,
+		},
+		{
+			desc:  "offset-date-time with space delim and +8hours offset",
+			input: `2021-07-21 12:08:05+08:00`,
+			kind:  ast.DateTime,
+		},
+		{
+			desc:  "local-date-time with nano second",
+			input: `2021-07-21T12:08:05.666666666`,
+			kind:  ast.LocalDateTime,
+		},
+		{
+			desc:  "local-date-time",
+			input: `2021-07-21T12:08:05`,
+			kind:  ast.LocalDateTime,
+		},
+		{
+			desc:  "local-date",
+			input: `2021-07-21`,
+			kind:  ast.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 {
+				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())
+			}
+		})
+	}
+}
@@ -1,6 +1,4 @@
-package unstable
-
-import "github.com/pelletier/go-toml/v2/internal/characters"
+package toml

 func scanFollows(b []byte, pattern string) bool {
 	n := len(pattern)
@@ -56,16 +54,16 @@ func scanLiteralString(b []byte) ([]byte, []byte, error) {
 		case '\'':
 			return b[:i+1], b[i+1:], nil
 		case '\n', '\r':
-			return nil, nil, NewParserError(b[i:i+1], "literal strings cannot have new lines")
+			return nil, nil, newDecodeError(b[i:i+1], "literal strings cannot have new lines")
 		}
-		size := characters.Utf8ValidNext(b[i:])
+		size := utf8ValidNext(b[i:])
 		if size == 0 {
-			return nil, nil, NewParserError(b[i:i+1], "invalid character")
+			return nil, nil, newDecodeError(b[i:i+1], "invalid character")
 		}
 		i += size
 	}

-	return nil, nil, NewParserError(b[len(b):], "unterminated literal string")
+	return nil, nil, newDecodeError(b[len(b):], "unterminated literal string")
 }

 func scanMultilineLiteralString(b []byte) ([]byte, []byte, error) {
@@ -100,39 +98,39 @@ func scanMultilineLiteralString(b []byte) ([]byte, []byte, error) {
 				i++

 				if i < len(b) && b[i] == '\'' {
-					return nil, nil, NewParserError(b[i-3:i+1], "''' not allowed in multiline literal string")
+					return nil, nil, newDecodeError(b[i-3:i+1], "''' not allowed in multiline literal string")
 				}

 				return b[:i], b[i:], nil
 			}
 		case '\r':
 			if len(b) < i+2 {
-				return nil, nil, NewParserError(b[len(b):], `need a \n after \r`)
+				return nil, nil, newDecodeError(b[len(b):], `need a \n after \r`)
 			}
 			if b[i+1] != '\n' {
-				return nil, nil, NewParserError(b[i:i+2], `need a \n after \r`)
+				return nil, nil, newDecodeError(b[i:i+2], `need a \n after \r`)
 			}
 			i += 2 // skip the \n
 			continue
 		}
-		size := characters.Utf8ValidNext(b[i:])
+		size := utf8ValidNext(b[i:])
 		if size == 0 {
-			return nil, nil, NewParserError(b[i:i+1], "invalid character")
+			return nil, nil, newDecodeError(b[i:i+1], "invalid character")
 		}
 		i += size
 	}

-	return nil, nil, NewParserError(b[len(b):], `multiline literal string not terminated by '''`)
+	return nil, nil, newDecodeError(b[len(b):], `multiline literal string not terminated by '''`)
 }

 func scanWindowsNewline(b []byte) ([]byte, []byte, error) {
 	const lenCRLF = 2
 	if len(b) < lenCRLF {
-		return nil, nil, NewParserError(b, "windows new line expected")
+		return nil, nil, newDecodeError(b, "windows new line expected")
 	}

 	if b[1] != '\n' {
-		return nil, nil, NewParserError(b, `windows new line should be \r\n`)
+		return nil, nil, newDecodeError(b, `windows new line should be \r\n`)
 	}

 	return b[:lenCRLF], b[lenCRLF:], nil
@@ -151,6 +149,7 @@ func scanWhitespace(b []byte) ([]byte, []byte) {
 	return b, b[len(b):]
 }

+//nolint:unparam
 func scanComment(b []byte) ([]byte, []byte, error) {
 	// comment-start-symbol = %x23 ; #
 	// non-ascii = %x80-D7FF / %xE000-10FFFF
@@ -166,11 +165,11 @@ func scanComment(b []byte) ([]byte, []byte, error) {
 			if i+1 < len(b) && b[i+1] == '\n' {
 				return b[:i+1], b[i+1:], nil
 			}
-			return nil, nil, NewParserError(b[i:i+1], "invalid character in comment")
+			return nil, nil, newDecodeError(b[i:i+1], "invalid character in comment")
 		}
-		size := characters.Utf8ValidNext(b[i:])
+		size := utf8ValidNext(b[i:])
 		if size == 0 {
-			return nil, nil, NewParserError(b[i:i+1], "invalid character in comment")
+			return nil, nil, newDecodeError(b[i:i+1], "invalid character in comment")
 		}

 		i += size
@@ -193,17 +192,17 @@ func scanBasicString(b []byte) ([]byte, bool, []byte, error) {
 		case '"':
 			return b[:i+1], escaped, b[i+1:], nil
 		case '\n', '\r':
-			return nil, escaped, nil, NewParserError(b[i:i+1], "basic strings cannot have new lines")
+			return nil, escaped, nil, newDecodeError(b[i:i+1], "basic strings cannot have new lines")
 		case '\\':
 			if len(b) < i+2 {
-				return nil, escaped, nil, NewParserError(b[i:i+1], "need a character after \\")
+				return nil, escaped, nil, newDecodeError(b[i:i+1], "need a character after \\")
 			}
 			escaped = true
 			i++ // skip the next character
 		}
 	}

-	return nil, escaped, nil, NewParserError(b[len(b):], `basic string not terminated by "`)
+	return nil, escaped, nil, newDecodeError(b[len(b):], `basic string not terminated by "`)
 }

 func scanMultilineBasicString(b []byte) ([]byte, bool, []byte, error) {
@@ -244,27 +243,27 @@ func scanMultilineBasicString(b []byte) ([]byte, bool, []byte, error) {
 				i++

 				if i < len(b) && b[i] == '"' {
-					return nil, escaped, nil, NewParserError(b[i-3:i+1], `""" not allowed in multiline basic string`)
+					return nil, escaped, nil, newDecodeError(b[i-3:i+1], `""" not allowed in multiline basic string`)
 				}

 				return b[:i], escaped, b[i:], nil
 			}
 		case '\\':
 			if len(b) < i+2 {
-				return nil, escaped, nil, NewParserError(b[len(b):], "need a character after \\")
+				return nil, escaped, nil, newDecodeError(b[len(b):], "need a character after \\")
 			}
 			escaped = true
 			i++ // skip the next character
 		case '\r':
 			if len(b) < i+2 {
-				return nil, escaped, nil, NewParserError(b[len(b):], `need a \n after \r`)
+				return nil, escaped, nil, newDecodeError(b[len(b):], `need a \n after \r`)
 			}
 			if b[i+1] != '\n' {
-				return nil, escaped, nil, NewParserError(b[i:i+2], `need a \n after \r`)
+				return nil, escaped, nil, newDecodeError(b[i:i+2], `need a \n after \r`)
 			}
 			i++ // skip the \n
 		}
 	}

-	return nil, escaped, nil, NewParserError(b[len(b):], `multiline basic string not terminated by """`)
+	return nil, escaped, nil, newDecodeError(b[len(b):], `multiline basic string not terminated by """`)
 }
@@ -1,8 +1,9 @@
 package toml

 import (
+	"github.com/pelletier/go-toml/v2/internal/ast"
+	"github.com/pelletier/go-toml/v2/internal/danger"
 	"github.com/pelletier/go-toml/v2/internal/tracker"
-	"github.com/pelletier/go-toml/v2/unstable"
 )

 type strict struct {
@@ -11,13 +12,10 @@ type strict struct {
 	// Tracks the current key being processed.
 	key tracker.KeyTracker

-	missing []unstable.ParserError
-
-	// Reference to the document for computing key ranges.
-	doc []byte
+	missing []decodeError
 }

-func (s *strict) EnterTable(node *unstable.Node) {
+func (s *strict) EnterTable(node *ast.Node) {
 	if !s.Enabled {
 		return
 	}
@@ -25,7 +23,7 @@ func (s *strict) EnterTable(node *unstable.Node) {
 	s.key.UpdateTable(node)
 }

-func (s *strict) EnterArrayTable(node *unstable.Node) {
+func (s *strict) EnterArrayTable(node *ast.Node) {
 	if !s.Enabled {
 		return
 	}
@@ -33,7 +31,7 @@ func (s *strict) EnterArrayTable(node *unstable.Node) {
 	s.key.UpdateArrayTable(node)
 }

-func (s *strict) EnterKeyValue(node *unstable.Node) {
+func (s *strict) EnterKeyValue(node *ast.Node) {
 	if !s.Enabled {
 		return
 	}
@@ -41,7 +39,7 @@ func (s *strict) EnterKeyValue(node *unstable.Node) {
 	s.key.Push(node)
 }

-func (s *strict) ExitKeyValue(node *unstable.Node) {
+func (s *strict) ExitKeyValue(node *ast.Node) {
 	if !s.Enabled {
 		return
 	}
@@ -49,27 +47,27 @@ func (s *strict) ExitKeyValue(node *unstable.Node) {
 	s.key.Pop(node)
 }

-func (s *strict) MissingTable(node *unstable.Node) {
+func (s *strict) MissingTable(node *ast.Node) {
 	if !s.Enabled {
 		return
 	}

-	s.missing = append(s.missing, unstable.ParserError{
-		Highlight: s.keyLocation(node),
-		Message:   "missing table",
-		Key:       s.key.Key(),
+	s.missing = append(s.missing, decodeError{
+		highlight: keyLocation(node),
+		message:   "missing table",
+		key:       s.key.Key(),
 	})
 }

-func (s *strict) MissingField(node *unstable.Node) {
+func (s *strict) MissingField(node *ast.Node) {
 	if !s.Enabled {
 		return
 	}

-	s.missing = append(s.missing, unstable.ParserError{
-		Highlight: s.keyLocation(node),
-		Message:   "missing field",
-		Key:       s.key.Key(),
+	s.missing = append(s.missing, decodeError{
+		highlight: keyLocation(node),
+		message:   "missing field",
+		key:       s.key.Key(),
 	})
 }

@@ -90,7 +88,7 @@ func (s *strict) Error(doc []byte) error {
 	return err
 }

-func (s *strict) keyLocation(node *unstable.Node) []byte {
+func keyLocation(node *ast.Node) []byte {
 	k := node.Key()

 	hasOne := k.Next()
@@ -98,17 +96,12 @@ func (s *strict) keyLocation(node *unstable.Node) []byte {
 		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
+	start := k.Node().Data
+	end := k.Node().Data

 	for k.Next() {
-		lastRaw = k.Node().Raw
+		end = k.Node().Data
 	}

-	// Compute the slice from the document using the ranges.
-	start := firstRaw.Offset
-	end := lastRaw.Offset + lastRaw.Length
-
-	return s.doc[start:end]
+	return danger.BytesRange(start, end)
 }
@@ -1,597 +0,0 @@
-#!/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.26)
-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"
-    "1.26"
-)
-
-# 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.25 1.26  # 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-6])$ ]]; then
-        log_error "Invalid Go version: $version. Supported versions: 1.11-1.26"
-        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
@@ -1,16 +1,15 @@
-//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
+//go:generate go run ./cmd/tomltestgen/main.go -o toml_testgen_test.go

+// This is a support file for toml_testgen_test.go
 package toml_test

 import (
 	"encoding/json"
-	"errors"
 	"testing"

 	"github.com/pelletier/go-toml/v2"
-	"github.com/pelletier/go-toml/v2/internal/assert"
 	"github.com/pelletier/go-toml/v2/internal/testsuite"
+	"github.com/stretchr/testify/require"
 )

 func testgenInvalid(t *testing.T, input string) {
@@ -39,22 +38,21 @@ func testgenValid(t *testing.T, input string, jsonRef string) {

 	err := testsuite.Unmarshal([]byte(input), &doc)
 	if err != nil {
-		de := &toml.DecodeError{}
-		if errors.As(err, &de) {
+		if de, ok := err.(*toml.DecodeError); ok {
 			t.Logf("%s\n%s", err, de)
 		}
 		t.Fatalf("failed parsing toml: %s", err)
 	}
 	j, err := testsuite.ValueToTaggedJSON(doc)
-	assert.NoError(t, err)
+	require.NoError(t, err)

 	var ref interface{}
 	err = json.Unmarshal([]byte(jsonRef), &ref)
-	assert.NoError(t, err)
+	require.NoError(t, err)

 	var actual interface{}
-	err = json.Unmarshal(j, &actual)
-	assert.NoError(t, err)
+	err = json.Unmarshal([]byte(j), &actual)
+	require.NoError(t, err)

 	testsuite.CmpJSON(t, "", ref, actual)
 }
@@ -6,18 +6,9 @@ import (
 	"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("")
-)
+var timeType = reflect.TypeOf(time.Time{})
+var textMarshalerType = reflect.TypeOf(new(encoding.TextMarshaler)).Elem()
+var textUnmarshalerType = reflect.TypeOf(new(encoding.TextUnmarshaler)).Elem()
+var mapStringInterfaceType = reflect.TypeOf(map[string]interface{}{})
+var sliceInterfaceType = reflect.TypeOf([]interface{}{})
+var stringType = reflect.TypeOf("")
@@ -1,145 +0,0 @@
-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}
-}
@@ -1,64 +0,0 @@
-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
-}
@@ -1,3 +0,0 @@
-// Package unstable provides APIs that do not meet the backward compatibility
-// guarantees yet.
-package unstable
@@ -1,697 +0,0 @@
-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
-}
@@ -1,32 +0,0 @@
-package unstable
-
-// Unmarshaler is implemented by types that can unmarshal a TOML
-// description of themselves. The input is a valid TOML document
-// containing the relevant portion of the parsed document.
-//
-// For tables (including split tables defined in multiple places),
-// the data contains the raw key-value bytes from the original document
-// with adjusted table headers to be relative to the unmarshaling target.
-type Unmarshaler interface {
-	UnmarshalTOML(data []byte) error
-}
-
-// RawMessage is a raw encoded TOML value. It implements Unmarshaler
-// and can be used to delay TOML decoding or capture raw content.
-//
-// Example usage:
-//
-//	type Config struct {
-//	    Plugin RawMessage `toml:"plugin"`
-//	}
-//
-//	var cfg Config
-//	toml.NewDecoder(r).EnableUnmarshalerInterface().Decode(&cfg)
-//	// cfg.Plugin now contains the raw TOML bytes for [plugin]
-type RawMessage []byte
-
-// UnmarshalTOML implements Unmarshaler.
-func (m *RawMessage) UnmarshalTOML(data []byte) error {
-	*m = append((*m)[0:0], data...)
-	return nil
-}
@@ -1,12 +1,20 @@
-// Package characters provides functions for working with string encodings.
-package characters
+package toml

 import (
 	"unicode/utf8"
 )

-// Utf8TomlValidAlreadyEscaped verifies that a given string is only made of
-// valid UTF-8 characters allowed by the TOML spec:
+type utf8Err struct {
+	Index int
+	Size  int
+}
+
+func (u utf8Err) Zero() bool {
+	return u.Size == 0
+}
+
+// Verified 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
@@ -15,8 +23,8 @@ import (
 // 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.
+// The returned utf8Err is Zero() if the string is valid, or contains the byte
+// index and size of the invalid character.
 //
 // quotation mark => already checked
 // backslash => already checked
@@ -24,8 +32,9 @@ import (
 // 0x9 => tab, ok
 // 0xA - 0x1F => invalid
 // 0x7F => invalid
-func Utf8TomlValidAlreadyEscaped(p []byte) []byte {
+func utf8TomlValidAlreadyEscaped(p []byte) (err utf8Err) {
 	// Fast path. Check for and skip 8 bytes of ASCII characters per iteration.
+	offset := 0
 	for len(p) >= 8 {
 		// Combining two 32 bit loads allows the same code to be used
 		// for 32 and 64 bit platforms.
@@ -39,19 +48,24 @@ func Utf8TomlValidAlreadyEscaped(p []byte) []byte {
 		}

 		for i, b := range p[:8] {
-			if InvalidASCII(b) {
-				return p[i : i+1]
+			if invalidAscii(b) {
+				err.Index = offset + i
+				err.Size = 1
+				return
 			}
 		}

 		p = p[8:]
+		offset += 8
 	}
 	n := len(p)
 	for i := 0; i < n; {
 		pi := p[i]
 		if pi < utf8.RuneSelf {
-			if InvalidASCII(pi) {
-				return p[i : i+1]
+			if invalidAscii(pi) {
+				err.Index = offset + i
+				err.Size = 1
+				return
 			}
 			i++
 			continue
@@ -59,34 +73,44 @@ func Utf8TomlValidAlreadyEscaped(p []byte) []byte {
 		x := first[pi]
 		if x == xx {
 			// Illegal starter byte.
-			return p[i : i+1]
+			err.Index = offset + i
+			err.Size = 1
+			return
 		}
 		size := int(x & 7)
 		if i+size > n {
 			// Short or invalid.
-			return p[i:n]
+			err.Index = offset + i
+			err.Size = n - i
+			return
 		}
 		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
+			err.Index = offset + i
+			err.Size = 2
+			return
+		} else if size == 2 {
 		} else if c := p[i+2]; c < locb || hicb < c {
-			return p[i : i+3]
-		} else if size == 3 { //revive:disable:empty-block
+			err.Index = offset + i
+			err.Size = 3
+			return
+		} else if size == 3 {
 		} else if c := p[i+3]; c < locb || hicb < c {
-			return p[i : i+4]
+			err.Index = offset + i
+			err.Size = 4
+			return
 		}
 		i += size
 	}
-	return nil
+	return
 }

-// Utf8ValidNext returns the size of the next rune if valid, 0 otherwise.
-func Utf8ValidNext(p []byte) int {
+// Return 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) {
+		if invalidAscii(c) {
 			return 0
 		}
 		return 1
@@ -105,10 +129,10 @@ func Utf8ValidNext(p []byte) int {
 	accept := acceptRanges[x>>4]
 	if c := p[1]; c < accept.lo || accept.hi < c {
 		return 0
-	} else if size == 2 { //nolint:revive
+	} else if size == 2 {
 	} else if c := p[2]; c < locb || hicb < c {
 		return 0
-	} else if size == 3 { //nolint:revive
+	} else if size == 3 {
 	} else if c := p[3]; c < locb || hicb < c {
 		return 0
 	}
@@ -116,6 +140,47 @@ func Utf8ValidNext(p []byte) int {
 	return size
 }

+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]
+}
+
 // acceptRange gives the range of valid values for the second byte in a UTF-8
 // sequence.
 type acceptRange struct {
				`@@ -1 +0,0 @@`
				`github.com/pelletier/go-toml/v2: CAPABILITY_REFLECT, CAPABILITY_UNANALYZED, CAPABILITY_UNSAFE_POINTER`